@farm.js/core 0.1.51-beta.3 → 0.1.60

package/dist/{chunk-3TLKUBXG.mjs → chunk-ZFUKPWFC.mjs}

@@ -5,7 +5,7 @@ import {
   collectSSGPages,
   matchSSGPage,
   resolveRouteRenderingConfigFromFile
-} from "./chunk-CZ35L6PL.mjs";
+} from "./chunk-LJVNMGE3.mjs";
 import {
   classifyFarmDocumentPrefix,
   composeFarmFullDocument,
@@ -24,16 +24,21 @@ import {
   getFarmServerTreeLayoutPatterns,
   getRouteDirectoryDepth,
   getRouteGroupScope,
+  getSharedLayoutPrefixLength,
   isInRouteGroupScope,
   openFarmStreamedDocument,
+  parseFarmLayoutChainHeader,
   removeFarmDocumentTitles,
   renderFarmLocaleAlternateLinks,
   resolveDefaultErrorStatus,
   routeBoundaryCoversDirectory
-} from "./chunk-YUEYBL35.mjs";
+} from "./chunk-PCXIJKPM.mjs";
+import {
+  handleFarmFormActionRequest
+} from "./chunk-Z5A6CNV2.mjs";
 import {
   listFarmMCPLlmsTxtLinks
-} from "./chunk-4TKAIO2F.mjs";
+} from "./chunk-ZMHAFH4R.mjs";
 import {
   FARM_DEFAULT_MCP_PATH,
   collectFarmDefaultMCPPages,
@@ -41,7 +46,7 @@ import {
   farmConfigMountsMCP,
   isFarmDefaultMCPPathname,
   resolveFarmDefaultMCPServer
-} from "./chunk-E5DXF5GE.mjs";
+} from "./chunk-UZZ6IEQP.mjs";
 import {
   createFarmMetadataImageResponse
 } from "./chunk-OZK2DS44.mjs";
@@ -49,9 +54,6 @@ import {
   installFarmIslandValues,
   uninstallFarmIslandValues
 } from "./chunk-A4PWGL46.mjs";
-import {
-  handleFarmFormActionRequest
-} from "./chunk-Z5A6CNV2.mjs";
 import {
   FARM_ISLAND_REPLAYABLE_SELECTOR,
   isFarmIslandStrategy
@@ -61,17 +63,6 @@ import {
   mergeProgrammaticClientRoutes,
   resolveProgrammaticClientRoutes
 } from "./chunk-ZQ5BDNKW.mjs";
-import {
-  createFarmMarkdownRouteModuleFromFile,
-  loadFarmMdxComponents
-} from "./chunk-3BLEXUGE.mjs";
-import {
-  isFarmMarkdownPageFile
-} from "./chunk-3Z63X45F.mjs";
-import {
-  _setDefaultFarmThemeConfig,
-  getTheme
-} from "./chunk-EMDGXYUD.mjs";
 import {
   isSecretDocsConfigKey
 } from "./chunk-EJCVG25Z.mjs";
@@ -105,14 +96,7 @@ import {
   resolveFarmAgentCrawlers,
   resolveFarmAgentSitemap,
   resolveFarmPerformanceConfig
-} from "./chunk-LDNSSHEG.mjs";
-import {
-  collectFarmLlmsTxtPages,
-  createFarmDefaultLlmsTxt,
-  createFarmLlmsMarkdownReader,
-  renderFarmLlmsFullTxt,
-  resolveFarmLlmsTxtConfig
-} from "./chunk-YAJTD3ZG.mjs";
+} from "./chunk-T4TBK5NY.mjs";
 import {
   createFarmCspNonce,
   createFarmCspNonceRewriter,
@@ -122,37 +106,55 @@ import {
   stampFarmCspNonce
 } from "./chunk-22W4FNTG.mjs";
 import {
-  resolveFarmImageConfig
-} from "./chunk-2NGZFOKG.mjs";
+  collectFarmLlmsTxtPages,
+  createFarmDefaultLlmsTxt,
+  createFarmLlmsMarkdownReader,
+  renderFarmLlmsFullTxt,
+  resolveFarmLlmsTxtConfig
+} from "./chunk-KVW2M6PI.mjs";
 import {
   getFarmAppDirectories,
   getFarmSourceRoots
 } from "./chunk-52Y3C3HG.mjs";
+import {
+  resolveFarmImageConfig
+} from "./chunk-2NGZFOKG.mjs";
+import {
+  createFarmMarkdownRouteModuleFromFile,
+  loadFarmMdxComponents
+} from "./chunk-55U5QIXQ.mjs";
+import {
+  isFarmMarkdownPageFile
+} from "./chunk-E72UD6ME.mjs";
 import {
   resolveFarmMdxComponentsModulePath,
   resolveMdxConfig
 } from "./chunk-UIJOLBUL.mjs";
+import {
+  FARM_MARKDOWN_CONTENT_TYPE,
+  FARM_MARKDOWN_PAGE_CHECK_HEADER,
+  _isFarmMarkdownPageCheck,
+  createFarmMarkdownErrorBody,
+  farmRequestWantsMarkdown,
+  getFarmMarkdownAlternatePath,
+  resolveMarkdownConfig
+} from "./chunk-YSXTNSXS.mjs";
 import {
   resolveWorkflowsConfig
-} from "./chunk-LZ4SB57H.mjs";
+} from "./chunk-JPIUGDK4.mjs";
 import {
   resolveCronConfig
-} from "./chunk-X3JNB2TB.mjs";
+} from "./chunk-3PX4AIXO.mjs";
 import {
   resolveServerActionsConfig
 } from "./chunk-FSQMN2MQ.mjs";
+import {
+  _setDefaultFarmThemeConfig,
+  getTheme
+} from "./chunk-EMDGXYUD.mjs";
 import {
   resolveFarmThemeConfig
 } from "./chunk-YWPNIYUP.mjs";
-import {
-  FARM_MARKDOWN_CONTENT_TYPE,
-  FARM_MARKDOWN_PAGE_CHECK_HEADER,
-  _isFarmMarkdownPageCheck,
-  createFarmMarkdownErrorBody,
-  farmRequestWantsMarkdown,
-  getFarmMarkdownAlternatePath,
-  resolveMarkdownConfig
-} from "./chunk-LPDKG6RA.mjs";
 import {
   initStorage
 } from "./chunk-TJVUTGED.mjs";
@@ -164,11 +166,11 @@ import {
   getIntegrationProviders,
   getRegisteredIntegrationAPIManifest,
   isFarmIntegrationProviderComponentReference
-} from "./chunk-Y2G5SJFB.mjs";
+} from "./chunk-IFHPDLIS.mjs";
 import {
   createRouteSlotContainerId,
   parseRouteSlotFile
-} from "./chunk-IRSS4HS4.mjs";
+} from "./chunk-K3RU5MOR.mjs";
 import {
   _clearCurrentMiddlewareContext,
   _clearCurrentMiddlewareData,
@@ -230,7 +232,7 @@ import {
   splitRoutePath,
   toRootRelativeUrlPath,
   toViteModuleId
-} from "./chunk-Y3N5BFRJ.mjs";
+} from "./chunk-JSDV2NUN.mjs";
 import {
   createFarmSearchParams,
   searchParamsToObject
@@ -242,6 +244,9 @@ import {
 import {
   sendWebResponse
 } from "./chunk-CO6UYM2D.mjs";
+import {
+  resolveFarmAPIServerBasePath
+} from "./chunk-2I6PUKWJ.mjs";
 import {
   matchesFarmIfNoneMatch,
   resolveFarmServerConfig
@@ -249,19 +254,16 @@ import {
 import {
   getRequestContextSnapshot
 } from "./chunk-D2LCAV6L.mjs";
-import {
-  resolveFarmAPIServerBasePath
-} from "./chunk-LM2YOGDK.mjs";
 import {
   FARM_VERSION
-} from "./chunk-R4PHCZ3G.mjs";
+} from "./chunk-HPWB57PZ.mjs";
 import {
   resolveFarmTrailingSlashRedirect,
   setFarmTrailingSlashPreference
 } from "./chunk-RFKTJTWZ.mjs";
 import {
   normalizeFarmAPIConfig
-} from "./chunk-BLD5GVCG.mjs";
+} from "./chunk-W6QLRQ3V.mjs";
 import {
   createFarmLocaleCookie,
   getFarmLocaleVaryHeaders
@@ -932,6 +934,41 @@ function resolveOwnerSourcePath(resolvedPath, root) {
   }
   return current;
 }
+function collectFarmRenderedClientModules(modulePath, root) {
+  const resolvedPath = resolveOwnerSourcePath(resolveModuleSourcePath(modulePath, root), root);
+  if (!resolvedPath) return null;
+  if (hasUseClientDirective(readIfExists(resolvedPath))) return [resolvedPath];
+  const collected = collectIsolatedClientBoundaries(resolvedPath, root, {
+    allowDynamicCardinality: true,
+    allowElementProps: true
+  });
+  if (collected.fallbackReason || collected.costGuardExceeded) return null;
+  return collected.boundaries.map((boundary) => boundary.modulePath);
+}
+var SERVER_MODULE_SOURCE = /\.[cm]?[jt]sx?$/;
+var STYLESHEET_SOURCE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)$/;
+function collectFarmServerStylesheets(modulePaths, root) {
+  const stylesheets = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (file) => {
+    if (visited.has(file) || !SERVER_MODULE_SOURCE.test(file)) return;
+    visited.add(file);
+    const content = readIfExists(file);
+    if (!content || hasUseClientDirective(content)) return;
+    for (const specifier of getImportSpecifiers(content)) {
+      if (specifier.includes("?")) continue;
+      const imported = resolveImportedModule(file, specifier, root);
+      if (!imported.path) continue;
+      if (STYLESHEET_SOURCE.test(imported.path)) stylesheets.add(imported.path);
+      else if (imported.local) visit(imported.path);
+    }
+  };
+  for (const modulePath of modulePaths) {
+    const resolved = resolveOwnerSourcePath(resolveModuleSourcePath(modulePath, root), root);
+    if (resolved) visit(resolved);
+  }
+  return [...stylesheets];
+}
 function getClientModuleMetadata(modulePath, root) {
   const resolvedPath = resolveModuleSourcePath(modulePath, root);
   return inspectClientModuleMetadata(resolvedPath, root, /* @__PURE__ */ new Set(), true);
@@ -946,7 +983,8 @@ function getClientModuleHydrationPlan(modulePath, root, mode = "off", options =
   if (!resolvedPath || owner.isClientComponent || owner.hasHydrateExport) return plan;
   const layout = collectIsolatedClientBoundaries(resolvedPath, root, {
     allowDynamicCardinality: true,
-    allowElementProps: true
+    allowElementProps: true,
+    staticPackageLeaves: true
   });
   const routeWide = {
     ...plan,
@@ -964,7 +1002,16 @@ function getClientModuleHydrationPlan(modulePath, root, mode = "off", options =
       islandsError: layout.fallbackHint ? `${layout.fallbackReason}. ${layout.fallbackHint}` : layout.fallbackReason
     };
   }
-  return { ...routeWide, serverTreeLayout: true, isolatedBoundaries: layout.boundaries };
+  const staticPackages = layout.staticPackages.length > 0 ? { staticPackageBoundaries: layout.staticPackages } : {};
+  if (layout.boundaries.length === 0) {
+    return { ...routeWide, shouldHydrate: false, islandStrategy: null, ...staticPackages };
+  }
+  return {
+    ...routeWide,
+    serverTreeLayout: true,
+    isolatedBoundaries: layout.boundaries,
+    ...staticPackages
+  };
 }
 function planClientModuleHydration(modulePath, root, mode, options) {
   const metadata = getClientModuleMetadata(modulePath, root);
@@ -995,7 +1042,8 @@ function planClientModuleHydration(modulePath, root, mode, options) {
   const inspection = collectIsolatedClientBoundaries(resolvedPath, root, {
     allowDynamicCardinality: asyncOwner,
     allowElementProps: asyncOwner,
-    staticPackageBoundaries: asyncOwner
+    staticPackageBoundaries: asyncOwner,
+    staticPackageLeaves: options.serverTreeLayouts === true && options.asyncOwnerIslands === true
   });
   if (inspection.fallbackReason && asyncOwner && options.serverOwners === true) {
     return {
@@ -1039,9 +1087,9 @@ function planClientModuleHydration(modulePath, root, mode, options) {
   if (asyncOwner) {
     delete plan.suppressedAsyncHydration;
     plan.asyncOwnerIslands = true;
-    if (inspection.staticPackages.length > 0)
-      plan.staticPackageBoundaries = inspection.staticPackages;
   }
+  if (inspection.staticPackages.length > 0)
+    plan.staticPackageBoundaries = inspection.staticPackages;
   return plan;
 }
 function usesFarmServerTree(plan) {
@@ -1104,10 +1152,10 @@ function restoreRouteWideHydration(metadata, fallbackReason) {
     metadata.fallbackReason = fallbackReason;
   }
 }
-function enforceFarmIsolatedHydrationRouteBudget(layouts, routes, layoutAppliesToRoute) {
+function enforceFarmIsolatedHydrationRouteBudget(layouts, routes, layoutAppliesToRoute, options = {}) {
   const boundaryLimit = isolatedHydrationBoundaryLimit();
   const sortedLayouts = [...layouts].sort((left, right) => left.depth - right.depth);
-  for (const route of routes) {
+  for (const route of options.serverOwners ? [] : routes) {
     if (route.metadata.mode !== "enabled") continue;
     const applicableLayouts = sortedLayouts.filter(
       (layout) => layoutAppliesToRoute(layout.pattern, route.pattern)
@@ -1414,6 +1462,25 @@ function passesElementValuedProps(content, localBindings) {
   }
   return false;
 }
+function rendersOnlyLeafElements(content, localBindings) {
+  if (!content) return false;
+  const names = new Set(localBindings);
+  const tokens = tokenizeModuleSource(content);
+  for (let index = 0; index < tokens.length - 1; index++) {
+    if (tokens[index].value !== "<" || !names.has(tokens[index + 1].value)) continue;
+    let braceDepth = 0;
+    let cursor = index + 2;
+    for (; cursor < tokens.length; cursor++) {
+      const value = tokens[cursor].value;
+      if (value === "{") braceDepth++;
+      else if (value === "}") braceDepth--;
+      else if (value === "<" && braceDepth > 0) return false;
+      else if (value === ">" && braceDepth === 0) break;
+    }
+    if (cursor >= tokens.length || tokens[cursor - 1]?.value !== "/") return false;
+  }
+  return true;
+}
 function hasDynamicJsxCardinality(content, localBindings) {
   if (!content || localBindings.length === 0) return false;
   const clientBindings = new Set(localBindings);
@@ -1492,7 +1559,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
       if (!imported.local) {
         const packageMetadata = inspectPackageClientBoundary(importedPath, root, /* @__PURE__ */ new Set());
         if (packageMetadata.shouldHydrate) {
-          if (options.staticPackageBoundaries) {
+          if (options.staticPackageBoundaries || options.staticPackageLeaves && rendersOnlyLeafElements(content, importedBindings.get(specifier) ?? [])) {
             staticPackages.add(specifier);
             continue;
           }
@@ -2472,7 +2539,7 @@ var RouteManager = class {
     for (const { entry, metadata } of [...layoutEntries, ...routeEntries]) {
       if (isFarmMarkdownPageFile(entry.modulePath) || !metadata.staticPackageBoundaries) continue;
       logger.info(
-        `[Farm.js] ${entry.pattern} is async, so it renders client components from ${metadata.staticPackageBoundaries.join(", ")} as static HTML: package client components cannot be isolated yet.`
+        `[Farm.js] ${entry.pattern} renders client components from ${metadata.staticPackageBoundaries.join(", ")} as static HTML: package client components cannot be isolated yet.`
       );
     }
     enforceFarmIsolatedHydrationRouteBudget(
@@ -2486,7 +2553,8 @@ var RouteManager = class {
         depth: getRouteDirectoryDepth(getRouteEntryDirectory(entry)),
         metadata
       })),
-      routeBoundaryCoversDirectory
+      routeBoundaryCoversDirectory,
+      { serverOwners: islandsMode }
     );
     for (const { entry, metadata } of [...layoutEntries, ...routeEntries]) {
       if (!metadata.costGuardExceeded) continue;
@@ -3309,17 +3377,18 @@ function resolveDevGlobalStylesheetHref(root, srcDir = "src") {
 }
 var STYLE_EXTENSIONS = /\.(css|scss|sass|less|styl|stylus)(?:$|\?)/;
 var ALREADY_LINKED = "/src/app/globals.css";
-function collectDevStylesheetUrls(modules, alreadyLinked = ALREADY_LINKED) {
+function collectDevStylesheetUrls(modules, alreadyLinked = ALREADY_LINKED, options = {}) {
   const seen = /* @__PURE__ */ new Set();
   for (const mod of modules) {
     const id = mod.id ?? mod.file ?? "";
     if (!STYLE_EXTENSIONS.test(id)) continue;
-    if (id.includes(".module.")) continue;
+    const cssModule = id.includes(".module.");
+    if (cssModule && !options.cssModules) continue;
     const url = mod.url;
     if (!url || !url.startsWith("/")) continue;
     const bare = url.split("?")[0];
     if (bare === alreadyLinked) continue;
-    seen.add(bare);
+    seen.add(cssModule ? `${bare}?direct` : bare);
   }
   return [...seen].sort();
 }
@@ -4423,101 +4492,498 @@ function resolveProviderModule(moduleId, root) {
   return toViteModuleId(path7.resolve(root, moduleId), root);
 }
 
-// src/server/renderer.ts
-import * as fs6 from "fs";
-import * as https from "https";
-import { isIP } from "net";
-import * as path10 from "path";
-import * as tls from "tls";
-import { Readable, Writable } from "stream";
-
-// src/not-found.ts
+// src/island-inference.ts
 import fs4 from "fs";
 import path8 from "path";
-function resolveFarmNotFoundComponentPath(config, appDirs) {
-  const extensions = getFarmRendererComponentExtensions(config.renderer);
-  const configuredPath = config.notFound?.component?.trim();
-  if (configuredPath) {
-    const componentPath = path8.isAbsolute(configuredPath) ? path8.normalize(configuredPath) : path8.resolve(config.root, configuredPath);
-    if (!extensions.some((extension) => componentPath.endsWith(extension))) {
-      throw new Error(
-        `notFound.component must use one of the configured renderer extensions: ${extensions.join(", ")}`
-      );
+import { inferStrategy } from "@farm.js/islx/compiler";
+import { parseAst } from "rolldown/parseAst";
+var PARSE_LANGS = /* @__PURE__ */ new Map([
+  [".tsx", "tsx"],
+  [".ts", "ts"],
+  [".jsx", "jsx"],
+  [".js", "jsx"],
+  [".mjs", "js"]
+]);
+function parseFarmIslandSource(file, code) {
+  const lang = PARSE_LANGS.get(path8.extname(file));
+  if (!lang) throw new Error(`${path8.basename(file)} is not a script module`);
+  return parseAst(code, { lang });
+}
+function modifiedAt(file) {
+  try {
+    return fs4.statSync(file).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+var inferences = /* @__PURE__ */ new Map();
+function inferFarmIslandStrategy(filePath, root) {
+  const file = path8.resolve(filePath);
+  const cached = inferences.get(file);
+  if (cached && cached.stamps.every(([read, stamp]) => modifiedAt(read) === stamp)) {
+    return cached.result;
+  }
+  let code;
+  try {
+    code = fs4.readFileSync(file, "utf8");
+  } catch {
+    return { strategy: null, files: [file], reason: `${path8.basename(file)} could not be read` };
+  }
+  const result = inferStrategy(file, code, {
+    parse: parseFarmIslandSource,
+    resolve: (specifier, importer) => {
+      const resolved = resolveImportedModule(importer, specifier, root);
+      return resolved.local ? resolved.path : null;
     }
-    if (!fs4.existsSync(componentPath) || !fs4.statSync(componentPath).isFile()) {
-      throw new Error(`notFound.component was not found: ${componentPath}`);
+  });
+  inferences.set(file, {
+    stamps: result.files.map((read) => [read, modifiedAt(read)]),
+    result
+  });
+  return result;
+}
+function inferFarmRouteRootStrategy(owners, root) {
+  const files = [];
+  const modules = [];
+  for (const owner of owners) {
+    const rendered = collectFarmRenderedClientModules(owner, root);
+    if (!rendered) {
+      return {
+        strategy: null,
+        files,
+        reason: `${path8.basename(owner)}: its client components could not be listed`
+      };
     }
-    return componentPath;
+    modules.push(...rendered);
   }
-  let discoveredPath = null;
-  for (const appDir of appDirs) {
-    for (const extension of extensions) {
-      const candidate = path8.join(appDir, `not-found${extension}`);
-      if (fs4.existsSync(candidate) && fs4.statSync(candidate).isFile()) {
-        discoveredPath = candidate;
-        break;
-      }
+  for (const module of modules) {
+    let source = null;
+    try {
+      source = fs4.readFileSync(module, "utf8");
+    } catch {
     }
+    if (getIslandStrategyExport(source) !== null) return { strategy: null, files, declared: true };
   }
-  return discoveredPath;
-}
-
-// src/components/not-found-styles.ts
-var DEFAULT_NOT_FOUND_STYLES = `
-body {
-  margin: 0;
-}
-
-.farm-default-not-found {
-  --farm-not-found-bg: #fafafa;
-  --farm-not-found-fg: #171717;
-  --farm-not-found-muted: #737373;
-  --farm-not-found-line: rgba(0, 0, 0, 0.16);
-  --farm-not-found-button-fg: #ffffff;
-  min-height: 100vh;
-  min-height: 100svh;
-  display: grid;
-  place-items: center;
-  padding: 24px;
-  color: var(--farm-not-found-fg);
-  background: var(--farm-not-found-bg);
-  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-  color-scheme: light;
+  for (const module of modules) {
+    const result = inferFarmIslandStrategy(module, root);
+    files.push(...result.files);
+    if (!result.strategy) return { strategy: null, files, reason: result.reason };
+  }
+  return { strategy: "interaction", files };
 }
-
-.farm-default-not-found,
-.farm-default-not-found * {
-  box-sizing: border-box;
+function resolveFarmRouteRootStrategy(route, page, layouts, root, islandsMode) {
+  const directory = route.directory ?? route.pattern;
+  const onRoute = layouts.filter(
+    (layout) => routeBoundaryCoversDirectory(layout.pattern, directory)
+  );
+  const declared = [
+    ...page.islandStrategy ? [page.islandStrategy] : [],
+    ...onRoute.flatMap(
+      (layout) => (layout.shouldHydrate || layout.hasIsolatedClientBoundaries) && layout.islandStrategy ? [layout.islandStrategy] : []
+    )
+  ];
+  const combined = declared.every((strategy) => strategy === declared[0]) ? declared[0] ?? "load" : "load";
+  const layoutHydrates = onRoute.some((layout) => layout.shouldHydrate);
+  if (!islandsMode || !page.shouldHydrate && !layoutHydrates) return combined;
+  const owners = [
+    route.modulePath,
+    ...layoutHydrates ? onRoute.map((layout) => layout.modulePath) : []
+  ];
+  const inference = inferFarmRouteRootStrategy(owners, root);
+  if (inference.declared) return combined;
+  return inference.strategy ?? "load";
 }
 
-.farm-default-not-found__content {
-  width: min(100%, 280px);
-  display: flex;
-  flex-direction: column;
-  align-items: center;
+// src/client-plugin-build.ts
+import fs5 from "fs";
+import path9 from "path";
+var CLIENT_KEYS = [
+  "public",
+  "setup",
+  "hydration",
+  "navigation",
+  "error",
+  "performance",
+  "close"
+];
+var HYDRATION_KEYS = ["before", "after"];
+var NAVIGATION_KEYS = ["before", "loaded", "resolved", "rendered", "error"];
+var MOBILE_SHELL_CLIENT_IMPORT = 'import { farmMobileShellClient as __farmMobileShellClient } from "@farm.js/core/internal/client-runtime";';
+var MOBILE_SHELL_CLIENT_REGISTRATION = `  {
+    name: "farm:mobile-shell",
+    enforce: "pre",
+    definition: __farmMobileShellClient,
+  }`;
+var APP_CLIENT_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
+function resolveFarmAppClientEntry(root = process.cwd(), srcDir = "src") {
+  const sourceRoot = path9.resolve(root, srcDir);
+  for (const extension of APP_CLIENT_EXTENSIONS) {
+    const candidate = path9.join(sourceRoot, `client.${extension}`);
+    if (fs5.existsSync(candidate) && fs5.statSync(candidate).isFile()) return candidate;
+  }
+  return void 0;
 }
-
-.farm-default-not-found__code {
-  margin: 0;
-  color: var(--farm-not-found-fg);
-  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
-  font-size: clamp(88px, 20vw, 140px);
-  font-weight: 800;
-  line-height: 0.75;
-  letter-spacing: -0.1em;
-  transform: translateX(-3px);
+function resolveFarmClientPlugins(plugins, _root) {
+  if (!plugins?.length) return [];
+  return plugins.flatMap((plugin) => {
+    if (!plugin.client) return [];
+    assertClientLifecycle(plugin.client, plugin.name);
+    assertPublicData(plugin.client.public, plugin.name);
+    return [
+      {
+        name: plugin.name,
+        version: plugin.version,
+        enforce: plugin.enforce,
+        definition: plugin.client,
+        publicData: plugin.client.public
+      }
+    ];
+  });
 }
-
-@supports (-webkit-text-stroke: 1px currentColor) {
-  .farm-default-not-found__code {
-    color: var(--farm-not-found-bg);
-    -webkit-text-stroke: 2px var(--farm-not-found-fg);
-    text-shadow: 5px 5px 0 var(--farm-not-found-fg);
+function generateFarmClientPluginEntryCode(plugins, root, srcDir = "src", appPublicData, platform = resolveFarmPlatform()) {
+  const resolved = resolveFarmClientPlugins(plugins, root);
+  const appClientEntry = root ? resolveFarmAppClientEntry(root, srcDir) : void 0;
+  const appImport = appClientEntry ? `import farmAppClientDefinition from ${JSON.stringify(appClientEntry.replace(/\\/g, "/"))};` : "";
+  const mobileShell = platform === "mobile";
+  const imports = mobileShell ? [MOBILE_SHELL_CLIENT_IMPORT, appImport].filter(Boolean).join("\n") : appImport;
+  const serializedPlugins = mobileShell ? [MOBILE_SHELL_CLIENT_REGISTRATION] : [];
+  serializedPlugins.push(
+    ...resolved.map(
+      (plugin) => `  {
+    name: ${JSON.stringify(plugin.name)},
+    version: ${serializeOptionalString(plugin.version)},
+    enforce: ${serializeOptionalString(plugin.enforce)},
+    definition: ${serializeClientLifecycle(plugin.definition, plugin.name)},
+    public: ${serializePublicData(plugin.publicData)},
+  }`
+    )
+  );
+  if (appClientEntry) {
+    assertPublicData(appPublicData, "farm:app-client");
+    serializedPlugins.push(`  {
+    name: "farm:app-client",
+    enforce: "post",
+    definition: farmAppClientDefinition,
+    public: ${serializePublicData(appPublicData)},
+  }`);
   }
+  const registrations = `[
+${serializedPlugins.join(",\n")}
+]`;
+  return { imports, registrations, plugins: resolved };
 }
-
-.farm-default-not-found__description {
-  width: 100%;
+function assertClientLifecycle(client, pluginName) {
+  assertLifecycleObject(client, pluginName, "client", CLIENT_KEYS);
+  assertHook(client.setup, pluginName, "client.setup");
+  assertHook(client.error, pluginName, "client.error");
+  assertHook(client.performance, pluginName, "client.performance");
+  assertHook(client.close, pluginName, "client.close");
+  if (client.hydration !== void 0) {
+    assertLifecycleObject(client.hydration, pluginName, "client.hydration", HYDRATION_KEYS);
+    assertHook(client.hydration.before, pluginName, "client.hydration.before");
+    assertHook(client.hydration.after, pluginName, "client.hydration.after");
+  }
+  if (client.navigation !== void 0) {
+    assertLifecycleObject(client.navigation, pluginName, "client.navigation", NAVIGATION_KEYS);
+    for (const key of NAVIGATION_KEYS) {
+      assertHook(client.navigation[key], pluginName, `client.navigation.${key}`);
+    }
+  }
+}
+function assertLifecycleObject(value, pluginName, location, allowedKeys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`Client plugin "${pluginName}" ${location} must be an object`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(`Client plugin "${pluginName}" ${location} must be a plain object`);
+  }
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key === "symbol") {
+      throw new TypeError(`Client plugin "${pluginName}" ${location} cannot contain symbol keys`);
+    }
+    if (!allowedKeys.includes(key)) {
+      throw new TypeError(`Client plugin "${pluginName}" has an unknown ${location}.${key} option`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable) {
+      throw new TypeError(`Client plugin "${pluginName}" ${location}.${key} must be enumerable`);
+    }
+    if (!("value" in descriptor)) {
+      throw new TypeError(`Client plugin "${pluginName}" ${location}.${key} cannot be an accessor`);
+    }
+  }
+}
+function assertHook(value, pluginName, location) {
+  if (value === void 0) return;
+  if (typeof value !== "function") {
+    throw new TypeError(`Client plugin "${pluginName}" ${location} must be a function`);
+  }
+  functionSource(value, pluginName, location);
+}
+function serializeClientLifecycle(definition, pluginName) {
+  const fields = [];
+  pushHook(fields, "setup", definition.setup, pluginName, "client.setup", 2);
+  pushHookGroup(fields, "hydration", definition.hydration, HYDRATION_KEYS, pluginName, 2);
+  pushHookGroup(fields, "navigation", definition.navigation, NAVIGATION_KEYS, pluginName, 2);
+  pushHook(fields, "error", definition.error, pluginName, "client.error", 2);
+  pushHook(fields, "performance", definition.performance, pluginName, "client.performance", 2);
+  pushHook(fields, "close", definition.close, pluginName, "client.close", 2);
+  return fields.length ? `{
+${fields.join(",\n")}
+  }` : "{}";
+}
+function pushHookGroup(fields, groupName, group, keys, pluginName, indent) {
+  if (!group) return;
+  const hooks = [];
+  for (const key of keys) {
+    pushHook(hooks, key, group[key], pluginName, `client.${groupName}.${key}`, indent + 2);
+  }
+  fields.push(
+    `${" ".repeat(indent)}${JSON.stringify(groupName)}: {
+${hooks.join(",\n")}
+${" ".repeat(indent)}}`
+  );
+}
+function pushHook(fields, key, hook, pluginName, location, indent) {
+  if (hook === void 0) return;
+  fields.push(
+    `${" ".repeat(indent)}${JSON.stringify(key)}: ${functionSource(hook, pluginName, location)}`
+  );
+}
+function functionSource(value, pluginName, location) {
+  if (typeof value !== "function") {
+    throw new TypeError(`Client plugin "${pluginName}" ${location} must be a function`);
+  }
+  const source = Function.prototype.toString.call(value).trim();
+  if (!source || source.includes("[native code]")) {
+    throw new TypeError(
+      `Client plugin "${pluginName}" ${location} must be authored inline and cannot be native or bound`
+    );
+  }
+  if (/^(?:async\s+)?function(?:\s*\*)?(?:\s+|\()/.test(source)) {
+    return `(${source})`;
+  }
+  const method = source.match(/^(async\s+)?(\*\s*)?[$A-Z_a-z][$\w]*\s*(\([\s\S]*)$/);
+  if (method) {
+    const asyncPrefix = method[1] ?? "";
+    const generator = method[2] ? "*" : "";
+    return `(${asyncPrefix}function${generator}${method[3]})`;
+  }
+  if (source.includes("=>")) return `(${source})`;
+  throw new TypeError(
+    `Client plugin "${pluginName}" ${location} must use a function, method, or arrow function`
+  );
+}
+function assertPublicData(value, pluginName) {
+  if (value === void 0) return;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (current, pathSegments) => {
+    if (current === null || typeof current === "string" || typeof current === "boolean") {
+      return;
+    }
+    if (typeof current === "number") {
+      if (Number.isFinite(current)) return;
+      throwPublicDataError(pluginName, pathSegments, "must be a finite number");
+    }
+    if (typeof current !== "object") {
+      throwPublicDataError(pluginName, pathSegments, `cannot contain ${typeof current} values`);
+    }
+    if (seen.has(current)) {
+      throwPublicDataError(pluginName, pathSegments, "cannot contain circular references");
+    }
+    seen.add(current);
+    if (Array.isArray(current)) {
+      for (let index = 0; index < current.length; index += 1) {
+        if (!Object.prototype.hasOwnProperty.call(current, index)) {
+          throwPublicDataError(
+            pluginName,
+            [...pathSegments, String(index)],
+            "cannot contain sparse array slots"
+          );
+        }
+        visit(current[index], [...pathSegments, String(index)]);
+      }
+      for (const key of Reflect.ownKeys(current)) {
+        if (key === "length" || typeof key === "string" && isArrayIndex(key)) continue;
+        throwPublicDataError(
+          pluginName,
+          pathSegments,
+          typeof key === "symbol" ? "cannot contain symbol keys" : `cannot contain non-index array property ${key}`
+        );
+      }
+      seen.delete(current);
+      return;
+    }
+    const prototype = Object.getPrototypeOf(current);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throwPublicDataError(pluginName, pathSegments, "must contain only plain objects and arrays");
+    }
+    for (const key of Reflect.ownKeys(current)) {
+      if (typeof key === "symbol") {
+        throwPublicDataError(pluginName, pathSegments, "cannot contain symbol keys");
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(current, key);
+      if (!descriptor?.enumerable) {
+        throwPublicDataError(
+          pluginName,
+          [...pathSegments, key],
+          "cannot contain non-enumerable properties"
+        );
+      }
+      if (!("value" in descriptor)) {
+        throwPublicDataError(
+          pluginName,
+          [...pathSegments, key],
+          "cannot contain accessor properties"
+        );
+      }
+      visit(descriptor.value, [...pathSegments, key]);
+    }
+    seen.delete(current);
+  };
+  visit(value, []);
+}
+function throwPublicDataError(pluginName, pathSegments, message) {
+  const location = pathSegments.length ? ` at client.public.${pathSegments.join(".")}` : "";
+  throw new TypeError(`Client plugin "${pluginName}"${location} ${message}`);
+}
+function serializePublicData(value) {
+  if (value === void 0) return "undefined";
+  return `JSON.parse(${JSON.stringify(JSON.stringify(value))})`;
+}
+function serializeOptionalString(value) {
+  return value === void 0 ? "undefined" : JSON.stringify(value);
+}
+function isArrayIndex(key) {
+  const value = Number(key);
+  return Number.isInteger(value) && value >= 0 && value < 4294967295 && String(value) === key;
+}
+
+// src/server/renderer.ts
+import * as fs8 from "fs";
+import * as https from "https";
+import { isIP } from "net";
+import * as path12 from "path";
+import * as tls from "tls";
+import { Readable, Writable } from "stream";
+
+// src/not-found.ts
+import fs6 from "fs";
+import path10 from "path";
+function resolveFarmNotFoundComponentPath(config, appDirs) {
+  const extensions = getFarmRendererComponentExtensions(config.renderer);
+  const configuredPath = config.notFound?.component?.trim();
+  if (configuredPath) {
+    const componentPath = path10.isAbsolute(configuredPath) ? path10.normalize(configuredPath) : path10.resolve(config.root, configuredPath);
+    if (!extensions.some((extension) => componentPath.endsWith(extension))) {
+      throw new Error(
+        `notFound.component must use one of the configured renderer extensions: ${extensions.join(", ")}`
+      );
+    }
+    if (!fs6.existsSync(componentPath) || !fs6.statSync(componentPath).isFile()) {
+      throw new Error(`notFound.component was not found: ${componentPath}`);
+    }
+    return componentPath;
+  }
+  let discoveredPath = null;
+  for (const appDir of appDirs) {
+    for (const extension of extensions) {
+      const candidate = path10.join(appDir, `not-found${extension}`);
+      if (fs6.existsSync(candidate) && fs6.statSync(candidate).isFile()) {
+        discoveredPath = candidate;
+        break;
+      }
+    }
+  }
+  return discoveredPath;
+}
+
+// src/navigation/segment-navigation.ts
+function getFarmLayoutKey(pattern, params) {
+  return pattern.replace(
+    /\[\[?\.\.\.([^\]]+)\]?\]|\[([^\]]+)\]/g,
+    (_match, rest, name) => {
+      const value = params ? params[rest || name] : void 0;
+      if (Array.isArray(value)) return value.map(encodeURIComponent).join("/");
+      return value === void 0 ? "" : encodeURIComponent(String(value));
+    }
+  );
+}
+function countFarmKeptLayouts(layoutsHeader, layouts, params) {
+  const chain = parseFarmLayoutChainHeader(layoutsHeader ?? null);
+  if (chain.length === 0) return 0;
+  const keys = layouts.map((layout) => getFarmLayoutKey(layout.pattern, params));
+  if (chain[0] === keys[0]) return getSharedLayoutPrefixLength(chain, keys);
+  return keys.length > 1 ? 1 + getSharedLayoutPrefixLength(chain, keys.slice(1)) : 0;
+}
+function createFarmFlushToken() {
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  let token = "";
+  for (const byte of bytes) token += byte.toString(16).padStart(2, "0");
+  return token;
+}
+function farmFlushMarker(token) {
+  return `<!--farm-flush:${token}-->`;
+}
+
+// src/components/not-found-styles.ts
+var DEFAULT_NOT_FOUND_STYLES = `
+body {
+  margin: 0;
+}
+
+.farm-default-not-found {
+  --farm-not-found-bg: #fafafa;
+  --farm-not-found-fg: #171717;
+  --farm-not-found-muted: #737373;
+  --farm-not-found-line: rgba(0, 0, 0, 0.16);
+  --farm-not-found-button-fg: #ffffff;
+  min-height: 100vh;
+  min-height: 100svh;
+  display: grid;
+  place-items: center;
+  padding: 24px;
+  color: var(--farm-not-found-fg);
+  background: var(--farm-not-found-bg);
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color-scheme: light;
+}
+
+.farm-default-not-found,
+.farm-default-not-found * {
+  box-sizing: border-box;
+}
+
+.farm-default-not-found__content {
+  width: min(100%, 280px);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.farm-default-not-found__code {
+  margin: 0;
+  color: var(--farm-not-found-fg);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: clamp(88px, 20vw, 140px);
+  font-weight: 800;
+  line-height: 0.75;
+  letter-spacing: -0.1em;
+  transform: translateX(-3px);
+}
+
+@supports (-webkit-text-stroke: 1px currentColor) {
+  .farm-default-not-found__code {
+    color: var(--farm-not-found-bg);
+    -webkit-text-stroke: 2px var(--farm-not-found-fg);
+    text-shadow: 5px 5px 0 var(--farm-not-found-fg);
+  }
+}
+
+.farm-default-not-found__description {
+  width: 100%;
   display: flex;
   align-items: center;
   gap: 12px;
@@ -4620,8 +5086,8 @@ body {
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/server/error-diagnostics.ts
-import * as fs5 from "fs";
-import * as path9 from "path";
+import * as fs7 from "fs";
+import * as path11 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var SECRET_VALUE_PATTERN = /\b(api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|secret[_-]?key|token|password|secret)\s*[:=]\s*([^\s,;]+)/gi;
 var BEARER_PATTERN = /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi;
@@ -4629,8 +5095,8 @@ function redactErrorText(value) {
   return value.replace(BEARER_PATTERN, "$1[REDACTED]").replace(SECRET_VALUE_PATTERN, "$1=[REDACTED]");
 }
 function isPathInsideRoot(root, filePath) {
-  const relative3 = path9.relative(root, filePath);
-  return relative3 === "" || !relative3.startsWith("..") && !path9.isAbsolute(relative3);
+  const relative3 = path11.relative(root, filePath);
+  return relative3 === "" || !relative3.startsWith("..") && !path11.isAbsolute(relative3);
 }
 function normalizeStackPath(value) {
   const withoutQuery = value.replace(/[?#].*$/, "");
@@ -4647,13 +5113,13 @@ function findStackLocation(stack, root) {
     );
     if (!match) continue;
     const candidate = normalizeStackPath(match[1]);
-    if (!candidate || candidate.includes(`${path9.sep}node_modules${path9.sep}`)) continue;
-    const absolutePath = path9.resolve(candidate);
-    if (!isPathInsideRoot(root, absolutePath) || !fs5.existsSync(absolutePath)) continue;
-    const relativePath = path9.relative(root, absolutePath).split(path9.sep).join("/");
+    if (!candidate || candidate.includes(`${path11.sep}node_modules${path11.sep}`)) continue;
+    const absolutePath = path11.resolve(candidate);
+    if (!isPathInsideRoot(root, absolutePath) || !fs7.existsSync(absolutePath)) continue;
+    const relativePath = path11.relative(root, absolutePath).split(path11.sep).join("/");
     return {
       absolutePath,
-      displayPath: relativePath || path9.basename(absolutePath),
+      displayPath: relativePath || path11.basename(absolutePath),
       line: Number(match[2]),
       column: Number(match[3])
     };
@@ -4662,7 +5128,7 @@ function findStackLocation(stack, root) {
 }
 function createSourceFrame(location) {
   try {
-    const sourceLines = fs5.readFileSync(location.absolutePath, "utf8").split(/\r?\n/);
+    const sourceLines = fs7.readFileSync(location.absolutePath, "utf8").split(/\r?\n/);
     if (location.line < 1 || location.line > sourceLines.length) return void 0;
     const start = Math.max(1, location.line - 2);
     const end = Math.min(sourceLines.length, location.line + 2);
@@ -4685,13 +5151,13 @@ function createSourceFrame(location) {
   }
 }
 function sanitizeStack(stack, root) {
-  const normalizedRoot = path9.resolve(root);
+  const normalizedRoot = path11.resolve(root);
   return redactErrorText(stack).split(normalizedRoot).join("<project>").replace(/<project>[^\s)]*/g, (segment) => segment.split("\\").join("/")).split("\n").filter((line, index) => index === 0 || !line.includes("node:internal")).slice(0, 14).join("\n");
 }
 function createDefaultErrorDiagnostics(error, root) {
   const normalizedError = error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown server rendering error");
   const rawStack = normalizedError.stack || `${normalizedError.name}: ${normalizedError.message}`;
-  const location = findStackLocation(rawStack, path9.resolve(root));
+  const location = findStackLocation(rawStack, path11.resolve(root));
   return {
     name: redactErrorText(normalizedError.name || "Error"),
     message: redactErrorText(normalizedError.message || "Unknown server rendering error"),
@@ -4700,6 +5166,13 @@ function createDefaultErrorDiagnostics(error, root) {
   };
 }
 
+// src/islands-client-boot.ts
+function canBootFarmIslandsClient(config) {
+  const docs = config.docs;
+  const docsEnabled = docs === true || typeof docs === "object" && docs !== null && docs.enabled !== false;
+  return resolveFarmServerComponentsMode(config.experimental?.serverComponents) === "islands" && !docsEnabled && resolveFarmClientPlugins(config.plugins, config.root).length === 0 && !resolveFarmAppClientEntry(config.root, config.srcDir || "src");
+}
+
 // src/server/renderer.ts
 var islands;
 function withFarmIslandsRenders(runtime, islandsRuntime) {
@@ -4806,6 +5279,10 @@ function appendResponseHeader(res, name, value) {
     res.setHeader(name, [String(current), value]);
   }
 }
+function requestHeader(req, name) {
+  const value = req.headers?.[name];
+  return Array.isArray(value) ? value[0] : value;
+}
 function appendResponseVary(res, value) {
   const current = res.getHeader("Vary");
   const values = new Set(
@@ -4832,6 +5309,10 @@ function rendererRenderOptions() {
   return nonce ? { nonce } : void 0;
 }
 var FARM_DEV_EARLY_CLIENT_SCRIPT = `<script type="module" async src="/@farm/client.js"></script>`;
+function createFarmDevBootScript(root, strategy) {
+  const rootAttributes = root ? ` data-farm-root="${root}" data-farm-root-strategy="${escapeHtmlAttribute2(strategy ?? "load")}"` : "";
+  return `<script type="module" async src="/@farm/client-boot.js" data-farm-runtime="/@farm/client.js"${rootAttributes}></script>`;
+}
 function createDocumentFooter(options) {
   return `${options.closeRoot === false ? "" : "</div>"}
   ${options.suspenseRevealFallback}
@@ -4945,7 +5426,7 @@ function createRouteStateProps(input) {
 function readAppPackageIdentity(root) {
   try {
     return JSON.parse(
-      fs6.readFileSync(path10.join(root || process.cwd(), "package.json"), "utf8")
+      fs8.readFileSync(path12.join(root || process.cwd(), "package.json"), "utf8")
     );
   } catch {
     return {};
@@ -5057,7 +5538,8 @@ var ServerRenderer = class {
     if (!graph) return [];
     return collectDevStylesheetUrls(
       graph.idToModuleMap.values(),
-      this.devGlobalStylesheetHref() ?? void 0
+      this.devGlobalStylesheetHref() ?? void 0,
+      { cssModules: this.islandValues() }
     );
   }
   collectDevStyleLinks() {
@@ -5065,12 +5547,19 @@ var ServerRenderer = class {
       (href) => `<link rel="stylesheet" href="${escapeHtmlAttribute2(href)}">`
     );
   }
-  createLayoutBoundary(pattern, layoutElement) {
+  /**
+   * A layout's boundary. Islands mode keys it (the pattern with its params, as the production
+   * server does), so a navigation can name the layouts the browser shows; a layout the browser
+   * keeps is sent as its boundary alone (`kept`).
+   */
+  createLayoutBoundary(pattern, layoutElement, segment) {
     return this.rendererRuntime.createElement(
       "div",
       {
         "data-farm-layout-boundary": "true",
         "data-farm-layout-pattern": pattern,
+        ...segment ? { "data-farm-layout-key": segment.key } : {},
+        ...segment?.kept ? { "data-farm-layout-kept": "true" } : {},
         style: { display: "contents" }
       },
       layoutElement
@@ -5244,10 +5733,10 @@ var ServerRenderer = class {
    * Load SSG manifest from build output
    */
   loadSSGManifest() {
-    const manifestPath = path10.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
+    const manifestPath = path12.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
     let content;
     try {
-      content = fs6.readFileSync(manifestPath, "utf-8");
+      content = fs8.readFileSync(manifestPath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
@@ -5466,10 +5955,10 @@ var ServerRenderer = class {
       return true;
     }
     try {
-      const htmlPath = page.urlPath === "/" ? path10.join(this.config.root, this.config.outDir, "client", "index.html") : path10.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
-      if (fs6.existsSync(htmlPath)) {
-        const stat = fs6.statSync(htmlPath);
-        const html = fs6.readFileSync(htmlPath, "utf-8");
+      const htmlPath = page.urlPath === "/" ? path12.join(this.config.root, this.config.outDir, "client", "index.html") : path12.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
+      if (fs8.existsSync(htmlPath)) {
+        const stat = fs8.statSync(htmlPath);
+        const html = fs8.readFileSync(htmlPath, "utf-8");
         await this.cacheSSGPage(page, html, {
           document: true,
           createdAt: stat.mtimeMs
@@ -5719,7 +6208,10 @@ var ServerRenderer = class {
         { experimentalPPR: this.config.experimental?.ppr === true }
       );
       const pprBypassReason = renderingConfig.ppr ? this.getPPRShellBypassReason(req, middlewareMap, middlewareContext, pluginExposedContext) : void 0;
-      const canCachePPRShell = renderingConfig.ppr && !pprBypassReason;
+      const islandsNavigationRequest = Boolean(
+        islands && this.islandValues() && (requestHeader(req, "f-layouts") || requestHeader(req, "f-stream"))
+      );
+      const canCachePPRShell = renderingConfig.ppr && !pprBypassReason && !islandsNavigationRequest;
       const pprI18nSnapshot = canCachePPRShell ? getFarmI18nClientSnapshot() : void 0;
       const pprShellOptions = canCachePPRShell ? {
         pathname,
@@ -5893,9 +6385,19 @@ var ServerRenderer = class {
           (metadata) => metadata.shouldHydrate && metadata.islandStrategy ? [metadata.islandStrategy] : []
         )
       ];
-      const hydrationIslandStrategy = hydrationStrategies.every(
-        (strategy) => strategy === hydrationStrategies[0]
-      ) ? hydrationStrategies[0] ?? "load" : "load";
+      const hydrationIslandStrategy = this.islandValues() ? resolveFarmRouteRootStrategy(
+        route,
+        { shouldHydrate, islandStrategy: moduleMetadata.islandStrategy ?? null },
+        layouts.map((layout, index) => ({
+          pattern: layout.pattern,
+          modulePath: layout.modulePath,
+          shouldHydrate: layoutHydrationMetadata[index]?.shouldHydrate === true,
+          hasIsolatedClientBoundaries: layoutHydrationMetadata[index]?.hasIsolatedClientBoundaries === true,
+          islandStrategy: layoutHydrationMetadata[index]?.islandStrategy ?? null
+        })),
+        this.config.root || process.cwd(),
+        true
+      ) : hydrationStrategies.every((strategy) => strategy === hydrationStrategies[0]) ? hydrationStrategies[0] ?? "load" : "load";
       const hasHydratableRouteSlots = renderedRouteSlots.some(
         (slot) => slot.isClientComponent || slot.shouldHydrate
       );
@@ -5992,11 +6494,22 @@ var ServerRenderer = class {
               layoutShouldHydrate: shouldHydrateLayout,
               islandStrategy: hydrationIslandStrategy
             });
+            const islandsSegments = Boolean(islands && this.islandValues());
+            const keptLayoutCount = islandsSegments && !renderingConfig.ssg && !shouldHydrateLayout && renderedRouteSlots.length === 0 ? countFarmKeptLayouts(requestHeader(req, "f-layouts"), layouts, params) : 0;
+            const keptLayouts = keptLayoutCount > 1 ? keptLayoutCount : 0;
             let wrappedElement = pageElement;
             for (let i = layoutModules.length - 1; i >= 0; i--) {
               const layoutModule = layoutModules[i];
               const layoutEntry = layouts[i];
               const LayoutComponent = layoutModule.default;
+              const segment = islandsSegments && !shouldHydrateLayout ? { key: getFarmLayoutKey(layoutEntry.pattern, params) } : void 0;
+              if (LayoutComponent && i > 0 && i < keptLayouts) {
+                wrappedElement = this.createLayoutBoundary(layoutEntry.pattern, wrappedElement, {
+                  key: segment.key,
+                  kept: true
+                });
+                continue;
+              }
               const slotProps = {};
               for (const slot of renderedRouteSlots) {
                 if ((slot.ownerDirectory ?? slot.ownerPattern) !== layoutEntry.pattern) continue;
@@ -6026,7 +6539,11 @@ var ServerRenderer = class {
                 params,
                 ...slotProps
               });
-              wrappedElement = this.createLayoutBoundary(layoutEntry.pattern, wrappedElement);
+              wrappedElement = this.createLayoutBoundary(
+                layoutEntry.pattern,
+                wrappedElement,
+                segment
+              );
             }
             if (shouldHydrateLayout) {
               wrappedElement = this.wrapClientGraph(wrappedElement);
@@ -6204,11 +6721,11 @@ var ServerRenderer = class {
         if (isFarmIntegrationProviderComponentReference(provider.component)) {
           providerSourceModule = provider.component.module;
           const providerModuleId = provider.component.module.startsWith(".") ? toViteModuleId(
-            path10.resolve(this.config.root, provider.component.module),
+            path12.resolve(this.config.root, provider.component.module),
             this.config.root
           ) : provider.component.module;
           const providerModule = this.viteServer ? await loadFarmDevModule(this.viteServer, providerModuleId) : await importRuntimeModule(
-            provider.component.module.startsWith(".") ? pathToFileURL2(path10.resolve(this.config.root, provider.component.module)).href : provider.component.module
+            provider.component.module.startsWith(".") ? pathToFileURL2(path12.resolve(this.config.root, provider.component.module)).href : provider.component.module
           );
           ProviderComponent = providerModule[provider.component.export || "default"];
         } else if (typeof provider.component === "function") {
@@ -6475,7 +6992,7 @@ var ServerRenderer = class {
               logger.warn(`Could not read metadata for ${pattern} in sitemap.xml: ${error}`);
               return void 0;
             }),
-            fs6.promises.stat(route.modulePath).catch(() => void 0)
+            fs8.promises.stat(route.modulePath).catch(() => void 0)
           ]);
           return { pattern, module, lastModified: stat?.mtime.toISOString() };
         })
@@ -6541,7 +7058,7 @@ var ServerRenderer = class {
     const server = this.getDefaultMCPServer();
     const request2 = getCurrentRequestOrNull() ?? createWebRequestFromFarmRequest(req, { trustProxy: this.config.server?.trustProxy });
     try {
-      const { handleFarmDefaultMCPRequest } = await import("./agent-mcp-handler-7JSKGSOW.mjs");
+      const { handleFarmDefaultMCPRequest } = await import("./agent-mcp-handler-7QMX2LUY.mjs");
       const origin = new URL(request2.url).origin;
       const response = await handleFarmDefaultMCPRequest(request2, {
         server,
@@ -6726,7 +7243,7 @@ var ServerRenderer = class {
       res.end();
       return;
     }
-    res.write(await fs6.promises.readFile(image.modulePath));
+    res.write(await fs8.promises.readFile(image.modulePath));
     res.end();
   }
   async renderRouteErrorBoundary(req, res, options) {
@@ -7048,6 +7565,18 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       for (const [key, value] of Object.entries(options.responseHeaders || {})) {
         res.setHeader(key, value);
       }
+      const islandsMode = Boolean(islands && this.islandValues());
+      const flushToken = islandsMode && requestHeader(req, "f-stream") === "flush" ? createFarmFlushToken() : "";
+      const flushMarker = flushToken ? Buffer.from(farmFlushMarker(flushToken)) : void 0;
+      if (islandsMode) {
+        for (const name of ["F-Values", "F-Layouts", "F-Render", "F-Stream"]) {
+          appendResponseVary(res, name);
+        }
+        if (requestHeader(req, "f-layouts") || flushToken) {
+          res.setHeader("Cache-Control", "private, no-store");
+        }
+        if (flushToken) res.setHeader("F-Flush", flushToken);
+      }
       const htmlParts = [];
       const findStaticShellBoundary = this.rendererRuntime.findStaticShellBoundary;
       const staticShellParts = options.captureStaticShell && findStaticShellBoundary ? [] : void 0;
@@ -7143,7 +7672,11 @@ window.__FARM_MANIFEST__ = ${JSON.stringify(clientManifest)};
 window.__FARM_INTEGRATION_API_MANIFEST__ = ${JSON.stringify(getRegisteredIntegrationAPIManifest())};
 window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getFarmI18nClientSnapshot()) : "null"};
 </script>`;
-      const hydrationClickQueueScript = isClientComponent || req.__FARM_SHOULD_HYDRATE__ === true || req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ === true ? createPreHydrationClickQueueScript() : "";
+      const islandsOnlyPage = this.islandValues() && req.__FARM_PAGE_SHOULD_HYDRATE__ !== true && req.__FARM_LAYOUT_SHOULD_HYDRATE__ !== true && req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ !== true;
+      const rootStrategy = req.__FARM_ISLAND_STRATEGY__;
+      const waitingRoot = this.islandValues() && !islandsOnlyPage && req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ !== true && rootStrategy !== void 0 && rootStrategy !== "load" ? req.__FARM_LAYOUT_SHOULD_HYDRATE__ === true ? "root" : "__farm_page__" : null;
+      const bootClient = (islandsOnlyPage || waitingRoot !== null) && !staticShellParts && canBootFarmIslandsClient(this.config);
+      const hydrationClickQueueScript = !islandsOnlyPage && !bootClient && (isClientComponent || req.__FARM_SHOULD_HYDRATE__ === true || req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ === true) ? createPreHydrationClickQueueScript() : "";
       const {
         title,
         tags: metaTags,
@@ -7174,6 +7707,7 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       const filterDocumentHTML = (html) => cspNonce ? filterFarmCspNonces(html, cspNonce) : html;
       const createLateNavigationRecovery = (navigationError) => this.createLateNavigationRecoveryHTML(req, navigationError);
       const earlyClient = this.islandValues();
+      const earlyClientScript = bootClient ? createFarmDevBootScript(waitingRoot, rootStrategy) : FARM_DEV_EARLY_CLIENT_SCRIPT;
       const { pipe, abort } = renderToPipeableStream(streamRoot, {
         nonce: cspNonce,
         onShellReady() {
@@ -7212,7 +7746,7 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
   ${hydrationClickQueueScript}
 </head>
 <body class="">${earlyClient ? `
-  ${FARM_DEV_EARLY_CLIENT_SCRIPT}` : ""}
+  ${earlyClientScript}` : ""}
   <div id="root">`;
           const securedShell = streamDocument ? "" : stampDocumentHTML(shell);
           if (securedShell) {
@@ -7224,7 +7758,7 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
             html: document.html.replace(
               /<body\b[^>]*>/i,
               (open) => `${open}
-  ${stampDocumentHTML(FARM_DEV_EARLY_CLIENT_SCRIPT)}`
+  ${stampDocumentHTML(earlyClientScript)}`
             )
           } : document;
           const documentTransform = streamDocument ? createFarmStreamedDocumentTransform(
@@ -7297,6 +7831,14 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
           };
           const writableStream = new Writable({
             write(chunk, encoding, callback) {
+              if (flushMarker && chunk === flushMarker) {
+                const marker = documentTransform ? documentTransform.write(flushMarker.toString()) : flushMarker;
+                res.write(marker, () => {
+                  if (typeof res.flush === "function") res.flush();
+                  callback();
+                });
+                return;
+              }
               if (firstChunk && process.env.FARM_VERBOSE) {
                 console.log(`[FARM STREAM] first pipe chunk at ${Date.now() - streamStartTime}ms`);
                 firstChunk = false;
@@ -7392,6 +7934,7 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
           if (typeof res.flush === "function") {
             res.flush();
           }
+          if (flushMarker) writableStream.flush = () => writableStream.write(flushMarker);
           pipe(writableStream);
         },
         onShellError(error) {
@@ -7521,13 +8064,13 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       res.end(createFarmMarkdownErrorBody(404, pathname, this.config.basePath || "/"));
       return;
     }
-    const appDir = path10.join(this.config.root, this.config.srcDir, "app");
+    const appDir = path12.join(this.config.root, this.config.srcDir, "app");
     const notFoundExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     let layoutModule = null;
     try {
       for (const ext of notFoundExtensions) {
-        const layoutPath = path10.join(appDir, `layout${ext}`);
-        if (fs6.existsSync(layoutPath)) {
+        const layoutPath = path12.join(appDir, `layout${ext}`);
+        if (fs8.existsSync(layoutPath)) {
           layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
           break;
         }
@@ -7740,7 +8283,7 @@ ${clientScript}
 };
 
 // src/app.ts
-import path11 from "path";
+import path13 from "path";
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -7880,7 +8423,7 @@ var FarmApp = class {
     }
     const componentExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     const rootLayoutPaths = appDirs.flatMap(
-      (appDir) => componentExtensions.map((extension) => path11.join(appDir, `layout${extension}`))
+      (appDir) => componentExtensions.map((extension) => path13.join(appDir, `layout${extension}`))
     );
     const hasRootLayout = await Promise.all(rootLayoutPaths.map((p) => fileExists(p))).then(
       (results) => results.some(Boolean)
@@ -7944,13 +8487,13 @@ function resolveFarmImageServerRuntime(images, preset) {
 }
 
 // src/app-manifest-packages.ts
-import fs7 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path14 from "path";
 var FARM_PACKAGE = /^@(?:farm\.js|farming-labs)\/[a-z0-9._-]+$/;
 function resolveFarmAppPackages(root) {
   let manifest;
   try {
-    manifest = JSON.parse(fs7.readFileSync(path12.join(root, "package.json"), "utf8"));
+    manifest = JSON.parse(fs9.readFileSync(path14.join(root, "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -7965,13 +8508,13 @@ function resolveFarmAppPackages(root) {
     for (let dir = root; ; ) {
       try {
         const { version } = JSON.parse(
-          fs7.readFileSync(path12.join(dir, "node_modules", name, "package.json"), "utf8")
+          fs9.readFileSync(path14.join(dir, "node_modules", name, "package.json"), "utf8")
         );
         if (typeof version === "string" && /^[0-9A-Za-z.+-]{1,64}$/.test(version))
           versions[name] = version;
         break;
       } catch {
-        const parent = path12.dirname(dir);
+        const parent = path14.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -7981,9 +8524,9 @@ function resolveFarmAppPackages(root) {
 }
 
 // src/app-manifest-webmcp.ts
-import fs8 from "fs";
+import fs10 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path13 from "path";
+import path15 from "path";
 import { globSync } from "tinyglobby";
 var WEBMCP_CLIENT = "@farm.js/webmcp/client";
 var DEFINERS = /* @__PURE__ */ new Set(["defineWebMCPTool", "registerWebMCPTool", "registerWebMCPTools"]);
@@ -8001,7 +8544,7 @@ var LANGS = {
   cjs: "jsx",
   jsx: "jsx"
 };
-var parseAst;
+var parseAst2;
 function staticValue(node) {
   if (!node) return NOT_STATIC;
   switch (node.type) {
@@ -8034,406 +8577,140 @@ function staticValue(node) {
         object[key] = value;
       }
       return object;
-    }
-    case "TSAsExpression":
-    case "TSSatisfiesExpression":
-    case "TSNonNullExpression":
-    case "ParenthesizedExpression":
-      return staticValue(node.expression);
-    default:
-      return NOT_STATIC;
-  }
-}
-function property(object, name) {
-  return object.properties.find(
-    (entry) => entry.type === "Property" && !entry.computed && (entry.key.name === name || entry.key.value === name)
-  )?.value;
-}
-function toolFromObject(object) {
-  const name = staticValue(property(object, "name"));
-  if (typeof name !== "string" || !/^[A-Za-z0-9_.-]{1,128}$/.test(name)) return null;
-  const text = (key) => {
-    const value = staticValue(property(object, key));
-    return typeof value === "string" && value.length <= 2e3 ? value : void 0;
-  };
-  const annotations = staticValue(property(object, "annotations"));
-  const hints = annotations && typeof annotations === "object" && !Array.isArray(annotations) ? Object.fromEntries(
-    HINTS.filter(
-      (hint) => typeof annotations[hint] === "boolean"
-    ).map((hint) => [hint, annotations[hint]])
-  ) : {};
-  const schemaNode = property(object, "inputSchema");
-  const schema = staticValue(schemaNode);
-  const literal = schema !== NOT_STATIC && schema !== null && typeof schema === "object" && !Array.isArray(schema) && Buffer.byteLength(JSON.stringify(schema)) <= MAX_SCHEMA_BYTES;
-  const title = text("title");
-  const description = text("description");
-  return {
-    name,
-    ...title ? { title } : {},
-    ...description ? { description } : {},
-    ...hints,
-    ...literal ? { inputSchema: schema } : {},
-    inputSchemaSource: literal ? "literal" : schemaNode ? "computed" : "none"
-  };
-}
-function findFarmWebMCPTools(code, filename = "module.tsx") {
-  if (!code.includes(WEBMCP_CLIENT)) return [];
-  const lang = LANGS[path13.extname(filename).slice(1)] ?? "tsx";
-  parseAst ?? (parseAst = createRequire2(typeof __filename === "string" ? __filename : import.meta.url)(
-    "rolldown/parseAst"
-  ).parseAst);
-  let program;
-  try {
-    program = parseAst(code, { lang });
-  } catch {
-    return [];
-  }
-  const locals = /* @__PURE__ */ new Map();
-  for (const statement of program.body) {
-    if (statement.type !== "ImportDeclaration" || statement.source.value !== WEBMCP_CLIENT)
-      continue;
-    for (const specifier of statement.specifiers) {
-      const imported = specifier.imported?.name ?? specifier.imported?.value;
-      if (specifier.type === "ImportSpecifier" && DEFINERS.has(imported))
-        locals.set(specifier.local.name, imported);
-    }
-  }
-  if (!locals.size) return [];
-  const found = [];
-  const visit = (node) => {
-    if (!node || typeof node !== "object") return;
-    if (Array.isArray(node)) return node.forEach(visit);
-    const current = node;
-    if (current.type === "CallExpression" && current.callee.type === "Identifier") {
-      const definer = locals.get(current.callee.name);
-      const [argument] = current.arguments;
-      if (definer && argument) {
-        const objects = definer === "registerWebMCPTools" ? argument.type === "ArrayExpression" ? argument.elements.filter(
-          (element) => element?.type === "ObjectExpression"
-        ) : [] : argument.type === "ObjectExpression" ? [argument] : [];
-        for (const object of objects) {
-          const tool = toolFromObject(object);
-          if (tool) found.push({ start: object.start, tool });
-        }
-      }
-    }
-    for (const [key, value] of Object.entries(current))
-      if (key !== "type" && value && typeof value === "object") visit(value);
-  };
-  visit(program.body);
-  return found.sort((a, b) => a.start - b.start).map(({ tool }) => tool);
-}
-var cache = /* @__PURE__ */ new Map();
-function collectFarmWebMCPTools(root, srcDir = "src") {
-  const base = path13.resolve(root, srcDir);
-  let files;
-  try {
-    files = globSync("**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", {
-      cwd: base,
-      absolute: true,
-      expandDirectories: false,
-      ignore: ["**/node_modules/**", "**/*.d.ts", "**/*.{test,spec}.*", "**/__tests__/**"]
-    });
-  } catch {
-    return [];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const tools = [];
-  for (const file of files.sort()) {
-    let mtimeMs;
-    try {
-      mtimeMs = fs8.statSync(file).mtimeMs;
-    } catch {
-      continue;
-    }
-    let entry = cache.get(file);
-    if (!entry || entry.mtimeMs !== mtimeMs) {
-      let code = "";
-      try {
-        code = fs8.readFileSync(file, "utf8");
-      } catch {
-      }
-      entry = { mtimeMs, tools: findFarmWebMCPTools(code, file) };
-      cache.set(file, entry);
-    }
-    for (const tool of entry.tools) {
-      if (seen.has(tool.name) || tools.length >= MAX_TOOLS) continue;
-      seen.add(tool.name);
-      tools.push(tool);
-    }
-  }
-  return tools;
-}
-
-// src/client-plugin-build.ts
-import fs9 from "fs";
-import path14 from "path";
-var CLIENT_KEYS = [
-  "public",
-  "setup",
-  "hydration",
-  "navigation",
-  "error",
-  "performance",
-  "close"
-];
-var HYDRATION_KEYS = ["before", "after"];
-var NAVIGATION_KEYS = ["before", "loaded", "resolved", "rendered", "error"];
-var MOBILE_SHELL_CLIENT_IMPORT = 'import { farmMobileShellClient as __farmMobileShellClient } from "@farm.js/core/internal/client-runtime";';
-var MOBILE_SHELL_CLIENT_REGISTRATION = `  {
-    name: "farm:mobile-shell",
-    enforce: "pre",
-    definition: __farmMobileShellClient,
-  }`;
-var APP_CLIENT_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
-function resolveFarmAppClientEntry(root = process.cwd(), srcDir = "src") {
-  const sourceRoot = path14.resolve(root, srcDir);
-  for (const extension of APP_CLIENT_EXTENSIONS) {
-    const candidate = path14.join(sourceRoot, `client.${extension}`);
-    if (fs9.existsSync(candidate) && fs9.statSync(candidate).isFile()) return candidate;
-  }
-  return void 0;
-}
-function resolveFarmClientPlugins(plugins, _root) {
-  if (!plugins?.length) return [];
-  return plugins.flatMap((plugin) => {
-    if (!plugin.client) return [];
-    assertClientLifecycle(plugin.client, plugin.name);
-    assertPublicData(plugin.client.public, plugin.name);
-    return [
-      {
-        name: plugin.name,
-        version: plugin.version,
-        enforce: plugin.enforce,
-        definition: plugin.client,
-        publicData: plugin.client.public
-      }
-    ];
-  });
-}
-function generateFarmClientPluginEntryCode(plugins, root, srcDir = "src", appPublicData, platform = resolveFarmPlatform()) {
-  const resolved = resolveFarmClientPlugins(plugins, root);
-  const appClientEntry = root ? resolveFarmAppClientEntry(root, srcDir) : void 0;
-  const appImport = appClientEntry ? `import farmAppClientDefinition from ${JSON.stringify(appClientEntry.replace(/\\/g, "/"))};` : "";
-  const mobileShell = platform === "mobile";
-  const imports = mobileShell ? [MOBILE_SHELL_CLIENT_IMPORT, appImport].filter(Boolean).join("\n") : appImport;
-  const serializedPlugins = mobileShell ? [MOBILE_SHELL_CLIENT_REGISTRATION] : [];
-  serializedPlugins.push(
-    ...resolved.map(
-      (plugin) => `  {
-    name: ${JSON.stringify(plugin.name)},
-    version: ${serializeOptionalString(plugin.version)},
-    enforce: ${serializeOptionalString(plugin.enforce)},
-    definition: ${serializeClientLifecycle(plugin.definition, plugin.name)},
-    public: ${serializePublicData(plugin.publicData)},
-  }`
-    )
-  );
-  if (appClientEntry) {
-    assertPublicData(appPublicData, "farm:app-client");
-    serializedPlugins.push(`  {
-    name: "farm:app-client",
-    enforce: "post",
-    definition: farmAppClientDefinition,
-    public: ${serializePublicData(appPublicData)},
-  }`);
-  }
-  const registrations = `[
-${serializedPlugins.join(",\n")}
-]`;
-  return { imports, registrations, plugins: resolved };
-}
-function assertClientLifecycle(client, pluginName) {
-  assertLifecycleObject(client, pluginName, "client", CLIENT_KEYS);
-  assertHook(client.setup, pluginName, "client.setup");
-  assertHook(client.error, pluginName, "client.error");
-  assertHook(client.performance, pluginName, "client.performance");
-  assertHook(client.close, pluginName, "client.close");
-  if (client.hydration !== void 0) {
-    assertLifecycleObject(client.hydration, pluginName, "client.hydration", HYDRATION_KEYS);
-    assertHook(client.hydration.before, pluginName, "client.hydration.before");
-    assertHook(client.hydration.after, pluginName, "client.hydration.after");
-  }
-  if (client.navigation !== void 0) {
-    assertLifecycleObject(client.navigation, pluginName, "client.navigation", NAVIGATION_KEYS);
-    for (const key of NAVIGATION_KEYS) {
-      assertHook(client.navigation[key], pluginName, `client.navigation.${key}`);
-    }
-  }
-}
-function assertLifecycleObject(value, pluginName, location, allowedKeys) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError(`Client plugin "${pluginName}" ${location} must be an object`);
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw new TypeError(`Client plugin "${pluginName}" ${location} must be a plain object`);
-  }
-  for (const key of Reflect.ownKeys(value)) {
-    if (typeof key === "symbol") {
-      throw new TypeError(`Client plugin "${pluginName}" ${location} cannot contain symbol keys`);
-    }
-    if (!allowedKeys.includes(key)) {
-      throw new TypeError(`Client plugin "${pluginName}" has an unknown ${location}.${key} option`);
-    }
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (!descriptor?.enumerable) {
-      throw new TypeError(`Client plugin "${pluginName}" ${location}.${key} must be enumerable`);
-    }
-    if (!("value" in descriptor)) {
-      throw new TypeError(`Client plugin "${pluginName}" ${location}.${key} cannot be an accessor`);
-    }
-  }
-}
-function assertHook(value, pluginName, location) {
-  if (value === void 0) return;
-  if (typeof value !== "function") {
-    throw new TypeError(`Client plugin "${pluginName}" ${location} must be a function`);
+    }
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+    case "ParenthesizedExpression":
+      return staticValue(node.expression);
+    default:
+      return NOT_STATIC;
   }
-  functionSource(value, pluginName, location);
-}
-function serializeClientLifecycle(definition, pluginName) {
-  const fields = [];
-  pushHook(fields, "setup", definition.setup, pluginName, "client.setup", 2);
-  pushHookGroup(fields, "hydration", definition.hydration, HYDRATION_KEYS, pluginName, 2);
-  pushHookGroup(fields, "navigation", definition.navigation, NAVIGATION_KEYS, pluginName, 2);
-  pushHook(fields, "error", definition.error, pluginName, "client.error", 2);
-  pushHook(fields, "performance", definition.performance, pluginName, "client.performance", 2);
-  pushHook(fields, "close", definition.close, pluginName, "client.close", 2);
-  return fields.length ? `{
-${fields.join(",\n")}
-  }` : "{}";
 }
-function pushHookGroup(fields, groupName, group, keys, pluginName, indent) {
-  if (!group) return;
-  const hooks = [];
-  for (const key of keys) {
-    pushHook(hooks, key, group[key], pluginName, `client.${groupName}.${key}`, indent + 2);
-  }
-  fields.push(
-    `${" ".repeat(indent)}${JSON.stringify(groupName)}: {
-${hooks.join(",\n")}
-${" ".repeat(indent)}}`
-  );
+function property(object, name) {
+  return object.properties.find(
+    (entry) => entry.type === "Property" && !entry.computed && (entry.key.name === name || entry.key.value === name)
+  )?.value;
 }
-function pushHook(fields, key, hook, pluginName, location, indent) {
-  if (hook === void 0) return;
-  fields.push(
-    `${" ".repeat(indent)}${JSON.stringify(key)}: ${functionSource(hook, pluginName, location)}`
-  );
+function toolFromObject(object) {
+  const name = staticValue(property(object, "name"));
+  if (typeof name !== "string" || !/^[A-Za-z0-9_.-]{1,128}$/.test(name)) return null;
+  const text = (key) => {
+    const value = staticValue(property(object, key));
+    return typeof value === "string" && value.length <= 2e3 ? value : void 0;
+  };
+  const annotations = staticValue(property(object, "annotations"));
+  const hints = annotations && typeof annotations === "object" && !Array.isArray(annotations) ? Object.fromEntries(
+    HINTS.filter(
+      (hint) => typeof annotations[hint] === "boolean"
+    ).map((hint) => [hint, annotations[hint]])
+  ) : {};
+  const schemaNode = property(object, "inputSchema");
+  const schema = staticValue(schemaNode);
+  const literal = schema !== NOT_STATIC && schema !== null && typeof schema === "object" && !Array.isArray(schema) && Buffer.byteLength(JSON.stringify(schema)) <= MAX_SCHEMA_BYTES;
+  const title = text("title");
+  const description = text("description");
+  return {
+    name,
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ...hints,
+    ...literal ? { inputSchema: schema } : {},
+    inputSchemaSource: literal ? "literal" : schemaNode ? "computed" : "none"
+  };
 }
-function functionSource(value, pluginName, location) {
-  if (typeof value !== "function") {
-    throw new TypeError(`Client plugin "${pluginName}" ${location} must be a function`);
-  }
-  const source = Function.prototype.toString.call(value).trim();
-  if (!source || source.includes("[native code]")) {
-    throw new TypeError(
-      `Client plugin "${pluginName}" ${location} must be authored inline and cannot be native or bound`
-    );
-  }
-  if (/^(?:async\s+)?function(?:\s*\*)?(?:\s+|\()/.test(source)) {
-    return `(${source})`;
-  }
-  const method = source.match(/^(async\s+)?(\*\s*)?[$A-Z_a-z][$\w]*\s*(\([\s\S]*)$/);
-  if (method) {
-    const asyncPrefix = method[1] ?? "";
-    const generator = method[2] ? "*" : "";
-    return `(${asyncPrefix}function${generator}${method[3]})`;
+function findFarmWebMCPTools(code, filename = "module.tsx") {
+  if (!code.includes(WEBMCP_CLIENT)) return [];
+  const lang = LANGS[path15.extname(filename).slice(1)] ?? "tsx";
+  parseAst2 ?? (parseAst2 = createRequire2(typeof __filename === "string" ? __filename : import.meta.url)(
+    "rolldown/parseAst"
+  ).parseAst);
+  let program;
+  try {
+    program = parseAst2(code, { lang });
+  } catch {
+    return [];
   }
-  if (source.includes("=>")) return `(${source})`;
-  throw new TypeError(
-    `Client plugin "${pluginName}" ${location} must use a function, method, or arrow function`
-  );
-}
-function assertPublicData(value, pluginName) {
-  if (value === void 0) return;
-  const seen = /* @__PURE__ */ new WeakSet();
-  const visit = (current, pathSegments) => {
-    if (current === null || typeof current === "string" || typeof current === "boolean") {
-      return;
-    }
-    if (typeof current === "number") {
-      if (Number.isFinite(current)) return;
-      throwPublicDataError(pluginName, pathSegments, "must be a finite number");
-    }
-    if (typeof current !== "object") {
-      throwPublicDataError(pluginName, pathSegments, `cannot contain ${typeof current} values`);
-    }
-    if (seen.has(current)) {
-      throwPublicDataError(pluginName, pathSegments, "cannot contain circular references");
+  const locals = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== WEBMCP_CLIENT)
+      continue;
+    for (const specifier of statement.specifiers) {
+      const imported = specifier.imported?.name ?? specifier.imported?.value;
+      if (specifier.type === "ImportSpecifier" && DEFINERS.has(imported))
+        locals.set(specifier.local.name, imported);
     }
-    seen.add(current);
-    if (Array.isArray(current)) {
-      for (let index = 0; index < current.length; index += 1) {
-        if (!Object.prototype.hasOwnProperty.call(current, index)) {
-          throwPublicDataError(
-            pluginName,
-            [...pathSegments, String(index)],
-            "cannot contain sparse array slots"
-          );
+  }
+  if (!locals.size) return [];
+  const found = [];
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) return node.forEach(visit);
+    const current = node;
+    if (current.type === "CallExpression" && current.callee.type === "Identifier") {
+      const definer = locals.get(current.callee.name);
+      const [argument] = current.arguments;
+      if (definer && argument) {
+        const objects = definer === "registerWebMCPTools" ? argument.type === "ArrayExpression" ? argument.elements.filter(
+          (element) => element?.type === "ObjectExpression"
+        ) : [] : argument.type === "ObjectExpression" ? [argument] : [];
+        for (const object of objects) {
+          const tool = toolFromObject(object);
+          if (tool) found.push({ start: object.start, tool });
         }
-        visit(current[index], [...pathSegments, String(index)]);
-      }
-      for (const key of Reflect.ownKeys(current)) {
-        if (key === "length" || typeof key === "string" && isArrayIndex(key)) continue;
-        throwPublicDataError(
-          pluginName,
-          pathSegments,
-          typeof key === "symbol" ? "cannot contain symbol keys" : `cannot contain non-index array property ${key}`
-        );
       }
-      seen.delete(current);
-      return;
     }
-    const prototype = Object.getPrototypeOf(current);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throwPublicDataError(pluginName, pathSegments, "must contain only plain objects and arrays");
+    for (const [key, value] of Object.entries(current))
+      if (key !== "type" && value && typeof value === "object") visit(value);
+  };
+  visit(program.body);
+  return found.sort((a, b) => a.start - b.start).map(({ tool }) => tool);
+}
+var cache = /* @__PURE__ */ new Map();
+function collectFarmWebMCPTools(root, srcDir = "src") {
+  const base = path15.resolve(root, srcDir);
+  let files;
+  try {
+    files = globSync("**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", {
+      cwd: base,
+      absolute: true,
+      expandDirectories: false,
+      ignore: ["**/node_modules/**", "**/*.d.ts", "**/*.{test,spec}.*", "**/__tests__/**"]
+    });
+  } catch {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  for (const file of files.sort()) {
+    let mtimeMs;
+    try {
+      mtimeMs = fs10.statSync(file).mtimeMs;
+    } catch {
+      continue;
     }
-    for (const key of Reflect.ownKeys(current)) {
-      if (typeof key === "symbol") {
-        throwPublicDataError(pluginName, pathSegments, "cannot contain symbol keys");
-      }
-      const descriptor = Object.getOwnPropertyDescriptor(current, key);
-      if (!descriptor?.enumerable) {
-        throwPublicDataError(
-          pluginName,
-          [...pathSegments, key],
-          "cannot contain non-enumerable properties"
-        );
-      }
-      if (!("value" in descriptor)) {
-        throwPublicDataError(
-          pluginName,
-          [...pathSegments, key],
-          "cannot contain accessor properties"
-        );
+    let entry = cache.get(file);
+    if (!entry || entry.mtimeMs !== mtimeMs) {
+      let code = "";
+      try {
+        code = fs10.readFileSync(file, "utf8");
+      } catch {
       }
-      visit(descriptor.value, [...pathSegments, key]);
+      entry = { mtimeMs, tools: findFarmWebMCPTools(code, file) };
+      cache.set(file, entry);
     }
-    seen.delete(current);
-  };
-  visit(value, []);
-}
-function throwPublicDataError(pluginName, pathSegments, message) {
-  const location = pathSegments.length ? ` at client.public.${pathSegments.join(".")}` : "";
-  throw new TypeError(`Client plugin "${pluginName}"${location} ${message}`);
-}
-function serializePublicData(value) {
-  if (value === void 0) return "undefined";
-  return `JSON.parse(${JSON.stringify(JSON.stringify(value))})`;
-}
-function serializeOptionalString(value) {
-  return value === void 0 ? "undefined" : JSON.stringify(value);
-}
-function isArrayIndex(key) {
-  const value = Number(key);
-  return Number.isInteger(value) && value >= 0 && value < 4294967295 && String(value) === key;
+    for (const tool of entry.tools) {
+      if (seen.has(tool.name) || tools.length >= MAX_TOOLS) continue;
+      seen.add(tool.name);
+      tools.push(tool);
+    }
+  }
+  return tools;
 }
 
 // src/client-cache-persistence-build.ts
-import fs10 from "fs";
-import path15 from "path";
+import fs11 from "fs";
+import path16 from "path";
 var ADAPTER_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
 function resolveFarmClientCacheAdapterEntry(root, cache2) {
   const client = cache2?.client;
@@ -8444,7 +8721,7 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
       'cache.client.adapter must be a module path string, for example "./src/cache-adapter".'
     );
   }
-  const resolved = path15.resolve(root, adapter);
+  const resolved = path16.resolve(root, adapter);
   const found = resolveAdapterFile(resolved);
   if (!found) {
     throw new Error(
@@ -8457,10 +8734,10 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
   return { importPath: found.replace(/\\/g, "/"), options };
 }
 function resolveAdapterFile(resolved) {
-  if (fs10.existsSync(resolved) && fs10.statSync(resolved).isFile()) return resolved;
+  if (fs11.existsSync(resolved) && fs11.statSync(resolved).isFile()) return resolved;
   for (const extension of ADAPTER_EXTENSIONS) {
     const candidate = `${resolved}.${extension}`;
-    if (fs10.existsSync(candidate) && fs10.statSync(candidate).isFile()) return candidate;
+    if (fs11.existsSync(candidate) && fs11.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -8623,11 +8900,55 @@ async function buildFarmTreeLayouts(layouts, params, source, options) {
 }
 `;
 
+// src/client/navigation-stream-client.ts
+var FARM_NAVIGATION_STREAM_READER_SOURCE = `// Reads a streamed navigation (F-Stream) up to the end of React's shell. \`next\` then resolves
+// with each later flush as it ends, and null at the end; a document without a marker is all shell.
+// The marker carries the random token the server sent in the F-Flush header, so page content
+// cannot forge a boundary; a response without a valid token is all shell.
+async function readFarmNavigationStream(body, flushToken) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const marker = typeof flushToken === "string" && /^[0-9a-f]{32}$/.test(flushToken)
+    ? "<!--farm-flush:" + flushToken + "-->"
+    : "";
+  let text = "";
+  let done = false;
+  const next = async function() {
+    for (;;) {
+      const at = marker ? text.indexOf(marker) : -1;
+      if (at !== -1) {
+        const flush = text.slice(0, at);
+        text = text.slice(at + marker.length);
+        return flush;
+      }
+      if (done) {
+        const flush = text;
+        text = "";
+        return flush ? flush : null;
+      }
+      const result = await reader.read();
+      if (result.done) {
+        done = true;
+        text += decoder.decode();
+      } else {
+        text += decoder.decode(result.value, { stream: true });
+      }
+    }
+  };
+  const shell = await next();
+  if (done && !text) return { shell: shell || "" };
+  return {
+    shell: shell,
+    next: next,
+    cancel: function() { reader.cancel().catch(function() {}); },
+  };
+}`;
+
 // src/docs/client-config.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path16 from "path";
-var parseAst2;
+import path17 from "path";
+var parseAst3;
 function propertyKeyName(property2) {
   if (property2.computed) return void 0;
   const key = property2.key;
@@ -8636,11 +8957,11 @@ function propertyKeyName(property2) {
   return void 0;
 }
 function redactFarmDocsClientConfig(code, filename) {
-  parseAst2 ?? (parseAst2 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
+  parseAst3 ?? (parseAst3 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
-  const extension = path16.extname(filename);
-  const program = parseAst2(code, {
+  const extension = path17.extname(filename);
+  const program = parseAst3(code, {
     lang: extension === ".tsx" || extension === ".jsx" ? "tsx" : "ts"
   });
   const edits = [];
@@ -8701,7 +9022,7 @@ function farmDocsClientConfigPlugin(configModule) {
 }
 
 // src/server/vite-config.ts
-import path17 from "path";
+import path18 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",
@@ -8728,9 +9049,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
   );
 }
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = path17.resolve(projectRoot);
+  const resolvedProjectRoot = path18.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = path17.relative(resolvedProjectRoot, path17.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = path18.relative(resolvedProjectRoot, path18.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -8752,7 +9073,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 }
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": path17.resolve(projectRoot, srcDir)
+    "@": path18.resolve(projectRoot, srcDir)
   };
 }
 function mergeNoExternal(farmValue, userValue) {
@@ -8909,6 +9230,7 @@ export {
   hasUseClientDirective,
   getIslandStrategyExport,
   stripUseClientDirective,
+  collectFarmServerStylesheets,
   getClientModuleMetadata,
   getClientModuleHydrationPlan,
   usesFarmServerTree,
@@ -8923,6 +9245,10 @@ export {
   DEFAULT_NOT_FOUND_STYLES,
   generateFarmIntegrationProviderClientCode,
   generateFarmIntegrationProviderServerModules,
+  inferFarmIslandStrategy,
+  resolveFarmRouteRootStrategy,
+  generateFarmClientPluginEntryCode,
+  canBootFarmIslandsClient,
   ServerRenderer,
   FarmApp,
   createFarmApp,
@@ -8931,11 +9257,11 @@ export {
   resolveFarmImageServerRuntime,
   resolveFarmAppPackages,
   collectFarmWebMCPTools,
-  generateFarmClientPluginEntryCode,
   resolveFarmClientCacheAdapterEntry,
   generateClientCachePersistenceCode,
   FARM_LAYOUT_ELEMENT_CLIENT_SOURCE,
   FARM_SERVER_TREE_LAYOUT_CLIENT_SOURCE,
+  FARM_NAVIGATION_STREAM_READER_SOURCE,
   redactFarmDocsClientConfig,
   isFarmDocsClientConfigModule,
   farmDocsClientConfigPlugin,