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

package/dist/server.cjs

@@ -688,11 +688,11 @@ function resolveFarmServerHealthConfig(config) {
   return Object.freeze({ enabled: true, livenessPath, readinessPath });
 }
 function normalizeHealthPath(value, optionName) {
-  const path36 = value.trim();
-  if (!path36.startsWith("/") || path36.includes("?") || path36.includes("#") || path36.includes("*")) {
+  const path37 = value.trim();
+  if (!path37.startsWith("/") || path37.includes("?") || path37.includes("#") || path37.includes("*")) {
     throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
   }
-  const normalized = path36.length > 1 ? path36.replace(/\/+$/, "") || "/" : path36;
+  const normalized = path37.length > 1 ? path37.replace(/\/+$/, "") || "/" : path37;
   assertBrowserStableRoutePath(normalized);
   return normalized;
 }
@@ -1083,8 +1083,8 @@ function toViteModuleId(filePath, root) {
 }
 async function fileExists(filePath) {
   try {
-    const fs15 = await import("fs/promises");
-    await fs15.access(filePath);
+    const fs16 = await import("fs/promises");
+    await fs16.access(filePath);
     return true;
   } catch {
     return false;
@@ -1598,35 +1598,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 fs15 = await import("fs/promises");
-  const path36 = await import("path");
-  const generatedDir = path36.join(root, distDir, ".nitro", "farm-workflows");
+  const fs16 = await import("fs/promises");
+  const path37 = await import("path");
+  const generatedDir = path37.join(root, distDir, ".nitro", "farm-workflows");
   const workflows = await discoverFarmWorkflows({
     root,
     workflows: workflowConfig
   });
   if (workflows.length === 0) {
-    await fs15.rm(generatedDir, { recursive: true, force: true });
+    await fs16.rm(generatedDir, { recursive: true, force: true });
     return {
       workflows,
       tasks: {},
       scheduledTasks: {}
     };
   }
-  await fs15.rm(generatedDir, { recursive: true, force: true });
-  await fs15.mkdir(generatedDir, { recursive: true });
+  await fs16.rm(generatedDir, { recursive: true, force: true });
+  await fs16.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = toPosixPath(path36.join(generatedDir, `${safeFileName(workflow.id)}.mjs`));
-    await fs15.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
+    const wrapperPath = toPosixPath(path37.join(generatedDir, `${safeFileName(workflow.id)}.mjs`));
+    await fs16.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = toPosixPath(path36.join(generatedDir, "http-handler.mjs"));
-  await fs15.writeFile(
+  const handlerPath = toPosixPath(path37.join(generatedDir, "http-handler.mjs"));
+  await fs16.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(
       workflowConfig,
@@ -1635,8 +1635,8 @@ async function prepareFarmWorkflowsForNitro(config) {
     ),
     "utf8"
   );
-  const manifestPath = path36.join(generatedDir, "manifest.json");
-  await fs15.writeFile(
+  const manifestPath = path37.join(generatedDir, "manifest.json");
+  await fs16.writeFile(
     manifestPath,
     JSON.stringify(
       {
@@ -1724,21 +1724,21 @@ function resolveWorkflowDefinition(module2) {
   return null;
 }
 async function findWorkflowFiles(root, dirs) {
-  const path36 = await import("path");
+  const path37 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path36.isAbsolute(dir) ? dir : path36.join(root, dir);
+    const absoluteDir = path37.isAbsolute(dir) ? dir : path37.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
   return files.sort();
 }
 async function walkWorkflowDir(dir, files) {
-  const fs15 = await import("fs/promises");
-  const path36 = await import("path");
-  const entries = await fs15.readdir(dir, { withFileTypes: true });
+  const fs16 = await import("fs/promises");
+  const path37 = await import("path");
+  const entries = await fs16.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path36.join(dir, entry.name);
+    const filePath = path37.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -1750,20 +1750,20 @@ async function walkWorkflowDir(dir, files) {
   }
 }
 async function pathExists(filePath) {
-  const fs15 = await import("fs/promises");
-  return fs15.access(filePath).then(() => true).catch(() => false);
+  const fs16 = await import("fs/promises");
+  return fs16.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 fs15 = await import("fs/promises");
-  const path36 = await import("path");
+  const fs16 = await import("fs/promises");
+  const path37 = await import("path");
   const { pathToFileURL: pathToFileURL10 } = await import("url");
   const { build: build2 } = await import("esbuild");
-  const outDir = path36.join(root, ".farm", ".workflow-loader");
-  await fs15.mkdir(outDir, { recursive: true });
-  const outfile = path36.join(
+  const outDir = path37.join(root, ".farm", ".workflow-loader");
+  await fs16.mkdir(outDir, { recursive: true });
+  const outfile = path37.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -1787,7 +1787,7 @@ async function loadWorkflowModule(filePath, root) {
       `${pathToFileURL10(outfile).href}?t=${Date.now()}`
     );
   } finally {
-    await fs15.unlink(outfile).catch(() => void 0);
+    await fs16.unlink(outfile).catch(() => void 0);
   }
 }
 function workflowIdFromFile(root, dirs, filePath) {
@@ -2082,7 +2082,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 path36 = normalizeCronPath(name2, job.path);
+  const path37 = 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) {
@@ -2091,7 +2091,7 @@ function normalizeCronJob(name2, job) {
   return {
     name: name2,
     schedule,
-    path: path36,
+    path: path37,
     description: job.description?.trim() || void 0
   };
 }
@@ -2108,13 +2108,13 @@ function normalizeCronPath(name2, value) {
       `Farm cron ${JSON.stringify(name2)} path cannot contain backslashes or control characters.`
     );
   }
-  const path36 = value.trim();
-  if (path36.startsWith("//") || path36.includes("?") || path36.includes("#")) {
+  const path37 = value.trim();
+  if (path37.startsWith("//") || path37.includes("?") || path37.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 path36.split("/")) {
+  for (const segment of path37.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -2136,7 +2136,7 @@ function normalizeCronPath(name2, value) {
       );
     }
   }
-  return path36.length > 1 ? path36.replace(/\/+$/, "") : path36;
+  return path37.length > 1 ? path37.replace(/\/+$/, "") : path37;
 }
 function normalizeCronExpression(name2, value) {
   if (typeof value !== "string") {
@@ -2815,7 +2815,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;
@@ -2909,12 +2915,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)) {
@@ -2932,9 +2951,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) {
@@ -2992,8 +3015,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");
@@ -3468,15 +3493,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 applyFarmCacheInvalidations(keys) {
@@ -3523,6 +3560,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(applyFarmCacheInvalidations, "applyFarmCacheInvalidations");
@@ -3995,7 +4033,7 @@ var init_server_action_security = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path36 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path37 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -4023,7 +4061,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path36,
+    path: path37,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -4069,11 +4107,11 @@ function normalizeImagePath(value) {
   if (hasUnstableCharacters(value)) {
     throw new TypeError("images.path cannot contain backslashes or control characters");
   }
-  const path36 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path36.startsWith("/") || path36.startsWith("//") || path36.includes("?") || path36.includes("#")) {
+  const path37 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path37.startsWith("/") || path37.startsWith("//") || path37.includes("?") || path37.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  for (const segment of path36.split("/")) {
+  for (const segment of path37.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -4089,7 +4127,7 @@ function normalizeImagePath(value) {
       throw new TypeError('images.path cannot contain "." or ".." path segments');
     }
   }
-  return path36;
+  return path37;
 }
 function normalizeIntegerList(values, name2, max) {
   if (values.length === 0) {
@@ -5692,7 +5730,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, path36, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path37, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -5701,7 +5739,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path36, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path36
+    path: path37
   });
   return { search, canonicalPath };
 }
@@ -5780,8 +5818,8 @@ function normalizeComparableValue(value) {
   }
   return value;
 }
-function createRoute(path36, options) {
-  return routesBuilder.page(path36, options);
+function createRoute(path37, options) {
+  return routesBuilder.page(path37, options);
 }
 function isProgrammaticRoutesFileName2(fileName) {
   const normalized = fileName.replace(/\\/g, "/");
@@ -5864,7 +5902,7 @@ function createRouteModuleFromProgrammaticPage(route, rendererRuntime) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path36) => resolveProgrammaticRouteSearch(route.search, rawSearch, path36, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path37) => resolveProgrammaticRouteSearch(route.search, rawSearch, path37, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -6274,25 +6312,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path36, options) {
+      page(path37, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path36,
+          path: path37,
           ...options
         });
       },
-      layout(path36, options) {
+      layout(path37, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path36,
+          path: path37,
           ...options
         });
       },
-      api(path36, options) {
+      api(path37, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path36,
+          path: path37,
           render,
           runtime,
           regions,
@@ -6776,9 +6814,9 @@ function getFarmIntegrationPluginOwner(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
   return value && typeof value === "object" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path36, input) {
+function defineTypedIntegrationRoute(method, path37, input) {
   return {
-    path: path36,
+    path: path37,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -6788,7 +6826,7 @@ function defineTypedIntegrationRoute(method, path36, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path36,
+      path: path37,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -6800,58 +6838,58 @@ function defineTypedIntegrationRoute(method, path36, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path36, input) {
+    get(path37, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path36,
+        path37,
         input
       );
     },
-    post(path36, input) {
+    post(path37, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path36,
+        path37,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    query(path36, input) {
-      return defineTypedIntegrationRoute("QUERY", path36, {
+    query(path37, input) {
+      return defineTypedIntegrationRoute("QUERY", path37, {
         bodyFormat: "json",
         ...input
       });
     },
-    put(path36, input) {
+    put(path37, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path36,
+        path37,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path36, input) {
-      return defineTypedIntegrationRoute("PATCH", path36, {
+    patch(path37, input) {
+      return defineTypedIntegrationRoute("PATCH", path37, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path36, input) {
-      return defineTypedIntegrationRoute("DELETE", path36, {
+    delete(path37, input) {
+      return defineTypedIntegrationRoute("DELETE", path37, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path36, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path36, input);
+    options(path37, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path37, input);
     },
-    head(path36, input) {
+    head(path37, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path36,
+        path37,
         input
       );
     }
@@ -7132,8 +7170,8 @@ async function parseIntegrationConfigSchema(integration, schema, value) {
 function createIntegrationConfigValidationError(integration, error) {
   const issues = Array.isArray(error.issues) && error.issues.length > 0 ? error.issues.map((issue) => {
     const normalizedPath = normalizeIntegrationValidationPath(issue.path);
-    const path36 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path36}${issue.message || "Invalid config"}`;
+    const path37 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path37}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -7857,8 +7895,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path36) {
-  return (path36 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path37) {
+  return (path37 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -8781,8 +8819,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path36 = "/", secure = false) {
-  const normalizedPath = path36.startsWith("/") ? path36 : `/${path36}`;
+function createFarmDeploymentCookie(deploymentId, path37 = "/", secure = false) {
+  const normalizedPath = path37.startsWith("/") ? path37 : `/${path37}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -9656,17 +9694,17 @@ function normalizeFarmAPIBasePath(value) {
   if (hasUnstableCharacters(value)) {
     throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
   }
-  const path36 = value.trim();
-  if (!path36) {
+  const path37 = value.trim();
+  if (!path37) {
     throw new Error("Farm api.basePath cannot be empty.");
   }
-  if (path36.includes("?") || path36.includes("#")) {
+  if (path37.includes("?") || path37.includes("#")) {
     throw new Error("Farm api.basePath cannot contain a query string or hash.");
   }
-  if (path36.startsWith("//")) {
+  if (path37.startsWith("//")) {
     throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
   }
-  for (const segment of path36.split("/")) {
+  for (const segment of path37.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -9682,7 +9720,7 @@ function normalizeFarmAPIBasePath(value) {
       throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
     }
   }
-  const normalized = `/${path36.replace(/^\/+|\/+$/g, "")}`;
+  const normalized = `/${path37.replace(/^\/+|\/+$/g, "")}`;
   return normalized === "/" ? "/" : normalized;
 }
 async function resolveConfigValue(value, context2, name2) {
@@ -9914,7 +9952,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) {
@@ -9922,14 +9960,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");
   }
 });
@@ -10107,9 +10145,9 @@ var init_type_generator = __esm({
         }
         const nestedStructure = {};
         const usedRouteNames = /* @__PURE__ */ new Map();
-        for (const [path36, routeList] of routeGroups) {
-          const routeName = this.uniqueRouteName(path36, usedRouteNames);
-          const cleanPath = path36 === "/api" ? "" : path36.replace(/^\/api\//, "");
+        for (const [path37, routeList] of routeGroups) {
+          const routeName = this.uniqueRouteName(path37, usedRouteNames);
+          const cleanPath = path37 === "/api" ? "" : path37.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const methodSources = /* @__PURE__ */ new Map();
           for (const route of routeList) {
@@ -10173,11 +10211,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(([path36, methods]) => ({ path: path36, methods: [...methods].sort() }));
+        const routeManifest = [...manifest].sort(([a], [b]) => a.localeCompare(b)).map(([path37, methods]) => ({ path: path37, methods: [...methods].sort() }));
         const manifestSource = routeManifest.length ? `[
 ${routeManifest.map(
-          ({ path: path36, methods }) => `  {
-    path: ${JSON.stringify(path36)},
+          ({ path: path37, methods }) => `  {
+    path: ${JSON.stringify(path37)},
     methods: [${methods.map((method) => JSON.stringify(method)).join(", ")}],
   },`
         ).join("\n")}
@@ -10207,11 +10245,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(path36) {
-        return (path36 === "/api" ? "root" : path36.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
+      pathToRouteName(path37) {
+        return (path37 === "/api" ? "root" : path37.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
       }
-      uniqueRouteName(path36, usedNames) {
-        const base = this.pathToRouteName(path36);
+      uniqueRouteName(path37, usedNames) {
+        const base = this.pathToRouteName(path37);
         const seen = usedNames.get(base);
         usedNames.set(base, (seen ?? 0) + 1);
         return seen ? `${base}_${seen + 1}` : base;
@@ -10234,15 +10272,15 @@ export const apiRoutes = ${manifestSource} as const;
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path36) {
-        const cleanPath = path36.replace(/^\/api\//, "");
+      getBaseExportName(path37) {
+        const cleanPath = path37.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path36, method) {
-        const cleanPath = path36.replace(/^\/api\//, "");
+      getExportName(path37, method) {
+        const cleanPath = path37.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -10734,12 +10772,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,
@@ -10752,13 +10790,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",
@@ -10811,22 +10849,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)) {
@@ -10834,7 +10872,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) {
@@ -10844,7 +10882,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",
@@ -10886,11 +10924,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(
@@ -10909,15 +10947,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;
@@ -10930,21 +10968,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"]);
@@ -10977,10 +11015,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;
@@ -11119,13 +11157,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");
@@ -11563,10 +11601,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}`;
     }
   }
@@ -11600,10 +11638,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;
@@ -11612,10 +11650,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;
   }
@@ -11629,16 +11667,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 [];
@@ -11661,10 +11699,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);
@@ -11703,7 +11741,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);
@@ -11726,9 +11764,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 "";
@@ -11741,12 +11779,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;
@@ -11754,7 +11792,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,
@@ -12273,11 +12311,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;
@@ -12766,12 +12823,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");
@@ -13032,7 +13089,7 @@ var init_adapter = __esm({
 // src/docs/framework-detect.ts
 async function frameworkDeclaredByApp(root) {
   try {
-    const raw = await (0, import_promises8.readFile)(import_node_path19.default.join(root, "package.json"), "utf8");
+    const raw = await (0, import_promises8.readFile)(import_node_path20.default.join(root, "package.json"), "utf8");
     const manifest = JSON.parse(raw);
     for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
       const section = manifest[field];
@@ -13065,7 +13122,7 @@ async function applyFarmDocsFrameworkAutoDetection(userConfig, options) {
   if (!docsWantsFrameworkDetection(userConfig.docs)) return userConfig;
   const log = options.log ?? ((message) => console.log(message));
   const warn = options.warn ?? ((message) => console.warn(message));
-  const root = import_node_path19.default.resolve(options.root || process.cwd());
+  const root = import_node_path20.default.resolve(options.root || process.cwd());
   if (!await frameworkDeclaredByApp(root)) {
     noticeOnce(
       "embedded-fallback",
@@ -13076,7 +13133,7 @@ async function applyFarmDocsFrameworkAutoDetection(userConfig, options) {
   }
   let configEntryPath;
   try {
-    const requireFromApp = (0, import_node_module6.createRequire)(import_node_path19.default.join(root, "package.json"));
+    const requireFromApp = (0, import_node_module6.createRequire)(import_node_path20.default.join(root, "package.json"));
     configEntryPath = requireFromApp.resolve(FRAMEWORK_CONFIG_ENTRY);
   } catch {
     noticeOnce(
@@ -13126,13 +13183,13 @@ async function applyFarmDocsFrameworkAutoDetection(userConfig, options) {
     return userConfig;
   }
 }
-var import_promises8, import_node_module6, import_node_path19, import_node_url7, FRAMEWORK_PACKAGE, FRAMEWORK_CONFIG_ENTRY, SUPPORTED_ADAPTER_PROTOCOL, emittedNotices;
+var import_promises8, import_node_module6, import_node_path20, import_node_url7, FRAMEWORK_PACKAGE, FRAMEWORK_CONFIG_ENTRY, SUPPORTED_ADAPTER_PROTOCOL, emittedNotices;
 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");
     FRAMEWORK_PACKAGE = "@farming-labs/farmjs";
     FRAMEWORK_CONFIG_ENTRY = "@farming-labs/farmjs/config";
@@ -13215,7 +13272,9 @@ function resolveDeployConfig(config, overrides = {}) {
       }
     }
   }
-  const preset = overrides.preset || deploy.preset || config.preset || getPresetForDeployTarget(target) || "node-server";
+  const configuredPreset = deploy.preset || config.preset;
+  const overrideTargetPreset = overrideTarget && getDeployTargetForPreset(configuredPreset) !== overrideTarget ? getPresetForDeployTarget(overrideTarget) : void 0;
+  const preset = overrides.preset || overrideTargetPreset || configuredPreset || getPresetForDeployTarget(target) || "node-server";
   const resolvedTarget = target || getDeployTargetForPreset(preset);
   if (detectedTarget && resolvedTarget !== detectedTarget) {
     const mismatchKey = `mismatch:${resolvedTarget}:${detectedTarget}`;
@@ -13317,19 +13376,19 @@ async function findDocsConfigPath(rootDir, configPath) {
   return void 0;
 }
 async function loadDocsConfig(rootDir, configPath) {
-  const fs15 = await import("fs/promises");
+  const fs16 = await import("fs/promises");
   const { pathToFileURL: pathToFileURL10 } = 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 fs15.readFile(resolvedPath, "utf8");
+      const content = await fs16.readFile(resolvedPath, "utf8");
       return { config: JSON.parse(content), configPath: resolvedPath };
     }
     const { build: build2 } = await import("esbuild");
     const configCacheDir = import_path10.default.join(root, ".farm", ".config-loader");
-    await fs15.mkdir(configCacheDir, { recursive: true });
+    await fs16.mkdir(configCacheDir, { recursive: true });
     const modulePath = import_path10.default.join(
       configCacheDir,
       `docs-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
@@ -13355,7 +13414,7 @@ async function loadDocsConfig(rootDir, configPath) {
         moduleUrl
       );
     } finally {
-      await fs15.unlink(modulePath).catch(() => void 0);
+      await fs16.unlink(modulePath).catch(() => void 0);
     }
     return {
       config: importedConfig.default || importedConfig,
@@ -13548,6 +13607,7 @@ async function resolveConfig(userConfig, mode) {
       serverComponents: false,
       serverActions: false,
       isolatedClientHydration: "off",
+      ppr: false,
       ...userConfig.experimental
     },
     plugins: [...resolveIntegrationPlugins(integrations), ...userConfig.plugins || []],
@@ -14480,8 +14540,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path36, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path36);
+        for (const [path37, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path37);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -14501,8 +14561,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path36) {
-        return path36.replace(/^\/api/, "");
+      convertToOpenAPIPath(path37) {
+        return path37.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -14664,8 +14724,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path36, method) {
-        const cleanPath = path36.replace(/^\/api\//, "");
+      generateSummary(path37, method) {
+        const cleanPath = path37.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;
@@ -14674,22 +14734,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path36, method) {
-        const cleanPath = path36.replace(/^\/api\//, "");
+      generateDescription(path37, method) {
+        const cleanPath = path37.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path36, method) {
-        const cleanPath = path36.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path37, method) {
+        const cleanPath = path37.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path36) {
-        const cleanPath = path36.replace(/^\/api\//, "");
+      generateTags(path37) {
+        const cleanPath = path37.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -14701,13 +14761,13 @@ var init_generator = __esm({
        */
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
-        const fs15 = require("fs");
-        const path36 = require("path");
-        const dir = path36.dirname(outputPath);
-        if (!fs15.existsSync(dir)) {
-          fs15.mkdirSync(dir, { recursive: true });
+        const fs16 = require("fs");
+        const path37 = require("path");
+        const dir = path37.dirname(outputPath);
+        if (!fs16.existsSync(dir)) {
+          fs16.mkdirSync(dir, { recursive: true });
         }
-        fs15.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
+        fs16.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
       }
     };
     __name(_OpenAPIGenerator, "OpenAPIGenerator");
@@ -15135,7 +15195,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 || "/",
@@ -15184,11 +15244,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();
@@ -15829,6 +15889,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; }
@@ -16338,6 +16399,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>
@@ -16593,23 +16655,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;
@@ -16625,7 +16690,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) {
@@ -16639,10 +16704,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;
@@ -16669,24 +16756,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";
@@ -16697,9 +16795,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";
     });
   };
 
@@ -16733,6 +16833,7 @@ function generateFarmDevtoolsClientRuntime(config) {
   window.addEventListener("message", onMessage);
   window[runtimeKey] = {
     dispose() {
+      finishClose();
       window.removeEventListener("keydown", onKeydown, true);
       window.removeEventListener("message", onMessage);
     },
@@ -17083,10 +17184,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;
@@ -17096,12 +17198,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 {
@@ -17115,23 +17217,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;
   }
@@ -17146,9 +17249,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 = {}) {
@@ -18246,7 +18349,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"
   );
 }
@@ -21415,7 +21518,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 {
@@ -21443,8 +21546,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}".`);
@@ -23793,7 +23907,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;
@@ -24721,7 +24835,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;
@@ -25426,6 +25541,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;
@@ -26163,6 +26283,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 || {}
@@ -27157,6 +27278,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();
@@ -27184,15 +27352,15 @@ function isEndpointFailure(value) {
 }
 __name(isEndpointFailure, "isEndpointFailure");
 function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path36;
+  let path37;
   let options;
   let handler;
   if (typeof pathOrOptions === "string") {
-    path36 = pathOrOptions;
+    path37 = pathOrOptions;
     options = optionsOrHandler;
     handler = maybeHandler;
   } else {
-    path36 = "";
+    path37 = "";
     options = pathOrOptions;
     handler = optionsOrHandler;
   }
@@ -27219,13 +27387,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     ...betterCallOptions
   } = options;
   const endpoint = (0, import_better_call.createEndpoint)(
-    path36 || "/__farm_auto_path__",
+    path37 || "/__farm_auto_path__",
     betterCallOptions,
     wrappedHandler
   );
-  endpoint.__path = path36 || void 0;
+  endpoint.__path = path37 || void 0;
   endpoint.__method = options.method || "GET";
-  endpoint.__autoPath = !path36;
+  endpoint.__autoPath = !path37;
   endpoint.__handler = wrappedHandler;
   endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
   endpoint.__middleware = middleware;
@@ -27236,6 +27404,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
@@ -27432,10 +27601,10 @@ function createRouteFactoryAt(prefix) {
     "OPTIONS"
   ]) {
     factory[method.toLowerCase()] = (child, options) => {
-      const path36 = joinRoutePath(prefix, child);
+      const path37 = joinRoutePath(prefix, child);
       const input = options.input ?? {};
       const endpoint = createEndpoint(
-        path36,
+        path37,
         {
           method,
           body: input.body,
@@ -27451,7 +27620,7 @@ function createRouteFactoryAt(prefix) {
       );
       endpoint.__types.params = input.params;
       endpoint.__output = options.output;
-      return Object.freeze({ path: path36, method, endpoint });
+      return Object.freeze({ path: path37, method, endpoint });
     };
   }
   return Object.freeze(factory);
@@ -27459,21 +27628,21 @@ function createRouteFactoryAt(prefix) {
 __name(createRouteFactoryAt, "createRouteFactoryAt");
 function joinRoutePath(prefix, child) {
   if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
-  const path36 = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
-  if (!(path36 === "/api" || path36.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path36)) {
+  const path37 = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
+  if (!(path37 === "/api" || path37.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path37)) {
     throw new TypeError(
-      `Plugin route "${path36}" must be a canonical /api path without a query, hash, or empty segment.`
+      `Plugin route "${path37}" must be a canonical /api path without a query, hash, or empty segment.`
     );
   }
-  assertBrowserStableRoutePath(path36);
-  assertUniqueRouteParameters(path36, "api");
-  getRoutePatternShape(path36, "api");
-  for (const segment of path36.split("/")) {
+  assertBrowserStableRoutePath(path37);
+  assertUniqueRouteParameters(path37, "api");
+  getRoutePatternShape(path37, "api");
+  for (const segment of path37.split("/")) {
     if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
       throw new TypeError(`Route segment "${segment}" is reserved.`);
     }
   }
-  return path36;
+  return path37;
 }
 __name(joinRoutePath, "joinRoutePath");
 function resolvePluginRoutes(plugins = []) {
@@ -27526,7 +27695,7 @@ function mergePluginAPIRoutes(existing, plugins, expected) {
   }
   const result = [...routes.values()];
   if (expected) {
-    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path: path36, methods }) => `${path36}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
+    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path: path37, methods }) => `${path37}:${[...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."
@@ -27538,8 +27707,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();
@@ -28003,9 +28172,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) {
@@ -28038,12 +28207,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)) {
@@ -28057,8 +28226,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 = {};
@@ -28131,7 +28300,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)))
     );
@@ -28160,16 +28329,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;
         }
       }
@@ -28303,8 +28472,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
@@ -28705,7 +28874,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);
@@ -28715,10 +28884,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);
       }
@@ -28730,8 +28899,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;
       }
     }
@@ -29071,8 +29240,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();
@@ -29125,12 +29294,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;
 }
@@ -29145,8 +29314,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}`,
         {
@@ -29182,7 +29351,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 {
@@ -29232,8 +29401,8 @@ ${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentati
 __name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
 
 // src/env-types.ts
-var fs9 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 init_write_file_if_changed();
 var DEFAULT_OUT_FILE2 = "farm-env.d.ts";
 var CONFIG_FILENAMES2 = [
@@ -29255,21 +29424,21 @@ var CONFIG_FILENAMES2 = [
   "config.cjs"
 ];
 async function generateEnvTypes(options) {
-  const root = path19.resolve(options.root);
+  const root = path20.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE2;
-  const outPath = path19.isAbsolute(outFile) ? outFile : path19.join(root, srcDir, outFile);
+  const outPath = path20.isAbsolute(outFile) ? outFile : path20.join(root, srcDir, outFile);
   const content = createEnvTypeDeclarations(options, outPath);
-  fs9.mkdirSync(path19.dirname(outPath), { recursive: true });
+  fs10.mkdirSync(path20.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
 __name(generateEnvTypes, "generateEnvTypes");
 function createEnvTypeDeclarations(options, outPath) {
-  const root = path19.resolve(options.root);
+  const root = path20.resolve(options.root);
   const configPath = findConfigPath(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs9.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs10.existsSync(value)),
     ...configPath ? [configPath] : []
   ];
   const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
@@ -29331,12 +29500,12 @@ export {};
 __name(createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path19.isAbsolute(configPath) ? configPath : path19.join(root, configPath);
-    return fs9.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path20.isAbsolute(configPath) ? configPath : path20.join(root, configPath);
+    return fs10.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path19.join(root, filename);
-    if (fs9.existsSync(resolvedPath)) {
+    const resolvedPath = path20.join(root, filename);
+    if (fs10.existsSync(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -29399,19 +29568,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;
 }
@@ -29439,8 +29608,8 @@ declare module "*?url" {
 __name(createFarmImageTypeDeclarations, "createFarmImageTypeDeclarations");
 
 // src/content-types.ts
-var fs10 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var CONFIG_FILENAMES3 = [
   "farm.config.ts",
   "farm.config.tsx",
@@ -29460,10 +29629,10 @@ var CONFIG_FILENAMES3 = [
   "config.cjs"
 ];
 function createContentTypeDeclarations(options, outPath) {
-  const root = path21.resolve(options.root);
+  const root = path22.resolve(options.root);
   const projectConfig = findConfigPath2(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs10.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs11.existsSync(value)),
     ...projectConfig ? [projectConfig] : []
   ];
   if (configPaths.length === 0) return createEmptyContentTypes();
@@ -29533,32 +29702,32 @@ export {};
 __name(createEmptyContentTypes, "createEmptyContentTypes");
 function findConfigPath2(root, configPath) {
   if (configPath) {
-    const resolvedPath = path21.isAbsolute(configPath) ? configPath : path21.join(root, configPath);
-    return fs10.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path22.isAbsolute(configPath) ? configPath : path22.join(root, configPath);
+    return fs11.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES3) {
-    const resolvedPath = path21.join(root, filename);
-    if (fs10.existsSync(resolvedPath)) return resolvedPath;
+    const resolvedPath = path22.join(root, filename);
+    if (fs11.existsSync(resolvedPath)) return resolvedPath;
   }
   return null;
 }
 __name(findConfigPath2, "findConfigPath");
 function toTypeImportPath2(outPath, targetPath) {
-  const relativePath2 = path21.relative(path21.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path22.relative(path22.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
 __name(toTypeImportPath2, "toTypeImportPath");
 
 // src/i18n/type-generator.ts
-var import_node_fs7 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path12 = require("path");
 init_write_file_if_changed();
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? (0, import_node_path11.resolve)(options.root, options.outFile) : (0, import_node_path11.join)((0, import_node_path11.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path12.resolve)(options.root, options.outFile) : (0, import_node_path12.join)((0, import_node_path12.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs7.mkdirSync)((0, import_node_path11.dirname)(outFile), { recursive: true });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path12.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -29851,8 +30020,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();
 
@@ -30359,7 +30528,7 @@ async function _runWithAfterRequest(request, handler, context2) {
     const response = await afterStorage.run(state, handler);
     return hasResponseHook ? response : wrapResponseBody(response, request, state);
   } catch (error) {
-    if (!hasResponseHook) finishSoon(state);
+    finishSoon(state);
     throw error;
   }
 }
@@ -30412,8 +30581,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(
@@ -30433,11 +30602,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 {
@@ -30452,6 +30621,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];
@@ -30481,7 +30651,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;
@@ -30564,7 +30734,7 @@ init_image_server();
 init_routing();
 
 // src/server/vite-config.ts
-var import_node_path13 = __toESM(require("path"));
+var import_node_path14 = __toESM(require("path"));
 var FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
 var FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
   "react",
@@ -30588,9 +30758,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
 }
 __name(getFarmClientOptimizeDepsInclude, "getFarmClientOptimizeDepsInclude");
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = import_node_path13.default.resolve(projectRoot);
+  const resolvedProjectRoot = import_node_path14.default.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = import_node_path13.default.relative(resolvedProjectRoot, import_node_path13.default.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = import_node_path14.default.relative(resolvedProjectRoot, import_node_path14.default.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -30614,7 +30784,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 __name(createFarmClientOptimizeDepsConfig, "createFarmClientOptimizeDepsConfig");
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": import_node_path13.default.resolve(projectRoot, srcDir)
+    "@": import_node_path14.default.resolve(projectRoot, srcDir)
   };
 }
 __name(createFarmSourceAlias, "createFarmSourceAlias");
@@ -30717,7 +30887,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) {
@@ -30774,7 +30944,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");
 
@@ -30886,6 +31056,7 @@ var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
   i18n: false
 }), "createEmptyTypeArtifactSelection");
 var FARM_I18N_CLIENT_BRIDGE_ID = "\0farm-i18n-client-bridge";
+var warnedDeprecatedDevtoolsDashboard = false;
 var EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME = `
 function isFarmDocsSearchPage() {
   return false;
@@ -31304,11 +31475,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;
   }
@@ -31316,7 +31487,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 = [];
@@ -31336,7 +31507,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,
@@ -31498,7 +31669,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]
             }
           }
         } : {}
@@ -31529,13 +31700,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();
@@ -31556,10 +31727,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;
@@ -31569,7 +31740,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 {
@@ -31610,7 +31781,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))
@@ -31731,7 +31902,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();
@@ -31996,12 +32167,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`)) {
@@ -32057,6 +32228,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));
             }
@@ -32099,7 +32276,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")
@@ -32983,7 +33160,10 @@ ${generatedDevIndicatorsClientRuntime}`,
           renderer,
           isolatedHydrationMode === "enabled",
           resolvedConfig?.trailingSlash ?? false,
-          resolvedConfig?.basePath ?? "/"
+          resolvedConfig?.basePath ?? "/",
+          generateClientCachePersistenceCode(
+            resolveFarmClientCacheAdapterEntry(root, resolvedConfig?.cache)
+          )
         );
       }
       if (id === "/@farm/server") {
@@ -33122,7 +33302,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({
@@ -33213,8 +33393,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"));
@@ -33266,9 +33446,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}`);
             });
@@ -33276,8 +33456,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) => ({
@@ -33320,9 +33500,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);
         }
@@ -33745,7 +33925,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,
@@ -33801,6 +33981,7 @@ import {
 } from '@farm.js/core/deployment'
 ${providerClientCode.imports}
 ${clientPluginEntry.imports}
+${clientCachePersistence.imports}
 ${docsSearchClientRuntime}
 ${devtoolsClientRuntime}
 ${docsAdapterImportBlock}
@@ -33816,6 +33997,7 @@ const integrationDocumentNavigationMatchers = ${JSON.stringify(documentNavigatio
 setFarmBasePath(${JSON.stringify(basePath)});
 setFarmTrailingSlashPreference(${JSON.stringify(trailingSlash)});
 installChunkErrorRecovery();
+${clientCachePersistence.init}
 
 let reactRoot = null;
 ${isolatedHydrationRuntime}
@@ -35199,7 +35381,7 @@ function generateClientManifest(bundle) {
 __name(generateClientManifest, "generateClientManifest");
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path33.resolve(config.root || process.cwd());
+  const appRoot = path34.resolve(config.root || process.cwd());
   if (config.extends?.length) {
     const { config: layeredConfig } = await Promise.resolve().then(() => (init_layers(), layers_exports)).then(
       ({ resolveFarmLayers: resolveFarmLayers2 }) => resolveFarmLayers2(config, {
@@ -35747,7 +35929,8 @@ function createServerQuery(options) {
       return createFarmServerQueryResult(data, {
         key: clientKey,
         staleTime,
-        updatedAt
+        updatedAt,
+        ...options.persist === true ? { persist: true } : {}
       });
     }, "handler")
   });
@@ -36135,8 +36318,8 @@ init_layers();
 
 // src/instrumentation.ts
 var import_esbuild = require("esbuild");
-var import_node_fs12 = __toESM(require("fs"));
-var import_node_path21 = __toESM(require("path"));
+var import_node_fs13 = __toESM(require("fs"));
+var import_node_path22 = __toESM(require("path"));
 var import_node_url9 = require("url");
 
 // src/instrumentation-runtime.ts
@@ -36184,16 +36367,16 @@ var INSTRUMENTATION_EXTENSIONS = ["ts", "mts", "js", "mjs"];
 function resolveFarmInstrumentationFile(root, srcDir = "src") {
   const candidates = [
     ...INSTRUMENTATION_EXTENSIONS.map(
-      (extension) => import_node_path21.default.join(root, srcDir, `instrumentation.${extension}`)
+      (extension) => import_node_path22.default.join(root, srcDir, `instrumentation.${extension}`)
     ),
     ...INSTRUMENTATION_EXTENSIONS.map(
-      (extension) => import_node_path21.default.join(root, `instrumentation.${extension}`)
+      (extension) => import_node_path22.default.join(root, `instrumentation.${extension}`)
     )
-  ].filter((candidate) => import_node_fs12.default.existsSync(candidate));
+  ].filter((candidate) => import_node_fs13.default.existsSync(candidate));
   if (candidates.length > 1) {
     throw new Error(
       `Farm.js found multiple instrumentation files:
-${candidates.map((candidate) => `- ${import_node_path21.default.relative(root, candidate)}`).join("\n")}
+${candidates.map((candidate) => `- ${import_node_path22.default.relative(root, candidate)}`).join("\n")}
 Keep only one instrumentation file in the project root or ${srcDir}/.`
     );
   }
@@ -36202,9 +36385,9 @@ Keep only one instrumentation file in the project root or ${srcDir}/.`
 __name(resolveFarmInstrumentationFile, "resolveFarmInstrumentationFile");
 async function loadFarmInstrumentation(filePath, root) {
   if (!filePath) return null;
-  const outputDirectory = import_node_path21.default.join(root, ".farm", ".instrumentation-loader");
-  const outputFile = import_node_path21.default.join(outputDirectory, "instrumentation.mjs");
-  await import_node_fs12.default.promises.mkdir(outputDirectory, { recursive: true });
+  const outputDirectory = import_node_path22.default.join(root, ".farm", ".instrumentation-loader");
+  const outputFile = import_node_path22.default.join(outputDirectory, "instrumentation.mjs");
+  await import_node_fs13.default.promises.mkdir(outputDirectory, { recursive: true });
   await (0, import_esbuild.build)({
     entryPoints: [filePath],
     outfile: outputFile,