@farm.js/core 0.1.0-beta.22 → 0.1.0-beta.24

package/dist/index.cjs

@@ -148,8 +148,8 @@ function toViteModuleId(filePath, root) {
 }
 async function fileExists(filePath) {
   try {
-    const fs9 = await import("fs/promises");
-    await fs9.access(filePath);
+    const fs10 = await import("fs/promises");
+    await fs10.access(filePath);
     return true;
   } catch {
     return false;
@@ -673,13 +673,13 @@ function defineIntegrationAPI(api3) {
 }
 function operation(method, pathOrOptions, maybeOptions = {}) {
   const hasExplicitPath = typeof pathOrOptions === "string";
-  const path32 = hasExplicitPath ? pathOrOptions : "";
+  const path33 = hasExplicitPath ? pathOrOptions : "";
   const options = hasExplicitPath ? maybeOptions : {
     ...maybeOptions,
     ...pathOrOptions
   };
   return defineIntegrationAPIOperation({
-    path: path32,
+    path: path33,
     method,
     __pathless: !hasExplicitPath,
     ...options
@@ -691,26 +691,26 @@ function get(pathOrOptions, maybeOptions = {}) {
 function isOperation(value) {
   return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
 }
-function bindRoutePath(path32, api3) {
+function bindRoutePath(path33, api3) {
   const entries = Object.entries(api3).map(([key, value]) => {
     if (isOperation(value)) {
       return [
         key,
         {
           ...value,
-          path: path32,
+          path: path33,
           __pathless: false
         }
       ];
     }
     if (value && typeof value === "object") {
-      return [key, bindRoutePath(path32, value)];
+      return [key, bindRoutePath(path33, value)];
     }
     return [key, value];
   });
   return Object.fromEntries(entries);
 }
-function route(path32, definitionOrOperation, ...operations) {
+function route(path33, definitionOrOperation, ...operations) {
   if (isOperation(definitionOrOperation)) {
     const allOperations = [definitionOrOperation, ...operations];
     return Object.fromEntries(
@@ -718,13 +718,13 @@ function route(path32, definitionOrOperation, ...operations) {
         operation2.method.toLowerCase(),
         {
           ...operation2,
-          path: path32,
+          path: path33,
           __pathless: false
         }
       ])
     );
   }
-  return bindRoutePath(path32, definitionOrOperation);
+  return bindRoutePath(path33, definitionOrOperation);
 }
 function normalizeRouteSegment(segment) {
   if (!segment) {
@@ -745,8 +745,8 @@ function normalizeRouteSegment(segment) {
 function camelCaseRouteSegment(segment) {
   return segment.replace(/-([a-zA-Z0-9])/g, (_match, value) => value.toUpperCase());
 }
-function getRouteClientSegments(path32) {
-  const segments = path32.split("/").filter(Boolean);
+function getRouteClientSegments(path33) {
+  const segments = path33.split("/").filter(Boolean);
   if (segments.length === 0) {
     return ["index"];
   }
@@ -1113,11 +1113,11 @@ function resolveFarmServerHealthConfig(config) {
   return Object.freeze({ enabled: true, livenessPath, readinessPath });
 }
 function normalizeHealthPath(value, optionName) {
-  const path32 = value.trim();
-  if (!path32.startsWith("/") || path32.includes("?") || path32.includes("#") || path32.includes("*")) {
+  const path33 = value.trim();
+  if (!path33.startsWith("/") || path33.includes("?") || path33.includes("#") || path33.includes("*")) {
     throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
   }
-  return path32.length > 1 ? path32.replace(/\/+$/, "") || "/" : path32;
+  return path33.length > 1 ? path33.replace(/\/+$/, "") || "/" : path33;
 }
 function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
   if (typeof value === "number") {
@@ -1214,7 +1214,7 @@ async function readNodeRequestBody(request, limit) {
     request.resume?.();
     throw error;
   }
-  return await new Promise((resolve6, reject) => {
+  return await new Promise((resolve7, reject) => {
     const chunks = [];
     let total = 0;
     let settled = false;
@@ -1243,7 +1243,7 @@ async function readNodeRequestBody(request, limit) {
       if (settled) return;
       settled = true;
       cleanup();
-      resolve6(Buffer.concat(chunks, total));
+      resolve7(Buffer.concat(chunks, total));
     }, "onEnd");
     const onError = /* @__PURE__ */ __name((error) => rejectOnce(error), "onError");
     request.on("data", onData);
@@ -1458,9 +1458,9 @@ function getFarmIntegrationPluginOwner(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
   return value && typeof value === "object" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path32, input) {
+function defineTypedIntegrationRoute(method, path33, input) {
   return {
-    path: path32,
+    path: path33,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -1470,7 +1470,7 @@ function defineTypedIntegrationRoute(method, path32, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path32,
+      path: path33,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -1482,52 +1482,52 @@ function defineTypedIntegrationRoute(method, path32, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path32, input) {
+    get(path33, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path32,
+        path33,
         input
       );
     },
-    post(path32, input) {
+    post(path33, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path32,
+        path33,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    put(path32, input) {
+    put(path33, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path32,
+        path33,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path32, input) {
-      return defineTypedIntegrationRoute("PATCH", path32, {
+    patch(path33, input) {
+      return defineTypedIntegrationRoute("PATCH", path33, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path32, input) {
-      return defineTypedIntegrationRoute("DELETE", path32, {
+    delete(path33, input) {
+      return defineTypedIntegrationRoute("DELETE", path33, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path32, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path32, input);
+    options(path33, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path33, input);
     },
-    head(path32, input) {
+    head(path33, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path32,
+        path33,
         input
       );
     }
@@ -1874,8 +1874,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 path32 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path32}${issue.message || "Invalid config"}`;
+    const path33 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path33}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -2572,8 +2572,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path32) {
-  return (path32 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path33) {
+  return (path33 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -4008,22 +4008,22 @@ async function prepareFarmWorkflowsForNitro(config) {
   }
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
-  const fs9 = await import("fs/promises");
-  const path32 = await import("path");
-  const generatedDir = path32.join(root, distDir, ".nitro", "farm-workflows");
-  await fs9.mkdir(generatedDir, { recursive: true });
+  const fs10 = await import("fs/promises");
+  const path33 = await import("path");
+  const generatedDir = path33.join(root, distDir, ".nitro", "farm-workflows");
+  await fs10.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = path32.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
-    await fs9.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
+    const wrapperPath = path33.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    await fs10.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = path32.join(generatedDir, "http-handler.mjs");
-  await fs9.writeFile(
+  const handlerPath = path33.join(generatedDir, "http-handler.mjs");
+  await fs10.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(
       workflowConfig,
@@ -4032,8 +4032,8 @@ async function prepareFarmWorkflowsForNitro(config) {
     ),
     "utf8"
   );
-  const manifestPath = path32.join(generatedDir, "manifest.json");
-  await fs9.writeFile(
+  const manifestPath = path33.join(generatedDir, "manifest.json");
+  await fs10.writeFile(
     manifestPath,
     JSON.stringify(
       {
@@ -4114,22 +4114,22 @@ function resolveWorkflowDefinition(module2) {
   return null;
 }
 async function findWorkflowFiles(root, dirs) {
-  const fs9 = await import("fs/promises");
-  const path32 = await import("path");
+  const fs10 = await import("fs/promises");
+  const path33 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path32.isAbsolute(dir) ? dir : path32.join(root, dir);
+    const absoluteDir = path33.isAbsolute(dir) ? dir : path33.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
   return files.sort();
 }
 async function walkWorkflowDir(dir, files) {
-  const fs9 = await import("fs/promises");
-  const path32 = await import("path");
-  const entries = await fs9.readdir(dir, { withFileTypes: true });
+  const fs10 = await import("fs/promises");
+  const path33 = await import("path");
+  const entries = await fs10.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path32.join(dir, entry.name);
+    const filePath = path33.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -4141,20 +4141,20 @@ async function walkWorkflowDir(dir, files) {
   }
 }
 async function pathExists(filePath) {
-  const fs9 = await import("fs/promises");
-  return fs9.access(filePath).then(() => true).catch(() => false);
+  const fs10 = await import("fs/promises");
+  return fs10.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 fs9 = await import("fs/promises");
-  const path32 = await import("path");
+  const fs10 = await import("fs/promises");
+  const path33 = await import("path");
   const { pathToFileURL: pathToFileURL5 } = await import("url");
   const { build: build2 } = await import("esbuild");
-  const outDir = path32.join(root, ".farm", ".workflow-loader");
-  await fs9.mkdir(outDir, { recursive: true });
-  const outfile = path32.join(
+  const outDir = path33.join(root, ".farm", ".workflow-loader");
+  await fs10.mkdir(outDir, { recursive: true });
+  const outfile = path33.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -4178,7 +4178,7 @@ async function loadWorkflowModule(filePath, root) {
       `${pathToFileURL5(outfile).href}?t=${Date.now()}`
     );
   } finally {
-    await fs9.unlink(outfile).catch(() => void 0);
+    await fs10.unlink(outfile).catch(() => void 0);
   }
 }
 function workflowIdFromFile(root, filePath) {
@@ -4448,14 +4448,14 @@ async function prepareFarmCronForNitro(config) {
   const cron = isResolvedCronConfig(config.cron) ? config.cron : resolveCronConfig(config.cron);
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
-  const fs9 = await import("fs/promises");
-  const path32 = await import("path");
-  const manifestPath = path32.join(root, distDir, FARM_CRON_MANIFEST);
-  const generatedDir = path32.join(root, distDir, ".nitro", "farm-cron");
+  const fs10 = await import("fs/promises");
+  const path33 = await import("path");
+  const manifestPath = path33.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path33.join(root, distDir, ".nitro", "farm-cron");
   if (!cron.enabled) {
     await Promise.all([
-      fs9.rm(manifestPath, { force: true }),
-      fs9.rm(generatedDir, { recursive: true, force: true })
+      fs10.rm(manifestPath, { force: true }),
+      fs10.rm(generatedDir, { recursive: true, force: true })
     ]);
     return {
       jobs: [],
@@ -4463,21 +4463,21 @@ async function prepareFarmCronForNitro(config) {
       scheduledTasks: {}
     };
   }
-  await fs9.rm(generatedDir, { recursive: true, force: true });
-  await fs9.mkdir(generatedDir, { recursive: true });
+  await fs10.rm(generatedDir, { recursive: true, force: true });
+  await fs10.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   for (const job of cron.jobs) {
     const taskName = getFarmCronTaskName(job.name);
-    const wrapperPath = path32.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
-    await fs9.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
+    const wrapperPath = path33.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
+    await fs10.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
     tasks[taskName] = {
       handler: wrapperPath,
       description: job.description || `Farm cron ${job.name}`
     };
   }
   const manifest = createFarmCronManifest(cron);
-  await fs9.mkdir(path32.dirname(manifestPath), { recursive: true });
-  await fs9.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await fs10.mkdir(path33.dirname(manifestPath), { recursive: true });
+  await fs10.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return {
     jobs: cron.jobs,
@@ -4578,7 +4578,7 @@ function normalizeCronJob(name, job) {
   if (!job || typeof job !== "object" || Array.isArray(job)) {
     throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
   }
-  const path32 = normalizeCronPath(name, job.path);
+  const path33 = normalizeCronPath(name, job.path);
   const rawSchedule = Array.isArray(job.schedule) ? job.schedule : [job.schedule];
   const schedule = [...new Set(rawSchedule.map((value) => normalizeCronExpression(name, value)))];
   if (schedule.length === 0) {
@@ -4587,7 +4587,7 @@ function normalizeCronJob(name, job) {
   return {
     name,
     schedule,
-    path: path32,
+    path: path33,
     description: job.description?.trim() || void 0
   };
 }
@@ -4595,13 +4595,13 @@ function normalizeCronPath(name, value) {
   if (typeof value !== "string" || !value.trim().startsWith("/")) {
     throw new TypeError(`Farm cron ${JSON.stringify(name)} path must start with "/".`);
   }
-  const path32 = value.trim();
-  if (path32.startsWith("//") || path32.includes("?") || path32.includes("#")) {
+  const path33 = value.trim();
+  if (path33.startsWith("//") || path33.includes("?") || path33.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  return path32.length > 1 ? path32.replace(/\/+$/, "") : path32;
+  return path33.length > 1 ? path33.replace(/\/+$/, "") : path33;
 }
 function normalizeCronExpression(name, value) {
   if (typeof value !== "string") {
@@ -5733,7 +5733,7 @@ var init_server_action_security = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path32 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path33 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -5761,7 +5761,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path32,
+    path: path33,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -5800,11 +5800,11 @@ function getPublicFarmImageConfig(config) {
   };
 }
 function normalizeImagePath(value) {
-  const path32 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path32.startsWith("/") || path32.includes("?") || path32.includes("#")) {
+  const path33 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path33.startsWith("/") || path33.includes("?") || path33.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  return path32;
+  return path33;
 }
 function normalizeIntegerList(values, name, max) {
   if (values.length === 0) {
@@ -7208,7 +7208,7 @@ function normalizePositiveDuration(value, fallback, name) {
   return Math.floor(value);
 }
 function delay(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function normalizeCacheOptionsTags(options) {
   const tags = /* @__PURE__ */ new Set();
@@ -7792,7 +7792,7 @@ function getProgrammaticRouteSearchClientOptions(search) {
   if (search.temporary?.length) options.temporary = [...search.temporary];
   return Object.keys(options).length > 0 ? options : void 0;
 }
-function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path32, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path33, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -7801,7 +7801,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path32, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path32
+    path: path33
   });
   return { search, canonicalPath };
 }
@@ -7880,8 +7880,8 @@ function normalizeComparableValue(value) {
   }
   return value;
 }
-function createRoute(path32, options) {
-  return routesBuilder.page(path32, options);
+function createRoute(path33, options) {
+  return routesBuilder.page(path33, options);
 }
 function isProgrammaticRoutesFileName(fileName) {
   const normalized = fileName.replace(/\\/g, "/");
@@ -7971,7 +7971,7 @@ function createRouteModuleFromProgrammaticPage(route2) {
     mod.__farmRouteData = route2.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route2, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path32) => resolveProgrammaticRouteSearch(route2.search, rawSearch, path32, route2.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path33) => resolveProgrammaticRouteSearch(route2.search, rawSearch, path33, route2.path).canonicalPath;
   }
   if (route2.pending || route2.error || route2.notFound) {
     mod.__farmRouteComponents = {
@@ -8369,25 +8369,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path32, options) {
+      page(path33, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path32,
+          path: path33,
           ...options
         });
       },
-      layout(path32, options) {
+      layout(path33, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path32,
+          path: path33,
           ...options
         });
       },
-      api(path32, options) {
+      api(path33, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path32,
+          path: path33,
           render,
           runtime,
           regions,
@@ -8758,6 +8758,35 @@ function getIslandStrategyExport(content) {
 function stripUseClientDirective(content) {
   return content.replace(/^\s*(["'])use client\1\s*;?\s*/, "");
 }
+function hasAsyncDefaultExport(content) {
+  if (!content) return false;
+  const tokens = tokenizeModuleSource(content);
+  for (let index = 0; index < tokens.length - 2; index++) {
+    const token = tokens[index];
+    if (token.kind !== "identifier" || token.value !== "export") continue;
+    if (tokens[index - 1]?.value === ".") continue;
+    if (tokens[index + 1]?.value !== "default") continue;
+    const exported = tokens[index + 2];
+    if (exported.kind === "identifier" && exported.value === "async") {
+      return true;
+    }
+    if (exported.kind === "identifier" && !["function", "class"].includes(exported.value) && tokens[index + 3]?.value !== "(" && isAsyncLocalDeclaration(tokens, exported.value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isAsyncLocalDeclaration(tokens, name) {
+  for (let index = 0; index < tokens.length - 2; index++) {
+    if (tokens[index].value === "async" && tokens[index + 1]?.value === "function" && tokens[index + 2]?.value === name) {
+      return true;
+    }
+    if (tokens[index].value === name && tokens[index + 1]?.value === "=" && tokens[index + 2]?.value === "async") {
+      return true;
+    }
+  }
+  return false;
+}
 function parseClientModuleMetadata(content, inspectIslandExport) {
   if (!content) {
     return {
@@ -8811,6 +8840,14 @@ function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandE
     }
   }
   const shouldHydrate = parsed.hasHydrateExport || importsClientBoundary;
+  if (shouldHydrate && hasAsyncDefaultExport(content)) {
+    return {
+      isClientComponent: false,
+      shouldHydrate: false,
+      islandStrategy: null,
+      suppressedAsyncHydration: true
+    };
+  }
   return {
     isClientComponent: false,
     shouldHydrate,
@@ -9111,6 +9148,8 @@ var init_client_component = __esm({
     __name(isIslandExportStart, "isIslandExportStart");
     __name(getIslandStrategyExport, "getIslandStrategyExport");
     __name(stripUseClientDirective, "stripUseClientDirective");
+    __name(hasAsyncDefaultExport, "hasAsyncDefaultExport");
+    __name(isAsyncLocalDeclaration, "isAsyncLocalDeclaration");
     __name(parseClientModuleMetadata, "parseClientModuleMetadata");
     __name(getClientModuleMetadata, "getClientModuleMetadata");
     __name(inspectClientModuleMetadata, "inspectClientModuleMetadata");
@@ -9671,6 +9710,7 @@ var init_route_manager = __esm({
             shouldHydrate: metadata.shouldHydrate,
             isClientComponent: metadata.isClientComponent,
             islandStrategy: metadata.islandStrategy,
+            suppressedAsyncHydration: metadata.suppressedAsyncHydration,
             search: getProgrammaticRouteSearchClientOptions(programmaticPage?.search),
             segments: entry.route.segments.map((seg) => ({
               segment: seg.segment,
@@ -10424,12 +10464,12 @@ function isFarmRouteActive(pattern, pathname, options = {}) {
 }
 function normalizeRouteInput(input, index) {
   const route2 = typeof input === "string" ? { path: input } : input;
-  const path32 = normalizePathname2(route2.path);
-  const segments = parseRoutePattern(path32);
+  const path33 = normalizePathname2(route2.path);
+  const segments = parseRoutePattern(path33);
   return {
     route: {
       ...route2,
-      path: path32
+      path: path33
     },
     segments,
     score: scoreSegments(segments),
@@ -10860,8 +10900,8 @@ function getControlledDeferred(id, controllers) {
   if (existing) return existing;
   let nativeResolve;
   let nativeReject;
-  const promise = new Promise((resolve6, reject) => {
-    nativeResolve = resolve6;
+  const promise = new Promise((resolve7, reject) => {
+    nativeResolve = resolve7;
     nativeReject = reject;
   });
   promise.status = "pending";
@@ -11075,8 +11115,8 @@ function createFarmDeploymentMismatchError(response, clientDeploymentId) {
     getFarmResponseDeploymentId(response) || "unknown"
   );
 }
-function createFarmDeploymentCookie(deploymentId, path32 = "/", secure = false) {
-  const normalizedPath = path32.startsWith("/") ? path32 : `/${path32}`;
+function createFarmDeploymentCookie(deploymentId, path33 = "/", secure = false) {
+  const normalizedPath = path33.startsWith("/") ? path33 : `/${path33}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -11257,11 +11297,11 @@ function readPageState() {
   if (!state || typeof state !== "object") return null;
   return state[FARM_PAGE_STATE_KEY] ?? null;
 }
-function createHistoryState(path32, pageState, currentState, interceptFrom) {
+function createHistoryState(path33, pageState, currentState, interceptFrom) {
   const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
   const nextState = {
     ...base,
-    path: path32,
+    path: path33,
     [FARM_PAGE_STATE_KEY]: pageState
   };
   if (interceptFrom === null) {
@@ -11271,9 +11311,9 @@ function createHistoryState(path32, pageState, currentState, interceptFrom) {
   }
   return nextState;
 }
-function getPageDataCacheKey(path32, interceptFrom) {
-  return interceptFrom ? `${path32}
-intercept:${interceptFrom}` : path32;
+function getPageDataCacheKey(path33, interceptFrom) {
+  return interceptFrom ? `${path33}
+intercept:${interceptFrom}` : path33;
 }
 function createNavigationLocation(url) {
   return {
@@ -11283,8 +11323,8 @@ function createNavigationLocation(url) {
     hash: url.hash
   };
 }
-function getScrollElementStorageKey(path32, key) {
-  return `farm-scroll-${path32}:${key}`;
+function getScrollElementStorageKey(path33, key) {
+  return `farm-scroll-${path33}:${key}`;
 }
 var FARM_PAGE_STATE_KEY, FARM_INTERCEPT_FROM_KEY, IDLE_NAVIGATION_STATE, routerInstance, _SPARouter, SPARouter;
 var init_spa_router = __esm({
@@ -11570,13 +11610,13 @@ var init_spa_router = __esm({
       /**
        * Fetch page data from cache or server
        */
-      async fetchPageData(path32, recover = true, interceptFrom) {
-        const cacheKey = getPageDataCacheKey(path32, interceptFrom);
+      async fetchPageData(path33, recover = true, interceptFrom) {
+        const cacheKey = getPageDataCacheKey(path33, interceptFrom);
         const cached = this.cache.get(cacheKey);
         if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
           return cached.data;
         }
-        const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path32)}`, {
+        const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path33)}`, {
           headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
             Accept: "application/x-farm-deferred+json, application/json",
             "X-Farm-SPA": "1",
@@ -11590,7 +11630,7 @@ var init_spa_router = __esm({
           );
           dispatchDeploymentMismatch(error);
           if (recover) {
-            window.location.assign(path32);
+            window.location.assign(path33);
           }
           throw error;
         }
@@ -11609,16 +11649,16 @@ var init_spa_router = __esm({
        */
       async handlePopState(event) {
         if (document.documentElement.dataset.farmDocsRuntime === "true") return;
-        const path32 = window.location.pathname + window.location.search;
+        const path33 = window.location.pathname + window.location.search;
         if (await this.shouldBlockNavigation({
-          from: event.state?.path || path32,
-          to: path32,
+          from: event.state?.path || path33,
+          to: path33,
           action: "pop"
         })) {
           return;
         }
         this.startNavigation({
-          from: event.state?.path || path32,
+          from: event.state?.path || path33,
           to: createNavigationLocation(new URL(window.location.href)),
           action: "pop"
         });
@@ -11630,7 +11670,7 @@ var init_spa_router = __esm({
             action: "pop"
           });
           const interceptFrom = typeof event.state?.[FARM_INTERCEPT_FROM_KEY] === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
-          const pageData = await this.fetchPageData(path32, true, interceptFrom);
+          const pageData = await this.fetchPageData(path33, true, interceptFrom);
           if (clientNavigation) {
             await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
           }
@@ -11661,8 +11701,8 @@ var init_spa_router = __esm({
       /**
        * Check if URL is cached
        */
-      isCached(path32, interceptFrom) {
-        const cached = this.cache.get(getPageDataCacheKey(path32, interceptFrom));
+      isCached(path33, interceptFrom) {
+        const cached = this.cache.get(getPageDataCacheKey(path33, interceptFrom));
         return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
       }
       /**
@@ -11716,15 +11756,15 @@ var init_spa_router = __esm({
       /**
        * Save scroll position for a path
        */
-      saveScrollPosition(path32) {
+      saveScrollPosition(path33) {
         try {
           sessionStorage.setItem(
-            `farm-scroll-${path32}`,
+            `farm-scroll-${path33}`,
             JSON.stringify({ x: window.scrollX, y: window.scrollY })
           );
           for (const [key, element] of this.scrollElements) {
             sessionStorage.setItem(
-              getScrollElementStorageKey(path32, key),
+              getScrollElementStorageKey(path33, key),
               JSON.stringify({ x: element.scrollLeft, y: element.scrollTop })
             );
           }
@@ -11734,22 +11774,22 @@ var init_spa_router = __esm({
       /**
        * Restore scroll position for a path
        */
-      restoreScrollPosition(path32) {
+      restoreScrollPosition(path33) {
         try {
-          const saved = sessionStorage.getItem(`farm-scroll-${path32}`);
+          const saved = sessionStorage.getItem(`farm-scroll-${path33}`);
           if (saved) {
             const { x, y } = JSON.parse(saved);
             setTimeout(() => window.scrollTo(x, y), 0);
           }
           for (const [key, element] of this.scrollElements) {
-            this.restoreScrollElement(path32, key, element);
+            this.restoreScrollElement(path33, key, element);
           }
         } catch {
         }
       }
-      restoreScrollElement(path32, key, element) {
+      restoreScrollElement(path33, key, element) {
         try {
-          const saved = sessionStorage.getItem(getScrollElementStorageKey(path32, key));
+          const saved = sessionStorage.getItem(getScrollElementStorageKey(path33, key));
           if (!saved) return;
           const { x, y } = JSON.parse(saved);
           setTimeout(() => {
@@ -14325,12 +14365,208 @@ body {
   }
 });
 
+// src/theme/config.ts
+function resolveFarmThemeConfig(config, basePath = "/") {
+  if (config && "enabled" in config) {
+    return config;
+  }
+  if (!config) {
+    return {
+      enabled: false,
+      default: "system",
+      storageKey: DEFAULT_FARM_THEME_STORAGE_KEY,
+      cookiePath: normalizeCookiePath(basePath)
+    };
+  }
+  const storageKey = config.storageKey?.trim() || DEFAULT_FARM_THEME_STORAGE_KEY;
+  if (!STORAGE_KEY_PATTERN.test(storageKey)) {
+    throw new Error(
+      "theme.storageKey may only contain letters, numbers, dots, underscores, and hyphens."
+    );
+  }
+  const defaultTheme = config.default ?? "system";
+  if (defaultTheme !== "light" && defaultTheme !== "dark" && defaultTheme !== "system") {
+    throw new Error('theme.default must be "light", "dark", or "system".');
+  }
+  return {
+    enabled: true,
+    default: defaultTheme,
+    storageKey,
+    cookiePath: normalizeCookiePath(basePath)
+  };
+}
+function normalizeCookiePath(basePath) {
+  const normalized = `/${basePath}`.replace(/\/{2,}/g, "/");
+  if (normalized === "/") return normalized;
+  return normalized.replace(/\/$/, "");
+}
+var DEFAULT_FARM_THEME_STORAGE_KEY, STORAGE_KEY_PATTERN;
+var init_config2 = __esm({
+  "src/theme/config.ts"() {
+    "use strict";
+    DEFAULT_FARM_THEME_STORAGE_KEY = "farm-theme";
+    STORAGE_KEY_PATTERN = /^[A-Za-z0-9._-]+$/;
+    __name(resolveFarmThemeConfig, "resolveFarmThemeConfig");
+    __name(normalizeCookiePath, "normalizeCookiePath");
+  }
+});
+
+// src/theme/server-runtime.ts
+function createFarmThemeDocumentParts(input, basePath = "/", serverTheme) {
+  const config = resolveFarmThemeConfig(input, basePath);
+  if (!config.enabled) return { attributes: "", head: "" };
+  const hydrationTheme = serverTheme ?? config.default;
+  const initialTheme = hydrationTheme === "system" ? "light" : hydrationTheme;
+  const script = createFarmThemeBootstrapScript(config, hydrationTheme);
+  return {
+    attributes: ` data-theme="${initialTheme}"`,
+    head: `<style id="${THEME_STYLE_ID}">:root[data-theme="light"]{color-scheme:light}:root[data-theme="dark"]{color-scheme:dark}</style><script id="${THEME_SCRIPT_ID}">${script}</script>`
+  };
+}
+function createFarmThemeBootstrapScript(config, serverTheme = config.default) {
+  return `(function(config,serverTheme){
+var isTheme=function(value){return value==="light"||value==="dark"||value==="system";};
+var decode=function(value){try{return decodeURIComponent(value);}catch(_error){return value;}};
+var readCookie=function(){var entries=document.cookie.split(";");for(var index=0;index<entries.length;index++){var entry=entries[index];var separator=entry.indexOf("=");if(separator<0)continue;if(decode(entry.slice(0,separator).trim())===config.storageKey)return decode(entry.slice(separator+1).trim());}};
+var media=window.matchMedia("(prefers-color-scheme: dark)");
+var resolveTheme=function(theme){return theme==="system"?(media.matches?"dark":"light"):theme;};
+var storedTheme=readCookie();
+var preference=isTheme(storedTheme)?storedTheme:config.default;
+var serverSnapshot={theme:serverTheme,resolvedTheme:serverTheme==="system"?undefined:serverTheme,mounted:false};
+var apply=function(){var resolvedTheme=resolveTheme(preference);document.documentElement.dataset.theme=resolvedTheme;var snapshot={theme:preference,resolvedTheme:resolvedTheme,mounted:true};if(window.__FARM_THEME__)window.__FARM_THEME__.snapshot=snapshot;return snapshot;};
+var emit=function(){var snapshot=apply();window.dispatchEvent(new CustomEvent("farm:themechange",{detail:snapshot}));};
+var persist=function(theme){var secure=window.location.protocol==="https:"?"; Secure":"";document.cookie=encodeURIComponent(config.storageKey)+"="+encodeURIComponent(theme)+"; Path="+config.cookiePath+"; Max-Age=31536000; SameSite=Lax"+secure;try{localStorage.setItem(config.storageKey,theme);}catch(_error){}};
+var setTheme=function(theme){if(!isTheme(theme))throw new TypeError("Unknown FARMJS theme: "+String(theme));preference=theme;persist(theme);emit();};
+var initialSnapshot={theme:preference,resolvedTheme:resolveTheme(preference),mounted:true};
+window.__FARM_THEME__={config:config,serverSnapshot:serverSnapshot,snapshot:initialSnapshot,setTheme:setTheme};
+document.documentElement.dataset.theme=initialSnapshot.resolvedTheme;
+var handleSystemChange=function(){if(preference==="system")emit();};
+if(typeof media.addEventListener==="function")media.addEventListener("change",handleSystemChange);else if(typeof media.addListener==="function")media.addListener(handleSystemChange);
+window.addEventListener("storage",function(event){if(event.key!==config.storageKey||!isTheme(event.newValue))return;preference=event.newValue;persist(preference);emit();});
+})(${serializeInlineValue(config)},${serializeInlineValue(serverTheme)});`;
+}
+function serializeInlineValue(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+var THEME_SCRIPT_ID, THEME_STYLE_ID;
+var init_server_runtime = __esm({
+  "src/theme/server-runtime.ts"() {
+    "use strict";
+    init_config2();
+    THEME_SCRIPT_ID = "farm-theme-script";
+    THEME_STYLE_ID = "farm-theme-style";
+    __name(createFarmThemeDocumentParts, "createFarmThemeDocumentParts");
+    __name(createFarmThemeBootstrapScript, "createFarmThemeBootstrapScript");
+    __name(serializeInlineValue, "serializeInlineValue");
+  }
+});
+
+// src/theme/bridge.ts
+function _setFarmThemeServerSnapshotResolver(resolver) {
+  globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER] = resolver;
+}
+function getFarmThemeServerSnapshot() {
+  return globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER]?.() ?? FALLBACK_SERVER_SNAPSHOT;
+}
+var FALLBACK_SERVER_SNAPSHOT, FARM_THEME_SERVER_SNAPSHOT_RESOLVER;
+var init_bridge2 = __esm({
+  "src/theme/bridge.ts"() {
+    "use strict";
+    FALLBACK_SERVER_SNAPSHOT = Object.freeze({
+      theme: "system",
+      resolvedTheme: void 0,
+      mounted: false
+    });
+    FARM_THEME_SERVER_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.js.theme.server-snapshot-resolver");
+    __name(_setFarmThemeServerSnapshotResolver, "_setFarmThemeServerSnapshotResolver");
+    __name(getFarmThemeServerSnapshot, "getFarmThemeServerSnapshot");
+  }
+});
+
+// src/theme/server.ts
+function _setDefaultFarmThemeConfig(config, basePath = "/") {
+  defaultThemeConfig = resolveFarmThemeConfig(config, basePath);
+}
+function getTheme(request = getCurrentRequest()) {
+  return readFarmThemePreference(request, defaultThemeConfig);
+}
+function getThemeSnapshot(request = getCurrentRequest()) {
+  const theme = readFarmThemePreference(request, defaultThemeConfig);
+  return {
+    theme,
+    resolvedTheme: theme === "system" ? void 0 : theme,
+    mounted: false
+  };
+}
+function readFarmThemePreference(request, config) {
+  if (!config.enabled) return config.default;
+  const stored = readCookie3(request.headers.get("cookie"), config.storageKey);
+  return isFarmThemePreference(stored) ? stored : config.default;
+}
+function readCookie3(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  for (const entry of cookieHeader.split(";")) {
+    const separator = entry.indexOf("=");
+    if (separator < 0) continue;
+    const key = decodeCookieValue(entry.slice(0, separator).trim());
+    if (key !== name) continue;
+    return decodeCookieValue(entry.slice(separator + 1).trim());
+  }
+  return void 0;
+}
+function decodeCookieValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function isFarmThemePreference(value) {
+  return value === "light" || value === "dark" || value === "system";
+}
+var defaultThemeConfig;
+var init_server3 = __esm({
+  "src/theme/server.ts"() {
+    "use strict";
+    init_request();
+    init_bridge2();
+    init_config2();
+    defaultThemeConfig = resolveFarmThemeConfig(void 0);
+    __name(_setDefaultFarmThemeConfig, "_setDefaultFarmThemeConfig");
+    __name(getTheme, "getTheme");
+    __name(getThemeSnapshot, "getThemeSnapshot");
+    __name(readFarmThemePreference, "readFarmThemePreference");
+    __name(readCookie3, "readCookie");
+    __name(decodeCookieValue, "decodeCookieValue");
+    __name(isFarmThemePreference, "isFarmThemePreference");
+    _setFarmThemeServerSnapshotResolver(() => {
+      try {
+        return getThemeSnapshot();
+      } catch {
+        const theme = defaultThemeConfig.default;
+        return {
+          theme,
+          resolvedTheme: theme === "system" ? void 0 : theme,
+          mounted: false
+        };
+      }
+    });
+  }
+});
+
 // src/server/renderer.ts
+function warnSuppressedAsyncHydrationOnce(modulePath) {
+  if (warnedSuppressedAsyncHydrationModules.has(modulePath)) return;
+  warnedSuppressedAsyncHydrationModules.add(modulePath);
+  logger.warn(
+    `${modulePath} is an async server component that imports client components. React cannot hydrate async components in the browser, so this route stays server-rendered and its client imports are not interactive. Move the interactive UI into a "use client" child rendered by a synchronous page, or enable experimental server components support.`
+  );
+}
 function hasRequestHeader(req, name) {
   const value = req.headers[name.toLowerCase()];
   return Array.isArray(value) ? value.length > 0 : Boolean(value);
 }
-function serializeInlineValue(value) {
+function serializeInlineValue2(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 function escapeHtmlAttribute2(value) {
@@ -14417,7 +14653,7 @@ function createDocumentFooter(options) {
 }
 function createDeferredHydrationScript(records) {
   if (records.length === 0) return "";
-  return `<script>window.__FARM_DEFERRED_DATA__=${serializeInlineValue(
+  return `<script>window.__FARM_DEFERRED_DATA__=${serializeInlineValue2(
     snapshotDeferredData(records)
   )};</script>`;
 }
@@ -14480,7 +14716,7 @@ function createRouteStateProps(input) {
     context: input.pluginExposedContext.size > 0 ? { data: input.pluginExposedContext } : void 0
   };
 }
-var import_react5, import_server2, fs2, path9, import_stream, cachedClerkProvider, importRuntimeModule, _FarmRouteErrorBoundary, FarmRouteErrorBoundary, _ServerRenderer, ServerRenderer;
+var import_react5, import_server2, fs2, path9, import_stream, cachedClerkProvider, importRuntimeModule, warnedSuppressedAsyncHydrationModules, _FarmRouteErrorBoundary, FarmRouteErrorBoundary, _ServerRenderer, ServerRenderer;
 var init_renderer = __esm({
   "src/server/renderer.ts"() {
     "use strict";
@@ -14510,10 +14746,14 @@ var init_renderer = __esm({
     init_font_vite();
     init_metadata_image();
     init_not_found();
+    init_server_runtime();
+    init_server3();
     cachedClerkProvider = null;
     importRuntimeModule = new Function("specifier", "return import(specifier);");
+    warnedSuppressedAsyncHydrationModules = /* @__PURE__ */ new Set();
+    __name(warnSuppressedAsyncHydrationOnce, "warnSuppressedAsyncHydrationOnce");
     __name(hasRequestHeader, "hasRequestHeader");
-    __name(serializeInlineValue, "serializeInlineValue");
+    __name(serializeInlineValue2, "serializeInlineValue");
     __name(escapeHtmlAttribute2, "escapeHtmlAttribute");
     __name(appendResponseHeader, "appendResponseHeader");
     __name(appendResponseVary, "appendResponseVary");
@@ -15032,6 +15272,9 @@ var init_renderer = __esm({
             })
           );
           const shouldHydrate = moduleMetadata.shouldHydrate;
+          if (moduleMetadata.suppressedAsyncHydration) {
+            warnSuppressedAsyncHydrationOnce(route2.modulePath);
+          }
           const layoutHydrationMetadata = layouts.map((layout2) => {
             const manifestEntry = routeManifest.layouts.find(
               (entry) => entry.pattern === layout2.pattern
@@ -15529,7 +15772,7 @@ var init_renderer = __esm({
         }
       }
       async renderWithSSR(element, req, res, clearMiddlewareData, options = {}) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           const streamStartTime = Date.now();
           const observabilityRoute = options.observabilityRoute || req.__FARM_ROUTE__ || req.url || "/";
           const deploymentId = this.getDeploymentId();
@@ -15601,9 +15844,9 @@ var init_renderer = __esm({
             slots: routeSlotPayload
           });
           const propsScript = `<script>
-window.__FARM_PROPS__ = ${serializeInlineValue(deferredProps.data.page)};
-window.__FARM_ROUTE_SLOTS__ = ${serializeInlineValue(deferredProps.data.slots)};
-window.__FARM_DEPLOYMENT_ID__ = ${serializeInlineValue(deploymentId)};
+window.__FARM_PROPS__ = ${serializeInlineValue2(deferredProps.data.page)};
+window.__FARM_ROUTE_SLOTS__ = ${serializeInlineValue2(deferredProps.data.slots)};
+window.__FARM_DEPLOYMENT_ID__ = ${serializeInlineValue2(deploymentId)};
 window.__FARM_PATH__ = ${JSON.stringify(req.__FARM_ROUTE__ || req.url || "/")};
 window.__FARM_IS_CLIENT__ = ${JSON.stringify(isClientComponent)};
 window.__FARM_PAGE_SHOULD_HYDRATE__ = ${JSON.stringify(
@@ -15621,7 +15864,7 @@ window.__FARM_LOADING_MODULE__ = ${JSON.stringify(
           )};
 window.__FARM_MANIFEST__ = ${JSON.stringify(clientManifest)};
 window.__FARM_INTEGRATION_API_MANIFEST__ = ${JSON.stringify(getRegisteredIntegrationAPIManifest())};
-${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(getFarmI18nClientSnapshot())};` : ""}
+${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue2(getFarmI18nClientSnapshot())};` : ""}
 </script>`;
           const hydrationClickQueueScript = isClientComponent || req.__FARM_SHOULD_HYDRATE__ === true || req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ === true ? createPreHydrationClickQueueScript() : "";
           const {
@@ -15632,6 +15875,11 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
           const i18nSnapshot = getFarmI18nClientSnapshot();
           const i18nAlternateTags = i18nSnapshot ? renderI18nAlternateLinks(req.__FARM_ROUTE__ || req.url || "/", i18nSnapshot) : "";
           const fontHead = renderFarmFontDevHead(this.config.root || process.cwd());
+          const themeDocument = createFarmThemeDocumentParts(
+            this.config.theme,
+            this.config.basePath,
+            getTheme()
+          );
           const streamRoot = import_react5.default.createElement("div", { style: { display: "contents" } }, element);
           const { pipe } = (0, import_server2.renderToPipeableStream)(streamRoot, {
             onShellReady() {
@@ -15645,8 +15893,9 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                 console.log(`[FARM STREAM] onShellReady at ${shellReadyMs}ms`);
               }
               const shell = `<!DOCTYPE html>
-<html lang="${escapeHtmlAttribute2(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}>
+<html lang="${escapeHtmlAttribute2(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}${themeDocument.attributes}>
 <head>
+  ${themeDocument.head}
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="farm-deployment-id" content="${escapeHtmlAttribute2(deploymentId)}">
@@ -15723,7 +15972,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                     route: observabilityRoute,
                     durationMs: Date.now() - streamStartTime
                   });
-                  resolve6();
+                  resolve7();
                 }
               });
               res.write(shell);
@@ -15848,15 +16097,21 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         const i18nSnapshot = getFarmI18nClientSnapshot();
         const clientScript = isClientComponent ? `  <script type="module" src="/@farm/client.js"></script>` : "";
         const integrationManifestScript = `<script>
-window.__FARM_DEPLOYMENT_ID__ = ${serializeInlineValue(this.getDeploymentId())};
+window.__FARM_DEPLOYMENT_ID__ = ${serializeInlineValue2(this.getDeploymentId())};
 window.__FARM_INTEGRATION_API_MANIFEST__ = ${JSON.stringify(getRegisteredIntegrationAPIManifest())};
-${i18nSnapshot ? `window.__FARM_I18N__ = ${serializeInlineValue(i18nSnapshot)};` : ""}
+${i18nSnapshot ? `window.__FARM_I18N__ = ${serializeInlineValue2(i18nSnapshot)};` : ""}
 </script>`;
         const alternateLinks = i18nSnapshot ? renderI18nAlternateLinks(requestPath, i18nSnapshot) : "";
         const fontHead = renderFarmFontDevHead(this.config.root || process.cwd());
+        const themeDocument = createFarmThemeDocumentParts(
+          this.config.theme,
+          this.config.basePath,
+          getTheme()
+        );
         return `<!DOCTYPE html>
-<html lang="${escapeHtmlAttribute2(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}>
+<html lang="${escapeHtmlAttribute2(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}${themeDocument.attributes}>
 <head>
+  ${themeDocument.head}
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="farm-deployment-id" content="${escapeHtmlAttribute2(this.getDeploymentId())}">
@@ -16218,6 +16473,8 @@ var init_app = __esm({
     init_auth_config();
     init_preload();
     init_security();
+    init_config2();
+    init_server3();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -16228,6 +16485,7 @@ var init_app = __esm({
       constructor(config = {}, viteServer) {
         this.config = this.normalizeConfig(config);
         configureFarmObservability(this.config.observability);
+        _setDefaultFarmThemeConfig(this.config.theme);
         this.i18nRuntime = createFarmI18nRuntime(this.config.i18n);
         _setDefaultFarmI18nRuntime(this.i18nRuntime);
         this.viteServer = viteServer;
@@ -16286,6 +16544,7 @@ var init_app = __esm({
           security: resolveFarmSecurityConfig(config.security),
           images: resolveFarmImageConfig(config.images),
           performance: resolveFarmPerformanceConfig(config.performance),
+          theme: resolveFarmThemeConfig(config.theme, config.basePath || "/"),
           i18n: isResolvedI18nConfig(config.i18n) ? config.i18n : resolveFarmI18nConfig(config.i18n, {
             root,
             mode: process.env.NODE_ENV === "production" ? "production" : "development"
@@ -16973,15 +17232,15 @@ function isEndpointFailure(value) {
   return value instanceof EndpointFailure;
 }
 function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path32;
+  let path33;
   let options;
   let handler;
   if (typeof pathOrOptions === "string") {
-    path32 = pathOrOptions;
+    path33 = pathOrOptions;
     options = optionsOrHandler;
     handler = maybeHandler;
   } else {
-    path32 = "";
+    path33 = "";
     options = pathOrOptions;
     handler = optionsOrHandler;
   }
@@ -17008,13 +17267,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     ...betterCallOptions
   } = options;
   const endpoint2 = (0, import_better_call.createEndpoint)(
-    path32 || "/__farm_auto_path__",
+    path33 || "/__farm_auto_path__",
     betterCallOptions,
     wrappedHandler
   );
-  endpoint2.__path = path32 || void 0;
+  endpoint2.__path = path33 || void 0;
   endpoint2.__method = options.method || "GET";
-  endpoint2.__autoPath = !path32;
+  endpoint2.__autoPath = !path33;
   endpoint2.__handler = wrappedHandler;
   endpoint2.__farmInvoke = (ctx) => runEndpointMiddleware(middleware2, ctx, handler, error, options.invalidates);
   endpoint2.__middleware = middleware2;
@@ -18725,11 +18984,11 @@ var init_type_generator = __esm({
           routeGroups.get(key).push(route2);
         }
         const nestedStructure = {};
-        for (const [path32, routeList] of routeGroups) {
+        for (const [path33, routeList] of routeGroups) {
           const route2 = routeList[0];
           const importPath = this.getRouteImportPath(route2, options.outFile);
           const routeName = this.pathToRouteName(route2.path);
-          const cleanPath = path32 === "/api" ? "" : path32.replace(/^\/api\//, "");
+          const cleanPath = path33 === "/api" ? "" : path33.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const allMethods = routeList.flatMap((r) => r.methods);
           for (const method of allMethods) {
@@ -18788,8 +19047,8 @@ ${typeExports}
         const relativeImport = (0, import_path7.relative)((0, import_path7.dirname)(outFile), route2.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path32) {
-        return (path32 === "/api" ? "root" : path32.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+      pathToRouteName(path33) {
+        return (path33 === "/api" ? "root" : path33.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
       }
       structureToTypeString(obj, indent) {
         const spaces = "  ".repeat(indent);
@@ -18809,15 +19068,15 @@ ${typeExports}
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path32) {
-        const cleanPath = path32.replace(/^\/api\//, "");
+      getBaseExportName(path33) {
+        const cleanPath = path33.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path32, method) {
-        const cleanPath = path32.replace(/^\/api\//, "");
+      getExportName(path33, method) {
+        const cleanPath = path33.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -19853,7 +20112,7 @@ var init_environment_vite = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.22";
+    version = "0.1.0-beta.24";
   }
 });
 
@@ -19890,8 +20149,8 @@ function reportAfterError(state, error) {
 function createAfterRequestState(reportError = defaultAfterErrorReporter) {
   let resolveResponseFinished;
   let responseFinished = false;
-  const responseFinishedPromise = new Promise((resolve6) => {
-    resolveResponseFinished = resolve6;
+  const responseFinishedPromise = new Promise((resolve7) => {
+    resolveResponseFinished = resolve7;
   });
   const state = {
     completion: Promise.resolve(),
@@ -19998,8 +20257,8 @@ function after(callback) {
     throw new Error("after() cannot schedule work after the request lifecycle has completed.");
   }
   let start;
-  const ready = new Promise((resolve6) => {
-    start = resolve6;
+  const ready = new Promise((resolve7) => {
+    start = resolve7;
   });
   const result = ready.then(callback);
   state.tasks.push({ result, start });
@@ -20065,6 +20324,40 @@ var init_after = __esm({
   }
 });
 
+// src/dev-static.ts
+function devServableFileExists(pathname, baseDirs) {
+  let decodedPathname;
+  try {
+    decodedPathname = decodeURIComponent(pathname);
+  } catch {
+    return false;
+  }
+  const relativePathname = decodedPathname.replace(/^\/+/, "");
+  if (!relativePathname) return false;
+  for (const baseDir of baseDirs) {
+    if (typeof baseDir !== "string" || baseDir.length === 0) continue;
+    const resolvedBase = path17.resolve(baseDir);
+    const candidate = path17.resolve(resolvedBase, relativePathname);
+    if (!candidate.startsWith(resolvedBase + path17.sep)) continue;
+    try {
+      if (fs7.existsSync(candidate) && fs7.statSync(candidate).isFile()) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+var fs7, path17;
+var init_dev_static = __esm({
+  "src/dev-static.ts"() {
+    "use strict";
+    fs7 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
+    __name(devServableFileExists, "devServableFileExists");
+  }
+});
+
 // src/image-vite.ts
 function farmImageImportsPlugin() {
   return {
@@ -20753,6 +21046,36 @@ var init_fonts = __esm({
   }
 });
 
+// src/theme/vite.ts
+function createFarmThemeCssPlugin(input, basePath = "/") {
+  const config = resolveFarmThemeConfig(input, basePath);
+  return {
+    name: "farm:theme-css",
+    enforce: "pre",
+    transform(code, id) {
+      if (!config.enabled || !/\.css(?:\?.*)?$/.test(id) || !/@import\s+["']tailwindcss["']/.test(code) || /@custom-variant\s+dark\b/.test(code)) {
+        return null;
+      }
+      return {
+        code: `${code.trimEnd()}
+
+${FARM_DARK_VARIANT}
+`,
+        map: null
+      };
+    }
+  };
+}
+var FARM_DARK_VARIANT;
+var init_vite = __esm({
+  "src/theme/vite.ts"() {
+    "use strict";
+    init_config2();
+    FARM_DARK_VARIANT = '@custom-variant dark (&:where([data-theme="dark"], [data-theme="dark"] *));';
+    __name(createFarmThemeCssPlugin, "createFarmThemeCssPlugin");
+  }
+});
+
 // src/docs/last-modified.ts
 function normalizeRelativePath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\/+/, "");
@@ -24524,37 +24847,37 @@ function sanitizeDocsConfig(config) {
   return cloneSerializable(config) || {};
 }
 async function findDocsConfigPath(rootDir, configPath) {
-  const { existsSync: existsSync17 } = await import("fs");
+  const { existsSync: existsSync18 } = await import("fs");
   const root = import_path9.default.resolve(rootDir || process.cwd());
   if (configPath) {
     const resolvedPath = import_path9.default.isAbsolute(configPath) ? configPath : import_path9.default.join(root, configPath);
-    if (!existsSync17(resolvedPath)) {
+    if (!existsSync18(resolvedPath)) {
       throw new Error(`Could not find docs config at ${configPath}.`);
     }
     return import_path9.default.resolve(resolvedPath);
   }
   for (const filename of DOCS_CONFIG_FILENAMES) {
     const resolvedPath = import_path9.default.join(root, filename);
-    if (existsSync17(resolvedPath)) {
+    if (existsSync18(resolvedPath)) {
       return resolvedPath;
     }
   }
   return void 0;
 }
 async function loadDocsConfig(rootDir, configPath) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const { pathToFileURL: pathToFileURL5 } = await import("url");
   const root = import_path9.default.resolve(rootDir || process.cwd());
   const resolvedPath = await findDocsConfigPath(root, configPath);
   if (!resolvedPath) return void 0;
   try {
     if (resolvedPath.endsWith(".json")) {
-      const content = await fs9.readFile(resolvedPath, "utf8");
+      const content = await fs10.readFile(resolvedPath, "utf8");
       return { config: JSON.parse(content), configPath: resolvedPath };
     }
     const { build: build2 } = await import("esbuild");
     const configCacheDir = import_path9.default.join(root, ".farm", ".config-loader");
-    await fs9.mkdir(configCacheDir, { recursive: true });
+    await fs10.mkdir(configCacheDir, { recursive: true });
     const modulePath = import_path9.default.join(
       configCacheDir,
       `docs-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
@@ -24580,7 +24903,7 @@ async function loadDocsConfig(rootDir, configPath) {
         moduleUrl
       );
     } finally {
-      await fs9.unlink(modulePath).catch(() => void 0);
+      await fs10.unlink(modulePath).catch(() => void 0);
     }
     return {
       config: importedConfig.default || importedConfig,
@@ -24730,6 +25053,7 @@ async function resolveConfig(userConfig, mode) {
     routeRules,
     images: resolveFarmImageConfig(userConfig.images),
     performance: resolveFarmPerformanceConfig(userConfig.performance),
+    theme: resolveFarmThemeConfig(userConfig.theme, userConfig.basePath || "/"),
     publicDir: userConfig.publicDir || "public",
     i18n: resolveFarmI18nConfig(userConfig.i18n, { root, mode }),
     openapi: {
@@ -24770,7 +25094,7 @@ async function resolveConfig(userConfig, mode) {
   return resolved;
 }
 async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "production" ? "production" : "development", loadEnvironment) {
-  const { existsSync: existsSync17 } = await import("fs");
+  const { existsSync: existsSync18 } = await import("fs");
   const loadEnv = loadEnvironment || (await import("vite")).loadEnv;
   const root = rootDir || process.cwd();
   const loadedEnv = loadEnv(mode, root, "");
@@ -24794,7 +25118,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
     try {
       const absolutePath = relativePath2.startsWith("/") ? relativePath2 : import_path9.default.join(root, relativePath2);
       const normalizedPath = import_path9.default.resolve(absolutePath);
-      if (!existsSync17(normalizedPath)) {
+      if (!existsSync18(normalizedPath)) {
         continue;
       }
       const loadedConfig = await loadFarmConfigFile(normalizedPath, { root });
@@ -24807,7 +25131,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
   return void 0;
 }
 var import_path9, FARM_RESOLVED_CUSTOM_CONTEXT, DOCS_CONFIG_FILENAMES;
-var init_config2 = __esm({
+var init_config3 = __esm({
   "src/config.ts"() {
     "use strict";
     init_integrations();
@@ -24828,6 +25152,7 @@ var init_config2 = __esm({
     init_auth_config();
     init_preload();
     init_security();
+    init_config2();
     init_config_entry();
     FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
     __name(hasCustomFarmRouteContext, "hasCustomFarmRouteContext");
@@ -25332,7 +25657,7 @@ var init_api = __esm({
   "src/docs/api.ts"() {
     "use strict";
     import_docs2 = require("@farming-labs/docs");
-    init_config2();
+    init_config3();
     init_handler();
     __name(isRecord4, "isRecord");
     __name(isResolvedDocsConfig2, "isResolvedDocsConfig");
@@ -25626,8 +25951,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route2);
         }
-        for (const [path32, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path32);
+        for (const [path33, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path33);
           spec.paths[openAPIPath] = {};
           for (const route2 of routeList) {
             for (const method of route2.methods) {
@@ -25641,8 +25966,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path32) {
-        return path32.replace(/^\/api/, "");
+      convertToOpenAPIPath(path33) {
+        return path33.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -25804,8 +26129,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path32, method) {
-        const cleanPath = path32.replace(/^\/api\//, "");
+      generateSummary(path33, method) {
+        const cleanPath = path33.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         const lastPart = pathParts[pathParts.length - 1];
         const action = method === "GET" ? "Get" : method === "POST" ? "Create" : method === "PUT" ? "Update" : method === "DELETE" ? "Delete" : method === "PATCH" ? "Update" : method;
@@ -25814,22 +26139,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path32, method) {
-        const cleanPath = path32.replace(/^\/api\//, "");
+      generateDescription(path33, method) {
+        const cleanPath = path33.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path32, method) {
-        const cleanPath = path32.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path33, method) {
+        const cleanPath = path33.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path32) {
-        const cleanPath = path32.replace(/^\/api\//, "");
+      generateTags(path33) {
+        const cleanPath = path33.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -25841,13 +26166,13 @@ var init_generator = __esm({
        */
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
-        const fs9 = require("fs");
-        const path32 = require("path");
-        const dir = path32.dirname(outputPath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const fs10 = require("fs");
+        const path33 = require("path");
+        const dir = path33.dirname(outputPath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
-        fs9.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
+        fs10.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
       }
     };
     __name(_OpenAPIGenerator, "OpenAPIGenerator");
@@ -26317,7 +26642,7 @@ var init_devtools = __esm({
   "src/devtools.ts"() {
     "use strict";
     import_node_path14 = __toESM(require("path"));
-    init_config2();
+    init_config3();
     init_cron();
     init_route_runtime();
     __name(normalizePath, "normalizePath");
@@ -28135,18 +28460,18 @@ function isPotentialProgrammaticRouteSourceFile(normalizedFile, srcDirSlug) {
   return normalizedFile.startsWith(`${srcDirSlug}/`) && /\.(ts|tsx|js|jsx)$/.test(normalizedFile) && !normalizedFile.endsWith(".d.ts") && !normalizedFile.endsWith("/farm-routes.d.ts") && !normalizedFile.endsWith("/farm-env.d.ts") && !normalizedFile.endsWith("/lib/api.generated.ts");
 }
 function fileContainsProgrammaticPageRoute(file) {
-  if (!fs7.existsSync(file)) {
+  if (!fs8.existsSync(file)) {
     return false;
   }
   try {
-    return scanProgrammaticPagePaths(fs7.readFileSync(file, "utf8")).length > 0;
+    return scanProgrammaticPagePaths(fs8.readFileSync(file, "utf8")).length > 0;
   } catch {
     return false;
   }
 }
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path25.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path26.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -28166,7 +28491,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 = path25.resolve(path25.dirname(cleanId), sourcePath);
+    const resolvedPath = path26.resolve(path26.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -28241,7 +28566,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path25.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path26.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -28272,13 +28597,13 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path25.join(server.config.root, "src/app/globals.css");
-      if (!fs7.existsSync(globalsCSSPath)) {
-        const appDir = path25.join(server.config.root, "src/app");
-        if (!fs7.existsSync(appDir)) {
-          fs7.mkdirSync(appDir, { recursive: true });
+      const globalsCSSPath = path26.join(server.config.root, "src/app/globals.css");
+      if (!fs8.existsSync(globalsCSSPath)) {
+        const appDir = path26.join(server.config.root, "src/app");
+        if (!fs8.existsSync(appDir)) {
+          fs8.mkdirSync(appDir, { recursive: true });
         }
-        fs7.writeFileSync(globalsCSSPath, defaultGlobalCSS);
+        fs8.writeFileSync(globalsCSSPath, defaultGlobalCSS);
       }
       await farmApp.initialize();
       const farmConfig = farmApp.getConfig();
@@ -28297,10 +28622,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path25.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path26.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path25.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path26.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -28310,7 +28635,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path25.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path26.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -28350,7 +28675,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path25.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path26.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -28468,7 +28793,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs7.existsSync(path25.isAbsolute(dir) ? dir : path25.join(farmConfig.root, dir))
+        (dir) => fs8.existsSync(path26.isAbsolute(dir) ? dir : path26.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler: createFarmWorkflowRequestHandler2, discoverFarmWorkflows: discoverFarmWorkflows2 } = await loadFarmWorkflowsDevRuntime();
@@ -28702,12 +29027,12 @@ window.__FARM_MANIFEST__ = ${inlineValue({
             }
           }
           const farmDocsFontPath = farmDocsFontAssets.get(requestPathname);
-          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs7.existsSync(farmDocsFontPath)) {
+          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs8.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 fs7.createReadStream(farmDocsFontPath).pipe(res);
+            else fs8.createReadStream(farmDocsFontPath).pipe(res);
             return;
           }
           if (requestMethod === "GET" && (requestPathname === FARM_DEVTOOLS_PATH || requestPathname === `${FARM_DEVTOOLS_PATH}.json`)) {
@@ -28805,7 +29130,7 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                 return null;
               }
               return {
-                source: await fs7.promises.readFile(sourcePath, "utf8"),
+                source: await fs8.promises.readFile(sourcePath, "utf8"),
                 filePath: sourcePath
               };
             }, "resolveSource")
@@ -29140,9 +29465,17 @@ window.__FARM_MANIFEST__ = ${inlineValue({
             res.end(JSON.stringify({ error: "API route not found", pathname: pathname2 }));
             return;
           }
-          if (req.url?.startsWith("/@") || req.url?.startsWith("/node_modules") || requestPathname.includes(".") && !requestPathname.endsWith(".html")) {
+          if (req.url?.startsWith("/@") || req.url?.startsWith("/node_modules")) {
             return next();
           }
+          if (requestPathname.includes(".") && !requestPathname.endsWith(".html")) {
+            const matchesAppRoute = Boolean(
+              farmApp?.getRouteManager()?.matchRoute(requestPathname)?.route
+            );
+            if (!matchesAppRoute || devServableFileExists(requestPathname, [server.config.publicDir, server.config.root])) {
+              return next();
+            }
+          }
           if (req.url?.startsWith("/__farm/page-data")) {
             const urlObj = new URL(req.url, `http://${req.headers.host || "localhost:3000"}`);
             const targetPath = urlObj.searchParams.get("path") || "/";
@@ -29848,8 +30181,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path25.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path25.join(outDir, "client");
+        const outDir = path26.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path26.join(outDir, "client");
         for (const page2 of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page2.urlPath, "http://farm.static"));
@@ -29901,9 +30234,9 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page2.urlPath === "/" ? path25.join(clientDir, "index.html") : path25.join(clientDir, page2.urlPath + ".html");
-              fs7.mkdirSync(path25.dirname(outputPath), { recursive: true });
-              fs7.writeFileSync(outputPath, fullHtml);
+              const outputPath = page2.urlPath === "/" ? path26.join(clientDir, "index.html") : path26.join(clientDir, page2.urlPath + ".html");
+              fs8.mkdirSync(path26.dirname(outputPath), { recursive: true });
+              fs8.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page2.revalidate ? ` (revalidate: ${page2.revalidate}s)` : "";
               logger.success(`  \u2713 ${page2.urlPath}${revalidateInfo}`);
             });
@@ -29911,8 +30244,8 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page2.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path25.join(outDir, "__ssg_manifest.json");
-        fs7.writeFileSync(
+        const manifestPath = path26.join(outDir, "__ssg_manifest.json");
+        fs8.writeFileSync(
           manifestPath,
           JSON.stringify(
             ssgPages.map((p) => ({
@@ -29947,9 +30280,9 @@ if (import.meta.hot) {
       }
       const currentFarmConfig = farmApp?.getConfig();
       const normalizedFile = file.replace(/\\/g, "/");
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path25.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path26.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path25.basename(file)}`);
+        logUpdate("PAGE", `updated ${path26.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -31129,6 +31462,19 @@ async function tryHydrateImportedPage(
     const PageComponent = pageModule?.default;
     if (!PageComponent) return false;
 
+    if (
+      typeof PageComponent === 'function' &&
+      PageComponent.constructor &&
+      PageComponent.constructor.name === 'AsyncFunction'
+    ) {
+      console.warn(
+        '[Farm.js] Skipping hydration for ' + modulePath +
+        ': async server components cannot run in the browser. ' +
+        'Server-rendered HTML is preserved; move interactive UI into a "use client" child of a synchronous page.'
+      );
+      return false;
+    }
+
     currentPageComponent = PageComponent;
     currentPageProps = await buildRouteComponentProps(
       pageModule,
@@ -31295,14 +31641,22 @@ async function renderPage(pageData) {
     if (!doc.documentElement || !doc.body) return false;
 
     resetReactRoots();
+    const activeFarmTheme =
+      window.__FARM_THEME__?.snapshot?.resolvedTheme ||
+      document.documentElement.getAttribute('data-theme');
     Array.from(document.documentElement.attributes).forEach(function(attr) {
+      if (attr.name === 'data-theme') return;
       if (!doc.documentElement.hasAttribute(attr.name)) {
         document.documentElement.removeAttribute(attr.name);
       }
     });
     Array.from(doc.documentElement.attributes).forEach(function(attr) {
+      if (attr.name === 'data-theme') return;
       document.documentElement.setAttribute(attr.name, attr.value);
     });
+    if (activeFarmTheme) {
+      document.documentElement.setAttribute('data-theme', activeFarmTheme);
+    }
 
     document.head.innerHTML = doc.head ? doc.head.innerHTML : '';
     document.body.innerHTML = doc.body.innerHTML;
@@ -31311,6 +31665,7 @@ async function renderPage(pageData) {
 
     setTimeout(function() {
       Array.from(document.querySelectorAll('script')).forEach(function(script) {
+        if (script.id === 'farm-theme-script') return;
         const freshScript = document.createElement('script');
         Array.from(script.attributes).forEach(function(attr) {
           freshScript.setAttribute(attr.name, attr.value);
@@ -31670,7 +32025,7 @@ function generateClientManifest(bundle) {
 }
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path25.resolve(config.root || process.cwd());
+  const appRoot = path26.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, {
@@ -31805,6 +32160,7 @@ async function defineConfig2(config = {}) {
   };
   return {
     plugins: [
+      createFarmThemeCssPlugin(config.theme, config.basePath),
       tailwindcss(),
       viteBrowserExternalPlugin,
       farmI18nClientBridgePlugin(),
@@ -31876,8 +32232,8 @@ async function defineConfig2(config = {}) {
     }
   };
 }
-var fs7, path25, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
-var init_vite = __esm({
+var fs8, path26, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
+var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
     init_app();
@@ -31895,13 +32251,14 @@ var init_vite = __esm({
     init_integrations();
     init_route_context();
     init_devtools_config();
-    fs7 = __toESM(require("fs"));
-    path25 = __toESM(require("path"));
+    fs8 = __toESM(require("fs"));
+    path26 = __toESM(require("path"));
     init_layers();
     init_environment_vite();
     init_version();
     init_deferred();
     init_after();
+    init_dev_static();
     init_deployment();
     init_image_config();
     init_image_vite();
@@ -31914,6 +32271,7 @@ var init_vite = __esm({
     init_fonts();
     init_server_http();
     init_cli_colors();
+    init_vite();
     ALL_TYPE_ARTIFACTS = {
       routes: true,
       api: true,
@@ -32013,7 +32371,7 @@ var init_plugin = __esm({
     init_env();
     init_request_context();
     init_plugin_integration_context();
-    init_vite();
+    init_vite2();
     _FarmRuntimeShutdownError = class _FarmRuntimeShutdownError extends Error {
       constructor(message, errors) {
         super(message);
@@ -33577,6 +33935,7 @@ __export(src_exports, {
   getServerActionInvalidations: () => getServerActionInvalidations,
   getServerActionSignal: () => getServerActionSignal,
   getStorage: () => getStorage,
+  getTheme: () => getTheme2,
   globFiles: () => globFiles,
   hasFarmRouteRuntimeControls: () => hasFarmRouteRuntimeControls,
   hasISR: () => hasISR,
@@ -33693,6 +34052,7 @@ __export(src_exports, {
   resolveFarmLayoutFonts: () => resolveFarmLayoutFonts,
   resolveFarmRouteRuleRuntimeConfig: () => resolveFarmRouteRuleRuntimeConfig,
   resolveFarmRouteRuntimeConfig: () => resolveFarmRouteRuntimeConfig,
+  resolveFarmThemeConfig: () => resolveFarmThemeConfig,
   resolveIntegrationOrmRuntimeClient: () => resolveIntegrationOrmRuntimeClient,
   resolveIntegrationPlugins: () => resolveIntegrationPlugins,
   resolveMarkdownConfig: () => resolveMarkdownConfig,
@@ -33719,12 +34079,14 @@ __export(src_exports, {
   segmentsToPattern: () => segmentsToPattern,
   serverEnv: () => serverEnv,
   setEnv: () => setEnv,
+  setTheme: () => setTheme,
   snapshotDeferredData: () => snapshotDeferredData,
   sqliteStorage: () => sqliteStorage,
   storageCacheAdapter: () => storageCacheAdapter,
   titleFromMarkdown: () => titleFromMarkdown,
   toFormData: () => toFormData,
   toViteModuleId: () => toViteModuleId,
+  toggleTheme: () => toggleTheme,
   unstable_cache: () => unstable_cache,
   unwrapMiddleware: () => unwrapMiddleware,
   updateTag: () => updateTag,
@@ -33740,6 +34102,7 @@ __export(src_exports, {
   useSearchParams: () => useSearchParams,
   useServerFn: () => useServerFn,
   useServerQuery: () => useServerQuery,
+  useTheme: () => useTheme,
   validateServerActionRequest: () => validateServerActionRequest,
   vercelBlobStorage: () => vercelBlobStorage,
   vercelKVStorage: () => vercelKVStorage,
@@ -33769,7 +34132,7 @@ __name(FarmProvider, "FarmProvider");
 // src/index.ts
 init_request();
 init_plugin();
-init_config2();
+init_config3();
 init_layers();
 
 // src/hmr.ts
@@ -35020,8 +35383,8 @@ function createAPIClient(options = {}) {
   const inflightState = /* @__PURE__ */ new Map();
   const routeMeta = /* @__PURE__ */ new WeakMap();
   let requestCounter = 0;
-  const fetchClient = /* @__PURE__ */ __name(async (path32, requestOptions = {}) => {
-    const url = new URL(path32, baseURL);
+  const fetchClient = /* @__PURE__ */ __name(async (path33, requestOptions = {}) => {
+    const url = new URL(path33, baseURL);
     if (requestOptions.query) {
       Object.entries(requestOptions.query).forEach(([key, value]) => {
         if (value !== void 0 && value !== null) {
@@ -35056,7 +35419,7 @@ function createAPIClient(options = {}) {
     }
     return { response, data };
   }, "fetchClient");
-  const request = /* @__PURE__ */ __name(async (path32, method, input = {}, clientOptions) => {
+  const request = /* @__PURE__ */ __name(async (path33, method, input = {}, clientOptions) => {
     const methodUpper = method.toUpperCase();
     const requestId = `${Date.now()}-${++requestCounter}`;
     const cacheOptions = clientOptions?.cache ? {
@@ -35065,7 +35428,7 @@ function createAPIClient(options = {}) {
     } : void 0;
     const configuredCacheKey = clientOptions?.key ?? cacheOptions?.key;
     const cacheKey = normalizeFarmClientCacheKey(
-      configuredCacheKey ?? buildCacheKey(methodUpper, path32, input, baseURL)
+      configuredCacheKey ?? buildCacheKey(methodUpper, path33, input, baseURL)
     );
     const now2 = Date.now();
     const emitStatus = /* @__PURE__ */ __name((phase, payload) => {
@@ -35147,13 +35510,13 @@ function createAPIClient(options = {}) {
             requestId,
             method: methodUpper,
             key: cacheKey,
-            path: path32,
+            path: path33,
             input,
             attempt,
             timestamp: Date.now()
           });
           try {
-            const { response, data } = await fetchClient(path32, {
+            const { response, data } = await fetchClient(path33, {
               ...input,
               method: methodUpper
             });
@@ -35162,7 +35525,7 @@ function createAPIClient(options = {}) {
               requestId,
               method: methodUpper,
               key: cacheKey,
-              path: path32,
+              path: path33,
               input,
               attempt,
               timestamp: Date.now(),
@@ -35185,7 +35548,7 @@ function createAPIClient(options = {}) {
               requestId,
               method: methodUpper,
               key: cacheKey,
-              path: path32,
+              path: path33,
               input,
               attempt,
               timestamp: Date.now(),
@@ -35200,7 +35563,7 @@ function createAPIClient(options = {}) {
           attempt += 1;
           const delay2 = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
           if (delay2 > 0) {
-            await new Promise((resolve6) => setTimeout(resolve6, delay2));
+            await new Promise((resolve7) => setTimeout(resolve7, delay2));
           }
         }
       })();
@@ -35290,17 +35653,17 @@ function createAPIClient(options = {}) {
   );
 }
 __name(createAPIClient, "createAPIClient");
-function createNestedProxy(path32, client, routeMeta, baseURL, sameOrigin, rootAliases) {
+function createNestedProxy(path33, client, routeMeta, baseURL, sameOrigin, rootAliases) {
   const target = /* @__PURE__ */ __name(() => {
   }, "target");
   const proxy = new Proxy(target, {
     // When accessing a property (api.hello)
     get(_target, prop) {
       if (prop === FARM_API_ROUTE_REF_SYMBOL) {
-        return path32.length > 0;
+        return path33.length > 0;
       }
       if (prop === FARM_API_ROUTE_META_SYMBOL) {
-        const metadata = resolveRouteMeta({ path: path32, baseURL });
+        const metadata = resolveRouteMeta({ path: path33, baseURL });
         return Object.freeze({
           path: metadata.routePath,
           method: metadata.method,
@@ -35308,14 +35671,14 @@ function createNestedProxy(path32, client, routeMeta, baseURL, sameOrigin, rootA
           sameOrigin
         });
       }
-      if (path32.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
+      if (path33.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
         return rootAliases[prop];
       }
       if (typeof prop !== "string") {
         return Reflect.get(_target, prop);
       }
       return createNestedProxy(
-        [...path32, prop],
+        [...path33, prop],
         client,
         routeMeta,
         baseURL,
@@ -35325,21 +35688,21 @@ function createNestedProxy(path32, client, routeMeta, baseURL, sameOrigin, rootA
     },
     // When calling as a function
     apply(_target, _thisArg, args) {
-      const lastPart = path32[path32.length - 1];
+      const lastPart = path33[path33.length - 1];
       const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
       if (httpMethods.includes(lastPart)) {
-        const routePath = "/api/" + path32.slice(0, -1).join("/");
+        const routePath = "/api/" + path33.slice(0, -1).join("/");
         const method = lastPart.toUpperCase();
         const [options, clientOptions] = args;
         return client(routePath, method, options, clientOptions);
       } else {
-        const routePath = "/api/" + path32.join("/");
+        const routePath = "/api/" + path33.join("/");
         const [options, clientOptions] = args;
         return client(routePath, options?.method || "GET", options, clientOptions);
       }
     }
   });
-  routeMeta.set(proxy, { path: [...path32], baseURL });
+  routeMeta.set(proxy, { path: [...path33], baseURL });
   return proxy;
 }
 __name(createNestedProxy, "createNestedProxy");
@@ -35379,9 +35742,9 @@ function createServerAPIClient(endpoints, options = {}) {
   return endpoints;
 }
 __name(createServerAPIClient, "createServerAPIClient");
-function buildCacheKey(method, path32, input, baseURL) {
+function buildCacheKey(method, path33, input, baseURL) {
   const keyInput = input && typeof input === "object" ? { query: input.query, body: input.body } : input;
-  const url = new URL(path32, baseURL);
+  const url = new URL(path33, baseURL);
   return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
 }
 __name(buildCacheKey, "buildCacheKey");
@@ -35610,18 +35973,18 @@ function farmApiPlugin(options = {}) {
     enforce: "pre",
     configureServer(server) {
       const discoverFileRoutes = /* @__PURE__ */ __name(async (apiDir) => {
-        const fs9 = await import("fs");
-        const path32 = await import("path");
-        if (!fs9.existsSync(apiDir)) {
+        const fs10 = await import("fs");
+        const path33 = await import("path");
+        if (!fs10.existsSync(apiDir)) {
           log("No api directory found");
           return;
         }
         const findRouteFiles = /* @__PURE__ */ __name((dir) => {
           const files = [];
-          if (!fs9.existsSync(dir)) return files;
-          const entries = fs9.readdirSync(dir, { withFileTypes: true });
+          if (!fs10.existsSync(dir)) return files;
+          const entries = fs10.readdirSync(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path32.join(dir, entry.name);
+            const fullPath = path33.join(dir, entry.name);
             if (entry.isDirectory()) {
               files.push(...findRouteFiles(fullPath));
             } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
@@ -35634,7 +35997,7 @@ function farmApiPlugin(options = {}) {
         apiRoutesCache.clear();
         for (const filePath of routeFiles) {
           try {
-            const relativePath2 = path32.relative(apiDir, path32.dirname(filePath));
+            const relativePath2 = path33.relative(apiDir, path33.dirname(filePath));
             const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
             const routeModule = await server.ssrLoadModule(filePath);
             const endpoints = {};
@@ -35660,15 +36023,15 @@ function farmApiPlugin(options = {}) {
         }
       }, "discoverFileRoutes");
       const discoverRootRoutes = /* @__PURE__ */ __name(async () => {
-        const fs9 = await import("fs");
-        const path32 = await import("path");
+        const fs10 = await import("fs");
+        const path33 = await import("path");
         const routesFiles = [
-          path32.join(server.config.root, srcDir, "routes.ts"),
-          path32.join(server.config.root, srcDir, "routes.tsx"),
-          path32.join(server.config.root, srcDir, "routes.js")
+          path33.join(server.config.root, srcDir, "routes.ts"),
+          path33.join(server.config.root, srcDir, "routes.tsx"),
+          path33.join(server.config.root, srcDir, "routes.js")
         ];
         for (const routesFile of routesFiles) {
-          if (fs9.existsSync(routesFile)) {
+          if (fs10.existsSync(routesFile)) {
             try {
               const routesModule = await server.ssrLoadModule(routesFile);
               for (const [exportName, exportValue] of Object.entries(routesModule)) {
@@ -35688,8 +36051,8 @@ function farmApiPlugin(options = {}) {
         }
       }, "discoverRootRoutes");
       const discoverProgrammaticRoutes = /* @__PURE__ */ __name(async () => {
-        const path32 = await import("path");
-        const srcRoot = path32.join(server.config.root, srcDir);
+        const path33 = await import("path");
+        const srcRoot = path33.join(server.config.root, srcDir);
         const routeFiles = findProgrammaticRouteFilesInDir(srcRoot);
         for (const routeFile of routeFiles) {
           try {
@@ -35713,8 +36076,8 @@ function farmApiPlugin(options = {}) {
         }
       }, "discoverProgrammaticRoutes");
       const initializeDiscovery = /* @__PURE__ */ __name(async () => {
-        const path32 = await import("path");
-        const apiDir = path32.join(server.config.root, srcDir, "api");
+        const path33 = await import("path");
+        const apiDir = path33.join(server.config.root, srcDir, "api");
         log(`Discovering API routes in: ${apiDir}`);
         await discoverFileRoutes(apiDir);
         await discoverRootRoutes();
@@ -35882,9 +36245,9 @@ function farmApiPlugin(options = {}) {
           }
         } else {
           try {
-            const path32 = await import("path");
-            const apiDir = path32.join(server.config.root, srcDir, "api");
-            const relativePath2 = path32.relative(apiDir, path32.dirname(file));
+            const path33 = await import("path");
+            const apiDir = path33.join(server.config.root, srcDir, "api");
+            const relativePath2 = path33.relative(apiDir, path33.dirname(file));
             const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
             const routeModule = await server.ssrLoadModule(file);
             const endpoints = {};
@@ -36325,8 +36688,8 @@ var _MiddlewareChainImpl = class _MiddlewareChainImpl {
   /**
    * Set the base path for this middleware chain (called by manager when loading)
    */
-  setBasePath(path32) {
-    this.basePath = path32 === "/" ? "/" : path32.endsWith("/") ? path32.slice(0, -1) : path32;
+  setBasePath(path33) {
+    this.basePath = path33 === "/" ? "/" : path33.endsWith("/") ? path33.slice(0, -1) : path33;
   }
   use(fn) {
     this.handlers.push(fn);
@@ -37292,6 +37655,9 @@ init_cron();
 init_env();
 init_env_types();
 
+// src/theme/index.ts
+init_config2();
+
 // src/environment.ts
 var _FarmEnvironmentError = class _FarmEnvironmentError extends Error {
   constructor(api3, expected, actual) {
@@ -38000,12 +38366,12 @@ function useServerQuery(query, input, options = {}) {
   const mountedKeyRef = (0, import_react9.useRef)(void 0);
   inputRef.current = input;
   optionsRef.current = options;
-  const subscribe = (0, import_react9.useCallback)(
+  const subscribe2 = (0, import_react9.useCallback)(
     (listener) => cache.subscribe(key, listener),
     [cache, key]
   );
   const getSnapshot = (0, import_react9.useCallback)(() => cache.get(key), [cache, key]);
-  const entry = (0, import_react9.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
+  const entry = (0, import_react9.useSyncExternalStore)(subscribe2, getSnapshot, () => void 0);
   const run = (0, import_react9.useCallback)(
     (force = false) => fetchServerQuery(query, inputRef.current, {
       ...optionsRef.current,
@@ -38131,7 +38497,7 @@ init_deployment();
 init_generate_route_types();
 
 // src/build/index.ts
-init_config2();
+init_config3();
 var import_path14 = __toESM(require("path"));
 init_utils();
 init_app();
@@ -38139,7 +38505,7 @@ init_route_manager2();
 init_layers();
 
 // src/nitro/universal-build.ts
-init_config2();
+init_config3();
 init_client_plugin_build();
 var import_os = __toESM(require("os"));
 var import_path12 = __toESM(require("path"));
@@ -38213,10 +38579,10 @@ async function createFarmRouteRuntimeManifest(options) {
 }
 __name(createFarmRouteRuntimeManifest, "createFarmRouteRuntimeManifest");
 async function writeFarmRouteRuntimeManifest(directory, manifest) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const manifestPath = import_path10.default.join(directory, FARM_ROUTE_RUNTIME_MANIFEST);
-  await fs9.mkdir(directory, { recursive: true });
-  await fs9.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await fs10.mkdir(directory, { recursive: true });
+  await fs10.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return manifestPath;
 }
@@ -38262,7 +38628,7 @@ __name(normalizeManifestSource, "normalizeManifestSource");
 // src/nitro/vercel-route-runtime.ts
 var import_path11 = __toESM(require("path"));
 init_route_runtime();
-async function createFarmVercelRouteRuntimeFunctions(outputDir, manifest, fs9) {
+async function createFarmVercelRouteRuntimeFunctions(outputDir, manifest, fs10) {
   const dynamicRoutes = manifest.routes.filter(
     (route2) => route2.rendering === "dynamic" && route2.runtime !== "edge"
   );
@@ -38293,8 +38659,8 @@ async function createFarmVercelRouteRuntimeFunctions(outputDir, manifest, fs9) {
     groupIndex += 1;
     const functionName = `__farm_runtime_${groupIndex}`;
     const functionDir = import_path11.default.join(functionsDir, `${functionName}.func`);
-    await fs9.cp(baseFunctionDir, functionDir, { recursive: true, force: true });
-    await configureVercelFunction(functionDir, group.config, fs9);
+    await fs10.cp(baseFunctionDir, functionDir, { recursive: true, force: true });
+    await configureVercelFunction(functionDir, group.config, fs10);
     destinations.set(key, `/${functionName}`);
   }
   const routes = [];
@@ -38341,15 +38707,15 @@ function farmRoutePatternToVercelSource(pattern) {
   return source || "/";
 }
 __name(farmRoutePatternToVercelSource, "farmRoutePatternToVercelSource");
-async function configureVercelFunction(functionDir, config, fs9) {
+async function configureVercelFunction(functionDir, config, fs10) {
   const configPath = import_path11.default.join(functionDir, ".vc-config.json");
-  const current = JSON.parse(await fs9.readFile(configPath, "utf8"));
+  const current = JSON.parse(await fs10.readFile(configPath, "utf8"));
   const next = {
     ...current,
     ...config.regions?.length ? { regions: config.regions } : {},
     ...config.maxDuration ? { maxDuration: config.maxDuration } : {}
   };
-  await fs9.writeFile(configPath, `${JSON.stringify(next, null, 2)}
+  await fs10.writeFile(configPath, `${JSON.stringify(next, null, 2)}
 `);
 }
 __name(configureVercelFunction, "configureVercelFunction");
@@ -38675,6 +39041,7 @@ __name(withVite5TransformContext, "withVite5TransformContext");
 init_font_vite();
 init_vite_config();
 init_not_found();
+init_vite();
 var import_meta = {};
 function preloadFarmNitroRuntime() {
   return import("nitro").then(
@@ -38990,7 +39357,7 @@ function hasProjectPostcssConfig(root) {
 }
 __name(hasProjectPostcssConfig, "hasProjectPostcssConfig");
 async function findFarmConfigPath(root) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const candidates = [
     "farm.config.ts",
     "farm.config.mts",
@@ -39004,7 +39371,7 @@ async function findFarmConfigPath(root) {
   for (const candidate of candidates) {
     const resolvedPath = import_path12.default.join(root, candidate);
     try {
-      await fs9.access(resolvedPath);
+      await fs10.access(resolvedPath);
       return resolvedPath;
     } catch {
     }
@@ -39031,13 +39398,13 @@ function hasFarmServerRuntimePlugins(config) {
 }
 __name(hasFarmServerRuntimePlugins, "hasFarmServerRuntimePlugins");
 async function discoverMiddlewareRoutes(appDir) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
   const routes = /* @__PURE__ */ new Map();
   async function walk(dir, routePath, discovered) {
     let entries;
     try {
-      entries = await fs9.readdir(dir, { withFileTypes: true });
+      entries = await fs10.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -39118,12 +39485,12 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
       })
     );
     logger.info(`\u{1F4CB} Found ${pageRoutes.length} page routes`);
-    const fs9 = await import("fs/promises");
+    const fs10 = await import("fs/promises");
     const layoutRoutes = [];
     const appDir = import_path12.default.join(root, srcDir, "app");
     async function findLayoutsForClient(dir, routePrefix = "/") {
       try {
-        const entries = await fs9.readdir(dir, { withFileTypes: true });
+        const entries = await fs10.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile() && entry.name.match(/^layout\.(tsx?|jsx?)$/)) {
             layoutRoutes.push({
@@ -39257,7 +39624,7 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
 }
 __name(buildUniversal, "buildUniversal");
 async function writeSSRAssetsToClient(bundle, outputDir) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   for (const [fileName, output] of Object.entries(bundle)) {
     if (output.type !== "asset") continue;
     if (fileName === "farm-fonts.css") {
@@ -39265,29 +39632,29 @@ async function writeSSRAssetsToClient(bundle, outputDir) {
       continue;
     }
     const filePath = import_path12.default.join(outputDir, fileName);
-    await fs9.mkdir(import_path12.default.dirname(filePath), { recursive: true });
-    await fs9.writeFile(filePath, output.source);
+    await fs10.mkdir(import_path12.default.dirname(filePath), { recursive: true });
+    await fs10.writeFile(filePath, output.source);
   }
 }
 __name(writeSSRAssetsToClient, "writeSSRAssetsToClient");
 async function copyFarmDocsFontAssetsToClient(root, outputDir) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   await Promise.all(
     resolveFarmDocsFontAssets(root).map(async ({ sourcePath, url }) => {
       const targetPath = import_path12.default.join(outputDir, url.replace(/^\/+/, ""));
-      await fs9.mkdir(import_path12.default.dirname(targetPath), { recursive: true });
-      await fs9.copyFile(sourcePath, targetPath);
+      await fs10.mkdir(import_path12.default.dirname(targetPath), { recursive: true });
+      await fs10.copyFile(sourcePath, targetPath);
     })
   );
 }
 __name(copyFarmDocsFontAssetsToClient, "copyFarmDocsFontAssetsToClient");
 async function mergeBuiltFontCss(outputDir, fontCssSource) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const fontCssPath = import_path12.default.join(outputDir, "farm-fonts.css");
   let fontCss = fontCssSource;
   if (fontCss === void 0) {
     try {
-      fontCss = await fs9.readFile(fontCssPath);
+      fontCss = await fs10.readFile(fontCssPath);
     } catch {
       return;
     }
@@ -39295,12 +39662,12 @@ async function mergeBuiltFontCss(outputDir, fontCssSource) {
   const clientCssPath = import_path12.default.join(outputDir, "farm-client.css");
   let clientCss = "";
   try {
-    clientCss = await fs9.readFile(clientCssPath, "utf8");
+    clientCss = await fs10.readFile(clientCssPath, "utf8");
   } catch {
   }
   const normalizedFontCss = typeof fontCss === "string" ? fontCss : Buffer.from(fontCss).toString("utf8");
-  await fs9.writeFile(fontCssPath, normalizedFontCss);
-  await fs9.writeFile(clientCssPath, mergeFarmFontCss(clientCss, normalizedFontCss));
+  await fs10.writeFile(fontCssPath, normalizedFontCss);
+  await fs10.writeFile(clientCssPath, mergeFarmFontCss(clientCss, normalizedFontCss));
 }
 __name(mergeBuiltFontCss, "mergeBuiltFontCss");
 var _IncompleteClientBuildOutputError = class _IncompleteClientBuildOutputError extends Error {
@@ -39312,11 +39679,11 @@ var _IncompleteClientBuildOutputError = class _IncompleteClientBuildOutputError
 __name(_IncompleteClientBuildOutputError, "IncompleteClientBuildOutputError");
 var IncompleteClientBuildOutputError = _IncompleteClientBuildOutputError;
 async function validateClientBuildOutput(root, srcDir, outputDir) {
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const clientEntryPath = import_path12.default.join(outputDir, "farm-client.js");
   let clientEntrySize = 0;
   try {
-    const clientEntry = await fs9.stat(clientEntryPath);
+    const clientEntry = await fs10.stat(clientEntryPath);
     if (clientEntry.isFile()) clientEntrySize = clientEntry.size;
   } catch {
   }
@@ -39327,12 +39694,12 @@ async function validateClientBuildOutput(root, srcDir, outputDir) {
   const globalsCssPath = import_path12.default.join(root, srcDir, "app", "globals.css");
   let expectsCss = false;
   try {
-    const globalsCss = await fs9.readFile(globalsCssPath, "utf8");
+    const globalsCss = await fs10.readFile(globalsCssPath, "utf8");
     expectsCss = globalsCss.replace(/\/\*[\s\S]*?\*\//g, "").trim().length > 0;
   } catch {
   }
   try {
-    const clientCss = await fs9.stat(clientCssPath);
+    const clientCss = await fs10.stat(clientCssPath);
     if (expectsCss && (!clientCss.isFile() || clientCss.size === 0)) {
       throw new IncompleteClientBuildOutputError("farm-client.css is empty");
     }
@@ -39341,15 +39708,15 @@ async function validateClientBuildOutput(root, srcDir, outputDir) {
     if (expectsCss) {
       throw new IncompleteClientBuildOutputError("farm-client.css is missing");
     }
-    await fs9.writeFile(clientCssPath, "");
+    await fs10.writeFile(clientCssPath, "");
   }
 }
 __name(validateClientBuildOutput, "validateClientBuildOutput");
 async function buildClient(productionVite, config, root, srcDir, outputDir, pageRoutes, layoutRoutes = [], routeSlots = []) {
   const viteBuild = productionVite.build;
-  const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
+  const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const pluginManager = new PluginManager2({
     config,
     isDev: false,
@@ -39385,6 +39752,11 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
       const applicableClientLayouts = clientLayouts.filter(
         (layout2) => layout2.shouldHydrate && layoutAppliesToRoute(layout2.pattern, route2.pattern)
       );
+      if (metadata.suppressedAsyncHydration) {
+        logger.warn(
+          `\u26A0\uFE0F  ${route2.pattern} is an async server component that imports client components; React cannot hydrate async components, so the route stays server-rendered and its client imports are not interactive.`
+        );
+      }
       if (metadata.shouldHydrate || applicableClientLayouts.length > 0) {
         const relativePath2 = route2.modulePath.replace(root, "").replace(/^\//, "");
         const hydrationStrategies = [
@@ -39443,8 +39815,8 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     `\u{1F4F1} Total hydratable routes detected: ${clientPages.length} pages, ${clientLayouts.filter((layout2) => layout2.shouldHydrate).length} layouts, and ${clientRouteSlots.length} slots`
   );
   const clientEntryRoot = import_path12.default.join(root, ".farm", "tmp");
-  await fs9.mkdir(clientEntryRoot, { recursive: true });
-  const clientEntryDir = await fs9.mkdtemp(import_path12.default.join(clientEntryRoot, "client-entry-"));
+  await fs10.mkdir(clientEntryRoot, { recursive: true });
+  const clientEntryDir = await fs10.mkdtemp(import_path12.default.join(clientEntryRoot, "client-entry-"));
   const clientEntryPath = import_path12.default.join(clientEntryDir, "farm-client-entry.tsx");
   const clientHydrationCode = generateClientHydrationEntry(
     clientPages,
@@ -39458,7 +39830,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     config.i18n,
     config.plugins
   );
-  await fs9.writeFile(clientEntryPath, clientHydrationCode);
+  await fs10.writeFile(clientEntryPath, clientHydrationCode);
   const hasScopedPostcssConfig = hasProjectPostcssConfig(root);
   let postcssSearchPath;
   let tailwindVitePlugin = void 0;
@@ -39466,7 +39838,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     logger.info("\u{1F4E6} Using project PostCSS/Tailwind configuration");
   } else {
     const postcssConfigPath = import_path12.default.join(clientEntryDir, "postcss.config.cjs");
-    await fs9.writeFile(postcssConfigPath, "module.exports = { plugins: [] };\n");
+    await fs10.writeFile(postcssConfigPath, "module.exports = { plugins: [] };\n");
     postcssSearchPath = clientEntryDir;
     try {
       const tailwindVite = (await import("@tailwindcss/vite")).default;
@@ -39539,6 +39911,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
         }
       },
       plugins: [
+        createFarmThemeCssPlugin(config.theme, config.basePath),
         ...tailwindVitePlugin ? [tailwindVitePlugin] : [],
         // Plugin to redirect @farm.js/core imports to client-only exports
         {
@@ -39610,7 +39983,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     await validateClientBuildOutput(root, srcDir, outputDir);
   } finally {
     try {
-      await fs9.rm(clientEntryDir, { recursive: true, force: true });
+      await fs10.rm(clientEntryDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -40261,6 +40634,13 @@ async function createMatchedHydrationElement(matched, pathname, searchParams) {
   if (matched.route.pageShouldHydrate) {
     const Component = await loadRouteComponent(matched.route);
     if (!Component) return null;
+    if (typeof Component === "function" && Component.constructor && Component.constructor.name === "AsyncFunction") {
+      console.warn(
+        "[Farm.js] Skipping hydration for " + pathname +
+        ": async server components cannot run in the browser. Server-rendered HTML is preserved."
+      );
+      return null;
+    }
     const props = { params: params, searchParams: Promise.resolve(searchParams) };
     pageElement = React.createElement(Component, props);
   } else if (hydrateLayouts) {
@@ -40916,9 +41296,9 @@ void hydrate();
 __name(generateClientHydrationEntry, "generateClientHydrationEntry");
 async function buildSSRInMemory(productionVite, config, root, routeManager, apiRouteManager, serverRenderer, preset, collectedPageRoutes, collectedLayoutRoutes, collectedRouteSlots) {
   const viteBuild = productionVite.build;
-  const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
+  const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
-  const fs9 = await import("fs/promises");
+  const fs10 = await import("fs/promises");
   const pluginManager = new PluginManager2({
     config,
     isDev: false,
@@ -40929,8 +41309,8 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   let postcssConfigDir;
   let tailwindVitePlugin = void 0;
   if (!hasScopedPostcssConfig) {
-    postcssConfigDir = await fs9.mkdtemp(import_path12.default.join(import_os.default.tmpdir(), "farm-postcss-"));
-    await fs9.writeFile(
+    postcssConfigDir = await fs10.mkdtemp(import_path12.default.join(import_os.default.tmpdir(), "farm-postcss-"));
+    await fs10.writeFile(
       import_path12.default.join(postcssConfigDir, "postcss.config.cjs"),
       "module.exports = { plugins: [] };\n"
     );
@@ -40960,7 +41340,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         fileName: entry.fileName,
         sourceType: "static",
         staticInfo: entry.staticInfo,
-        data: (await fs9.readFile(entry.modulePath)).toString("base64")
+        data: (await fs10.readFile(entry.modulePath)).toString("base64")
       });
       continue;
     }
@@ -41010,7 +41390,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     for (const ext of notFoundExtensions) {
       const checkPath = import_path12.default.join(sourceAppDir, `not-found${ext}`);
       try {
-        await fs9.access(checkPath);
+        await fs10.access(checkPath);
         notFoundPath = checkPath;
         break;
       } catch {
@@ -41157,6 +41537,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
       },
       plugins: [
+        createFarmThemeCssPlugin(config.theme, config.basePath),
         ...tailwindVitePlugin ? [tailwindVitePlugin] : [],
         ...!useExternalMetadataImageRuntime && metadataImageRoutes.some((image) => image.sourceType === "module") ? [createMetadataImageWasmPlugin()] : [],
         {
@@ -41221,7 +41602,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   } finally {
     if (postcssConfigDir) {
       try {
-        await fs9.rm(postcssConfigDir, { recursive: true, force: true });
+        await fs10.rm(postcssConfigDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -41370,15 +41751,19 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
   _runWithCurrentRequest,
   _runWithMiddlewareContext,
   _runWithMiddlewareData,
+  _setDefaultFarmThemeConfig,
   addMetadataImageReference,
+  applyFarmThemeDocument,
   appendFarmLinkHeader,
   applyProductionMiddlewareHeaders,
   configureFarmCache,
   configureFarmObservability,
   createFarmCacheKey,
+  createFarmThemeDocumentParts,
   createFarmLocaleCookie,
   createFarmProductionLifecycle,
   createProductionMiddlewareRunner,
+  getTheme as getFarmTheme,
   emitFarmEvent,
   getFarmDataCache,
   getFarmLocaleVaryHeaders,
@@ -41573,6 +41958,8 @@ configureFarmObservability(farmObservabilityConfig);
 configureFarmCache(farmResolvedRuntimeConfig.cache);
 const farmI18nConfig = ${JSON.stringify(config.i18n)};
 const farmServerConfig = ${JSON.stringify(config.server)};
+const farmThemeConfig = ${JSON.stringify(config.theme)};
+_setDefaultFarmThemeConfig(farmThemeConfig);
 export const farmProductionLifecycle = createFarmProductionLifecycle({
   server: farmServerConfig,
   start: () => farmPluginRuntime?.startRuntime(),
@@ -43409,7 +43796,13 @@ async function handleFarmRequestInContext(
           !farmI18nSnapshot &&
           !pprCacheKey
         ) {
+          const farmThemeDocument = createFarmThemeDocumentParts(
+            farmThemeConfig,
+            farmResolvedRuntimeConfig.basePath,
+            getFarmTheme(request)
+          );
           const streamPrefix = '<!DOCTYPE html>\\n<html lang="en">\\n<head>\\n' +
+            farmThemeDocument.head + '\\n' +
             '  <meta charset="utf-8">\\n' +
             '  <meta name="viewport" content="width=device-width, initial-scale=1">\\n' +
             (hasFavicon ? '' : '  <link rel="icon" href="data:,">\\n') +
@@ -43425,9 +43818,13 @@ async function handleFarmRequestInContext(
             ) + '\\n' +
             '  <script type="module" src="/farm-client.js"></script>\\n' +
             '</body>\\n</html>';
+          const themedStreamPrefix = streamPrefix.replace(
+            '<html lang="en">',
+            '<html lang="en"' + farmThemeDocument.attributes + '>'
+          );
           const streamedDocument = createFarmDocumentStream(
             renderedPage.stream,
-            streamPrefix,
+            themedStreamPrefix,
             streamSuffix,
             function() {
               if (pprBypassReason === "refresh") {
@@ -43510,6 +43907,12 @@ async function handleFarmRequestInContext(
 </html>\`;
         }
         fullHtml = applyFarmI18nDocument(fullHtml, pathname, farmI18nSnapshot);
+        fullHtml = applyFarmThemeDocument(
+          fullHtml,
+          farmThemeConfig,
+          farmResolvedRuntimeConfig.basePath,
+          getFarmTheme(request)
+        );
 
         if (pageStatus === 200 && pprCacheKey && request.method.toUpperCase() !== "HEAD") {
           await pprShellCache.setAsync(
@@ -43636,10 +44039,15 @@ async function handleFarmRequestInContext(
           const errorHtml = ${hasMiddlewareRuntime ? `await _runWithMiddlewareData(middlewareData, () =>
             _runWithMiddlewareContext(middlewareContext, renderErrorElement)
           )` : "await renderErrorElement()"};
-          const errorDocument = applyFarmI18nDocument(
-            createFarmErrorDocument(errorHtml, "Application Error"),
-            pathname,
-            getFarmI18nSnapshot()
+          const errorDocument = applyFarmThemeDocument(
+            applyFarmI18nDocument(
+              createFarmErrorDocument(errorHtml, "Application Error"),
+              pathname,
+              getFarmI18nSnapshot()
+            ),
+            farmThemeConfig,
+            farmResolvedRuntimeConfig.basePath,
+            getFarmTheme(request)
           );
           emitFarmEvent({
             type: "render.complete",
@@ -43664,10 +44072,15 @@ async function handleFarmRequestInContext(
       const errorMessage = "Internal Server Error";
       const fallbackHtml = '<main><h1>Application Error</h1><p>' +
         escapeFarmHtmlAttribute(errorMessage) + '</p></main>';
-      const fallbackDocument = applyFarmI18nDocument(
-        createFarmErrorDocument(fallbackHtml, "Application Error"),
-        pathname,
-        getFarmI18nSnapshot()
+      const fallbackDocument = applyFarmThemeDocument(
+        applyFarmI18nDocument(
+          createFarmErrorDocument(fallbackHtml, "Application Error"),
+          pathname,
+          getFarmI18nSnapshot()
+        ),
+        farmThemeConfig,
+        farmResolvedRuntimeConfig.basePath,
+        getFarmTheme(request)
       );
       return applyProductionMiddlewareHeaders(new Response(
         fallbackDocument,
@@ -43765,6 +44178,12 @@ async function handleFarmRequestInContext(
 </html>\`;
     }
     fullHtml = applyFarmI18nDocument(fullHtml, pathname, getFarmI18nSnapshot());
+    fullHtml = applyFarmThemeDocument(
+      fullHtml,
+      farmThemeConfig,
+      farmResolvedRuntimeConfig.basePath,
+      getFarmTheme(request)
+    );
     
     emitFarmEvent({
       type: "render.complete",
@@ -43783,8 +44202,14 @@ async function handleFarmRequestInContext(
     }), middlewareHeaders);
   } catch (error) {
     console.error("404 render error:", error);
-    return applyProductionMiddlewareHeaders(new Response(
+    const fallbackDocument = applyFarmThemeDocument(
       \`<!DOCTYPE html><html><head><title>404</title></head><body><h1>404 - Page Not Found</h1><p>The page \${pathname} doesn't exist.</p><a href="/">Go Home</a></body></html>\`,
+      farmThemeConfig,
+      farmResolvedRuntimeConfig.basePath,
+      getFarmTheme(request)
+    );
+    return applyProductionMiddlewareHeaders(new Response(
+      fallbackDocument,
       {
         status: 404,
         headers: { "Content-Type": "text/html", "x-farm-preload-buffered": "1" },
@@ -44072,7 +44497,7 @@ function getPhysicalPrerenderBypassReason(options) {
 }
 __name(getPhysicalPrerenderBypassReason, "getPhysicalPrerenderBypassReason");
 async function buildNitroUniversal(config, routeManager, apiRouteManager, serverRenderer, preset, root, distDir, ssrBundle, ssrEntryFile, clientOutputDir, routeRuntimeManifest, configuredHeaderRoutes, nitroRuntimeResultPromise, pluginManager) {
-  const [fs9, nitroRuntimeResult] = await Promise.all([
+  const [fs10, nitroRuntimeResult] = await Promise.all([
     import("fs/promises"),
     nitroRuntimeResultPromise
   ]);
@@ -44150,11 +44575,11 @@ async function buildNitroUniversal(config, routeManager, apiRouteManager, server
   }
   const scheduledTasks = mergeScheduledTasks(farmWorkflows.scheduledTasks, farmCron.scheduledTasks);
   const cloudflareCronConfig = createFarmCronCloudflareConfig(farmCron.jobs);
-  await fs9.mkdir(ssrOutputDir, { recursive: true });
+  await fs10.mkdir(ssrOutputDir, { recursive: true });
   for (const [fileName, output] of Object.entries(ssrBundle)) {
     const filePath = import_path12.default.join(ssrOutputDir, fileName);
-    await fs9.mkdir(import_path12.default.dirname(filePath), { recursive: true });
-    await fs9.writeFile(filePath, output.type === "chunk" ? output.code : output.source);
+    await fs10.mkdir(import_path12.default.dirname(filePath), { recursive: true });
+    await fs10.writeFile(filePath, output.type === "chunk" ? output.code : output.source);
   }
   const nitroEntryPath = import_path12.default.join(ssrOutputDir, "nitro-entry.mjs");
   const nitroEntryCode = `
@@ -44220,10 +44645,10 @@ export default async function farmNitroEventHandler(event) {
   return response
 }
   `.trim();
-  await fs9.writeFile(nitroEntryPath, nitroEntryCode);
+  await fs10.writeFile(nitroEntryPath, nitroEntryCode);
   const farmNodeServerEntryPath = preset === "node-server" ? import_path12.default.join(ssrOutputDir, "farm-node-server-entry.mjs") : null;
   if (farmNodeServerEntryPath) {
-    await fs9.writeFile(
+    await fs10.writeFile(
       farmNodeServerEntryPath,
       createFarmNodeServerEntry({
         nitroEntryFile: import_path12.default.basename(nitroEntryPath),
@@ -44423,9 +44848,9 @@ export default async function farmNitroEventHandler(event) {
           import_path12.default.join(prerenderServerDir, FARM_SSR_OUTPUT_DIR),
           {},
           false,
-          fs9
+          fs10
         );
-        await registerPrebuiltSSRPackageImport(prerenderServerDir, ssrEntryFile, fs9);
+        await registerPrebuiltSSRPackageImport(prerenderServerDir, ssrEntryFile, fs10);
       });
     });
   }
@@ -44457,17 +44882,17 @@ export default async function farmNitroEventHandler(event) {
       import_path12.default.join(outputDir, "server", FARM_SSR_OUTPUT_DIR),
       configuredEsbuildOptions,
       effectiveMinify,
-      fs9
+      fs10
     ) : Promise.resolve(),
-    imageRuntime === "node" ? copySharpRuntime(config, root, import_path12.default.join(outputDir, "server"), fs9) : Promise.resolve(),
-    useExternalMetadataImageRuntime ? copyMetadataImageRuntime(root, import_path12.default.join(outputDir, "server"), fs9) : Promise.resolve()
+    imageRuntime === "node" ? copySharpRuntime(config, root, import_path12.default.join(outputDir, "server"), fs10) : Promise.resolve(),
+    useExternalMetadataImageRuntime ? copyMetadataImageRuntime(root, import_path12.default.join(outputDir, "server"), fs10) : Promise.resolve()
   ]);
   const failedCopy = copyResults.find(
     (result) => result.status === "rejected"
   );
   if (failedCopy) throw failedCopy.reason;
   if (canReusePrebuiltSSR) {
-    await registerPrebuiltSSRPackageImport(import_path12.default.join(outputDir, "server"), ssrEntryFile, fs9);
+    await registerPrebuiltSSRPackageImport(import_path12.default.join(outputDir, "server"), ssrEntryFile, fs10);
     logger.info("\u26A1 Reused Farm's prebuilt SSR bundle for the Node output");
   }
   if (useRolldownBuilder) {
@@ -44482,12 +44907,12 @@ export default async function farmNitroEventHandler(event) {
     });
   }
   if (isVercel) {
-    await postProcessVercelOutput(root, outputDir, fs9, config, farmWorkflows, routeRuntimeManifest);
+    await postProcessVercelOutput(root, outputDir, fs10, config, farmWorkflows, routeRuntimeManifest);
   }
   logger.success(`\u2705 Nitro build completed with preset: ${preset}`);
 }
 __name(buildNitroUniversal, "buildNitroUniversal");
-async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOptions, minify, fs9) {
+async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOptions, minify, fs10) {
   const {
     include: _include,
     exclude: _exclude,
@@ -44504,13 +44929,13 @@ async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOpti
     "node18"
   );
   const transform = minify || hasConfiguredTransforms ? (await import("esbuild")).transform : null;
-  await fs9.rm(targetDir, { recursive: true, force: true });
+  await fs10.rm(targetDir, { recursive: true, force: true });
   await Promise.all(
     Object.entries(ssrBundle).map(async ([fileName, output]) => {
       const targetPath = import_path12.default.join(targetDir, fileName);
-      await fs9.mkdir(import_path12.default.dirname(targetPath), { recursive: true });
+      await fs10.mkdir(import_path12.default.dirname(targetPath), { recursive: true });
       if (output.type === "asset") {
-        await fs9.writeFile(targetPath, output.source);
+        await fs10.writeFile(targetPath, output.source);
         return;
       }
       let code = output.code;
@@ -44521,14 +44946,14 @@ async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOpti
         });
         code = result.code;
       }
-      await fs9.writeFile(targetPath, code);
+      await fs10.writeFile(targetPath, code);
     })
   );
 }
 __name(copyPrebuiltSSRBundle, "copyPrebuiltSSRBundle");
-async function registerPrebuiltSSRPackageImport(serverDir, ssrEntryFile, fs9) {
+async function registerPrebuiltSSRPackageImport(serverDir, ssrEntryFile, fs10) {
   const packagePath = import_path12.default.join(serverDir, "package.json");
-  const packageJSON = await fs9.readFile(packagePath, "utf8").then((contents) => JSON.parse(contents)).catch((error) => {
+  const packageJSON = await fs10.readFile(packagePath, "utf8").then((contents) => JSON.parse(contents)).catch((error) => {
     if (error.code === "ENOENT") return { type: "module" };
     throw error;
   });
@@ -44538,38 +44963,38 @@ async function registerPrebuiltSSRPackageImport(serverDir, ssrEntryFile, fs9) {
     ...existingImports,
     [FARM_SSR_PACKAGE_IMPORT]: `./${outputEntry}`
   };
-  await fs9.mkdir(serverDir, { recursive: true });
-  await fs9.writeFile(packagePath, `${JSON.stringify(packageJSON, null, 2)}
+  await fs10.mkdir(serverDir, { recursive: true });
+  await fs10.writeFile(packagePath, `${JSON.stringify(packageJSON, null, 2)}
 `);
 }
 __name(registerPrebuiltSSRPackageImport, "registerPrebuiltSSRPackageImport");
-async function postProcessVercelOutput(root, outputDir, fs9, config, farmWorkflows, routeRuntimeManifest) {
+async function postProcessVercelOutput(root, outputDir, fs10, config, farmWorkflows, routeRuntimeManifest) {
   const serverDir = import_path12.default.join(outputDir, "server");
   const functionsDir = import_path12.default.join(outputDir, "functions");
   const nitroFuncDir = import_path12.default.join(functionsDir, "__nitro.func");
   const staticDir = import_path12.default.join(outputDir, "static");
   const publicDir = import_path12.default.join(outputDir, "public");
-  await fs9.mkdir(nitroFuncDir, { recursive: true });
-  const serverContents = await fs9.readdir(serverDir);
+  await fs10.mkdir(nitroFuncDir, { recursive: true });
+  const serverContents = await fs10.readdir(serverDir);
   for (const file of serverContents) {
     const src = import_path12.default.join(serverDir, file);
     const dest = import_path12.default.join(nitroFuncDir, file);
-    await fs9.rename(src, dest);
+    await fs10.rename(src, dest);
   }
-  await fs9.rmdir(serverDir);
+  await fs10.rmdir(serverDir);
   try {
-    await fs9.rename(publicDir, staticDir);
+    await fs10.rename(publicDir, staticDir);
   } catch {
   }
-  await copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs9);
-  await copyPrismaClientForVercel(root, nitroFuncDir, fs9);
+  await copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs10);
+  await copyPrismaClientForVercel(root, nitroFuncDir, fs10);
   const configPath = import_path12.default.join(outputDir, "config.json");
-  const configContent = await fs9.readFile(configPath, "utf-8");
+  const configContent = await fs10.readFile(configPath, "utf-8");
   const vercelConfig = JSON.parse(configContent);
   const runtimeRoutes = await createFarmVercelRouteRuntimeFunctions(
     outputDir,
     routeRuntimeManifest,
-    fs9
+    fs10
   );
   vercelConfig.routes = [
     // Apply the header before the filesystem handler. `continue` lets Vercel
@@ -44604,24 +45029,24 @@ async function postProcessVercelOutput(root, outputDir, fs9, config, farmWorkflo
     vercelConfigWithWorkflowCrons,
     config.cron.jobs
   );
-  await fs9.writeFile(configPath, JSON.stringify(vercelConfigWithCrons, null, 2));
+  await fs10.writeFile(configPath, JSON.stringify(vercelConfigWithCrons, null, 2));
   logger.info("\u2705 Post-processed Vercel output for Build Output API v3");
 }
 __name(postProcessVercelOutput, "postProcessVercelOutput");
-async function copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs9) {
+async function copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs10) {
   const docsContentDir = resolveBuildDocsContentDir(config, root);
   if (!docsContentDir) return;
   const bundledContentDir = import_path12.default.join(nitroFuncDir, "chunks", "nitro", "farm-docs-content");
   const lastModifiedManifest = createFarmDocsLastModifiedManifest(docsContentDir, {
     fallback: "now"
   });
-  await fs9.rm(bundledContentDir, { recursive: true, force: true });
-  await fs9.mkdir(import_path12.default.dirname(bundledContentDir), { recursive: true });
-  await fs9.cp(docsContentDir, bundledContentDir, {
+  await fs10.rm(bundledContentDir, { recursive: true, force: true });
+  await fs10.mkdir(import_path12.default.dirname(bundledContentDir), { recursive: true });
+  await fs10.cp(docsContentDir, bundledContentDir, {
     recursive: true,
     force: true
   });
-  await fs9.writeFile(
+  await fs10.writeFile(
     import_path12.default.join(bundledContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST),
     `${JSON.stringify(lastModifiedManifest, null, 2)}
 `
@@ -44629,7 +45054,7 @@ async function copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs9) {
   logger.info(`\u{1F4DA} Bundled docs content for Vercel: ${import_path12.default.relative(root, docsContentDir)}`);
 }
 __name(copyFarmDocsContentForVercel, "copyFarmDocsContentForVercel");
-async function copySharpRuntime(config, root, nitroFuncDir, fs9) {
+async function copySharpRuntime(config, root, nitroFuncDir, fs10) {
   if (config.images.provider === "none") return;
   const projectRequire = (0, import_module3.createRequire)(import_path12.default.join(root, "package.json"));
   let sharpRequire = projectRequire;
@@ -44653,18 +45078,18 @@ async function copySharpRuntime(config, root, nitroFuncDir, fs9) {
   async function copyPackageOnce(packageName, parentRequire) {
     const packageJsonPath = resolvePackageJson(parentRequire, packageName);
     if (!packageJsonPath) return;
-    const packageJson = JSON.parse(await fs9.readFile(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(await fs10.readFile(packageJsonPath, "utf8"));
     const packageDir = import_path12.default.dirname(packageJsonPath);
     const targetDir = import_path12.default.join(targetNodeModules, ...packageName.split("/"));
     copiedPackages.set(packageName, String(packageJson.version || "*"));
-    await fs9.mkdir(import_path12.default.dirname(targetDir), { recursive: true });
+    await fs10.mkdir(import_path12.default.dirname(targetDir), { recursive: true });
     const packageRequire = (0, import_module3.createRequire)(packageJsonPath);
     const dependencies = {
       ...packageJson.dependencies,
       ...packageJson.optionalDependencies
     };
     await Promise.all([
-      fs9.cp(packageDir, targetDir, {
+      fs10.cp(packageDir, targetDir, {
         recursive: true,
         force: true,
         dereference: true,
@@ -44683,16 +45108,16 @@ async function copySharpRuntime(config, root, nitroFuncDir, fs9) {
     );
   }
   const functionPackagePath = import_path12.default.join(nitroFuncDir, "package.json");
-  const functionPackage = JSON.parse(await fs9.readFile(functionPackagePath, "utf8"));
+  const functionPackage = JSON.parse(await fs10.readFile(functionPackagePath, "utf8"));
   functionPackage.dependencies = {
     ...functionPackage.dependencies,
     ...Object.fromEntries([...copiedPackages].sort(([left], [right]) => left.localeCompare(right)))
   };
-  await fs9.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  await fs10.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
   logger.info(`\u{1F5BC}\uFE0F  Bundled Sharp image runtime (${copiedPackages.size} packages)`);
 }
 __name(copySharpRuntime, "copySharpRuntime");
-async function copyMetadataImageRuntime(root, nitroFuncDir, fs9) {
+async function copyMetadataImageRuntime(root, nitroFuncDir, fs10) {
   const projectRequire = (0, import_module3.createRequire)(import_path12.default.join(root, "package.json"));
   let runtimeRequire = projectRequire;
   let packageJsonPath = resolvePackageJson(runtimeRequire, "@vercel/og");
@@ -44708,23 +45133,23 @@ async function copyMetadataImageRuntime(root, nitroFuncDir, fs9) {
       "Generated metadata images require @vercel/og. Reinstall @farm.js/core with production dependencies."
     );
   }
-  const packageJson = JSON.parse(await fs9.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fs10.readFile(packageJsonPath, "utf8"));
   const packageDir = import_path12.default.dirname(packageJsonPath);
   const targetDir = import_path12.default.join(nitroFuncDir, "node_modules", "@vercel", "og");
-  await fs9.mkdir(import_path12.default.dirname(targetDir), { recursive: true });
-  await fs9.cp(packageDir, targetDir, {
+  await fs10.mkdir(import_path12.default.dirname(targetDir), { recursive: true });
+  await fs10.cp(packageDir, targetDir, {
     recursive: true,
     force: true,
     dereference: true,
     mode: import_fs5.constants.COPYFILE_FICLONE
   });
   const functionPackagePath = import_path12.default.join(nitroFuncDir, "package.json");
-  const functionPackage = JSON.parse(await fs9.readFile(functionPackagePath, "utf8"));
+  const functionPackage = JSON.parse(await fs10.readFile(functionPackagePath, "utf8"));
   functionPackage.dependencies = {
     ...functionPackage.dependencies,
     "@vercel/og": String(packageJson.version || "0.11.1")
   };
-  await fs9.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  await fs10.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
   logger.info("\u{1F5BC}\uFE0F  Bundled generated metadata image runtime");
 }
 __name(copyMetadataImageRuntime, "copyMetadataImageRuntime");
@@ -44738,7 +45163,7 @@ function resolvePackageJson(parentRequire, packageName) {
   return null;
 }
 __name(resolvePackageJson, "resolvePackageJson");
-async function copyPrismaClientForVercel(root, nitroFuncDir, fs9) {
+async function copyPrismaClientForVercel(root, nitroFuncDir, fs10) {
   const projectRequire = (0, import_module3.createRequire)(import_path12.default.join(root, "package.json"));
   let prismaClientDir;
   try {
@@ -44748,7 +45173,7 @@ async function copyPrismaClientForVercel(root, nitroFuncDir, fs9) {
   }
   const generatedClientDir = import_path12.default.join(prismaClientDir, "..", "..", ".prisma", "client");
   try {
-    await fs9.access(generatedClientDir);
+    await fs10.access(generatedClientDir);
   } catch {
     return;
   }
@@ -44756,20 +45181,20 @@ async function copyPrismaClientForVercel(root, nitroFuncDir, fs9) {
   const targetPrismaScopeDir = import_path12.default.join(targetNodeModules, "@prisma");
   const targetGeneratedDir = import_path12.default.join(targetNodeModules, ".prisma", "client");
   const targetClientDir = import_path12.default.join(targetPrismaScopeDir, "client");
-  await fs9.mkdir(targetPrismaScopeDir, { recursive: true });
-  await fs9.cp(prismaClientDir, targetClientDir, {
+  await fs10.mkdir(targetPrismaScopeDir, { recursive: true });
+  await fs10.cp(prismaClientDir, targetClientDir, {
     recursive: true,
     force: true
   });
-  await fs9.cp(generatedClientDir, targetGeneratedDir, {
+  await fs10.cp(generatedClientDir, targetGeneratedDir, {
     recursive: true,
     force: true
   });
   const functionPackagePath = import_path12.default.join(nitroFuncDir, "package.json");
   const clientPackagePath = import_path12.default.join(prismaClientDir, "package.json");
   const [functionPackageContent, clientPackageContent] = await Promise.all([
-    fs9.readFile(functionPackagePath, "utf-8"),
-    fs9.readFile(clientPackagePath, "utf-8")
+    fs10.readFile(functionPackagePath, "utf-8"),
+    fs10.readFile(clientPackagePath, "utf-8")
   ]);
   const functionPackage = JSON.parse(functionPackageContent);
   const clientPackage = JSON.parse(clientPackageContent);
@@ -44777,7 +45202,7 @@ async function copyPrismaClientForVercel(root, nitroFuncDir, fs9) {
     ...functionPackage.dependencies,
     "@prisma/client": clientPackage.version
   };
-  await fs9.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  await fs10.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
 }
 __name(copyPrismaClientForVercel, "copyPrismaClientForVercel");
 
@@ -45011,7 +45436,7 @@ async function createProjectModuleServer(createViteServer, config, root) {
 }
 __name(createProjectModuleServer, "createProjectModuleServer");
 async function buildClient2(viteBuild, config, root, srcDir, outputDir) {
-  const { farmI18nClientBridgePlugin: farmI18nClientBridgePlugin2, farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
+  const { farmI18nClientBridgePlugin: farmI18nClientBridgePlugin2, farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
   const pluginManager = new PluginManager2({
     config,
@@ -45038,7 +45463,7 @@ async function buildClient2(viteBuild, config, root, srcDir, outputDir) {
 }
 __name(buildClient2, "buildClient");
 async function buildSSR(viteBuild, config, root, srcDir, outputDir) {
-  const { farmI18nClientBridgePlugin: farmI18nClientBridgePlugin2, farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
+  const { farmI18nClientBridgePlugin: farmI18nClientBridgePlugin2, farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
   const pluginManager = new PluginManager2({
     config,
@@ -45099,10 +45524,10 @@ async function buildNitro(config, routeManager, apiRouteManager, serverRenderer,
     const manifestPath = import_path14.default.join(publicOutputDir, "farm-client-manifest.json");
     const assetsDir = import_path14.default.join(publicOutputDir, "assets");
     const manifestExists = await import("fs/promises").then(
-      (fs9) => fs9.access(manifestPath).then(() => true).catch(() => false)
+      (fs10) => fs10.access(manifestPath).then(() => true).catch(() => false)
     );
     const assetsExist = await import("fs/promises").then(
-      (fs9) => fs9.access(assetsDir).then(() => true).catch(() => false)
+      (fs10) => fs10.access(assetsDir).then(() => true).catch(() => false)
     );
     if (manifestExists && assetsExist) {
       logger.info("\u2705 Verified client assets are present");
@@ -45684,8 +46109,74 @@ function createStore(initialState, extend) {
 }
 __name(createStore, "createStore");
 
-// src/client/link.tsx
+// src/theme/client.tsx
 var import_react13 = require("react");
+init_bridge2();
+var FALLBACK_CLIENT_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: "light",
+  mounted: true
+});
+var cachedClientSnapshot = FALLBACK_CLIENT_SNAPSHOT;
+function snapshotsMatch(left, right) {
+  return left.theme === right.theme && left.resolvedTheme === right.resolvedTheme && left.mounted === right.mounted;
+}
+__name(snapshotsMatch, "snapshotsMatch");
+function getClientSnapshot() {
+  const next = typeof window === "undefined" ? FALLBACK_CLIENT_SNAPSHOT : window.__FARM_THEME__?.snapshot;
+  if (!next) return cachedClientSnapshot;
+  if (!snapshotsMatch(cachedClientSnapshot, next)) cachedClientSnapshot = next;
+  return cachedClientSnapshot;
+}
+__name(getClientSnapshot, "getClientSnapshot");
+function getHydrationSnapshot() {
+  if (typeof window !== "undefined" && window.__FARM_THEME__?.serverSnapshot) {
+    return window.__FARM_THEME__.serverSnapshot;
+  }
+  return getFarmThemeServerSnapshot();
+}
+__name(getHydrationSnapshot, "getHydrationSnapshot");
+function subscribe(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  const handleThemeChange = /* @__PURE__ */ __name(() => {
+    getClientSnapshot();
+    listener();
+  }, "handleThemeChange");
+  window.addEventListener("farm:themechange", handleThemeChange);
+  return () => window.removeEventListener("farm:themechange", handleThemeChange);
+}
+__name(subscribe, "subscribe");
+function getTheme2() {
+  return getClientSnapshot();
+}
+__name(getTheme2, "getTheme");
+function setTheme(theme) {
+  const runtime = typeof window === "undefined" ? void 0 : window.__FARM_THEME__;
+  if (!runtime) {
+    throw new Error("The FARMJS theme runtime is not enabled. Add `theme` to farm.config.ts.");
+  }
+  runtime.setTheme(theme);
+}
+__name(setTheme, "setTheme");
+function toggleTheme() {
+  const next = getClientSnapshot().resolvedTheme === "dark" ? "light" : "dark";
+  setTheme(next);
+  return next;
+}
+__name(toggleTheme, "toggleTheme");
+function useTheme() {
+  const snapshot = (0, import_react13.useSyncExternalStore)(subscribe, getClientSnapshot, getHydrationSnapshot);
+  return {
+    ...snapshot,
+    setTheme,
+    toggleTheme
+  };
+}
+__name(useTheme, "useTheme");
+
+// src/client/link.tsx
+var import_react14 = require("react");
 init_router();
 init_client_runtime();
 var import_jsx_runtime5 = require("react/jsx-runtime");
@@ -45747,9 +46238,9 @@ function LinkInner({
   onTouchStart,
   ...props
 }, ref) {
-  const elementRef = (0, import_react13.useRef)(null);
-  const intentTimeoutRef = (0, import_react13.useRef)(null);
-  const hasPrefetched = (0, import_react13.useRef)(false);
+  const elementRef = (0, import_react14.useRef)(null);
+  const intentTimeoutRef = (0, import_react14.useRef)(null);
+  const hasPrefetched = (0, import_react14.useRef)(false);
   const { intent, viewport, render } = normalizePrefetch(prefetch2);
   const baseHref = resolveLinkHref(href, params, {
     query,
@@ -45758,17 +46249,17 @@ function LinkInner({
   });
   const resolvedHref = localizeActiveFarmHref(baseHref, locale);
   const isExternal = isExternalUrl(resolvedHref);
-  const doPrefetch = (0, import_react13.useCallback)(() => {
+  const doPrefetch = (0, import_react14.useCallback)(() => {
     if (isExternal || hasPrefetched.current) return;
     const router = getRouter2();
     if (!router) return;
     hasPrefetched.current = true;
     router.prefetch(resolvedHref);
   }, [resolvedHref, isExternal]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     hasPrefetched.current = false;
   }, [resolvedHref]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     const element = elementRef.current;
     if (!element || isExternal) return;
     const router = getRouter2();
@@ -45778,7 +46269,7 @@ function LinkInner({
       return () => router.unobserveForPrefetch(element);
     }
   }, [resolvedHref, viewport, isExternal]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     if (!render || isExternal) return;
     let cancelled = false;
     let timeoutId = null;
@@ -45800,7 +46291,7 @@ function LinkInner({
       }
     };
   }, [render, isExternal, resolvedHref]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     return () => {
       if (intentTimeoutRef.current) {
         clearTimeout(intentTimeoutRef.current);
@@ -45808,13 +46299,13 @@ function LinkInner({
       }
     };
   }, []);
-  const cancelIntent = (0, import_react13.useCallback)(() => {
+  const cancelIntent = (0, import_react14.useCallback)(() => {
     if (intentTimeoutRef.current) {
       clearTimeout(intentTimeoutRef.current);
       intentTimeoutRef.current = null;
     }
   }, []);
-  const scheduleIntentPrefetch = (0, import_react13.useCallback)(() => {
+  const scheduleIntentPrefetch = (0, import_react14.useCallback)(() => {
     if (isExternal || !intent || hasPrefetched.current) return;
     cancelIntent();
     intentTimeoutRef.current = setTimeout(() => {
@@ -45822,42 +46313,42 @@ function LinkInner({
       doPrefetch();
     }, prefetchDelay);
   }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
-  const handleMouseEnter = (0, import_react13.useCallback)(
+  const handleMouseEnter = (0, import_react14.useCallback)(
     (event) => {
       onMouseEnter?.(event);
       scheduleIntentPrefetch();
     },
     [onMouseEnter, scheduleIntentPrefetch]
   );
-  const handleMouseLeave = (0, import_react13.useCallback)(
+  const handleMouseLeave = (0, import_react14.useCallback)(
     (event) => {
       onMouseLeave?.(event);
       cancelIntent();
     },
     [onMouseLeave, cancelIntent]
   );
-  const handleTouchStart = (0, import_react13.useCallback)(
+  const handleTouchStart = (0, import_react14.useCallback)(
     (event) => {
       onTouchStart?.(event);
       scheduleIntentPrefetch();
     },
     [onTouchStart, scheduleIntentPrefetch]
   );
-  const handleFocus = (0, import_react13.useCallback)(
+  const handleFocus = (0, import_react14.useCallback)(
     (event) => {
       onFocus?.(event);
       scheduleIntentPrefetch();
     },
     [onFocus, scheduleIntentPrefetch]
   );
-  const handleBlur = (0, import_react13.useCallback)(
+  const handleBlur = (0, import_react14.useCallback)(
     (event) => {
       onBlur?.(event);
       cancelIntent();
     },
     [onBlur, cancelIntent]
   );
-  const handleClick = (0, import_react13.useCallback)(
+  const handleClick = (0, import_react14.useCallback)(
     (event) => {
       onClick?.(event);
       if (event.defaultPrevented) return;
@@ -45882,7 +46373,7 @@ function LinkInner({
     },
     [resolvedHref, replace, scroll, viewTransition, target, isExternal, onClick]
   );
-  const setRefs = (0, import_react13.useCallback)(
+  const setRefs = (0, import_react14.useCallback)(
     (node) => {
       elementRef.current = node;
       if (typeof ref === "function") ref(node);
@@ -45911,7 +46402,7 @@ function LinkInner({
   );
 }
 __name(LinkInner, "LinkInner");
-var LinkWithRef = (0, import_react13.forwardRef)(LinkInner);
+var LinkWithRef = (0, import_react14.forwardRef)(LinkInner);
 LinkWithRef.displayName = "Link";
 var Link = LinkWithRef;
 function resolveLinkHref(href, params, options) {
@@ -46299,10 +46790,10 @@ var _FarmClientPluginManager = class _FarmClientPluginManager {
     if (session.signal.aborted) return Promise.resolve();
     const clientWindow = this.options.window;
     const schedule = clientWindow?.requestAnimationFrame ? (callback) => clientWindow.requestAnimationFrame(() => clientWindow.requestAnimationFrame(callback)) : (callback) => setTimeout(callback, 0);
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       schedule(() => {
         if (session.signal.aborted || this.closed) {
-          resolve6();
+          resolve7();
           return;
         }
         void this.runHook(
@@ -46316,7 +46807,7 @@ var _FarmClientPluginManager = class _FarmClientPluginManager {
           if (this.currentNavigation?.session === session) {
             this.currentNavigation = void 0;
           }
-          resolve6();
+          resolve7();
         });
       });
     });
@@ -46851,6 +47342,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   getServerActionInvalidations,
   getServerActionSignal,
   getStorage,
+  getTheme,
   globFiles,
   hasFarmRouteRuntimeControls,
   hasISR,
@@ -46967,6 +47459,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   resolveFarmLayoutFonts,
   resolveFarmRouteRuleRuntimeConfig,
   resolveFarmRouteRuntimeConfig,
+  resolveFarmThemeConfig,
   resolveIntegrationOrmRuntimeClient,
   resolveIntegrationPlugins,
   resolveMarkdownConfig,
@@ -46993,12 +47486,14 @@ __name(decodeCookiePart, "decodeCookiePart");
   segmentsToPattern,
   serverEnv,
   setEnv,
+  setTheme,
   snapshotDeferredData,
   sqliteStorage,
   storageCacheAdapter,
   titleFromMarkdown,
   toFormData,
   toViteModuleId,
+  toggleTheme,
   unstable_cache,
   unwrapMiddleware,
   updateTag,
@@ -47014,6 +47509,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   useSearchParams,
   useServerFn,
   useServerQuery,
+  useTheme,
   validateServerActionRequest,
   vercelBlobStorage,
   vercelKVStorage,