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

package/dist/vite.cjs

@@ -688,11 +688,11 @@ function resolveFarmServerHealthConfig(config) {
   return Object.freeze({ enabled: true, livenessPath, readinessPath });
 }
 function normalizeHealthPath(value, optionName) {
-  const path34 = value.trim();
-  if (!path34.startsWith("/") || path34.includes("?") || path34.includes("#") || path34.includes("*")) {
+  const path35 = value.trim();
+  if (!path35.startsWith("/") || path35.includes("?") || path35.includes("#") || path35.includes("*")) {
     throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
   }
-  const normalized = path34.length > 1 ? path34.replace(/\/+$/, "") || "/" : path34;
+  const normalized = path35.length > 1 ? path35.replace(/\/+$/, "") || "/" : path35;
   assertBrowserStableRoutePath(normalized);
   return normalized;
 }
@@ -1073,8 +1073,8 @@ function toViteModuleId(filePath, root) {
 }
 async function fileExists(filePath) {
   try {
-    const fs13 = await import("fs/promises");
-    await fs13.access(filePath);
+    const fs14 = await import("fs/promises");
+    await fs14.access(filePath);
     return true;
   } catch {
     return false;
@@ -1471,35 +1471,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 fs13 = await import("fs/promises");
-  const path34 = await import("path");
-  const generatedDir = path34.join(root, distDir, ".nitro", "farm-workflows");
+  const fs14 = await import("fs/promises");
+  const path35 = await import("path");
+  const generatedDir = path35.join(root, distDir, ".nitro", "farm-workflows");
   const workflows = await discoverFarmWorkflows({
     root,
     workflows: workflowConfig
   });
   if (workflows.length === 0) {
-    await fs13.rm(generatedDir, { recursive: true, force: true });
+    await fs14.rm(generatedDir, { recursive: true, force: true });
     return {
       workflows,
       tasks: {},
       scheduledTasks: {}
     };
   }
-  await fs13.rm(generatedDir, { recursive: true, force: true });
-  await fs13.mkdir(generatedDir, { recursive: true });
+  await fs14.rm(generatedDir, { recursive: true, force: true });
+  await fs14.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = toPosixPath(path34.join(generatedDir, `${safeFileName(workflow.id)}.mjs`));
-    await fs13.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
+    const wrapperPath = toPosixPath(path35.join(generatedDir, `${safeFileName(workflow.id)}.mjs`));
+    await fs14.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = toPosixPath(path34.join(generatedDir, "http-handler.mjs"));
-  await fs13.writeFile(
+  const handlerPath = toPosixPath(path35.join(generatedDir, "http-handler.mjs"));
+  await fs14.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(
       workflowConfig,
@@ -1508,8 +1508,8 @@ async function prepareFarmWorkflowsForNitro(config) {
     ),
     "utf8"
   );
-  const manifestPath = path34.join(generatedDir, "manifest.json");
-  await fs13.writeFile(
+  const manifestPath = path35.join(generatedDir, "manifest.json");
+  await fs14.writeFile(
     manifestPath,
     JSON.stringify(
       {
@@ -1597,21 +1597,21 @@ function resolveWorkflowDefinition(module2) {
   return null;
 }
 async function findWorkflowFiles(root, dirs) {
-  const path34 = await import("path");
+  const path35 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path34.isAbsolute(dir) ? dir : path34.join(root, dir);
+    const absoluteDir = path35.isAbsolute(dir) ? dir : path35.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
   return files.sort();
 }
 async function walkWorkflowDir(dir, files) {
-  const fs13 = await import("fs/promises");
-  const path34 = await import("path");
-  const entries = await fs13.readdir(dir, { withFileTypes: true });
+  const fs14 = await import("fs/promises");
+  const path35 = await import("path");
+  const entries = await fs14.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path34.join(dir, entry.name);
+    const filePath = path35.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -1623,20 +1623,20 @@ async function walkWorkflowDir(dir, files) {
   }
 }
 async function pathExists(filePath) {
-  const fs13 = await import("fs/promises");
-  return fs13.access(filePath).then(() => true).catch(() => false);
+  const fs14 = await import("fs/promises");
+  return fs14.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 fs13 = await import("fs/promises");
-  const path34 = await import("path");
+  const fs14 = await import("fs/promises");
+  const path35 = await import("path");
   const { pathToFileURL: pathToFileURL9 } = await import("url");
   const { build } = await import("esbuild");
-  const outDir = path34.join(root, ".farm", ".workflow-loader");
-  await fs13.mkdir(outDir, { recursive: true });
-  const outfile = path34.join(
+  const outDir = path35.join(root, ".farm", ".workflow-loader");
+  await fs14.mkdir(outDir, { recursive: true });
+  const outfile = path35.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -1660,7 +1660,7 @@ async function loadWorkflowModule(filePath, root) {
       `${pathToFileURL9(outfile).href}?t=${Date.now()}`
     );
   } finally {
-    await fs13.unlink(outfile).catch(() => void 0);
+    await fs14.unlink(outfile).catch(() => void 0);
   }
 }
 function workflowIdFromFile(root, dirs, filePath) {
@@ -1955,7 +1955,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 path34 = normalizeCronPath(name2, job.path);
+  const path35 = 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) {
@@ -1964,7 +1964,7 @@ function normalizeCronJob(name2, job) {
   return {
     name: name2,
     schedule,
-    path: path34,
+    path: path35,
     description: job.description?.trim() || void 0
   };
 }
@@ -1981,13 +1981,13 @@ function normalizeCronPath(name2, value) {
       `Farm cron ${JSON.stringify(name2)} path cannot contain backslashes or control characters.`
     );
   }
-  const path34 = value.trim();
-  if (path34.startsWith("//") || path34.includes("?") || path34.includes("#")) {
+  const path35 = value.trim();
+  if (path35.startsWith("//") || path35.includes("?") || path35.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 path34.split("/")) {
+  for (const segment of path35.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -2009,7 +2009,7 @@ function normalizeCronPath(name2, value) {
       );
     }
   }
-  return path34.length > 1 ? path34.replace(/\/+$/, "") : path34;
+  return path35.length > 1 ? path35.replace(/\/+$/, "") : path35;
 }
 function normalizeCronExpression(name2, value) {
   if (typeof value !== "string") {
@@ -2688,7 +2688,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;
@@ -2782,12 +2788,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)) {
@@ -2805,9 +2824,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) {
@@ -2865,8 +2888,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");
@@ -3289,15 +3314,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) {
@@ -3336,6 +3373,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");
@@ -3435,7 +3473,7 @@ var init_server_action_security = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path34 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path35 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -3463,7 +3501,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path34,
+    path: path35,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -3509,11 +3547,11 @@ function normalizeImagePath(value) {
   if (hasUnstableCharacters(value)) {
     throw new TypeError("images.path cannot contain backslashes or control characters");
   }
-  const path34 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path34.startsWith("/") || path34.startsWith("//") || path34.includes("?") || path34.includes("#")) {
+  const path35 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path35.startsWith("/") || path35.startsWith("//") || path35.includes("?") || path35.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  for (const segment of path34.split("/")) {
+  for (const segment of path35.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -3529,7 +3567,7 @@ function normalizeImagePath(value) {
       throw new TypeError('images.path cannot contain "." or ".." path segments');
     }
   }
-  return path34;
+  return path35;
 }
 function normalizeIntegerList(values, name2, max) {
   if (values.length === 0) {
@@ -5034,7 +5072,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, path34, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path35, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -5043,7 +5081,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path34, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path34
+    path: path35
   });
   return { search, canonicalPath };
 }
@@ -5122,8 +5160,8 @@ function normalizeComparableValue(value) {
   }
   return value;
 }
-function createRoute(path34, options) {
-  return routesBuilder.page(path34, options);
+function createRoute(path35, options) {
+  return routesBuilder.page(path35, options);
 }
 function isProgrammaticRoutesFileName2(fileName) {
   const normalized = fileName.replace(/\\/g, "/");
@@ -5206,7 +5244,7 @@ function createRouteModuleFromProgrammaticPage(route, rendererRuntime) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path34) => resolveProgrammaticRouteSearch(route.search, rawSearch, path34, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path35) => resolveProgrammaticRouteSearch(route.search, rawSearch, path35, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -5616,25 +5654,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path34, options) {
+      page(path35, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path34,
+          path: path35,
           ...options
         });
       },
-      layout(path34, options) {
+      layout(path35, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path34,
+          path: path35,
           ...options
         });
       },
-      api(path34, options) {
+      api(path35, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path34,
+          path: path35,
           render,
           runtime,
           regions,
@@ -6105,9 +6143,9 @@ function getFarmIntegrationPluginOwner(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
   return value && typeof value === "object" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path34, input) {
+function defineTypedIntegrationRoute(method, path35, input) {
   return {
-    path: path34,
+    path: path35,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -6117,7 +6155,7 @@ function defineTypedIntegrationRoute(method, path34, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path34,
+      path: path35,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -6129,58 +6167,58 @@ function defineTypedIntegrationRoute(method, path34, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path34, input) {
+    get(path35, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path34,
+        path35,
         input
       );
     },
-    post(path34, input) {
+    post(path35, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path34,
+        path35,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    query(path34, input) {
-      return defineTypedIntegrationRoute("QUERY", path34, {
+    query(path35, input) {
+      return defineTypedIntegrationRoute("QUERY", path35, {
         bodyFormat: "json",
         ...input
       });
     },
-    put(path34, input) {
+    put(path35, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path34,
+        path35,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path34, input) {
-      return defineTypedIntegrationRoute("PATCH", path34, {
+    patch(path35, input) {
+      return defineTypedIntegrationRoute("PATCH", path35, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path34, input) {
-      return defineTypedIntegrationRoute("DELETE", path34, {
+    delete(path35, input) {
+      return defineTypedIntegrationRoute("DELETE", path35, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path34, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path34, input);
+    options(path35, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path35, input);
     },
-    head(path34, input) {
+    head(path35, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path34,
+        path35,
         input
       );
     }
@@ -6551,8 +6589,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path34) {
-  return (path34 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path35) {
+  return (path35 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -7380,8 +7418,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path34 = "/", secure = false) {
-  const normalizedPath = path34.startsWith("/") ? path34 : `/${path34}`;
+function createFarmDeploymentCookie(deploymentId, path35 = "/", secure = false) {
+  const normalizedPath = path35.startsWith("/") ? path35 : `/${path35}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -8213,17 +8251,17 @@ function normalizeFarmAPIBasePath(value) {
   if (hasUnstableCharacters(value)) {
     throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
   }
-  const path34 = value.trim();
-  if (!path34) {
+  const path35 = value.trim();
+  if (!path35) {
     throw new Error("Farm api.basePath cannot be empty.");
   }
-  if (path34.includes("?") || path34.includes("#")) {
+  if (path35.includes("?") || path35.includes("#")) {
     throw new Error("Farm api.basePath cannot contain a query string or hash.");
   }
-  if (path34.startsWith("//")) {
+  if (path35.startsWith("//")) {
     throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
   }
-  for (const segment of path34.split("/")) {
+  for (const segment of path35.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -8239,7 +8277,7 @@ function normalizeFarmAPIBasePath(value) {
       throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
     }
   }
-  const normalized = `/${path34.replace(/^\/+|\/+$/g, "")}`;
+  const normalized = `/${path35.replace(/^\/+|\/+$/g, "")}`;
   return normalized === "/" ? "/" : normalized;
 }
 function parseRootRelativeBaseURL(value) {
@@ -8406,7 +8444,7 @@ var init_route_files = __esm({
 // src/write-file-if-changed.ts
 function writeFileIfChanged(filePath, content) {
   try {
-    if ((0, import_node_fs5.readFileSync)(filePath, "utf8") === content) {
+    if ((0, import_node_fs6.readFileSync)(filePath, "utf8") === content) {
       return false;
     }
   } catch (error) {
@@ -8414,14 +8452,14 @@ function writeFileIfChanged(filePath, content) {
       throw error;
     }
   }
-  (0, import_node_fs5.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs6.writeFileSync)(filePath, content, "utf8");
   return true;
 }
-var import_node_fs5;
+var import_node_fs6;
 var init_write_file_if_changed = __esm({
   "src/write-file-if-changed.ts"() {
     "use strict";
-    import_node_fs5 = require("fs");
+    import_node_fs6 = require("fs");
     __name(writeFileIfChanged, "writeFileIfChanged");
   }
 });
@@ -8599,9 +8637,9 @@ var init_type_generator = __esm({
         }
         const nestedStructure = {};
         const usedRouteNames = /* @__PURE__ */ new Map();
-        for (const [path34, routeList] of routeGroups) {
-          const routeName = this.uniqueRouteName(path34, usedRouteNames);
-          const cleanPath = path34 === "/api" ? "" : path34.replace(/^\/api\//, "");
+        for (const [path35, routeList] of routeGroups) {
+          const routeName = this.uniqueRouteName(path35, usedRouteNames);
+          const cleanPath = path35 === "/api" ? "" : path35.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const methodSources = /* @__PURE__ */ new Map();
           for (const route of routeList) {
@@ -8665,11 +8703,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(([path34, methods]) => ({ path: path34, methods: [...methods].sort() }));
+        const routeManifest = [...manifest].sort(([a], [b]) => a.localeCompare(b)).map(([path35, methods]) => ({ path: path35, methods: [...methods].sort() }));
         const manifestSource = routeManifest.length ? `[
 ${routeManifest.map(
-          ({ path: path34, methods }) => `  {
-    path: ${JSON.stringify(path34)},
+          ({ path: path35, methods }) => `  {
+    path: ${JSON.stringify(path35)},
     methods: [${methods.map((method) => JSON.stringify(method)).join(", ")}],
   },`
         ).join("\n")}
@@ -8699,11 +8737,11 @@ export const apiRoutes = ${manifestSource} as const;
         const relativeImport = (0, import_path8.relative)((0, import_path8.dirname)(outFile), route.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path34) {
-        return (path34 === "/api" ? "root" : path34.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
+      pathToRouteName(path35) {
+        return (path35 === "/api" ? "root" : path35.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
       }
-      uniqueRouteName(path34, usedNames) {
-        const base = this.pathToRouteName(path34);
+      uniqueRouteName(path35, usedNames) {
+        const base = this.pathToRouteName(path35);
         const seen = usedNames.get(base);
         usedNames.set(base, (seen ?? 0) + 1);
         return seen ? `${base}_${seen + 1}` : base;
@@ -8726,15 +8764,15 @@ export const apiRoutes = ${manifestSource} as const;
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path34) {
-        const cleanPath = path34.replace(/^\/api\//, "");
+      getBaseExportName(path35) {
+        const cleanPath = path35.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path34, method) {
-        const cleanPath = path34.replace(/^\/api\//, "");
+      getExportName(path35, method) {
+        const cleanPath = path35.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -9226,12 +9264,12 @@ var init_image_server = __esm({
 // src/docs/fonts.ts
 function resolveFarmDocsFontAssets(root) {
   return FARM_DOCS_FONT_SOURCES.flatMap(({ family, packagePath }) => {
-    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 sourcePath = import_node_path15.default.join(root, "node_modules", packagePath);
+    if (!(0, import_node_fs9.existsSync)(sourcePath)) return [];
+    const source = (0, import_node_fs9.readFileSync)(sourcePath);
     const fingerprint = (0, import_node_crypto3.createHash)("sha256").update(source).digest("hex").slice(0, 12);
-    const extension = import_node_path14.default.extname(packagePath);
-    const baseName = import_node_path14.default.basename(packagePath, extension);
+    const extension = import_node_path15.default.extname(packagePath);
+    const baseName = import_node_path15.default.basename(packagePath, extension);
     return [
       {
         family,
@@ -9244,13 +9282,13 @@ function resolveFarmDocsFontAssets(root) {
 function toFarmDocsPublicFontAssets(assets) {
   return assets.map(({ family, url }) => ({ family, url }));
 }
-var import_node_crypto3, import_node_fs8, import_node_path14, FARM_DOCS_FONT_SOURCES;
+var import_node_crypto3, import_node_fs9, import_node_path15, FARM_DOCS_FONT_SOURCES;
 var init_fonts = __esm({
   "src/docs/fonts.ts"() {
     "use strict";
     import_node_crypto3 = require("crypto");
-    import_node_fs8 = require("fs");
-    import_node_path14 = __toESM(require("path"));
+    import_node_fs9 = require("fs");
+    import_node_path15 = __toESM(require("path"));
     FARM_DOCS_FONT_SOURCES = [
       {
         family: "Geist Sans",
@@ -9303,22 +9341,22 @@ function normalizeRelativePath(value) {
 }
 function resolveExistingPath(filePath) {
   try {
-    return (0, import_node_fs9.realpathSync)(filePath);
+    return (0, import_node_fs10.realpathSync)(filePath);
   } catch {
-    return import_node_path16.default.resolve(filePath);
+    return import_node_path17.default.resolve(filePath);
   }
 }
 function isDocsSourceFile(filePath) {
-  return DOCS_FILE_EXTENSIONS.has(import_node_path16.default.extname(filePath).toLowerCase());
+  return DOCS_FILE_EXTENSIONS.has(import_node_path17.default.extname(filePath).toLowerCase());
 }
 function discoverDocsSourceFiles(contentDir) {
   const files = [];
   const visit = /* @__PURE__ */ __name((dir) => {
-    for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true }).sort(
+    for (const entry of (0, import_node_fs10.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_path16.default.join(dir, entry.name);
+      const absolutePath = import_node_path17.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
       } else if (entry.isFile() && isDocsSourceFile(absolutePath)) {
@@ -9326,7 +9364,7 @@ function discoverDocsSourceFiles(contentDir) {
       }
     }
   }, "visit");
-  if ((0, import_node_fs9.existsSync)(contentDir)) visit(contentDir);
+  if ((0, import_node_fs10.existsSync)(contentDir)) visit(contentDir);
   return files;
 }
 function getGitLastModifiedDates(contentDir) {
@@ -9336,7 +9374,7 @@ function getGitLastModifiedDates(contentDir) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!gitRoot) return {};
-    const contentPathspec = normalizeRelativePath(import_node_path16.default.relative(gitRoot, contentDir)) || ".";
+    const contentPathspec = normalizeRelativePath(import_node_path17.default.relative(gitRoot, contentDir)) || ".";
     const contentPrefix = contentPathspec === "." ? "" : `${contentPathspec}/`;
     const history = (0, import_node_child_process.execFileSync)(
       "git",
@@ -9378,11 +9416,11 @@ function getGitLastModifiedDates(contentDir) {
   }
 }
 function readManifest(contentDir) {
-  const manifestPath = import_node_path16.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
-  if (!(0, import_node_fs9.existsSync)(manifestPath)) return null;
+  const manifestPath = import_node_path17.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  if (!(0, import_node_fs10.existsSync)(manifestPath)) return null;
   try {
     const parsed = JSON.parse(
-      (0, import_node_fs9.readFileSync)(manifestPath, "utf8")
+      (0, import_node_fs10.readFileSync)(manifestPath, "utf8")
     );
     if (parsed.version !== 1 || !parsed.pages || typeof parsed.pages !== "object") return null;
     const pages = Object.fromEntries(
@@ -9401,15 +9439,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_path16.default.relative(resolvedContentDir, sourcePath));
-    pages[relativePath2] = gitDates[relativePath2] || (options.fallback === "now" ? fallbackDate : (0, import_node_fs9.statSync)(sourcePath).mtime.toISOString());
+    const relativePath2 = normalizeRelativePath(import_node_path17.default.relative(resolvedContentDir, sourcePath));
+    pages[relativePath2] = gitDates[relativePath2] || (options.fallback === "now" ? fallbackDate : (0, import_node_fs10.statSync)(sourcePath).mtime.toISOString());
   }
   return { version: 1, pages };
 }
 function getLastModifiedManifest(contentDir) {
   const resolvedContentDir = resolveExistingPath(contentDir);
-  const manifestPath = import_node_path16.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
-  const manifestStat = (0, import_node_fs9.existsSync)(manifestPath) ? (0, import_node_fs9.statSync)(manifestPath) : null;
+  const manifestPath = import_node_path17.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  const manifestStat = (0, import_node_fs10.existsSync)(manifestPath) ? (0, import_node_fs10.statSync)(manifestPath) : null;
   const signature = manifestStat ? `file:${manifestStat.mtimeMs}:${manifestStat.size}` : "generated";
   const cached = manifestCache.get(resolvedContentDir);
   if (cached?.signature === signature) return cached.manifest;
@@ -9422,21 +9460,21 @@ function resolveFarmDocsPageLastModified(contentDir, sourcePath, frontmatter) {
   if (configured) return configured;
   const resolvedContentDir = resolveExistingPath(contentDir);
   const resolvedSourcePath = resolveExistingPath(sourcePath);
-  const relativePath2 = normalizeRelativePath(import_node_path16.default.relative(resolvedContentDir, resolvedSourcePath));
-  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path16.default.isAbsolute(relativePath2);
+  const relativePath2 = normalizeRelativePath(import_node_path17.default.relative(resolvedContentDir, resolvedSourcePath));
+  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path17.default.isAbsolute(relativePath2);
   if (isInsideContentDir) {
     const generated = getLastModifiedManifest(resolvedContentDir).pages[relativePath2];
     if (generated) return generated;
   }
-  return (0, import_node_fs9.statSync)(resolvedSourcePath).mtime.toISOString();
+  return (0, import_node_fs10.statSync)(resolvedSourcePath).mtime.toISOString();
 }
-var import_node_child_process, import_node_fs9, import_node_path16, FARM_DOCS_LAST_MODIFIED_MANIFEST, COMMIT_MARKER, DOCS_FILE_EXTENSIONS, manifestCache;
+var import_node_child_process, import_node_fs10, import_node_path17, 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_fs9 = require("fs");
-    import_node_path16 = __toESM(require("path"));
+    import_node_fs10 = require("fs");
+    import_node_path17 = __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"]);
@@ -9469,10 +9507,10 @@ function isFarmDocsSearchEnabled(docs) {
 }
 function resolveFarmDocsSearchClientModule(root) {
   try {
-    const requireFromApp = (0, import_node_module5.createRequire)(import_node_path17.default.join(import_node_path17.default.resolve(root), "package.json"));
+    const requireFromApp = (0, import_node_module5.createRequire)(import_node_path18.default.join(import_node_path18.default.resolve(root), "package.json"));
     const themeEntry = requireFromApp.resolve("@farming-labs/theme");
-    const commandSearchModule = import_node_path17.default.join(import_node_path17.default.dirname(themeEntry), "docs-command-search.mjs");
-    if ((0, import_node_fs10.existsSync)(commandSearchModule)) return commandSearchModule;
+    const commandSearchModule = import_node_path18.default.join(import_node_path18.default.dirname(themeEntry), "docs-command-search.mjs");
+    if ((0, import_node_fs11.existsSync)(commandSearchModule)) return commandSearchModule;
   } catch {
   }
   return void 0;
@@ -9611,13 +9649,13 @@ async function mountFarmDocsSearch() {
 window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
 `;
 }
-var import_node_fs10, import_node_module5, import_node_path17;
+var import_node_fs11, import_node_module5, import_node_path18;
 var init_search_client = __esm({
   "src/docs/search-client.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
+    import_node_fs11 = require("fs");
     import_node_module5 = require("module");
-    import_node_path17 = __toESM(require("path"));
+    import_node_path18 = __toESM(require("path"));
     __name(isFarmDocsSearchEnabled, "isFarmDocsSearchEnabled");
     __name(resolveFarmDocsSearchClientModule, "resolveFarmDocsSearchClientModule");
     __name(generateFarmDocsSearchBootstrapRuntime, "generateFarmDocsSearchBootstrapRuntime");
@@ -10055,10 +10093,10 @@ function resolveFarmDocsFavicon(docs, options) {
   if (typeof configuredFavicon === "string" && configuredFavicon.trim()) {
     return configuredFavicon.trim();
   }
-  const publicDir = import_node_path18.default.join(import_node_path18.default.resolve(options.root), "public");
+  const publicDir = import_node_path19.default.join(import_node_path19.default.resolve(options.root), "public");
   for (const fileName of FARM_DOCS_FAVICON_FILES) {
-    const faviconPath = import_node_path18.default.join(publicDir, fileName);
-    if ((0, import_node_fs11.existsSync)(faviconPath) && (0, import_node_fs11.statSync)(faviconPath).isFile()) {
+    const faviconPath = import_node_path19.default.join(publicDir, fileName);
+    if ((0, import_node_fs12.existsSync)(faviconPath) && (0, import_node_fs12.statSync)(faviconPath).isFile()) {
       return `/${fileName}`;
     }
   }
@@ -10092,10 +10130,10 @@ function isSafeSegment(segment) {
   return segment !== ".." && !segment.includes("/") && !segment.includes("\\");
 }
 function resolveInside(root, target) {
-  const resolvedRoot = import_node_path18.default.resolve(root);
-  const resolvedTarget = import_node_path18.default.resolve(target);
-  const relative6 = import_node_path18.default.relative(resolvedRoot, resolvedTarget);
-  if (relative6 === "" || !relative6.startsWith("..") && !import_node_path18.default.isAbsolute(relative6)) {
+  const resolvedRoot = import_node_path19.default.resolve(root);
+  const resolvedTarget = import_node_path19.default.resolve(target);
+  const relative6 = import_node_path19.default.relative(resolvedRoot, resolvedTarget);
+  if (relative6 === "" || !relative6.startsWith("..") && !import_node_path19.default.isAbsolute(relative6)) {
     return resolvedTarget;
   }
   return null;
@@ -10104,10 +10142,10 @@ function resolveExistingFileInside(root, target) {
   const safePath = resolveInside(root, target);
   if (!safePath) return null;
   try {
-    const realRoot = (0, import_node_fs11.realpathSync)(root);
-    const realTarget = (0, import_node_fs11.realpathSync)(safePath);
+    const realRoot = (0, import_node_fs12.realpathSync)(root);
+    const realTarget = (0, import_node_fs12.realpathSync)(safePath);
     const containedTarget = resolveInside(realRoot, realTarget);
-    return containedTarget && (0, import_node_fs11.statSync)(containedTarget).isFile() ? containedTarget : null;
+    return containedTarget && (0, import_node_fs12.statSync)(containedTarget).isFile() ? containedTarget : null;
   } catch {
     return null;
   }
@@ -10121,16 +10159,16 @@ function isFarmDocsRequest(docs, request) {
   return pathname === entry || pathname === `${entry}.md` || pathname.startsWith(`${entry}/`);
 }
 function resolveFarmDocsContentDir(docs, options) {
-  const root = import_node_path18.default.resolve(options.root);
+  const root = import_node_path19.default.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const configuredContentDir = docs.contentDir || docs.config.contentDir;
   if (configuredContentDir) {
-    return import_node_path18.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path18.default.join(root, configuredContentDir);
+    return import_node_path19.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path19.default.join(root, configuredContentDir);
   }
   const entryDir = docs.config.entry || trimSlashes2(docs.entry) || "docs";
-  const appDocsDir = import_node_path18.default.join(root, srcDir, "app", entryDir);
-  if ((0, import_node_fs11.existsSync)(appDocsDir)) return appDocsDir;
-  return import_node_path18.default.join(root, entryDir);
+  const appDocsDir = import_node_path19.default.join(root, srcDir, "app", entryDir);
+  if ((0, import_node_fs12.existsSync)(appDocsDir)) return appDocsDir;
+  return import_node_path19.default.join(root, entryDir);
 }
 function getFarmDocsRouteTypeEntries(docs) {
   if (!docs?.enabled) return [];
@@ -10153,10 +10191,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_path18.default.join(contentDir, ...segments);
-  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path18.default.join(contentDir, filename)) : [
-    ...DOCS_FILE_NAMES.map((filename) => import_node_path18.default.join(slugDir, filename)),
-    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path18.default.join(contentDir, `${slug}${extension}`))
+  const slugDir = import_node_path19.default.join(contentDir, ...segments);
+  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path19.default.join(contentDir, filename)) : [
+    ...DOCS_FILE_NAMES.map((filename) => import_node_path19.default.join(slugDir, filename)),
+    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path19.default.join(contentDir, `${slug}${extension}`))
   ];
   for (const candidate of candidates) {
     const safePath = resolveExistingFileInside(contentDir, candidate);
@@ -10195,7 +10233,7 @@ function titleFromMarkdown2(body, fallback) {
 function loadFarmDocsPage(contentDir, docs, slug) {
   const sourcePath = findDocsPageFile(contentDir, slug);
   if (!sourcePath) return null;
-  const source = (0, import_node_fs11.readFileSync)(sourcePath, "utf8");
+  const source = (0, import_node_fs12.readFileSync)(sourcePath, "utf8");
   const { frontmatter, body } = parseFrontmatter(source);
   const title = frontmatter.title || titleFromMarkdown2(body, titleFromSlug(slug));
   const href = createDocsHref(docs.entry, slug);
@@ -10218,9 +10256,9 @@ function createDocsHref(entry, slug) {
   return normalizedSlug ? `${normalizedEntry}/${normalizedSlug}` : normalizedEntry;
 }
 function pathToSlug(contentDir, filePath) {
-  const relative6 = import_node_path18.default.relative(contentDir, filePath).replace(/\\/g, "/");
+  const relative6 = import_node_path19.default.relative(contentDir, filePath).replace(/\\/g, "/");
   if (relative6.startsWith("..")) return null;
-  const extension = import_node_path18.default.extname(relative6);
+  const extension = import_node_path19.default.extname(relative6);
   if (!DOCS_FILE_EXTENSIONS2.includes(extension)) return null;
   const withoutExtension = relative6.slice(0, -extension.length);
   if (withoutExtension === "page" || withoutExtension === "index") return "";
@@ -10233,12 +10271,12 @@ function loadPage(contentDir, docs, request) {
   return loadFarmDocsPage(contentDir, docs, getRequestSlug(docs, request));
 }
 function discoverFarmDocsPages(contentDir, docs) {
-  if (!(0, import_node_fs11.existsSync)(contentDir)) return [];
+  if (!(0, import_node_fs12.existsSync)(contentDir)) return [];
   const pages = [];
   const visit = /* @__PURE__ */ __name((dir) => {
-    for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path18.default.join(dir, entry.name);
+      const absolutePath = import_node_path19.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
         continue;
@@ -10246,7 +10284,7 @@ function discoverFarmDocsPages(contentDir, docs) {
       if (!entry.isFile()) continue;
       const slug = pathToSlug(contentDir, absolutePath);
       if (slug === null) continue;
-      const source = (0, import_node_fs11.readFileSync)(absolutePath, "utf8");
+      const source = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
       const { frontmatter, body } = parseFrontmatter(source);
       pages.push({
         slug,
@@ -10765,11 +10803,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;
@@ -11258,12 +11315,12 @@ function createFarmDocsHandler(docs, options) {
     );
   }, "handleFarmDocsRequest");
 }
-var import_node_fs11, import_node_path18, 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_fs12, import_node_path19, 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_fs11 = require("fs");
-    import_node_path18 = __toESM(require("path"));
+    import_node_fs12 = require("fs");
+    import_node_path19 = __toESM(require("path"));
     import_docs = require("@farming-labs/docs");
     import_marked = require("marked");
     import_sugar_high = require("sugar-high");
@@ -11522,13 +11579,13 @@ var init_adapter = __esm({
 });
 
 // src/docs/framework-detect.ts
-var import_promises8, import_node_module6, import_node_path19, import_node_url7;
+var import_promises8, import_node_module6, import_node_path20, import_node_url7;
 var init_framework_detect = __esm({
   "src/docs/framework-detect.ts"() {
     "use strict";
     import_promises8 = require("fs/promises");
     import_node_module6 = require("module");
-    import_node_path19 = __toESM(require("path"));
+    import_node_path20 = __toESM(require("path"));
     import_node_url7 = require("url");
   }
 });
@@ -11628,19 +11685,19 @@ async function findDocsConfigPath(rootDir, configPath) {
   return void 0;
 }
 async function loadDocsConfig(rootDir, configPath) {
-  const fs13 = await import("fs/promises");
+  const fs14 = await import("fs/promises");
   const { pathToFileURL: pathToFileURL9 } = await import("url");
   const root = import_path10.default.resolve(rootDir || process.cwd());
   const resolvedPath = await findDocsConfigPath(root, configPath);
   if (!resolvedPath) return void 0;
   try {
     if (resolvedPath.endsWith(".json")) {
-      const content = await fs13.readFile(resolvedPath, "utf8");
+      const content = await fs14.readFile(resolvedPath, "utf8");
       return { config: JSON.parse(content), configPath: resolvedPath };
     }
     const { build } = await import("esbuild");
     const configCacheDir = import_path10.default.join(root, ".farm", ".config-loader");
-    await fs13.mkdir(configCacheDir, { recursive: true });
+    await fs14.mkdir(configCacheDir, { recursive: true });
     const modulePath = import_path10.default.join(
       configCacheDir,
       `docs-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
@@ -11666,7 +11723,7 @@ async function loadDocsConfig(rootDir, configPath) {
         moduleUrl
       );
     } finally {
-      await fs13.unlink(modulePath).catch(() => void 0);
+      await fs14.unlink(modulePath).catch(() => void 0);
     }
     return {
       config: importedConfig.default || importedConfig,
@@ -12576,8 +12633,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path34, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path34);
+        for (const [path35, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path35);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -12597,8 +12654,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path34) {
-        return path34.replace(/^\/api/, "");
+      convertToOpenAPIPath(path35) {
+        return path35.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -12760,8 +12817,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path34, method) {
-        const cleanPath = path34.replace(/^\/api\//, "");
+      generateSummary(path35, method) {
+        const cleanPath = path35.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;
@@ -12770,22 +12827,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path34, method) {
-        const cleanPath = path34.replace(/^\/api\//, "");
+      generateDescription(path35, method) {
+        const cleanPath = path35.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path34, method) {
-        const cleanPath = path34.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path35, method) {
+        const cleanPath = path35.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path34) {
-        const cleanPath = path34.replace(/^\/api\//, "");
+      generateTags(path35) {
+        const cleanPath = path35.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -12797,13 +12854,13 @@ var init_generator = __esm({
        */
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
-        const fs13 = require("fs");
-        const path34 = require("path");
-        const dir = path34.dirname(outputPath);
-        if (!fs13.existsSync(dir)) {
-          fs13.mkdirSync(dir, { recursive: true });
+        const fs14 = require("fs");
+        const path35 = require("path");
+        const dir = path35.dirname(outputPath);
+        if (!fs14.existsSync(dir)) {
+          fs14.mkdirSync(dir, { recursive: true });
         }
-        fs13.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
+        fs14.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
       }
     };
     __name(_OpenAPIGenerator, "OpenAPIGenerator");
@@ -13231,7 +13288,7 @@ async function createFarmDevtoolsSnapshot(input) {
     generatedAt: (input.now?.() || /* @__PURE__ */ new Date()).toISOString(),
     health: resolveHealth(diagnostics),
     project: {
-      name: import_node_path20.default.basename(import_node_path20.default.resolve(input.root)),
+      name: import_node_path21.default.basename(import_node_path21.default.resolve(input.root)),
       root: input.root,
       srcDir: input.srcDir,
       basePath: config.basePath || "/",
@@ -13280,11 +13337,11 @@ async function createFarmDevtoolsSnapshot(input) {
     diagnostics
   };
 }
-var import_node_path20;
+var import_node_path21;
 var init_devtools = __esm({
   "src/devtools.ts"() {
     "use strict";
-    import_node_path20 = __toESM(require("path"));
+    import_node_path21 = __toESM(require("path"));
     init_config4();
     init_cron();
     init_route_runtime();
@@ -13925,6 +13982,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; }
@@ -14434,6 +14492,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>
@@ -15085,6 +15144,8 @@ __export(vite_exports, {
   defineConfig: () => defineConfig2,
   farmI18nClientBridgePlugin: () => farmI18nClientBridgePlugin,
   farmPlugin: () => farmPlugin,
+  generateClientCachePersistenceCode: () => generateClientCachePersistenceCode,
+  resolveFarmClientCacheAdapterEntry: () => resolveFarmClientCacheAdapterEntry,
   rewriteEarlySsrRelativeImports: () => rewriteEarlySsrRelativeImports,
   transformIsolatedClientBoundaryModule: () => transformIsolatedClientBoundaryModule,
   withFarmRequestTracing: () => withFarmRequestTracing
@@ -15129,10 +15190,11 @@ var ROUTE_PROP_LABELS = /* @__PURE__ */ new Map([
   ["middlewareData", "middleware request data"],
   ["context", "request context"]
 ]);
-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;
@@ -15142,12 +15204,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 {
@@ -15161,23 +15223,24 @@ 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
   };
 }
 __name(resolveConfiguredRouteRenderingConfig, "resolveConfiguredRouteRenderingConfig");
-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;
   }
@@ -15192,9 +15255,9 @@ function resolveRouteRenderingConfig(mod, source) {
   };
 }
 __name(resolveRouteRenderingConfig, "resolveRouteRenderingConfig");
-async function resolveRouteRenderingConfigFromFile(mod, filePath) {
+async function resolveRouteRenderingConfigFromFile(mod, filePath, options) {
   const source = await (0, import_promises2.readFile)(filePath, "utf8").catch(() => void 0);
-  return resolveRouteRenderingConfig(mod, source);
+  return resolveRouteRenderingConfig(mod, source, options);
 }
 __name(resolveRouteRenderingConfigFromFile, "resolveRouteRenderingConfigFromFile");
 function analyzeStaticRouteCandidate(mod, source, options = {}) {
@@ -16292,7 +16355,7 @@ function getIslandStrategyExport(content) {
 __name(getIslandStrategyExport, "getIslandStrategyExport");
 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"
   );
 }
@@ -19447,7 +19510,7 @@ var _FarmI18nRuntime = class _FarmI18nRuntime {
     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 {
@@ -19475,8 +19538,19 @@ var _FarmI18nRuntime = class _FarmI18nRuntime {
     }
     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}".`);
@@ -21825,7 +21899,7 @@ _setFarmThemeServerSnapshotResolver(() => {
 });
 
 // package.json
-var version = "0.1.0-beta.96";
+var version = "0.1.0-beta.97";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -22753,7 +22827,8 @@ var _ServerRenderer = class _ServerRenderer {
       }
       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;
@@ -23458,6 +23533,11 @@ var _ServerRenderer = class _ServerRenderer {
       );
       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;
@@ -24195,6 +24275,7 @@ var _FarmApp = class _FarmApp {
         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 || {}
@@ -24549,6 +24630,53 @@ function isArrayIndex(key) {
 }
 __name(isArrayIndex, "isArrayIndex");
 
+// src/client-cache-persistence-build.ts
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_path10 = __toESM(require("path"));
+var ADAPTER_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
+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_path10.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 };
+}
+__name(resolveFarmClientCacheAdapterEntry, "resolveFarmClientCacheAdapterEntry");
+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;
+}
+__name(resolveAdapterFile, "resolveAdapterFile");
+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)});`
+  };
+}
+__name(generateClientCachePersistenceCode, "generateClientCachePersistenceCode");
+
 // src/api/endpoint.ts
 var import_better_call = require("better-call");
 init_cache();
@@ -24576,15 +24704,15 @@ function isEndpointFailure(value) {
 }
 __name(isEndpointFailure, "isEndpointFailure");
 function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path34;
+  let path35;
   let options;
   let handler;
   if (typeof pathOrOptions === "string") {
-    path34 = pathOrOptions;
+    path35 = pathOrOptions;
     options = optionsOrHandler;
     handler = maybeHandler;
   } else {
-    path34 = "";
+    path35 = "";
     options = pathOrOptions;
     handler = optionsOrHandler;
   }
@@ -24611,13 +24739,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     ...betterCallOptions
   } = options;
   const endpoint = (0, import_better_call.createEndpoint)(
-    path34 || "/__farm_auto_path__",
+    path35 || "/__farm_auto_path__",
     betterCallOptions,
     wrappedHandler
   );
-  endpoint.__path = path34 || void 0;
+  endpoint.__path = path35 || void 0;
   endpoint.__method = options.method || "GET";
-  endpoint.__autoPath = !path34;
+  endpoint.__autoPath = !path35;
   endpoint.__handler = wrappedHandler;
   endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
   endpoint.__middleware = middleware;
@@ -24628,6 +24756,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
@@ -24824,10 +24953,10 @@ function createRouteFactoryAt(prefix) {
     "OPTIONS"
   ]) {
     factory[method.toLowerCase()] = (child, options) => {
-      const path34 = joinRoutePath(prefix, child);
+      const path35 = joinRoutePath(prefix, child);
       const input = options.input ?? {};
       const endpoint = createEndpoint(
-        path34,
+        path35,
         {
           method,
           body: input.body,
@@ -24843,7 +24972,7 @@ function createRouteFactoryAt(prefix) {
       );
       endpoint.__types.params = input.params;
       endpoint.__output = options.output;
-      return Object.freeze({ path: path34, method, endpoint });
+      return Object.freeze({ path: path35, method, endpoint });
     };
   }
   return Object.freeze(factory);
@@ -24851,21 +24980,21 @@ function createRouteFactoryAt(prefix) {
 __name(createRouteFactoryAt, "createRouteFactoryAt");
 function joinRoutePath(prefix, child) {
   if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
-  const path34 = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
-  if (!(path34 === "/api" || path34.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path34)) {
+  const path35 = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
+  if (!(path35 === "/api" || path35.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path35)) {
     throw new TypeError(
-      `Plugin route "${path34}" must be a canonical /api path without a query, hash, or empty segment.`
+      `Plugin route "${path35}" must be a canonical /api path without a query, hash, or empty segment.`
     );
   }
-  assertBrowserStableRoutePath(path34);
-  assertUniqueRouteParameters(path34, "api");
-  getRoutePatternShape(path34, "api");
-  for (const segment of path34.split("/")) {
+  assertBrowserStableRoutePath(path35);
+  assertUniqueRouteParameters(path35, "api");
+  getRoutePatternShape(path35, "api");
+  for (const segment of path35.split("/")) {
     if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
       throw new TypeError(`Route segment "${segment}" is reserved.`);
     }
   }
-  return path34;
+  return path35;
 }
 __name(joinRoutePath, "joinRoutePath");
 function resolvePluginRoutes(plugins = []) {
@@ -24918,7 +25047,7 @@ function mergePluginAPIRoutes(existing, plugins, expected) {
   }
   const result = [...routes.values()];
   if (expected) {
-    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path: path34, methods }) => `${path34}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
+    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path: path35, methods }) => `${path35}:${[...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."
@@ -24930,8 +25059,8 @@ function mergePluginAPIRoutes(existing, plugins, expected) {
 __name(mergePluginAPIRoutes, "mergePluginAPIRoutes");
 
 // src/api/route-manager.ts
-var fs6 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 init_utils();
 init_routes_shared();
 init_route_runtime();
@@ -25395,9 +25524,9 @@ var _APIRouteManager = class _APIRouteManager {
     this.routeShapes = /* @__PURE__ */ new Map();
     try {
       for (const appDir of this.appDirs) {
-        const apiDir = path16.join(appDir, "api");
+        const apiDir = path17.join(appDir, "api");
         let routeFiles = [];
-        if (fs6.existsSync(apiDir)) {
+        if (fs7.existsSync(apiDir)) {
           routeFiles = this.findRouteFiles(apiDir);
         }
         for (const filePath of routeFiles) {
@@ -25430,12 +25559,12 @@ var _APIRouteManager = class _APIRouteManager {
    */
   findRouteFiles(dir) {
     const files = [];
-    if (!fs6.existsSync(dir)) {
+    if (!fs7.existsSync(dir)) {
       return files;
     }
-    const entries = fs6.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...this.findRouteFiles(fullPath));
       } else if (isFarmAPIRouteFileName(entry.name)) {
@@ -25449,8 +25578,8 @@ var _APIRouteManager = class _APIRouteManager {
    */
   async loadRoute(filePath, appDir) {
     try {
-      const apiDir = path16.join(appDir, "api");
-      const relativePath2 = path16.relative(apiDir, path16.dirname(filePath));
+      const apiDir = path17.join(appDir, "api");
+      const relativePath2 = path17.relative(apiDir, path17.dirname(filePath));
       const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
       const routeModule = await this.loadModule(filePath);
       const endpoints = {};
@@ -25523,7 +25652,7 @@ var _APIRouteManager = class _APIRouteManager {
     }
   }
   async loadProgrammaticApiRoutes(appDir) {
-    const candidateRoots = [path16.dirname(appDir), appDir];
+    const candidateRoots = [path17.dirname(appDir), appDir];
     const routeFiles = Array.from(
       new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
     );
@@ -25552,16 +25681,16 @@ var _APIRouteManager = class _APIRouteManager {
   }
   findRootRoutesFile(appDir) {
     const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
-    const candidateDirs = [path16.dirname(appDir), appDir];
+    const candidateDirs = [path17.dirname(appDir), appDir];
     const seen = /* @__PURE__ */ new Set();
     for (const dir of candidateDirs) {
       for (const routeName of routeNames) {
-        const routesFile = path16.join(dir, routeName);
+        const routesFile = path17.join(dir, routeName);
         if (seen.has(routesFile)) {
           continue;
         }
         seen.add(routesFile);
-        if (fs6.existsSync(routesFile)) {
+        if (fs7.existsSync(routesFile)) {
           return routesFile;
         }
       }
@@ -25695,8 +25824,8 @@ var APIRouteManager = _APIRouteManager;
 init_config3();
 
 // src/middleware/manager.ts
-var fs7 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 init_decode();
 
 // src/middleware/cookie-header.ts
@@ -26097,7 +26226,7 @@ var _MiddlewareManager = class _MiddlewareManager {
    * Recursively discover middleware files
    */
   async discoverInDirectory(dir, routePath, discovered) {
-    if (!fs7.existsSync(dir)) {
+    if (!fs8.existsSync(dir)) {
       return;
     }
     const middlewareFile = this.findMiddlewareFile(dir);
@@ -26107,10 +26236,10 @@ var _MiddlewareManager = class _MiddlewareManager {
         discovered.push(middleware);
       }
     }
-    const entries = fs7.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-        const subPath = path17.join(dir, entry.name);
+        const subPath = path18.join(dir, entry.name);
         const subRoutePath = appendMiddlewareRoutePath(routePath, entry.name);
         await this.discoverInDirectory(subPath, subRoutePath, discovered);
       }
@@ -26122,8 +26251,8 @@ var _MiddlewareManager = class _MiddlewareManager {
   findMiddlewareFile(dir) {
     const extensions = [".ts", ".tsx", ".js", ".jsx"];
     for (const ext of extensions) {
-      const filePath = path17.join(dir, `middleware${ext}`);
-      if (fs7.existsSync(filePath)) {
+      const filePath = path18.join(dir, `middleware${ext}`);
+      if (fs8.existsSync(filePath)) {
         return filePath;
       }
     }
@@ -26463,8 +26592,8 @@ var import_path9 = require("path");
 init_type_generator();
 
 // src/routing/generate-route-types.ts
-var path18 = __toESM(require("path"));
-var fs8 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
 init_utils();
 init_write_file_if_changed();
 init_renderer();
@@ -26517,12 +26646,12 @@ function createRoutePattern(route) {
 __name(createRoutePattern, "createRoutePattern");
 var DEFAULT_OUT_FILE = "farm-routes.d.ts";
 async function generateRouteTypes(options) {
-  const root = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path18.isAbsolute(outFile) ? outFile : path18.join(root, srcDir, outFile);
+  const outPath = path19.isAbsolute(outFile) ? outFile : path19.join(root, srcDir, outFile);
   const content = await createRouteTypeDeclarations(options, outPath);
-  fs8.mkdirSync(path18.dirname(outPath), { recursive: true });
+  fs9.mkdirSync(path19.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
@@ -26537,8 +26666,8 @@ async function createRouteTypeDeclarations(options, outPath) {
   const routeModulePatterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path18.join(source.root, source.srcDir, "app");
-    if (fs8.existsSync(appDir)) {
+    const appDir = path19.join(source.root, source.srcDir, "app");
+    if (fs9.existsSync(appDir)) {
       const routeModuleFiles = await glob.default(
         `**/{page,layout,loading,error}.{${componentExtensions.join(",")},md,mdx}`,
         {
@@ -26574,7 +26703,7 @@ async function createRouteTypeDeclarations(options, outPath) {
   const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
   const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
   const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
-  const routeTypesImportPath = `./${path18.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const routeTypesImportPath = `./${path19.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
@@ -26624,8 +26753,8 @@ ${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentati
 __name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
 
 // src/env-types.ts
-var fs9 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 init_write_file_if_changed();
 var DEFAULT_OUT_FILE2 = "farm-env.d.ts";
 var CONFIG_FILENAMES2 = [
@@ -26647,21 +26776,21 @@ var CONFIG_FILENAMES2 = [
   "config.cjs"
 ];
 async function generateEnvTypes(options) {
-  const root = path19.resolve(options.root);
+  const root = path20.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE2;
-  const outPath = path19.isAbsolute(outFile) ? outFile : path19.join(root, srcDir, outFile);
+  const outPath = path20.isAbsolute(outFile) ? outFile : path20.join(root, srcDir, outFile);
   const content = createEnvTypeDeclarations(options, outPath);
-  fs9.mkdirSync(path19.dirname(outPath), { recursive: true });
+  fs10.mkdirSync(path20.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
 __name(generateEnvTypes, "generateEnvTypes");
 function createEnvTypeDeclarations(options, outPath) {
-  const root = path19.resolve(options.root);
+  const root = path20.resolve(options.root);
   const configPath = findConfigPath(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs9.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs10.existsSync(value)),
     ...configPath ? [configPath] : []
   ];
   const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
@@ -26723,12 +26852,12 @@ export {};
 __name(createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path19.isAbsolute(configPath) ? configPath : path19.join(root, configPath);
-    return fs9.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path20.isAbsolute(configPath) ? configPath : path20.join(root, configPath);
+    return fs10.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path19.join(root, filename);
-    if (fs9.existsSync(resolvedPath)) {
+    const resolvedPath = path20.join(root, filename);
+    if (fs10.existsSync(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -26791,19 +26920,19 @@ export {};
 }
 __name(createEmptyEnvTypes, "createEmptyEnvTypes");
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath2 = path19.relative(path19.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path20.relative(path20.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
 __name(toTypeImportPath, "toTypeImportPath");
 
 // src/image-types.ts
-var import_node_fs6 = require("fs");
-var import_node_path10 = __toESM(require("path"));
+var import_node_fs7 = require("fs");
+var import_node_path11 = __toESM(require("path"));
 init_write_file_if_changed();
 var FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? import_node_path10.default.resolve(options.root, options.outFile) : import_node_path10.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  (0, import_node_fs6.mkdirSync)(import_node_path10.default.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? import_node_path11.default.resolve(options.root, options.outFile) : import_node_path11.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  (0, import_node_fs7.mkdirSync)(import_node_path11.default.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -26831,8 +26960,8 @@ declare module "*?url" {
 __name(createFarmImageTypeDeclarations, "createFarmImageTypeDeclarations");
 
 // src/content-types.ts
-var fs10 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var CONFIG_FILENAMES3 = [
   "farm.config.ts",
   "farm.config.tsx",
@@ -26852,10 +26981,10 @@ var CONFIG_FILENAMES3 = [
   "config.cjs"
 ];
 function createContentTypeDeclarations(options, outPath) {
-  const root = path21.resolve(options.root);
+  const root = path22.resolve(options.root);
   const projectConfig = findConfigPath2(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs10.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs11.existsSync(value)),
     ...projectConfig ? [projectConfig] : []
   ];
   if (configPaths.length === 0) return createEmptyContentTypes();
@@ -26925,32 +27054,32 @@ export {};
 __name(createEmptyContentTypes, "createEmptyContentTypes");
 function findConfigPath2(root, configPath) {
   if (configPath) {
-    const resolvedPath = path21.isAbsolute(configPath) ? configPath : path21.join(root, configPath);
-    return fs10.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path22.isAbsolute(configPath) ? configPath : path22.join(root, configPath);
+    return fs11.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES3) {
-    const resolvedPath = path21.join(root, filename);
-    if (fs10.existsSync(resolvedPath)) return resolvedPath;
+    const resolvedPath = path22.join(root, filename);
+    if (fs11.existsSync(resolvedPath)) return resolvedPath;
   }
   return null;
 }
 __name(findConfigPath2, "findConfigPath");
 function toTypeImportPath2(outPath, targetPath) {
-  const relativePath2 = path21.relative(path21.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path22.relative(path22.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
 __name(toTypeImportPath2, "toTypeImportPath");
 
 // src/i18n/type-generator.ts
-var import_node_fs7 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path12 = require("path");
 init_write_file_if_changed();
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? (0, import_node_path11.resolve)(options.root, options.outFile) : (0, import_node_path11.join)((0, import_node_path11.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path12.resolve)(options.root, options.outFile) : (0, import_node_path12.join)((0, import_node_path12.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs7.mkdirSync)((0, import_node_path11.dirname)(outFile), { recursive: true });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path12.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -27243,8 +27372,8 @@ init_integrations();
 init_route_context();
 init_devtools_config();
 init_dev_indicators();
-var fs12 = __toESM(require("fs"));
-var path33 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
 var import_node_url8 = require("url");
 init_layers();
 
@@ -27713,8 +27842,8 @@ function _runWithAPIRequestRuntime(runtime, run) {
 __name(_runWithAPIRequestRuntime, "_runWithAPIRequestRuntime");
 
 // src/dev-static.ts
-var fs11 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 function shouldBypassFarmRouterForDottedPath(pathname, routeManager, baseDirs) {
   if (!pathname.includes(".") || pathname.endsWith(".html")) return false;
   const matchesAppRoute = Boolean(
@@ -27734,11 +27863,11 @@ function devServableFileExists(pathname, baseDirs) {
   if (!relativePathname) return false;
   for (const baseDir of baseDirs) {
     if (typeof baseDir !== "string" || baseDir.length === 0) continue;
-    const resolvedBase = path22.resolve(baseDir);
-    const candidate = path22.resolve(resolvedBase, relativePathname);
-    if (!candidate.startsWith(resolvedBase + path22.sep)) continue;
+    const resolvedBase = path23.resolve(baseDir);
+    const candidate = path23.resolve(resolvedBase, relativePathname);
+    if (!candidate.startsWith(resolvedBase + path23.sep)) continue;
     try {
-      if (fs11.existsSync(candidate) && fs11.statSync(candidate).isFile()) {
+      if (fs12.existsSync(candidate) && fs12.statSync(candidate).isFile()) {
         return true;
       }
     } catch {
@@ -27753,6 +27882,7 @@ var SERVER_FN_FACTORIES = ["createServerQuery", "createServerFn"];
 var FARM_CORE_IMPORT_RE = /import\s*(?!type\b)(?:[\w$]+\s*,\s*)?\{([^}]*)\}\s*from\s*(["'])@farm\.js\/core(?:\/[\w./-]+)?\2/g;
 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];
@@ -27782,7 +27912,7 @@ init_image_config();
 
 // src/image-vite.ts
 var import_promises7 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var import_image_size2 = require("image-size");
 var FARM_IMAGE_ID_PREFIX = "\0farm:image:";
 var STATIC_IMAGE_RE = /\.(?:avif|gif|jpe?g|png|webp)$/i;
@@ -27865,7 +27995,7 @@ init_image_server();
 init_routing();
 
 // src/server/vite-config.ts
-var import_node_path13 = __toESM(require("path"));
+var import_node_path14 = __toESM(require("path"));
 var FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
 var FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
   "react",
@@ -27889,9 +28019,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
 }
 __name(getFarmClientOptimizeDepsInclude, "getFarmClientOptimizeDepsInclude");
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = import_node_path13.default.resolve(projectRoot);
+  const resolvedProjectRoot = import_node_path14.default.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = import_node_path13.default.relative(resolvedProjectRoot, import_node_path13.default.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = import_node_path14.default.relative(resolvedProjectRoot, import_node_path14.default.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -27915,7 +28045,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 __name(createFarmClientOptimizeDepsConfig, "createFarmClientOptimizeDepsConfig");
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": import_node_path13.default.resolve(projectRoot, srcDir)
+    "@": import_node_path14.default.resolve(projectRoot, srcDir)
   };
 }
 __name(createFarmSourceAlias, "createFarmSourceAlias");
@@ -27954,7 +28084,7 @@ init_observability();
 init_renderer();
 
 // src/integration-provider-build.ts
-var import_node_path15 = __toESM(require("path"));
+var import_node_path16 = __toESM(require("path"));
 init_integrations();
 init_utils();
 function generateFarmIntegrationProviderClientCode(providers, root) {
@@ -28011,7 +28141,7 @@ function wrapWithIntegrationProviders(element) {
 __name(generateFarmIntegrationProviderClientCode, "generateFarmIntegrationProviderClientCode");
 function resolveProviderModule(moduleId, root) {
   if (!moduleId.startsWith(".")) return moduleId;
-  return toViteModuleId(import_node_path15.default.resolve(root, moduleId), root);
+  return toViteModuleId(import_node_path16.default.resolve(root, moduleId), root);
 }
 __name(resolveProviderModule, "resolveProviderModule");
 
@@ -28079,6 +28209,7 @@ var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
   i18n: false
 }), "createEmptyTypeArtifactSelection");
 var FARM_I18N_CLIENT_BRIDGE_ID = "\0farm-i18n-client-bridge";
+var warnedDeprecatedDevtoolsDashboard = false;
 var EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME = `
 function isFarmDocsSearchPage() {
   return false;
@@ -28497,11 +28628,11 @@ function isPotentialProgrammaticRouteSourceFile(normalizedFile, srcDirSlug) {
 }
 __name(isPotentialProgrammaticRouteSourceFile, "isPotentialProgrammaticRouteSourceFile");
 function fileContainsProgrammaticPageRoute(file) {
-  if (!fs12.existsSync(file)) {
+  if (!fs13.existsSync(file)) {
     return false;
   }
   try {
-    return scanProgrammaticPagePaths(fs12.readFileSync(file, "utf8")).length > 0;
+    return scanProgrammaticPagePaths(fs13.readFileSync(file, "utf8")).length > 0;
   } catch {
     return false;
   }
@@ -28509,7 +28640,7 @@ function fileContainsProgrammaticPageRoute(file) {
 __name(fileContainsProgrammaticPageRoute, "fileContainsProgrammaticPageRoute");
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path33.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path34.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -28529,7 +28660,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 = path33.resolve(path33.dirname(cleanId), sourcePath);
+    const resolvedPath = path34.resolve(path34.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -28691,7 +28822,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path33.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path34.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -28722,13 +28853,13 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path33.join(server.config.root, "src/app/globals.css");
-      if (!fs12.existsSync(globalsCSSPath)) {
-        const appDir = path33.join(server.config.root, "src/app");
-        if (!fs12.existsSync(appDir)) {
-          fs12.mkdirSync(appDir, { recursive: true });
+      const globalsCSSPath = path34.join(server.config.root, "src/app/globals.css");
+      if (!fs13.existsSync(globalsCSSPath)) {
+        const appDir = path34.join(server.config.root, "src/app");
+        if (!fs13.existsSync(appDir)) {
+          fs13.mkdirSync(appDir, { recursive: true });
         }
-        fs12.writeFileSync(globalsCSSPath, defaultGlobalCSS);
+        fs13.writeFileSync(globalsCSSPath, defaultGlobalCSS);
       }
       await farmApp.initialize();
       const farmConfig = farmApp.getConfig();
@@ -28749,10 +28880,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path33.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path34.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path33.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path34.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -28762,7 +28893,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path33.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path34.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -28803,7 +28934,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path33.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path34.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -28924,7 +29055,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs12.existsSync(path33.isAbsolute(dir) ? dir : path33.join(farmConfig.root, dir))
+        (dir) => fs13.existsSync(path34.isAbsolute(dir) ? dir : path34.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler: createFarmWorkflowRequestHandler2, discoverFarmWorkflows: discoverFarmWorkflows2 } = await loadFarmWorkflowsDevRuntime();
@@ -29189,12 +29320,12 @@ window.__FARM_MANIFEST__ = ${inlineValue({
             }
           }
           const farmDocsFontPath = farmDocsFontAssets.get(requestPathname);
-          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs12.existsSync(farmDocsFontPath)) {
+          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs13.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 fs12.createReadStream(farmDocsFontPath).pipe(res);
+            else fs13.createReadStream(farmDocsFontPath).pipe(res);
             return;
           }
           if (requestMethod === "GET" && (requestPathname === FARM_DEVTOOLS_PATH || requestPathname === `${FARM_DEVTOOLS_PATH}.json`)) {
@@ -29250,6 +29381,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));
             }
@@ -29292,7 +29429,7 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                 return null;
               }
               return {
-                source: await fs12.promises.readFile(sourcePath, "utf8"),
+                source: await fs13.promises.readFile(sourcePath, "utf8"),
                 filePath: sourcePath
               };
             }, "resolveSource")
@@ -30176,7 +30313,10 @@ ${generatedDevIndicatorsClientRuntime}`,
           renderer,
           isolatedHydrationMode === "enabled",
           resolvedConfig?.trailingSlash ?? false,
-          resolvedConfig?.basePath ?? "/"
+          resolvedConfig?.basePath ?? "/",
+          generateClientCachePersistenceCode(
+            resolveFarmClientCacheAdapterEntry(root, resolvedConfig?.cache)
+          )
         );
       }
       if (id === "/@farm/server") {
@@ -30315,7 +30455,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(path33.resolve(cleanId)) === true;
+        const selectedForIsolatedHydration = selectedIsolatedModules?.has(path34.resolve(cleanId)) === true;
         if (isolatedHydrationEnabled && selectedForIsolatedHydration && isIsolatableClientBoundarySource(clientBoundarySource)) {
           isolatedModuleReference = toViteModuleId(cleanId, root);
           const transformedBoundary = transformIsolatedClientBoundaryModule({
@@ -30406,8 +30546,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path33.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path33.join(outDir, "client");
+        const outDir = path34.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path34.join(outDir, "client");
         for (const page2 of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page2.urlPath, "http://farm.static"));
@@ -30459,9 +30599,9 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page2.urlPath === "/" ? path33.join(clientDir, "index.html") : path33.join(clientDir, page2.urlPath + ".html");
-              fs12.mkdirSync(path33.dirname(outputPath), { recursive: true });
-              fs12.writeFileSync(outputPath, fullHtml);
+              const outputPath = page2.urlPath === "/" ? path34.join(clientDir, "index.html") : path34.join(clientDir, page2.urlPath + ".html");
+              fs13.mkdirSync(path34.dirname(outputPath), { recursive: true });
+              fs13.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page2.revalidate ? ` (revalidate: ${page2.revalidate}s)` : "";
               logger.success(`  \u2713 ${page2.urlPath}${revalidateInfo}`);
             });
@@ -30469,8 +30609,8 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page2.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path33.join(outDir, "__ssg_manifest.json");
-        fs12.writeFileSync(
+        const manifestPath = path34.join(outDir, "__ssg_manifest.json");
+        fs13.writeFileSync(
           manifestPath,
           JSON.stringify(
             ssgPages.map((p) => ({
@@ -30513,9 +30653,9 @@ if (import.meta.hot) {
         server2.ws.send({ type: "full-reload", path: "*" });
         return [];
       }
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path33.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path34.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path33.basename(file)}`);
+        logUpdate("PAGE", `updated ${path34.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -30938,7 +31078,7 @@ function parseRouteModuleSchema2(schema, value, label, routePath) {
   }
 }
 __name(parseRouteModuleSchema2, "parseRouteModuleSchema");
-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,
@@ -30994,6 +31134,7 @@ import {
 } from '@farm.js/core/deployment'
 ${providerClientCode.imports}
 ${clientPluginEntry.imports}
+${clientCachePersistence.imports}
 ${docsSearchClientRuntime}
 ${devtoolsClientRuntime}
 ${docsAdapterImportBlock}
@@ -31009,6 +31150,7 @@ const integrationDocumentNavigationMatchers = ${JSON.stringify(documentNavigatio
 setFarmBasePath(${JSON.stringify(basePath)});
 setFarmTrailingSlashPreference(${JSON.stringify(trailingSlash)});
 installChunkErrorRecovery();
+${clientCachePersistence.init}
 
 let reactRoot = null;
 ${isolatedHydrationRuntime}
@@ -32392,7 +32534,7 @@ function generateClientManifest(bundle) {
 __name(generateClientManifest, "generateClientManifest");
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path33.resolve(config.root || process.cwd());
+  const appRoot = path34.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, {
@@ -32613,6 +32755,8 @@ __name(defineConfig2, "defineConfig");
   defineConfig,
   farmI18nClientBridgePlugin,
   farmPlugin,
+  generateClientCachePersistenceCode,
+  resolveFarmClientCacheAdapterEntry,
   rewriteEarlySsrRelativeImports,
   transformIsolatedClientBoundaryModule,
   withFarmRequestTracing