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

package/dist/plugin.cjs

@@ -893,11 +893,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;
 }
@@ -1278,8 +1278,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;
@@ -1676,35 +1676,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,
@@ -1713,8 +1713,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(
       {
@@ -1802,21 +1802,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);
@@ -1828,20 +1828,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`
   );
@@ -1865,7 +1865,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) {
@@ -2160,7 +2160,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) {
@@ -2169,7 +2169,7 @@ function normalizeCronJob(name2, job) {
   return {
     name: name2,
     schedule,
-    path: path34,
+    path: path35,
     description: job.description?.trim() || void 0
   };
 }
@@ -2186,13 +2186,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);
@@ -2214,7 +2214,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") {
@@ -2893,7 +2893,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;
@@ -2987,12 +2993,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)) {
@@ -3010,9 +3029,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) {
@@ -3070,8 +3093,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");
@@ -3494,15 +3519,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) {
@@ -3541,6 +3578,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");
@@ -3640,7 +3678,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"
@@ -3668,7 +3706,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)
@@ -3714,11 +3752,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);
@@ -3734,7 +3772,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) {
@@ -4815,7 +4853,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);
@@ -4824,7 +4862,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path34, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path34
+    path: path35
   });
   return { search, canonicalPath };
 }
@@ -4903,8 +4941,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, "/");
@@ -4987,7 +5025,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 = {
@@ -5397,25 +5435,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,
@@ -5802,9 +5840,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,
@@ -5814,7 +5852,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,
@@ -5826,58 +5864,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
       );
     }
@@ -6248,8 +6286,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;
   });
@@ -7060,8 +7098,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}`,
@@ -7893,17 +7931,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);
@@ -7919,7 +7957,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) {
@@ -7976,7 +8014,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) {
@@ -7984,14 +8022,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");
   }
 });
@@ -8169,9 +8207,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) {
@@ -8235,11 +8273,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")}
@@ -8269,11 +8307,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;
@@ -8296,15 +8334,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();
         }
@@ -8796,12 +8834,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,
@@ -8814,13 +8852,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",
@@ -8873,22 +8911,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)) {
@@ -8896,7 +8934,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) {
@@ -8906,7 +8944,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",
@@ -8948,11 +8986,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(
@@ -8971,15 +9009,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;
@@ -8992,21 +9030,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"]);
@@ -9039,10 +9077,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;
@@ -9181,13 +9219,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");
@@ -9625,10 +9663,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}`;
     }
   }
@@ -9662,10 +9700,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;
@@ -9674,10 +9712,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;
   }
@@ -9691,16 +9729,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 [];
@@ -9723,10 +9761,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);
@@ -9765,7 +9803,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);
@@ -9788,9 +9826,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 "";
@@ -9803,12 +9841,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;
@@ -9816,7 +9854,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,
@@ -10335,11 +10373,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;
@@ -10828,12 +10885,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");
@@ -11092,13 +11149,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");
   }
 });
@@ -11198,19 +11255,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`
@@ -11236,7 +11293,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,
@@ -12146,8 +12203,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) {
@@ -12167,8 +12224,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
@@ -12330,8 +12387,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;
@@ -12340,22 +12397,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]];
@@ -12367,13 +12424,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");
@@ -12801,7 +12858,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 || "/",
@@ -12850,11 +12907,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();
@@ -13495,6 +13552,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; }
@@ -14004,6 +14062,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>
@@ -14259,23 +14318,26 @@ function generateFarmDevtoolsClientRuntime(config) {
       z-index: 2147483646;
       display: grid;
       place-items: center;
+      box-sizing: border-box;
       padding: 20px;
       background: rgb(0 0 0 / 0);
-      backdrop-filter: blur(0);
+      backdrop-filter: blur(6px);
+      -webkit-backdrop-filter: blur(6px);
+      overscroll-behavior: none;
+      isolation: isolate;
       opacity: 0;
       pointer-events: none;
-      transition: background-color 150ms ease-out, backdrop-filter 150ms ease-out, opacity 150ms ease-out;
+      transition: opacity 150ms ease-out;
     }
     #__farm_devtools_overlay__[data-open="true"] {
-      background: rgb(0 0 0 / 0.12);
-      backdrop-filter: blur(1px);
+      background: rgb(0 0 0 / 0.32);
       opacity: 1;
       pointer-events: auto;
     }
     #__farm_devtools_overlay__ > iframe {
       display: block;
-      width: min(960px, calc(100vw - 40px));
-      height: min(560px, calc(100dvh - 40px));
+      width: min(1100px, calc(100vw - 48px));
+      height: min(720px, calc(100dvh - 48px));
       border: 0;
       border-radius: 12px;
       background: transparent;
@@ -14291,7 +14353,7 @@ function generateFarmDevtoolsClientRuntime(config) {
       #__farm_devtools_overlay__ > iframe {
         width: calc(100vw - 16px);
         height: calc(100dvh - 16px);
-        border-radius: 10px;
+        border-radius: 12px;
       }
     }
     @media (prefers-reduced-motion: reduce) {
@@ -14305,10 +14367,32 @@ function generateFarmDevtoolsClientRuntime(config) {
   const runtimeKey = "__FARM_DEVTOOLS_RUNTIME__";
   const launchParam = ${JSON.stringify(FARM_DEVTOOLS_LAUNCH_PARAM)};
   const devtoolsPath = ${JSON.stringify(FARM_DEVTOOLS_PATH)};
-  const validViews = new Set(["overview", "routes", "api", "systems", "runtime", "raw"]);
+  const validViews = new Set(["overview", "routes", "api", "systems", "runtime", "raw", "inspect", "diagnostics"]);
   const shortcut = ${JSON.stringify(shortcut)};
   const isMac = /Mac|iPhone|iPad|iPod/.test(navigator.platform);
   let returnFocus = null;
+  let restorePage = null;
+  let closeTimer = null;
+
+  const lockPage = () => {
+    const styles = [];
+    for (const element of [document.documentElement, document.body]) {
+      for (const [property, value] of [["overflow-x", "hidden"], ["overflow-y", "hidden"], ["overscroll-behavior", "none"]]) {
+        const previous = element.style.getPropertyValue(property);
+        const priority = element.style.getPropertyPriority(property);
+        element.style.setProperty(property, value, "important");
+        styles.push({ element, property, value, previous, priority });
+      }
+    }
+    return () => {
+      for (const { element, property, value, previous, priority } of styles) {
+        // Do not overwrite a newer style set by the application while the panel was open.
+        if (element.style.getPropertyValue(property) !== value || element.style.getPropertyPriority(property) !== "important") continue;
+        if (previous) element.style.setProperty(property, previous, priority);
+        else element.style.removeProperty(property);
+      }
+    };
+  };
 
   const matchesShortcut = (event) => {
     if (!shortcut || event.repeat) return false;
@@ -14335,24 +14419,35 @@ function generateFarmDevtoolsClientRuntime(config) {
     document.head.appendChild(style);
   };
 
-  const close = () => {
+  const finishClose = () => {
+    if (closeTimer !== null) window.clearTimeout(closeTimer);
+    closeTimer = null;
     const overlay = document.getElementById(overlayId);
-    if (!overlay) return;
+    overlay?.remove();
+    restorePage?.();
+    restorePage = null;
     const focusTarget = returnFocus;
     returnFocus = null;
+    focusTarget?.focus?.({ preventScroll: true });
+  };
+
+  const close = () => {
+    const overlay = document.getElementById(overlayId);
+    if (!overlay || closeTimer !== null) return;
     overlay.dataset.open = "false";
-    window.setTimeout(() => {
-      overlay.remove();
-      focusTarget?.focus?.();
-    }, 160);
+    closeTimer = window.setTimeout(finishClose, 160);
   };
 
   const open = (view = "overview") => {
+    if (closeTimer !== null) finishClose();
     if (document.getElementById(overlayId)) return;
     ensureStyles();
     returnFocus = document.activeElement;
+    restorePage = lockPage();
     const overlay = document.createElement("div");
     overlay.id = overlayId;
+    overlay.setAttribute("role", "dialog");
+    overlay.setAttribute("aria-modal", "true");
     overlay.setAttribute("aria-label", "Farm.js DevTools overlay");
     const frame = document.createElement("iframe");
     const resolvedView = validViews.has(view) ? view : "overview";
@@ -14363,9 +14458,11 @@ function generateFarmDevtoolsClientRuntime(config) {
     overlay.addEventListener("pointerdown", (event) => {
       if (event.target === overlay) close();
     });
+    overlay.addEventListener("wheel", (event) => event.preventDefault(), { passive: false });
+    overlay.addEventListener("touchmove", (event) => event.preventDefault(), { passive: false });
     document.body.appendChild(overlay);
     requestAnimationFrame(() => {
-      overlay.dataset.open = "true";
+      if (overlay.isConnected && closeTimer === null) overlay.dataset.open = "true";
     });
   };
 
@@ -14399,6 +14496,7 @@ function generateFarmDevtoolsClientRuntime(config) {
   window.addEventListener("message", onMessage);
   window[runtimeKey] = {
     dispose() {
+      finishClose();
       window.removeEventListener("keydown", onKeydown, true);
       window.removeEventListener("message", onMessage);
     },
@@ -14661,10 +14759,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;
@@ -14674,12 +14773,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 {
@@ -14693,23 +14792,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;
   }
@@ -14724,9 +14824,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 = {}) {
@@ -15824,7 +15924,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"
   );
 }
@@ -18979,7 +19079,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 {
@@ -19007,8 +19107,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}".`);
@@ -21357,7 +21468,7 @@ _setFarmThemeServerSnapshotResolver(() => {
 });
 
 // package.json
-var version = "0.1.0-beta.95";
+var version = "0.1.0-beta.97";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -22285,7 +22396,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;
@@ -22990,6 +23102,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;
@@ -23727,6 +23844,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 || {}
@@ -24062,6 +24180,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();
@@ -24089,15 +24254,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;
   }
@@ -24124,13 +24289,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;
@@ -24141,6 +24306,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
@@ -24337,10 +24503,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,
@@ -24356,7 +24522,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);
@@ -24364,21 +24530,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 = []) {
@@ -24431,7 +24597,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."
@@ -24443,8 +24609,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();
@@ -24908,9 +25074,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) {
@@ -24943,12 +25109,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)) {
@@ -24962,8 +25128,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 = {};
@@ -25036,7 +25202,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)))
     );
@@ -25065,16 +25231,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;
         }
       }
@@ -25208,8 +25374,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
@@ -25610,7 +25776,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);
@@ -25620,10 +25786,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);
       }
@@ -25635,8 +25801,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;
       }
     }
@@ -25976,8 +26142,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();
@@ -26030,12 +26196,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;
 }
@@ -26050,8 +26216,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}`,
         {
@@ -26087,7 +26253,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 {
@@ -26137,8 +26303,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_FILENAMES = [
@@ -26160,21 +26326,21 @@ var CONFIG_FILENAMES = [
   "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();
@@ -26236,12 +26402,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_FILENAMES) {
-    const resolvedPath = path19.join(root, filename);
-    if (fs9.existsSync(resolvedPath)) {
+    const resolvedPath = path20.join(root, filename);
+    if (fs10.existsSync(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -26304,19 +26470,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;
 }
@@ -26344,8 +26510,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_FILENAMES2 = [
   "farm.config.ts",
   "farm.config.tsx",
@@ -26365,10 +26531,10 @@ var CONFIG_FILENAMES2 = [
   "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();
@@ -26438,32 +26604,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_FILENAMES2) {
-    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;
 }
@@ -26756,8 +26922,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();
 
@@ -26883,8 +27049,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(
@@ -26904,11 +27070,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 {
@@ -26923,6 +27089,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];
@@ -26952,7 +27119,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;
@@ -27035,7 +27202,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"));
 
 // src/vite.ts
 init_fonts();
@@ -27050,7 +27217,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) {
@@ -27107,7 +27274,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");
 
@@ -27174,6 +27341,7 @@ var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
   images: false,
   i18n: false
 }), "createEmptyTypeArtifactSelection");
+var warnedDeprecatedDevtoolsDashboard = false;
 var EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME = `
 function isFarmDocsSearchPage() {
   return false;
@@ -27575,11 +27743,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;
   }
@@ -27587,7 +27755,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 = [];
@@ -27607,7 +27775,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,
@@ -27769,7 +27937,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]
             }
           }
         } : {}
@@ -27800,13 +27968,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();
@@ -27827,10 +27995,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;
@@ -27840,7 +28008,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 {
@@ -27881,7 +28049,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))
@@ -28002,7 +28170,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();
@@ -28267,12 +28435,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`)) {
@@ -28328,6 +28496,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));
             }
@@ -28370,7 +28544,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")
@@ -29254,7 +29428,10 @@ ${generatedDevIndicatorsClientRuntime}`,
           renderer,
           isolatedHydrationMode === "enabled",
           resolvedConfig?.trailingSlash ?? false,
-          resolvedConfig?.basePath ?? "/"
+          resolvedConfig?.basePath ?? "/",
+          generateClientCachePersistenceCode(
+            resolveFarmClientCacheAdapterEntry(root, resolvedConfig?.cache)
+          )
         );
       }
       if (id === "/@farm/server") {
@@ -29393,7 +29570,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({
@@ -29484,8 +29661,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"));
@@ -29537,9 +29714,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}`);
             });
@@ -29547,8 +29724,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) => ({
@@ -29591,9 +29768,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);
         }
@@ -30016,7 +30193,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,
@@ -30072,6 +30249,7 @@ import {
 } from '@farm.js/core/deployment'
 ${providerClientCode.imports}
 ${clientPluginEntry.imports}
+${clientCachePersistence.imports}
 ${docsSearchClientRuntime}
 ${devtoolsClientRuntime}
 ${docsAdapterImportBlock}
@@ -30087,6 +30265,7 @@ const integrationDocumentNavigationMatchers = ${JSON.stringify(documentNavigatio
 setFarmBasePath(${JSON.stringify(basePath)});
 setFarmTrailingSlashPreference(${JSON.stringify(trailingSlash)});
 installChunkErrorRecovery();
+${clientCachePersistence.init}
 
 let reactRoot = null;
 ${isolatedHydrationRuntime}