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

package/dist/{chunk-77BOAQHI.mjs → chunk-Z3YG4OZT.mjs}

@@ -6,6 +6,12 @@ import {
   mergeMetadata,
   renderMetadataHead
 } from "./chunk-FRPWCMMG.mjs";
+import {
+  createFarmMetadataImageResponse
+} from "./chunk-53MVSX3R.mjs";
+import {
+  resolveFarmLayoutFonts
+} from "./chunk-6ZXIQSXE.mjs";
 import {
   farmEnvironmentFunctionsPlugin
 } from "./chunk-V6WE6JSZ.mjs";
@@ -24,9 +30,18 @@ import {
   isFarmNotFoundError,
   isFarmRedirectError
 } from "./chunk-7HO6AEOP.mjs";
+import {
+  resolveFarmDocsFontAssets,
+  toFarmDocsPublicFontAssets
+} from "./chunk-USLFXFFH.mjs";
 import {
   resolveFarmAuthConfig
 } from "./chunk-I4CUBGVF.mjs";
+import {
+  FARM_DEVTOOLS_LAUNCH_PARAM,
+  FARM_DEVTOOLS_PATH,
+  resolveFarmDevtoolsConfig
+} from "./chunk-7MABZJIM.mjs";
 import {
   normalizeRouteRules
 } from "./chunk-YW7OBE6Q.mjs";
@@ -36,10 +51,8 @@ import {
   getFarmSourceRoots
 } from "./chunk-74YTBPTY.mjs";
 import {
-  FARM_DEVTOOLS_LAUNCH_PARAM,
-  FARM_DEVTOOLS_PATH,
-  resolveFarmDevtoolsConfig
-} from "./chunk-7MABZJIM.mjs";
+  resolveFarmPerformanceConfig
+} from "./chunk-7ZVN3YZI.mjs";
 import {
   getPublicFarmImageConfig,
   resolveFarmImageConfig
@@ -147,7 +160,7 @@ import {
 } from "./chunk-RHIFZZUI.mjs";
 import {
   FARM_VERSION
-} from "./chunk-5EVQFRL2.mjs";
+} from "./chunk-3WIRO3N7.mjs";
 import {
   FARM_DEPLOYMENT_ID_HEADER,
   createFarmDeploymentCookie,
@@ -185,6 +198,22 @@ import { readFile } from "fs/promises";
 var OPTIONAL_CATCH_ALL_SEGMENT = /^\[\[\.\.\.([^\]]+)\]\]$/;
 var REQUIRED_CATCH_ALL_SEGMENT = /^\[\.\.\.([^\]]+)\]$/;
 var REQUIRED_DYNAMIC_SEGMENT = /^\[([^\]]+)\]$/;
+var 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"]
+]);
+var ROUTE_PROP_LABELS = /* @__PURE__ */ new Map([
+  ["searchParams", "URL search parameters"],
+  ["middleware", "middleware request data"],
+  ["middlewareData", "middleware request data"],
+  ["context", "request context"]
+]);
 function resolveRouteRenderingConfig(mod, source) {
   const directiveConfig = parseRouteRenderingDirective(source);
   let ssg = directiveConfig?.ssg ?? false;
@@ -237,6 +266,221 @@ async function resolveRouteRenderingConfigFromFile(mod, filePath) {
   return resolveRouteRenderingConfig(mod, source);
 }
 __name(resolveRouteRenderingConfigFromFile, "resolveRouteRenderingConfigFromFile");
+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
+  };
+}
+__name(analyzeStaticRouteCandidate, "analyzeStaticRouteCandidate");
+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${escapeRegExp(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${escapeRegExp(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${escapeRegExp(propsName)}\\s*\\.\\s*${name}\\b`).test(code)) {
+          blockers.add(`the route reads ${label}`);
+        }
+        if (new RegExp(`\\{[^}]*\\b${name}\\b[^}]*\\}\\s*=\\s*${escapeRegExp(propsName)}\\b`).test(
+          code
+        )) {
+          blockers.add(`the route reads ${label}`);
+        }
+      }
+    }
+  }
+  return [...blockers];
+}
+__name(findRequestBoundSourceBlockers, "findRequestBoundSourceBlockers");
+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;
+}
+__name(readRequestApiImportBindings, "readRequestApiImportBindings");
+function readNamespaceImportBindings(source) {
+  return readStaticImportClauses(source).map((clause) => clause.match(/\*\s*as\s*([A-Za-z_$][\w$]*)/)?.[1]).filter((binding) => Boolean(binding));
+}
+__name(readNamespaceImportBindings, "readNamespaceImportBindings");
+function readStaticImportClauses(source) {
+  return [...source.matchAll(/\bimport\s+(?!\()([\s\S]*?)\s+from\s*["'][^"']+["']/g)].map((match) => match[1]).filter((clause) => Boolean(clause));
+}
+__name(readStaticImportClauses, "readStaticImportClauses");
+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 = escapeRegExp(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];
+}
+__name(readDefaultRouteParameters, "readDefaultRouteParameters");
+function stripCommentsAndLiteralContents(source) {
+  return sanitizeSource(source, true);
+}
+__name(stripCommentsAndLiteralContents, "stripCommentsAndLiteralContents");
+function stripComments(source) {
+  return sanitizeSource(source, false);
+}
+__name(stripComments, "stripComments");
+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("");
+}
+__name(sanitizeSource, "sanitizeSource");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+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";
+}
+__name(hasExplicitRenderingConfig, "hasExplicitRenderingConfig");
 function parseRouteRenderingDirective(source) {
   if (!source) {
     return void 0;
@@ -368,9 +612,10 @@ function skipHorizontalWhitespace(source, start) {
   return index;
 }
 __name(skipHorizontalWhitespace, "skipHorizontalWhitespace");
-async function collectSSGPages(routes, loadModule) {
+async function collectSSGPages(routes, loadModule, options = {}) {
   const ssgPages = [];
   const ssrRoutes = [];
+  const staticCandidateRoutes = [];
   for (const route of routes) {
     try {
       const mod = await loadModule(route.filePath);
@@ -378,7 +623,8 @@ async function collectSSGPages(routes, loadModule) {
         ssrRoutes.push(route.path);
         continue;
       }
-      const rendering = await resolveRouteRenderingConfigFromFile(mod, route.filePath);
+      const source = await readFile(route.filePath, "utf8").catch(() => void 0);
+      const rendering = resolveRouteRenderingConfig(mod, source);
       if (rendering.ssg) {
         if (route.isDynamic) {
           const getStaticPaths = mod.getStaticPaths || mod.generateStaticParams;
@@ -405,12 +651,26 @@ async function collectSSGPages(routes, loadModule) {
         }
       } 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 };
 }
 __name(collectSSGPages, "collectSSGPages");
@@ -558,6 +818,15 @@ import path3 from "path";
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+
+// src/island.ts
+var FARM_ISLAND_STRATEGIES = ["load", "interaction", "visible", "idle"];
+function isFarmIslandStrategy(value) {
+  return FARM_ISLAND_STRATEGIES.includes(value);
+}
+__name(isFarmIslandStrategy, "isFarmIslandStrategy");
+
+// src/utils/client-component.ts
 function readIfExists(filePath) {
   try {
     if (!filePath || !fs.existsSync(filePath)) {
@@ -628,56 +897,186 @@ function hasHydrateExport(content) {
   return /\bexport\s+const\s+hydrate\s*=\s*true\b/.test(content) || /\bexport\s*\{\s*hydrate\s*\}\b/.test(content);
 }
 __name(hasHydrateExport, "hasHydrateExport");
+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;
+}
+__name(tokenizeModuleSource, "tokenizeModuleSource");
+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";
+}
+__name(isIslandExportStart, "isIslandExportStart");
+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;
+}
+__name(getIslandStrategyExport, "getIslandStrategyExport");
 function stripUseClientDirective(content) {
   return content.replace(/^\s*(["'])use client\1\s*;?\s*/, "");
 }
 __name(stripUseClientDirective, "stripUseClientDirective");
-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
   };
 }
 __name(parseClientModuleMetadata, "parseClientModuleMetadata");
 function getClientModuleMetadata(modulePath, root) {
   const resolvedPath = resolveModuleSourcePath(modulePath, root);
-  return inspectClientModuleMetadata(resolvedPath, root, /* @__PURE__ */ new Set());
+  return inspectClientModuleMetadata(resolvedPath, root, /* @__PURE__ */ new Set(), true);
 }
 __name(getClientModuleMetadata, "getClientModuleMetadata");
-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
   };
 }
 __name(inspectClientModuleMetadata, "inspectClientModuleMetadata");
@@ -855,6 +1254,10 @@ function parseInterceptionMarker(segment) {
 __name(parseInterceptionMarker, "parseInterceptionMarker");
 
 // 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");
+}
+__name(shouldSuggestStaticRenderingForI18n, "shouldSuggestStaticRenderingForI18n");
 function routeSpecificity(entry) {
   return entry.route.segments.reduce((score, segment) => {
     if (!segment.isDynamic) return score + 100;
@@ -1098,6 +1501,7 @@ var _RouteManager = class _RouteManager {
         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,
@@ -1560,8 +1964,10 @@ var _RouteManager = class _RouteManager {
       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;
     }
@@ -1693,7 +2099,7 @@ __name(safeGlobFiles, "safeGlobFiles");
 
 // src/server/renderer.ts
 import React from "react";
-import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
+import { renderToPipeableStream } from "react-dom/server";
 import * as fs2 from "fs";
 import * as path5 from "path";
 import { Writable } from "stream";
@@ -2027,6 +2433,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
@@ -2123,7 +2533,7 @@ ${FONT_SECTION_END}
     const normalizedExtension = extension.toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
     const baseName = sanitizeFileName(path4.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;
@@ -2393,7 +2803,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
   });
 }
 __name(serializeFontResult, "serializeFontResult");
@@ -2813,7 +3224,7 @@ function createPPRRefreshScript() {
 }
 __name(createPPRRefreshScript, "createPPRRefreshScript");
 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>`;
 }
 __name(createPreHydrationClickQueueScript, "createPreHydrationClickQueueScript");
 function searchParamsToObject(searchParams) {
@@ -3424,6 +3835,7 @@ var _ServerRenderer = class _ServerRenderer {
       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/")
@@ -3499,7 +3911,12 @@ var _ServerRenderer = class _ServerRenderer {
             if (isClientComponent || 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": moduleMetadata.islandStrategy ?? "load"
+                },
                 pageElement
               );
             }
@@ -3744,6 +4161,13 @@ var _ServerRenderer = class _ServerRenderer {
     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`);
@@ -3769,42 +4193,12 @@ var _ServerRenderer = class _ServerRenderer {
     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 (React.isValidElement(value)) {
-      body = 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();
@@ -3934,6 +4328,7 @@ var _ServerRenderer = class _ServerRenderer {
           search: routeEntry.search,
           isClientComponent: routeEntry.isClientComponent,
           shouldHydrate: routeEntry.shouldHydrate,
+          islandStrategy: routeEntry.islandStrategy,
           preloads: [routeEntry.modulePath],
           assets: []
         };
@@ -3970,6 +4365,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(relativePath)};
 window.__FARM_LOADING_MODULE__ = ${JSON.stringify(
         req.__FARM_LOADING_MODULE_PATH__ || null
@@ -4330,6 +4726,7 @@ var _FarmApp = class _FarmApp {
       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"
@@ -5076,7 +5473,7 @@ __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
 
 // src/vite.ts
 import * as fs4 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 
 // src/image-vite.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -5147,6 +5544,100 @@ async function createBlurDataURL(bytes) {
 }
 __name(createBlurDataURL, "createBlurDataURL");
 
+// src/server/vite-config.ts
+import path10 from "path";
+var FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
+var 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"
+];
+function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
+  const resolvedProjectRoot = path10.resolve(projectRoot);
+  return appDirectories.map((appDirectory) => {
+    const relativeAppDirectory = path10.relative(resolvedProjectRoot, path10.resolve(appDirectory)).replace(/\\/g, "/");
+    const prefix = relativeAppDirectory || ".";
+    return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
+  });
+}
+__name(createFarmClientOptimizeDepsEntries, "createFarmClientOptimizeDepsEntries");
+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] } : {}
+  };
+}
+__name(createFarmClientOptimizeDepsConfig, "createFarmClientOptimizeDepsConfig");
+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 = {}) {
+  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)
+    }
+  };
+}
+__name(mergeFarmViteConfig, "mergeFarmViteConfig");
+
 // src/vite.ts
 var ALL_TYPE_ARTIFACTS = {
   routes: true,
@@ -5189,7 +5680,7 @@ function loadFarmWorkflowsDevRuntime() {
 }
 __name(loadFarmWorkflowsDevRuntime, "loadFarmWorkflowsDevRuntime");
 function loadFarmDevtoolsSnapshotRuntime() {
-  return import("./devtools-A22KUJZT.mjs");
+  return import("./devtools-GAZ7F3KL.mjs");
 }
 __name(loadFarmDevtoolsSnapshotRuntime, "loadFarmDevtoolsSnapshotRuntime");
 function loadFarmDevtoolsUIRuntime() {
@@ -5368,7 +5859,7 @@ function fileContainsProgrammaticPageRoute(file) {
 __name(fileContainsProgrammaticPageRoute, "fileContainsProgrammaticPageRoute");
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path10.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path11.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -5388,7 +5879,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 = path10.resolve(path10.dirname(cleanId), sourcePath);
+    const resolvedPath = path11.resolve(path11.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -5473,7 +5964,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path10.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path11.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -5504,9 +5995,9 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path10.join(server.config.root, "src/app/globals.css");
+      const globalsCSSPath = path11.join(server.config.root, "src/app/globals.css");
       if (!fs4.existsSync(globalsCSSPath)) {
-        const appDir = path10.join(server.config.root, "src/app");
+        const appDir = path11.join(server.config.root, "src/app");
         if (!fs4.existsSync(appDir)) {
           fs4.mkdirSync(appDir, { recursive: true });
         }
@@ -5528,10 +6019,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path10.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path11.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path10.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path11.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -5541,7 +6032,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path10.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path11.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -5581,7 +6072,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path10.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path11.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -5699,7 +6190,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs4.existsSync(path10.isAbsolute(dir) ? dir : path10.join(farmConfig.root, dir))
+        (dir) => fs4.existsSync(path11.isAbsolute(dir) ? dir : path11.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler, discoverFarmWorkflows } = await loadFarmWorkflowsDevRuntime();
@@ -5763,10 +6254,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((layout) => routeManager.loadLayoutModule(layout.modulePath))
+          );
+          return resolveFarmLayoutFonts(layoutModules);
+        }, "resolveLayoutFonts"),
+        fontStylesheetHref: "/@farm/fonts.css"
       }) : null;
       const farmDocsAPIHandler = farmDocsDevRuntime ? farmDocsDevRuntime.createFarmDocsAPIHandler({
         rootDir: farmConfig.root,
@@ -5774,22 +6275,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         docs: farmConfig.docs
       }) : null;
       const farmDocsFontAssets = new Map(
-        farmDocsDevRuntime ? [
-          [
-            "/assets/Geist-Variable-CrgPqtmy.woff2",
-            path10.join(
-              farmConfig.root,
-              "node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2"
-            )
-          ],
-          [
-            "/assets/GeistMono-Variable-BNLlm6Cd.woff2",
-            path10.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 {
@@ -5853,11 +6339,12 @@ function farmPlugin(options = {}, initialPluginManager) {
             }
           }
           const farmDocsFontPath = farmDocsFontAssets.get(requestPathname);
-          if (farmDocsFontPath && fs4.existsSync(farmDocsFontPath)) {
+          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs4.existsSync(farmDocsFontPath)) {
             res.statusCode = 200;
             res.setHeader("Content-Type", "font/woff2");
             res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-            fs4.createReadStream(farmDocsFontPath).pipe(res);
+            if (requestMethod === "HEAD") res.end();
+            else fs4.createReadStream(farmDocsFontPath).pipe(res);
             return;
           }
           if (requestMethod === "GET" && (requestPathname === FARM_DEVTOOLS_PATH || requestPathname === `${FARM_DEVTOOLS_PATH}.json`)) {
@@ -6463,6 +6950,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
@@ -6847,6 +7335,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: []
@@ -6973,8 +7462,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path10.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path10.join(outDir, "client");
+        const outDir = path11.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path11.join(outDir, "client");
         for (const page of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page.urlPath, "http://farm.static"));
@@ -7026,8 +7515,8 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page.urlPath === "/" ? path10.join(clientDir, "index.html") : path10.join(clientDir, page.urlPath + ".html");
-              fs4.mkdirSync(path10.dirname(outputPath), { recursive: true });
+              const outputPath = page.urlPath === "/" ? path11.join(clientDir, "index.html") : path11.join(clientDir, page.urlPath + ".html");
+              fs4.mkdirSync(path11.dirname(outputPath), { recursive: true });
               fs4.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page.revalidate ? ` (revalidate: ${page.revalidate}s)` : "";
               logger.success(`  \u2713 ${page.urlPath}${revalidateInfo}`);
@@ -7036,7 +7525,7 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path10.join(outDir, "__ssg_manifest.json");
+        const manifestPath = path11.join(outDir, "__ssg_manifest.json");
         fs4.writeFileSync(
           manifestPath,
           JSON.stringify(
@@ -7072,9 +7561,9 @@ if (import.meta.hot) {
       }
       const currentFarmConfig = farmApp?.getConfig();
       const normalizedFile = file.replace(/\\/g, "/");
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path10.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path11.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path10.basename(file)}`);
+        logUpdate("PAGE", `updated ${path11.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -7471,6 +7960,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,
@@ -7723,6 +8213,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;
@@ -7867,6 +8358,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 } : {};
@@ -7935,7 +8432,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);
     }
@@ -8006,16 +8507,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;
@@ -8024,6 +8538,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__;
@@ -8166,9 +8685,10 @@ async function tryHydrateImportedPage(
   layouts,
   useHydrate = false,
   existingProps = null,
+  signal = null,
 ) {
   const modulePath = route?.modulePath;
-  if (!modulePath) {
+  if (!modulePath || signal?.aborted) {
     return false;
   }
 
@@ -8177,6 +8697,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) {
@@ -8191,6 +8712,7 @@ async function tryHydrateImportedPage(
     window.location.pathname,
     existingProps,
   );
+  if (signal?.aborted || !container?.isConnected) return false;
 
   const wrappedElement = useHydrate && container?.id === '__farm_page__'
     ? wrapWithIntegrationProviders(
@@ -8201,6 +8723,7 @@ async function tryHydrateImportedPage(
         currentPageProps,
         layouts,
       );
+  if (signal?.aborted || !container?.isConnected) return false;
 
   if (useHydrate) {
     try {
@@ -8231,6 +8754,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) {
@@ -8247,6 +8771,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) => ({
@@ -8446,14 +8971,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__;
@@ -8501,34 +9018,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;
 
-    console.log('[Farm.js] Server component - SPA router ready')
+          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;
+          }
+
+          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)
   }
@@ -8634,7 +9205,7 @@ function generateClientManifest(bundle) {
 __name(generateClientManifest, "generateClientManifest");
 async function defineConfig(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path10.resolve(config.root || process.cwd());
+  const appRoot = path11.resolve(config.root || process.cwd());
   if (config.extends?.length) {
     const { config: layeredConfig } = await import("./layers-VWVDTPUZ.mjs").then(
       ({ resolveFarmLayers }) => resolveFarmLayers(config, {
@@ -8779,13 +9350,16 @@ async function defineConfig(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",
@@ -8820,7 +9394,7 @@ async function defineConfig(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path10.resolve(appRoot, "src"),
+        "@": path11.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 {};",
@@ -8842,6 +9416,7 @@ __name(defineConfig, "defineConfig");
 export {
   resolveRouteRenderingConfig,
   resolveRouteRenderingConfigFromFile,
+  analyzeStaticRouteCandidate,
   parseRouteRenderingDirective,
   collectSSGPages,
   isSSGModule,
@@ -8864,9 +9439,12 @@ export {
   createFarmImageTypeDeclarations,
   generateFarmI18nTypes,
   generateFarmTypeArtifacts,
+  createFarmClientOptimizeDepsEntries,
+  createFarmClientOptimizeDepsConfig,
+  mergeFarmViteConfig,
   farmI18nClientBridgePlugin,
   rewriteEarlySsrRelativeImports,
   farmPlugin,
   defineConfig
 };
-//# sourceMappingURL=chunk-77BOAQHI.mjs.map
+//# sourceMappingURL=chunk-Z3YG4OZT.mjs.map