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

package/dist/{chunk-PMKUU273.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-7UPCJDB5.mjs";
+} from "./chunk-PCXIJKPM.mjs";
+import {
+  handleFarmFormActionRequest
+} from "./chunk-Z5A6CNV2.mjs";
 import {
   listFarmMCPLlmsTxtLinks
-} from "./chunk-E73PGHSR.mjs";
+} from "./chunk-ZMHAFH4R.mjs";
 import {
   FARM_DEFAULT_MCP_PATH,
   collectFarmDefaultMCPPages,
@@ -41,7 +46,7 @@ import {
   farmConfigMountsMCP,
   isFarmDefaultMCPPathname,
   resolveFarmDefaultMCPServer
-} from "./chunk-KRRZJ77U.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-YVJV7Q2X.mjs";
-import {
-  isFarmMarkdownPageFile
-} from "./chunk-GW4YUIHW.mjs";
-import {
-  _setDefaultFarmThemeConfig,
-  getTheme
-} from "./chunk-EMDGXYUD.mjs";
 import {
   isSecretDocsConfigKey
 } from "./chunk-EJCVG25Z.mjs";
@@ -105,14 +96,7 @@ import {
   resolveFarmAgentCrawlers,
   resolveFarmAgentSitemap,
   resolveFarmPerformanceConfig
-} from "./chunk-KBRZAYI7.mjs";
-import {
-  collectFarmLlmsTxtPages,
-  createFarmDefaultLlmsTxt,
-  createFarmLlmsMarkdownReader,
-  renderFarmLlmsFullTxt,
-  resolveFarmLlmsTxtConfig
-} from "./chunk-LAZK6UV7.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-N77JBPLC.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-6CYQQQGR.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
@@ -326,15 +328,240 @@ import {
 } from "./chunk-AYP2YFVN.mjs";
 
 // src/utils/client-component.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/package-client-boundary-cache.ts
+import { AsyncLocalStorage } from "async_hooks";
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
+var SCHEMA_VERSION = 1;
+var NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;
+var PackageInspectionTrace = class {
+  constructor() {
+    this.files = /* @__PURE__ */ new Set();
+    this.stops = /* @__PURE__ */ new Set();
+    this.fileStamps = [];
+    this.directoryStamps = /* @__PURE__ */ new Map();
+  }
+  visit(file) {
+    this.files.add(file);
+    const directory = path.dirname(file);
+    if (!this.directoryStamps.has(directory)) {
+      this.directoryStamps.set(directory, stampPackagePath(directory, "directory"));
+    }
+    this.fileStamps.push(stampPackagePath(file, "file"));
+  }
+  /** The inspection reached `file` after it was already visited. */
+  stop(file) {
+    if (!this.files.has(file)) this.stops.add(file);
+  }
+  toEntry(result) {
+    const entry = {
+      result: { ...result },
+      files: Array.from(this.files),
+      stops: Array.from(this.stops)
+    };
+    const files = this.fileStamps.filter((stamp) => stamp !== void 0);
+    const directories = Array.from(this.directoryStamps.values()).filter(
+      (stamp) => stamp !== void 0
+    );
+    if (files.length === this.fileStamps.length && directories.length === this.directoryStamps.size) {
+      entry.stamps = { files, directories };
+    }
+    return entry;
+  }
+};
+function stampPackagePath(target, kind) {
+  if (!`${target}${path.sep}`.includes(NODE_MODULES_SEGMENT)) return void 0;
+  try {
+    const stat = fs.statSync(target, { throwIfNoEntry: false });
+    if (!stat || (kind === "file" ? !stat.isFile() : !stat.isDirectory())) return void 0;
+    return [target, stat.size, stat.mtimeMs, stat.ctimeMs];
+  } catch {
+    return void 0;
+  }
+}
+var PackageClientBoundaryCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.stored = /* @__PURE__ */ new Map();
+    this.storedPaths = [];
+    this.unchangedPaths = /* @__PURE__ */ new Map();
+    this.dirty = false;
+  }
+  load(file) {
+    this.file = file;
+    const stored = readStoredCache(file);
+    if (!stored) {
+      this.dirty = true;
+      return;
+    }
+    this.storedPaths = stored.paths;
+    this.stored = new Map(Object.entries(stored.entries));
+  }
+  /** An inspection of `key` that applies to `visited`. */
+  find(key, visited) {
+    let entries = this.entries.get(key);
+    const stored = this.stored.get(key);
+    if (stored) {
+      this.stored.delete(key);
+      entries ?? (entries = []);
+      this.entries.set(key, entries);
+      for (const entry of stored) {
+        const restored = this.restore(entry);
+        if (restored) entries.push(restored);
+        else this.dirty = true;
+      }
+    }
+    return entries?.find(
+      (entry) => entry.stops.every((file) => visited.has(file)) && !entry.files.some((file) => visited.has(file))
+    );
+  }
+  add(key, entry) {
+    const entries = this.entries.get(key);
+    if (entries) entries.push(entry);
+    else this.entries.set(key, [entry]);
+    if (entry.stamps) this.dirty = true;
+  }
+  async persist() {
+    const file = this.file;
+    if (!file || !this.dirty && this.stored.size === 0) return;
+    const paths = [];
+    const pathIndexes = /* @__PURE__ */ new Map();
+    const indexOf = (stamp) => {
+      let index = pathIndexes.get(stamp[0]);
+      if (index === void 0) {
+        index = paths.push(stamp) - 1;
+        pathIndexes.set(stamp[0], index);
+      }
+      return index;
+    };
+    const entries = {};
+    for (const [key, variants] of this.entries) {
+      const persisted = variants.flatMap(
+        ({ result, stops, stamps }) => stamps ? [
+          {
+            result,
+            files: stamps.files.map(indexOf),
+            directories: stamps.directories.map(indexOf),
+            stops
+          }
+        ] : []
+      );
+      if (persisted.length > 0) entries[key] = persisted;
+    }
+    const contents = JSON.stringify({
+      schema: SCHEMA_VERSION,
+      farm: FARM_VERSION,
+      paths,
+      entries
+    });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await fs.promises.mkdir(path.dirname(file), { recursive: true });
+      await fs.promises.writeFile(temporary, contents);
+      await fs.promises.rename(temporary, file);
+    } catch {
+      await fs.promises.rm(temporary, { force: true }).catch(() => {
+      });
+    }
+  }
+  restore(entry) {
+    const files = this.restoreStamps(entry.files, "file");
+    const directories = this.restoreStamps(entry.directories, "directory");
+    if (!files || !directories) return void 0;
+    return {
+      result: entry.result,
+      files: files.map(([file]) => file),
+      stops: entry.stops,
+      stamps: { files, directories }
+    };
+  }
+  restoreStamps(indexes, kind) {
+    const stamps = [];
+    for (const index of indexes) {
+      const stamp = this.storedPaths[index];
+      let unchanged = this.unchangedPaths.get(index);
+      if (unchanged === void 0) {
+        const current = stampPackagePath(stamp[0], kind);
+        unchanged = current !== void 0 && current[1] === stamp[1] && current[2] === stamp[2] && current[3] === stamp[3];
+        this.unchangedPaths.set(index, unchanged);
+      }
+      if (!unchanged) return void 0;
+      stamps.push(stamp);
+    }
+    return stamps;
+  }
+};
+function readStoredCache(file) {
+  let value;
+  try {
+    value = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord(value) || value.schema !== SCHEMA_VERSION || value.farm !== FARM_VERSION) {
+    return null;
+  }
+  const { paths, entries } = value;
+  if (!Array.isArray(paths) || !paths.every(isPathStamp) || !isRecord(entries)) return null;
+  const valid = {};
+  for (const [key, variants] of Object.entries(entries)) {
+    if (!Array.isArray(variants)) continue;
+    const usable = variants.filter((entry) => isStoredEntry(entry, paths.length));
+    if (usable.length > 0) valid[key] = usable;
+  }
+  return { schema: SCHEMA_VERSION, farm: FARM_VERSION, paths, entries: valid };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPathStamp(value) {
+  return Array.isArray(value) && value.length === 4 && typeof value[0] === "string" && path.isAbsolute(value[0]) && value.slice(1).every((part) => typeof part === "number" && Number.isFinite(part));
+}
+function isPathIndexList(value, pathCount) {
+  return Array.isArray(value) && value.length > 0 && value.every((index) => Number.isSafeInteger(index) && index >= 0 && index < pathCount);
+}
+function isStoredEntry(value, pathCount) {
+  if (!isRecord(value) || !isRecord(value.result)) return false;
+  const { isClientComponent, shouldHydrate, islandStrategy } = value.result;
+  return isPathIndexList(value.files, pathCount) && isPathIndexList(value.directories, pathCount) && Array.isArray(value.stops) && value.stops.every((file) => typeof file === "string" && path.isAbsolute(file)) && typeof isClientComponent === "boolean" && typeof shouldHydrate === "boolean" && (islandStrategy === null || isFarmIslandStrategy(islandStrategy)) && Object.keys(value.result).length === 3;
+}
+var STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/package-client-boundary-cache");
+function getStorage() {
+  const runtime = globalThis;
+  const existing = runtime[STORAGE_KEY];
+  if (existing instanceof AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new AsyncLocalStorage();
+  runtime[STORAGE_KEY] = storage;
+  return storage;
+}
+function getPackageClientBoundaryCache() {
+  return getStorage().getStore();
+}
+async function withPackageClientBoundaryCache(operation) {
+  const cache2 = new PackageClientBoundaryCache();
+  try {
+    return await getStorage().run(cache2, operation);
+  } finally {
+    await cache2.persist();
+  }
+}
+function usePackageClientBoundaryCacheFile(file) {
+  getPackageClientBoundaryCache()?.load(file);
+}
+
+// src/utils/client-component.ts
 function readIfExists(filePath) {
   try {
-    if (!filePath || !fs.existsSync(filePath)) {
+    if (!filePath || !fs2.existsSync(filePath)) {
       return null;
     }
-    return fs.readFileSync(filePath, "utf-8");
+    return fs2.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -353,21 +580,21 @@ function resolveModuleSourcePath(modulePath, root) {
     }
     if (modulePath.startsWith("/@fs/")) {
       const fsPath = withoutQuery.slice("/@fs/".length);
-      candidates.add(path.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
+      candidates.add(path2.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
     }
   }
   if (root && modulePath) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path.join(root, normalized));
-    candidates.add(path.resolve(root, normalized));
+    candidates.add(path2.join(root, normalized));
+    candidates.add(path2.resolve(root, normalized));
   }
   if (withoutQuery?.startsWith("/src/")) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path.join(process.cwd(), normalized));
-    candidates.add(path.resolve(process.cwd(), normalized));
+    candidates.add(path2.join(process.cwd(), normalized));
+    candidates.add(path2.resolve(process.cwd(), normalized));
   }
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -384,8 +611,8 @@ var FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES = 4;
 function isolatedHydrationBoundaryLimit() {
   const benchmarkRoot = process.env.FARM_INTERNAL_ISOLATED_HYDRATION_BENCHMARK_ROOT;
   const benchmarkLimit = Number(process.env.FARM_INTERNAL_ISOLATED_HYDRATION_BENCHMARK_LIMIT);
-  const resolvedBenchmarkRoot = benchmarkRoot ? path.resolve(benchmarkRoot) : null;
-  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path.sep}`));
+  const resolvedBenchmarkRoot = benchmarkRoot ? path2.resolve(benchmarkRoot) : null;
+  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path2.sep}`));
   return isBenchmarkFixture && Number.isSafeInteger(benchmarkLimit) && benchmarkLimit > FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES ? benchmarkLimit : FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES;
 }
 var RESOLVABLE_SOURCE_EXTENSIONS = [
@@ -707,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);
@@ -721,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,
@@ -739,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);
@@ -770,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 {
@@ -814,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) {
@@ -879,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)
@@ -1189,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);
@@ -1225,7 +1517,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
   let fallbackReason;
   let fallbackHint;
   let costGuardExceeded = false;
-  const projectRoot = root ? path.resolve(root) : void 0;
+  const projectRoot = root ? path2.resolve(root) : void 0;
   const visit = (moduleSourcePath) => {
     if (fallbackReason) return 0;
     const cached = estimates.get(moduleSourcePath);
@@ -1235,7 +1527,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
     const content = readIfExists(moduleSourcePath);
     const parsed = parseClientModuleMetadata(content, false);
     if (parsed.isClientComponent) {
-      if (projectRoot && !path.resolve(moduleSourcePath).startsWith(`${projectRoot}${path.sep}`)) {
+      if (projectRoot && !path2.resolve(moduleSourcePath).startsWith(`${projectRoot}${path2.sep}`)) {
         fallbackReason = `client boundary ${moduleSourcePath} is outside the application root`;
         fallbackHint = "Move the component into the application, or publish it as a package (package client components render as static HTML)";
         return 0;
@@ -1267,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;
           }
@@ -1368,7 +1660,24 @@ function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandE
   };
 }
 function inspectPackageClientBoundary(resolvedPath, root, visited) {
+  const cache2 = getPackageClientBoundaryCache();
+  if (!cache2 || !resolvedPath || visited.has(resolvedPath)) {
+    return traversePackageClientBoundary(resolvedPath, root, visited);
+  }
+  const key = `${root ?? ""}\0${resolvedPath}`;
+  const cached = cache2.find(key, visited);
+  if (cached) {
+    for (const file of cached.files) visited.add(file);
+    return { ...cached.result };
+  }
+  const trace = new PackageInspectionTrace();
+  const result = traversePackageClientBoundary(resolvedPath, root, visited, trace);
+  cache2.add(key, trace.toEntry(result));
+  return result;
+}
+function traversePackageClientBoundary(resolvedPath, root, visited, trace) {
   if (!resolvedPath || visited.has(resolvedPath)) {
+    if (resolvedPath) trace?.stop(resolvedPath);
     return {
       isClientComponent: false,
       shouldHydrate: false,
@@ -1376,6 +1685,7 @@ function inspectPackageClientBoundary(resolvedPath, root, visited) {
     };
   }
   visited.add(resolvedPath);
+  trace?.visit(resolvedPath);
   const content = readIfExists(resolvedPath);
   const parsed = parseClientModuleMetadata(content, false);
   let importsClientBoundary = false;
@@ -1383,7 +1693,7 @@ function inspectPackageClientBoundary(resolvedPath, root, visited) {
   for (const specifier of getImportSpecifiers(content)) {
     if (!specifier.startsWith(".") && !specifier.startsWith("/")) continue;
     const importedPath = resolveImportedModuleSourcePath(resolvedPath, specifier, root);
-    const importedMetadata = inspectPackageClientBoundary(importedPath, root, visited);
+    const importedMetadata = traversePackageClientBoundary(importedPath, root, visited, trace);
     if (!importedMetadata.shouldHydrate) continue;
     importsClientBoundary = true;
     if (importedIslandStrategy === null) {
@@ -1482,7 +1792,7 @@ var ALIAS_IMPORT = /^(?:@\/|~\/|#)/;
 function warnUnresolvedAliasImport(importerPath, specifier, root) {
   if (!ALIAS_IMPORT.test(specifier) || warnedUnresolvedAliasImports.has(specifier)) return;
   warnedUnresolvedAliasImports.add(specifier);
-  const importer = root ? path.relative(root, importerPath) : importerPath;
+  const importer = root ? path2.relative(root, importerPath) : importerPath;
   logger.warn(
     `Could not resolve "${specifier}" (imported by ${importer}) while checking which pages need client JavaScript. If it holds client components, they will not hydrate. Map the alias in tsconfig.json "paths" or package.json "imports".`
   );
@@ -1491,7 +1801,7 @@ var projectImportAliasCache = /* @__PURE__ */ new Map();
 var PROJECT_ALIAS_FILES = ["tsconfig.json", "jsconfig.json", "package.json"];
 function resolveProjectAliasSourcePath(specifier, root) {
   if (!root) return void 0;
-  const projectRoot = path.resolve(root);
+  const projectRoot = path2.resolve(root);
   let match;
   for (const alias of getProjectImportAliases(projectRoot)) {
     const captured = matchProjectImportAlias(alias, specifier);
@@ -1501,7 +1811,7 @@ function resolveProjectAliasSourcePath(specifier, root) {
   if (!match) return void 0;
   const resolved = resolveSourceCandidate(
     match.alias.targets.map(
-      (target) => path.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+      (target) => path2.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
     )
   );
   return resolved && /\.d\.[cm]?ts$/.test(resolved) ? null : resolved;
@@ -1516,7 +1826,7 @@ function matchProjectImportAlias(alias, specifier) {
 function getProjectImportAliases(projectRoot) {
   const stamp = PROJECT_ALIAS_FILES.map((file) => {
     try {
-      return String(fs.statSync(path.join(projectRoot, file)).mtimeMs);
+      return String(fs2.statSync(path2.join(projectRoot, file)).mtimeMs);
     } catch {
       return "-";
     }
@@ -1534,7 +1844,7 @@ function getProjectImportAliases(projectRoot) {
       prefix: "@/",
       suffix: "",
       wildcard: true,
-      targets: [path.join(projectRoot, sourceDir, "*")]
+      targets: [path2.join(projectRoot, sourceDir, "*")]
     });
   }
   projectImportAliasCache.set(projectRoot, { stamp: cacheStamp, aliases });
@@ -1542,8 +1852,8 @@ function getProjectImportAliases(projectRoot) {
 }
 function readTsconfigPathAliases(projectRoot) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
-    const configPath = path.join(projectRoot, name);
-    if (!fs.existsSync(configPath)) continue;
+    const configPath = path2.join(projectRoot, name);
+    if (!fs2.existsSync(configPath)) continue;
     const resolved = readTsconfigPaths(configPath, /* @__PURE__ */ new Set());
     if (!resolved?.paths) return [];
     const base = resolved.baseUrl ?? resolved.pathsDirectory;
@@ -1555,7 +1865,7 @@ function readTsconfigPathAliases(projectRoot) {
           prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
           suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
           wildcard: wildcardIndex !== -1,
-          targets: targets.filter((target) => typeof target === "string").map((target) => path.resolve(base, target))
+          targets: targets.filter((target) => typeof target === "string").map((target) => path2.resolve(base, target))
         }
       ];
     });
@@ -1567,27 +1877,27 @@ function readTsconfigPaths(configPath, visited) {
   visited.add(configPath);
   const config = readJsonWithComments(configPath);
   if (!config) return null;
-  const directory = path.dirname(configPath);
+  const directory = path2.dirname(configPath);
   const parents = (Array.isArray(config.extends) ? config.extends : [config.extends]).filter(
     (parent) => typeof parent === "string" && parent.startsWith(".")
   );
   let inherited = null;
   for (const parent of parents) {
-    const parentPath = path.resolve(
+    const parentPath = path2.resolve(
       directory,
       parent.endsWith(".json") ? parent : `${parent}.json`
     );
     inherited = readTsconfigPaths(parentPath, visited) ?? inherited;
   }
   const options = config.compilerOptions ?? {};
-  const baseUrl = typeof options.baseUrl === "string" ? path.resolve(directory, options.baseUrl) : inherited?.baseUrl;
+  const baseUrl = typeof options.baseUrl === "string" ? path2.resolve(directory, options.baseUrl) : inherited?.baseUrl;
   if (options.paths && typeof options.paths === "object") {
     return { paths: options.paths, pathsDirectory: directory, baseUrl };
   }
   return inherited ? { ...inherited, baseUrl } : { pathsDirectory: directory, baseUrl };
 }
 function readPackageImportAliases(projectRoot) {
-  const imports = readPackageJson(path.join(projectRoot, "package.json"))?.imports;
+  const imports = readPackageJson(path2.join(projectRoot, "package.json"))?.imports;
   if (!imports || typeof imports !== "object") return [];
   return Object.entries(imports).flatMap(([pattern, value]) => {
     const target = resolveConditionalExportTarget(value);
@@ -1598,7 +1908,7 @@ function readPackageImportAliases(projectRoot) {
         prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
         suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
         wildcard: wildcardIndex !== -1,
-        targets: [path.resolve(projectRoot, target)]
+        targets: [path2.resolve(projectRoot, target)]
       }
     ];
   });
@@ -1606,7 +1916,7 @@ function readPackageImportAliases(projectRoot) {
 function readJsonWithComments(filePath) {
   let source;
   try {
-    source = fs.readFileSync(filePath, "utf8");
+    source = fs2.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -1644,7 +1954,7 @@ function resolveImportedModuleSourcePath(importerPath, specifier, root) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
   }
   const candidates = /* @__PURE__ */ new Set();
-  const basePath = specifier.startsWith(".") ? path.resolve(path.dirname(importerPath), specifier) : root ? path.resolve(root, specifier.replace(/^\/+/, "")) : path.resolve(specifier);
+  const basePath = specifier.startsWith(".") ? path2.resolve(path2.dirname(importerPath), specifier) : root ? path2.resolve(root, specifier.replace(/^\/+/, "")) : path2.resolve(specifier);
   candidates.add(basePath);
   return resolveSourceCandidate(candidates);
 }
@@ -1654,45 +1964,45 @@ function resolvePackageModuleSourcePath(importerPath, specifier, root) {
   const packageSubpath = packageParts.slice(packageName.startsWith("@") ? 2 : 1).join("/");
   const packageDirectory = findPackageDirectory(importerPath, packageName, root);
   if (!packageDirectory) return null;
-  const packageJsonPath = path.join(packageDirectory, "package.json");
+  const packageJsonPath = path2.join(packageDirectory, "package.json");
   const packageJson = readPackageJson(packageJsonPath);
   const exportKey = packageSubpath ? `./${packageSubpath}` : ".";
   const exportTarget = resolvePackageExport(packageJson?.exports, exportKey);
   const candidates = /* @__PURE__ */ new Set();
   if (exportTarget?.startsWith("./")) {
-    candidates.add(path.resolve(packageDirectory, exportTarget));
+    candidates.add(path2.resolve(packageDirectory, exportTarget));
   }
   if (packageSubpath) {
-    candidates.add(path.join(packageDirectory, packageSubpath));
+    candidates.add(path2.join(packageDirectory, packageSubpath));
   } else {
     for (const entry of [packageJson?.browser, packageJson?.module, packageJson?.main]) {
-      if (typeof entry === "string") candidates.add(path.resolve(packageDirectory, entry));
+      if (typeof entry === "string") candidates.add(path2.resolve(packageDirectory, entry));
     }
-    candidates.add(path.join(packageDirectory, "index"));
+    candidates.add(path2.join(packageDirectory, "index"));
   }
   return resolveSourceCandidate(candidates);
 }
 function findPackageDirectory(importerPath, packageName, root) {
   const searchRoots = /* @__PURE__ */ new Set();
-  let current = path.dirname(importerPath);
+  let current = path2.dirname(importerPath);
   while (true) {
     searchRoots.add(current);
-    const parent = path.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   if (root) {
-    current = path.resolve(root);
+    current = path2.resolve(root);
     while (true) {
       searchRoots.add(current);
-      const parent = path.dirname(current);
+      const parent = path2.dirname(current);
       if (parent === current) break;
       current = parent;
     }
   }
   for (const searchRoot of searchRoots) {
-    const packageDirectory = path.join(searchRoot, "node_modules", packageName);
-    if (fs.existsSync(path.join(packageDirectory, "package.json"))) {
+    const packageDirectory = path2.join(searchRoot, "node_modules", packageName);
+    if (fs2.existsSync(path2.join(packageDirectory, "package.json"))) {
       return packageDirectory;
     }
   }
@@ -1700,7 +2010,7 @@ function findPackageDirectory(importerPath, packageName, root) {
 }
 function readPackageJson(packageJsonPath) {
   try {
-    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -1758,11 +2068,11 @@ function resolveSourceCandidate(candidates) {
   for (const candidate of candidates) {
     const paths = [candidate];
     for (const extension of RESOLVABLE_SOURCE_EXTENSIONS) {
-      paths.push(`${candidate}${extension}`, path.join(candidate, `index${extension}`));
+      paths.push(`${candidate}${extension}`, path2.join(candidate, `index${extension}`));
     }
     for (const sourcePath of paths) {
       try {
-        if (fs.statSync(sourcePath).isFile()) return sourcePath;
+        if (fs2.statSync(sourcePath).isFile()) return sourcePath;
       } catch {
       }
     }
@@ -1772,12 +2082,12 @@ function resolveSourceCandidate(candidates) {
 
 // src/routing/route-manager.ts
 import { realpathSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 
 // src/static-metadata-image.ts
 import { createHash } from "crypto";
 import { readFile } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 import { imageSize } from "image-size";
 var STATIC_METADATA_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp"];
 var CONTENT_TYPES = {
@@ -1818,13 +2128,13 @@ async function inspectStaticMetadataImage(filePath) {
   };
 }
 function getStaticMetadataImageAltPath(filePath) {
-  return path2.join(
-    path2.dirname(filePath),
-    `${path2.basename(filePath, path2.extname(filePath))}.alt.txt`
+  return path3.join(
+    path3.dirname(filePath),
+    `${path3.basename(filePath, path3.extname(filePath))}.alt.txt`
   );
 }
 function getStaticMetadataImageExtension(filePath) {
-  const extension = path2.extname(filePath).slice(1).toLowerCase();
+  const extension = path3.extname(filePath).slice(1).toLowerCase();
   return STATIC_METADATA_IMAGE_EXTENSIONS.includes(extension) ? extension : null;
 }
 async function readAltText(filePath) {
@@ -2152,14 +2462,14 @@ var RouteManager = class {
    * Requests still fetch route data, but never inspect component source.
    */
   generateClientManifest(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path3.resolve(projectRoot);
+    const normalizedProjectRoot = path4.resolve(projectRoot);
     if (this.clientManifestCache?.projectRoot === normalizedProjectRoot) {
       return this.clientManifestCache.manifest;
     }
     const toUrlPath = (absolutePath) => {
       const rootRelative = toRootRelativeUrlPath(absolutePath, normalizedProjectRoot);
       if (rootRelative !== void 0) return rootRelative;
-      if (path3.isAbsolute(absolutePath)) {
+      if (path4.isAbsolute(absolutePath)) {
         const normalized = absolutePath.replace(/\\/g, "/");
         return normalized.startsWith("/") ? `/@fs${normalized}` : `/@fs/${normalized}`;
       }
@@ -2229,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(
@@ -2243,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;
@@ -2338,7 +2649,7 @@ var RouteManager = class {
     for (const { metadata } of [...layoutEntries, ...routeEntries]) {
       if (!metadata.hasIsolatedClientBoundaries && !metadata.serverTreeLayout) continue;
       for (const boundary of metadata.isolatedBoundaries) {
-        isolatedClientBoundaryModules.add(path3.resolve(boundary.modulePath));
+        isolatedClientBoundaryModules.add(path4.resolve(boundary.modulePath));
       }
     }
     const islandsErrors = [
@@ -2389,7 +2700,7 @@ var RouteManager = class {
   }
   /** @internal Client modules selected by the compiled hydration ownership plan. */
   getIsolatedClientBoundaryModules(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path3.resolve(projectRoot);
+    const normalizedProjectRoot = path4.resolve(projectRoot);
     this.generateClientManifest(normalizedProjectRoot);
     return this.clientManifestCache?.isolatedClientBoundaryModules ?? /* @__PURE__ */ new Set();
   }
@@ -2398,7 +2709,7 @@ var RouteManager = class {
    * such a page whole would ship its server code to the browser, so it stays static instead.
    */
   getIslandsErrors(projectRoot = this.config.root) {
-    this.generateClientManifest(path3.resolve(projectRoot));
+    this.generateClientManifest(path4.resolve(projectRoot));
     return this.clientManifestCache?.islandsErrors ?? [];
   }
   /**
@@ -2529,19 +2840,19 @@ var RouteManager = class {
       const markdownFiles = group.files.filter(isFarmMarkdownPageFile);
       if (componentFiles.length > 1) {
         throw new Error(
-          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path4.join(appDir, file)).join(" and ")}.`
         );
       }
       if (markdownFiles.length > 1) {
         throw new Error(
-          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path4.join(appDir, file)).join(" and ")}.`
         );
       }
       const componentFile = componentFiles[0];
       const markdownFile = markdownFiles[0];
       const primaryFile = componentFile || markdownFile;
       if (!primaryFile) continue;
-      const modulePath = path3.join(appDir, primaryFile);
+      const modulePath = path4.join(appDir, primaryFile);
       const existing = this.routes.get(pattern);
       if (existing?.sourceRoot === source.root) {
         throw new Error(
@@ -2552,7 +2863,7 @@ var RouteManager = class {
         route: group.route,
         modulePath,
         ...markdownFile ? {
-          markdownSourcePath: path3.join(appDir, markdownFile)
+          markdownSourcePath: path4.join(appDir, markdownFile)
         } : {},
         pattern,
         ...getPageDirectoryField(group.route, pattern),
@@ -2567,7 +2878,7 @@ var RouteManager = class {
     ]) {
       for (const file of files) {
         const route = parseRoutePath(file);
-        const modulePath = path3.join(appDir, file);
+        const modulePath = path4.join(appDir, file);
         const pattern = createRouteDirectoryPattern(route);
         const existing = target.get(pattern);
         if (existing?.sourceRoot === source.root) {
@@ -2587,7 +2898,7 @@ var RouteManager = class {
     for (const file of [...pageFiles, ...slotDefaultFiles]) {
       const slot = parseRouteSlotFile(file);
       if (!slot) continue;
-      const modulePath = path3.join(appDir, file);
+      const modulePath = path4.join(appDir, file);
       const pattern = this.createRoutePattern(slot.route);
       const ownerPattern = this.createRoutePattern(slot.ownerRoute);
       const ownerDirectory = createRouteDirectoryPattern(slot.ownerRoute);
@@ -2613,11 +2924,11 @@ var RouteManager = class {
       });
     }
     for (const file of metadataImageFiles) {
-      const fileBase = path3.basename(file, path3.extname(file));
+      const fileBase = path4.basename(file, path4.extname(file));
       const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
       const fileName = kind === "twitter" ? "twitter-image" : "opengraph-image";
       const route = parseRoutePath(file);
-      const modulePath = path3.join(appDir, file);
+      const modulePath = path4.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${kind}:${pattern}`;
       const existing = this.metadataImages.get(key);
@@ -2642,11 +2953,11 @@ var RouteManager = class {
     }
     for (const file of metadataRouteFiles) {
       const descriptor = getApplicationMetadataRouteDescriptor(
-        path3.basename(file, path3.extname(file))
+        path4.basename(file, path4.extname(file))
       );
       if (!descriptor) continue;
       const route = parseRoutePath(file);
-      const modulePath = path3.join(appDir, file);
+      const modulePath = path4.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${descriptor.kind}:${pattern}`;
       const existing = this.metadataRoutes.get(key);
@@ -3057,26 +3368,27 @@ function toRealPath(filePath) {
 }
 
 // src/server/dev-styles.ts
-import * as fs2 from "fs";
-import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path5 from "path";
 function resolveDevGlobalStylesheetHref(root, srcDir = "src") {
-  const file = path4.join(root, srcDir, "app", "globals.css");
-  if (!fs2.existsSync(file)) return void 0;
-  return `/${path4.relative(root, file).split(path4.sep).join("/")}`;
+  const file = path5.join(root, srcDir, "app", "globals.css");
+  if (!fs3.existsSync(file)) return void 0;
+  return `/${path5.relative(root, file).split(path5.sep).join("/")}`;
 }
 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();
 }
@@ -3085,7 +3397,7 @@ function collectDevStylesheetUrls(modules, alreadyLinked = ALREADY_LINKED) {
 import { createHash as createHash2, timingSafeEqual } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 var FONT_IMPORTS = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/font"]);
@@ -3442,7 +3754,7 @@ ${FONT_SECTION_END}
         return resource;
       }
       const bytes2 = await fetchRemoteFont(url, input.integrity);
-      return this.createSelfHostedResource(bytes2, extension, path5.basename(url.pathname));
+      return this.createSelfHostedResource(bytes2, extension, path6.basename(url.pathname));
     }
     if (input.source.startsWith("/")) {
       return this.createPublicResource(input.moduleId, input.source);
@@ -3465,8 +3777,8 @@ ${FONT_SECTION_END}
     }
     return this.createSelfHostedResource(
       bytes,
-      path5.extname(resolvedPath),
-      path5.basename(resolvedPath)
+      path6.extname(resolvedPath),
+      path6.basename(resolvedPath)
     );
   }
   async createPublicResource(moduleId, source) {
@@ -3477,7 +3789,7 @@ ${FONT_SECTION_END}
       );
     }
     const publicPath = normalizePublicFontPath(source, moduleId);
-    const resolvedPath = path5.resolve(this.publicDir, `.${publicPath}`);
+    const resolvedPath = path6.resolve(this.publicDir, `.${publicPath}`);
     if (!isPathInside(this.publicDir, resolvedPath)) {
       throw fontError(moduleId, `public font path must stay inside publicDir`);
     }
@@ -3493,7 +3805,7 @@ ${FONT_SECTION_END}
         `could not read ${JSON.stringify(source)} from publicDir: ${error.message}`
       );
     }
-    const extension = path5.extname(resolvedPath).toLowerCase();
+    const extension = path6.extname(resolvedPath).toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
     const resource = {
       extension,
@@ -3508,7 +3820,7 @@ ${FONT_SECTION_END}
   createSelfHostedResource(bytes, extension, fileName) {
     const normalizedExtension = extension.toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
-    const baseName = sanitizeFileName(path5.basename(fileName, extension)) || "font";
+    const baseName = sanitizeFileName(path6.basename(fileName, extension)) || "font";
     const outputFileName = `assets/fonts/${baseName}-h${hash}${normalizedExtension}`;
     const key = `${hash}${normalizedExtension}`;
     const existing = this.resources.get(key);
@@ -3861,24 +4173,24 @@ function verifyIntegrity(bytes, integrity) {
   if (!matches) throw new Error("downloaded font did not match its integrity value");
 }
 function resolveLocalFontPath(source, importer, root) {
-  if (source.startsWith(".")) return path5.resolve(path5.dirname(importer), source);
-  if (path5.isAbsolute(source)) {
+  if (source.startsWith(".")) return path6.resolve(path6.dirname(importer), source);
+  if (path6.isAbsolute(source)) {
     return source;
   }
   try {
     return createRequire(pathToFileURL(importer)).resolve(source);
   } catch {
     const segments = source.replace(/\\/g, "/").split("/");
-    if (segments.includes("..")) return path5.resolve(root, source);
-    let current = path5.dirname(importer);
-    const filesystemRoot = path5.parse(current).root;
+    if (segments.includes("..")) return path6.resolve(root, source);
+    let current = path6.dirname(importer);
+    const filesystemRoot = path6.parse(current).root;
     while (true) {
-      const candidate = path5.join(current, "node_modules", ...segments);
+      const candidate = path6.join(current, "node_modules", ...segments);
       if (existsSync2(candidate)) return candidate;
       if (current === filesystemRoot) break;
-      current = path5.dirname(current);
+      current = path6.dirname(current);
     }
-    return path5.resolve(root, "node_modules", ...segments);
+    return path6.resolve(root, "node_modules", ...segments);
   }
 }
 function replaceFontSection(css, section) {
@@ -3911,11 +4223,11 @@ function getGlobalMap(key) {
   return created;
 }
 function normalizeRoot(root) {
-  return path5.resolve(root).replace(/\\/g, "/");
+  return path6.resolve(root).replace(/\\/g, "/");
 }
 function normalizePublicDir(root, publicDir) {
   if (publicDir === false || publicDir === "") return false;
-  return path5.resolve(root, publicDir || "public");
+  return path6.resolve(root, publicDir || "public");
 }
 function normalizePublicFontPath(source, moduleId) {
   if (source.includes("?") || source.includes("#")) {
@@ -3924,8 +4236,8 @@ function normalizePublicFontPath(source, moduleId) {
   return `/${source.replace(/\\/g, "/").replace(/^\/+/, "")}`;
 }
 function isPathInside(parent, child) {
-  const relative3 = path5.relative(parent, child);
-  return relative3 === "" || !relative3.startsWith("..") && !path5.isAbsolute(relative3);
+  const relative3 = path6.relative(parent, child);
+  return relative3 === "" || !relative3.startsWith("..") && !path6.isAbsolute(relative3);
 }
 function normalizeBasePath(value) {
   if (!value || value === "/") return "/";
@@ -3935,7 +4247,7 @@ function joinBasePath(basePath, value) {
   return basePath === "/" ? value : `${basePath.replace(/\/$/, "")}${value}`;
 }
 function extensionFromPath(pathname) {
-  const extension = path5.extname(pathname).toLowerCase();
+  const extension = path6.extname(pathname).toLowerCase();
   if (!FONT_EXTENSION_RE.test(extension)) {
     throw new Error(`[Farm fonts] Remote font URL must end in .woff2, .woff, .ttf, or .otf`);
   }
@@ -4075,7 +4387,7 @@ function fontError(id, message) {
 }
 
 // src/integration-provider-build.ts
-import path6 from "path";
+import path7 from "path";
 function isRendererCompiledComponent(moduleId, rendererComponentExtensions) {
   const lowered = moduleId.toLowerCase();
   return rendererComponentExtensions.some((extension) => lowered.endsWith(extension.toLowerCase()));
@@ -4177,76 +4489,473 @@ function generateFarmIntegrationProviderServerModules(providers, root, rendererC
 }
 function resolveProviderModule(moduleId, root) {
   if (!moduleId.startsWith(".")) return moduleId;
-  return toViteModuleId(path6.resolve(root, moduleId), root);
+  return toViteModuleId(path7.resolve(root, moduleId), root);
 }
 
-// src/server/renderer.ts
-import * as fs5 from "fs";
-import * as https from "https";
-import { isIP } from "net";
-import * as path9 from "path";
-import * as tls from "tls";
-import { Readable, Writable } from "stream";
-
-// src/not-found.ts
-import fs3 from "fs";
-import path7 from "path";
-function resolveFarmNotFoundComponentPath(config, appDirs) {
-  const extensions = getFarmRendererComponentExtensions(config.renderer);
-  const configuredPath = config.notFound?.component?.trim();
-  if (configuredPath) {
-    const componentPath = path7.isAbsolute(configuredPath) ? path7.normalize(configuredPath) : path7.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(", ")}`
-      );
+// src/island-inference.ts
+import fs4 from "fs";
+import path8 from "path";
+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 (!fs3.existsSync(componentPath) || !fs3.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 = path7.join(appDir, `not-found${extension}`);
-      if (fs3.existsSync(candidate) && fs3.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;
+  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-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;
+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,
-.farm-default-not-found * {
-  box-sizing: border-box;
+// 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;
 }
-
+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`);
+  }
+  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;
@@ -4377,8 +5086,8 @@ body {
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/server/error-diagnostics.ts
-import * as fs4 from "fs";
-import * as path8 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;
@@ -4386,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 = path8.relative(root, filePath);
-  return relative3 === "" || !relative3.startsWith("..") && !path8.isAbsolute(relative3);
+  const relative3 = path11.relative(root, filePath);
+  return relative3 === "" || !relative3.startsWith("..") && !path11.isAbsolute(relative3);
 }
 function normalizeStackPath(value) {
   const withoutQuery = value.replace(/[?#].*$/, "");
@@ -4404,13 +5113,13 @@ function findStackLocation(stack, root) {
     );
     if (!match) continue;
     const candidate = normalizeStackPath(match[1]);
-    if (!candidate || candidate.includes(`${path8.sep}node_modules${path8.sep}`)) continue;
-    const absolutePath = path8.resolve(candidate);
-    if (!isPathInsideRoot(root, absolutePath) || !fs4.existsSync(absolutePath)) continue;
-    const relativePath = path8.relative(root, absolutePath).split(path8.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 || path8.basename(absolutePath),
+      displayPath: relativePath || path11.basename(absolutePath),
       line: Number(match[2]),
       column: Number(match[3])
     };
@@ -4419,7 +5128,7 @@ function findStackLocation(stack, root) {
 }
 function createSourceFrame(location) {
   try {
-    const sourceLines = fs4.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);
@@ -4442,13 +5151,13 @@ function createSourceFrame(location) {
   }
 }
 function sanitizeStack(stack, root) {
-  const normalizedRoot = path8.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, path8.resolve(root));
+  const location = findStackLocation(rawStack, path11.resolve(root));
   return {
     name: redactErrorText(normalizedError.name || "Error"),
     message: redactErrorText(normalizedError.message || "Unknown server rendering error"),
@@ -4457,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) {
@@ -4563,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(
@@ -4589,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}
@@ -4702,7 +5426,7 @@ function createRouteStateProps(input) {
 function readAppPackageIdentity(root) {
   try {
     return JSON.parse(
-      fs5.readFileSync(path9.join(root || process.cwd(), "package.json"), "utf8")
+      fs8.readFileSync(path12.join(root || process.cwd(), "package.json"), "utf8")
     );
   } catch {
     return {};
@@ -4814,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() {
@@ -4822,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
@@ -5001,10 +5733,10 @@ var ServerRenderer = class {
    * Load SSG manifest from build output
    */
   loadSSGManifest() {
-    const manifestPath = path9.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 = fs5.readFileSync(manifestPath, "utf-8");
+      content = fs8.readFileSync(manifestPath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
@@ -5223,10 +5955,10 @@ var ServerRenderer = class {
       return true;
     }
     try {
-      const htmlPath = page.urlPath === "/" ? path9.join(this.config.root, this.config.outDir, "client", "index.html") : path9.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
-      if (fs5.existsSync(htmlPath)) {
-        const stat = fs5.statSync(htmlPath);
-        const html = fs5.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
@@ -5476,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,
@@ -5650,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
       );
@@ -5749,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;
@@ -5783,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);
@@ -5961,11 +6721,11 @@ var ServerRenderer = class {
         if (isFarmIntegrationProviderComponentReference(provider.component)) {
           providerSourceModule = provider.component.module;
           const providerModuleId = provider.component.module.startsWith(".") ? toViteModuleId(
-            path9.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(path9.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") {
@@ -6232,7 +6992,7 @@ var ServerRenderer = class {
               logger.warn(`Could not read metadata for ${pattern} in sitemap.xml: ${error}`);
               return void 0;
             }),
-            fs5.promises.stat(route.modulePath).catch(() => void 0)
+            fs8.promises.stat(route.modulePath).catch(() => void 0)
           ]);
           return { pattern, module, lastModified: stat?.mtime.toISOString() };
         })
@@ -6298,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-WWCC4GLG.mjs");
+      const { handleFarmDefaultMCPRequest } = await import("./agent-mcp-handler-7QMX2LUY.mjs");
       const origin = new URL(request2.url).origin;
       const response = await handleFarmDefaultMCPRequest(request2, {
         server,
@@ -6483,7 +7243,7 @@ var ServerRenderer = class {
       res.end();
       return;
     }
-    res.write(await fs5.promises.readFile(image.modulePath));
+    res.write(await fs8.promises.readFile(image.modulePath));
     res.end();
   }
   async renderRouteErrorBoundary(req, res, options) {
@@ -6805,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;
@@ -6900,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,
@@ -6931,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() {
@@ -6969,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) {
@@ -6981,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(
@@ -7054,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;
@@ -7149,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) {
@@ -7278,13 +8064,13 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       res.end(createFarmMarkdownErrorBody(404, pathname, this.config.basePath || "/"));
       return;
     }
-    const appDir = path9.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 = path9.join(appDir, `layout${ext}`);
-        if (fs5.existsSync(layoutPath)) {
+        const layoutPath = path12.join(appDir, `layout${ext}`);
+        if (fs8.existsSync(layoutPath)) {
           layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
           break;
         }
@@ -7497,7 +8283,7 @@ ${clientScript}
 };
 
 // src/app.ts
-import path10 from "path";
+import path13 from "path";
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -7637,7 +8423,7 @@ var FarmApp = class {
     }
     const componentExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     const rootLayoutPaths = appDirs.flatMap(
-      (appDir) => componentExtensions.map((extension) => path10.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)
@@ -7701,13 +8487,13 @@ function resolveFarmImageServerRuntime(images, preset) {
 }
 
 // src/app-manifest-packages.ts
-import fs6 from "fs";
-import path11 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(fs6.readFileSync(path11.join(root, "package.json"), "utf8"));
+    manifest = JSON.parse(fs9.readFileSync(path14.join(root, "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -7722,13 +8508,13 @@ function resolveFarmAppPackages(root) {
     for (let dir = root; ; ) {
       try {
         const { version } = JSON.parse(
-          fs6.readFileSync(path11.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 = path11.dirname(dir);
+        const parent = path14.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -7738,9 +8524,9 @@ function resolveFarmAppPackages(root) {
 }
 
 // src/app-manifest-webmcp.ts
-import fs7 from "fs";
+import fs10 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path12 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"]);
@@ -7758,7 +8544,7 @@ var LANGS = {
   cjs: "jsx",
   jsx: "jsx"
 };
-var parseAst;
+var parseAst2;
 function staticValue(node) {
   if (!node) return NOT_STATIC;
   switch (node.type) {
@@ -7790,407 +8576,141 @@ function staticValue(node) {
         if (value === NOT_STATIC) return NOT_STATIC;
         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[path12.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 = path12.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 = fs7.statSync(file).mtimeMs;
-    } catch {
-      continue;
-    }
-    let entry = cache.get(file);
-    if (!entry || entry.mtimeMs !== mtimeMs) {
-      let code = "";
-      try {
-        code = fs7.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 fs8 from "fs";
-import path13 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 = path13.resolve(root, srcDir);
-  for (const extension of APP_CLIENT_EXTENSIONS) {
-    const candidate = path13.join(sourceRoot, `client.${extension}`);
-    if (fs8.existsSync(candidate) && fs8.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) {
-  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 = resolveFarmPlatform() === "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`);
+      return object;
+    }
+    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 fs9 from "fs";
-import path14 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;
@@ -8201,7 +8721,7 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
       'cache.client.adapter must be a module path string, for example "./src/cache-adapter".'
     );
   }
-  const resolved = path14.resolve(root, adapter);
+  const resolved = path16.resolve(root, adapter);
   const found = resolveAdapterFile(resolved);
   if (!found) {
     throw new Error(
@@ -8214,10 +8734,10 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
   return { importPath: found.replace(/\\/g, "/"), options };
 }
 function resolveAdapterFile(resolved) {
-  if (fs9.existsSync(resolved) && fs9.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 (fs9.existsSync(candidate) && fs9.statSync(candidate).isFile()) return candidate;
+    if (fs11.existsSync(candidate) && fs11.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -8380,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 path15 from "path";
-var parseAst2;
+import path17 from "path";
+var parseAst3;
 function propertyKeyName(property2) {
   if (property2.computed) return void 0;
   const key = property2.key;
@@ -8393,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 = path15.extname(filename);
-  const program = parseAst2(code, {
+  const extension = path17.extname(filename);
+  const program = parseAst3(code, {
     lang: extension === ".tsx" || extension === ".jsx" ? "tsx" : "ts"
   });
   const edits = [];
@@ -8458,7 +9022,7 @@ function farmDocsClientConfigPlugin(configModule) {
 }
 
 // src/server/vite-config.ts
-import path16 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",
@@ -8485,9 +9049,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
   );
 }
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = path16.resolve(projectRoot);
+  const resolvedProjectRoot = path18.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = path16.relative(resolvedProjectRoot, path16.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = path18.relative(resolvedProjectRoot, path18.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -8509,7 +9073,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 }
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": path16.resolve(projectRoot, srcDir)
+    "@": path18.resolve(projectRoot, srcDir)
   };
 }
 function mergeNoExternal(farmValue, userValue) {
@@ -8657,6 +9221,8 @@ ${FARM_DARK_VARIANT}
 }
 
 export {
+  withPackageClientBoundaryCache,
+  usePackageClientBoundaryCacheFile,
   resolveModuleSourcePath,
   getFarmClientHydrationPlanOptions,
   describeSuppressedAsyncHydration,
@@ -8664,6 +9230,7 @@ export {
   hasUseClientDirective,
   getIslandStrategyExport,
   stripUseClientDirective,
+  collectFarmServerStylesheets,
   getClientModuleMetadata,
   getClientModuleHydrationPlan,
   usesFarmServerTree,
@@ -8678,6 +9245,10 @@ export {
   DEFAULT_NOT_FOUND_STYLES,
   generateFarmIntegrationProviderClientCode,
   generateFarmIntegrationProviderServerModules,
+  inferFarmIslandStrategy,
+  resolveFarmRouteRootStrategy,
+  generateFarmClientPluginEntryCode,
+  canBootFarmIslandsClient,
   ServerRenderer,
   FarmApp,
   createFarmApp,
@@ -8686,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,