@farm.js/core 0.1.62 → 0.1.63

package/dist/{chunk-2JYBLE63.mjs → chunk-LA45FN37.mjs}

@@ -41,7 +41,7 @@ import {
 } from "./chunk-MK5E44WP.mjs";
 import {
   listFarmMCPLlmsTxtLinks
-} from "./chunk-VM7X5CKC.mjs";
+} from "./chunk-7FFW7DC4.mjs";
 import {
   FARM_DEFAULT_MCP_PATH,
   collectFarmDefaultMCPPages,
@@ -256,7 +256,7 @@ import {
 } from "./chunk-D2LCAV6L.mjs";
 import {
   FARM_VERSION
-} from "./chunk-NT3QDN2E.mjs";
+} from "./chunk-RFYL5OLP.mjs";
 import {
   resolveFarmTrailingSlashRedirect,
   setFarmTrailingSlashPreference
@@ -327,12 +327,171 @@ import {
   getRoutePatternShape
 } from "./chunk-AYP2YFVN.mjs";
 
-// src/islands-package-references.ts
+// src/islands-react-server-exports.ts
 import fs from "fs";
 import path from "path";
 import { parseAst } from "rolldown/parseAst";
-var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
-function parse(code, file) {
+var REACT_PACKAGES = /* @__PURE__ */ new Set([
+  "react",
+  "react-dom",
+  "scheduler",
+  "react-server-dom-webpack",
+  "react-server-dom-esm",
+  "react-server-dom-turbopack"
+]);
+var SERVER_CONDITIONS = ["react-server", "node", "import", "module", "default"];
+var DEFAULT_CONDITIONS = ["node", "import", "module", "default"];
+var SCRIPT_EXTENSIONS = ["", ".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx", ".mts"];
+var INDEX_FILES = ["index.js", "index.mjs", "index.cjs", "index.ts", "index.tsx"];
+function packageNameOf(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.includes(":") || specifier.includes("\0")) {
+    return null;
+  }
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!name || specifier.startsWith("@") && parts.length < 2) return null;
+  return { name, subpath: parts.slice(name.startsWith("@") ? 2 : 1).join("/") };
+}
+function findPackageDirectory(importer, name) {
+  for (let current = path.dirname(importer); ; current = path.dirname(current)) {
+    const directory = path.join(current, "node_modules", name);
+    if (fs.existsSync(path.join(directory, "package.json"))) return fs.realpathSync(directory);
+    if (path.dirname(current) === current) return null;
+  }
+}
+function pickTarget(value, conditions) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const target = pickTarget(entry, conditions);
+      if (target) return target;
+    }
+    return null;
+  }
+  if (!value || typeof value !== "object") return null;
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "types" || !conditions.includes(key)) continue;
+    const target = pickTarget(entry, conditions);
+    if (target) return target;
+  }
+  return null;
+}
+function exportEntry(exportsField, subpath) {
+  const key = subpath ? `./${subpath}` : ".";
+  if (typeof exportsField === "string" || Array.isArray(exportsField)) {
+    return key === "." ? exportsField : void 0;
+  }
+  if (!exportsField || typeof exportsField !== "object") return void 0;
+  const entries = exportsField;
+  if (!Object.keys(entries).some((entry) => entry.startsWith("."))) {
+    return key === "." ? entries : void 0;
+  }
+  if (entries[key] !== void 0) return entries[key];
+  for (const [pattern, value] of Object.entries(entries)) {
+    const star = pattern.indexOf("*");
+    if (star === -1) continue;
+    const prefix = pattern.slice(0, star);
+    const suffix = pattern.slice(star + 1);
+    if (key.startsWith(prefix) && key.endsWith(suffix)) {
+      const match = key.slice(prefix.length, key.length - suffix.length);
+      const replace = (target) => typeof target === "string" ? target.replace("*", match) : target && typeof target === "object" && !Array.isArray(target) ? Object.fromEntries(
+        Object.entries(target).map(([k, v]) => [k, replace(v)])
+      ) : target;
+      return replace(value);
+    }
+  }
+  return void 0;
+}
+var cache = /* @__PURE__ */ new Map();
+function resolveFarmReactServerExport(importer, specifier) {
+  const parsed = packageNameOf(specifier);
+  if (!parsed || REACT_PACKAGES.has(parsed.name) || parsed.name.startsWith("@farm.js/"))
+    return null;
+  const directory = findPackageDirectory(importer, parsed.name);
+  if (!directory) return null;
+  const key = `${directory}\0${parsed.subpath}`;
+  if (cache.has(key)) return cache.get(key);
+  let resolved = null;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8"));
+    const entry = exportEntry(manifest.exports, parsed.subpath);
+    const server = pickTarget(entry, SERVER_CONDITIONS);
+    const fallback = pickTarget(entry, DEFAULT_CONDITIONS);
+    if (server && server !== fallback && server.startsWith("./")) {
+      const file = path.resolve(directory, server);
+      if (fs.existsSync(file)) resolved = file;
+    }
+  } catch {
+    resolved = null;
+  }
+  cache.set(key, resolved);
+  return resolved;
+}
+function readModule(file) {
+  try {
+    const code = fs.readFileSync(file, "utf8");
+    const extension = path.extname(file).slice(1);
+    const lang = extension === "ts" || extension === "mts" || extension === "cts" ? "ts" : "tsx";
+    return parseAst(code, { lang });
+  } catch {
+    return null;
+  }
+}
+function isClientModule(program) {
+  for (const node of program.body ?? []) {
+    if (node.type !== "ExpressionStatement" || typeof node.directive !== "string") break;
+    if (node.directive === "use client") return true;
+  }
+  return false;
+}
+function resolveRelative(from, specifier) {
+  const base = path.resolve(path.dirname(from), specifier);
+  for (const extension of SCRIPT_EXTENSIONS) {
+    const file = `${base}${extension}`;
+    if (fs.existsSync(file) && fs.statSync(file).isFile()) return file;
+  }
+  for (const index of INDEX_FILES) {
+    const file = path.join(base, index);
+    if (fs.existsSync(file)) return file;
+  }
+  return null;
+}
+function exportedName(node) {
+  return node?.type === "Identifier" ? node.name : node?.value;
+}
+function isFarmClientExport(file, name, depth = 0) {
+  if (depth > 6) return false;
+  const program = readModule(file);
+  if (!program) return false;
+  if (isClientModule(program)) return true;
+  const stars = [];
+  for (const node of program.body ?? []) {
+    if (node.type === "ExportNamedDeclaration" && node.source) {
+      for (const specifier of node.specifiers ?? []) {
+        if (exportedName(specifier.exported) !== name) continue;
+        const target = resolveRelative(file, node.source.value);
+        return target ? isFarmClientExport(target, exportedName(specifier.local) ?? name, depth + 1) : false;
+      }
+    } else if (node.type === "ExportAllDeclaration" && node.source && !node.exported) {
+      stars.push(node.source.value);
+    } else if (node.type === "ExportNamedDeclaration" && !node.source) {
+      const names = [
+        ...(node.specifiers ?? []).map((specifier) => exportedName(specifier.exported)),
+        ...node.declaration?.id ? [node.declaration.id.name] : [],
+        ...(node.declaration?.declarations ?? []).map((declarator) => declarator.id?.name)
+      ];
+      if (names.includes(name)) return false;
+    } else if (node.type === "ExportDefaultDeclaration" && name === "default") {
+      return false;
+    }
+  }
+  for (const source of stars) {
+    const target = resolveRelative(file, source);
+    if (target && isFarmClientExport(target, name, depth + 1)) return true;
+  }
+  return false;
+}
+function parseCode(code, file) {
   const extension = path.extname(file).slice(1);
   const lang = extension === "ts" || extension === "mts" || extension === "cts" ? "ts" : "tsx";
   try {
@@ -341,6 +500,280 @@ function parse(code, file) {
     return null;
   }
 }
+function namespaceMembers(program, local) {
+  const members = /* @__PURE__ */ new Set();
+  let opaque = false;
+  const visit = (node, parent) => {
+    if (opaque || !node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child, parent);
+      return;
+    }
+    const current = node;
+    if (typeof current.type !== "string") return;
+    if ((current.type === "Identifier" || current.type === "JSXIdentifier") && current.name === local && parent?.type !== "ImportNamespaceSpecifier") {
+      const property2 = (parent?.type === "MemberExpression" || parent?.type === "JSXMemberExpression") && parent.object === current && !parent.computed ? parent.property?.name : void 0;
+      if (property2) members.add(property2);
+      else opaque = true;
+      return;
+    }
+    for (const [key, value] of Object.entries(current)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      if (value && typeof value === "object") visit(value, current);
+    }
+  };
+  visit(program, null);
+  return opaque ? null : [...members];
+}
+function findPackageImports(program, accept) {
+  const found = [];
+  for (const node of program.body ?? []) {
+    if (node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+    const specifier = node.source?.value;
+    if (typeof specifier !== "string" || !accept(specifier)) continue;
+    const specifiers = (node.specifiers ?? []).filter(
+      (entry2) => entry2.importKind !== "type"
+    );
+    if ((node.specifiers ?? []).length > 0 && specifiers.length === 0) continue;
+    const entry = {
+      start: node.start,
+      end: node.end,
+      specifier,
+      sideEffect: specifiers.length === 0,
+      named: []
+    };
+    for (const binding of specifiers) {
+      if (binding.type === "ImportDefaultSpecifier") entry.defaultLocal = binding.local.name;
+      else if (binding.type === "ImportNamespaceSpecifier") {
+        entry.namespace = {
+          local: binding.local.name,
+          members: namespaceMembers(program, binding.local.name)
+        };
+      } else {
+        const imported = exportedName(binding.imported);
+        if (imported) entry.named.push({ imported, local: binding.local.name });
+      }
+    }
+    found.push(entry);
+  }
+  return found;
+}
+function findFarmReactServerClientNames(code, file, specifier) {
+  const target = resolveFarmReactServerExport(file, specifier);
+  if (!target) return null;
+  const program = parseCode(code, file);
+  if (!program) return null;
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of findPackageImports(program, (candidate) => candidate === specifier)) {
+    const wanted = [
+      ...entry.defaultLocal ? ["default"] : [],
+      ...entry.named.map((binding) => binding.imported),
+      ...entry.namespace?.members ?? []
+    ];
+    for (const name of wanted) if (isFarmClientExport(target, name)) names.add(name);
+  }
+  return [...names];
+}
+function rewriteFarmReactServerImports(options) {
+  if (!options.code.includes("import")) return null;
+  const program = parseCode(options.code, options.file);
+  if (!program) return null;
+  const targets = /* @__PURE__ */ new Map();
+  const imports = findPackageImports(program, (specifier) => {
+    const target = resolveFarmReactServerExport(options.file, specifier);
+    if (target) targets.set(specifier, target);
+    return target !== null;
+  });
+  if (imports.length === 0) return null;
+  let output = options.code;
+  let next = 0;
+  for (const entry of [...imports].sort((left, right) => right.start - left.start)) {
+    const target = targets.get(entry.specifier);
+    options.onServerFile?.(target);
+    const server = JSON.stringify(target);
+    const lines = [];
+    const bind = (name, local) => {
+      if (isFarmClientExport(target, name)) {
+        lines.push(
+          `import { ${name} as ${local} } from ${JSON.stringify(options.reference(entry.specifier, name))};`
+        );
+      } else lines.push(`import { ${name} as ${local} } from ${server};`);
+    };
+    if (entry.sideEffect) lines.push(`import ${server};`);
+    if (entry.defaultLocal) bind("default", entry.defaultLocal);
+    for (const binding of entry.named) bind(binding.imported, binding.local);
+    if (entry.namespace) {
+      if (entry.namespace.members === null) {
+        lines.push(`import * as ${entry.namespace.local} from ${server};`);
+      } else {
+        const fields = [];
+        for (const member of entry.namespace.members) {
+          const local = `__farm_react_server_${next++}__`;
+          bind(member, local);
+          fields.push(`${member}: ${local}`);
+        }
+        lines.push(`const ${entry.namespace.local} = Object.freeze({ ${fields.join(", ")} });`);
+      }
+    }
+    output = output.slice(0, entry.start) + lines.join("\n") + output.slice(entry.end);
+  }
+  return output;
+}
+function farmRelativeImportFiles(code, file) {
+  const program = parseCode(code, file);
+  if (!program) return [];
+  const files = [];
+  for (const node of program.body ?? []) {
+    const source = (node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration" && node.source) && node.source?.value;
+    if (typeof source !== "string" || !source.startsWith(".")) continue;
+    const resolved = resolveRelative(file, source);
+    if (resolved) files.push(resolved);
+  }
+  return files;
+}
+function farmReactServerBuildReachesClientModules(importer, specifier) {
+  const target = resolveFarmReactServerExport(importer, specifier);
+  if (!target) return false;
+  const seen = /* @__PURE__ */ new Set();
+  const reaches = (file, depth) => {
+    if (depth > 6 || seen.has(file)) return false;
+    seen.add(file);
+    const program = readModule(file);
+    if (!program) return false;
+    if (depth > 0 && isClientModule(program)) return true;
+    for (const node of program.body ?? []) {
+      const source = (node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration" && node.source || node.type === "ImportDeclaration") && node.source?.value;
+      if (typeof source !== "string" || !source.startsWith(".")) continue;
+      const child = resolveRelative(file, source);
+      if (child && reaches(child, depth + 1)) return true;
+    }
+    return false;
+  };
+  return reaches(target, 0);
+}
+var IMPORT_SPECIFIER = /(?:\bfrom\s*|\bimport\s*\(?\s*)["']([^"'./][^"']*)["']/g;
+var MAX_SCANNED_FILES = 2e3;
+function packageImportSpecifiers(directory) {
+  const found = /* @__PURE__ */ new Set();
+  const pending = [directory];
+  let scanned = 0;
+  while (pending.length > 0 && scanned < MAX_SCANNED_FILES) {
+    const current = pending.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      const file = path.join(current, entry.name);
+      if (entry.isDirectory()) pending.push(file);
+      else if (/\.(?:m?js|jsx)$/.test(entry.name) && scanned++ < MAX_SCANNED_FILES) {
+        let code;
+        try {
+          code = fs.readFileSync(file, "utf8");
+        } catch {
+          continue;
+        }
+        for (const match of code.matchAll(IMPORT_SPECIFIER)) found.add(match[1]);
+      }
+    }
+  }
+  return found;
+}
+function findFarmPackageManifest(importer, specifier) {
+  const parsed = packageNameOf(specifier);
+  if (!parsed) return null;
+  const directory = findPackageDirectory(importer, parsed.name);
+  if (!directory) return null;
+  let names;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8"));
+    names = new Set(Object.keys(manifest.dependencies ?? {}));
+  } catch {
+    return null;
+  }
+  const dependencies = [...packageImportSpecifiers(directory)].filter((imported) => {
+    const name = packageNameOf(imported)?.name;
+    return name !== void 0 && names.has(name);
+  });
+  return { name: parsed.name, dependencies: dependencies.sort() };
+}
+function listFarmPackageExports(importer, specifier) {
+  const parsed = packageNameOf(specifier);
+  if (!parsed) return null;
+  const directory = findPackageDirectory(importer, parsed.name);
+  if (!directory) return null;
+  let entry = null;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8"));
+    const target = pickTarget(exportEntry(manifest.exports, parsed.subpath), [
+      "browser",
+      ...DEFAULT_CONDITIONS
+    ]) ?? (!parsed.subpath ? manifest.module ?? manifest.main ?? "index.js" : parsed.subpath);
+    entry = resolveRelative(
+      path.join(directory, "package.json"),
+      `./${String(target).replace(/^\.\//, "")}`
+    );
+  } catch {
+    return null;
+  }
+  if (!entry) return null;
+  const names = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const collect = (file, depth) => {
+    if (depth > 8 || seen.has(file)) return true;
+    seen.add(file);
+    const program = readModule(file);
+    if (!program) return false;
+    let esm = false;
+    for (const node of program.body ?? []) {
+      if (node.type === "ExportAllDeclaration" && node.source && !node.exported) {
+        esm = true;
+        const child = resolveRelative(file, node.source.value);
+        if (!child || !collect(child, depth + 1)) return false;
+      } else if (node.type === "ExportAllDeclaration" && node.exported) {
+        esm = true;
+        const name = exportedName(node.exported);
+        if (name) names.add(name);
+      } else if (node.type === "ExportNamedDeclaration") {
+        esm = true;
+        for (const specifier2 of node.specifiers ?? []) {
+          const name = exportedName(specifier2.exported);
+          if (name) names.add(name);
+        }
+        if (node.declaration?.id?.name) names.add(node.declaration.id.name);
+        for (const declarator of node.declaration?.declarations ?? []) {
+          if (declarator.id?.type === "Identifier") names.add(declarator.id.name);
+        }
+      } else if (node.type === "ExportDefaultDeclaration") {
+        esm = true;
+        names.add("default");
+      } else if (node.type === "ImportDeclaration") {
+        esm = true;
+      }
+    }
+    return esm || depth > 0;
+  };
+  if (!collect(entry, 0)) return null;
+  return [...names].filter((name) => /^[A-Za-z_$][\w$]*$/.test(name)).sort();
+}
+
+// src/islands-package-references.ts
+import fs2 from "fs";
+import path2 from "path";
+import { parseAst as parseAst2 } from "rolldown/parseAst";
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function parse(code, file) {
+  const extension = path2.extname(file).slice(1);
+  const lang = extension === "ts" || extension === "mts" || extension === "cts" ? "ts" : "tsx";
+  try {
+    return parseAst2(code, { lang });
+  } catch {
+    return null;
+  }
+}
 function walk(node, visit, parent = null) {
   if (!node || typeof node !== "object") return;
   if (Array.isArray(node)) {
@@ -355,7 +788,7 @@ function walk(node, visit, parent = null) {
     if (value && typeof value === "object") walk(value, visit, current);
   }
 }
-function namespaceMembers(program, local, declaration) {
+function namespaceMembers2(program, local, declaration) {
   const members = /* @__PURE__ */ new Set();
   let opaque = false;
   walk(program, (node, parent) => {
@@ -394,9 +827,18 @@ function findFarmPackageClientImports(code, file, isClientPackage) {
     for (const binding of specifiers) {
       if (binding.type === "ImportDefaultSpecifier") entry.defaultLocal = binding.local.name;
       else if (binding.type === "ImportNamespaceSpecifier") {
-        const members = namespaceMembers(program, binding.local.name, node);
+        const read = namespaceMembers2(program, binding.local.name, node);
+        const members = read ?? listFarmPackageExports(file, specifier);
         if (!members || members.some((member) => !IDENTIFIER.test(member))) supported = false;
-        else entry.namespace = { local: binding.local.name, members };
+        else if (read) entry.namespace = { local: binding.local.name, members };
+        else {
+          const component = (name) => name === "default" || /^[A-Z]/.test(name);
+          entry.namespace = {
+            local: binding.local.name,
+            members: members.filter(component),
+            values: members.filter((name) => !component(name))
+          };
+        }
       } else {
         const imported = binding.imported?.type === "Identifier" ? binding.imported.name : binding.imported?.value;
         if (typeof imported !== "string" || !IDENTIFIER.test(imported)) supported = false;
@@ -416,7 +858,7 @@ function farmPackageClientImportExports(entry) {
 }
 function farmPackageClientReferencePath(root, specifier, exportName) {
   const directory = specifier.replace(/^@/, "").replace(/[^A-Za-z0-9._-]/g, "+");
-  return path.join(root, ".farm", "client-references", directory, `${exportName}.tsx`);
+  return path2.join(root, ".farm", "client-references", directory, `${exportName}.tsx`);
 }
 function ensureFarmPackageClientReference(root, specifier, exportName) {
   const file = farmPackageClientReferencePath(root, specifier, exportName);
@@ -428,12 +870,12 @@ function ensureFarmPackageClientReference(root, specifier, exportName) {
   ].join("\n");
   let current = null;
   try {
-    current = fs.readFileSync(file, "utf8");
+    current = fs2.readFileSync(file, "utf8");
   } catch {
   }
   if (current !== source) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, source);
+    fs2.mkdirSync(path2.dirname(file), { recursive: true });
+    fs2.writeFileSync(file, source);
   }
   return file;
 }
@@ -460,6 +902,11 @@ function rewriteFarmPackageClientImports(options) {
         lines.push(`import { ${member} as ${local} } from ${reference(entry.specifier, member)};`);
         fields.push(`${member}: ${local}`);
       }
+      if (entry.namespace.values?.length) {
+        const local = `__farm_package_values_${next++}__`;
+        lines.push(`import * as ${local} from ${JSON.stringify(entry.specifier)};`);
+        for (const value of entry.namespace.values) fields.push(`${value}: ${local}.${value}`);
+      }
       lines.push(`const ${entry.namespace.local} = Object.freeze({ ${fields.join(", ")} });`);
     }
     output = output.slice(0, entry.start) + lines.join("\n") + output.slice(entry.end);
@@ -468,16 +915,16 @@ function rewriteFarmPackageClientImports(options) {
 }
 
 // src/utils/client-component.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/package-client-boundary-cache.ts
 import { AsyncLocalStorage } from "async_hooks";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var SCHEMA_VERSION = 1;
-var NODE_MODULES_SEGMENT = `${path2.sep}node_modules${path2.sep}`;
+var NODE_MODULES_SEGMENT = `${path3.sep}node_modules${path3.sep}`;
 var PackageInspectionTrace = class {
   constructor() {
     this.files = /* @__PURE__ */ new Set();
@@ -487,7 +934,7 @@ var PackageInspectionTrace = class {
   }
   visit(file) {
     this.files.add(file);
-    const directory = path2.dirname(file);
+    const directory = path3.dirname(file);
     if (!this.directoryStamps.has(directory)) {
       this.directoryStamps.set(directory, stampPackagePath(directory, "directory"));
     }
@@ -514,9 +961,9 @@ var PackageInspectionTrace = class {
   }
 };
 function stampPackagePath(target, kind) {
-  if (!`${target}${path2.sep}`.includes(NODE_MODULES_SEGMENT)) return void 0;
+  if (!`${target}${path3.sep}`.includes(NODE_MODULES_SEGMENT)) return void 0;
   try {
-    const stat = fs2.statSync(target, { throwIfNoEntry: false });
+    const stat = fs3.statSync(target, { throwIfNoEntry: false });
     if (!stat || (kind === "file" ? !stat.isFile() : !stat.isDirectory())) return void 0;
     return [target, stat.size, stat.mtimeMs, stat.ctimeMs];
   } catch {
@@ -600,11 +1047,11 @@ var PackageClientBoundaryCache = class {
     });
     const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
     try {
-      await fs2.promises.mkdir(path2.dirname(file), { recursive: true });
-      await fs2.promises.writeFile(temporary, contents);
-      await fs2.promises.rename(temporary, file);
+      await fs3.promises.mkdir(path3.dirname(file), { recursive: true });
+      await fs3.promises.writeFile(temporary, contents);
+      await fs3.promises.rename(temporary, file);
     } catch {
-      await fs2.promises.rm(temporary, { force: true }).catch(() => {
+      await fs3.promises.rm(temporary, { force: true }).catch(() => {
       });
     }
   }
@@ -638,7 +1085,7 @@ var PackageClientBoundaryCache = class {
 function readStoredCache(file) {
   let value;
   try {
-    value = JSON.parse(fs2.readFileSync(file, "utf8"));
+    value = JSON.parse(fs3.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -659,7 +1106,7 @@ 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" && path2.isAbsolute(value[0]) && value.slice(1).every((part) => typeof part === "number" && Number.isFinite(part));
+  return Array.isArray(value) && value.length === 4 && typeof value[0] === "string" && path3.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);
@@ -667,7 +1114,7 @@ function isPathIndexList(value, 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" && path2.isAbsolute(file)) && typeof isClientComponent === "boolean" && typeof shouldHydrate === "boolean" && (islandStrategy === null || isFarmIslandStrategy(islandStrategy)) && Object.keys(value.result).length === 3;
+  return isPathIndexList(value.files, pathCount) && isPathIndexList(value.directories, pathCount) && Array.isArray(value.stops) && value.stops.every((file) => typeof file === "string" && path3.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() {
@@ -684,11 +1131,11 @@ function getPackageClientBoundaryCache() {
   return getStorage().getStore();
 }
 async function withPackageClientBoundaryCache(operation) {
-  const cache2 = new PackageClientBoundaryCache();
+  const cache3 = new PackageClientBoundaryCache();
   try {
-    return await getStorage().run(cache2, operation);
+    return await getStorage().run(cache3, operation);
   } finally {
-    await cache2.persist();
+    await cache3.persist();
   }
 }
 function usePackageClientBoundaryCacheFile(file) {
@@ -698,10 +1145,10 @@ function usePackageClientBoundaryCacheFile(file) {
 // src/utils/client-component.ts
 function readIfExists(filePath) {
   try {
-    if (!filePath || !fs3.existsSync(filePath)) {
+    if (!filePath || !fs4.existsSync(filePath)) {
       return null;
     }
-    return fs3.readFileSync(filePath, "utf-8");
+    return fs4.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -720,21 +1167,21 @@ function resolveModuleSourcePath(modulePath, root) {
     }
     if (modulePath.startsWith("/@fs/")) {
       const fsPath = withoutQuery.slice("/@fs/".length);
-      candidates.add(path3.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
+      candidates.add(path4.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
     }
   }
   if (root && modulePath) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path3.join(root, normalized));
-    candidates.add(path3.resolve(root, normalized));
+    candidates.add(path4.join(root, normalized));
+    candidates.add(path4.resolve(root, normalized));
   }
   if (withoutQuery?.startsWith("/src/")) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path3.join(process.cwd(), normalized));
-    candidates.add(path3.resolve(process.cwd(), normalized));
+    candidates.add(path4.join(process.cwd(), normalized));
+    candidates.add(path4.resolve(process.cwd(), normalized));
   }
   for (const candidate of candidates) {
-    if (fs3.existsSync(candidate)) {
+    if (fs4.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -751,8 +1198,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 ? path3.resolve(benchmarkRoot) : null;
-  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path3.sep}`));
+  const resolvedBenchmarkRoot = benchmarkRoot ? path4.resolve(benchmarkRoot) : null;
+  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path4.sep}`));
   return isBenchmarkFixture && Number.isSafeInteger(benchmarkLimit) && benchmarkLimit > FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES ? benchmarkLimit : FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES;
 }
 var RESOLVABLE_SOURCE_EXTENSIONS = [
@@ -807,8 +1254,8 @@ function hasHydrateExport(content) {
   for (const match of content.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
     for (const specifier of match[1].split(",")) {
       const parts = specifier.trim().split(/\s+as\s+/);
-      const exportedName = (parts[1] ?? parts[0])?.trim();
-      if (exportedName === "hydrate") {
+      const exportedName2 = (parts[1] ?? parts[0])?.trim();
+      if (exportedName2 === "hydrate") {
         return true;
       }
     }
@@ -1660,7 +2107,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
   let fallbackReason;
   let fallbackHint;
   let costGuardExceeded = false;
-  const projectRoot = root ? path3.resolve(root) : void 0;
+  const projectRoot = root ? path4.resolve(root) : void 0;
   const visit = (moduleSourcePath) => {
     if (fallbackReason) return 0;
     const cached = estimates.get(moduleSourcePath);
@@ -1670,7 +2117,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
     const content = readIfExists(moduleSourcePath);
     const parsed = parseClientModuleMetadata(content, false);
     if (parsed.isClientComponent) {
-      if (projectRoot && !path3.resolve(moduleSourcePath).startsWith(`${projectRoot}${path3.sep}`)) {
+      if (projectRoot && !path4.resolve(moduleSourcePath).startsWith(`${projectRoot}${path4.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;
@@ -1703,29 +2150,39 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
       if (imported.local) {
         importedBoundaryCount = visit(importedPath);
       } else {
-        const packageMetadata = inspectPackageClientBoundary(importedPath, root, /* @__PURE__ */ new Set());
-        if (!packageMetadata.shouldHydrate) continue;
-        const references = options.packageReferences && projectRoot ? findFarmPackageClientImports(
-          content ?? "",
-          moduleSourcePath,
-          (candidate) => candidate === specifier
-        ) : [];
-        if (references.length > 0) {
+        const reactServerClientNames = options.packageReferences && projectRoot ? findFarmReactServerClientNames(content ?? "", moduleSourcePath, specifier) : null;
+        if (reactServerClientNames) {
           importedBoundaryCount = 0;
-          for (const reference of references) {
-            for (const exportName of farmPackageClientImportExports(reference)) {
-              importedBoundaryCount += visit(
-                ensureFarmPackageClientReference(projectRoot, specifier, exportName)
-              );
-            }
+          for (const exportName of reactServerClientNames) {
+            importedBoundaryCount += visit(
+              ensureFarmPackageClientReference(projectRoot, specifier, exportName)
+            );
           }
-        } else if (options.staticPackageBoundaries || options.staticPackageLeaves && rendersOnlyLeafElements(content, importedBindings.get(specifier) ?? [])) {
-          staticPackages.add(specifier);
-          continue;
         } else {
-          fallbackReason = `package client boundary ${specifier} cannot yet be isolated`;
-          fallbackHint = `Render it from a local "use client" module (a providers.tsx that renders the ${specifier} component)`;
-          return 0;
+          const packageMetadata = inspectPackageClientBoundary(importedPath, root, /* @__PURE__ */ new Set());
+          if (!packageMetadata.shouldHydrate) continue;
+          const references = options.packageReferences && projectRoot ? findFarmPackageClientImports(
+            content ?? "",
+            moduleSourcePath,
+            (candidate) => candidate === specifier
+          ) : [];
+          if (references.length > 0) {
+            importedBoundaryCount = 0;
+            for (const reference of references) {
+              for (const exportName of farmPackageClientImportExports(reference)) {
+                importedBoundaryCount += visit(
+                  ensureFarmPackageClientReference(projectRoot, specifier, exportName)
+                );
+              }
+            }
+          } else if (options.staticPackageBoundaries || options.staticPackageLeaves && rendersOnlyLeafElements(content, importedBindings.get(specifier) ?? [])) {
+            staticPackages.add(specifier);
+            continue;
+          } else {
+            fallbackReason = `package client boundary ${specifier} cannot yet be isolated`;
+            fallbackHint = `Render it from a local "use client" module (a providers.tsx that renders the ${specifier} component)`;
+            return 0;
+          }
         }
       }
       if (fallbackReason || importedBoundaryCount === 0) continue;
@@ -1818,19 +2275,19 @@ function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandE
   };
 }
 function inspectPackageClientBoundary(resolvedPath, root, visited) {
-  const cache2 = getPackageClientBoundaryCache();
-  if (!cache2 || !resolvedPath || visited.has(resolvedPath)) {
+  const cache3 = getPackageClientBoundaryCache();
+  if (!cache3 || !resolvedPath || visited.has(resolvedPath)) {
     return traversePackageClientBoundary(resolvedPath, root, visited);
   }
   const key = `${root ?? ""}\0${resolvedPath}`;
-  const cached = cache2.find(key, visited);
+  const cached = cache3.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));
+  cache3.add(key, trace.toEntry(result));
   return result;
 }
 function traversePackageClientBoundary(resolvedPath, root, visited, trace) {
@@ -1950,7 +2407,7 @@ var ALIAS_IMPORT = /^(?:@\/|~\/|#)/;
 function warnUnresolvedAliasImport(importerPath, specifier, root) {
   if (!ALIAS_IMPORT.test(specifier) || warnedUnresolvedAliasImports.has(specifier)) return;
   warnedUnresolvedAliasImports.add(specifier);
-  const importer = root ? path3.relative(root, importerPath) : importerPath;
+  const importer = root ? path4.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".`
   );
@@ -1959,7 +2416,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 = path3.resolve(root);
+  const projectRoot = path4.resolve(root);
   let match;
   for (const alias of getProjectImportAliases(projectRoot)) {
     const captured = matchProjectImportAlias(alias, specifier);
@@ -1969,7 +2426,7 @@ function resolveProjectAliasSourcePath(specifier, root) {
   if (!match) return void 0;
   const resolved = resolveSourceCandidate(
     match.alias.targets.map(
-      (target) => path3.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+      (target) => path4.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
     )
   );
   return resolved && /\.d\.[cm]?ts$/.test(resolved) ? null : resolved;
@@ -1984,7 +2441,7 @@ function matchProjectImportAlias(alias, specifier) {
 function getProjectImportAliases(projectRoot) {
   const stamp = PROJECT_ALIAS_FILES.map((file) => {
     try {
-      return String(fs3.statSync(path3.join(projectRoot, file)).mtimeMs);
+      return String(fs4.statSync(path4.join(projectRoot, file)).mtimeMs);
     } catch {
       return "-";
     }
@@ -2002,7 +2459,7 @@ function getProjectImportAliases(projectRoot) {
       prefix: "@/",
       suffix: "",
       wildcard: true,
-      targets: [path3.join(projectRoot, sourceDir, "*")]
+      targets: [path4.join(projectRoot, sourceDir, "*")]
     });
   }
   projectImportAliasCache.set(projectRoot, { stamp: cacheStamp, aliases });
@@ -2010,8 +2467,8 @@ function getProjectImportAliases(projectRoot) {
 }
 function readTsconfigPathAliases(projectRoot) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
-    const configPath = path3.join(projectRoot, name);
-    if (!fs3.existsSync(configPath)) continue;
+    const configPath = path4.join(projectRoot, name);
+    if (!fs4.existsSync(configPath)) continue;
     const resolved = readTsconfigPaths(configPath, /* @__PURE__ */ new Set());
     if (!resolved?.paths) return [];
     const base = resolved.baseUrl ?? resolved.pathsDirectory;
@@ -2023,7 +2480,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) => path3.resolve(base, target))
+          targets: targets.filter((target) => typeof target === "string").map((target) => path4.resolve(base, target))
         }
       ];
     });
@@ -2035,27 +2492,27 @@ function readTsconfigPaths(configPath, visited) {
   visited.add(configPath);
   const config = readJsonWithComments(configPath);
   if (!config) return null;
-  const directory = path3.dirname(configPath);
+  const directory = path4.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 = path3.resolve(
+    const parentPath = path4.resolve(
       directory,
       parent.endsWith(".json") ? parent : `${parent}.json`
     );
     inherited = readTsconfigPaths(parentPath, visited) ?? inherited;
   }
   const options = config.compilerOptions ?? {};
-  const baseUrl = typeof options.baseUrl === "string" ? path3.resolve(directory, options.baseUrl) : inherited?.baseUrl;
+  const baseUrl = typeof options.baseUrl === "string" ? path4.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(path3.join(projectRoot, "package.json"))?.imports;
+  const imports = readPackageJson(path4.join(projectRoot, "package.json"))?.imports;
   if (!imports || typeof imports !== "object") return [];
   return Object.entries(imports).flatMap(([pattern, value]) => {
     const target = resolveConditionalExportTarget(value);
@@ -2066,7 +2523,7 @@ function readPackageImportAliases(projectRoot) {
         prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
         suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
         wildcard: wildcardIndex !== -1,
-        targets: [path3.resolve(projectRoot, target)]
+        targets: [path4.resolve(projectRoot, target)]
       }
     ];
   });
@@ -2074,7 +2531,7 @@ function readPackageImportAliases(projectRoot) {
 function readJsonWithComments(filePath) {
   let source;
   try {
-    source = fs3.readFileSync(filePath, "utf8");
+    source = fs4.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -2112,7 +2569,7 @@ function resolveImportedModuleSourcePath(importerPath, specifier, root) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
   }
   const candidates = /* @__PURE__ */ new Set();
-  const basePath = specifier.startsWith(".") ? path3.resolve(path3.dirname(importerPath), specifier) : root ? path3.resolve(root, specifier.replace(/^\/+/, "")) : path3.resolve(specifier);
+  const basePath = specifier.startsWith(".") ? path4.resolve(path4.dirname(importerPath), specifier) : root ? path4.resolve(root, specifier.replace(/^\/+/, "")) : path4.resolve(specifier);
   candidates.add(basePath);
   return resolveSourceCandidate(candidates);
 }
@@ -2120,47 +2577,47 @@ function resolvePackageModuleSourcePath(importerPath, specifier, root) {
   const packageParts = specifier.split("/");
   const packageName = specifier.startsWith("@") ? packageParts.slice(0, 2).join("/") : packageParts[0];
   const packageSubpath = packageParts.slice(packageName.startsWith("@") ? 2 : 1).join("/");
-  const packageDirectory = findPackageDirectory(importerPath, packageName, root);
+  const packageDirectory = findPackageDirectory2(importerPath, packageName, root);
   if (!packageDirectory) return null;
-  const packageJsonPath = path3.join(packageDirectory, "package.json");
+  const packageJsonPath = path4.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(path3.resolve(packageDirectory, exportTarget));
+    candidates.add(path4.resolve(packageDirectory, exportTarget));
   }
   if (packageSubpath) {
-    candidates.add(path3.join(packageDirectory, packageSubpath));
+    candidates.add(path4.join(packageDirectory, packageSubpath));
   } else {
     for (const entry of [packageJson?.browser, packageJson?.module, packageJson?.main]) {
-      if (typeof entry === "string") candidates.add(path3.resolve(packageDirectory, entry));
+      if (typeof entry === "string") candidates.add(path4.resolve(packageDirectory, entry));
     }
-    candidates.add(path3.join(packageDirectory, "index"));
+    candidates.add(path4.join(packageDirectory, "index"));
   }
   return resolveSourceCandidate(candidates);
 }
-function findPackageDirectory(importerPath, packageName, root) {
+function findPackageDirectory2(importerPath, packageName, root) {
   const searchRoots = /* @__PURE__ */ new Set();
-  let current = path3.dirname(importerPath);
+  let current = path4.dirname(importerPath);
   while (true) {
     searchRoots.add(current);
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   if (root) {
-    current = path3.resolve(root);
+    current = path4.resolve(root);
     while (true) {
       searchRoots.add(current);
-      const parent = path3.dirname(current);
+      const parent = path4.dirname(current);
       if (parent === current) break;
       current = parent;
     }
   }
   for (const searchRoot of searchRoots) {
-    const packageDirectory = path3.join(searchRoot, "node_modules", packageName);
-    if (fs3.existsSync(path3.join(packageDirectory, "package.json"))) {
+    const packageDirectory = path4.join(searchRoot, "node_modules", packageName);
+    if (fs4.existsSync(path4.join(packageDirectory, "package.json"))) {
       return packageDirectory;
     }
   }
@@ -2168,7 +2625,7 @@ function findPackageDirectory(importerPath, packageName, root) {
 }
 function readPackageJson(packageJsonPath) {
   try {
-    return JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    return JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -2226,11 +2683,11 @@ function resolveSourceCandidate(candidates) {
   for (const candidate of candidates) {
     const paths = [candidate];
     for (const extension of RESOLVABLE_SOURCE_EXTENSIONS) {
-      paths.push(`${candidate}${extension}`, path3.join(candidate, `index${extension}`));
+      paths.push(`${candidate}${extension}`, path4.join(candidate, `index${extension}`));
     }
     for (const sourcePath of paths) {
       try {
-        if (fs3.statSync(sourcePath).isFile()) return sourcePath;
+        if (fs4.statSync(sourcePath).isFile()) return sourcePath;
       } catch {
       }
     }
@@ -2258,13 +2715,13 @@ function collectFarmClientPackageImports(directory, root) {
   const walk2 = (current) => {
     let entries;
     try {
-      entries = fs3.readdirSync(current, { withFileTypes: true });
+      entries = fs4.readdirSync(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.isDirectory()) continue;
-      const file = path3.join(current, entry.name);
+      const file = path4.join(current, entry.name);
       if (entry.isDirectory()) {
         if (!CLIENT_PACKAGE_SCAN_SKIP.has(entry.name)) walk2(file);
         continue;
@@ -2284,15 +2741,78 @@ function collectFarmClientPackageImports(directory, root) {
   walk2(directory);
   return [...found].sort();
 }
+var clientReachableModules = /* @__PURE__ */ new Map();
+function invalidateFarmClientReachableModules() {
+  clientReachableModules.clear();
+}
+function getFarmClientReachableModules(directory, root) {
+  const key = `${path4.resolve(root)}\0${path4.resolve(directory)}`;
+  const cached = clientReachableModules.get(key);
+  if (cached) return cached;
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  const walk2 = (current) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const file = path4.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !CLIENT_PACKAGE_SCAN_SKIP.has(entry.name)) walk2(file);
+      } else if (CLIENT_PACKAGE_SCAN_EXTENSIONS.test(entry.name) && !entry.name.endsWith(".d.ts") && hasUseClientDirective(readIfExists(file))) {
+        queue.push(file);
+      }
+    }
+  };
+  walk2(directory);
+  while (queue.length > 0) {
+    const file = path4.resolve(queue.pop());
+    if (reachable.has(file)) continue;
+    reachable.add(file);
+    for (const specifier of getImportSpecifiers(readIfExists(file))) {
+      const imported = resolveImportedModule(file, specifier, root);
+      if (imported.local && imported.path && !reachable.has(path4.resolve(imported.path))) {
+        queue.push(imported.path);
+      }
+    }
+  }
+  clientReachableModules.set(key, reachable);
+  return reachable;
+}
+function resolveFarmClientOptimizeDeps(directory, root) {
+  const importer = path4.join(path4.resolve(root), "package.json");
+  const include = /* @__PURE__ */ new Set();
+  const exclude = /* @__PURE__ */ new Set();
+  for (const specifier of collectFarmClientPackageImports(directory, root)) {
+    const manifest = findFarmPackageManifest(importer, specifier);
+    if (manifest && farmReactServerBuildReachesClientModules(importer, manifest.name)) {
+      exclude.add(manifest.name);
+      for (const dependency of manifest.dependencies) {
+        include.add(`${manifest.name} > ${dependency}`);
+      }
+    } else {
+      include.add(specifier);
+    }
+  }
+  for (const name of exclude) {
+    for (const entry of include) {
+      if (entry === name || entry.startsWith(`${name}/`)) include.delete(entry);
+    }
+  }
+  return { include: [...include].sort(), exclude: [...exclude].sort() };
+}
 
 // src/routing/route-manager.ts
 import { realpathSync } from "fs";
-import path5 from "path";
+import path6 from "path";
 
 // src/static-metadata-image.ts
 import { createHash } from "crypto";
 import { readFile } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 import { imageSize } from "image-size";
 var STATIC_METADATA_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp"];
 var CONTENT_TYPES = {
@@ -2333,13 +2853,13 @@ async function inspectStaticMetadataImage(filePath) {
   };
 }
 function getStaticMetadataImageAltPath(filePath) {
-  return path4.join(
-    path4.dirname(filePath),
-    `${path4.basename(filePath, path4.extname(filePath))}.alt.txt`
+  return path5.join(
+    path5.dirname(filePath),
+    `${path5.basename(filePath, path5.extname(filePath))}.alt.txt`
   );
 }
 function getStaticMetadataImageExtension(filePath) {
-  const extension = path4.extname(filePath).slice(1).toLowerCase();
+  const extension = path5.extname(filePath).slice(1).toLowerCase();
   return STATIC_METADATA_IMAGE_EXTENSIONS.includes(extension) ? extension : null;
 }
 async function readAltText(filePath) {
@@ -2667,14 +3187,14 @@ var RouteManager = class {
    * Requests still fetch route data, but never inspect component source.
    */
   generateClientManifest(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path5.resolve(projectRoot);
+    const normalizedProjectRoot = path6.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 (path5.isAbsolute(absolutePath)) {
+      if (path6.isAbsolute(absolutePath)) {
         const normalized = absolutePath.replace(/\\/g, "/");
         return normalized.startsWith("/") ? `/@fs${normalized}` : `/@fs/${normalized}`;
       }
@@ -2854,7 +3374,7 @@ var RouteManager = class {
     for (const { metadata } of [...layoutEntries, ...routeEntries]) {
       if (!metadata.hasIsolatedClientBoundaries && !metadata.serverTreeLayout) continue;
       for (const boundary of metadata.isolatedBoundaries) {
-        isolatedClientBoundaryModules.add(path5.resolve(boundary.modulePath));
+        isolatedClientBoundaryModules.add(path6.resolve(boundary.modulePath));
       }
     }
     const islandsErrors = [
@@ -2905,7 +3425,7 @@ var RouteManager = class {
   }
   /** @internal Client modules selected by the compiled hydration ownership plan. */
   getIsolatedClientBoundaryModules(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path5.resolve(projectRoot);
+    const normalizedProjectRoot = path6.resolve(projectRoot);
     this.generateClientManifest(normalizedProjectRoot);
     return this.clientManifestCache?.isolatedClientBoundaryModules ?? /* @__PURE__ */ new Set();
   }
@@ -2914,7 +3434,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(path5.resolve(projectRoot));
+    this.generateClientManifest(path6.resolve(projectRoot));
     return this.clientManifestCache?.islandsErrors ?? [];
   }
   /**
@@ -3045,19 +3565,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) => path5.join(appDir, file)).join(" and ")}.`
+          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path6.join(appDir, file)).join(" and ")}.`
         );
       }
       if (markdownFiles.length > 1) {
         throw new Error(
-          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path5.join(appDir, file)).join(" and ")}.`
+          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path6.join(appDir, file)).join(" and ")}.`
         );
       }
       const componentFile = componentFiles[0];
       const markdownFile = markdownFiles[0];
       const primaryFile = componentFile || markdownFile;
       if (!primaryFile) continue;
-      const modulePath = path5.join(appDir, primaryFile);
+      const modulePath = path6.join(appDir, primaryFile);
       const existing = this.routes.get(pattern);
       if (existing?.sourceRoot === source.root) {
         throw new Error(
@@ -3068,7 +3588,7 @@ var RouteManager = class {
         route: group.route,
         modulePath,
         ...markdownFile ? {
-          markdownSourcePath: path5.join(appDir, markdownFile)
+          markdownSourcePath: path6.join(appDir, markdownFile)
         } : {},
         pattern,
         ...getPageDirectoryField(group.route, pattern),
@@ -3083,7 +3603,7 @@ var RouteManager = class {
     ]) {
       for (const file of files) {
         const route = parseRoutePath(file);
-        const modulePath = path5.join(appDir, file);
+        const modulePath = path6.join(appDir, file);
         const pattern = createRouteDirectoryPattern(route);
         const existing = target.get(pattern);
         if (existing?.sourceRoot === source.root) {
@@ -3103,7 +3623,7 @@ var RouteManager = class {
     for (const file of [...pageFiles, ...slotDefaultFiles]) {
       const slot = parseRouteSlotFile(file);
       if (!slot) continue;
-      const modulePath = path5.join(appDir, file);
+      const modulePath = path6.join(appDir, file);
       const pattern = this.createRoutePattern(slot.route);
       const ownerPattern = this.createRoutePattern(slot.ownerRoute);
       const ownerDirectory = createRouteDirectoryPattern(slot.ownerRoute);
@@ -3129,11 +3649,11 @@ var RouteManager = class {
       });
     }
     for (const file of metadataImageFiles) {
-      const fileBase = path5.basename(file, path5.extname(file));
+      const fileBase = path6.basename(file, path6.extname(file));
       const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
       const fileName = kind === "twitter" ? "twitter-image" : "opengraph-image";
       const route = parseRoutePath(file);
-      const modulePath = path5.join(appDir, file);
+      const modulePath = path6.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${kind}:${pattern}`;
       const existing = this.metadataImages.get(key);
@@ -3158,11 +3678,11 @@ var RouteManager = class {
     }
     for (const file of metadataRouteFiles) {
       const descriptor = getApplicationMetadataRouteDescriptor(
-        path5.basename(file, path5.extname(file))
+        path6.basename(file, path6.extname(file))
       );
       if (!descriptor) continue;
       const route = parseRoutePath(file);
-      const modulePath = path5.join(appDir, file);
+      const modulePath = path6.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${descriptor.kind}:${pattern}`;
       const existing = this.metadataRoutes.get(key);
@@ -3573,12 +4093,12 @@ function toRealPath(filePath) {
 }
 
 // src/server/dev-styles.ts
-import * as fs4 from "fs";
-import * as path6 from "path";
+import * as fs5 from "fs";
+import * as path7 from "path";
 function resolveDevGlobalStylesheetHref(root, srcDir = "src") {
-  const file = path6.join(root, srcDir, "app", "globals.css");
-  if (!fs4.existsSync(file)) return void 0;
-  return `/${path6.relative(root, file).split(path6.sep).join("/")}`;
+  const file = path7.join(root, srcDir, "app", "globals.css");
+  if (!fs5.existsSync(file)) return void 0;
+  return `/${path7.relative(root, file).split(path7.sep).join("/")}`;
 }
 var STYLE_EXTENSIONS = /\.(css|scss|sass|less|styl|stylus)(?:$|\?)/;
 var ALREADY_LINKED = "/src/app/globals.css";
@@ -3602,7 +4122,7 @@ function collectDevStylesheetUrls(modules, alreadyLinked = ALREADY_LINKED, optio
 import { createHash as createHash2, timingSafeEqual } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 var FONT_IMPORTS = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/font"]);
@@ -3959,7 +4479,7 @@ ${FONT_SECTION_END}
         return resource;
       }
       const bytes2 = await fetchRemoteFont(url, input.integrity);
-      return this.createSelfHostedResource(bytes2, extension, path7.basename(url.pathname));
+      return this.createSelfHostedResource(bytes2, extension, path8.basename(url.pathname));
     }
     if (input.source.startsWith("/")) {
       return this.createPublicResource(input.moduleId, input.source);
@@ -3982,8 +4502,8 @@ ${FONT_SECTION_END}
     }
     return this.createSelfHostedResource(
       bytes,
-      path7.extname(resolvedPath),
-      path7.basename(resolvedPath)
+      path8.extname(resolvedPath),
+      path8.basename(resolvedPath)
     );
   }
   async createPublicResource(moduleId, source) {
@@ -3994,7 +4514,7 @@ ${FONT_SECTION_END}
       );
     }
     const publicPath = normalizePublicFontPath(source, moduleId);
-    const resolvedPath = path7.resolve(this.publicDir, `.${publicPath}`);
+    const resolvedPath = path8.resolve(this.publicDir, `.${publicPath}`);
     if (!isPathInside(this.publicDir, resolvedPath)) {
       throw fontError(moduleId, `public font path must stay inside publicDir`);
     }
@@ -4010,7 +4530,7 @@ ${FONT_SECTION_END}
         `could not read ${JSON.stringify(source)} from publicDir: ${error.message}`
       );
     }
-    const extension = path7.extname(resolvedPath).toLowerCase();
+    const extension = path8.extname(resolvedPath).toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
     const resource = {
       extension,
@@ -4025,7 +4545,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(path7.basename(fileName, extension)) || "font";
+    const baseName = sanitizeFileName(path8.basename(fileName, extension)) || "font";
     const outputFileName = `assets/fonts/${baseName}-h${hash}${normalizedExtension}`;
     const key = `${hash}${normalizedExtension}`;
     const existing = this.resources.get(key);
@@ -4378,24 +4898,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 path7.resolve(path7.dirname(importer), source);
-  if (path7.isAbsolute(source)) {
+  if (source.startsWith(".")) return path8.resolve(path8.dirname(importer), source);
+  if (path8.isAbsolute(source)) {
     return source;
   }
   try {
     return createRequire(pathToFileURL(importer)).resolve(source);
   } catch {
     const segments = source.replace(/\\/g, "/").split("/");
-    if (segments.includes("..")) return path7.resolve(root, source);
-    let current = path7.dirname(importer);
-    const filesystemRoot = path7.parse(current).root;
+    if (segments.includes("..")) return path8.resolve(root, source);
+    let current = path8.dirname(importer);
+    const filesystemRoot = path8.parse(current).root;
     while (true) {
-      const candidate = path7.join(current, "node_modules", ...segments);
+      const candidate = path8.join(current, "node_modules", ...segments);
       if (existsSync2(candidate)) return candidate;
       if (current === filesystemRoot) break;
-      current = path7.dirname(current);
+      current = path8.dirname(current);
     }
-    return path7.resolve(root, "node_modules", ...segments);
+    return path8.resolve(root, "node_modules", ...segments);
   }
 }
 function replaceFontSection(css, section) {
@@ -4428,11 +4948,11 @@ function getGlobalMap(key) {
   return created;
 }
 function normalizeRoot(root) {
-  return path7.resolve(root).replace(/\\/g, "/");
+  return path8.resolve(root).replace(/\\/g, "/");
 }
 function normalizePublicDir(root, publicDir) {
   if (publicDir === false || publicDir === "") return false;
-  return path7.resolve(root, publicDir || "public");
+  return path8.resolve(root, publicDir || "public");
 }
 function normalizePublicFontPath(source, moduleId) {
   if (source.includes("?") || source.includes("#")) {
@@ -4441,8 +4961,8 @@ function normalizePublicFontPath(source, moduleId) {
   return `/${source.replace(/\\/g, "/").replace(/^\/+/, "")}`;
 }
 function isPathInside(parent, child) {
-  const relative3 = path7.relative(parent, child);
-  return relative3 === "" || !relative3.startsWith("..") && !path7.isAbsolute(relative3);
+  const relative3 = path8.relative(parent, child);
+  return relative3 === "" || !relative3.startsWith("..") && !path8.isAbsolute(relative3);
 }
 function normalizeBasePath(value) {
   if (!value || value === "/") return "/";
@@ -4452,7 +4972,7 @@ function joinBasePath(basePath, value) {
   return basePath === "/" ? value : `${basePath.replace(/\/$/, "")}${value}`;
 }
 function extensionFromPath(pathname) {
-  const extension = path7.extname(pathname).toLowerCase();
+  const extension = path8.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`);
   }
@@ -4592,7 +5112,7 @@ function fontError(id, message) {
 }
 
 // src/integration-provider-build.ts
-import path8 from "path";
+import path9 from "path";
 function isRendererCompiledComponent(moduleId, rendererComponentExtensions) {
   const lowered = moduleId.toLowerCase();
   return rendererComponentExtensions.some((extension) => lowered.endsWith(extension.toLowerCase()));
@@ -4694,14 +5214,14 @@ function generateFarmIntegrationProviderServerModules(providers, root, rendererC
 }
 function resolveProviderModule(moduleId, root) {
   if (!moduleId.startsWith(".")) return moduleId;
-  return toViteModuleId(path8.resolve(root, moduleId), root);
+  return toViteModuleId(path9.resolve(root, moduleId), root);
 }
 
 // src/island-inference.ts
-import fs5 from "fs";
-import path9 from "path";
+import fs6 from "fs";
+import path10 from "path";
 import { inferStrategy } from "@farm.js/islx/compiler";
-import { parseAst as parseAst2 } from "rolldown/parseAst";
+import { parseAst as parseAst3 } from "rolldown/parseAst";
 var PARSE_LANGS = /* @__PURE__ */ new Map([
   [".tsx", "tsx"],
   [".ts", "ts"],
@@ -4710,29 +5230,29 @@ var PARSE_LANGS = /* @__PURE__ */ new Map([
   [".mjs", "js"]
 ]);
 function parseFarmIslandSource(file, code) {
-  const lang = PARSE_LANGS.get(path9.extname(file));
-  if (!lang) throw new Error(`${path9.basename(file)} is not a script module`);
-  return parseAst2(code, { lang });
+  const lang = PARSE_LANGS.get(path10.extname(file));
+  if (!lang) throw new Error(`${path10.basename(file)} is not a script module`);
+  return parseAst3(code, { lang });
 }
 function modifiedAt(file) {
   try {
-    return fs5.statSync(file).mtimeMs;
+    return fs6.statSync(file).mtimeMs;
   } catch {
     return -1;
   }
 }
 var inferences = /* @__PURE__ */ new Map();
 function inferFarmIslandStrategy(filePath, root) {
-  const file = path9.resolve(filePath);
+  const file = path10.resolve(filePath);
   const cached = inferences.get(file);
   if (cached && cached.stamps.every(([read, stamp]) => modifiedAt(read) === stamp)) {
     return cached.result;
   }
   let code;
   try {
-    code = fs5.readFileSync(file, "utf8");
+    code = fs6.readFileSync(file, "utf8");
   } catch {
-    return { strategy: null, files: [file], reason: `${path9.basename(file)} could not be read` };
+    return { strategy: null, files: [file], reason: `${path10.basename(file)} could not be read` };
   }
   const result = inferStrategy(file, code, {
     parse: parseFarmIslandSource,
@@ -4756,7 +5276,7 @@ function inferFarmRouteRootStrategy(owners, root) {
       return {
         strategy: null,
         files,
-        reason: `${path9.basename(owner)}: its client components could not be listed`
+        reason: `${path10.basename(owner)}: its client components could not be listed`
       };
     }
     modules.push(...rendered);
@@ -4764,7 +5284,7 @@ function inferFarmRouteRootStrategy(owners, root) {
   for (const module of modules) {
     let source = null;
     try {
-      source = fs5.readFileSync(module, "utf8");
+      source = fs6.readFileSync(module, "utf8");
     } catch {
     }
     if (getIslandStrategyExport(source) !== null) return { strategy: null, files, declared: true };
@@ -4800,8 +5320,8 @@ function resolveFarmRouteRootStrategy(route, page, layouts, root, islandsMode) {
 }
 
 // src/client-plugin-build.ts
-import fs6 from "fs";
-import path10 from "path";
+import fs7 from "fs";
+import path11 from "path";
 var CLIENT_KEYS = [
   "public",
   "setup",
@@ -4821,10 +5341,10 @@ var MOBILE_SHELL_CLIENT_REGISTRATION = `  {
   }`;
 var APP_CLIENT_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
 function resolveFarmAppClientEntry(root = process.cwd(), srcDir = "src") {
-  const sourceRoot = path10.resolve(root, srcDir);
+  const sourceRoot = path11.resolve(root, srcDir);
   for (const extension of APP_CLIENT_EXTENSIONS) {
-    const candidate = path10.join(sourceRoot, `client.${extension}`);
-    if (fs6.existsSync(candidate) && fs6.statSync(candidate).isFile()) return candidate;
+    const candidate = path11.join(sourceRoot, `client.${extension}`);
+    if (fs7.existsSync(candidate) && fs7.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -5066,27 +5586,27 @@ function isArrayIndex(key) {
 }
 
 // src/server/renderer.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as https from "https";
 import { isIP } from "net";
-import * as path13 from "path";
+import * as path14 from "path";
 import * as tls from "tls";
 import { Readable, Writable } from "stream";
 
 // src/not-found.ts
-import fs7 from "fs";
-import path11 from "path";
+import fs8 from "fs";
+import path12 from "path";
 function resolveFarmNotFoundComponentPath(config, appDirs) {
   const extensions = getFarmRendererComponentExtensions(config.renderer);
   const configuredPath = config.notFound?.component?.trim();
   if (configuredPath) {
-    const componentPath = path11.isAbsolute(configuredPath) ? path11.normalize(configuredPath) : path11.resolve(config.root, configuredPath);
+    const componentPath = path12.isAbsolute(configuredPath) ? path12.normalize(configuredPath) : path12.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 (!fs7.existsSync(componentPath) || !fs7.statSync(componentPath).isFile()) {
+    if (!fs8.existsSync(componentPath) || !fs8.statSync(componentPath).isFile()) {
       throw new Error(`notFound.component was not found: ${componentPath}`);
     }
     return componentPath;
@@ -5094,8 +5614,8 @@ function resolveFarmNotFoundComponentPath(config, appDirs) {
   let discoveredPath = null;
   for (const appDir of appDirs) {
     for (const extension of extensions) {
-      const candidate = path11.join(appDir, `not-found${extension}`);
-      if (fs7.existsSync(candidate) && fs7.statSync(candidate).isFile()) {
+      const candidate = path12.join(appDir, `not-found${extension}`);
+      if (fs8.existsSync(candidate) && fs8.statSync(candidate).isFile()) {
         discoveredPath = candidate;
         break;
       }
@@ -5291,8 +5811,8 @@ body {
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/server/error-diagnostics.ts
-import * as fs8 from "fs";
-import * as path12 from "path";
+import * as fs9 from "fs";
+import * as path13 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;
@@ -5300,8 +5820,8 @@ function redactErrorText(value) {
   return value.replace(BEARER_PATTERN, "$1[REDACTED]").replace(SECRET_VALUE_PATTERN, "$1=[REDACTED]");
 }
 function isPathInsideRoot(root, filePath) {
-  const relative3 = path12.relative(root, filePath);
-  return relative3 === "" || !relative3.startsWith("..") && !path12.isAbsolute(relative3);
+  const relative3 = path13.relative(root, filePath);
+  return relative3 === "" || !relative3.startsWith("..") && !path13.isAbsolute(relative3);
 }
 function normalizeStackPath(value) {
   const withoutQuery = value.replace(/[?#].*$/, "");
@@ -5318,13 +5838,13 @@ function findStackLocation(stack, root) {
     );
     if (!match) continue;
     const candidate = normalizeStackPath(match[1]);
-    if (!candidate || candidate.includes(`${path12.sep}node_modules${path12.sep}`)) continue;
-    const absolutePath = path12.resolve(candidate);
-    if (!isPathInsideRoot(root, absolutePath) || !fs8.existsSync(absolutePath)) continue;
-    const relativePath = path12.relative(root, absolutePath).split(path12.sep).join("/");
+    if (!candidate || candidate.includes(`${path13.sep}node_modules${path13.sep}`)) continue;
+    const absolutePath = path13.resolve(candidate);
+    if (!isPathInsideRoot(root, absolutePath) || !fs9.existsSync(absolutePath)) continue;
+    const relativePath = path13.relative(root, absolutePath).split(path13.sep).join("/");
     return {
       absolutePath,
-      displayPath: relativePath || path12.basename(absolutePath),
+      displayPath: relativePath || path13.basename(absolutePath),
       line: Number(match[2]),
       column: Number(match[3])
     };
@@ -5333,7 +5853,7 @@ function findStackLocation(stack, root) {
 }
 function createSourceFrame(location) {
   try {
-    const sourceLines = fs8.readFileSync(location.absolutePath, "utf8").split(/\r?\n/);
+    const sourceLines = fs9.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);
@@ -5356,13 +5876,13 @@ function createSourceFrame(location) {
   }
 }
 function sanitizeStack(stack, root) {
-  const normalizedRoot = path12.resolve(root);
+  const normalizedRoot = path13.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, path12.resolve(root));
+  const location = findStackLocation(rawStack, path13.resolve(root));
   return {
     name: redactErrorText(normalizedError.name || "Error"),
     message: redactErrorText(normalizedError.message || "Unknown server rendering error"),
@@ -5631,7 +6151,7 @@ function createRouteStateProps(input) {
 function readAppPackageIdentity(root) {
   try {
     return JSON.parse(
-      fs9.readFileSync(path13.join(root || process.cwd(), "package.json"), "utf8")
+      fs10.readFileSync(path14.join(root || process.cwd(), "package.json"), "utf8")
     );
   } catch {
     return {};
@@ -5938,10 +6458,10 @@ var ServerRenderer = class {
    * Load SSG manifest from build output
    */
   loadSSGManifest() {
-    const manifestPath = path13.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
+    const manifestPath = path14.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
     let content;
     try {
-      content = fs9.readFileSync(manifestPath, "utf-8");
+      content = fs10.readFileSync(manifestPath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
@@ -6160,10 +6680,10 @@ var ServerRenderer = class {
       return true;
     }
     try {
-      const htmlPath = page.urlPath === "/" ? path13.join(this.config.root, this.config.outDir, "client", "index.html") : path13.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
-      if (fs9.existsSync(htmlPath)) {
-        const stat = fs9.statSync(htmlPath);
-        const html = fs9.readFileSync(htmlPath, "utf-8");
+      const htmlPath = page.urlPath === "/" ? path14.join(this.config.root, this.config.outDir, "client", "index.html") : path14.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
+      if (fs10.existsSync(htmlPath)) {
+        const stat = fs10.statSync(htmlPath);
+        const html = fs10.readFileSync(htmlPath, "utf-8");
         await this.cacheSSGPage(page, html, {
           document: true,
           createdAt: stat.mtimeMs
@@ -6926,11 +7446,11 @@ var ServerRenderer = class {
         if (isFarmIntegrationProviderComponentReference(provider.component)) {
           providerSourceModule = provider.component.module;
           const providerModuleId = provider.component.module.startsWith(".") ? toViteModuleId(
-            path13.resolve(this.config.root, provider.component.module),
+            path14.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(path13.resolve(this.config.root, provider.component.module)).href : provider.component.module
+            provider.component.module.startsWith(".") ? pathToFileURL2(path14.resolve(this.config.root, provider.component.module)).href : provider.component.module
           );
           ProviderComponent = providerModule[provider.component.export || "default"];
         } else if (typeof provider.component === "function") {
@@ -7197,7 +7717,7 @@ var ServerRenderer = class {
               logger.warn(`Could not read metadata for ${pattern} in sitemap.xml: ${error}`);
               return void 0;
             }),
-            fs9.promises.stat(route.modulePath).catch(() => void 0)
+            fs10.promises.stat(route.modulePath).catch(() => void 0)
           ]);
           return { pattern, module, lastModified: stat?.mtime.toISOString() };
         })
@@ -7448,7 +7968,7 @@ var ServerRenderer = class {
       res.end();
       return;
     }
-    res.write(await fs9.promises.readFile(image.modulePath));
+    res.write(await fs10.promises.readFile(image.modulePath));
     res.end();
   }
   async renderRouteErrorBoundary(req, res, options) {
@@ -8269,13 +8789,13 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       res.end(createFarmMarkdownErrorBody(404, pathname, this.config.basePath || "/"));
       return;
     }
-    const appDir = path13.join(this.config.root, this.config.srcDir, "app");
+    const appDir = path14.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 = path13.join(appDir, `layout${ext}`);
-        if (fs9.existsSync(layoutPath)) {
+        const layoutPath = path14.join(appDir, `layout${ext}`);
+        if (fs10.existsSync(layoutPath)) {
           layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
           break;
         }
@@ -8488,7 +9008,7 @@ ${clientScript}
 };
 
 // src/app.ts
-import path14 from "path";
+import path15 from "path";
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -8628,7 +9148,7 @@ var FarmApp = class {
     }
     const componentExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     const rootLayoutPaths = appDirs.flatMap(
-      (appDir) => componentExtensions.map((extension) => path14.join(appDir, `layout${extension}`))
+      (appDir) => componentExtensions.map((extension) => path15.join(appDir, `layout${extension}`))
     );
     const hasRootLayout = await Promise.all(rootLayoutPaths.map((p) => fileExists(p))).then(
       (results) => results.some(Boolean)
@@ -8692,13 +9212,13 @@ function resolveFarmImageServerRuntime(images, preset) {
 }
 
 // src/app-manifest-packages.ts
-import fs10 from "fs";
-import path15 from "path";
+import fs11 from "fs";
+import path16 from "path";
 var FARM_PACKAGE = /^@(?:farm\.js|farming-labs)\/[a-z0-9._-]+$/;
 function resolveFarmAppPackages(root) {
   let manifest;
   try {
-    manifest = JSON.parse(fs10.readFileSync(path15.join(root, "package.json"), "utf8"));
+    manifest = JSON.parse(fs11.readFileSync(path16.join(root, "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -8713,13 +9233,13 @@ function resolveFarmAppPackages(root) {
     for (let dir = root; ; ) {
       try {
         const { version } = JSON.parse(
-          fs10.readFileSync(path15.join(dir, "node_modules", name, "package.json"), "utf8")
+          fs11.readFileSync(path16.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 = path15.dirname(dir);
+        const parent = path16.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -8729,9 +9249,9 @@ function resolveFarmAppPackages(root) {
 }
 
 // src/app-manifest-webmcp.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path16 from "path";
+import path17 from "path";
 import { globSync } from "tinyglobby";
 var WEBMCP_CLIENT = "@farm.js/webmcp/client";
 var DEFINERS = /* @__PURE__ */ new Set(["defineWebMCPTool", "registerWebMCPTool", "registerWebMCPTools"]);
@@ -8749,7 +9269,7 @@ var LANGS = {
   cjs: "jsx",
   jsx: "jsx"
 };
-var parseAst3;
+var parseAst4;
 function staticValue(node) {
   if (!node) return NOT_STATIC;
   switch (node.type) {
@@ -8826,13 +9346,13 @@ function toolFromObject(object) {
 }
 function findFarmWebMCPTools(code, filename = "module.tsx") {
   if (!code.includes(WEBMCP_CLIENT)) return [];
-  const lang = LANGS[path16.extname(filename).slice(1)] ?? "tsx";
-  parseAst3 ?? (parseAst3 = createRequire2(typeof __filename === "string" ? __filename : import.meta.url)(
+  const lang = LANGS[path17.extname(filename).slice(1)] ?? "tsx";
+  parseAst4 ?? (parseAst4 = createRequire2(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
   let program;
   try {
-    program = parseAst3(code, { lang });
+    program = parseAst4(code, { lang });
   } catch {
     return [];
   }
@@ -8871,9 +9391,9 @@ function findFarmWebMCPTools(code, filename = "module.tsx") {
   visit(program.body);
   return found.sort((a, b) => a.start - b.start).map(({ tool }) => tool);
 }
-var cache = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 function collectFarmWebMCPTools(root, srcDir = "src") {
-  const base = path16.resolve(root, srcDir);
+  const base = path17.resolve(root, srcDir);
   let files;
   try {
     files = globSync("**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", {
@@ -8890,19 +9410,19 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
   for (const file of files.sort()) {
     let mtimeMs;
     try {
-      mtimeMs = fs11.statSync(file).mtimeMs;
+      mtimeMs = fs12.statSync(file).mtimeMs;
     } catch {
       continue;
     }
-    let entry = cache.get(file);
+    let entry = cache2.get(file);
     if (!entry || entry.mtimeMs !== mtimeMs) {
       let code = "";
       try {
-        code = fs11.readFileSync(file, "utf8");
+        code = fs12.readFileSync(file, "utf8");
       } catch {
       }
       entry = { mtimeMs, tools: findFarmWebMCPTools(code, file) };
-      cache.set(file, entry);
+      cache2.set(file, entry);
     }
     for (const tool of entry.tools) {
       if (seen.has(tool.name) || tools.length >= MAX_TOOLS) continue;
@@ -8914,11 +9434,11 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
 }
 
 // src/client-cache-persistence-build.ts
-import fs12 from "fs";
-import path17 from "path";
+import fs13 from "fs";
+import path18 from "path";
 var ADAPTER_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
-function resolveFarmClientCacheAdapterEntry(root, cache2) {
-  const client = cache2?.client;
+function resolveFarmClientCacheAdapterEntry(root, cache3) {
+  const client = cache3?.client;
   const adapter = client?.adapter;
   if (adapter === void 0) return void 0;
   if (typeof adapter !== "string" || adapter.trim().length === 0) {
@@ -8926,7 +9446,7 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
       'cache.client.adapter must be a module path string, for example "./src/cache-adapter".'
     );
   }
-  const resolved = path17.resolve(root, adapter);
+  const resolved = path18.resolve(root, adapter);
   const found = resolveAdapterFile(resolved);
   if (!found) {
     throw new Error(
@@ -8939,10 +9459,10 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
   return { importPath: found.replace(/\\/g, "/"), options };
 }
 function resolveAdapterFile(resolved) {
-  if (fs12.existsSync(resolved) && fs12.statSync(resolved).isFile()) return resolved;
+  if (fs13.existsSync(resolved) && fs13.statSync(resolved).isFile()) return resolved;
   for (const extension of ADAPTER_EXTENSIONS) {
     const candidate = `${resolved}.${extension}`;
-    if (fs12.existsSync(candidate) && fs12.statSync(candidate).isFile()) return candidate;
+    if (fs13.existsSync(candidate) && fs13.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -9152,8 +9672,8 @@ async function readFarmNavigationStream(body, flushToken) {
 // src/docs/client-config.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path18 from "path";
-var parseAst4;
+import path19 from "path";
+var parseAst5;
 function propertyKeyName(property2) {
   if (property2.computed) return void 0;
   const key = property2.key;
@@ -9162,11 +9682,11 @@ function propertyKeyName(property2) {
   return void 0;
 }
 function redactFarmDocsClientConfig(code, filename) {
-  parseAst4 ?? (parseAst4 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
+  parseAst5 ?? (parseAst5 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
-  const extension = path18.extname(filename);
-  const program = parseAst4(code, {
+  const extension = path19.extname(filename);
+  const program = parseAst5(code, {
     lang: extension === ".tsx" || extension === ".jsx" ? "tsx" : "ts"
   });
   const edits = [];
@@ -9227,7 +9747,7 @@ function farmDocsClientConfigPlugin(configModule) {
 }
 
 // src/server/vite-config.ts
-import path19 from "path";
+import path20 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",
@@ -9254,9 +9774,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
   );
 }
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = path19.resolve(projectRoot);
+  const resolvedProjectRoot = path20.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = path19.relative(resolvedProjectRoot, path19.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = path20.relative(resolvedProjectRoot, path20.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -9278,7 +9798,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 }
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": path19.resolve(projectRoot, srcDir)
+    "@": path20.resolve(projectRoot, srcDir)
   };
 }
 function mergeNoExternal(farmValue, userValue) {
@@ -9426,6 +9946,9 @@ ${FARM_DARK_VARIANT}
 }
 
 export {
+  rewriteFarmReactServerImports,
+  farmRelativeImportFiles,
+  ensureFarmPackageClientReference,
   rewriteFarmPackageClientImports,
   withPackageClientBoundaryCache,
   usePackageClientBoundaryCacheFile,
@@ -9445,8 +9968,12 @@ export {
   isIsolatableClientBoundarySource,
   isFarmPackageClientBoundary,
   collectFarmClientPackageImports,
+  invalidateFarmClientReachableModules,
+  getFarmClientReachableModules,
+  resolveFarmClientOptimizeDeps,
   RouteManager,
   resolveDevGlobalStylesheetHref,
+  collectDevStylesheetUrls,
   resolveFarmNotFoundComponentPath,
   farmFontImportsPlugin,
   mergeFarmFontCss,