@farm.js/core 0.1.0-beta.11 → 0.1.0-beta.14

package/dist/internal/build-runtime.cjs

@@ -784,9 +784,9 @@ function getFarmIntegrationPluginServerRuntime(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME];
   return typeof value === "boolean" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path29, input) {
+function defineTypedIntegrationRoute(method, path31, input) {
   return {
-    path: path29,
+    path: path31,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -796,7 +796,7 @@ function defineTypedIntegrationRoute(method, path29, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path29,
+      path: path31,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -808,52 +808,52 @@ function defineTypedIntegrationRoute(method, path29, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path29, input) {
+    get(path31, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path29,
+        path31,
         input
       );
     },
-    post(path29, input) {
+    post(path31, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path29,
+        path31,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    put(path29, input) {
+    put(path31, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path29,
+        path31,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path29, input) {
-      return defineTypedIntegrationRoute("PATCH", path29, {
+    patch(path31, input) {
+      return defineTypedIntegrationRoute("PATCH", path31, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path29, input) {
-      return defineTypedIntegrationRoute("DELETE", path29, {
+    delete(path31, input) {
+      return defineTypedIntegrationRoute("DELETE", path31, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path29, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path29, input);
+    options(path31, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path31, input);
     },
-    head(path29, input) {
+    head(path31, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path29,
+        path31,
         input
       );
     }
@@ -1070,8 +1070,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 path29 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path29}${issue.message || "Invalid config"}`;
+    const path31 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path31}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -1756,8 +1756,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path29) {
-  return (path29 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path31) {
+  return (path31 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -2956,26 +2956,26 @@ async function prepareFarmWorkflowsForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs8 = await import("fs/promises");
-  const path29 = await import("path");
-  const generatedDir = path29.join(root, distDir, ".nitro", "farm-workflows");
+  const path31 = await import("path");
+  const generatedDir = path31.join(root, distDir, ".nitro", "farm-workflows");
   await fs8.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = path29.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    const wrapperPath = path31.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
     await fs8.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = path29.join(generatedDir, "http-handler.mjs");
+  const handlerPath = path31.join(generatedDir, "http-handler.mjs");
   await fs8.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(workflowConfig, workflows),
     "utf8"
   );
-  const manifestPath = path29.join(generatedDir, "manifest.json");
+  const manifestPath = path31.join(generatedDir, "manifest.json");
   await fs8.writeFile(
     manifestPath,
     JSON.stringify(
@@ -3058,10 +3058,10 @@ function resolveWorkflowDefinition(module2) {
 }
 async function findWorkflowFiles(root, dirs) {
   const fs8 = await import("fs/promises");
-  const path29 = await import("path");
+  const path31 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path29.isAbsolute(dir) ? dir : path29.join(root, dir);
+    const absoluteDir = path31.isAbsolute(dir) ? dir : path31.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
@@ -3069,10 +3069,10 @@ async function findWorkflowFiles(root, dirs) {
 }
 async function walkWorkflowDir(dir, files) {
   const fs8 = await import("fs/promises");
-  const path29 = await import("path");
+  const path31 = await import("path");
   const entries = await fs8.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path29.join(dir, entry.name);
+    const filePath = path31.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -3092,12 +3092,12 @@ function isWorkflowFile(fileName) {
 }
 async function loadWorkflowModule(filePath, root) {
   const fs8 = await import("fs/promises");
-  const path29 = await import("path");
+  const path31 = await import("path");
   const { pathToFileURL: pathToFileURL5 } = await import("url");
   const { build: build2 } = await import("esbuild");
-  const outDir = path29.join(root, ".farm", ".workflow-loader");
+  const outDir = path31.join(root, ".farm", ".workflow-loader");
   await fs8.mkdir(outDir, { recursive: true });
-  const outfile = path29.join(
+  const outfile = path31.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -3376,9 +3376,9 @@ async function prepareFarmCronForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs8 = await import("fs/promises");
-  const path29 = await import("path");
-  const manifestPath = path29.join(root, distDir, FARM_CRON_MANIFEST);
-  const generatedDir = path29.join(root, distDir, ".nitro", "farm-cron");
+  const path31 = await import("path");
+  const manifestPath = path31.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path31.join(root, distDir, ".nitro", "farm-cron");
   if (!cron.enabled) {
     await Promise.all([
       fs8.rm(manifestPath, { force: true }),
@@ -3395,7 +3395,7 @@ async function prepareFarmCronForNitro(config) {
   const tasks = {};
   for (const job of cron.jobs) {
     const taskName = getFarmCronTaskName(job.name);
-    const wrapperPath = path29.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
+    const wrapperPath = path31.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
     await fs8.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
     tasks[taskName] = {
       handler: wrapperPath,
@@ -3403,7 +3403,7 @@ async function prepareFarmCronForNitro(config) {
     };
   }
   const manifest = createFarmCronManifest(cron);
-  await fs8.mkdir(path29.dirname(manifestPath), { recursive: true });
+  await fs8.mkdir(path31.dirname(manifestPath), { recursive: true });
   await fs8.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return {
@@ -3485,7 +3485,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 path29 = normalizeCronPath(name, job.path);
+  const path31 = 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) {
@@ -3494,7 +3494,7 @@ function normalizeCronJob(name, job) {
   return {
     name,
     schedule,
-    path: path29,
+    path: path31,
     description: job.description?.trim() || void 0
   };
 }
@@ -3502,13 +3502,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 path29 = value.trim();
-  if (path29.startsWith("//") || path29.includes("?") || path29.includes("#")) {
+  const path31 = value.trim();
+  if (path31.startsWith("//") || path31.includes("?") || path31.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  return path29.length > 1 ? path29.replace(/\/+$/, "") : path29;
+  return path31.length > 1 ? path31.replace(/\/+$/, "") : path31;
 }
 function normalizeCronExpression(name, value) {
   if (typeof value !== "string") {
@@ -4904,8 +4904,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path29 = "/", secure = false) {
-  const normalizedPath = path29.startsWith("/") ? path29 : `/${path29}`;
+function createFarmDeploymentCookie(deploymentId, path31 = "/", secure = false) {
+  const normalizedPath = path31.startsWith("/") ? path31 : `/${path31}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -4976,7 +4976,7 @@ var init_devtools_config = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path29 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path31 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -5004,7 +5004,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path29,
+    path: path31,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -5043,11 +5043,11 @@ function getPublicFarmImageConfig(config) {
   };
 }
 function normalizeImagePath(value) {
-  const path29 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path29.startsWith("/") || path29.includes("?") || path29.includes("#")) {
+  const path31 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path31.startsWith("/") || path31.includes("?") || path31.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  return path29;
+  return path31;
 }
 function normalizeIntegerList(values, name, max) {
   if (values.length === 0) {
@@ -5361,6 +5361,33 @@ var init_auth_config = __esm({
   }
 });
 
+// src/preload.ts
+function resolveFarmPerformanceConfig(config) {
+  return {
+    preload: {
+      mode: config?.preload?.mode === "warn" ? "warn" : "enforce",
+      maxImages: normalizeBudget(config?.preload?.maxImages, DEFAULT_PRELOAD_CONFIG.maxImages),
+      maxFonts: normalizeBudget(config?.preload?.maxFonts, DEFAULT_PRELOAD_CONFIG.maxFonts)
+    }
+  };
+}
+function normalizeBudget(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+var DEFAULT_PRELOAD_CONFIG;
+var init_preload = __esm({
+  "src/preload.ts"() {
+    "use strict";
+    DEFAULT_PRELOAD_CONFIG = {
+      mode: "enforce",
+      maxImages: 1,
+      maxFonts: 2
+    };
+    __name(resolveFarmPerformanceConfig, "resolveFarmPerformanceConfig");
+    __name(normalizeBudget, "normalizeBudget");
+  }
+});
+
 // src/config-entry.ts
 var init_config_entry = __esm({
   "src/config-entry.ts"() {
@@ -5481,18 +5508,18 @@ function sanitizeDocsConfig(config) {
   return cloneSerializable(config) || {};
 }
 async function findDocsConfigPath(rootDir, configPath) {
-  const { existsSync: existsSync16 } = await import("fs");
+  const { existsSync: existsSync17 } = await import("fs");
   const root = import_path2.default.resolve(rootDir || process.cwd());
   if (configPath) {
     const resolvedPath = import_path2.default.isAbsolute(configPath) ? configPath : import_path2.default.join(root, configPath);
-    if (!existsSync16(resolvedPath)) {
+    if (!existsSync17(resolvedPath)) {
       throw new Error(`Could not find docs config at ${configPath}.`);
     }
     return import_path2.default.resolve(resolvedPath);
   }
   for (const filename of DOCS_CONFIG_FILENAMES) {
     const resolvedPath = import_path2.default.join(root, filename);
-    if (existsSync16(resolvedPath)) {
+    if (existsSync17(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -5680,6 +5707,7 @@ async function resolveConfig(userConfig, mode) {
     headers: /* @__PURE__ */ __name(() => [...headers, ...routeRuleHeaders], "headers"),
     routeRules,
     images: resolveFarmImageConfig(userConfig.images),
+    performance: resolveFarmPerformanceConfig(userConfig.performance),
     publicDir: userConfig.publicDir || "public",
     i18n: resolveFarmI18nConfig(userConfig.i18n, { root, mode }),
     openapi: {
@@ -5718,7 +5746,7 @@ async function resolveConfig(userConfig, mode) {
   return resolved;
 }
 async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "production" ? "production" : "development", loadEnvironment) {
-  const { existsSync: existsSync16 } = await import("fs");
+  const { existsSync: existsSync17 } = await import("fs");
   const loadEnv = loadEnvironment || (await import("vite")).loadEnv;
   const root = rootDir || process.cwd();
   const loadedEnv = loadEnv(mode, root, "");
@@ -5742,7 +5770,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
     try {
       const absolutePath = relativePath2.startsWith("/") ? relativePath2 : import_path2.default.join(root, relativePath2);
       const normalizedPath = import_path2.default.resolve(absolutePath);
-      if (!existsSync16(normalizedPath)) {
+      if (!existsSync17(normalizedPath)) {
         continue;
       }
       const loadedConfig = await loadFarmConfigFile(normalizedPath, { root });
@@ -5773,6 +5801,7 @@ var init_config2 = __esm({
     init_image_config();
     init_config();
     init_auth_config();
+    init_preload();
     init_config_entry();
     FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
     __name(hasCustomFarmRouteContext, "hasCustomFarmRouteContext");
@@ -6140,6 +6169,210 @@ async function resolveRouteRenderingConfigFromFile(mod, filePath) {
   const source = await (0, import_promises3.readFile)(filePath, "utf8").catch(() => void 0);
   return resolveRouteRenderingConfig(mod, source);
 }
+function analyzeStaticRouteCandidate(mod, source, options = {}) {
+  const blockers = [];
+  if (!source) {
+    blockers.push("route source is unavailable");
+  }
+  if (options.isDynamic) {
+    blockers.push("the route has dynamic path segments");
+  }
+  if (hasExplicitRenderingConfig(mod, source)) {
+    blockers.push("the route already has explicit rendering config");
+  }
+  if (source) {
+    blockers.push(...findRequestBoundSourceBlockers(source));
+  }
+  return {
+    candidate: blockers.length === 0,
+    blockers
+  };
+}
+function findRequestBoundSourceBlockers(source) {
+  const blockers = /* @__PURE__ */ new Set();
+  const code = stripCommentsAndLiteralContents(source);
+  const sourceWithoutComments = stripComments(source);
+  for (const binding of readRequestApiImportBindings(sourceWithoutComments)) {
+    if (new RegExp(`\\b${escapeRegExp2(binding.local)}\\s*(?:\\?\\.\\s*)?\\(`).test(code)) {
+      blockers.add(`the route reads ${binding.label}`);
+    }
+  }
+  for (const namespace of readNamespaceImportBindings(sourceWithoutComments)) {
+    for (const [name, label] of REQUEST_API_LABELS) {
+      if (new RegExp(
+        `\\b${escapeRegExp2(namespace)}\\s*(?:\\?\\.\\s*|\\.\\s*)${name}\\s*(?:\\?\\.\\s*)?\\(`
+      ).test(code)) {
+        blockers.add(`the route reads ${label}`);
+      }
+    }
+  }
+  const params = readDefaultRouteParameters(code);
+  if (params) {
+    for (const [name, label] of ROUTE_PROP_LABELS) {
+      if (new RegExp(`\\b${name}\\b`).test(params)) {
+        blockers.add(`the route reads ${label}`);
+      }
+    }
+    const propsName = params.match(/^\s*([A-Za-z_$][\w$]*)\s*(?::|,|$)/)?.[1];
+    if (propsName) {
+      for (const [name, label] of ROUTE_PROP_LABELS) {
+        if (new RegExp(`\\b${escapeRegExp2(propsName)}\\s*\\.\\s*${name}\\b`).test(code)) {
+          blockers.add(`the route reads ${label}`);
+        }
+        if (new RegExp(`\\{[^}]*\\b${name}\\b[^}]*\\}\\s*=\\s*${escapeRegExp2(propsName)}\\b`).test(
+          code
+        )) {
+          blockers.add(`the route reads ${label}`);
+        }
+      }
+    }
+  }
+  return [...blockers];
+}
+function readRequestApiImportBindings(source) {
+  const bindings = [];
+  for (const clause of readStaticImportClauses(source)) {
+    const namedGroup = clause.match(/\{([\s\S]*?)\}/)?.[1];
+    for (const rawSpecifier of (namedGroup ?? "").split(",")) {
+      const specifier = rawSpecifier.trim().replace(/^type\s+/, "");
+      const imported = specifier.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+      if (!imported?.[1]) continue;
+      const label = REQUEST_API_LABELS.get(imported[1]);
+      if (label) bindings.push({ local: imported[2] ?? imported[1], label });
+    }
+    const local = clause.match(/^\s*([A-Za-z_$][\w$]*)\s*(?:,|$)/)?.[1];
+    if (local) {
+      const label = REQUEST_API_LABELS.get(local);
+      if (label) bindings.push({ local, label });
+    }
+  }
+  return bindings;
+}
+function readNamespaceImportBindings(source) {
+  return readStaticImportClauses(source).map((clause) => clause.match(/\*\s*as\s*([A-Za-z_$][\w$]*)/)?.[1]).filter((binding) => Boolean(binding));
+}
+function readStaticImportClauses(source) {
+  return [...source.matchAll(/\bimport\s+(?!\()([\s\S]*?)\s+from\s*["'][^"']+["']/g)].map((match) => match[1]).filter((clause) => Boolean(clause));
+}
+function readDefaultRouteParameters(code) {
+  const inlineParams = code.match(/\bexport\s+default\s+(?:async\s+)?function\b[^(]*\(([^)]*)\)/)?.[1] ?? code.match(/\bexport\s+default\s+(?:async\s+)?\(([^)]*)\)\s*=>/)?.[1];
+  if (inlineParams !== void 0) return inlineParams;
+  const binding = code.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;?/)?.[1] ?? code.match(/\bexport\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*\}/)?.[1];
+  if (!binding) return void 0;
+  const escapedBinding = escapeRegExp2(binding);
+  return code.match(new RegExp(`\\bfunction\\s+${escapedBinding}\\s*\\(([^)]*)\\)`))?.[1] ?? code.match(
+    new RegExp(
+      `\\b(?:const|let|var)\\s+${escapedBinding}\\s*=\\s*(?:async\\s+)?\\(([^)]*)\\)\\s*=>`
+    )
+  )?.[1] ?? code.match(
+    new RegExp(`\\b(?:const|let|var)\\s+${escapedBinding}\\s*=\\s*function\\s*\\(([^)]*)\\)`)
+  )?.[1];
+}
+function stripCommentsAndLiteralContents(source) {
+  return sanitizeSource(source, true);
+}
+function stripComments(source) {
+  return sanitizeSource(source, false);
+}
+function sanitizeSource(source, maskLiterals) {
+  const output = [...source];
+  const mask = /* @__PURE__ */ __name((index) => {
+    if (output[index] !== "\n" && output[index] !== "\r") output[index] = " ";
+  }, "mask");
+  const scanQuoted = /* @__PURE__ */ __name((start, quote) => {
+    let index = start;
+    if (maskLiterals) mask(index);
+    index += 1;
+    while (index < source.length) {
+      if (source[index] === "\\") {
+        if (maskLiterals) mask(index);
+        if (index + 1 < source.length && maskLiterals) mask(index + 1);
+        index += 2;
+        continue;
+      }
+      const character = source[index];
+      if (maskLiterals) mask(index);
+      index += 1;
+      if (character === quote) break;
+    }
+    return index;
+  }, "scanQuoted");
+  const scanCode = /* @__PURE__ */ __name((start, stopAtTemplateBrace) => {
+    let index = start;
+    let braceDepth = 0;
+    while (index < source.length) {
+      const character = source[index];
+      const next = source[index + 1];
+      if (character === "/" && next === "/") {
+        while (index < source.length && source[index] !== "\n" && source[index] !== "\r") {
+          mask(index++);
+        }
+        continue;
+      }
+      if (character === "/" && next === "*") {
+        mask(index++);
+        mask(index++);
+        while (index < source.length) {
+          const closesComment = source[index] === "*" && source[index + 1] === "/";
+          mask(index++);
+          if (closesComment) {
+            mask(index++);
+            break;
+          }
+        }
+        continue;
+      }
+      if (character === "'" || character === '"') {
+        index = scanQuoted(index, character);
+        continue;
+      }
+      if (character === "`") {
+        if (maskLiterals) mask(index);
+        index += 1;
+        while (index < source.length) {
+          if (source[index] === "\\") {
+            if (maskLiterals) mask(index);
+            if (index + 1 < source.length && maskLiterals) mask(index + 1);
+            index += 2;
+          } else if (source[index] === "`") {
+            if (maskLiterals) mask(index);
+            index += 1;
+            break;
+          } else if (source[index] === "$" && source[index + 1] === "{") {
+            if (maskLiterals) {
+              mask(index);
+              mask(index + 1);
+            }
+            index = scanCode(index + 2, true);
+          } else {
+            if (maskLiterals) mask(index);
+            index += 1;
+          }
+        }
+        continue;
+      }
+      if (character === "{") {
+        braceDepth += 1;
+      } else if (character === "}") {
+        if (stopAtTemplateBrace && braceDepth === 0) {
+          if (maskLiterals) mask(index);
+          return index + 1;
+        }
+        braceDepth = Math.max(0, braceDepth - 1);
+      }
+      index += 1;
+    }
+    return index;
+  }, "scanCode");
+  scanCode(0, false);
+  return output.join("");
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasExplicitRenderingConfig(mod, source) {
+  return typeof mod?.ssg === "boolean" || typeof mod?.ppr === "boolean" || typeof mod?.experimental_ppr === "boolean" || typeof mod?.revalidate !== "undefined" || typeof mod?.dynamic !== "undefined" || typeof parseRouteRenderingDirective(source) !== "undefined";
+}
 function parseRouteRenderingDirective(source) {
   if (!source) {
     return void 0;
@@ -6264,9 +6497,10 @@ function skipHorizontalWhitespace(source, start) {
   }
   return index;
 }
-async function collectSSGPages(routes, loadModule2) {
+async function collectSSGPages(routes, loadModule2, options = {}) {
   const ssgPages = [];
   const ssrRoutes = [];
+  const staticCandidateRoutes = [];
   for (const route of routes) {
     try {
       const mod = await loadModule2(route.filePath);
@@ -6274,7 +6508,8 @@ async function collectSSGPages(routes, loadModule2) {
         ssrRoutes.push(route.path);
         continue;
       }
-      const rendering = await resolveRouteRenderingConfigFromFile(mod, route.filePath);
+      const source = await (0, import_promises3.readFile)(route.filePath, "utf8").catch(() => void 0);
+      const rendering = resolveRouteRenderingConfig(mod, source);
       if (rendering.ssg) {
         if (route.isDynamic) {
           const getStaticPaths = mod.getStaticPaths || mod.generateStaticParams;
@@ -6301,12 +6536,26 @@ async function collectSSGPages(routes, loadModule2) {
         }
       } else {
         ssrRoutes.push(route.path);
+        if (options.suggestStaticRendering !== false && analyzeStaticRouteCandidate(mod, source, { isDynamic: route.isDynamic }).candidate) {
+          staticCandidateRoutes.push(route.path);
+        }
       }
     } catch (error) {
       console.error(`Error processing route ${route.path}:`, error);
       ssrRoutes.push(route.path);
     }
   }
+  if (staticCandidateRoutes.length > 0) {
+    const visibleRoutes = staticCandidateRoutes.slice(0, 10);
+    const remainingCount = staticCandidateRoutes.length - visibleRoutes.length;
+    const remainingSuffix = remainingCount > 0 ? `
+  \u2026and ${remainingCount} more` : "";
+    console.warn(
+      `[Farm.js] ${staticCandidateRoutes.length} route${staticCandidateRoutes.length === 1 ? " appears" : "s appear"} eligible for static rendering:
+  ${visibleRoutes.join("\n  ")}${remainingSuffix}
+Add \`export const dynamic = "force-static";\` after verifying that imported code does not read cookies, headers, authentication, or other request data.`
+    );
+  }
   return { ssg: ssgPages, ssr: ssrRoutes };
 }
 function materializeSSGRoutePath(routePattern, params) {
@@ -6408,7 +6657,7 @@ function matchSSGPage(urlPath, ssgPages) {
   const normalizedPath = urlPath === "/" ? "/" : urlPath.replace(/\/$/, "");
   return ssgPages.find((page2) => page2.urlPath === normalizedPath);
 }
-var import_promises3, OPTIONAL_CATCH_ALL_SEGMENT, REQUIRED_CATCH_ALL_SEGMENT, REQUIRED_DYNAMIC_SEGMENT;
+var import_promises3, OPTIONAL_CATCH_ALL_SEGMENT, REQUIRED_CATCH_ALL_SEGMENT, REQUIRED_DYNAMIC_SEGMENT, REQUEST_API_LABELS, ROUTE_PROP_LABELS;
 var init_ssg = __esm({
   "src/ssg.ts"() {
     "use strict";
@@ -6416,8 +6665,35 @@ var init_ssg = __esm({
     OPTIONAL_CATCH_ALL_SEGMENT = /^\[\[\.\.\.([^\]]+)\]\]$/;
     REQUIRED_CATCH_ALL_SEGMENT = /^\[\.\.\.([^\]]+)\]$/;
     REQUIRED_DYNAMIC_SEGMENT = /^\[([^\]]+)\]$/;
+    REQUEST_API_LABELS = /* @__PURE__ */ new Map([
+      ["cookies", "request cookies"],
+      ["headers", "request headers"],
+      ["getCurrentRequest", "the current Request"],
+      ["useSearchParams", "URL search parameters"],
+      ["auth", "request authentication"],
+      ["getServerSession", "request authentication"],
+      ["getSession", "request authentication"],
+      ["currentUser", "request authentication"]
+    ]);
+    ROUTE_PROP_LABELS = /* @__PURE__ */ new Map([
+      ["searchParams", "URL search parameters"],
+      ["middleware", "middleware request data"],
+      ["middlewareData", "middleware request data"],
+      ["context", "request context"]
+    ]);
     __name(resolveRouteRenderingConfig, "resolveRouteRenderingConfig");
     __name(resolveRouteRenderingConfigFromFile, "resolveRouteRenderingConfigFromFile");
+    __name(analyzeStaticRouteCandidate, "analyzeStaticRouteCandidate");
+    __name(findRequestBoundSourceBlockers, "findRequestBoundSourceBlockers");
+    __name(readRequestApiImportBindings, "readRequestApiImportBindings");
+    __name(readNamespaceImportBindings, "readNamespaceImportBindings");
+    __name(readStaticImportClauses, "readStaticImportClauses");
+    __name(readDefaultRouteParameters, "readDefaultRouteParameters");
+    __name(stripCommentsAndLiteralContents, "stripCommentsAndLiteralContents");
+    __name(stripComments, "stripComments");
+    __name(sanitizeSource, "sanitizeSource");
+    __name(escapeRegExp2, "escapeRegExp");
+    __name(hasExplicitRenderingConfig, "hasExplicitRenderingConfig");
     __name(parseRouteRenderingDirective, "parseRouteRenderingDirective");
     __name(parseKnownRenderingDirective, "parseKnownRenderingDirective");
     __name(normalizeDynamicMode, "normalizeDynamicMode");
@@ -7098,7 +7374,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, path29, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path31, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -7107,7 +7383,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path29, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path29
+    path: path31
   });
   return { search, canonicalPath };
 }
@@ -7274,7 +7550,7 @@ function createRouteModuleFromProgrammaticPage(route) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path29) => resolveProgrammaticRouteSearch(route.search, rawSearch, path29, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path31) => resolveProgrammaticRouteSearch(route.search, rawSearch, path31, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -7672,25 +7948,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path29, options) {
+      page(path31, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path29,
+          path: path31,
           ...options
         });
       },
-      layout(path29, options) {
+      layout(path31, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path29,
+          path: path31,
           ...options
         });
       },
-      api(path29, options) {
+      api(path31, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path29,
+          path: path31,
           render,
           runtime,
           regions,
@@ -7833,6 +8109,19 @@ var init_routes_server = __esm({
   }
 });
 
+// src/island.ts
+function isFarmIslandStrategy(value) {
+  return FARM_ISLAND_STRATEGIES.includes(value);
+}
+var FARM_ISLAND_STRATEGIES;
+var init_island = __esm({
+  "src/island.ts"() {
+    "use strict";
+    FARM_ISLAND_STRATEGIES = ["load", "interaction", "visible", "idle"];
+    __name(isFarmIslandStrategy, "isFarmIslandStrategy");
+  }
+});
+
 // src/utils/client-component.ts
 function readIfExists(filePath) {
   try {
@@ -7890,53 +8179,180 @@ function hasHydrateExport(content) {
   }
   return /\bexport\s+const\s+hydrate\s*=\s*true\b/.test(content) || /\bexport\s*\{\s*hydrate\s*\}\b/.test(content);
 }
+function tokenizeModuleSource(content) {
+  const tokens = [];
+  let index = 0;
+  let line = 1;
+  while (index < content.length) {
+    const character = content[index];
+    if (/\s/.test(character)) {
+      if (character === "\n") line++;
+      index++;
+      continue;
+    }
+    if (character === "/" && content[index + 1] === "/") {
+      index += 2;
+      while (index < content.length && content[index] !== "\n") index++;
+      continue;
+    }
+    if (character === "/" && content[index + 1] === "*") {
+      index += 2;
+      while (index < content.length) {
+        if (content[index] === "\n") line++;
+        if (content[index] === "*" && content[index + 1] === "/") {
+          index += 2;
+          break;
+        }
+        index++;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      const quote = character;
+      const tokenLine = line;
+      let value = "";
+      index++;
+      while (index < content.length) {
+        const next = content[index];
+        if (next === "\\") {
+          value += next;
+          if (index + 1 < content.length) value += content[index + 1];
+          index += 2;
+          continue;
+        }
+        if (next === quote) {
+          index++;
+          break;
+        }
+        if (next === "\n") line++;
+        value += next;
+        index++;
+      }
+      tokens.push({ kind: "string", value, line: tokenLine });
+      continue;
+    }
+    if (character === "`") {
+      index++;
+      while (index < content.length) {
+        const next = content[index];
+        if (next === "\\") {
+          index += 2;
+          continue;
+        }
+        if (next === "`") {
+          index++;
+          break;
+        }
+        if (next === "\n") line++;
+        index++;
+      }
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(character)) {
+      const start = index++;
+      while (index < content.length && /[\w$]/.test(content[index])) index++;
+      tokens.push({ kind: "identifier", value: content.slice(start, index), line });
+      continue;
+    }
+    tokens.push({ kind: "punctuation", value: character, line });
+    index++;
+  }
+  return tokens;
+}
+function isIslandExportStart(tokens, index) {
+  const token = tokens[index];
+  const previous = tokens[index - 1];
+  const startsStatement = !previous || previous.value === ";" || previous.value === "{" || previous.value === "}" || token.line > previous.line;
+  return startsStatement && token.value === "export" && tokens[index + 1]?.value === "const" && tokens[index + 2]?.value === "island";
+}
+function getIslandStrategyExport(content) {
+  if (!content) return null;
+  const tokens = tokenizeModuleSource(content);
+  for (let index = 0; index < tokens.length - 2; index++) {
+    if (!isIslandExportStart(tokens, index)) continue;
+    let valueIndex = index + 3;
+    if (tokens[valueIndex]?.value === ":") {
+      while (valueIndex < tokens.length && tokens[valueIndex].value !== "=") valueIndex++;
+    }
+    if (tokens[valueIndex]?.value !== "=") break;
+    valueIndex++;
+    const literal = tokens[valueIndex];
+    if (!literal || literal.kind !== "string" || !isFarmIslandStrategy(literal.value)) break;
+    let trailingIndex = valueIndex + 1;
+    if (tokens[trailingIndex]?.value === "as" && tokens[trailingIndex + 1]?.value === "const") {
+      trailingIndex += 2;
+    }
+    const trailing = tokens[trailingIndex];
+    if (trailing && trailing.value !== ";" && trailing.line === literal.line) break;
+    return literal.value;
+  }
+  if (tokens.some((_token, index) => isIslandExportStart(tokens, index))) {
+    throw new Error(
+      'Farm island configuration must be a static "load", "interaction", "visible", or "idle" string literal.'
+    );
+  }
+  return null;
+}
 function stripUseClientDirective(content) {
   return content.replace(/^\s*(["'])use client\1\s*;?\s*/, "");
 }
-function parseClientModuleMetadata(content) {
+function parseClientModuleMetadata(content, inspectIslandExport) {
   if (!content) {
     return {
       isClientComponent: false,
-      hasHydrateExport: false
+      hasHydrateExport: false,
+      islandStrategy: null
     };
   }
+  const isClientComponent = hasUseClientDirective(content);
+  const hasHydrate = hasHydrateExport(content);
   return {
-    isClientComponent: hasUseClientDirective(content),
-    hasHydrateExport: hasHydrateExport(content)
+    isClientComponent,
+    hasHydrateExport: hasHydrate,
+    islandStrategy: inspectIslandExport || isClientComponent || hasHydrate ? getIslandStrategyExport(content) : null
   };
 }
 function getClientModuleMetadata(modulePath, root) {
   const resolvedPath = resolveModuleSourcePath(modulePath, root);
-  return inspectClientModuleMetadata(resolvedPath, root, /* @__PURE__ */ new Set());
+  return inspectClientModuleMetadata(resolvedPath, root, /* @__PURE__ */ new Set(), true);
 }
-function inspectClientModuleMetadata(resolvedPath, root, visited) {
+function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandExport) {
   if (!resolvedPath || visited.has(resolvedPath)) {
     return {
       isClientComponent: false,
-      shouldHydrate: false
+      shouldHydrate: false,
+      islandStrategy: null
     };
   }
   visited.add(resolvedPath);
   const content = readIfExists(resolvedPath);
-  const parsed = parseClientModuleMetadata(content);
+  const parsed = parseClientModuleMetadata(content, inspectIslandExport);
   if (parsed.isClientComponent) {
     return {
       isClientComponent: true,
-      shouldHydrate: true
+      shouldHydrate: true,
+      islandStrategy: parsed.islandStrategy ?? "load"
     };
   }
   let importsClientBoundary = false;
+  let importedIslandStrategy = null;
   for (const specifier of getRelativeImportSpecifiers(content)) {
     const importedPath = resolveImportedModuleSourcePath(resolvedPath, specifier, root);
-    const importedMetadata = inspectClientModuleMetadata(importedPath, root, visited);
+    const importedMetadata = inspectClientModuleMetadata(importedPath, root, visited, false);
     if (importedMetadata.isClientComponent || importedMetadata.shouldHydrate) {
       importsClientBoundary = true;
-      break;
+      if (importedIslandStrategy === null) {
+        importedIslandStrategy = importedMetadata.islandStrategy;
+      } else if (importedIslandStrategy !== importedMetadata.islandStrategy) {
+        importedIslandStrategy = "load";
+      }
     }
   }
+  const shouldHydrate = parsed.hasHydrateExport || importsClientBoundary;
   return {
     isClientComponent: false,
-    shouldHydrate: parsed.hasHydrateExport || importsClientBoundary
+    shouldHydrate,
+    islandStrategy: shouldHydrate ? parsed.islandStrategy ?? importedIslandStrategy ?? "load" : null
   };
 }
 function getRelativeImportSpecifiers(content) {
@@ -7976,6 +8392,7 @@ var init_client_component = __esm({
     import_fs2 = __toESM(require("fs"));
     import_path5 = __toESM(require("path"));
     import_url2 = require("url");
+    init_island();
     __name(readIfExists, "readIfExists");
     __name(resolveModuleSourcePath, "resolveModuleSourcePath");
     RESOLVABLE_SOURCE_EXTENSIONS = [
@@ -7990,6 +8407,9 @@ var init_client_component = __esm({
     ];
     __name(hasUseClientDirective, "hasUseClientDirective");
     __name(hasHydrateExport, "hasHydrateExport");
+    __name(tokenizeModuleSource, "tokenizeModuleSource");
+    __name(isIslandExportStart, "isIslandExportStart");
+    __name(getIslandStrategyExport, "getIslandStrategyExport");
     __name(stripUseClientDirective, "stripUseClientDirective");
     __name(parseClientModuleMetadata, "parseClientModuleMetadata");
     __name(getClientModuleMetadata, "getClientModuleMetadata");
@@ -8231,6 +8651,9 @@ var init_route_slots = __esm({
 });
 
 // src/routing/route-manager.ts
+function shouldSuggestStaticRenderingForI18n(i18n) {
+  return !i18n || i18n.routing === "prefix-always" || i18n.routing === "prefix-except-default" && i18n.detection.every((signal) => signal === "url");
+}
 function routeSpecificity(entry) {
   return entry.route.segments.reduce((score, segment) => {
     if (!segment.isDynamic) return score + 100;
@@ -8302,6 +8725,7 @@ var init_route_manager = __esm({
     init_route_runtime();
     init_routing();
     init_route_slots();
+    __name(shouldSuggestStaticRenderingForI18n, "shouldSuggestStaticRenderingForI18n");
     __name(routeSpecificity, "routeSpecificity");
     _RouteManager = class _RouteManager {
       constructor(config, viteServer) {
@@ -8538,6 +8962,7 @@ var init_route_manager = __esm({
             modulePath: toUrlPath(entry.modulePath),
             shouldHydrate: metadata.shouldHydrate,
             isClientComponent: metadata.isClientComponent,
+            islandStrategy: metadata.islandStrategy,
             search: getProgrammaticRouteSearchClientOptions(programmaticPage?.search),
             segments: entry.route.segments.map((seg) => ({
               segment: seg.segment,
@@ -9000,8 +9425,10 @@ var init_route_manager = __esm({
           isDynamic: entry.route.segments.some((seg) => seg.isDynamic),
           pattern: entry.pattern
         }));
-        const result = await collectSSGPages(routes, (filePath) => this.loadRouteModule(filePath));
         const i18n = this.getI18nConfig();
+        const result = await collectSSGPages(routes, (filePath) => this.loadRouteModule(filePath), {
+          suggestStaticRendering: shouldSuggestStaticRenderingForI18n(i18n)
+        });
         if (!i18n) {
           return result;
         }
@@ -10667,7 +11094,8 @@ function serializeFontResult(font) {
       fontFamily: stack,
       ...font.style ? { fontStyle: font.style } : {},
       ...font.weight !== void 0 && !String(font.weight).includes(" ") ? { fontWeight: font.weight } : {}
-    }
+    },
+    preloads: font.preloadResources
   });
 }
 function renderFontDefinitionCss(font, production, basePath) {
@@ -11180,6 +11608,10 @@ ${FONT_SECTION_END}
           fallback,
           display,
           preload: raw.preload !== false,
+          preloadResources: raw.preload === false ? [] : normalizedSources.map(({ resource }) => ({
+            href: resourceUrl(resource, production, this.basePath),
+            type: fontContentType(resource.extension)
+          })),
           weight: defaultWeight,
           style: raw.style === void 0 ? void 0 : defaultStyle,
           sources: normalizedSources
@@ -11276,7 +11708,7 @@ ${FONT_SECTION_END}
         const normalizedExtension = extension.toLowerCase();
         const hash = (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex").slice(0, 12);
         const baseName = sanitizeFileName(import_node_path5.default.basename(fileName, extension)) || "font";
-        const outputFileName = `assets/fonts/${baseName}-${hash}${normalizedExtension}`;
+        const outputFileName = `assets/fonts/${baseName}-h${hash}${normalizedExtension}`;
         const key = `${hash}${normalizedExtension}`;
         const existing = this.resources.get(key);
         if (existing) return existing;
@@ -11348,6 +11780,172 @@ ${FONT_SECTION_END}
   }
 });
 
+// src/metadata-image.ts
+function isResponse(value) {
+  return typeof Response !== "undefined" && (value instanceof Response || Boolean(
+    value && typeof value === "object" && typeof value.arrayBuffer === "function" && value.headers
+  ));
+}
+function isThenable(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+async function prepareMetadataImageNode(node) {
+  if (isThenable(node)) {
+    return prepareMetadataImageNode(await node);
+  }
+  if (Array.isArray(node)) {
+    return Promise.all(node.map((child) => prepareMetadataImageNode(child)));
+  }
+  if (!import_react4.default.isValidElement(node)) {
+    return node;
+  }
+  const element = node;
+  const type = element.type;
+  const props = element.props || {};
+  if (typeof type === "function") {
+    if (type.prototype?.isReactComponent) {
+      throw new Error(
+        "Metadata image components must be stateless function components; React class components are not supported."
+      );
+    }
+    return prepareMetadataImageNode(await type(props));
+  }
+  if (type && typeof type === "object") {
+    if (type.$$typeof === REACT_MEMO_TYPE) {
+      return prepareMetadataImageNode(import_react4.default.createElement(type.type, props));
+    }
+    if (type.$$typeof === REACT_FORWARD_REF_TYPE) {
+      return prepareMetadataImageNode(await type.render(props, null));
+    }
+    if (type.$$typeof === REACT_LAZY_TYPE) {
+      return prepareMetadataImageNode(import_react4.default.createElement(type._init(type._payload), props));
+    }
+  }
+  const preparedChildren = await prepareMetadataImageNode(props.children);
+  const preparedProps = { ...props };
+  if (typeof preparedProps.className === "string") {
+    preparedProps.tw = [preparedProps.tw, preparedProps.className].filter(Boolean).join(" ");
+    delete preparedProps.className;
+  }
+  delete preparedProps.children;
+  return import_react4.default.createElement(type, {
+    ...preparedProps,
+    key: element.key,
+    children: preparedChildren
+  });
+}
+async function normalizeFonts(fonts) {
+  if (!fonts?.length) return void 0;
+  return Promise.all(
+    fonts.map(async (font) => {
+      const data = await font.data;
+      const arrayBuffer = ArrayBuffer.isView(data) ? toArrayBuffer(data) : data;
+      return { ...font, data: arrayBuffer };
+    })
+  );
+}
+function resolveCacheControl(revalidate) {
+  if (revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0) {
+    return `public, s-maxage=${Math.floor(revalidate)}, stale-while-revalidate=300`;
+  }
+  return "public, max-age=0, must-revalidate";
+}
+function toArrayBuffer(value) {
+  if (value instanceof ArrayBuffer) return value;
+  const bytes = new Uint8Array(value.byteLength);
+  bytes.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return bytes.buffer;
+}
+async function createEntityTag(body) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", body);
+  const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 32);
+  return `"${hash}"`;
+}
+async function finalizeMetadataImageResponse(body, headers, options) {
+  const responseHeaders = new Headers(headers);
+  const etag = await createEntityTag(body);
+  responseHeaders.set("ETag", etag);
+  responseHeaders.set("Content-Length", String(body.byteLength));
+  responseHeaders.set("X-Content-Type-Options", "nosniff");
+  const matchesEntityTag = options.ifNoneMatch?.trim() === "*" || options.ifNoneMatch?.split(",").some((candidate) => candidate.trim().replace(/^W\//, "") === etag);
+  if (matchesEntityTag) {
+    return new Response(null, { status: 304, headers: responseHeaders });
+  }
+  return new Response(options.method?.toUpperCase() === "HEAD" ? null : body, {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+async function createFarmMetadataImageResponse(value, imageModule, options = {}) {
+  const method = (options.method || "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+  if (isResponse(value)) {
+    return method === "HEAD" ? new Response(null, { status: value.status, headers: value.headers }) : value;
+  }
+  const cacheControl = resolveCacheControl(imageModule.revalidate);
+  const explicitContentType = imageModule.contentType?.split(";", 1)[0]?.trim().toLowerCase();
+  if (import_react4.default.isValidElement(value) && explicitContentType !== "image/svg+xml") {
+    const { ImageResponse } = await import("@vercel/og");
+    const element = await prepareMetadataImageNode(value);
+    const response = new ImageResponse(element, {
+      width: imageModule.size?.width || 1200,
+      height: imageModule.size?.height || 630,
+      fonts: await normalizeFonts(imageModule.fonts),
+      emoji: imageModule.emoji,
+      debug: imageModule.debug,
+      headers: { "cache-control": cacheControl }
+    });
+    const headers = new Headers(response.headers);
+    headers.set("Cache-Control", cacheControl);
+    return finalizeMetadataImageResponse(await response.arrayBuffer(), headers, options);
+  }
+  let body;
+  if (typeof value === "string") {
+    body = toArrayBuffer(new TextEncoder().encode(value));
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    body = toArrayBuffer(value);
+  } else if (import_react4.default.isValidElement(value)) {
+    body = toArrayBuffer(new TextEncoder().encode((0, import_server.renderToStaticMarkup)(value)));
+  } else {
+    throw new Error("Metadata image must return a Response, string, bytes, or React element");
+  }
+  return finalizeMetadataImageResponse(
+    body,
+    {
+      "Content-Type": imageModule.contentType || "image/svg+xml; charset=utf-8",
+      "Cache-Control": cacheControl
+    },
+    options
+  );
+}
+var import_react4, import_server, REACT_FORWARD_REF_TYPE, REACT_MEMO_TYPE, REACT_LAZY_TYPE;
+var init_metadata_image = __esm({
+  "src/metadata-image.ts"() {
+    "use strict";
+    import_react4 = __toESM(require("react"));
+    import_server = require("react-dom/server");
+    REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+    REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+    REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+    __name(isResponse, "isResponse");
+    __name(isThenable, "isThenable");
+    __name(prepareMetadataImageNode, "prepareMetadataImageNode");
+    __name(normalizeFonts, "normalizeFonts");
+    __name(resolveCacheControl, "resolveCacheControl");
+    __name(toArrayBuffer, "toArrayBuffer");
+    __name(createEntityTag, "createEntityTag");
+    __name(finalizeMetadataImageResponse, "finalizeMetadataImageResponse");
+    __name(createFarmMetadataImageResponse, "createFarmMetadataImageResponse");
+  }
+});
+
 // src/server/renderer.ts
 function hasRequestHeader(req, name) {
   const value = req.headers[name.toLowerCase()];
@@ -11411,7 +12009,7 @@ function createPPRRefreshScript() {
   return `<script>(function(){if(window.__FARM_PPR_REFRESHING__)return;window.__FARM_PPR_REFRESHING__=true;function replaceRoot(html){var doc=new DOMParser().parseFromString(html,"text/html");var next=doc.getElementById("root");var current=document.getElementById("root");if(!next||!current)return;current.innerHTML=next.innerHTML;}fetch(window.location.href,{credentials:"same-origin",headers:{"x-farm-ppr-refresh":"1"}}).then(function(response){return response.ok?response.text():null;}).then(function(html){if(html)replaceRoot(html);}).catch(function(){});})();</script>`;
 }
 function createPreHydrationClickQueueScript() {
-  return `<script>(function(){if(window.__FARM_PREHYDRATION_CLICK_QUEUE__)return;var queue=[];window.__FARM_PREHYDRATION_CLICK_QUEUE__=queue;window.__FARM_HYDRATED__=false;document.documentElement.dataset.farmHydrated="false";function isModified(event){return !!(event.metaKey||event.altKey||event.ctrlKey||event.shiftKey)}function closestQueuedTarget(target){while(target&&target!==document.documentElement){if(target.matches&&target.matches('button,[role="button"],input[type="button"],input[type="submit"],input[type="reset"]'))return target;target=target.parentElement}return null}document.addEventListener("click",function(event){if(window.__FARM_HYDRATED__)return;if(event.defaultPrevented||event.button!==0||isModified(event))return;var target=closestQueuedTarget(event.target);if(!target||target.closest&&target.closest("a[href]"))return;if(queue.some(function(item){return item.target===target}))return;queue.push({target:target,createdAt:Date.now()});event.preventDefault();event.stopImmediatePropagation()},true);})();</script>`;
+  return `<script>(function(){if(window.__FARM_PREHYDRATION_CLICK_QUEUE__)return;var queue=[];window.__FARM_PREHYDRATION_CLICK_QUEUE__=queue;window.__FARM_HYDRATED__=false;document.documentElement.dataset.farmHydrated="false";function isModified(event){return !!(event.metaKey||event.altKey||event.ctrlKey||event.shiftKey)}function closestQueuedTarget(target){while(target&&target!==document.documentElement){if(target.matches&&target.matches('button,[role="button"],input[type="button"],input[type="submit"],input[type="reset"]'))return target;target=target.parentElement}return null}document.addEventListener("click",function(event){if(window.__FARM_HYDRATED__)return;if(event.defaultPrevented||event.button!==0||isModified(event))return;var target=closestQueuedTarget(event.target);if(!target||target.closest&&target.closest("a[href]")||target.closest&&target.closest('[data-farm-island-hydrated="true"]'))return;if(queue.some(function(item){return item.target===target}))return;queue.push({target:target,createdAt:Date.now()});document.dispatchEvent(new CustomEvent("farm:island-interaction",{detail:{target:target}}));event.preventDefault();event.stopImmediatePropagation()},true);})();</script>`;
 }
 function searchParamsToObject(searchParams) {
   const output = {};
@@ -11503,12 +12101,12 @@ function createRouteStateProps(input) {
     context: input.pluginExposedContext.size > 0 ? { data: input.pluginExposedContext } : void 0
   };
 }
-var import_react4, import_server, fs2, path11, import_stream, cachedClerkProvider, importRuntimeModule, _FarmRouteErrorBoundary, FarmRouteErrorBoundary, _ServerRenderer, ServerRenderer;
+var import_react5, import_server2, fs2, path11, import_stream, cachedClerkProvider, importRuntimeModule, _FarmRouteErrorBoundary, FarmRouteErrorBoundary, _ServerRenderer, ServerRenderer;
 var init_renderer = __esm({
   "src/server/renderer.ts"() {
     "use strict";
-    import_react4 = __toESM(require("react"));
-    import_server = require("react-dom/server");
+    import_react5 = __toESM(require("react"));
+    import_server2 = require("react-dom/server");
     fs2 = __toESM(require("fs"));
     path11 = __toESM(require("path"));
     init_utils();
@@ -11531,6 +12129,7 @@ var init_renderer = __esm({
     init_routing();
     init_response();
     init_font_vite();
+    init_metadata_image();
     cachedClerkProvider = null;
     importRuntimeModule = new Function("specifier", "return import(specifier);");
     __name(hasRequestHeader, "hasRequestHeader");
@@ -11547,7 +12146,7 @@ var init_renderer = __esm({
     __name(createDeferredHydrationScript, "createDeferredHydrationScript");
     __name(toMiddlewareMap2, "toMiddlewareMap");
     __name(isWebResponse, "isWebResponse");
-    _FarmRouteErrorBoundary = class _FarmRouteErrorBoundary extends import_react4.default.Component {
+    _FarmRouteErrorBoundary = class _FarmRouteErrorBoundary extends import_react5.default.Component {
       constructor(props) {
         super(props);
         this.state = { hasError: false, error: null };
@@ -11558,7 +12157,7 @@ var init_renderer = __esm({
       render() {
         if (this.state.hasError) {
           const Fallback = this.props.Fallback;
-          return import_react4.default.createElement(Fallback, {
+          return import_react5.default.createElement(Fallback, {
             ...this.props.fallbackProps,
             error: this.state.error,
             reset: /* @__PURE__ */ __name(() => this.setState({ hasError: false, error: null }), "reset")
@@ -11727,14 +12326,14 @@ var init_renderer = __esm({
                 searchParams: Promise.resolve({}),
                 path: page2.urlPath
               };
-              let pageElement = import_react4.default.createElement(
+              let pageElement = import_react5.default.createElement(
                 PageComponent,
                 pageProps
               );
               for (let i = layoutModules.length - 1; i >= 0; i--) {
                 const layoutModule = layoutModules[i];
                 const LayoutComponent = layoutModule.default;
-                pageElement = import_react4.default.createElement(
+                pageElement = import_react5.default.createElement(
                   LayoutComponent,
                   {
                     children: pageElement,
@@ -12060,6 +12659,7 @@ var init_renderer = __esm({
           req.__FARM_ROUTE__ = pathname;
           req.__FARM_IS_CLIENT_COMPONENT__ = isClientComponent;
           req.__FARM_SHOULD_HYDRATE__ = shouldHydrate;
+          req.__FARM_ISLAND_STRATEGY__ = moduleMetadata.islandStrategy;
           req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ = hasHydratableRouteSlots;
           req.__FARM_LOADING_MODULE_PATH__ = loadingBoundaryEntry?.modulePath ? loadingBoundaryEntry.modulePath.substring(
             loadingBoundaryEntry.modulePath.indexOf("/src/app/")
@@ -12112,12 +12712,12 @@ var init_renderer = __esm({
           await _runWithMiddlewareData(middlewareDataForContext, async () => {
             await _runWithMiddlewareContext(middlewareContext, async () => {
               await _runWithCurrentRequest(currentRequest, async () => {
-                let pageElement = import_react4.default.createElement(
+                let pageElement = import_react5.default.createElement(
                   PageComponent,
                   pageProps
                 );
                 if (LoadingFallbackComponent) {
-                  const loadingFallback = import_react4.default.createElement(LoadingFallbackComponent, {
+                  const loadingFallback = import_react5.default.createElement(LoadingFallbackComponent, {
                     ...createRouteStateProps({
                       params,
                       searchParamsObject,
@@ -12126,16 +12726,21 @@ var init_renderer = __esm({
                       pluginExposedContext
                     })
                   });
-                  pageElement = import_react4.default.createElement(
-                    import_react4.default.Suspense,
+                  pageElement = import_react5.default.createElement(
+                    import_react5.default.Suspense,
                     { fallback: loadingFallback },
                     pageElement
                   );
                 }
                 if (isClientComponent || shouldHydrate) {
-                  pageElement = import_react4.default.createElement(
+                  pageElement = import_react5.default.createElement(
                     "div",
-                    { id: "__farm_page__", "data-farm-client": "true" },
+                    {
+                      id: "__farm_page__",
+                      "data-farm-client": "true",
+                      "data-farm-island": "page",
+                      "data-farm-island-strategy": moduleMetadata.islandStrategy ?? "load"
+                    },
                     pageElement
                   );
                 }
@@ -12147,11 +12752,11 @@ var init_renderer = __esm({
                   const slotProps = {};
                   for (const slot of renderedRouteSlots) {
                     if (slot.ownerPattern !== layoutEntry.pattern) continue;
-                    let slotElement = import_react4.default.createElement(
+                    let slotElement = import_react5.default.createElement(
                       slot.module.default,
                       slot.props
                     );
-                    slotElement = import_react4.default.createElement(
+                    slotElement = import_react5.default.createElement(
                       "div",
                       {
                         id: slot.containerId,
@@ -12162,7 +12767,7 @@ var init_renderer = __esm({
                     );
                     slotProps[slot.name] = slotElement;
                   }
-                  wrappedElement = import_react4.default.createElement(
+                  wrappedElement = import_react5.default.createElement(
                     LayoutComponent,
                     {
                       children: wrappedElement,
@@ -12172,7 +12777,7 @@ var init_renderer = __esm({
                   );
                 }
                 if (ErrorFallbackComponent) {
-                  wrappedElement = import_react4.default.createElement(
+                  wrappedElement = import_react5.default.createElement(
                     FarmRouteErrorBoundary,
                     {
                       Fallback: ErrorFallbackComponent,
@@ -12305,7 +12910,7 @@ var init_renderer = __esm({
             if (!cachedClerkProvider) {
               cachedClerkProvider = await importRuntimeModule("@clerk/react");
             }
-            wrapped = import_react4.default.createElement(
+            wrapped = import_react5.default.createElement(
               cachedClerkProvider.ClerkProvider,
               provider.props || {},
               wrapped
@@ -12380,6 +12985,13 @@ var init_renderer = __esm({
         return reference;
       }
       async renderMetadataImage(req, res, options) {
+        const method = (req.method || "GET").toUpperCase();
+        if (method !== "GET" && method !== "HEAD") {
+          res.statusCode = 405;
+          res.setHeader("Allow", "GET, HEAD");
+          res.end();
+          return;
+        }
         if (options.image.sourceType === "static") {
           if (!options.image.staticInfo) {
             throw new Error(`Static metadata image ${options.image.modulePath} is missing file info`);
@@ -12405,42 +13017,12 @@ var init_renderer = __esm({
         await this.writeMetadataImageResponse(req, res, handlerResult, imageModule);
       }
       async writeMetadataImageResponse(req, res, value, imageModule) {
-        if (isWebResponse(value)) {
-          res.statusCode = value.status;
-          value.headers.forEach((headerValue, key) => {
-            res.setHeader(key, headerValue);
-          });
-          if (req.method === "HEAD") {
-            res.end();
-            return;
-          }
-          const body2 = Buffer.from(await value.arrayBuffer());
-          res.write(body2);
-          res.end();
-          return;
-        }
-        const contentType = imageModule.contentType || "image/svg+xml; charset=utf-8";
-        let body;
-        if (typeof value === "string") {
-          body = value;
-        } else if (value instanceof ArrayBuffer) {
-          body = Buffer.from(value);
-        } else if (ArrayBuffer.isView(value)) {
-          body = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-        } else if (import_react4.default.isValidElement(value)) {
-          body = (0, import_server.renderToStaticMarkup)(value);
-        } else {
-          throw new Error("Metadata image must return a Response, string, bytes, or React element");
-        }
-        res.statusCode = res.statusCode || 200;
-        res.setHeader("Content-Type", contentType);
-        res.setHeader("Cache-Control", "public, max-age=0, must-revalidate");
-        if (req.method === "HEAD") {
-          res.end();
-          return;
-        }
-        res.write(body);
-        res.end();
+        const ifNoneMatch = req.headers["if-none-match"];
+        const response = await createFarmMetadataImageResponse(value, imageModule, {
+          method: req.method,
+          ifNoneMatch: Array.isArray(ifNoneMatch) ? ifNoneMatch[0] : ifNoneMatch
+        });
+        await sendWebResponse(res, response);
       }
       async writeStaticMetadataImageResponse(req, res, image) {
         const method = (req.method || "GET").toUpperCase();
@@ -12487,7 +13069,7 @@ var init_renderer = __esm({
             return false;
           }
           const ErrorComponent = errorModule.default;
-          const errorElement = import_react4.default.createElement(ErrorComponent, {
+          const errorElement = import_react5.default.createElement(ErrorComponent, {
             ...createRouteStateProps({
               params: options.params,
               searchParamsObject: options.searchParamsObject,
@@ -12505,7 +13087,7 @@ var init_renderer = __esm({
           );
           for (let i = layoutModules.length - 1; i >= 0; i--) {
             const LayoutComponent = layoutModules[i].default;
-            wrapped = import_react4.default.createElement(
+            wrapped = import_react5.default.createElement(
               LayoutComponent,
               {
                 children: wrapped,
@@ -12570,6 +13152,7 @@ var init_renderer = __esm({
               search: routeEntry.search,
               isClientComponent: routeEntry.isClientComponent,
               shouldHydrate: routeEntry.shouldHydrate,
+              islandStrategy: routeEntry.islandStrategy,
               preloads: [routeEntry.modulePath],
               assets: []
             };
@@ -12606,6 +13189,7 @@ window.__FARM_DEPLOYMENT_ID__ = ${serializeInlineValue(deploymentId)};
 window.__FARM_PATH__ = ${JSON.stringify(req.__FARM_ROUTE__ || req.url || "/")};
 window.__FARM_IS_CLIENT__ = ${JSON.stringify(isClientComponent)};
 window.__FARM_SHOULD_HYDRATE__ = ${JSON.stringify(req.__FARM_SHOULD_HYDRATE__ === true)};
+window.__FARM_ISLAND_STRATEGY__ = ${JSON.stringify(req.__FARM_ISLAND_STRATEGY__ || "load")};
 window.__FARM_PAGE_MODULE__ = ${JSON.stringify(relativePath2)};
 window.__FARM_LOADING_MODULE__ = ${JSON.stringify(
             req.__FARM_LOADING_MODULE_PATH__ || null
@@ -12623,8 +13207,8 @@ ${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 streamRoot = import_react4.default.createElement("div", { style: { display: "contents" } }, element);
-          const { pipe, abort } = (0, import_server.renderToPipeableStream)(streamRoot, {
+          const streamRoot = import_react5.default.createElement("div", { style: { display: "contents" } }, element);
+          const { pipe, abort } = (0, import_server2.renderToPipeableStream)(streamRoot, {
             onShellReady() {
               const shellReadyMs = Date.now() - streamStartTime;
               emitFarmEvent({
@@ -12782,12 +13366,12 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                   break;
                 }
               }
-              let element = import_react4.default.createElement(
+              let element = import_react5.default.createElement(
                 NotFoundComponent,
                 { pathname }
               );
               if (LayoutComponent) {
-                element = import_react4.default.createElement(
+                element = import_react5.default.createElement(
                   LayoutComponent,
                   { children: element }
                 );
@@ -12937,6 +13521,7 @@ var init_app = __esm({
     init_server2();
     init_cache();
     init_auth_config();
+    init_preload();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -13002,6 +13587,7 @@ var init_app = __esm({
           context: config.context || (() => void 0),
           serverActions: resolveServerActionsConfig(config.serverActions),
           images: resolveFarmImageConfig(config.images),
+          performance: resolveFarmPerformanceConfig(config.performance),
           i18n: isResolvedI18nConfig(config.i18n) ? config.i18n : resolveFarmI18nConfig(config.i18n, {
             root,
             mode: process.env.NODE_ENV === "production" ? "production" : "development"
@@ -14595,6 +15181,49 @@ var init_search_client = __esm({
   }
 });
 
+// src/docs/fonts.ts
+function resolveFarmDocsFontAssets(root) {
+  return FARM_DOCS_FONT_SOURCES.flatMap(({ family, packagePath }) => {
+    const sourcePath = import_node_path8.default.join(root, "node_modules", packagePath);
+    if (!(0, import_node_fs5.existsSync)(sourcePath)) return [];
+    const source = (0, import_node_fs5.readFileSync)(sourcePath);
+    const fingerprint = (0, import_node_crypto3.createHash)("sha256").update(source).digest("hex").slice(0, 12);
+    const extension = import_node_path8.default.extname(packagePath);
+    const baseName = import_node_path8.default.basename(packagePath, extension);
+    return [
+      {
+        family,
+        sourcePath,
+        url: `/assets/fonts/${baseName}-h${fingerprint}${extension}`
+      }
+    ];
+  });
+}
+function toFarmDocsPublicFontAssets(assets) {
+  return assets.map(({ family, url }) => ({ family, url }));
+}
+var import_node_crypto3, import_node_fs5, import_node_path8, FARM_DOCS_FONT_SOURCES;
+var init_fonts = __esm({
+  "src/docs/fonts.ts"() {
+    "use strict";
+    import_node_crypto3 = require("crypto");
+    import_node_fs5 = require("fs");
+    import_node_path8 = __toESM(require("path"));
+    FARM_DOCS_FONT_SOURCES = [
+      {
+        family: "Geist Sans",
+        packagePath: "geist/dist/fonts/geist-sans/Geist-Variable.woff2"
+      },
+      {
+        family: "Geist Mono",
+        packagePath: "geist/dist/fonts/geist-mono/GeistMono-Variable.woff2"
+      }
+    ];
+    __name(resolveFarmDocsFontAssets, "resolveFarmDocsFontAssets");
+    __name(toFarmDocsPublicFontAssets, "toFarmDocsPublicFontAssets");
+  }
+});
+
 // src/default-styles.ts
 var defaultGlobalCSS;
 var init_default_styles = __esm({
@@ -15002,12 +15631,12 @@ var init_module = __esm({
 function isMiddlewareResponse(value) {
   return value instanceof Response;
 }
-var fs4, path18, _MiddlewareManager, MiddlewareManager;
+var fs4, path19, _MiddlewareManager, MiddlewareManager;
 var init_manager = __esm({
   "src/middleware/manager.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"));
-    path18 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     init_context();
     init_module();
     init_utils();
@@ -15087,8 +15716,8 @@ var init_manager = __esm({
         const entries = fs4.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-            const subPath = path18.join(dir, entry.name);
-            const subRoutePath = path18.posix.join(routePath, entry.name);
+            const subPath = path19.join(dir, entry.name);
+            const subRoutePath = path19.posix.join(routePath, entry.name);
             await this.discoverInDirectory(subPath, subRoutePath, discovered);
           }
         }
@@ -15099,7 +15728,7 @@ var init_manager = __esm({
       findMiddlewareFile(dir) {
         const extensions = [".ts", ".tsx", ".js", ".jsx"];
         for (const ext of extensions) {
-          const filePath = path18.join(dir, `middleware${ext}`);
+          const filePath = path19.join(dir, `middleware${ext}`);
           if (fs4.existsSync(filePath)) {
             return filePath;
           }
@@ -15450,7 +16079,7 @@ var init_manager = __esm({
 // src/write-file-if-changed.ts
 function writeFileIfChanged(filePath, content) {
   try {
-    if ((0, import_node_fs5.readFileSync)(filePath, "utf8") === content) {
+    if ((0, import_node_fs6.readFileSync)(filePath, "utf8") === content) {
       return false;
     }
   } catch (error) {
@@ -15458,14 +16087,14 @@ function writeFileIfChanged(filePath, content) {
       throw error;
     }
   }
-  (0, import_node_fs5.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs6.writeFileSync)(filePath, content, "utf8");
   return true;
 }
-var import_node_fs5;
+var import_node_fs6;
 var init_write_file_if_changed = __esm({
   "src/write-file-if-changed.ts"() {
     "use strict";
-    import_node_fs5 = require("fs");
+    import_node_fs6 = require("fs");
     __name(writeFileIfChanged, "writeFileIfChanged");
   }
 });
@@ -15566,11 +16195,11 @@ var init_type_generator = __esm({
           routeGroups.get(key).push(route);
         }
         const nestedStructure = {};
-        for (const [path29, routeList] of routeGroups) {
+        for (const [path31, routeList] of routeGroups) {
           const route = routeList[0];
           const importPath = this.getRouteImportPath(route, options.outFile);
           const routeName = this.pathToRouteName(route.path);
-          const cleanPath = path29 === "/api" ? "" : path29.replace(/^\/api\//, "");
+          const cleanPath = path31 === "/api" ? "" : path31.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const allMethods = routeList.flatMap((r) => r.methods);
           for (const method of allMethods) {
@@ -15629,8 +16258,8 @@ ${typeExports}
         const relativeImport = (0, import_path10.relative)((0, import_path10.dirname)(outFile), route.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path29) {
-        return (path29 === "/api" ? "root" : path29.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+      pathToRouteName(path31) {
+        return (path31 === "/api" ? "root" : path31.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
       }
       structureToTypeString(obj, indent) {
         const spaces = "  ".repeat(indent);
@@ -15650,15 +16279,15 @@ ${typeExports}
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path29) {
-        const cleanPath = path29.replace(/^\/api\//, "");
+      getBaseExportName(path31) {
+        const cleanPath = path31.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path29, method) {
-        const cleanPath = path29.replace(/^\/api\//, "");
+      getExportName(path31, method) {
+        const cleanPath = path31.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -15720,12 +16349,12 @@ function createRoutePattern(route) {
   }).join("/");
 }
 async function generateRouteTypes(options) {
-  const root = path19.resolve(options.root);
+  const root = path20.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path19.isAbsolute(outFile) ? outFile : path19.join(root, srcDir, outFile);
+  const outPath = path20.isAbsolute(outFile) ? outFile : path20.join(root, srcDir, outFile);
   const content = await createRouteTypeDeclarations(options, outPath);
-  fs5.mkdirSync(path19.dirname(outPath), { recursive: true });
+  fs5.mkdirSync(path20.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
@@ -15733,39 +16362,48 @@ async function createRouteTypeDeclarations(options, outPath) {
   const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
   const patterns = /* @__PURE__ */ new Set();
+  const routeModulePatterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path19.join(source.root, source.srcDir, "app");
+    const appDir = path20.join(source.root, source.srcDir, "app");
     if (fs5.existsSync(appDir)) {
-      const pageFiles = await glob.default("**/page.{ts,tsx,js,jsx,md,mdx}", {
-        cwd: appDir,
-        absolute: false
-      });
-      for (const file of pageFiles) {
+      const routeModuleFiles = await glob.default(
+        "**/{page,layout,loading,error}.{ts,tsx,js,jsx,md,mdx}",
+        {
+          cwd: appDir,
+          absolute: false
+        }
+      );
+      for (const file of routeModuleFiles) {
         if (parseRouteSlotFile(file)) continue;
         const route = parseRoutePath(file);
+        const pattern = createRoutePattern(route);
+        routeModulePatterns.add(pattern);
         if (route.type === "page") {
-          const pattern = createRoutePattern(route);
           patterns.add(pattern);
         }
       }
     }
     for (const route of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
       patterns.add(route);
+      routeModulePatterns.add(route);
     }
   }
   for (const route of extraRoutes) {
     if (route.startsWith("/")) {
       patterns.add(route);
+      routeModulePatterns.add(route);
     }
   }
   const sortedPatterns = Array.from(patterns).sort();
   const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
+  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
   const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
   const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
-  const routeTypesImportPath = `./${path19.basename(outPath).replace(/\.d\.ts$/, "")}`;
-  const augmentationBlock = suppressLintOnLink ? "" : `
+  const routeModulePatternType = routeModulePatternLiterals.length ? routeModulePatternLiterals.join(" | ") : "never";
+  const routeTypesImportPath = `./${path20.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
     _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
@@ -15789,22 +16427,33 @@ declare module "@farm.js/core/dist/client.js" {
     pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
+`;
+  const routeModuleAugmentationBlock = `
+declare global {
+  namespace FarmJS {
+    interface RouteRegistry {
+      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
+    }
+  }
+}
 `;
   const content = `/**
  * Auto-generated route types from src/app.
- * Link href is typed automatically via module augmentation. Regenerated on dev start and when routes change.
+ * Link href and route component props are typed automatically from generated declarations.
+ * Regenerated on dev start and when routes change.
  * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
  */
 export type RoutePath = ${routePathType};
-export type RoutePattern = ${routePatternType};${augmentationBlock}
+export type RoutePattern = ${routePatternType};
+export type RouteModulePattern = ${routeModulePatternType};${linkAugmentationBlock}${routeModuleAugmentationBlock}
 `;
   return content;
 }
-var path19, fs5, DEFAULT_OUT_FILE;
+var path20, fs5, DEFAULT_OUT_FILE;
 var init_generate_route_types = __esm({
   "src/routing/generate-route-types.ts"() {
     "use strict";
-    path19 = __toESM(require("path"));
+    path20 = __toESM(require("path"));
     fs5 = __toESM(require("fs"));
     init_utils();
     init_route_slots();
@@ -15822,17 +16471,17 @@ var init_generate_route_types = __esm({
 
 // src/env-types.ts
 async function generateEnvTypes(options) {
-  const root = path20.resolve(options.root);
+  const root = path21.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE2;
-  const outPath = path20.isAbsolute(outFile) ? outFile : path20.join(root, srcDir, outFile);
+  const outPath = path21.isAbsolute(outFile) ? outFile : path21.join(root, srcDir, outFile);
   const content = createEnvTypeDeclarations(options, outPath);
-  fs6.mkdirSync(path20.dirname(outPath), { recursive: true });
+  fs6.mkdirSync(path21.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
 function createEnvTypeDeclarations(options, outPath) {
-  const root = path20.resolve(options.root);
+  const root = path21.resolve(options.root);
   const configPath = findConfigPath(root, options.configPath);
   const configPaths = [
     ...(options.layerConfigPaths ?? []).filter((value) => fs6.existsSync(value)),
@@ -15895,11 +16544,11 @@ export {};
 }
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path20.isAbsolute(configPath) ? configPath : path20.join(root, configPath);
+    const resolvedPath = path21.isAbsolute(configPath) ? configPath : path21.join(root, configPath);
     return fs6.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path20.join(root, filename);
+    const resolvedPath = path21.join(root, filename);
     if (fs6.existsSync(resolvedPath)) {
       return resolvedPath;
     }
@@ -15960,15 +16609,15 @@ export {};
 `;
 }
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath2 = path20.relative(path20.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path21.relative(path21.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
-var fs6, path20, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
+var fs6, path21, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
 var init_env_types = __esm({
   "src/env-types.ts"() {
     "use strict";
     fs6 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
+    path21 = __toESM(require("path"));
     init_write_file_if_changed();
     DEFAULT_OUT_FILE2 = "farm-env.d.ts";
     CONFIG_FILENAMES2 = [
@@ -16001,8 +16650,8 @@ var init_env_types = __esm({
 
 // src/image-types.ts
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? import_node_path8.default.resolve(options.root, options.outFile) : import_node_path8.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  (0, import_node_fs6.mkdirSync)(import_node_path8.default.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? import_node_path9.default.resolve(options.root, options.outFile) : import_node_path9.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  (0, import_node_fs7.mkdirSync)(import_node_path9.default.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -16026,12 +16675,12 @@ declare module "*?url" {
 }
 `;
 }
-var import_node_fs6, import_node_path8, FARM_STATIC_IMAGE_EXTENSIONS;
+var import_node_fs7, import_node_path9, FARM_STATIC_IMAGE_EXTENSIONS;
 var init_image_types = __esm({
   "src/image-types.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
-    import_node_path8 = __toESM(require("path"));
+    import_node_fs7 = require("fs");
+    import_node_path9 = __toESM(require("path"));
     init_write_file_if_changed();
     FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
     __name(generateFarmImageTypes, "generateFarmImageTypes");
@@ -16043,9 +16692,9 @@ var init_image_types = __esm({
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? (0, import_node_path9.resolve)(options.root, options.outFile) : (0, import_node_path9.join)((0, import_node_path9.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path10.resolve)(options.root, options.outFile) : (0, import_node_path10.join)((0, import_node_path10.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs7.mkdirSync)((0, import_node_path9.dirname)(outFile), { recursive: true });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path10.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -16086,12 +16735,12 @@ function argumentType(kind) {
       return "string";
   }
 }
-var import_node_fs7, import_node_path9;
+var import_node_fs8, import_node_path10;
 var init_type_generator2 = __esm({
   "src/i18n/type-generator.ts"() {
     "use strict";
-    import_node_fs7 = require("fs");
-    import_node_path9 = require("path");
+    import_node_fs8 = require("fs");
+    import_node_path10 = require("path");
     init_catalog();
     init_write_file_if_changed();
     __name(generateFarmI18nTypes, "generateFarmI18nTypes");
@@ -16246,7 +16895,7 @@ var init_type_artifacts = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.11";
+    version = "0.1.0-beta.14";
   }
 });
 
@@ -16426,12 +17075,12 @@ async function createBlurDataURL(bytes) {
     return void 0;
   }
 }
-var import_promises7, import_node_path10, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
+var import_promises7, import_node_path11, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
 var init_image_vite = __esm({
   "src/image-vite.ts"() {
     "use strict";
     import_promises7 = require("fs/promises");
-    import_node_path10 = __toESM(require("path"));
+    import_node_path11 = __toESM(require("path"));
     import_image_size2 = require("image-size");
     FARM_IMAGE_ID_PREFIX = "\0farm:image:";
     STATIC_IMAGE_RE = /\.(?:avif|gif|jpe?g|png|webp)$/i;
@@ -16442,6 +17091,22 @@ var init_image_vite = __esm({
   }
 });
 
+// src/font.ts
+function resolveFarmLayoutFonts(layouts) {
+  let resolved;
+  for (const layout2 of layouts) {
+    if (!layout2.fonts) continue;
+    resolved = { ...resolved, ...layout2.fonts };
+  }
+  return resolved;
+}
+var init_font = __esm({
+  "src/font.ts"() {
+    "use strict";
+    __name(resolveFarmLayoutFonts, "resolveFarmLayoutFonts");
+  }
+});
+
 // src/image-server.ts
 function createFarmImageHandler(config, options) {
   const fetcher = options.fetch ?? globalThis.fetch;
@@ -16858,6 +17523,106 @@ var init_image_server = __esm({
   }
 });
 
+// src/server/vite-config.ts
+function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
+  const resolvedProjectRoot = import_node_path12.default.resolve(projectRoot);
+  return appDirectories.map((appDirectory) => {
+    const relativeAppDirectory = import_node_path12.default.relative(resolvedProjectRoot, import_node_path12.default.resolve(appDirectory)).replace(/\\/g, "/");
+    const prefix = relativeAppDirectory || ".";
+    return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
+  });
+}
+function createFarmClientOptimizeDepsConfig(entries) {
+  return {
+    // Keep normal application dependency discovery for CJS-only packages, but
+    // seed every Farm browser runtime so React is present in the first crawl.
+    noDiscovery: false,
+    // Waiting for the crawl avoids serving a partial optimizer generation and
+    // then changing browser hashes while hydration is already in progress.
+    holdUntilCrawlEnd: true,
+    include: [...FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE],
+    // Farm's HTML boots through a virtual module and imports route UI lazily.
+    // Explicit entries let Vite finish that crawl before a navigation can
+    // rotate the optimizer hash underneath a hydrated React runtime.
+    ...entries?.length ? { entries: [...entries] } : {}
+  };
+}
+function mergeNoExternal(farmValue, userValue) {
+  if (farmValue === true || userValue === true) return true;
+  const normalize = /* @__PURE__ */ __name((value) => value == null || value === true ? [] : Array.isArray(value) ? value : [value], "normalize");
+  return Array.from(/* @__PURE__ */ new Set([...normalize(farmValue), ...normalize(userValue)]));
+}
+function mergeFarmViteConfig(farmConfig, userConfig = {}) {
+  const noDiscovery = userConfig.optimizeDeps?.noDiscovery ?? farmConfig.optimizeDeps?.noDiscovery;
+  const holdUntilCrawlEnd = userConfig.optimizeDeps?.holdUntilCrawlEnd ?? (userConfig.optimizeDeps?.noDiscovery === true ? false : farmConfig.optimizeDeps?.holdUntilCrawlEnd);
+  return {
+    ...farmConfig,
+    ...userConfig,
+    plugins: [...farmConfig.plugins || [], ...userConfig.plugins || []],
+    server: {
+      ...farmConfig.server,
+      ...userConfig.server
+    },
+    resolve: {
+      ...farmConfig.resolve,
+      ...userConfig.resolve,
+      dedupe: Array.from(
+        /* @__PURE__ */ new Set([...farmConfig.resolve?.dedupe || [], ...userConfig.resolve?.dedupe || []])
+      )
+    },
+    optimizeDeps: {
+      ...farmConfig.optimizeDeps,
+      ...userConfig.optimizeDeps,
+      noDiscovery,
+      holdUntilCrawlEnd,
+      include: Array.from(
+        /* @__PURE__ */ new Set([
+          ...farmConfig.optimizeDeps?.include || [],
+          ...userConfig.optimizeDeps?.include || []
+        ])
+      ),
+      exclude: Array.from(
+        /* @__PURE__ */ new Set([
+          ...farmConfig.optimizeDeps?.exclude || [],
+          ...userConfig.optimizeDeps?.exclude || []
+        ])
+      )
+    },
+    ssr: {
+      ...farmConfig.ssr,
+      ...userConfig.ssr,
+      noExternal: mergeNoExternal(farmConfig.ssr?.noExternal, userConfig.ssr?.noExternal)
+    }
+  };
+}
+var import_node_path12, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
+var init_vite_config = __esm({
+  "src/server/vite-config.ts"() {
+    "use strict";
+    import_node_path12 = __toESM(require("path"));
+    FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
+    FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
+      "react",
+      "react-dom",
+      "react-dom/client",
+      "react/jsx-runtime",
+      "react/jsx-dev-runtime",
+      "@farm.js/core/client",
+      "@farm.js/core/plugin/client",
+      "@farm.js/core/deferred",
+      "@farm.js/core/deployment",
+      "@farm.js/core/i18n/client",
+      "@farm.js/core/query/client",
+      "@farm.js/core/server-fn/client",
+      "@farm.js/core/server-query/client"
+    ];
+    __name(createFarmClientOptimizeDepsEntries, "createFarmClientOptimizeDepsEntries");
+    __name(createFarmClientOptimizeDepsConfig, "createFarmClientOptimizeDepsConfig");
+    __name(mergeNoExternal, "mergeNoExternal");
+    __name(mergeFarmViteConfig, "mergeFarmViteConfig");
+  }
+});
+
 // src/docs/pixel-border-css.ts
 var farmDocsPixelBorderCss;
 var init_pixel_border_css = __esm({
@@ -16903,8 +17668,8 @@ var init_pixel_border_css = __esm({
   --scrollbar-thumb-hover: var(--color-fd-ring);
   --scrollbar-track: transparent;
   --radius: 0px;
-  --font-geist-sans: "Geist Sans";
-  --font-geist-mono: "Geist Mono";
+  --font-geist-sans: ui-sans-serif, system-ui, sans-serif;
+  --font-geist-mono: ui-monospace, monospace;
 }
 
 .dark {
@@ -16917,28 +17682,6 @@ body,
   background-color: var(--color-fd-background) !important;
 }
 
-@font-face {
-  font-family: "Geist Sans";
-  font-display: block;
-  font-style: normal;
-  font-weight: 100 900;
-  src:
-    local("Geist Sans"),
-    url("/assets/Geist-Variable-CrgPqtmy.woff2") format("woff2"),
-    url("/node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2") format("woff2");
-}
-
-@font-face {
-  font-family: "Geist Mono";
-  font-display: block;
-  font-style: normal;
-  font-weight: 100 900;
-  src:
-    local("Geist Mono"),
-    url("/assets/GeistMono-Variable-BNLlm6Cd.woff2") format("woff2"),
-    url("/node_modules/geist/dist/fonts/geist-mono/GeistMono-Variable.woff2") format("woff2");
-}
-
 * {
   scrollbar-color: var(--scrollbar-thumb) var(--scrollbar-track);
   scrollbar-width: thin;
@@ -18129,11 +18872,418 @@ code:not(pre code) {
   }
 });
 
+// src/docs/social-image.ts
+function normalizeEntry(entry) {
+  if (!entry || entry === "/") return "";
+  return `/${entry.replace(/^\/+|\/+$/g, "")}`;
+}
+function encodeSlugPath(slug) {
+  return slug.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+}
+function getSocialImageConfig(docs) {
+  return typeof docs.config.socialImage === "object" && docs.config.socialImage ? docs.config.socialImage : void 0;
+}
+function getNavTitle(docs) {
+  if (typeof docs.config.nav !== "object" || !docs.config.nav || !("title" in docs.config.nav)) {
+    return "Farm.js";
+  }
+  return String(docs.config.nav.title || "Farm.js");
+}
+function isFalse(value) {
+  return value ? /^(false|no|none|off|disabled)$/i.test(value.trim()) : false;
+}
+function isExternalOrRootPath(value) {
+  return /^(https?:)?\/\//i.test(value) || value.startsWith("/");
+}
+function isFarmDocsSocialImageEnabled(page2, docs) {
+  if (docs.config.socialImage === false || getSocialImageConfig(docs)?.enabled === false) {
+    return false;
+  }
+  return !isFalse(page2.frontmatter.socialImage);
+}
+function getFarmDocsCustomSocialImage(page2) {
+  const value = page2.frontmatter.socialImage || page2.frontmatter.openGraphImage || page2.frontmatter.ogImage;
+  return value && !isFalse(value) && isExternalOrRootPath(value) ? value : void 0;
+}
+function resolveIllustration(page2) {
+  const explicit = page2.frontmatter.socialIllustration?.toLowerCase();
+  if (explicit === "auth" || explicit === "cache" || explicit === "cli" || explicit === "integrations" || explicit === "project" || explicit === "routing" || explicit === "runtime") {
+    return explicit;
+  }
+  const source = `${page2.slug} ${page2.title} ${page2.section || ""}`.toLowerCase();
+  if (/auth|session|security|csrf/.test(source)) return "auth";
+  if (/cache|ppr|render|static|revalid|stream/.test(source)) return "cache";
+  if (/integration|stripe|prisma|better.auth|email|job|workflow/.test(source)) {
+    return "integrations";
+  }
+  if (/cli|test|deploy|preview|upgrade|migration|install/.test(source)) return "cli";
+  if (/project|structure|config|environment|markdown|docs.engine/.test(source)) {
+    return "project";
+  }
+  if (/rout|endpoint|middleware|navigation|server.function|server.action|api/.test(source)) {
+    return "routing";
+  }
+  return "runtime";
+}
+function createHashValue(value) {
+  return (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
+}
+function resolveBaseUrl(requestUrl, config) {
+  return config?.baseUrl ? new URL(config.baseUrl) : new URL(requestUrl.origin);
+}
+function createFarmDocsSocialImageDescriptor(page2, docs, requestUrl) {
+  const config = getSocialImageConfig(docs);
+  const siteName = config?.siteName || getNavTitle(docs);
+  const brand = config?.brand || siteName;
+  const title = page2.frontmatter.socialTitle || page2.title;
+  const description = page2.frontmatter.socialDescription || page2.description || docs.config.metadata?.description || `Documentation for ${siteName}`;
+  const section = page2.frontmatter.section || page2.section || "Documentation";
+  const illustration = resolveIllustration(page2);
+  const entry = normalizeEntry(docs.entry);
+  const slugPath = encodeSlugPath(page2.slug) || "index";
+  const imagePath = `${entry}/_social/${slugPath}/opengraph-image.svg`;
+  const baseUrl = resolveBaseUrl(requestUrl, config);
+  const pageUrl = new URL(page2.href, baseUrl).href;
+  const imageAlt = `${title} \u2014 ${siteName} documentation`;
+  const hash = createHashValue({
+    version: FARM_DOCS_SOCIAL_IMAGE_VERSION,
+    title,
+    description,
+    section,
+    siteName,
+    brand,
+    pageHref: page2.href,
+    illustration,
+    fonts: config?.fonts
+  });
+  return {
+    title,
+    description,
+    section,
+    siteName,
+    brand,
+    pageHref: page2.href,
+    pageUrl,
+    imagePath,
+    imageUrl: new URL(`${imagePath}?v=${hash}`, baseUrl).href,
+    imageAlt,
+    illustration,
+    fonts: config?.fonts,
+    hash
+  };
+}
+function getFarmDocsSocialImageSlug(docs, requestUrl) {
+  const entry = normalizeEntry(docs.entry);
+  const prefix = `${entry}/_social/`;
+  const suffix = "/opengraph-image.svg";
+  if (!requestUrl.pathname.startsWith(prefix) || !requestUrl.pathname.endsWith(suffix)) {
+    return null;
+  }
+  const rawSlug = requestUrl.pathname.slice(prefix.length, -suffix.length);
+  if (!rawSlug) return null;
+  try {
+    const slug = rawSlug.split("/").map((segment) => decodeURIComponent(segment)).join("/");
+    if (slug.split("/").some((segment) => !segment || segment === ".." || segment === ".")) {
+      return null;
+    }
+    return slug === "index" ? "" : slug;
+  } catch {
+    return null;
+  }
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function truncate(value, length) {
+  if (value.length <= length) return value;
+  return `${value.slice(0, Math.max(0, length - 1)).trimEnd()}\u2026`;
+}
+function wrapText(value, maxCharacters, maxLines) {
+  const words = value.trim().split(/\s+/).filter(Boolean);
+  const lines = [];
+  let current = "";
+  let consumedWords = 0;
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (candidate.length <= maxCharacters || !current) {
+      current = candidate;
+      consumedWords += 1;
+      continue;
+    }
+    lines.push(current);
+    if (lines.length === maxLines) break;
+    current = word;
+    consumedWords += 1;
+  }
+  if (current && lines.length < maxLines) lines.push(current);
+  if (consumedWords < words.length && lines.length) {
+    lines[lines.length - 1] = truncate(`${lines[lines.length - 1]}\u2026`, maxCharacters);
+  }
+  return lines;
+}
+function renderTextLines(lines, x, y, lineHeight, attributes) {
+  return lines.map(
+    (line, index) => `<text x="${x}" y="${y + index * lineHeight}" ${attributes}>${escapeXml(line)}</text>`
+  ).join("");
+}
+function renderEmbeddedFont(name, source, weight) {
+  if (!source) return "";
+  return `@font-face{font-family:"${name}";src:url("${escapeXml(source)}") format("woff2");font-style:normal;font-weight:${weight};font-display:block;}`;
+}
+function renderArrow(x1, y, x2, color = "#8b8b8b") {
+  return `<path d="M${x1} ${y}H${x2 - 9}" fill="none" stroke="${color}"/><path d="m${x2 - 9} ${y - 5} 9 5-9 5" fill="none" stroke="${color}"/>`;
+}
+function renderPanelHeader(label, status) {
+  return `<text x="819" y="171" class="label">${escapeXml(label)}</text><text x="1134" y="171" class="label bright" text-anchor="end">${escapeXml(status)}</text>`;
+}
+function renderRoutingIllustration() {
+  return `${renderPanelHeader("ROUTE BLUEPRINT", "TYPED")}
+    <rect x="819" y="296" width="92" height="54" fill="#a3a3a3"/>
+    <text x="832" y="327" class="diagram-title ink">src/app</text>
+    <path d="M911 323h41M952 232v181M952 232h44M952 323h44M952 413h44" fill="none" stroke="#696969"/>
+    <rect x="996" y="205" width="138" height="54" fill="#0a0a0a" stroke="#414141"/>
+    <text x="1010" y="228" class="diagram-title">/</text><text x="1010" y="246" class="micro">STATIC</text>
+    <rect x="996" y="296" width="138" height="54" fill="#0a0a0a" stroke="#414141"/>
+    <text x="1010" y="319" class="diagram-title">/blog/:slug</text><text x="1010" y="337" class="micro">DYNAMIC</text>
+    <rect x="996" y="386" width="138" height="55" fill="#f0f0f0"/>
+    <text x="1010" y="410" class="diagram-title ink">/docs/:path*</text><text x="1010" y="428" class="micro ink-muted">CATCH-ALL</text>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">FILE ROUTES</text><text x="1134" y="475" class="label" text-anchor="end">TYPES INCLUDED</text>`;
+}
+function renderAuthIllustration() {
+  return `${renderPanelHeader("REQUEST GUARD", "SERVER VERIFIED")}
+    <rect x="819" y="269" width="86" height="54" fill="#0a0a0a" stroke="#454545"/>
+    <text x="837" y="292" class="micro bright">REQUEST</text><text x="837" y="310" class="diagram-title">GET /app</text>
+    ${renderArrow(905, 296, 943)}
+    <rect x="943" y="224" width="104" height="118" fill="#f0f0f0"/>
+    <path d="M974 271v-12a21 21 0 0 1 42 0v12M968 271h54v45h-54z" fill="#050505"/>
+    <circle cx="995" cy="292" r="4" fill="#f0f0f0"/><path d="M995 296v8" stroke="#f0f0f0" stroke-width="3"/>
+    <text x="995" y="332" class="micro ink" text-anchor="middle">auth()</text>
+    ${renderArrow(1047, 296, 1071)}
+    <rect x="1071" y="269" width="63" height="54" fill="#0a0a0a" stroke="#454545"/>
+    <text x="1082" y="292" class="micro bright">ALLOW</text><text x="1082" y="310" class="micro">/app</text>
+    <rect x="819" y="372" width="315" height="38" fill="#090909" stroke="#3d3d3d"/>
+    <rect x="832" y="385" width="11" height="11" fill="#a3a3a3"/>
+    <text x="856" y="395" class="code">session.user / verified</text>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">SESSION TYPED</text><text x="1134" y="475" class="label" text-anchor="end">CSRF PROTECTED</text>`;
+}
+function renderCacheIllustration() {
+  return `${renderPanelHeader("PAGE / PRODUCT", "CACHE + PPR")}
+    <rect x="819" y="204" width="315" height="54" fill="#f0f0f0"/>
+    <text x="836" y="235" class="diagram-title ink">STATIC SHELL</text><text x="1116" y="235" class="micro ink-muted" text-anchor="end">BUILD</text>
+    <rect x="819" y="271" width="198" height="76" fill="#a3a3a3"/>
+    <text x="836" y="301" class="diagram-title ink">CACHED DATA</text><text x="836" y="326" class="micro ink-muted">tag: products</text>
+    <rect x="1029" y="271" width="105" height="76" fill="#0a0a0a" stroke="#555"/>
+    <text x="1045" y="301" class="diagram-title">LIVE</text><text x="1045" y="326" class="micro">stream</text>
+    <path d="M1081 347v43m-8-9 8 9 8-9" fill="none" stroke="#d4d4d4"/>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">STATIC FIRST</text><text x="1134" y="475" class="label" text-anchor="end">DYNAMIC WHERE NEEDED</text>`;
+}
+function renderIntegrationsIllustration() {
+  return `${renderPanelHeader("INTEGRATION GRAPH", "ONE PRODUCT")}
+    <path d="M976 309H879V247M976 309H879v87M1030 309h93V247M1030 309h93v87" fill="none" stroke="#4a4a4a"/>
+    <rect x="819" y="214" width="120" height="57" fill="#0a0a0a" stroke="#4b4b4b"/><text x="839" y="247" class="diagram-title">BETTER AUTH</text>
+    <rect x="819" y="368" width="120" height="57" fill="#0a0a0a" stroke="#4b4b4b"/><text x="851" y="401" class="diagram-title">PRISMA</text>
+    <rect x="1061" y="214" width="73" height="57" fill="#0a0a0a" stroke="#4b4b4b"/><text x="1077" y="247" class="diagram-title">STRIPE</text>
+    <rect x="1061" y="368" width="73" height="57" fill="#a3a3a3"/><text x="1075" y="401" class="diagram-title ink">VERCEL</text>
+    <rect x="976" y="277" width="94" height="64" fill="#f0f0f0"/>
+    <text x="994" y="304" class="diagram-title ink">FARM.JS</text><text x="994" y="324" class="micro ink-muted">CORE</text>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">BRING YOUR STACK</text><text x="1134" y="475" class="label" text-anchor="end">CONNECTED ONCE</text>`;
+}
+function renderCliIllustration() {
+  return `${renderPanelHeader("TERMINAL", "PRODUCTION OUTPUT")}
+    <rect x="819" y="203" width="315" height="213" fill="#050505" stroke="#555"/>
+    <line x1="819" y1="236" x2="1134" y2="236" stroke="#555"/>
+    <circle cx="837" cy="220" r="4" fill="#5d5d5d"/><circle cx="850" cy="220" r="4" fill="#7a7a7a"/><circle cx="863" cy="220" r="4" fill="#a3a3a3"/>
+    <text x="837" y="273" class="code bright"><tspan fill="#7a7a7a">$</tspan> farm build</text>
+    <rect x="837" y="293" width="11" height="11" fill="#a3a3a3"/><path d="m839 298 3 3 6-7" fill="none" stroke="#050505" stroke-width="1.5"/>
+    <text x="861" y="303" class="code">64 routes discovered</text>
+    <rect x="837" y="320" width="11" height="11" fill="#a3a3a3"/><path d="m839 325 3 3 6-7" fill="none" stroke="#050505" stroke-width="1.5"/>
+    <text x="861" y="330" class="code">client + server bundles</text>
+    <rect x="837" y="355" width="126" height="30" fill="#f0f0f0"/><text x="853" y="374" class="micro ink">BUILD COMPLETE</text>
+    <text x="1115" y="374" class="micro" text-anchor="end">/dist</text>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">REAL COMMANDS</text><text x="1134" y="475" class="label" text-anchor="end">842MS</text>`;
+}
+function renderProjectIllustration() {
+  return `${renderPanelHeader("PROJECT MAP", "CONVENTION TYPED")}
+    <rect x="819" y="202" width="315" height="216" fill="#050505" stroke="#555"/>
+    <text x="837" y="227" class="diagram-title bright">my-app/</text>
+    <path d="M847 243v143M847 259h23M847 293h23M847 327h23M847 361h23" fill="none" stroke="#666"/>
+    <rect x="870" y="243" width="246" height="33" fill="#0a0a0a" stroke="#444"/><text x="886" y="264" class="code">src/app</text><text x="1098" y="264" class="micro" text-anchor="end">ROUTES</text>
+    <rect x="870" y="277" width="246" height="33" fill="#f0f0f0"/><text x="886" y="298" class="code ink">src/app/page.tsx</text>
+    <rect x="870" y="311" width="246" height="33" fill="#0a0a0a" stroke="#444"/><text x="886" y="332" class="code">src/app/api/users/route.ts</text><text x="1098" y="332" class="micro" text-anchor="end">API</text>
+    <rect x="870" y="345" width="246" height="33" fill="#0a0a0a" stroke="#444"/><text x="886" y="366" class="code">farm.config.ts</text><text x="1098" y="366" class="micro" text-anchor="end">CONFIG</text>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">FILES BECOME FEATURES</text><text x="1134" y="475" class="label" text-anchor="end">ONE CONFIG</text>`;
+}
+function renderRuntimeIllustration() {
+  return `${renderPanelHeader("PRODUCT ARCHITECTURE", "FULL STACK")}
+    <rect x="819" y="211" width="315" height="55" fill="#f0f0f0"/>
+    <text x="836" y="244" class="diagram-title ink">PRODUCT SURFACE</text><text x="1116" y="244" class="micro ink-muted" text-anchor="end">UI + ROUTES</text>
+    <path d="M976 266v20m0 61v20" stroke="#727272"/>
+    <rect x="855" y="286" width="242" height="61" fill="#a3a3a3"/>
+    <text x="874" y="314" class="diagram-title ink">APPLICATION CORE</text><text x="874" y="334" class="micro ink-muted">APIS \xB7 MIDDLEWARE</text>
+    <rect x="819" y="367" width="315" height="55" fill="#4c4c4c"/>
+    <text x="836" y="400" class="diagram-title bright">CONNECTED STACK</text><text x="1116" y="400" class="micro" text-anchor="end">DATA \xB7 AUTH \xB7 DEPLOY</text>
+    <line x1="819" y1="450" x2="1134" y2="450" stroke="#343434"/>
+    <text x="819" y="475" class="label bright">ONE FRAMEWORK</text><text x="1134" y="475" class="label" text-anchor="end">ONE DEPLOYMENT MODEL</text>`;
+}
+function renderIllustration(type) {
+  switch (type) {
+    case "auth":
+      return renderAuthIllustration();
+    case "cache":
+      return renderCacheIllustration();
+    case "cli":
+      return renderCliIllustration();
+    case "integrations":
+      return renderIntegrationsIllustration();
+    case "project":
+      return renderProjectIllustration();
+    case "routing":
+      return renderRoutingIllustration();
+    default:
+      return renderRuntimeIllustration();
+  }
+}
+function renderFarmDocsSocialImageSvg(descriptor) {
+  const titleLines = wrapText(descriptor.title, 22, 2);
+  const longestTitleLine = Math.max(...titleLines.map((line) => line.length));
+  const titleSize = titleLines.length === 1 ? longestTitleLine > 17 ? 62 : 74 : 56;
+  const titleLineHeight = Math.round(titleSize * 0.98);
+  const titleY = titleLines.length === 1 ? 294 : 266;
+  const descriptionY = titleY + (titleLines.length - 1) * titleLineHeight + 59;
+  const descriptionLines = wrapText(descriptor.description, 68, 2);
+  const routeY = Math.max(418, descriptionY + descriptionLines.length * 29 + 24);
+  const section = truncate(descriptor.section.toUpperCase(), 27);
+  const route = truncate(descriptor.pageHref, 42);
+  const footerUrl = truncate(descriptor.pageUrl.replace(/^https?:\/\//, ""), 70);
+  const brand = truncate(descriptor.brand.toUpperCase(), 25);
+  const titleId = `farm-docs-og-${descriptor.hash}`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${FARM_DOCS_SOCIAL_IMAGE_WIDTH}" height="${FARM_DOCS_SOCIAL_IMAGE_HEIGHT}" viewBox="0 0 ${FARM_DOCS_SOCIAL_IMAGE_WIDTH} ${FARM_DOCS_SOCIAL_IMAGE_HEIGHT}" role="img" aria-labelledby="${titleId}-title ${titleId}-description">
+  <title id="${titleId}-title">${escapeXml(descriptor.imageAlt)}</title>
+  <desc id="${titleId}-description">${escapeXml(descriptor.description)}</desc>
+  <metadata>${escapeXml(JSON.stringify({ generator: "Farm.js docs", page: descriptor.pageUrl, illustration: descriptor.illustration }))}</metadata>
+  <style type="text/css">
+    ${renderEmbeddedFont("Farm Sans", descriptor.fonts?.sans, "100 900")}
+    ${renderEmbeddedFont("Farm Mono", descriptor.fonts?.mono, "100 900")}
+    ${renderEmbeddedFont("Farm Pixel", descriptor.fonts?.display, "400 700")}
+    .sans{font-family:"Farm Sans","Arial",sans-serif}.mono,.label,.code,.diagram-title,.micro{font-family:"Farm Mono","Menlo","DejaVu Sans Mono",monospace}.pixel{font-family:"Farm Pixel","Farm Mono",monospace}.label{fill:#8b8b8b;font-size:10px;font-weight:600;letter-spacing:1.2px}.code{fill:#8b8b8b;font-size:11px}.diagram-title{fill:#e7e7e7;font-size:11px;font-weight:650}.micro{fill:#777;font-size:8px;letter-spacing:.45px}.bright{fill:#f5f5f4}.ink{fill:#050505}.ink-muted{fill:#4c4c4c}
+  </style>
+  <defs>
+    <pattern id="canvas-grid" width="40" height="40" patternUnits="userSpaceOnUse"><path d="M40 0H0V40" fill="none" stroke="#151515"/></pattern>
+    <pattern id="diagonal" width="12" height="12" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><line x1="0" y1="0" x2="0" y2="12" stroke="#171717" stroke-width="2"/></pattern>
+    <clipPath id="frame-clip"><rect x="28" y="28" width="1144" height="574"/></clipPath>
+  </defs>
+  <rect width="1200" height="630" fill="#050505"/>
+  <rect width="1200" height="630" fill="url(#canvas-grid)"/>
+  <g clip-path="url(#frame-clip)">
+    <rect x="28" y="28" width="1144" height="574" fill="#020202"/>
+    <rect x="782" y="114" width="390" height="411" fill="url(#diagonal)"/>
+  </g>
+  <rect x="28.5" y="28.5" width="1143" height="573" fill="none" stroke="#323232"/>
+  <path d="M28 114.5h1144M28 525.5h1144M781.5 114v411" fill="none" stroke="#303030"/>
+
+  <g transform="translate(71 51)">
+    <rect width="11" height="11" rx="1" fill="#f5f5f4"/><rect x="15" width="28" height="11" rx="1" fill="#f5f5f4"/>
+    <rect y="15" width="11" height="11" rx="1" fill="#9b9b9b"/><rect x="15" y="15" width="28" height="11" rx="1" fill="#9b9b9b"/>
+    <rect y="30" width="11" height="11" rx="1" fill="#5f5f5f"/><rect x="15" y="30" width="20" height="11" rx="1" fill="#5f5f5f"/>
+    <text x="61" y="24" class="mono bright" font-size="24" font-weight="550">FARM<tspan fill="#777">.JS</tspan></text>
+    <text x="61" y="43" class="label">BY FARMING LABS</text>
+  </g>
+  <text x="1134" y="72" class="label" text-anchor="end">${escapeXml(brand)} \xB7 DOCUMENTATION</text>
+
+  <text x="71" y="198" class="mono bright" font-size="13" font-weight="650">DOCS</text>
+  <line x1="117" y1="193" x2="155" y2="193" stroke="#696969"/>
+  <text x="166" y="198" class="mono" fill="#9b9b9b" font-size="13">${escapeXml(section)}</text>
+  ${renderTextLines(titleLines, 71, titleY, titleLineHeight, `class="pixel bright" font-size="${titleSize}" font-weight="500" letter-spacing="-2.4"`)}
+  ${renderTextLines(descriptionLines, 71, descriptionY, 29, 'class="sans" fill="#a3a3a3" font-size="20" font-weight="430" letter-spacing="-.3"')}
+  <rect x="71" y="${routeY}" width="${Math.min(390, 56 + route.length * 8)}" height="36" fill="#050505" stroke="#3c3c3c"/>
+  <text x="85" y="${routeY + 23}" class="mono bright" font-size="11" font-weight="600">GET</text>
+  <text x="119" y="${routeY + 23}" class="mono" fill="#898989" font-size="11">${escapeXml(route)}</text>
+
+  ${renderIllustration(descriptor.illustration)}
+
+  <text x="71" y="570" class="mono bright" font-size="13" font-weight="550">${escapeXml(footerUrl)}</text>
+  <text x="1134" y="570" class="mono" fill="#9b9b9b" font-size="12" text-anchor="end">FARM.JS DOCUMENTATION</text>
+  <path d="M20 20h10M20 20v10M1180 20h-10M1180 20v10M20 610h10M20 610v-10M1180 610h-10M1180 610v-10" fill="none" stroke="#9b9b9b"/>
+</svg>`;
+}
+function renderFarmDocsSocialMetadata(descriptor, customImage) {
+  const imageUrl = customImage ? new URL(customImage, descriptor.pageUrl).href : descriptor.imageUrl;
+  const customExtension = customImage?.toLowerCase().split(/[?#]/, 1)[0];
+  const imageType = customExtension?.endsWith(".webp") ? "image/webp" : customExtension?.endsWith(".png") ? "image/png" : customExtension?.match(/\.jpe?g$/) ? "image/jpeg" : "image/svg+xml";
+  const tag = /* @__PURE__ */ __name((property, content, name = false) => `<meta ${name ? "name" : "property"}="${property}" content="${escapeXml(content)}">`, "tag");
+  return [
+    tag("og:type", "article"),
+    tag("og:site_name", descriptor.siteName),
+    tag("og:title", descriptor.title),
+    tag("og:description", descriptor.description),
+    tag("og:url", descriptor.pageUrl),
+    tag("og:image", imageUrl),
+    tag("og:image:type", imageType),
+    ...customImage ? [] : [
+      tag("og:image:width", String(FARM_DOCS_SOCIAL_IMAGE_WIDTH)),
+      tag("og:image:height", String(FARM_DOCS_SOCIAL_IMAGE_HEIGHT))
+    ],
+    tag("og:image:alt", descriptor.imageAlt),
+    tag("twitter:card", "summary_large_image", true),
+    tag("twitter:title", descriptor.title, true),
+    tag("twitter:description", descriptor.description, true),
+    tag("twitter:image", imageUrl, true),
+    tag("twitter:image:alt", descriptor.imageAlt, true)
+  ].join("\n  ");
+}
+var import_node_crypto4, FARM_DOCS_SOCIAL_IMAGE_WIDTH, FARM_DOCS_SOCIAL_IMAGE_HEIGHT, FARM_DOCS_SOCIAL_IMAGE_VERSION;
+var init_social_image = __esm({
+  "src/docs/social-image.ts"() {
+    "use strict";
+    import_node_crypto4 = require("crypto");
+    FARM_DOCS_SOCIAL_IMAGE_WIDTH = 1200;
+    FARM_DOCS_SOCIAL_IMAGE_HEIGHT = 630;
+    FARM_DOCS_SOCIAL_IMAGE_VERSION = 3;
+    __name(normalizeEntry, "normalizeEntry");
+    __name(encodeSlugPath, "encodeSlugPath");
+    __name(getSocialImageConfig, "getSocialImageConfig");
+    __name(getNavTitle, "getNavTitle");
+    __name(isFalse, "isFalse");
+    __name(isExternalOrRootPath, "isExternalOrRootPath");
+    __name(isFarmDocsSocialImageEnabled, "isFarmDocsSocialImageEnabled");
+    __name(getFarmDocsCustomSocialImage, "getFarmDocsCustomSocialImage");
+    __name(resolveIllustration, "resolveIllustration");
+    __name(createHashValue, "createHashValue");
+    __name(resolveBaseUrl, "resolveBaseUrl");
+    __name(createFarmDocsSocialImageDescriptor, "createFarmDocsSocialImageDescriptor");
+    __name(getFarmDocsSocialImageSlug, "getFarmDocsSocialImageSlug");
+    __name(escapeXml, "escapeXml");
+    __name(truncate, "truncate");
+    __name(wrapText, "wrapText");
+    __name(renderTextLines, "renderTextLines");
+    __name(renderEmbeddedFont, "renderEmbeddedFont");
+    __name(renderArrow, "renderArrow");
+    __name(renderPanelHeader, "renderPanelHeader");
+    __name(renderRoutingIllustration, "renderRoutingIllustration");
+    __name(renderAuthIllustration, "renderAuthIllustration");
+    __name(renderCacheIllustration, "renderCacheIllustration");
+    __name(renderIntegrationsIllustration, "renderIntegrationsIllustration");
+    __name(renderCliIllustration, "renderCliIllustration");
+    __name(renderProjectIllustration, "renderProjectIllustration");
+    __name(renderRuntimeIllustration, "renderRuntimeIllustration");
+    __name(renderIllustration, "renderIllustration");
+    __name(renderFarmDocsSocialImageSvg, "renderFarmDocsSocialImageSvg");
+    __name(renderFarmDocsSocialMetadata, "renderFarmDocsSocialMetadata");
+  }
+});
+
 // src/docs/handler.ts
 function trimSlashes2(value) {
   return value.replace(/^\/+|\/+$/g, "");
 }
-function normalizeEntry(entry) {
+function normalizeEntry2(entry) {
   if (!entry || entry === "/") return "/";
   return `/${trimSlashes2(entry)}`;
 }
@@ -18145,10 +19295,10 @@ function resolveFarmDocsFavicon(docs, options) {
   if (typeof configuredFavicon === "string" && configuredFavicon.trim()) {
     return configuredFavicon.trim();
   }
-  const publicDir = import_node_path11.default.join(import_node_path11.default.resolve(options.root), "public");
+  const publicDir = import_node_path13.default.join(import_node_path13.default.resolve(options.root), "public");
   for (const fileName of FARM_DOCS_FAVICON_FILES) {
-    const faviconPath = import_node_path11.default.join(publicDir, fileName);
-    if ((0, import_node_fs8.existsSync)(faviconPath) && (0, import_node_fs8.statSync)(faviconPath).isFile()) {
+    const faviconPath = import_node_path13.default.join(publicDir, fileName);
+    if ((0, import_node_fs9.existsSync)(faviconPath) && (0, import_node_fs9.statSync)(faviconPath).isFile()) {
       return `/${fileName}`;
     }
   }
@@ -18182,10 +19332,10 @@ function isSafeSegment(segment) {
   return segment !== ".." && !segment.includes("/") && !segment.includes("\\");
 }
 function resolveInside(root, target) {
-  const resolvedRoot = import_node_path11.default.resolve(root);
-  const resolvedTarget = import_node_path11.default.resolve(target);
-  const relative4 = import_node_path11.default.relative(resolvedRoot, resolvedTarget);
-  if (relative4 === "" || !relative4.startsWith("..") && !import_node_path11.default.isAbsolute(relative4)) {
+  const resolvedRoot = import_node_path13.default.resolve(root);
+  const resolvedTarget = import_node_path13.default.resolve(target);
+  const relative4 = import_node_path13.default.relative(resolvedRoot, resolvedTarget);
+  if (relative4 === "" || !relative4.startsWith("..") && !import_node_path13.default.isAbsolute(relative4)) {
     return resolvedTarget;
   }
   return null;
@@ -18194,36 +19344,36 @@ function isFarmDocsRequest(docs, request) {
   if (!docs?.enabled) return false;
   if (request.method !== "GET" && request.method !== "HEAD") return false;
   const pathname = new URL(request.url).pathname;
-  const entry = normalizeEntry(docs.entry);
+  const entry = normalizeEntry2(docs.entry);
   if (entry === "/") return true;
   return pathname === entry || pathname === `${entry}.md` || pathname.startsWith(`${entry}/`);
 }
 function resolveFarmDocsContentDir(docs, options) {
-  const root = import_node_path11.default.resolve(options.root);
+  const root = import_node_path13.default.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const configuredContentDir = docs.contentDir || docs.config.contentDir;
   if (configuredContentDir) {
-    return import_node_path11.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path11.default.join(root, configuredContentDir);
+    return import_node_path13.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path13.default.join(root, configuredContentDir);
   }
   const entryDir = docs.config.entry || trimSlashes2(docs.entry) || "docs";
-  const appDocsDir = import_node_path11.default.join(root, srcDir, "app", entryDir);
-  if ((0, import_node_fs8.existsSync)(appDocsDir)) return appDocsDir;
-  return import_node_path11.default.join(root, entryDir);
+  const appDocsDir = import_node_path13.default.join(root, srcDir, "app", entryDir);
+  if ((0, import_node_fs9.existsSync)(appDocsDir)) return appDocsDir;
+  return import_node_path13.default.join(root, entryDir);
 }
 function getFarmDocsRouteTypeEntries(docs) {
   if (!docs?.enabled) return [];
-  const entry = normalizeEntry(docs.entry);
+  const entry = normalizeEntry2(docs.entry);
   if (entry === "/") return ["/", "/[...docs]"];
   return [entry, `${entry}/[...docs]`];
 }
 function getFarmDocsDocumentNavigationMatchers(docs) {
   if (!docs?.enabled) return [];
-  const entry = normalizeEntry(docs.entry);
+  const entry = normalizeEntry2(docs.entry);
   return [entry === "/" ? "/(.*)" : `${entry}(.*)`];
 }
 function getRequestSlug(docs, request) {
   const pathname = new URL(request.url).pathname;
-  const entry = normalizeEntry(docs.entry);
+  const entry = normalizeEntry2(docs.entry);
   if (entry === "/") return normalizeSlug(pathname);
   if (pathname === entry || pathname === `${entry}.md`) return "";
   return normalizeSlug(pathname.slice(entry.length));
@@ -18231,14 +19381,14 @@ function getRequestSlug(docs, request) {
 function findDocsPageFile(contentDir, slug) {
   const segments = slug ? slug.split("/").filter(Boolean) : [];
   if (!segments.every(isSafeSegment)) return null;
-  const slugDir = import_node_path11.default.join(contentDir, ...segments);
-  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path11.default.join(contentDir, filename)) : [
-    ...DOCS_FILE_NAMES.map((filename) => import_node_path11.default.join(slugDir, filename)),
-    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path11.default.join(contentDir, `${slug}${extension}`))
+  const slugDir = import_node_path13.default.join(contentDir, ...segments);
+  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path13.default.join(contentDir, filename)) : [
+    ...DOCS_FILE_NAMES.map((filename) => import_node_path13.default.join(slugDir, filename)),
+    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path13.default.join(contentDir, `${slug}${extension}`))
   ];
   for (const candidate of candidates) {
     const safePath = resolveInside(contentDir, candidate);
-    if (safePath && (0, import_node_fs8.existsSync)(safePath) && (0, import_node_fs8.statSync)(safePath).isFile()) {
+    if (safePath && (0, import_node_fs9.existsSync)(safePath) && (0, import_node_fs9.statSync)(safePath).isFile()) {
       return safePath;
     }
   }
@@ -18273,7 +19423,7 @@ function titleFromMarkdown2(body, fallback) {
 function loadFarmDocsPage(contentDir, docs, slug) {
   const sourcePath = findDocsPageFile(contentDir, slug);
   if (!sourcePath) return null;
-  const source = (0, import_node_fs8.readFileSync)(sourcePath, "utf8");
+  const source = (0, import_node_fs9.readFileSync)(sourcePath, "utf8");
   const { frontmatter, body } = parseFrontmatter(source);
   const title = frontmatter.title || titleFromMarkdown2(body, titleFromSlug(slug));
   const href = createDocsHref(docs.entry, slug);
@@ -18281,6 +19431,7 @@ function loadFarmDocsPage(contentDir, docs, slug) {
     slug,
     title,
     description: frontmatter.description,
+    section: frontmatter.section,
     href,
     sourcePath,
     lastModified: resolveFarmDocsPageLastModified(contentDir, sourcePath, frontmatter),
@@ -18289,15 +19440,15 @@ function loadFarmDocsPage(contentDir, docs, slug) {
   };
 }
 function createDocsHref(entry, slug) {
-  const normalizedEntry = normalizeEntry(entry);
+  const normalizedEntry = normalizeEntry2(entry);
   const normalizedSlug = trimSlashes2(slug);
   if (normalizedEntry === "/") return normalizedSlug ? `/${normalizedSlug}` : "/";
   return normalizedSlug ? `${normalizedEntry}/${normalizedSlug}` : normalizedEntry;
 }
 function pathToSlug(contentDir, filePath) {
-  const relative4 = import_node_path11.default.relative(contentDir, filePath).replace(/\\/g, "/");
+  const relative4 = import_node_path13.default.relative(contentDir, filePath).replace(/\\/g, "/");
   if (relative4.startsWith("..")) return null;
-  const extension = import_node_path11.default.extname(relative4);
+  const extension = import_node_path13.default.extname(relative4);
   if (!DOCS_FILE_EXTENSIONS2.includes(extension)) return null;
   const withoutExtension = relative4.slice(0, -extension.length);
   if (withoutExtension === "page" || withoutExtension === "index") return "";
@@ -18310,12 +19461,12 @@ function loadPage(contentDir, docs, request) {
   return loadFarmDocsPage(contentDir, docs, getRequestSlug(docs, request));
 }
 function discoverFarmDocsPages(contentDir, docs) {
-  if (!(0, import_node_fs8.existsSync)(contentDir)) return [];
+  if (!(0, import_node_fs9.existsSync)(contentDir)) return [];
   const pages = [];
   const visit = /* @__PURE__ */ __name((dir) => {
-    for (const entry of (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path11.default.join(dir, entry.name);
+      const absolutePath = import_node_path13.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
         continue;
@@ -18323,7 +19474,7 @@ function discoverFarmDocsPages(contentDir, docs) {
       if (!entry.isFile()) continue;
       const slug = pathToSlug(contentDir, absolutePath);
       if (slug === null) continue;
-      const source = (0, import_node_fs8.readFileSync)(absolutePath, "utf8");
+      const source = (0, import_node_fs9.readFileSync)(absolutePath, "utf8");
       const { frontmatter, body } = parseFrontmatter(source);
       pages.push({
         slug,
@@ -19101,7 +20252,7 @@ function renderPixelBreadcrumb(page2, docs) {
   const parentSegments = segments.slice(0, -1);
   const parentSegment = parentSegments[parentSegments.length - 1];
   const currentSegment = segments[segments.length - 1];
-  const entry = normalizeEntry(docs.entry);
+  const entry = normalizeEntry2(docs.entry);
   const parentPath = parentSegments.join("/");
   const parentHref = entry === "/" ? `/${parentPath}` : `${entry}/${parentPath}`;
   return `<nav class="fd-breadcrumb" aria-label="Breadcrumb">
@@ -19139,7 +20290,7 @@ ${items.map(
 </div>`;
 }
 function renderDocsRuntimeScript(docs) {
-  const docsEntry = JSON.stringify(normalizeEntry(docs.entry));
+  const docsEntry = JSON.stringify(normalizeEntry2(docs.entry));
   return `<script>(()=>{if(window.__farmDocsRuntime)return;window.__farmDocsRuntime=true;document.documentElement.dataset.farmDocsRuntime="true";document.documentElement.dataset.farmDocsRuntimeId=Math.random().toString(36).slice(2);const docsEntry=${docsEntry};let cleanupToc=()=>{};let closeMobileSidebar=()=>{};const normalizePath=(path)=>path.length>1?path.replace(/\\/+$/,""):path;const isDocsPath=(path)=>{const next=normalizePath(path);const entry=normalizePath(docsEntry);if(next.endsWith(".md"))return false;if(entry==="/")return true;return next===entry||next.startsWith(entry+"/")};const initToc=()=>{cleanupToc();const toc=document.getElementById("nd-toc");if(!toc){cleanupToc=()=>{};return}const links=Array.from(toc.querySelectorAll("[data-toc-item]"));const thumb=toc.querySelector("[data-toc-thumb]");const pairs=links.map((link)=>{let id=link.hash.slice(1);try{id=decodeURIComponent(id)}catch{}return{link,heading:document.getElementById(id)}}).filter((item)=>item.heading);const setActive=(active)=>{for(const {link} of pairs)link.dataset.active=link===active.link?"true":"false";if(!thumb)return;const styles=getComputedStyle(active.link);const top=active.link.offsetTop+parseFloat(styles.paddingTop||"0");const bottom=active.link.offsetTop+active.link.clientHeight-parseFloat(styles.paddingBottom||"0");thumb.style.clipPath="polygon(0 "+top+"px,100% "+top+"px,100% "+bottom+"px,0 "+bottom+"px)"};const update=()=>{if(pairs.length===0)return;const offset=Math.min(window.innerHeight*0.3,160);let active=pairs[0];for(const pair of pairs){if(pair.heading.getBoundingClientRect().top<=offset)active=pair;else break}setActive(active)};let frame=0;const schedule=()=>{if(frame)return;frame=requestAnimationFrame(()=>{frame=0;update()})};const onHashChange=()=>setTimeout(schedule,0);window.addEventListener("scroll",schedule,{passive:true});window.addEventListener("resize",schedule);window.addEventListener("hashchange",onHashChange);cleanupToc=()=>{window.removeEventListener("scroll",schedule);window.removeEventListener("resize",schedule);window.removeEventListener("hashchange",onHashChange);if(frame)cancelAnimationFrame(frame);frame=0};update()};const getSidebar=()=>document.getElementById("nd-sidebar");const ensureActiveVisible=()=>{const sidebar=getSidebar();if(!sidebar)return;const active=sidebar.querySelector('a[data-active="true"]');if(!(active instanceof HTMLElement))return;const activeRect=active.getBoundingClientRect();const sidebarRect=sidebar.getBoundingClientRect();if(activeRect.top<sidebarRect.top||activeRect.bottom>sidebarRect.bottom)sidebar.scrollTop+=activeRect.top-sidebarRect.top-(sidebar.clientHeight-activeRect.height)/2};const setSidebarActive=(path)=>{const sidebar=getSidebar();if(!sidebar)return;const current=normalizePath(path);for(const link of Array.from(sidebar.querySelectorAll("a[href]"))){try{link.dataset.active=normalizePath(new URL(link.href,location.href).pathname)===current?"true":"false"}catch{}}ensureActiveVisible()};const initMobileSidebar=()=>{const layout=document.getElementById("nd-docs-layout");const sidebar=getSidebar();const toggle=document.querySelector("[data-sidebar-toggle]");const backdrop=document.querySelector("[data-sidebar-backdrop]");if(!layout||!sidebar||!(toggle instanceof HTMLButtonElement))return;const setOpen=(open)=>{layout.dataset.sidebarOpen=open?"true":"false";document.documentElement.dataset.farmDocsSidebar=open?"open":"closed";toggle.setAttribute("aria-expanded",open?"true":"false");toggle.setAttribute("aria-label",open?"Close menu":"Open menu")};const toggleOpen=()=>setOpen(layout.dataset.sidebarOpen!=="true");closeMobileSidebar=()=>setOpen(false);toggle.addEventListener("click",(event)=>{event.preventDefault();toggleOpen()});backdrop?.addEventListener("click",()=>closeMobileSidebar());document.addEventListener("keydown",(event)=>{if(event.key==="Escape")closeMobileSidebar()});sidebar.addEventListener("click",(event)=>{const target=event.target instanceof Element?event.target.closest("a[href]"):null;if(target)closeMobileSidebar()});closeMobileSidebar()};const initSidebarScroll=()=>{const sidebar=getSidebar();if(!sidebar)return;const key="farmdocs:sidebar-scroll:"+location.origin;const getStorage=()=>{try{return window.sessionStorage}catch{return null}};const readSaved=()=>{try{const raw=getStorage()?.getItem(key);if(!raw)return null;const parsed=JSON.parse(raw);return parsed&&typeof parsed==="object"?parsed:null}catch{return null}};const save=(path=location.pathname)=>{try{getStorage()?.setItem(key,JSON.stringify({path,scrollTop:sidebar.scrollTop}))}catch{}};const saved=readSaved();if(saved?.path===location.pathname&&Number.isFinite(Number(saved.scrollTop)))sidebar.scrollTop=Number(saved.scrollTop);ensureActiveVisible();save();sidebar.addEventListener("scroll",()=>save(),{passive:true});sidebar.addEventListener("click",(event)=>{const target=event.target instanceof Element?event.target.closest("a[href]"):null;if(!target)return;try{save(new URL(target.href,location.href).pathname)}catch{save()}});window.addEventListener("beforeunload",()=>save())};let navigateController=null;const getPageKey=(root)=>{const article=root.getElementById("nd-page");if(!article)return"";return article.querySelector("h1")?.textContent?.trim()||article.textContent?.replace(/\\s+/g," ").trim().slice(0,160)||""};const swapDocsPage=(html,url)=>{const nextDoc=new DOMParser().parseFromString(html,"text/html");const nextArticle=nextDoc.getElementById("nd-page");const currentArticle=document.getElementById("nd-page");if(!nextArticle||!currentArticle)return false;const nextKey=getPageKey(nextDoc);const importedArticle=document.importNode(nextArticle,true);currentArticle.replaceWith(importedArticle);const renderedArticle=document.getElementById("nd-page");if(!renderedArticle||renderedArticle===currentArticle||(nextKey&&getPageKey(document)!==nextKey))return false;const nextToc=nextDoc.getElementById("nd-toc");const currentToc=document.getElementById("nd-toc");if(nextToc&&currentToc)currentToc.replaceWith(document.importNode(nextToc,true));if(nextDoc.title)document.title=nextDoc.title;const nextDescription=nextDoc.querySelector('meta[name="description"]');const currentDescription=document.querySelector('meta[name="description"]');if(nextDescription&&currentDescription)currentDescription.setAttribute("content",nextDescription.getAttribute("content")||"");setSidebarActive(url.pathname);initToc();closeMobileSidebar();return true};const navigateDocs=async(url,{replace=false,scroll=true}={})=>{if(!isDocsPath(url.pathname))return false;if(navigateController)navigateController.abort();const controller=new AbortController();navigateController=controller;document.documentElement.dataset.farmDocsNavigating="true";try{const response=await fetch(url.href,{cache:"no-store",headers:{accept:"text/html","x-farm-docs-navigate":"1"},signal:controller.signal});if(!response.ok||!((response.headers.get("content-type")||"").includes("text/html")))return false;const html=await response.text();if(!swapDocsPage(html,url))return false;if(replace)history.replaceState({farmDocs:true},"",url.href);else history.pushState({farmDocs:true},"",url.href);if(scroll){if(url.hash){let id=url.hash.slice(1);try{id=decodeURIComponent(id)}catch{}document.getElementById(id)?.scrollIntoView({block:"start"})}else window.scrollTo({top:0,left:0})}return true}catch(error){if(error?.name==="AbortError")return true;return false}finally{if(navigateController===controller){delete document.documentElement.dataset.farmDocsNavigating;navigateController=null}}};const initClientNavigation=()=>{document.addEventListener("click",(event)=>{if(event.defaultPrevented||event.button!==0||event.metaKey||event.ctrlKey||event.shiftKey||event.altKey)return;const target=event.target instanceof Element?event.target.closest("a[href]"):null;if(!target||target.target||target.hasAttribute("download"))return;let url;try{url=new URL(target.href,location.href)}catch{return}if(url.origin!==location.origin||!isDocsPath(url.pathname))return;if(normalizePath(url.pathname)===normalizePath(location.pathname)&&url.hash)return;event.preventDefault();navigateDocs(url).then((handled)=>{if(!handled)location.href=url.href})});window.addEventListener("popstate",()=>{navigateDocs(new URL(location.href),{replace:true,scroll:false}).then((handled)=>{if(!handled)location.reload()})})};const init=()=>{initToc();initMobileSidebar();initSidebarScroll();initClientNavigation()};if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",init,{once:true});else init()})();</script>`;
 }
 function renderDocsPageActionsRuntimeScript() {
@@ -19154,13 +20305,13 @@ ${renderDocsHashRuntimeScript()}
 ${renderDocsPageActionsRuntimeScript()}`;
 }
 function readCssWithImports(filePath, seen = /* @__PURE__ */ new Set()) {
-  const resolved = import_node_path11.default.resolve(filePath);
+  const resolved = import_node_path13.default.resolve(filePath);
   if (seen.has(resolved)) return "";
   seen.add(resolved);
-  const source = (0, import_node_fs8.readFileSync)(resolved, "utf8");
+  const source = (0, import_node_fs9.readFileSync)(resolved, "utf8");
   return source.replace(/@import\s+["']([^"']+)["'];?/g, (_match, importPath) => {
     try {
-      const importedPath = importPath.startsWith(".") ? import_node_path11.default.resolve(import_node_path11.default.dirname(resolved), importPath) : (0, import_node_module5.createRequire)(resolved).resolve(importPath);
+      const importedPath = importPath.startsWith(".") ? import_node_path13.default.resolve(import_node_path13.default.dirname(resolved), importPath) : (0, import_node_module5.createRequire)(resolved).resolve(importPath);
       return readCssWithImports(importedPath, seen);
     } catch {
       return "";
@@ -19168,11 +20319,11 @@ function readCssWithImports(filePath, seen = /* @__PURE__ */ new Set()) {
   });
 }
 function resolvePixelBorderThemeCss(options) {
-  const cacheKey = import_node_path11.default.resolve(options.root);
+  const cacheKey = import_node_path13.default.resolve(options.root);
   const cached = themeCssCache.get(cacheKey);
   if (cached !== void 0) return cached;
   try {
-    const requireFromApp = (0, import_node_module5.createRequire)(import_node_path11.default.join(cacheKey, "package.json"));
+    const requireFromApp = (0, import_node_module5.createRequire)(import_node_path13.default.join(cacheKey, "package.json"));
     const themeCssPath = requireFromApp.resolve("@farming-labs/theme/pixel-border/css");
     const requireFromTheme = (0, import_node_module5.createRequire)(themeCssPath);
     const fumadocsCssPath = requireFromTheme.resolve("fumadocs-ui/style.css");
@@ -19185,17 +20336,28 @@ ${readCssWithImports(themeCssPath)}`;
     return "";
   }
 }
-function renderFarmDocsBridgeCss(docs) {
+function renderFarmDocsBridgeCss(docs, fontAssets, layoutFonts) {
   const sidebarWidth = getThemeLayoutValue(docs, "sidebarWidth", 320);
   const contentWidth = getThemeLayoutValue(docs, "contentWidth", 860);
+  const fontFaces = fontAssets.map(
+    ({ family, url }) => `@font-face { font-family: "${family}"; src: url("${url}") format("woff2"); font-style: normal; font-weight: 100 900; font-display: block; }`
+  ).join("\n");
+  const fontVariables = [
+    fontAssets.some(({ family }) => family === "Geist Sans") ? '--font-geist-sans: "Geist Sans", ui-sans-serif, system-ui, sans-serif;' : "",
+    fontAssets.some(({ family }) => family === "Geist Mono") ? '--font-geist-mono: "Geist Mono", ui-monospace, monospace;' : ""
+  ].filter(Boolean).join(" ");
+  const fontCss = fontFaces ? `${fontFaces}
+:root { ${fontVariables} }` : "";
+  const layoutFontVariables = [
+    renderFarmDocsLayoutFontVariable("--fd-layout-font-body", layoutFonts?.body),
+    renderFarmDocsLayoutFontVariable("--fd-layout-font-code", layoutFonts?.code)
+  ].filter(Boolean).join(" ");
   return `
-    @font-face { font-family: "Geist Sans"; src: local("Geist Sans"), url("${GEIST_SANS_FONT_URL}") format("woff2"), url("/node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2") format("woff2"); font-display: block; font-style: normal; font-weight: 100 900; }
-    @font-face { font-family: "Geist Mono"; src: local("Geist Mono"), url("${GEIST_MONO_FONT_URL}") format("woff2"), url("/node_modules/geist/dist/fonts/geist-mono/GeistMono-Variable.woff2") format("woff2"); font-display: block; font-style: normal; font-weight: 100 900; }
-    :root { color-scheme: dark; --font-geist-sans: "Geist Sans"; --font-geist-mono: "Geist Mono"; --fd-sidebar-width: ${sidebarWidth}px; --fd-content-width: ${contentWidth}px; --fd-toc-width: 240px; --fd-docs-height: 100vh; --fd-docs-row-1: var(--fd-nav-height, 44px); --fd-docs-font-sans: var(--font-geist-sans, "Geist Sans", var(--font-sans, system-ui, -apple-system, sans-serif)); --fd-docs-font-mono: var(--font-geist-mono, "Geist Mono", var(--font-mono, ui-monospace, monospace)); --fd-font-sans: var(--fd-docs-font-sans); --fd-font-mono: var(--fd-docs-font-mono); --fd-pixel-rail-width: 12px; --fd-sidebar-edge: calc(var(--fd-pixel-rail-width) + 18px); --fd-sidebar-guide-x: calc(var(--fd-sidebar-edge) + 16px); --fd-sidebar-link-x: calc(var(--fd-sidebar-guide-x) + 22px); --fd-sidebar-sub-guide-x: calc(var(--fd-sidebar-link-x) + 7px); --fd-sidebar-sub-link-x: calc(var(--fd-sidebar-sub-guide-x) + 28px); --fd-sidebar-branch-gap: 0px; --fd-sidebar-nested-icon-gap: 0px; --fd-sidebar-line-color: color-mix(in srgb, var(--color-fd-border, hsl(0 0% 15%)) 88%, transparent); }
+    :root { color-scheme: dark; --font-geist-sans: ui-sans-serif, system-ui, sans-serif; --font-geist-mono: ui-monospace, monospace; ${layoutFontVariables} --fd-sidebar-width: ${sidebarWidth}px; --fd-content-width: ${contentWidth}px; --fd-toc-width: 240px; --fd-docs-height: 100vh; --fd-docs-row-1: var(--fd-nav-height, 44px); --fd-docs-font-sans: var(--fd-layout-font-body, var(--font-geist-sans, var(--font-sans, system-ui, -apple-system, sans-serif))); --fd-docs-font-mono: var(--fd-layout-font-code, var(--font-geist-mono, var(--font-mono, ui-monospace, monospace))); --fd-font-sans: var(--fd-docs-font-sans); --fd-font-mono: var(--fd-docs-font-mono); --fd-pixel-rail-width: 12px; --fd-sidebar-edge: calc(var(--fd-pixel-rail-width) + 18px); --fd-sidebar-guide-x: calc(var(--fd-sidebar-edge) + 16px); --fd-sidebar-link-x: calc(var(--fd-sidebar-guide-x) + 22px); --fd-sidebar-sub-guide-x: calc(var(--fd-sidebar-link-x) + 7px); --fd-sidebar-sub-link-x: calc(var(--fd-sidebar-sub-guide-x) + 28px); --fd-sidebar-branch-gap: 0px; --fd-sidebar-nested-icon-gap: 0px; --fd-sidebar-line-color: color-mix(in srgb, var(--color-fd-border, hsl(0 0% 15%)) 88%, transparent); }
     * { box-sizing: border-box; }
     html { background: var(--color-fd-background, hsl(0 0% 2%)); scroll-padding-top: calc(var(--fd-nav-height, 44px) + 24px); }
     html[data-farm-docs-sidebar="open"], html[data-farm-docs-sidebar="open"] body { overflow: hidden; }
-    body { margin: 0; min-height: 100vh; background: var(--color-fd-background, hsl(0 0% 2%)); color: var(--color-fd-foreground, oklch(0.985 0.001 106.423)); font-family: var(--fd-docs-font-sans); text-rendering: optimizeLegibility; }
+    body { margin: 0; min-height: 100vh; background: var(--color-fd-background, hsl(0 0% 2%)); color: var(--color-fd-foreground, oklch(0.985 0.001 106.423)); font-family: var(--fd-docs-font-sans); font-synthesis: none; text-rendering: optimizeLegibility; }
     ::selection { background: var(--color-fd-foreground, #fff); color: var(--color-fd-background, #000); }
     a { color: inherit; }
     #nd-docs-layout { --fd-sidebar-col: var(--fd-sidebar-width); display: grid; grid-template: "sidebar header header" var(--fd-nav-height, 44px) "sidebar main toc" 1fr / var(--fd-sidebar-width) minmax(0, 1fr) var(--fd-toc-width) !important; min-height: 100vh; border-top: 1px solid var(--color-fd-border, hsl(0 0% 15%)); background: var(--color-fd-background, hsl(0 0% 2%)); }
@@ -19375,14 +20537,45 @@ function renderFarmDocsBridgeCss(docs) {
       .sh__line { min-height: 1.6em; }
     }
 ${farmDocsPixelBorderCss}
+${fontCss}
   `;
 }
-function renderPixelDocsHtml(page2, pages, docs, themeCss, clientEntry, faviconHref) {
+function renderFarmDocsLayoutFontVariable(name, font) {
+  const family = font?.style.fontFamily;
+  if (!family || /[;{}<>]/.test(family)) return "";
+  return `${name}: ${family};`;
+}
+function renderFarmDocsFontPreloads(fontAssets) {
+  return fontAssets.map(
+    ({ url }) => `<link rel="preload" href="${escapeAttribute2(url)}" as="font" type="font/woff2" crossorigin>`
+  ).join("\n  ");
+}
+function renderFarmDocsFontPreloadHeader(fontAssets) {
+  return fontAssets.map(({ url }) => `<${url}>; rel=preload; as=font; type=font/woff2; crossorigin`).join(", ");
+}
+function getFarmLayoutFontPreloads(layoutFonts) {
+  const seen = /* @__PURE__ */ new Set();
+  return [layoutFonts?.body, layoutFonts?.code].flatMap(
+    (font) => (font?.preloads || []).filter(({ href }) => {
+      if (seen.has(href)) return false;
+      seen.add(href);
+      return true;
+    })
+  );
+}
+function renderFarmLayoutFontPreloadHeader(layoutFonts) {
+  return getFarmLayoutFontPreloads(layoutFonts).map(({ href, type }) => `<${href}>; rel=preload; as=font; type=${type}; crossorigin`).join(", ");
+}
+function renderPixelDocsHtml(page2, pages, docs, themeCss, clientEntry, faviconHref, requestUrl, fontAssets, layoutFonts, fontStylesheetHref) {
   const navTitle = typeof docs.config.nav === "object" && docs.config.nav && "title" in docs.config.nav ? String(docs.config.nav.title || "Docs") : "Docs";
   const description = page2.description || docs.config.metadata?.description || "";
   const tocItems = extractTocItems(page2.body, getThemeTocDepth(docs));
   const themeName = getThemeName(docs);
   const searchEnabled = isFarmDocsSearchEnabled(docs);
+  const socialMetadata = isFarmDocsSocialImageEnabled(page2, docs) ? renderFarmDocsSocialMetadata(
+    createFarmDocsSocialImageDescriptor(page2, docs, requestUrl),
+    getFarmDocsCustomSocialImage(page2)
+  ) : "";
   return `<!DOCTYPE html>
 <html class="dark" lang="en" data-docs-theme="${escapeAttribute2(themeName)}">
 <head>
@@ -19391,11 +20584,12 @@ function renderPixelDocsHtml(page2, pages, docs, themeCss, clientEntry, faviconH
   <meta name="generator" content="@farming-labs/docs via Farm.js">
   <title>${escapeHtml(page2.title)}</title>
   ${renderFarmDocsFaviconLink(faviconHref)}
-  <link rel="preload" href="${GEIST_SANS_FONT_URL}" as="font" type="font/woff2" crossorigin>
-  <link rel="preload" href="${GEIST_MONO_FONT_URL}" as="font" type="font/woff2" crossorigin>
+  ${renderFarmDocsFontPreloads(fontAssets)}
+  ${fontStylesheetHref ? `<link rel="stylesheet" href="${escapeAttribute2(fontStylesheetHref)}">` : ""}
   ${description ? `<meta name="description" content="${escapeHtml(description)}">` : ""}
+  ${socialMetadata}
   <style>${themeCss}
-${renderFarmDocsBridgeCss(docs)}</style>
+${renderFarmDocsBridgeCss(docs, fontAssets, layoutFonts)}</style>
   ${searchEnabled ? renderDocsSearchBootstrapScript() : ""}
 </head>
 <body>
@@ -19447,9 +20641,34 @@ ${renderMarkdownHtmlWithTitleMeta(page2, docs)}
 }
 function createFarmDocsHandler(docs, options) {
   const faviconHref = resolveFarmDocsFavicon(docs, options);
+  const fontAssets = options.fontAssets ?? toFarmDocsPublicFontAssets(resolveFarmDocsFontAssets(options.root));
+  const fallbackFontPreloadHeader = renderFarmDocsFontPreloadHeader(fontAssets);
   return /* @__PURE__ */ __name(async function handleFarmDocsRequest(request) {
     if (!docs?.enabled || request.method !== "GET" && request.method !== "HEAD") return null;
     const contentDir = resolveFarmDocsContentDir(docs, options);
+    const requestUrl = new URL(request.url);
+    const socialImageSlug = getFarmDocsSocialImageSlug(docs, requestUrl);
+    if (socialImageSlug !== null) {
+      const socialImagePage = loadFarmDocsPage(contentDir, docs, socialImageSlug);
+      if (!socialImagePage || !isFarmDocsSocialImageEnabled(socialImagePage, docs) || getFarmDocsCustomSocialImage(socialImagePage)) {
+        return null;
+      }
+      const descriptor = createFarmDocsSocialImageDescriptor(socialImagePage, docs, requestUrl);
+      if (requestUrl.pathname !== descriptor.imagePath) return null;
+      const etag = `"${descriptor.hash}"`;
+      const immutable = requestUrl.searchParams.get("v") === descriptor.hash;
+      const headers = new Headers({
+        "Content-Type": "image/svg+xml; charset=utf-8",
+        "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "public, max-age=0, must-revalidate",
+        ETag: etag,
+        "X-Content-Type-Options": "nosniff"
+      });
+      if (request.headers.get("if-none-match") === etag) {
+        return new Response(null, { status: 304, headers });
+      }
+      if (request.method === "HEAD") return new Response(null, { status: 200, headers });
+      return new Response(renderFarmDocsSocialImageSvg(descriptor), { status: 200, headers });
+    }
     const publicResponse = createFarmDocsPublicResponse(contentDir, docs, request);
     if (publicResponse) return publicResponse;
     if (!isFarmDocsRequest(docs, request)) return null;
@@ -19472,6 +20691,11 @@ function createFarmDocsHandler(docs, options) {
         }
       );
     }
+    const pathname = new URL(request.url).pathname;
+    const layoutFonts = await options.resolveLayoutFonts?.(pathname);
+    const usesLayoutFonts = Boolean(layoutFonts?.body || layoutFonts?.code);
+    const activeFontAssets = usesLayoutFonts ? [] : fontAssets;
+    const fontPreloadHeader = usesLayoutFonts ? renderFarmLayoutFontPreloadHeader(layoutFonts) : fallbackFontPreloadHeader;
     return new Response(
       renderPixelDocsHtml(
         page2,
@@ -19479,39 +20703,44 @@ function createFarmDocsHandler(docs, options) {
         docs,
         resolvePixelBorderThemeCss(options),
         options.clientEntry || "/farm-client.js",
-        faviconHref
+        faviconHref,
+        requestUrl,
+        activeFontAssets,
+        layoutFonts,
+        usesLayoutFonts ? options.fontStylesheetHref : void 0
       ),
       {
         status: 200,
         headers: {
           "Content-Type": "text/html; charset=utf-8",
-          "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300"
+          "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
+          ...fontPreloadHeader ? { Link: fontPreloadHeader } : {}
         }
       }
     );
   }, "handleFarmDocsRequest");
 }
-var import_node_fs8, import_node_module5, import_node_path11, import_docs, import_marked, import_sugar_high, DOCS_FILE_NAMES, DOCS_FILE_EXTENSIONS2, FARM_DOCS_FALLBACK_FAVICON, FARM_DOCS_FAVICON_FILES, GEIST_SANS_FONT_URL, GEIST_MONO_FONT_URL, CODE_LANGUAGE_LABELS, EXTENSIONLESS_CODE_FILENAMES, SIDEBAR_SECTION_ORDER, SIDEBAR_PAGE_ORDER, themeCssCache;
+var import_node_fs9, import_node_module5, import_node_path13, import_docs, import_marked, import_sugar_high, DOCS_FILE_NAMES, DOCS_FILE_EXTENSIONS2, FARM_DOCS_FALLBACK_FAVICON, FARM_DOCS_FAVICON_FILES, CODE_LANGUAGE_LABELS, EXTENSIONLESS_CODE_FILENAMES, SIDEBAR_SECTION_ORDER, SIDEBAR_PAGE_ORDER, themeCssCache;
 var init_handler = __esm({
   "src/docs/handler.ts"() {
     "use strict";
-    import_node_fs8 = require("fs");
+    import_node_fs9 = require("fs");
     import_node_module5 = require("module");
-    import_node_path11 = __toESM(require("path"));
+    import_node_path13 = __toESM(require("path"));
     import_docs = require("@farming-labs/docs");
     import_marked = require("marked");
     import_sugar_high = require("sugar-high");
+    init_fonts();
     init_last_modified();
     init_pixel_border_css();
     init_search_client();
+    init_social_image();
     DOCS_FILE_NAMES = ["page.mdx", "page.md", "index.mdx", "index.md"];
     DOCS_FILE_EXTENSIONS2 = [".mdx", ".md"];
     FARM_DOCS_FALLBACK_FAVICON = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='black'/%3E%3Cpath d='M7 8h18v3H10v5h12v3H10v5H7z' fill='white'/%3E%3C/svg%3E";
     FARM_DOCS_FAVICON_FILES = ["favicon.svg", "favicon.ico", "favicon.png"];
-    GEIST_SANS_FONT_URL = "/assets/Geist-Variable-CrgPqtmy.woff2";
-    GEIST_MONO_FONT_URL = "/assets/GeistMono-Variable-BNLlm6Cd.woff2";
     __name(trimSlashes2, "trimSlashes");
-    __name(normalizeEntry, "normalizeEntry");
+    __name(normalizeEntry2, "normalizeEntry");
     __name(normalizeSlug, "normalizeSlug");
     __name(resolveFarmDocsFavicon, "resolveFarmDocsFavicon");
     __name(renderFarmDocsFaviconLink, "renderFarmDocsFaviconLink");
@@ -19701,6 +20930,11 @@ var init_handler = __esm({
     __name(readCssWithImports, "readCssWithImports");
     __name(resolvePixelBorderThemeCss, "resolvePixelBorderThemeCss");
     __name(renderFarmDocsBridgeCss, "renderFarmDocsBridgeCss");
+    __name(renderFarmDocsLayoutFontVariable, "renderFarmDocsLayoutFontVariable");
+    __name(renderFarmDocsFontPreloads, "renderFarmDocsFontPreloads");
+    __name(renderFarmDocsFontPreloadHeader, "renderFarmDocsFontPreloadHeader");
+    __name(getFarmLayoutFontPreloads, "getFarmLayoutFontPreloads");
+    __name(renderFarmLayoutFontPreloadHeader, "renderFarmLayoutFontPreloadHeader");
     __name(renderPixelDocsHtml, "renderPixelDocsHtml");
     __name(createFarmDocsHandler, "createFarmDocsHandler");
   }
@@ -20469,8 +21703,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path29, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path29);
+        for (const [path31, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path31);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -20484,8 +21718,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path29) {
-        return path29.replace(/^\/api/, "");
+      convertToOpenAPIPath(path31) {
+        return path31.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -20647,8 +21881,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path29, method) {
-        const cleanPath = path29.replace(/^\/api\//, "");
+      generateSummary(path31, method) {
+        const cleanPath = path31.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;
@@ -20657,22 +21891,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path29, method) {
-        const cleanPath = path29.replace(/^\/api\//, "");
+      generateDescription(path31, method) {
+        const cleanPath = path31.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path29, method) {
-        const cleanPath = path29.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path31, method) {
+        const cleanPath = path31.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path29) {
-        const cleanPath = path29.replace(/^\/api\//, "");
+      generateTags(path31) {
+        const cleanPath = path31.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -20685,8 +21919,8 @@ var init_generator = __esm({
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
         const fs8 = require("fs");
-        const path29 = require("path");
-        const dir = path29.dirname(outputPath);
+        const path31 = require("path");
+        const dir = path31.dirname(outputPath);
         if (!fs8.existsSync(dir)) {
           fs8.mkdirSync(dir, { recursive: true });
         }
@@ -21106,7 +22340,7 @@ async function createFarmDevtoolsSnapshot(input) {
     generatedAt: (input.now?.() || /* @__PURE__ */ new Date()).toISOString(),
     health: resolveHealth(diagnostics),
     project: {
-      name: import_node_path12.default.basename(import_node_path12.default.resolve(input.root)),
+      name: import_node_path14.default.basename(import_node_path14.default.resolve(input.root)),
       root: input.root,
       srcDir: input.srcDir,
       basePath: config.basePath || "/",
@@ -21155,11 +22389,11 @@ async function createFarmDevtoolsSnapshot(input) {
     diagnostics
   };
 }
-var import_node_path12;
+var import_node_path14;
 var init_devtools = __esm({
   "src/devtools.ts"() {
     "use strict";
-    import_node_path12 = __toESM(require("path"));
+    import_node_path14 = __toESM(require("path"));
     init_config2();
     init_cron();
     init_route_runtime();
@@ -22983,7 +24217,7 @@ function fileContainsProgrammaticPageRoute(file) {
 }
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path25.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path27.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -23003,7 +24237,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 = path27.resolve(path27.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -23084,7 +24318,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path25.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path27.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -23115,9 +24349,9 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path25.join(server.config.root, "src/app/globals.css");
+      const globalsCSSPath = path27.join(server.config.root, "src/app/globals.css");
       if (!fs7.existsSync(globalsCSSPath)) {
-        const appDir = path25.join(server.config.root, "src/app");
+        const appDir = path27.join(server.config.root, "src/app");
         if (!fs7.existsSync(appDir)) {
           fs7.mkdirSync(appDir, { recursive: true });
         }
@@ -23139,10 +24373,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) => path27.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}") ? path27.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -23152,7 +24386,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) => path27.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -23192,7 +24426,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path25.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path27.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -23310,7 +24544,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) => fs7.existsSync(path27.isAbsolute(dir) ? dir : path27.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler: createFarmWorkflowRequestHandler2, discoverFarmWorkflows: discoverFarmWorkflows2 } = await loadFarmWorkflowsDevRuntime();
@@ -23374,10 +24608,20 @@ function farmPlugin(options = {}, initialPluginManager) {
           logger.info(`Refreshed routes: ${reason}`);
         }
       }, "refreshRouteDiscovery");
+      const farmDocsFontAssetList = farmDocsDevRuntime ? resolveFarmDocsFontAssets(farmConfig.root) : [];
       const farmDocsHandler = farmDocsDevRuntime ? farmDocsDevRuntime.createFarmDocsHandler(farmConfig.docs, {
         root: farmConfig.root,
         srcDir: farmConfig.srcDir,
-        clientEntry: "/@farm/client.js"
+        clientEntry: "/@farm/client.js",
+        fontAssets: toFarmDocsPublicFontAssets(farmDocsFontAssetList),
+        resolveLayoutFonts: /* @__PURE__ */ __name(async (pathname) => {
+          const layouts = routeManager.matchRoute(pathname).layouts;
+          const layoutModules = await Promise.all(
+            layouts.map((layout2) => routeManager.loadLayoutModule(layout2.modulePath))
+          );
+          return resolveFarmLayoutFonts(layoutModules);
+        }, "resolveLayoutFonts"),
+        fontStylesheetHref: "/@farm/fonts.css"
       }) : null;
       const farmDocsAPIHandler = farmDocsDevRuntime ? farmDocsDevRuntime.createFarmDocsAPIHandler({
         rootDir: farmConfig.root,
@@ -23385,22 +24629,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         docs: farmConfig.docs
       }) : null;
       const farmDocsFontAssets = new Map(
-        farmDocsDevRuntime ? [
-          [
-            "/assets/Geist-Variable-CrgPqtmy.woff2",
-            path25.join(
-              farmConfig.root,
-              "node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2"
-            )
-          ],
-          [
-            "/assets/GeistMono-Variable-BNLlm6Cd.woff2",
-            path25.join(
-              farmConfig.root,
-              "node_modules/geist/dist/fonts/geist-mono/GeistMono-Variable.woff2"
-            )
-          ]
-        ] : []
+        farmDocsFontAssetList.map(({ url, sourcePath }) => [url, sourcePath])
       );
       const logRequest = /* @__PURE__ */ __name((method, urlPath, tag) => {
         try {
@@ -23464,11 +24693,12 @@ function farmPlugin(options = {}, initialPluginManager) {
             }
           }
           const farmDocsFontPath = farmDocsFontAssets.get(requestPathname);
-          if (farmDocsFontPath && fs7.existsSync(farmDocsFontPath)) {
+          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs7.existsSync(farmDocsFontPath)) {
             res.statusCode = 200;
             res.setHeader("Content-Type", "font/woff2");
             res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-            fs7.createReadStream(farmDocsFontPath).pipe(res);
+            if (requestMethod === "HEAD") res.end();
+            else fs7.createReadStream(farmDocsFontPath).pipe(res);
             return;
           }
           if (requestMethod === "GET" && (requestPathname === FARM_DEVTOOLS_PATH || requestPathname === `${FARM_DEVTOOLS_PATH}.json`)) {
@@ -24074,6 +25304,7 @@ function farmPlugin(options = {}, initialPluginManager) {
                   modulePath: toUrlPath(route.modulePath),
                   isClientComponent: routeSlots.length > 0 ? false : isClientComponent,
                   shouldHydrate: shouldHydrate || routeSlots.some((slot) => slot.isClientComponent || slot.shouldHydrate),
+                  islandStrategy: moduleMetadata.islandStrategy,
                   metadata: {
                     title: mergedMetadata.title,
                     description: mergedMetadata.description
@@ -24458,6 +25689,7 @@ export const getManifest = () => ({
             search: route.search,
             isClientComponent: moduleMetadata.isClientComponent,
             shouldHydrate: moduleMetadata.shouldHydrate,
+            islandStrategy: moduleMetadata.islandStrategy,
             preloads: [route.modulePath],
             // In dev, preload is just the module
             assets: []
@@ -24584,8 +25816,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 = path27.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path27.join(outDir, "client");
         for (const page2 of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page2.urlPath, "http://farm.static"));
@@ -24596,7 +25828,7 @@ if (import.meta.hot) {
               const layoutModules = await Promise.all(
                 layouts.map((l) => routeManager.loadLayoutModule(l.modulePath))
               );
-              const React3 = await import("react");
+              const React4 = await import("react");
               const { renderToString } = await import("react-dom/server");
               const PageComponent = mod.default;
               const pageProps = {
@@ -24604,14 +25836,14 @@ if (import.meta.hot) {
                 searchParams: Promise.resolve({}),
                 path: page2.urlPath
               };
-              let pageElement = React3.createElement(
+              let pageElement = React4.createElement(
                 PageComponent,
                 pageProps
               );
               for (let i = layoutModules.length - 1; i >= 0; i--) {
                 const layoutModule = layoutModules[i];
                 const LayoutComponent = layoutModule.default;
-                pageElement = React3.createElement(
+                pageElement = React4.createElement(
                   LayoutComponent,
                   {
                     children: pageElement,
@@ -24637,8 +25869,8 @@ 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 });
+              const outputPath = page2.urlPath === "/" ? path27.join(clientDir, "index.html") : path27.join(clientDir, page2.urlPath + ".html");
+              fs7.mkdirSync(path27.dirname(outputPath), { recursive: true });
               fs7.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page2.revalidate ? ` (revalidate: ${page2.revalidate}s)` : "";
               logger.success(`  \u2713 ${page2.urlPath}${revalidateInfo}`);
@@ -24647,7 +25879,7 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page2.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path25.join(outDir, "__ssg_manifest.json");
+        const manifestPath = path27.join(outDir, "__ssg_manifest.json");
         fs7.writeFileSync(
           manifestPath,
           JSON.stringify(
@@ -24683,9 +25915,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) => path27.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 ${path27.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -25076,6 +26308,7 @@ import React from 'react'
 import { hydrateRoot, createRoot } from 'react-dom/client'
 import { installChunkErrorRecovery, SPARouter } from '@farm.js/core/client'
 import { createClientPluginManager } from '@farm.js/core/plugin/client'
+import { scheduleFarmIslandHydration } from '@farm.js/core/internal/client-runtime'
 import { reviveDeferredData } from '@farm.js/core/deferred'
 import {
   createFarmDeploymentMismatchError,
@@ -25328,6 +26561,7 @@ class LegacyManifestSPARouter {
 
     // Only prefetch routes that will hydrate on the client.
     if (!match.route.isClientComponent && !match.route.shouldHydrate) return;
+    if (match.route.islandStrategy && match.route.islandStrategy !== 'load') return;
 
     const modulePath = match.route.modulePath;
     if (this.moduleCache.has(modulePath)) return;
@@ -25472,6 +26706,12 @@ let hasClientTakenOver = false;
 const routeSlotRoots = new Map();
 const routeSlotDefinitions = new Map();
 let activeRouteInterception = null;
+let pendingPageHydrationController = null;
+
+function cancelPendingPageHydration() {
+  pendingPageHydrationController?.abort();
+  pendingPageHydrationController = null;
+}
 
 function normalizeServerProps(rawProps) {
   const props = rawProps && typeof rawProps === 'object' ? { ...rawProps } : {};
@@ -25540,7 +26780,11 @@ async function hydrateInitialRouteSlots() {
     routeSlotDefinitions.set(getRouteSlotKey(slot), slot);
     if (!slot.isClientComponent && !slot.shouldHydrate) continue;
     try {
-      hydrated = (await renderRouteSlot(slot, 'hydrate')) || hydrated;
+      const slotHydrated = await renderRouteSlot(slot, 'hydrate');
+      hydrated = slotHydrated || hydrated;
+      if (slotHydrated) {
+        replayPreHydrationClicks(document.getElementById(slot.containerId));
+      }
     } catch (error) {
       console.warn('[Farm.js] Could not hydrate route slot:', slot.name, error);
     }
@@ -25611,16 +26855,29 @@ function applyCanonicalPathFromProps(props) {
   window.history.replaceState({ ...(window.history.state || {}), path: canonicalPath }, '', canonicalPath);
 }
 
-function replayPreHydrationClicks() {
-  window.__FARM_HYDRATED__ = true;
-  document.documentElement.dataset.farmHydrated = 'true';
+function replayPreHydrationClicks(container = null) {
+  if (!container) {
+    markFarmHydrated();
+  } else {
+    container.dataset.farmIslandHydrated = 'true';
+  }
 
   const queue = Array.isArray(window.__FARM_PREHYDRATION_CLICK_QUEUE__)
     ? window.__FARM_PREHYDRATION_CLICK_QUEUE__
     : [];
   if (queue.length === 0) return;
 
-  const queuedClicks = queue.splice(0, queue.length);
+  const queuedClicks = [];
+  const remainingClicks = [];
+  for (const queuedClick of queue) {
+    const target = queuedClick?.target;
+    if (!container || (target instanceof Node && container.contains(target))) {
+      queuedClicks.push(queuedClick);
+    } else {
+      remainingClicks.push(queuedClick);
+    }
+  }
+  queue.splice(0, queue.length, ...remainingClicks);
   for (const queuedClick of queuedClicks) {
     const target = queuedClick?.target;
     if (!target || typeof target.click !== 'function') continue;
@@ -25629,6 +26886,11 @@ function replayPreHydrationClicks() {
   }
 }
 
+function markFarmHydrated() {
+  window.__FARM_HYDRATED__ = true;
+  document.documentElement.dataset.farmHydrated = 'true';
+}
+
 async function buildClientHydrationElement(PageComponent, pageProps) {
   let element = React.createElement(PageComponent, pageProps);
   const loadingModulePath = window.__FARM_LOADING_MODULE__;
@@ -25771,9 +27033,10 @@ async function tryHydrateImportedPage(
   layouts,
   useHydrate = false,
   existingProps = null,
+  signal = null,
 ) {
   const modulePath = route?.modulePath;
-  if (!modulePath) {
+  if (!modulePath || signal?.aborted) {
     return false;
   }
 
@@ -25782,6 +27045,7 @@ async function tryHydrateImportedPage(
     pageModule = await import(/* @vite-ignore */ modulePath);
     pageModuleCache.set(modulePath, pageModule);
   }
+  if (signal?.aborted || !container?.isConnected) return false;
 
   const PageComponent = pageModule?.default;
   if (!PageComponent) {
@@ -25796,6 +27060,7 @@ async function tryHydrateImportedPage(
     window.location.pathname,
     existingProps,
   );
+  if (signal?.aborted || !container?.isConnected) return false;
 
   const wrappedElement = useHydrate && container?.id === '__farm_page__'
     ? wrapWithIntegrationProviders(
@@ -25806,6 +27071,7 @@ async function tryHydrateImportedPage(
         currentPageProps,
         layouts,
       );
+  if (signal?.aborted || !container?.isConnected) return false;
 
   if (useHydrate) {
     try {
@@ -25836,6 +27102,7 @@ async function tryHydrateImportedPage(
 async function renderPage(pageData) {
   const container = document.getElementById('root');
   if (!container) return;
+  cancelPendingPageHydration();
   const destination = window.location.pathname + window.location.search;
 
   if (pageData.interception) {
@@ -25852,6 +27119,7 @@ async function renderPage(pageData) {
     modulePath: pageData.modulePath,
     isClientComponent: pageData.isClientComponent === true,
     shouldHydrate: pageData.shouldHydrate === true,
+    islandStrategy: pageData.islandStrategy || 'load',
   };
   const params = pageData.props?.params || {};
   const layouts = (pageData.layoutModules || []).map((modulePath, index) => ({
@@ -26051,14 +27319,6 @@ async function hydrate() {
   }
 
   try {
-    // Pre-load layout for SPA navigation
-    try {
-      const layoutModule = await import(/* @vite-ignore */ '/src/app/layout.tsx');
-      LayoutComponent = layoutModule.default;
-    } catch (e) {
-      console.warn('[Farm.js] Could not preload layout:', e);
-    }
-
     // Check if this is a client component (set by SSR)
     const isClientComponent = window.__FARM_IS_CLIENT__ === true;
     const modulePath = window.__FARM_PAGE_MODULE__;
@@ -26106,34 +27366,88 @@ async function hydrate() {
       return
     }
 
-    const hydrationSession = await farmClientRuntime.beginHydration({
-      container: pageContainer,
-      mode: shouldHydrate ? 'hydrate' : 'render',
-    });
+    const currentRoute = findRoute(window.location.pathname)?.route;
+    const islandStrategy = window.__FARM_ISLAND_STRATEGY__ || currentRoute?.islandStrategy || 'load';
+    pageContainer.dataset.farmIsland = 'page';
+    pageContainer.dataset.farmIslandStrategy = islandStrategy;
 
-    let hydrated = false;
+    const hydrationPathname = window.location.pathname;
+    const hydrationController = new AbortController();
+    pendingPageHydrationController = hydrationController;
     try {
-      hydrated = await tryHydrateImportedPage(
-        pageContainer,
-        { modulePath },
-        currentPageProps.params || {},
-        layouts,
-        shouldHydrate,
-        currentPageProps,
-      );
-      await farmClientRuntime.completeHydration(hydrationSession);
-    } catch (error) {
-      await farmClientRuntime.failHydration(hydrationSession, error);
-      throw error;
-    }
+      await scheduleFarmIslandHydration({
+        container: pageContainer,
+        strategy: islandStrategy,
+        signal: hydrationController.signal,
+        hydrate: async () => {
+          if (
+            hydrationController.signal.aborted ||
+            !pageContainer.isConnected ||
+            window.location.pathname !== hydrationPathname
+          ) {
+            return;
+          }
 
-    if (hydrated) {
-      replayPreHydrationClicks();
-      console.log('[Farm.js] \u2705 Hydrated:', modulePath);
-      return;
-    }
+          // Layout code is only needed when this route boundary actually hydrates.
+          try {
+            const layoutModule = await import(/* @vite-ignore */ '/src/app/layout.tsx');
+            LayoutComponent = layoutModule.default;
+          } catch (e) {
+            console.warn('[Farm.js] Could not preload layout:', e);
+          }
+          if (hydrationController.signal.aborted || !pageContainer.isConnected) return;
+
+          const hydrationSession = await farmClientRuntime.beginHydration({
+            container: pageContainer,
+            mode: shouldHydrate ? 'hydrate' : 'render',
+          });
+
+          let hydrated = false;
+          try {
+            if (hydrationController.signal.aborted || !pageContainer.isConnected) {
+              await farmClientRuntime.failHydration(
+                hydrationSession,
+                new DOMException('Route hydration was cancelled', 'AbortError'),
+              );
+              return;
+            }
+            hydrated = await tryHydrateImportedPage(
+              pageContainer,
+              { modulePath },
+              currentPageProps.params || {},
+              layouts,
+              shouldHydrate,
+              currentPageProps,
+              hydrationController.signal,
+            );
+            if (hydrationController.signal.aborted || !pageContainer.isConnected) {
+              await farmClientRuntime.failHydration(
+                hydrationSession,
+                new DOMException('Route hydration was cancelled', 'AbortError'),
+              );
+              return;
+            }
+            await farmClientRuntime.completeHydration(hydrationSession);
+          } catch (error) {
+            await farmClientRuntime.failHydration(hydrationSession, error);
+            throw error;
+          }
 
-    console.log('[Farm.js] Server component - SPA router ready')
+          if (hydrated) {
+            // The scheduler owns queue draining and exactly-once click replay.
+            markFarmHydrated();
+            console.log('[Farm.js] \u2705 Hydrated:', modulePath, '(' + islandStrategy + ')');
+            return;
+          }
+
+          console.log('[Farm.js] Server component - SPA router ready')
+        },
+      });
+    } finally {
+      if (pendingPageHydrationController === hydrationController) {
+        pendingPageHydrationController = null;
+      }
+    }
   } catch (error) {
     console.error('[Farm.js] Hydration error:', error)
   }
@@ -26236,7 +27550,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 = path27.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, {
@@ -26381,13 +27695,16 @@ async function defineConfig2(config = {}) {
     customLogger: farmLogger,
     clearScreen: false,
     optimizeDeps: {
-      include: [
-        "react",
-        "react-dom",
-        "react-dom/client",
-        "react/jsx-runtime",
-        "react/jsx-dev-runtime"
-      ],
+      ...createFarmClientOptimizeDepsConfig(
+        createFarmClientOptimizeDepsEntries(
+          appRoot,
+          getFarmAppDirectories({ ...config, root: appRoot })
+        )
+      ),
+      // Pre-bundle every framework client-runtime entry with React. Without
+      // this, Vite can discover a linked Farm entry after the page has loaded,
+      // regenerate the optimizer browser hash, and leave React DOM holding a
+      // different React module instance from a client component.
       // Exclude server-side packages from browser bundling
       exclude: [
         "@farm.js/core/server",
@@ -26422,7 +27739,7 @@ async function defineConfig2(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path25.resolve(appRoot, "src"),
+        "@": path27.resolve(appRoot, "src"),
         // Nitro internals that should not be resolved in browser
         "supports-color": "data:text/javascript,export default false; export const supportsColor = false; export const stdout = false; export const stderr = false;",
         "@poppinss/dumper": "data:text/javascript,export default {};",
@@ -26439,7 +27756,7 @@ 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 fs7, path27, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
 var init_vite = __esm({
   "src/vite.ts"() {
     "use strict";
@@ -26460,7 +27777,7 @@ var init_vite = __esm({
     init_route_context();
     init_devtools_config();
     fs7 = __toESM(require("fs"));
-    path25 = __toESM(require("path"));
+    path27 = __toESM(require("path"));
     init_layers();
     init_environment_vite();
     init_version();
@@ -26470,9 +27787,12 @@ var init_vite = __esm({
     init_image_config();
     init_image_vite();
     init_font_vite();
+    init_font();
     init_image_server();
     init_server2();
     init_routing();
+    init_vite_config();
+    init_fonts();
     ALL_TYPE_ARTIFACTS = {
       routes: true,
       api: true,
@@ -27866,6 +29186,7 @@ init_layers();
 init_environment_vite();
 init_last_modified();
 init_search_client();
+init_fonts();
 
 // src/route-runtime-manifest.ts
 var import_path8 = __toESM(require("path"));
@@ -28047,7 +29368,7 @@ function farmRoutePatternToVercelSource(pattern) {
     } else if (segment === "*" || /^\[.+\]$/.test(segment)) {
       source += "/([^/]+)";
     } else {
-      source += `/${escapeRegExp2(segment)}`;
+      source += `/${escapeRegExp3(segment)}`;
     }
   }
   return source || "/";
@@ -28092,10 +29413,35 @@ function normalizePattern(value) {
   return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
 }
 __name(normalizePattern, "normalizePattern");
-function escapeRegExp2(value) {
+function escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp3, "escapeRegExp");
+
+// src/nitro/vercel-assets.ts
+var FARM_IMMUTABLE_ASSET_CACHE_CONTROL = "public, max-age=31536000, immutable";
+function createFarmVercelImmutableAssetRoute(basePath = "/") {
+  const normalizedBasePath = normalizeBasePath3(basePath);
+  const escapedBasePath = escapeRegex(normalizedBasePath);
+  const prefix = escapedBasePath ? `/${escapedBasePath}` : "";
+  return {
+    src: `^${prefix}/(?:assets|chunks)/(?:.+/)*[^/]+-h(?:[a-fA-F0-9]{8}|[a-fA-F0-9]{12}|[a-fA-F0-9]{16})\\.(?!(?:[hH][tT][mM][lL]?)$)[^/]+$`,
+    headers: {
+      "Cache-Control": FARM_IMMUTABLE_ASSET_CACHE_CONTROL
+    },
+    continue: true,
+    caseSensitive: true
+  };
+}
+__name(createFarmVercelImmutableAssetRoute, "createFarmVercelImmutableAssetRoute");
+function normalizeBasePath3(basePath) {
+  return basePath.trim().replace(/^\/+|\/+$/g, "");
+}
+__name(normalizeBasePath3, "normalizeBasePath");
+function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-__name(escapeRegExp2, "escapeRegExp");
+__name(escapeRegex, "escapeRegex");
 
 // src/nitro/universal-build.ts
 init_catalog();
@@ -28304,6 +29650,10 @@ function isCloudflareImagePreset(preset) {
   return preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module";
 }
 __name(isCloudflareImagePreset, "isCloudflareImagePreset");
+function shouldUseExternalMetadataImageRuntime(preset, hasGeneratedMetadataImages) {
+  return hasGeneratedMetadataImages && preset !== "vercel-edge" && !isCloudflareImagePreset(preset);
+}
+__name(shouldUseExternalMetadataImageRuntime, "shouldUseExternalMetadataImageRuntime");
 function resolveImageRuntime(config, preset) {
   if (config.images.provider === "none") return "none";
   const cloudflarePreset = isCloudflareImagePreset(preset);
@@ -28321,6 +29671,31 @@ function isNitroRollupExternal(id) {
   return NODE_BUILTIN_MODULES.has(id) || NITRO_EXTERNAL_MODULES.has(id) || normalizedId.startsWith(".prisma/") || normalizedId.includes("/node_modules/@prisma/client/") || normalizedId.includes("/node_modules/.prisma/client/");
 }
 __name(isNitroRollupExternal, "isNitroRollupExternal");
+var FARM_METADATA_IMAGE_WASM_PREFIX = "\0farm-metadata-image-wasm:";
+function createMetadataImageWasmPlugin() {
+  return {
+    name: "farm-metadata-image-wasm",
+    resolveId(source, importer) {
+      if (!source.endsWith(".wasm?module") || !importer?.replace(/\\/g, "/").includes("/@vercel/og/")) {
+        return null;
+      }
+      const requestPath = source.slice(0, -"?module".length);
+      const resolvedPath = import_path12.default.isAbsolute(requestPath) ? requestPath : import_path12.default.resolve(import_path12.default.dirname(importer.split("?", 1)[0]), requestPath);
+      return `${FARM_METADATA_IMAGE_WASM_PREFIX}${resolvedPath}`;
+    },
+    load(id) {
+      if (!id.startsWith(FARM_METADATA_IMAGE_WASM_PREFIX)) return null;
+      const wasmPath = id.slice(FARM_METADATA_IMAGE_WASM_PREFIX.length);
+      const encoded = (0, import_fs5.readFileSync)(wasmPath).toString("base64");
+      return `
+const encoded = ${JSON.stringify(encoded)};
+const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
+export default new WebAssembly.Module(bytes);
+`;
+    }
+  };
+}
+__name(createMetadataImageWasmPlugin, "createMetadataImageWasmPlugin");
 function collectSSRExternalPackages(ssrBundle) {
   const emittedFiles = new Set(
     Object.keys(ssrBundle).map((fileName) => fileName.replace(/^\.\//, ""))
@@ -28704,6 +30079,9 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
     }
     const { bundle: ssrBundle, entryFile: ssrEntryFile, configuredHeaderRoutes } = ssrResult;
     await writeSSRAssetsToClient(ssrBundle, clientOutputDir);
+    if (config.docs.enabled) {
+      await copyFarmDocsFontAssetsToClient(root, clientOutputDir);
+    }
     logger.info(`\u{1F680} Building server with Nitro (preset: ${preset})...`);
     await buildNitroUniversal(
       config,
@@ -28758,6 +30136,17 @@ async function writeSSRAssetsToClient(bundle, outputDir) {
   }
 }
 __name(writeSSRAssetsToClient, "writeSSRAssetsToClient");
+async function copyFarmDocsFontAssetsToClient(root, outputDir) {
+  const fs8 = await import("fs/promises");
+  await Promise.all(
+    resolveFarmDocsFontAssets(root).map(async ({ sourcePath, url }) => {
+      const targetPath = import_path12.default.join(outputDir, url.replace(/^\/+/, ""));
+      await fs8.mkdir(import_path12.default.dirname(targetPath), { recursive: true });
+      await fs8.copyFile(sourcePath, targetPath);
+    })
+  );
+}
+__name(copyFarmDocsFontAssetsToClient, "copyFarmDocsFontAssetsToClient");
 async function mergeBuiltFontCss(outputDir, fontCssSource) {
   const fs8 = await import("fs/promises");
   const fontCssPath = import_path12.default.join(outputDir, "farm-fonts.css");
@@ -28776,11 +30165,8 @@ async function mergeBuiltFontCss(outputDir, fontCssSource) {
   } catch {
   }
   const normalizedFontCss = typeof fontCss === "string" ? fontCss : Buffer.from(fontCss).toString("utf8");
+  await fs8.writeFile(fontCssPath, normalizedFontCss);
   await fs8.writeFile(clientCssPath, mergeFarmFontCss(clientCss, normalizedFontCss));
-  try {
-    await fs8.rm(fontCssPath, { force: true });
-  } catch {
-  }
 }
 __name(mergeBuiltFontCss, "mergeBuiltFontCss");
 var _IncompleteClientBuildOutputError = class _IncompleteClientBuildOutputError extends Error {
@@ -28845,7 +30231,11 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
       const metadata = getClientModuleMetadata(route.modulePath, root);
       if (metadata.shouldHydrate) {
         const relativePath2 = route.modulePath.replace(root, "").replace(/^\//, "");
-        clientPages.push({ ...route, relativePath: relativePath2 });
+        clientPages.push({
+          ...route,
+          relativePath: relativePath2,
+          islandStrategy: metadata.islandStrategy ?? "load"
+        });
         logger.info(`\u{1F4F1} Found hydratable route: ${route.pattern} -> ${route.modulePath}`);
       }
     } catch (error) {
@@ -28919,13 +30309,14 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
           },
           output: {
             entryFileNames: "[name].js",
-            chunkFileNames: "chunks/[name]-[hash].js",
+            chunkFileNames: "chunks/[name]-h[hash].js",
+            hashCharacters: "hex",
             // Use predictable name for CSS so we can reference it in SSR HTML
             assetFileNames: /* @__PURE__ */ __name((assetInfo) => {
               if (assetInfo.name?.endsWith(".css")) {
                 return "farm-client.css";
               }
-              return "assets/[name]-[hash][extname]";
+              return "assets/[name]-h[hash][extname]";
             }, "assetFileNames")
           },
           // Externalize Node.js built-ins and server-side modules for client build
@@ -29524,10 +30915,13 @@ document.addEventListener("click", function(e) {
   const imports = [];
   const routeEntries = [];
   const routeSlotEntries = [];
-  clientPages.forEach((page2, index) => {
+  clientPages.forEach((page2) => {
     const importPath = toImportPath(page2.modulePath);
-    imports.push(`import Page${index} from "${importPath}";`);
-    routeEntries.push(`  { pattern: ${JSON.stringify(page2.pattern)}, Component: Page${index} }`);
+    routeEntries.push(`  {
+    pattern: ${JSON.stringify(page2.pattern)},
+    islandStrategy: ${JSON.stringify(page2.islandStrategy)},
+    load: () => import(${JSON.stringify(importPath)}).then((module) => module.default),
+  }`);
   });
   clientRouteSlots.forEach((slot, index) => {
     const importPath = toImportPath(slot.modulePath);
@@ -29548,7 +30942,7 @@ ${cssImport}
 ${layoutImports}
 import React from "react";
 import { createRoot, hydrateRoot } from "react-dom/client";
-import { createClientPluginManager, installChunkErrorRecovery } from "@farm.js/core/internal/client-runtime";
+import { createClientPluginManager, installChunkErrorRecovery, scheduleFarmIslandHydration } from "@farm.js/core/internal/client-runtime";
 import { matchFarmRoute } from "@farm.js/core/router";
 ${clientPluginEntry.imports}
 ${i18nClientRuntime}
@@ -29621,6 +31015,12 @@ function matchRoute(pathname) {
   return null;
 }
 
+async function loadRouteComponent(route) {
+  if (route.Component) return route.Component;
+  route.Component = await route.load();
+  return route.Component;
+}
+
 function matchesRoutePrefix(pathname, pattern) {
   if (pattern === "/") return true;
   const pathSegments = getFarmRoutePathname(pathname).split("/").filter(Boolean);
@@ -29763,15 +31163,24 @@ function clearRouteInterception(destination) {
 
 // State
 let reactRoot = null;
+let reactRootContainer = null;
 let currentPathname = null;
 let isHydrated = false;
+let pendingPageHydrationController = null;
 
 ${generateUniversalRouterStateRuntime()}
 
+function cancelPendingPageHydration() {
+  pendingPageHydrationController?.abort();
+  pendingPageHydrationController = null;
+}
+
 function resetReactRoot() {
+  cancelPendingPageHydration();
   if (!reactRoot) return;
   reactRoot.unmount();
   reactRoot = null;
+  reactRootContainer = null;
   isHydrated = false;
 }
 
@@ -29785,49 +31194,77 @@ async function hydrate() {
     return;
   }
   
-  const hasRouteSlots =
-    Array.isArray(window.__FARM_ROUTE_SLOTS__) && window.__FARM_ROUTE_SLOTS__.length > 0;
   const container =
-    (hasRouteSlots ? document.getElementById("__farm_page__") : null) ||
+    document.getElementById("__farm_page__") ||
     document.getElementById("root");
   if (!container) {
     console.error("[Farm.js] No root element found");
     return;
   }
   
-  const Component = matched.route.Component;
-  const params = matched.params;
-  const searchParams = Object.fromEntries(new URLSearchParams(window.location.search));
-  
-  const props = { params: params, searchParams: Promise.resolve(searchParams) };
-  
-  // Create page element and wrap with layouts
-  const pageElement = React.createElement(Component, props);
-  const wrappedElement = hasRouteSlots
-    ? pageElement
-    : wrapWithLayouts(pageElement, pathname, params);
-
-  const shouldHydrate = !isHydrated && Boolean(container.innerHTML.trim());
-  const hydrationSession = await farmClientRuntime.beginHydration({
-    container,
-    mode: shouldHydrate ? "hydrate" : "render",
-  });
+  container.dataset.farmIsland = "page";
+  container.dataset.farmIslandStrategy = matched.route.islandStrategy || "load";
 
+  const hydrationController = new AbortController();
+  pendingPageHydrationController = hydrationController;
   try {
-    if (shouldHydrate) {
-      reactRoot = hydrateRoot(container, wrappedElement);
-      isHydrated = true;
-    } else {
-      if (!reactRoot) {
-        reactRoot = createRoot(container);
-      }
-      reactRoot.render(wrappedElement);
+    await scheduleFarmIslandHydration({
+      container,
+      strategy: matched.route.islandStrategy,
+      signal: hydrationController.signal,
+      hydrate: async function() {
+        const Component = await loadRouteComponent(matched.route);
+        if (
+          hydrationController.signal.aborted ||
+          !container.isConnected ||
+          window.location.pathname !== pathname
+        ) {
+          return;
+        }
+        const params = matched.params;
+        const searchParams = Object.fromEntries(new URLSearchParams(window.location.search));
+        const props = { params: params, searchParams: Promise.resolve(searchParams) };
+        const pageElement = React.createElement(Component, props);
+        const wrappedElement = container.id === "__farm_page__"
+          ? pageElement
+          : wrapWithLayouts(pageElement, pathname, params);
+        const shouldHydrate = !isHydrated && Boolean(container.innerHTML.trim());
+        const hydrationSession = await farmClientRuntime.beginHydration({
+          container,
+          mode: shouldHydrate ? "hydrate" : "render",
+        });
+
+        try {
+          if (hydrationController.signal.aborted || !container.isConnected) {
+            await farmClientRuntime.failHydration(
+              hydrationSession,
+              new DOMException("Route hydration was cancelled", "AbortError"),
+            );
+            return;
+          }
+          if (shouldHydrate) {
+            reactRoot = hydrateRoot(container, wrappedElement);
+            reactRootContainer = container;
+            isHydrated = true;
+          } else {
+            if (!reactRoot) {
+              reactRoot = createRoot(container);
+              reactRootContainer = container;
+            }
+            reactRoot.render(wrappedElement);
+          }
+          currentPathname = pathname;
+          await farmClientRuntime.completeHydration(hydrationSession);
+        } catch (error) {
+          await farmClientRuntime.failHydration(hydrationSession, error);
+          console.error("[Farm.js] Hydration error:", error);
+        }
+      },
+    });
+  } finally {
+    if (pendingPageHydrationController === hydrationController) {
+      pendingPageHydrationController = null;
     }
-    currentPathname = pathname;
-    await farmClientRuntime.completeHydration(hydrationSession);
-  } catch (error) {
-    await farmClientRuntime.failHydration(hydrationSession, error);
-    console.error("[Farm.js] Hydration error:", error);
   }
 }
 
@@ -29856,6 +31293,8 @@ ${generateUniversalRouterStateProperties()}
     const from = this.currentPath;
     if (await this.shouldBlockNavigation({ from, to, action })) return;
 
+    // A route transition invalidates any trigger waiting on the previous DOM boundary.
+    cancelPendingPageHydration();
     this.saveScrollPosition(window.location.pathname);
     this.startNavigation(from, url, action);
     let clientNavigation;
@@ -29922,7 +31361,9 @@ ${generateUniversalRouterStateProperties()}
       }
 
       if (matched) {
-        const Component = matched.route.Component;
+        // Navigation itself signals intent, so destination routes load eagerly even
+        // when their initial document hydration strategy is deferred.
+        const Component = await loadRouteComponent(matched.route);
         const params = matched.params;
         const searchParams = Object.fromEntries(url.searchParams);
         const props = { params: params, searchParams: Promise.resolve(searchParams) };
@@ -29948,8 +31389,10 @@ ${generateUniversalRouterStateProperties()}
 
           const container = document.getElementById("root");
           if (container) {
+            if (reactRoot && reactRootContainer !== container) resetReactRoot();
             if (!reactRoot) {
               reactRoot = createRoot(container);
+              reactRootContainer = container;
             }
             reactRoot.render(wrappedElement);
             currentPathname = pathname;
@@ -29959,7 +31402,7 @@ ${generateUniversalRouterStateProperties()}
         const html = await this.fetchPage(url.pathname + url.search);
         await farmClientRuntime.markNavigationLoaded(clientNavigation, html);
         await this.runViewTransition(options.viewTransition, async () => {
-          if (!this.swapContent(html, url.pathname + url.search)) {
+          if (!(await this.swapContent(html, url.pathname + url.search))) {
             throw new Error("Farm could not swap the target document");
           }
           const historyState = createHistoryState(
@@ -30014,7 +31457,7 @@ ${generateUniversalRouterStateProperties()}
     return html;
   },
   
-  swapContent: function(html, targetPath) {
+  swapContent: async function(html, targetPath) {
     const parser = new DOMParser();
     const doc = parser.parseFromString(html, "text/html");
     if (isFarmLocaleDocumentChange(doc)) return false;
@@ -30054,18 +31497,18 @@ ${generateUniversalRouterStateProperties()}
     const matched = matchRoute(newPathname);
     if (matched) {
       // Re-hydrate the client component
-      const Component = matched.route.Component;
+      const Component = await loadRouteComponent(matched.route);
       const params = matched.params;
       const searchParams = Object.fromEntries(targetUrl.searchParams);
       const props = { params: params, searchParams: Promise.resolve(searchParams) };
       const pageElement = React.createElement(Component, props);
-      const hasRouteSlots = nextRouteSlots.length > 0;
       const pageContainer =
-        (hasRouteSlots ? document.getElementById("__farm_page__") : null) || currentRoot;
-      const wrappedElement = hasRouteSlots
+        document.getElementById("__farm_page__") || currentRoot;
+      const wrappedElement = pageContainer.id === "__farm_page__"
         ? pageElement
         : wrapWithLayouts(pageElement, newPathname, params);
       reactRoot = hydrateRoot(pageContainer, wrappedElement);
+      reactRootContainer = pageContainer;
       isHydrated = true;
     }
     return true;
@@ -30356,6 +31799,10 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     i18nCatalogs
   );
   const virtualEntryId = "\0virtual:farm-ssr-entry";
+  const useExternalMetadataImageRuntime = shouldUseExternalMetadataImageRuntime(
+    preset,
+    metadataImageRoutes.some((image) => image.sourceType === "module")
+  );
   try {
     await viteBuild({
       root,
@@ -30376,6 +31823,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
           external: [
             "fsevents",
             "sharp",
+            ...useExternalMetadataImageRuntime ? ["@vercel/og"] : [],
             "@prisma/client",
             "@prisma/client/default",
             "@prisma/client/default.js",
@@ -30404,6 +31852,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         external: [
           "fsevents",
           "sharp",
+          ...useExternalMetadataImageRuntime ? ["@vercel/og"] : [],
           "esbuild",
           "lightningcss",
           "rollup",
@@ -30430,7 +31879,12 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         // React runtime. Leaving a React component package external can make it
         // resolve a second React instance at runtime and break hooks during SSR.
         // Native and build-only packages above remain explicitly external.
-        noExternal: preset === "cloudflare-module" ? ["@farm.js/core", "@farm.js/core/image", "better-call"] : true
+        noExternal: preset === "cloudflare-module" ? [
+          "@farm.js/core",
+          "@farm.js/core/image",
+          "better-call",
+          ...metadataImageRoutes.some((image) => image.sourceType === "module") ? ["@vercel/og"] : []
+        ] : true
       },
       define: {
         __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
@@ -30438,6 +31892,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       },
       plugins: [
         ...tailwindVitePlugin ? [tailwindVitePlugin] : [],
+        ...!useExternalMetadataImageRuntime && metadataImageRoutes.some((image) => image.sourceType === "module") ? [createMetadataImageWasmPlugin()] : [],
         {
           name: "farm-react-production-mode",
           enforce: "pre",
@@ -30516,8 +31971,12 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
 __name(buildSSRInMemory, "buildSSRInMemory");
 function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlots, errorRoutes, metadataImageRoutes, middlewareRoutes, redirectRoutes, configuredRewriteRoutes, configuredHeaderRoutes, notFoundPath, config, configModulePath, hasServerRuntimeIntegrations, hasRuntimeIntegrationConfig, hasConfiguredRuntimePlugins, preset, i18nCatalogs) {
   const hasPluginRuntime = hasRuntimeIntegrationConfig || hasConfiguredRuntimePlugins;
+  const hasGeneratedMetadataImages = metadataImageRoutes.some(
+    (image) => image.sourceType === "module"
+  );
   const hasMiddlewareRuntime = middlewareRoutes.length > 0 || hasFarmMiddlewareConfig(config.middleware);
   const farmDocsBaseConfig = config.docs?.enabled ? { ...config.docs, config: void 0 } : void 0;
+  const farmDocsFontAssets = config.docs?.enabled ? toFarmDocsPublicFontAssets(resolveFarmDocsFontAssets(config.root)) : [];
   const apiImports = [];
   const apiRegistrations = [];
   apiRoutes.forEach((route, index) => {
@@ -30556,12 +32015,13 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
       return;
     }
     pageImports.push(`import * as ${varName} from "${route.modulePath}";`);
-    const shouldHydrate = getClientModuleMetadata(route.modulePath, config.root).shouldHydrate;
+    const clientMetadata = getClientModuleMetadata(route.modulePath, config.root);
     pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route.pattern)},
     module: ${varName},
-    shouldHydrate: ${JSON.stringify(shouldHydrate)},
+    shouldHydrate: ${JSON.stringify(clientMetadata.shouldHydrate)},
+    islandStrategy: ${JSON.stringify(clientMetadata.islandStrategy)},
     ${route.source !== void 0 ? `markdownSource: {
       source: ${JSON.stringify(route.source)},
       filePath: ${JSON.stringify(route.markdownSourcePath)},
@@ -30659,16 +32119,21 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
   isFarmRedirectError,
   localizeFarmHref,
   localizeFarmPathname,
+  manageFarmDocumentPreloads,
+  manageFarmLinkHeaderPreloads,
   mergeMetadata,
   normalizeRevalidatePath,
+  reportFarmPreloadWarnings,
   renderMetadataHead,
   resolveFarmRouteContext,
   stripFarmLocaleFromPathname,
   withFarmRouteContext,
 } from "@farm.js/core/internal/production-runtime";`;
+  const metadataImageRuntimeImport = hasGeneratedMetadataImages ? `import { createFarmMetadataImageResponse } from "@farm.js/core/internal/metadata-image-runtime";` : "";
   const pluginRuntimeImport = hasPluginRuntime ? `import { PluginManager } from "@farm.js/core/plugin";` : "";
   const i18nServerImport = config.i18n.enabled ? `import { _runWithFarmI18nRequest, _setDefaultFarmI18nRuntime, createFarmI18nRuntime, getFarmI18nClientSnapshot } from "@farm.js/core/i18n/server";` : "";
   const docsHandlerImport = config.docs?.enabled ? `import { createFarmDocsAPIHandler, createFarmDocsHandler, isFarmDocsAPIRequest } from "@farm.js/core/docs";` : "";
+  const docsFontImport = config.docs?.enabled ? `import { resolveFarmLayoutFonts } from "@farm.js/core/font";` : "";
   const docsRuntimeImport = config.docs?.enabled ? `import { existsSync as farmDocsExistsSync } from "node:fs";
 import { dirname as farmDocsDirname, join as farmDocsJoin } from "node:path";
 import { fileURLToPath as farmDocsFileURLToPath } from "node:url";` : "";
@@ -30756,9 +32221,11 @@ ${middlewareImports.join("\n")}
 ${notFoundImport}
 ${apiRouteHelpersImport}
 ${productionRuntimeImport}
+${metadataImageRuntimeImport}
 ${pluginRuntimeImport}
 ${i18nServerImport}
 ${docsHandlerImport}
+${docsFontImport}
 ${docsRuntimeImport}
 ${markdownHandlerImport}
 ${appMarkdownImport}
@@ -30770,6 +32237,8 @@ import { farmFontPreloadHeader } from "virtual:farm-font-runtime";
 import * as React from "react";
 import * as ReactDOMServer from "react-dom/server";
 
+const farmPreloadConfig = ${JSON.stringify(config.performance.preload)};
+
 // Custom 404 page component (if provided)
 const hasCustomNotFound = ${notFoundPath ? "true" : "false"};
 const CustomNotFoundComponent = ${notFoundPath ? "CustomNotFound.default || CustomNotFound" : "null"};
@@ -30861,7 +32330,17 @@ globalThis.__FARM_DOCS_RUNTIME_CONFIG__ = {
   srcDir: ${JSON.stringify(config.srcDir)},
   docs: farmDocsResolvedConfig,
 };
-const farmDocsHandler = ${config.docs?.enabled ? `createFarmDocsHandler(farmDocsResolvedConfig, { root: farmDocsRuntimeRoot, srcDir: ${JSON.stringify(config.srcDir)}, clientEntry: "/farm-client.js" })` : "null"};
+const farmDocsHandler = ${config.docs?.enabled ? `createFarmDocsHandler(farmDocsResolvedConfig, {
+  root: farmDocsRuntimeRoot,
+  srcDir: ${JSON.stringify(config.srcDir)},
+  clientEntry: "/farm-client.js",
+  fontAssets: ${JSON.stringify(farmDocsFontAssets)},
+  resolveLayoutFonts: (pathname) =>
+    resolveFarmLayoutFonts(
+      getApplicableLayouts(getFarmRoutePathname(pathname)).map((layout) => layout.module),
+    ),
+  fontStylesheetHref: "/farm-fonts.css",
+})` : "null"};
 const farmDocsAPIHandler = ${config.docs?.enabled ? `createFarmDocsAPIHandler({ rootDir: farmDocsRuntimeRoot, srcDir: ${JSON.stringify(config.srcDir)}, docs: farmDocsResolvedConfig })` : "null"};
 
 // API routes bundled at build time
@@ -31522,30 +33001,10 @@ async function handleMetadataImageRequest(request, routePathname) {
       ? await imageModule.default(props)
       : imageModule.default;
 
-    if (value instanceof Response) {
-      return method === "HEAD"
-        ? new Response(null, { status: value.status, headers: value.headers })
-        : value;
-    }
-
-    let body;
-    if (typeof value === "string" || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
-      body = value;
-    } else {
-      if (!React.isValidElement(value)) {
-        throw new Error("Metadata image must return a Response, string, bytes, or React element");
-      }
-      body = ReactDOMServer.renderToStaticMarkup(value);
-    }
-
-    return new Response(method === "HEAD" ? null : body, {
-      status: 200,
-      headers: {
-        "Content-Type": imageModule.contentType || "image/svg+xml; charset=utf-8",
-        "Cache-Control": "public, max-age=0, must-revalidate",
-        "X-Content-Type-Options": "nosniff",
-      },
-    });
+    ${hasGeneratedMetadataImages ? `return createFarmMetadataImageResponse(value, imageModule, {
+      method,
+      ifNoneMatch: request.headers.get("if-none-match"),
+    });` : 'throw new Error("Generated metadata image runtime is unavailable");'}
   } catch (error) {
     console.error("Metadata image render failed:", error);
     return new Response("Internal Server Error", {
@@ -32081,7 +33540,16 @@ async function handleFarmRequestInContext(
   if (farmDocsHandler) {
     const docsResponse = await farmDocsHandler(request.clone());
     if (docsResponse) {
-      return docsResponse;
+      if (!docsResponse.headers.get("content-type")?.toLowerCase().includes("text/html")) {
+        return docsResponse;
+      }
+      const docsHeaders = new Headers(docsResponse.headers);
+      docsHeaders.set("x-farm-preload-buffered", "1");
+      return new Response(docsResponse.body, {
+        status: docsResponse.status,
+        statusText: docsResponse.statusText,
+        headers: docsHeaders,
+      });
     }
   }
   ` : ""}
@@ -32209,6 +33677,7 @@ async function handleFarmRequestInContext(
             status: 200,
             headers: {
               "Content-Type": "text/html; charset=utf-8",
+              "x-farm-preload-buffered": "1",
               ...(farmFontPreloadHeader ? { "Link": farmFontPreloadHeader } : {}),
               ...getPPRHeaders("hit", pprConfig),
             },
@@ -32436,10 +33905,15 @@ async function handleFarmRequestInContext(
               pageElement = React.createElement(PageComponent, pageProps);
             }
 
-            if (route.shouldHydrate && renderedRouteSlots.length > 0) {
+            if (route.shouldHydrate) {
               pageElement = React.createElement(
                 "div",
-                { id: "__farm_page__", "data-farm-client": "true" },
+                {
+                  id: "__farm_page__",
+                  "data-farm-client": "true",
+                  "data-farm-island": "page",
+                  "data-farm-island-strategy": route.islandStrategy || "load",
+                },
                 pageElement,
               );
             }
@@ -32590,7 +34064,7 @@ async function handleFarmRequestInContext(
           );
           return applyProductionMiddlewareHeaders(new Response(streamedDocument, {
             status: pageStatus,
-            headers: responseHeaders,
+            headers: { ...responseHeaders, "x-farm-preload-streaming": "1" },
           }), middlewareHeaders);
         }
 
@@ -32691,7 +34165,7 @@ async function handleFarmRequestInContext(
           fullHtml,
           { 
             status: pageStatus,
-            headers: responseHeaders
+            headers: { ...responseHeaders, "x-farm-preload-buffered": "1" }
           }
         ), middlewareHeaders);
       }
@@ -32795,6 +34269,7 @@ async function handleFarmRequestInContext(
             headers: {
               "Content-Type": "text/html; charset=utf-8",
               "Cache-Control": "private, no-store",
+              "x-farm-preload-buffered": "1",
             },
           }), middlewareHeaders);
         } catch (boundaryError) {
@@ -32817,6 +34292,7 @@ async function handleFarmRequestInContext(
           headers: {
             "Content-Type": "text/html; charset=utf-8",
             "Cache-Control": "private, no-store",
+            "x-farm-preload-buffered": "1",
           },
         }
       ), middlewareHeaders);
@@ -32963,13 +34439,19 @@ async function handleFarmRequestInContext(
 
     return applyProductionMiddlewareHeaders(new Response(fullHtml, {
       status: 404,
-      headers: { "Content-Type": "text/html; charset=utf-8" }
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        "x-farm-preload-buffered": "1",
+      }
     }), middlewareHeaders);
   } catch (error) {
     console.error("404 render error:", error);
     return applyProductionMiddlewareHeaders(new Response(
       \`<!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>\`,
-      { status: 404, headers: { "Content-Type": "text/html" } }
+      {
+        status: 404,
+        headers: { "Content-Type": "text/html", "x-farm-preload-buffered": "1" },
+      }
     ), middlewareHeaders);
   }
   ${hasMiddlewareRuntime ? `
@@ -33011,7 +34493,10 @@ async function handleFarmPluginRequest(request, runtimeOptions) {
   await farmPluginRuntime.runHookParallel("beforeRender", renderPayload);
 
   const response = await handleFarmRequest(request);
-  if (!hasFarmPluginHTMLTransforms || !response.headers.get("content-type")?.includes("text/html")) {
+  if (
+    !hasFarmPluginHTMLTransforms ||
+    !response.headers.get("content-type")?.toLowerCase().includes("text/html")
+  ) {
     return response;
   }
 
@@ -33021,6 +34506,8 @@ async function handleFarmPluginRequest(request, runtimeOptions) {
 
   const headers = new Headers(response.headers);
   headers.delete("content-length");
+  headers.delete("x-farm-preload-streaming");
+  headers.set("x-farm-preload-buffered", "1");
   return new Response(html, {
     status: response.status,
     statusText: response.statusText,
@@ -33028,6 +34515,49 @@ async function handleFarmPluginRequest(request, runtimeOptions) {
   });
 }
 
+async function applyFarmPreloadBudget(response, pathname) {
+  const headers = new Headers(response.headers);
+  const linkHeader = headers.get("Link") || "";
+  const isHtml = headers.get("Content-Type")?.toLowerCase().includes("text/html");
+  const isStreaming = headers.get("x-farm-preload-streaming") === "1";
+  const isBuffered = headers.get("x-farm-preload-buffered") === "1";
+  headers.delete("x-farm-preload-streaming");
+  headers.delete("x-farm-preload-buffered");
+
+  if (!isHtml) {
+    if (!isStreaming && !isBuffered) return response;
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }
+
+  if (isStreaming || !isBuffered || response.body === null) {
+    const managed = manageFarmLinkHeaderPreloads(linkHeader, farmPreloadConfig);
+    if (managed.value) headers.set("Link", managed.value);
+    else headers.delete("Link");
+    reportFarmPreloadWarnings(managed.warnings, "route " + pathname);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }
+
+  const html = await response.text();
+  const managed = manageFarmDocumentPreloads(html, linkHeader, farmPreloadConfig);
+  if (managed.linkHeader) headers.set("Link", managed.linkHeader);
+  else headers.delete("Link");
+  if (managed.html !== html) headers.delete("Content-Length");
+  reportFarmPreloadWarnings(managed.warnings, "route " + pathname);
+  return new Response(managed.html, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
 // Export as Web Standard fetch API
 export async function fetch(request, context) {
   const runtimeOptions = farmPluginRuntime ? getFarmPluginRequestOptions(request) : null;
@@ -33050,7 +34580,8 @@ export async function fetch(request, context) {
   const response = await _runWithCurrentRequest(request, () =>
     _runWithAfterRequest(request, runRequest, context),
   );
-  return applyConfiguredResponseHeaders(response, new URL(request.url).pathname);
+  const pathname = new URL(request.url).pathname;
+  return applyFarmPreloadBudget(applyConfiguredResponseHeaders(response, pathname), pathname);
 }
 export default { fetch };
   `.trim();
@@ -33206,8 +34737,19 @@ async function buildNitroUniversal(config, routeManager, apiRouteManager, server
   const outputDir = resolveDeployOutputPath(root, config.deploy.outputDir);
   const ssrOutputDir = import_path12.default.join(root, distDir, "ssr");
   const imageRuntime = resolveImageRuntime(config, preset);
+  const hasGeneratedMetadataImages = Array.from(routeManager.getMetadataImages().values()).some(
+    (image) => image.sourceType === "module"
+  );
+  const useExternalMetadataImageRuntime = shouldUseExternalMetadataImageRuntime(
+    preset,
+    hasGeneratedMetadataImages
+  );
+  const nitroRollupExternal = /* @__PURE__ */ __name((id) => useExternalMetadataImageRuntime && id === "@vercel/og" || isNitroRollupExternal(id), "nitroRollupExternal");
   const ssrExternalPackages = collectSSRExternalPackages(ssrBundle);
-  const copiedRuntimePackages = new Set(imageRuntime === "node" ? ["sharp"] : []);
+  const copiedRuntimePackages = /* @__PURE__ */ new Set([
+    ...imageRuntime === "node" ? ["sharp"] : [],
+    ...useExternalMetadataImageRuntime ? ["@vercel/og"] : []
+  ]);
   const isPrebuiltSSRCandidate = preset === "node-server" && [...ssrExternalPackages].every((packageName) => copiedRuntimePackages.has(packageName));
   logger.info(`\u{1F4E6} Nitro output directory: ${outputDir}`);
   logger.info(`\u{1F4E6} SSR entry file: ${ssrEntryFile}`);
@@ -33423,11 +34965,13 @@ export default async function farmNitroEventHandler(event) {
         ".prisma/client",
         ".prisma/client/default",
         "better-sqlite3",
-        "sharp"
+        "sharp",
+        ...useExternalMetadataImageRuntime ? ["@vercel/og"] : []
       ]
     },
     rollupConfig: {
-      external: isNitroRollupExternal
+      external: nitroRollupExternal,
+      plugins: hasGeneratedMetadataImages && !useExternalMetadataImageRuntime ? [createMetadataImageWasmPlugin()] : []
     },
     // Keep the public Nitro boolean intact for build hooks. It is translated to
     // Nitro's existing esbuild pass after hooks run, avoiding a second Terser pass.
@@ -33455,7 +34999,7 @@ export default async function farmNitroEventHandler(event) {
     snapshotSSRRebundleOptions(nitroConfig)
   );
   const requestedBuilder = nitroConfig.builder ?? process.env.NITRO_BUILDER;
-  const canReusePrebuiltSSR = isPrebuiltSSRCandidate && nitroConfig.preset === "node-server" && (requestedBuilder === void 0 || requestedBuilder === "rollup" || requestedBuilder === "rolldown") && nitroConfig.sourceMap === false && !hasUnsupportedEsbuildOverrides && !hasLateBuildMutationConfig && !hasUnsupportedSSRRebundleOverrides && nitroConfig.rollupConfig?.external === isNitroRollupExternal && !hasRollupPlugins(nitroConfig.rollupConfig?.plugins) && customRollupKeys.length === 0 && import_path12.default.resolve(nitroConfig.output?.serverDir || "") === import_path12.default.resolve(expectedServerDir) && Boolean(
+  const canReusePrebuiltSSR = isPrebuiltSSRCandidate && nitroConfig.preset === "node-server" && (requestedBuilder === void 0 || requestedBuilder === "rollup" || requestedBuilder === "rolldown") && nitroConfig.sourceMap === false && !hasUnsupportedEsbuildOverrides && !hasLateBuildMutationConfig && !hasUnsupportedSSRRebundleOverrides && nitroConfig.rollupConfig?.external === nitroRollupExternal && !hasRollupPlugins(nitroConfig.rollupConfig?.plugins) && customRollupKeys.length === 0 && import_path12.default.resolve(nitroConfig.output?.serverDir || "") === import_path12.default.resolve(expectedServerDir) && Boolean(
     nitroConfig.handlers?.some(
       (handler) => import_path12.default.resolve(handler?.handler || "") === nitroEntryPath
     )
@@ -33543,7 +35087,8 @@ export default async function farmNitroEventHandler(event) {
       effectiveMinify,
       fs8
     ) : Promise.resolve(),
-    imageRuntime === "node" ? copySharpRuntime(config, root, import_path12.default.join(outputDir, "server"), fs8) : Promise.resolve()
+    imageRuntime === "node" ? copySharpRuntime(config, root, import_path12.default.join(outputDir, "server"), fs8) : Promise.resolve(),
+    useExternalMetadataImageRuntime ? copyMetadataImageRuntime(root, import_path12.default.join(outputDir, "server"), fs8) : Promise.resolve()
   ]);
   const failedCopy = copyResults.find(
     (result) => result.status === "rejected"
@@ -33655,6 +35200,9 @@ async function postProcessVercelOutput(root, outputDir, fs8, config, farmWorkflo
     fs8
   );
   vercelConfig.routes = [
+    // Apply the header before the filesystem handler. `continue` lets Vercel
+    // serve the matching file while preserving the immutable cache policy.
+    createFarmVercelImmutableAssetRoute(config.basePath),
     // Serve static files first
     {
       handle: "filesystem"
@@ -33772,6 +35320,42 @@ async function copySharpRuntime(config, root, nitroFuncDir, fs8) {
   logger.info(`\u{1F5BC}\uFE0F  Bundled Sharp image runtime (${copiedPackages.size} packages)`);
 }
 __name(copySharpRuntime, "copySharpRuntime");
+async function copyMetadataImageRuntime(root, nitroFuncDir, fs8) {
+  const projectRequire = (0, import_module2.createRequire)(import_path12.default.join(root, "package.json"));
+  let runtimeRequire = projectRequire;
+  let packageJsonPath = resolvePackageJson(runtimeRequire, "@vercel/og");
+  if (!packageJsonPath) {
+    try {
+      runtimeRequire = (0, import_module2.createRequire)(projectRequire.resolve("@farm.js/core"));
+      packageJsonPath = resolvePackageJson(runtimeRequire, "@vercel/og");
+    } catch {
+    }
+  }
+  if (!packageJsonPath) {
+    throw new Error(
+      "Generated metadata images require @vercel/og. Reinstall @farm.js/core with production dependencies."
+    );
+  }
+  const packageJson = JSON.parse(await fs8.readFile(packageJsonPath, "utf8"));
+  const packageDir = import_path12.default.dirname(packageJsonPath);
+  const targetDir = import_path12.default.join(nitroFuncDir, "node_modules", "@vercel", "og");
+  await fs8.mkdir(import_path12.default.dirname(targetDir), { recursive: true });
+  await fs8.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 fs8.readFile(functionPackagePath, "utf8"));
+  functionPackage.dependencies = {
+    ...functionPackage.dependencies,
+    "@vercel/og": String(packageJson.version || "0.11.1")
+  };
+  await fs8.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  logger.info("\u{1F5BC}\uFE0F  Bundled generated metadata image runtime");
+}
+__name(copyMetadataImageRuntime, "copyMetadataImageRuntime");
 function resolvePackageJson(parentRequire, packageName) {
   for (const request of [`${packageName}/package.json`, `${packageName}/package`]) {
     try {
@@ -33831,54 +35415,7 @@ init_type_artifacts();
 init_plugin();
 init_environment_vite();
 init_font_vite();
-
-// src/server/vite-config.ts
-function mergeNoExternal(farmValue, userValue) {
-  if (farmValue === true || userValue === true) return true;
-  const normalize = /* @__PURE__ */ __name((value) => value == null || value === true ? [] : Array.isArray(value) ? value : [value], "normalize");
-  return Array.from(/* @__PURE__ */ new Set([...normalize(farmValue), ...normalize(userValue)]));
-}
-__name(mergeNoExternal, "mergeNoExternal");
-function mergeFarmViteConfig(farmConfig, userConfig = {}) {
-  return {
-    ...farmConfig,
-    ...userConfig,
-    plugins: [...farmConfig.plugins || [], ...userConfig.plugins || []],
-    server: {
-      ...farmConfig.server,
-      ...userConfig.server
-    },
-    resolve: {
-      ...farmConfig.resolve,
-      ...userConfig.resolve,
-      dedupe: Array.from(
-        /* @__PURE__ */ new Set([...farmConfig.resolve?.dedupe || [], ...userConfig.resolve?.dedupe || []])
-      )
-    },
-    optimizeDeps: {
-      ...farmConfig.optimizeDeps,
-      ...userConfig.optimizeDeps,
-      include: Array.from(
-        /* @__PURE__ */ new Set([
-          ...farmConfig.optimizeDeps?.include || [],
-          ...userConfig.optimizeDeps?.include || []
-        ])
-      ),
-      exclude: Array.from(
-        /* @__PURE__ */ new Set([
-          ...farmConfig.optimizeDeps?.exclude || [],
-          ...userConfig.optimizeDeps?.exclude || []
-        ])
-      )
-    },
-    ssr: {
-      ...farmConfig.ssr,
-      ...userConfig.ssr,
-      noExternal: mergeNoExternal(farmConfig.ssr?.noExternal, userConfig.ssr?.noExternal)
-    }
-  };
-}
-__name(mergeFarmViteConfig, "mergeFarmViteConfig");
+init_vite_config();
 
 // src/build/production-node-env.ts
 var productionNodeEnvStateKey = /* @__PURE__ */ Symbol.for("@farm.js/core/production-node-env-state");