@farm.js/core 0.1.60 → 0.1.62

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

@@ -1,3 +1,6 @@
+import {
+  createFarmMetadataImageResponse
+} from "./chunk-CROAFCMW.mjs";
 import {
   resolveFarmPlatform
 } from "./chunk-SMUW7UST.mjs";
@@ -5,7 +8,7 @@ import {
   collectSSGPages,
   matchSSGPage,
   resolveRouteRenderingConfigFromFile
-} from "./chunk-LJVNMGE3.mjs";
+} from "./chunk-BM2LH2JM.mjs";
 import {
   classifyFarmDocumentPrefix,
   composeFarmFullDocument,
@@ -35,10 +38,10 @@ import {
 } from "./chunk-PCXIJKPM.mjs";
 import {
   handleFarmFormActionRequest
-} from "./chunk-Z5A6CNV2.mjs";
+} from "./chunk-MK5E44WP.mjs";
 import {
   listFarmMCPLlmsTxtLinks
-} from "./chunk-ZMHAFH4R.mjs";
+} from "./chunk-VM7X5CKC.mjs";
 import {
   FARM_DEFAULT_MCP_PATH,
   collectFarmDefaultMCPPages,
@@ -47,9 +50,6 @@ import {
   isFarmDefaultMCPPathname,
   resolveFarmDefaultMCPServer
 } from "./chunk-UZZ6IEQP.mjs";
-import {
-  createFarmMetadataImageResponse
-} from "./chunk-OZK2DS44.mjs";
 import {
   installFarmIslandValues,
   uninstallFarmIslandValues
@@ -141,13 +141,13 @@ import {
 } from "./chunk-YSXTNSXS.mjs";
 import {
   resolveWorkflowsConfig
-} from "./chunk-JPIUGDK4.mjs";
+} from "./chunk-TZVUF5JJ.mjs";
 import {
   resolveCronConfig
-} from "./chunk-3PX4AIXO.mjs";
+} from "./chunk-DQF3QLOH.mjs";
 import {
   resolveServerActionsConfig
-} from "./chunk-FSQMN2MQ.mjs";
+} from "./chunk-E46NXBNJ.mjs";
 import {
   _setDefaultFarmThemeConfig,
   getTheme
@@ -166,7 +166,7 @@ import {
   getIntegrationProviders,
   getRegisteredIntegrationAPIManifest,
   isFarmIntegrationProviderComponentReference
-} from "./chunk-IFHPDLIS.mjs";
+} from "./chunk-TGULJSHD.mjs";
 import {
   createRouteSlotContainerId,
   parseRouteSlotFile
@@ -250,13 +250,13 @@ import {
 import {
   matchesFarmIfNoneMatch,
   resolveFarmServerConfig
-} from "./chunk-GFT5AHAT.mjs";
+} from "./chunk-QDWMCFTH.mjs";
 import {
   getRequestContextSnapshot
 } from "./chunk-D2LCAV6L.mjs";
 import {
   FARM_VERSION
-} from "./chunk-HPWB57PZ.mjs";
+} from "./chunk-NT3QDN2E.mjs";
 import {
   resolveFarmTrailingSlashRedirect,
   setFarmTrailingSlashPreference
@@ -327,17 +327,157 @@ import {
   getRoutePatternShape
 } from "./chunk-AYP2YFVN.mjs";
 
+// src/islands-package-references.ts
+import fs from "fs";
+import path from "path";
+import { parseAst } from "rolldown/parseAst";
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function parse(code, file) {
+  const extension = path.extname(file).slice(1);
+  const lang = extension === "ts" || extension === "mts" || extension === "cts" ? "ts" : "tsx";
+  try {
+    return parseAst(code, { lang });
+  } catch {
+    return null;
+  }
+}
+function walk(node, visit, parent = null) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit, parent);
+    return;
+  }
+  const current = node;
+  if (typeof current.type !== "string") return;
+  visit(current, parent);
+  for (const [key, value] of Object.entries(current)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (value && typeof value === "object") walk(value, visit, current);
+  }
+}
+function namespaceMembers(program, local, declaration) {
+  const members = /* @__PURE__ */ new Set();
+  let opaque = false;
+  walk(program, (node, parent) => {
+    if (opaque || node === declaration) return;
+    const name = node.type === "Identifier" || node.type === "JSXIdentifier" ? node.name : null;
+    if (name !== local) return;
+    if (parent?.type === "ImportNamespaceSpecifier") return;
+    const member = (parent?.type === "MemberExpression" || parent?.type === "JSXMemberExpression") && parent.object === node ? parent.property : null;
+    const property2 = member && !parent.computed && (member.type === "Identifier" || member.type === "JSXIdentifier") ? member.name : null;
+    if (property2) members.add(property2);
+    else opaque = true;
+  });
+  return opaque ? null : [...members];
+}
+function findFarmPackageClientImports(code, file, isClientPackage) {
+  if (!code.includes("import")) return [];
+  const program = parse(code, file);
+  if (!program) return [];
+  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" || specifier.startsWith(".") || specifier.startsWith("/"))
+      continue;
+    const specifiers = (node.specifiers ?? []).filter(
+      (entry2) => entry2.importKind !== "type"
+    );
+    if (specifiers.length === 0 || !isClientPackage(specifier)) continue;
+    const entry = {
+      start: node.start,
+      end: node.end,
+      specifier,
+      named: []
+    };
+    let supported = true;
+    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);
+        if (!members || members.some((member) => !IDENTIFIER.test(member))) supported = false;
+        else entry.namespace = { local: binding.local.name, members };
+      } else {
+        const imported = binding.imported?.type === "Identifier" ? binding.imported.name : binding.imported?.value;
+        if (typeof imported !== "string" || !IDENTIFIER.test(imported)) supported = false;
+        else entry.named.push({ imported, local: binding.local.name });
+      }
+    }
+    if (supported) found.push(entry);
+  }
+  return found;
+}
+function farmPackageClientImportExports(entry) {
+  return [
+    ...entry.defaultLocal ? ["default"] : [],
+    ...entry.named.map((binding) => binding.imported),
+    ...entry.namespace?.members ?? []
+  ];
+}
+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`);
+}
+function ensureFarmPackageClientReference(root, specifier, exportName) {
+  const file = farmPackageClientReferencePath(root, specifier, exportName);
+  const source = [
+    `// Generated by Farm: ${specifier}'s ${exportName} export, as a client reference for server components.`,
+    '"use client";',
+    `export { ${exportName} } from ${JSON.stringify(specifier)};`,
+    ""
+  ].join("\n");
+  let current = null;
+  try {
+    current = fs.readFileSync(file, "utf8");
+  } catch {
+  }
+  if (current !== source) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, source);
+  }
+  return file;
+}
+function rewriteFarmPackageClientImports(options) {
+  const imports = findFarmPackageClientImports(options.code, options.file, options.isClientPackage);
+  if (imports.length === 0) return null;
+  const reference = (specifier, exportName) => JSON.stringify(ensureFarmPackageClientReference(options.root, specifier, exportName));
+  let output = options.code;
+  let next = 0;
+  for (const entry of [...imports].sort((left, right) => right.start - left.start)) {
+    const lines = [];
+    if (entry.defaultLocal) {
+      lines.push(`import ${entry.defaultLocal} from ${reference(entry.specifier, "default")};`);
+    }
+    for (const binding of entry.named) {
+      lines.push(
+        `import { ${binding.imported} as ${binding.local} } from ${reference(entry.specifier, binding.imported)};`
+      );
+    }
+    if (entry.namespace) {
+      const fields = [];
+      for (const member of entry.namespace.members) {
+        const local = `__farm_package_reference_${next++}__`;
+        lines.push(`import { ${member} as ${local} } from ${reference(entry.specifier, member)};`);
+        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;
+}
+
 // src/utils/client-component.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 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 fs2 from "fs";
+import path2 from "path";
 var SCHEMA_VERSION = 1;
-var NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;
+var NODE_MODULES_SEGMENT = `${path2.sep}node_modules${path2.sep}`;
 var PackageInspectionTrace = class {
   constructor() {
     this.files = /* @__PURE__ */ new Set();
@@ -347,7 +487,7 @@ var PackageInspectionTrace = class {
   }
   visit(file) {
     this.files.add(file);
-    const directory = path.dirname(file);
+    const directory = path2.dirname(file);
     if (!this.directoryStamps.has(directory)) {
       this.directoryStamps.set(directory, stampPackagePath(directory, "directory"));
     }
@@ -374,9 +514,9 @@ var PackageInspectionTrace = class {
   }
 };
 function stampPackagePath(target, kind) {
-  if (!`${target}${path.sep}`.includes(NODE_MODULES_SEGMENT)) return void 0;
+  if (!`${target}${path2.sep}`.includes(NODE_MODULES_SEGMENT)) return void 0;
   try {
-    const stat = fs.statSync(target, { throwIfNoEntry: false });
+    const stat = fs2.statSync(target, { throwIfNoEntry: false });
     if (!stat || (kind === "file" ? !stat.isFile() : !stat.isDirectory())) return void 0;
     return [target, stat.size, stat.mtimeMs, stat.ctimeMs];
   } catch {
@@ -460,11 +600,11 @@ var PackageClientBoundaryCache = class {
     });
     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);
+      await fs2.promises.mkdir(path2.dirname(file), { recursive: true });
+      await fs2.promises.writeFile(temporary, contents);
+      await fs2.promises.rename(temporary, file);
     } catch {
-      await fs.promises.rm(temporary, { force: true }).catch(() => {
+      await fs2.promises.rm(temporary, { force: true }).catch(() => {
       });
     }
   }
@@ -498,7 +638,7 @@ var PackageClientBoundaryCache = class {
 function readStoredCache(file) {
   let value;
   try {
-    value = JSON.parse(fs.readFileSync(file, "utf8"));
+    value = JSON.parse(fs2.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -519,7 +659,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" && path.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" && path2.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);
@@ -527,7 +667,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" && path.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" && path2.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() {
@@ -558,10 +698,10 @@ function usePackageClientBoundaryCacheFile(file) {
 // src/utils/client-component.ts
 function readIfExists(filePath) {
   try {
-    if (!filePath || !fs2.existsSync(filePath)) {
+    if (!filePath || !fs3.existsSync(filePath)) {
       return null;
     }
-    return fs2.readFileSync(filePath, "utf-8");
+    return fs3.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -580,21 +720,21 @@ function resolveModuleSourcePath(modulePath, root) {
     }
     if (modulePath.startsWith("/@fs/")) {
       const fsPath = withoutQuery.slice("/@fs/".length);
-      candidates.add(path2.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
+      candidates.add(path3.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
     }
   }
   if (root && modulePath) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path2.join(root, normalized));
-    candidates.add(path2.resolve(root, normalized));
+    candidates.add(path3.join(root, normalized));
+    candidates.add(path3.resolve(root, normalized));
   }
   if (withoutQuery?.startsWith("/src/")) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path2.join(process.cwd(), normalized));
-    candidates.add(path2.resolve(process.cwd(), normalized));
+    candidates.add(path3.join(process.cwd(), normalized));
+    candidates.add(path3.resolve(process.cwd(), normalized));
   }
   for (const candidate of candidates) {
-    if (fs2.existsSync(candidate)) {
+    if (fs3.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -611,8 +751,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 ? path2.resolve(benchmarkRoot) : null;
-  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path2.sep}`));
+  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}`));
   return isBenchmarkFixture && Number.isSafeInteger(benchmarkLimit) && benchmarkLimit > FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES ? benchmarkLimit : FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES;
 }
 var RESOLVABLE_SOURCE_EXTENSIONS = [
@@ -984,7 +1124,7 @@ function getClientModuleHydrationPlan(modulePath, root, mode = "off", options =
   const layout = collectIsolatedClientBoundaries(resolvedPath, root, {
     allowDynamicCardinality: true,
     allowElementProps: true,
-    staticPackageLeaves: true
+    packageReferences: true
   });
   const routeWide = {
     ...plan,
@@ -1043,7 +1183,9 @@ function planClientModuleHydration(modulePath, root, mode, options) {
     allowDynamicCardinality: asyncOwner,
     allowElementProps: asyncOwner,
     staticPackageBoundaries: asyncOwner,
-    staticPackageLeaves: options.serverTreeLayouts === true && options.asyncOwnerIslands === true
+    staticPackageLeaves: options.serverTreeLayouts === true && options.asyncOwnerIslands === true,
+    // Islands mode: pages carry `serverOwners`, layouts `serverTreeLayouts`.
+    packageReferences: options.serverOwners === true || options.serverTreeLayouts === true
   });
   if (inspection.fallbackReason && asyncOwner && options.serverOwners === true) {
     return {
@@ -1115,7 +1257,8 @@ function getMarkdownPageHydrationPlan(componentsModulePath, root, mode = "off",
   }
   const inspection = collectIsolatedClientBoundaries(resolvedPath, root, {
     allowDynamicCardinality: true,
-    staticPackageBoundaries: true
+    staticPackageBoundaries: true,
+    packageReferences: options.packageReferences === true
   });
   if (inspection.fallbackReason) return { ...plan, fallbackReason: inspection.fallbackReason };
   if (inspection.staticPackages.length > 0)
@@ -1517,7 +1660,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
   let fallbackReason;
   let fallbackHint;
   let costGuardExceeded = false;
-  const projectRoot = root ? path2.resolve(root) : void 0;
+  const projectRoot = root ? path3.resolve(root) : void 0;
   const visit = (moduleSourcePath) => {
     if (fallbackReason) return 0;
     const cached = estimates.get(moduleSourcePath);
@@ -1527,7 +1670,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
     const content = readIfExists(moduleSourcePath);
     const parsed = parseClientModuleMetadata(content, false);
     if (parsed.isClientComponent) {
-      if (projectRoot && !path2.resolve(moduleSourcePath).startsWith(`${projectRoot}${path2.sep}`)) {
+      if (projectRoot && !path3.resolve(moduleSourcePath).startsWith(`${projectRoot}${path3.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;
@@ -1556,20 +1699,35 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
       const imported = resolveImportedModule(moduleSourcePath, specifier, root);
       const importedPath = imported.path;
       if (!importedPath) continue;
-      if (!imported.local) {
+      let importedBoundaryCount;
+      if (imported.local) {
+        importedBoundaryCount = visit(importedPath);
+      } else {
         const packageMetadata = inspectPackageClientBoundary(importedPath, root, /* @__PURE__ */ new Set());
-        if (packageMetadata.shouldHydrate) {
-          if (options.staticPackageBoundaries || options.staticPackageLeaves && rendersOnlyLeafElements(content, importedBindings.get(specifier) ?? [])) {
-            staticPackages.add(specifier);
-            continue;
+        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;
         }
-        continue;
       }
-      const importedBoundaryCount = visit(importedPath);
       if (fallbackReason || importedBoundaryCount === 0) continue;
       const localBindings = importedBindings.get(specifier) ?? [];
       const staticUses = countStaticJsxUses(content, localBindings);
@@ -1792,7 +1950,7 @@ var ALIAS_IMPORT = /^(?:@\/|~\/|#)/;
 function warnUnresolvedAliasImport(importerPath, specifier, root) {
   if (!ALIAS_IMPORT.test(specifier) || warnedUnresolvedAliasImports.has(specifier)) return;
   warnedUnresolvedAliasImports.add(specifier);
-  const importer = root ? path2.relative(root, importerPath) : importerPath;
+  const importer = root ? path3.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".`
   );
@@ -1801,7 +1959,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 = path2.resolve(root);
+  const projectRoot = path3.resolve(root);
   let match;
   for (const alias of getProjectImportAliases(projectRoot)) {
     const captured = matchProjectImportAlias(alias, specifier);
@@ -1811,7 +1969,7 @@ function resolveProjectAliasSourcePath(specifier, root) {
   if (!match) return void 0;
   const resolved = resolveSourceCandidate(
     match.alias.targets.map(
-      (target) => path2.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+      (target) => path3.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
     )
   );
   return resolved && /\.d\.[cm]?ts$/.test(resolved) ? null : resolved;
@@ -1826,7 +1984,7 @@ function matchProjectImportAlias(alias, specifier) {
 function getProjectImportAliases(projectRoot) {
   const stamp = PROJECT_ALIAS_FILES.map((file) => {
     try {
-      return String(fs2.statSync(path2.join(projectRoot, file)).mtimeMs);
+      return String(fs3.statSync(path3.join(projectRoot, file)).mtimeMs);
     } catch {
       return "-";
     }
@@ -1844,7 +2002,7 @@ function getProjectImportAliases(projectRoot) {
       prefix: "@/",
       suffix: "",
       wildcard: true,
-      targets: [path2.join(projectRoot, sourceDir, "*")]
+      targets: [path3.join(projectRoot, sourceDir, "*")]
     });
   }
   projectImportAliasCache.set(projectRoot, { stamp: cacheStamp, aliases });
@@ -1852,8 +2010,8 @@ function getProjectImportAliases(projectRoot) {
 }
 function readTsconfigPathAliases(projectRoot) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
-    const configPath = path2.join(projectRoot, name);
-    if (!fs2.existsSync(configPath)) continue;
+    const configPath = path3.join(projectRoot, name);
+    if (!fs3.existsSync(configPath)) continue;
     const resolved = readTsconfigPaths(configPath, /* @__PURE__ */ new Set());
     if (!resolved?.paths) return [];
     const base = resolved.baseUrl ?? resolved.pathsDirectory;
@@ -1865,7 +2023,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) => path2.resolve(base, target))
+          targets: targets.filter((target) => typeof target === "string").map((target) => path3.resolve(base, target))
         }
       ];
     });
@@ -1877,27 +2035,27 @@ function readTsconfigPaths(configPath, visited) {
   visited.add(configPath);
   const config = readJsonWithComments(configPath);
   if (!config) return null;
-  const directory = path2.dirname(configPath);
+  const directory = path3.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 = path2.resolve(
+    const parentPath = path3.resolve(
       directory,
       parent.endsWith(".json") ? parent : `${parent}.json`
     );
     inherited = readTsconfigPaths(parentPath, visited) ?? inherited;
   }
   const options = config.compilerOptions ?? {};
-  const baseUrl = typeof options.baseUrl === "string" ? path2.resolve(directory, options.baseUrl) : inherited?.baseUrl;
+  const baseUrl = typeof options.baseUrl === "string" ? path3.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(path2.join(projectRoot, "package.json"))?.imports;
+  const imports = readPackageJson(path3.join(projectRoot, "package.json"))?.imports;
   if (!imports || typeof imports !== "object") return [];
   return Object.entries(imports).flatMap(([pattern, value]) => {
     const target = resolveConditionalExportTarget(value);
@@ -1908,7 +2066,7 @@ function readPackageImportAliases(projectRoot) {
         prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
         suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
         wildcard: wildcardIndex !== -1,
-        targets: [path2.resolve(projectRoot, target)]
+        targets: [path3.resolve(projectRoot, target)]
       }
     ];
   });
@@ -1916,7 +2074,7 @@ function readPackageImportAliases(projectRoot) {
 function readJsonWithComments(filePath) {
   let source;
   try {
-    source = fs2.readFileSync(filePath, "utf8");
+    source = fs3.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -1954,7 +2112,7 @@ function resolveImportedModuleSourcePath(importerPath, specifier, root) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
   }
   const candidates = /* @__PURE__ */ new Set();
-  const basePath = specifier.startsWith(".") ? path2.resolve(path2.dirname(importerPath), specifier) : root ? path2.resolve(root, specifier.replace(/^\/+/, "")) : path2.resolve(specifier);
+  const basePath = specifier.startsWith(".") ? path3.resolve(path3.dirname(importerPath), specifier) : root ? path3.resolve(root, specifier.replace(/^\/+/, "")) : path3.resolve(specifier);
   candidates.add(basePath);
   return resolveSourceCandidate(candidates);
 }
@@ -1964,45 +2122,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 = path2.join(packageDirectory, "package.json");
+  const packageJsonPath = path3.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(path2.resolve(packageDirectory, exportTarget));
+    candidates.add(path3.resolve(packageDirectory, exportTarget));
   }
   if (packageSubpath) {
-    candidates.add(path2.join(packageDirectory, packageSubpath));
+    candidates.add(path3.join(packageDirectory, packageSubpath));
   } else {
     for (const entry of [packageJson?.browser, packageJson?.module, packageJson?.main]) {
-      if (typeof entry === "string") candidates.add(path2.resolve(packageDirectory, entry));
+      if (typeof entry === "string") candidates.add(path3.resolve(packageDirectory, entry));
     }
-    candidates.add(path2.join(packageDirectory, "index"));
+    candidates.add(path3.join(packageDirectory, "index"));
   }
   return resolveSourceCandidate(candidates);
 }
 function findPackageDirectory(importerPath, packageName, root) {
   const searchRoots = /* @__PURE__ */ new Set();
-  let current = path2.dirname(importerPath);
+  let current = path3.dirname(importerPath);
   while (true) {
     searchRoots.add(current);
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   if (root) {
-    current = path2.resolve(root);
+    current = path3.resolve(root);
     while (true) {
       searchRoots.add(current);
-      const parent = path2.dirname(current);
+      const parent = path3.dirname(current);
       if (parent === current) break;
       current = parent;
     }
   }
   for (const searchRoot of searchRoots) {
-    const packageDirectory = path2.join(searchRoot, "node_modules", packageName);
-    if (fs2.existsSync(path2.join(packageDirectory, "package.json"))) {
+    const packageDirectory = path3.join(searchRoot, "node_modules", packageName);
+    if (fs3.existsSync(path3.join(packageDirectory, "package.json"))) {
       return packageDirectory;
     }
   }
@@ -2010,7 +2168,7 @@ function findPackageDirectory(importerPath, packageName, root) {
 }
 function readPackageJson(packageJsonPath) {
   try {
-    return JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    return JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -2068,26 +2226,73 @@ function resolveSourceCandidate(candidates) {
   for (const candidate of candidates) {
     const paths = [candidate];
     for (const extension of RESOLVABLE_SOURCE_EXTENSIONS) {
-      paths.push(`${candidate}${extension}`, path2.join(candidate, `index${extension}`));
+      paths.push(`${candidate}${extension}`, path3.join(candidate, `index${extension}`));
     }
     for (const sourcePath of paths) {
       try {
-        if (fs2.statSync(sourcePath).isFile()) return sourcePath;
+        if (fs3.statSync(sourcePath).isFile()) return sourcePath;
       } catch {
       }
     }
   }
   return null;
 }
+function isFarmPackageClientBoundary(importerPath, specifier, root) {
+  const imported = resolveImportedModule(importerPath, specifier, root);
+  if (imported.local || !imported.path) return false;
+  return inspectPackageClientBoundary(imported.path, root, /* @__PURE__ */ new Set()).shouldHydrate;
+}
+var CLIENT_PACKAGE_SCAN_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
+var CLIENT_PACKAGE_SCAN_SKIP = /* @__PURE__ */ new Set(["node_modules", ".farm", ".git", "dist", ".output"]);
+function bareSpecifierPackage(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || specifier.startsWith("virtual:") || specifier.includes("\0") || // A package's stylesheet or asset is not a module for the optimizer.
+  /\.(?:css|scss|sass|less|styl|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|json|wasm)$/.test(
+    specifier
+  )) {
+    return null;
+  }
+  return specifier;
+}
+function collectFarmClientPackageImports(directory, root) {
+  const found = /* @__PURE__ */ new Set();
+  const walk2 = (current) => {
+    let entries;
+    try {
+      entries = fs3.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);
+      if (entry.isDirectory()) {
+        if (!CLIENT_PACKAGE_SCAN_SKIP.has(entry.name)) walk2(file);
+        continue;
+      }
+      if (!CLIENT_PACKAGE_SCAN_EXTENSIONS.test(entry.name) || entry.name.endsWith(".d.ts"))
+        continue;
+      const content = readIfExists(file);
+      if (!content) continue;
+      const client = hasUseClientDirective(content);
+      for (const specifier of new Set(getImportSpecifiers(content))) {
+        const name = bareSpecifierPackage(specifier);
+        if (!name || found.has(name)) continue;
+        if (client || isFarmPackageClientBoundary(file, name, root)) found.add(name);
+      }
+    }
+  };
+  walk2(directory);
+  return [...found].sort();
+}
 
 // src/routing/route-manager.ts
 import { realpathSync } from "fs";
-import path4 from "path";
+import path5 from "path";
 
 // src/static-metadata-image.ts
 import { createHash } from "crypto";
 import { readFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import { imageSize } from "image-size";
 var STATIC_METADATA_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp"];
 var CONTENT_TYPES = {
@@ -2128,13 +2333,13 @@ async function inspectStaticMetadataImage(filePath) {
   };
 }
 function getStaticMetadataImageAltPath(filePath) {
-  return path3.join(
-    path3.dirname(filePath),
-    `${path3.basename(filePath, path3.extname(filePath))}.alt.txt`
+  return path4.join(
+    path4.dirname(filePath),
+    `${path4.basename(filePath, path4.extname(filePath))}.alt.txt`
   );
 }
 function getStaticMetadataImageExtension(filePath) {
-  const extension = path3.extname(filePath).slice(1).toLowerCase();
+  const extension = path4.extname(filePath).slice(1).toLowerCase();
   return STATIC_METADATA_IMAGE_EXTENSIONS.includes(extension) ? extension : null;
 }
 async function readAltText(filePath) {
@@ -2462,14 +2667,14 @@ var RouteManager = class {
    * Requests still fetch route data, but never inspect component source.
    */
   generateClientManifest(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path4.resolve(projectRoot);
+    const normalizedProjectRoot = path5.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 (path4.isAbsolute(absolutePath)) {
+      if (path5.isAbsolute(absolutePath)) {
         const normalized = absolutePath.replace(/\\/g, "/");
         return normalized.startsWith("/") ? `/@fs${normalized}` : `/@fs/${normalized}`;
       }
@@ -2511,7 +2716,7 @@ var RouteManager = class {
       resolveFarmMdxComponentsModulePath(resolveMdxConfig(this.config.mdx), normalizedProjectRoot),
       normalizedProjectRoot,
       isolatedMode,
-      planOptions
+      { ...planOptions, packageReferences: islandsMode }
     );
     const routeEntries = Array.from(this.routes.values()).map((entry) => ({
       entry,
@@ -2649,7 +2854,7 @@ var RouteManager = class {
     for (const { metadata } of [...layoutEntries, ...routeEntries]) {
       if (!metadata.hasIsolatedClientBoundaries && !metadata.serverTreeLayout) continue;
       for (const boundary of metadata.isolatedBoundaries) {
-        isolatedClientBoundaryModules.add(path4.resolve(boundary.modulePath));
+        isolatedClientBoundaryModules.add(path5.resolve(boundary.modulePath));
       }
     }
     const islandsErrors = [
@@ -2700,7 +2905,7 @@ var RouteManager = class {
   }
   /** @internal Client modules selected by the compiled hydration ownership plan. */
   getIsolatedClientBoundaryModules(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path4.resolve(projectRoot);
+    const normalizedProjectRoot = path5.resolve(projectRoot);
     this.generateClientManifest(normalizedProjectRoot);
     return this.clientManifestCache?.isolatedClientBoundaryModules ?? /* @__PURE__ */ new Set();
   }
@@ -2709,7 +2914,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(path4.resolve(projectRoot));
+    this.generateClientManifest(path5.resolve(projectRoot));
     return this.clientManifestCache?.islandsErrors ?? [];
   }
   /**
@@ -2840,19 +3045,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) => path4.join(appDir, file)).join(" and ")}.`
+          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path5.join(appDir, file)).join(" and ")}.`
         );
       }
       if (markdownFiles.length > 1) {
         throw new Error(
-          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path4.join(appDir, file)).join(" and ")}.`
+          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path5.join(appDir, file)).join(" and ")}.`
         );
       }
       const componentFile = componentFiles[0];
       const markdownFile = markdownFiles[0];
       const primaryFile = componentFile || markdownFile;
       if (!primaryFile) continue;
-      const modulePath = path4.join(appDir, primaryFile);
+      const modulePath = path5.join(appDir, primaryFile);
       const existing = this.routes.get(pattern);
       if (existing?.sourceRoot === source.root) {
         throw new Error(
@@ -2863,7 +3068,7 @@ var RouteManager = class {
         route: group.route,
         modulePath,
         ...markdownFile ? {
-          markdownSourcePath: path4.join(appDir, markdownFile)
+          markdownSourcePath: path5.join(appDir, markdownFile)
         } : {},
         pattern,
         ...getPageDirectoryField(group.route, pattern),
@@ -2878,7 +3083,7 @@ var RouteManager = class {
     ]) {
       for (const file of files) {
         const route = parseRoutePath(file);
-        const modulePath = path4.join(appDir, file);
+        const modulePath = path5.join(appDir, file);
         const pattern = createRouteDirectoryPattern(route);
         const existing = target.get(pattern);
         if (existing?.sourceRoot === source.root) {
@@ -2898,7 +3103,7 @@ var RouteManager = class {
     for (const file of [...pageFiles, ...slotDefaultFiles]) {
       const slot = parseRouteSlotFile(file);
       if (!slot) continue;
-      const modulePath = path4.join(appDir, file);
+      const modulePath = path5.join(appDir, file);
       const pattern = this.createRoutePattern(slot.route);
       const ownerPattern = this.createRoutePattern(slot.ownerRoute);
       const ownerDirectory = createRouteDirectoryPattern(slot.ownerRoute);
@@ -2924,11 +3129,11 @@ var RouteManager = class {
       });
     }
     for (const file of metadataImageFiles) {
-      const fileBase = path4.basename(file, path4.extname(file));
+      const fileBase = path5.basename(file, path5.extname(file));
       const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
       const fileName = kind === "twitter" ? "twitter-image" : "opengraph-image";
       const route = parseRoutePath(file);
-      const modulePath = path4.join(appDir, file);
+      const modulePath = path5.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${kind}:${pattern}`;
       const existing = this.metadataImages.get(key);
@@ -2953,11 +3158,11 @@ var RouteManager = class {
     }
     for (const file of metadataRouteFiles) {
       const descriptor = getApplicationMetadataRouteDescriptor(
-        path4.basename(file, path4.extname(file))
+        path5.basename(file, path5.extname(file))
       );
       if (!descriptor) continue;
       const route = parseRoutePath(file);
-      const modulePath = path4.join(appDir, file);
+      const modulePath = path5.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${descriptor.kind}:${pattern}`;
       const existing = this.metadataRoutes.get(key);
@@ -3368,12 +3573,12 @@ function toRealPath(filePath) {
 }
 
 // src/server/dev-styles.ts
-import * as fs3 from "fs";
-import * as path5 from "path";
+import * as fs4 from "fs";
+import * as path6 from "path";
 function resolveDevGlobalStylesheetHref(root, srcDir = "src") {
-  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("/")}`;
+  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("/")}`;
 }
 var STYLE_EXTENSIONS = /\.(css|scss|sass|less|styl|stylus)(?:$|\?)/;
 var ALREADY_LINKED = "/src/app/globals.css";
@@ -3397,7 +3602,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 path6 from "path";
+import path7 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 var FONT_IMPORTS = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/font"]);
@@ -3754,7 +3959,7 @@ ${FONT_SECTION_END}
         return resource;
       }
       const bytes2 = await fetchRemoteFont(url, input.integrity);
-      return this.createSelfHostedResource(bytes2, extension, path6.basename(url.pathname));
+      return this.createSelfHostedResource(bytes2, extension, path7.basename(url.pathname));
     }
     if (input.source.startsWith("/")) {
       return this.createPublicResource(input.moduleId, input.source);
@@ -3777,8 +3982,8 @@ ${FONT_SECTION_END}
     }
     return this.createSelfHostedResource(
       bytes,
-      path6.extname(resolvedPath),
-      path6.basename(resolvedPath)
+      path7.extname(resolvedPath),
+      path7.basename(resolvedPath)
     );
   }
   async createPublicResource(moduleId, source) {
@@ -3789,7 +3994,7 @@ ${FONT_SECTION_END}
       );
     }
     const publicPath = normalizePublicFontPath(source, moduleId);
-    const resolvedPath = path6.resolve(this.publicDir, `.${publicPath}`);
+    const resolvedPath = path7.resolve(this.publicDir, `.${publicPath}`);
     if (!isPathInside(this.publicDir, resolvedPath)) {
       throw fontError(moduleId, `public font path must stay inside publicDir`);
     }
@@ -3805,7 +4010,7 @@ ${FONT_SECTION_END}
         `could not read ${JSON.stringify(source)} from publicDir: ${error.message}`
       );
     }
-    const extension = path6.extname(resolvedPath).toLowerCase();
+    const extension = path7.extname(resolvedPath).toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
     const resource = {
       extension,
@@ -3820,7 +4025,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(path6.basename(fileName, extension)) || "font";
+    const baseName = sanitizeFileName(path7.basename(fileName, extension)) || "font";
     const outputFileName = `assets/fonts/${baseName}-h${hash}${normalizedExtension}`;
     const key = `${hash}${normalizedExtension}`;
     const existing = this.resources.get(key);
@@ -4173,24 +4378,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 path6.resolve(path6.dirname(importer), source);
-  if (path6.isAbsolute(source)) {
+  if (source.startsWith(".")) return path7.resolve(path7.dirname(importer), source);
+  if (path7.isAbsolute(source)) {
     return source;
   }
   try {
     return createRequire(pathToFileURL(importer)).resolve(source);
   } catch {
     const segments = source.replace(/\\/g, "/").split("/");
-    if (segments.includes("..")) return path6.resolve(root, source);
-    let current = path6.dirname(importer);
-    const filesystemRoot = path6.parse(current).root;
+    if (segments.includes("..")) return path7.resolve(root, source);
+    let current = path7.dirname(importer);
+    const filesystemRoot = path7.parse(current).root;
     while (true) {
-      const candidate = path6.join(current, "node_modules", ...segments);
+      const candidate = path7.join(current, "node_modules", ...segments);
       if (existsSync2(candidate)) return candidate;
       if (current === filesystemRoot) break;
-      current = path6.dirname(current);
+      current = path7.dirname(current);
     }
-    return path6.resolve(root, "node_modules", ...segments);
+    return path7.resolve(root, "node_modules", ...segments);
   }
 }
 function replaceFontSection(css, section) {
@@ -4223,11 +4428,11 @@ function getGlobalMap(key) {
   return created;
 }
 function normalizeRoot(root) {
-  return path6.resolve(root).replace(/\\/g, "/");
+  return path7.resolve(root).replace(/\\/g, "/");
 }
 function normalizePublicDir(root, publicDir) {
   if (publicDir === false || publicDir === "") return false;
-  return path6.resolve(root, publicDir || "public");
+  return path7.resolve(root, publicDir || "public");
 }
 function normalizePublicFontPath(source, moduleId) {
   if (source.includes("?") || source.includes("#")) {
@@ -4236,8 +4441,8 @@ function normalizePublicFontPath(source, moduleId) {
   return `/${source.replace(/\\/g, "/").replace(/^\/+/, "")}`;
 }
 function isPathInside(parent, child) {
-  const relative3 = path6.relative(parent, child);
-  return relative3 === "" || !relative3.startsWith("..") && !path6.isAbsolute(relative3);
+  const relative3 = path7.relative(parent, child);
+  return relative3 === "" || !relative3.startsWith("..") && !path7.isAbsolute(relative3);
 }
 function normalizeBasePath(value) {
   if (!value || value === "/") return "/";
@@ -4247,7 +4452,7 @@ function joinBasePath(basePath, value) {
   return basePath === "/" ? value : `${basePath.replace(/\/$/, "")}${value}`;
 }
 function extensionFromPath(pathname) {
-  const extension = path6.extname(pathname).toLowerCase();
+  const extension = path7.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`);
   }
@@ -4387,7 +4592,7 @@ function fontError(id, message) {
 }
 
 // src/integration-provider-build.ts
-import path7 from "path";
+import path8 from "path";
 function isRendererCompiledComponent(moduleId, rendererComponentExtensions) {
   const lowered = moduleId.toLowerCase();
   return rendererComponentExtensions.some((extension) => lowered.endsWith(extension.toLowerCase()));
@@ -4489,14 +4694,14 @@ function generateFarmIntegrationProviderServerModules(providers, root, rendererC
 }
 function resolveProviderModule(moduleId, root) {
   if (!moduleId.startsWith(".")) return moduleId;
-  return toViteModuleId(path7.resolve(root, moduleId), root);
+  return toViteModuleId(path8.resolve(root, moduleId), root);
 }
 
 // src/island-inference.ts
-import fs4 from "fs";
-import path8 from "path";
+import fs5 from "fs";
+import path9 from "path";
 import { inferStrategy } from "@farm.js/islx/compiler";
-import { parseAst } from "rolldown/parseAst";
+import { parseAst as parseAst2 } from "rolldown/parseAst";
 var PARSE_LANGS = /* @__PURE__ */ new Map([
   [".tsx", "tsx"],
   [".ts", "ts"],
@@ -4505,29 +4710,29 @@ var PARSE_LANGS = /* @__PURE__ */ new Map([
   [".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 });
+  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 });
 }
 function modifiedAt(file) {
   try {
-    return fs4.statSync(file).mtimeMs;
+    return fs5.statSync(file).mtimeMs;
   } catch {
     return -1;
   }
 }
 var inferences = /* @__PURE__ */ new Map();
 function inferFarmIslandStrategy(filePath, root) {
-  const file = path8.resolve(filePath);
+  const file = path9.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");
+    code = fs5.readFileSync(file, "utf8");
   } catch {
-    return { strategy: null, files: [file], reason: `${path8.basename(file)} could not be read` };
+    return { strategy: null, files: [file], reason: `${path9.basename(file)} could not be read` };
   }
   const result = inferStrategy(file, code, {
     parse: parseFarmIslandSource,
@@ -4551,7 +4756,7 @@ function inferFarmRouteRootStrategy(owners, root) {
       return {
         strategy: null,
         files,
-        reason: `${path8.basename(owner)}: its client components could not be listed`
+        reason: `${path9.basename(owner)}: its client components could not be listed`
       };
     }
     modules.push(...rendered);
@@ -4559,7 +4764,7 @@ function inferFarmRouteRootStrategy(owners, root) {
   for (const module of modules) {
     let source = null;
     try {
-      source = fs4.readFileSync(module, "utf8");
+      source = fs5.readFileSync(module, "utf8");
     } catch {
     }
     if (getIslandStrategyExport(source) !== null) return { strategy: null, files, declared: true };
@@ -4595,8 +4800,8 @@ function resolveFarmRouteRootStrategy(route, page, layouts, root, islandsMode) {
 }
 
 // src/client-plugin-build.ts
-import fs5 from "fs";
-import path9 from "path";
+import fs6 from "fs";
+import path10 from "path";
 var CLIENT_KEYS = [
   "public",
   "setup",
@@ -4616,10 +4821,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 = path9.resolve(root, srcDir);
+  const sourceRoot = path10.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;
+    const candidate = path10.join(sourceRoot, `client.${extension}`);
+    if (fs6.existsSync(candidate) && fs6.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -4861,27 +5066,27 @@ function isArrayIndex(key) {
 }
 
 // src/server/renderer.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as https from "https";
 import { isIP } from "net";
-import * as path12 from "path";
+import * as path13 from "path";
 import * as tls from "tls";
 import { Readable, Writable } from "stream";
 
 // src/not-found.ts
-import fs6 from "fs";
-import path10 from "path";
+import fs7 from "fs";
+import path11 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);
+    const componentPath = path11.isAbsolute(configuredPath) ? path11.normalize(configuredPath) : path11.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()) {
+    if (!fs7.existsSync(componentPath) || !fs7.statSync(componentPath).isFile()) {
       throw new Error(`notFound.component was not found: ${componentPath}`);
     }
     return componentPath;
@@ -4889,8 +5094,8 @@ function resolveFarmNotFoundComponentPath(config, appDirs) {
   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()) {
+      const candidate = path11.join(appDir, `not-found${extension}`);
+      if (fs7.existsSync(candidate) && fs7.statSync(candidate).isFile()) {
         discoveredPath = candidate;
         break;
       }
@@ -5086,8 +5291,8 @@ body {
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/server/error-diagnostics.ts
-import * as fs7 from "fs";
-import * as path11 from "path";
+import * as fs8 from "fs";
+import * as path12 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;
@@ -5095,8 +5300,8 @@ function redactErrorText(value) {
   return value.replace(BEARER_PATTERN, "$1[REDACTED]").replace(SECRET_VALUE_PATTERN, "$1=[REDACTED]");
 }
 function isPathInsideRoot(root, filePath) {
-  const relative3 = path11.relative(root, filePath);
-  return relative3 === "" || !relative3.startsWith("..") && !path11.isAbsolute(relative3);
+  const relative3 = path12.relative(root, filePath);
+  return relative3 === "" || !relative3.startsWith("..") && !path12.isAbsolute(relative3);
 }
 function normalizeStackPath(value) {
   const withoutQuery = value.replace(/[?#].*$/, "");
@@ -5113,13 +5318,13 @@ function findStackLocation(stack, root) {
     );
     if (!match) continue;
     const candidate = normalizeStackPath(match[1]);
-    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("/");
+    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("/");
     return {
       absolutePath,
-      displayPath: relativePath || path11.basename(absolutePath),
+      displayPath: relativePath || path12.basename(absolutePath),
       line: Number(match[2]),
       column: Number(match[3])
     };
@@ -5128,7 +5333,7 @@ function findStackLocation(stack, root) {
 }
 function createSourceFrame(location) {
   try {
-    const sourceLines = fs7.readFileSync(location.absolutePath, "utf8").split(/\r?\n/);
+    const sourceLines = fs8.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);
@@ -5151,13 +5356,13 @@ function createSourceFrame(location) {
   }
 }
 function sanitizeStack(stack, root) {
-  const normalizedRoot = path11.resolve(root);
+  const normalizedRoot = path12.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, path11.resolve(root));
+  const location = findStackLocation(rawStack, path12.resolve(root));
   return {
     name: redactErrorText(normalizedError.name || "Error"),
     message: redactErrorText(normalizedError.message || "Unknown server rendering error"),
@@ -5426,7 +5631,7 @@ function createRouteStateProps(input) {
 function readAppPackageIdentity(root) {
   try {
     return JSON.parse(
-      fs8.readFileSync(path12.join(root || process.cwd(), "package.json"), "utf8")
+      fs9.readFileSync(path13.join(root || process.cwd(), "package.json"), "utf8")
     );
   } catch {
     return {};
@@ -5733,10 +5938,10 @@ var ServerRenderer = class {
    * Load SSG manifest from build output
    */
   loadSSGManifest() {
-    const manifestPath = path12.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
+    const manifestPath = path13.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
     let content;
     try {
-      content = fs8.readFileSync(manifestPath, "utf-8");
+      content = fs9.readFileSync(manifestPath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
@@ -5955,10 +6160,10 @@ var ServerRenderer = class {
       return true;
     }
     try {
-      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");
+      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");
         await this.cacheSSGPage(page, html, {
           document: true,
           createdAt: stat.mtimeMs
@@ -6721,11 +6926,11 @@ var ServerRenderer = class {
         if (isFarmIntegrationProviderComponentReference(provider.component)) {
           providerSourceModule = provider.component.module;
           const providerModuleId = provider.component.module.startsWith(".") ? toViteModuleId(
-            path12.resolve(this.config.root, provider.component.module),
+            path13.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(path12.resolve(this.config.root, provider.component.module)).href : provider.component.module
+            provider.component.module.startsWith(".") ? pathToFileURL2(path13.resolve(this.config.root, provider.component.module)).href : provider.component.module
           );
           ProviderComponent = providerModule[provider.component.export || "default"];
         } else if (typeof provider.component === "function") {
@@ -6992,7 +7197,7 @@ var ServerRenderer = class {
               logger.warn(`Could not read metadata for ${pattern} in sitemap.xml: ${error}`);
               return void 0;
             }),
-            fs8.promises.stat(route.modulePath).catch(() => void 0)
+            fs9.promises.stat(route.modulePath).catch(() => void 0)
           ]);
           return { pattern, module, lastModified: stat?.mtime.toISOString() };
         })
@@ -7243,7 +7448,7 @@ var ServerRenderer = class {
       res.end();
       return;
     }
-    res.write(await fs8.promises.readFile(image.modulePath));
+    res.write(await fs9.promises.readFile(image.modulePath));
     res.end();
   }
   async renderRouteErrorBoundary(req, res, options) {
@@ -8064,13 +8269,13 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       res.end(createFarmMarkdownErrorBody(404, pathname, this.config.basePath || "/"));
       return;
     }
-    const appDir = path12.join(this.config.root, this.config.srcDir, "app");
+    const appDir = path13.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 = path12.join(appDir, `layout${ext}`);
-        if (fs8.existsSync(layoutPath)) {
+        const layoutPath = path13.join(appDir, `layout${ext}`);
+        if (fs9.existsSync(layoutPath)) {
           layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
           break;
         }
@@ -8283,7 +8488,7 @@ ${clientScript}
 };
 
 // src/app.ts
-import path13 from "path";
+import path14 from "path";
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -8423,7 +8628,7 @@ var FarmApp = class {
     }
     const componentExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     const rootLayoutPaths = appDirs.flatMap(
-      (appDir) => componentExtensions.map((extension) => path13.join(appDir, `layout${extension}`))
+      (appDir) => componentExtensions.map((extension) => path14.join(appDir, `layout${extension}`))
     );
     const hasRootLayout = await Promise.all(rootLayoutPaths.map((p) => fileExists(p))).then(
       (results) => results.some(Boolean)
@@ -8487,13 +8692,13 @@ function resolveFarmImageServerRuntime(images, preset) {
 }
 
 // src/app-manifest-packages.ts
-import fs9 from "fs";
-import path14 from "path";
+import fs10 from "fs";
+import path15 from "path";
 var FARM_PACKAGE = /^@(?:farm\.js|farming-labs)\/[a-z0-9._-]+$/;
 function resolveFarmAppPackages(root) {
   let manifest;
   try {
-    manifest = JSON.parse(fs9.readFileSync(path14.join(root, "package.json"), "utf8"));
+    manifest = JSON.parse(fs10.readFileSync(path15.join(root, "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -8508,13 +8713,13 @@ function resolveFarmAppPackages(root) {
     for (let dir = root; ; ) {
       try {
         const { version } = JSON.parse(
-          fs9.readFileSync(path14.join(dir, "node_modules", name, "package.json"), "utf8")
+          fs10.readFileSync(path15.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 = path14.dirname(dir);
+        const parent = path15.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -8524,9 +8729,9 @@ function resolveFarmAppPackages(root) {
 }
 
 // src/app-manifest-webmcp.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path15 from "path";
+import path16 from "path";
 import { globSync } from "tinyglobby";
 var WEBMCP_CLIENT = "@farm.js/webmcp/client";
 var DEFINERS = /* @__PURE__ */ new Set(["defineWebMCPTool", "registerWebMCPTool", "registerWebMCPTools"]);
@@ -8544,7 +8749,7 @@ var LANGS = {
   cjs: "jsx",
   jsx: "jsx"
 };
-var parseAst2;
+var parseAst3;
 function staticValue(node) {
   if (!node) return NOT_STATIC;
   switch (node.type) {
@@ -8621,13 +8826,13 @@ function toolFromObject(object) {
 }
 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)(
+  const lang = LANGS[path16.extname(filename).slice(1)] ?? "tsx";
+  parseAst3 ?? (parseAst3 = createRequire2(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
   let program;
   try {
-    program = parseAst2(code, { lang });
+    program = parseAst3(code, { lang });
   } catch {
     return [];
   }
@@ -8668,7 +8873,7 @@ function findFarmWebMCPTools(code, filename = "module.tsx") {
 }
 var cache = /* @__PURE__ */ new Map();
 function collectFarmWebMCPTools(root, srcDir = "src") {
-  const base = path15.resolve(root, srcDir);
+  const base = path16.resolve(root, srcDir);
   let files;
   try {
     files = globSync("**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", {
@@ -8685,7 +8890,7 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
   for (const file of files.sort()) {
     let mtimeMs;
     try {
-      mtimeMs = fs10.statSync(file).mtimeMs;
+      mtimeMs = fs11.statSync(file).mtimeMs;
     } catch {
       continue;
     }
@@ -8693,7 +8898,7 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
     if (!entry || entry.mtimeMs !== mtimeMs) {
       let code = "";
       try {
-        code = fs10.readFileSync(file, "utf8");
+        code = fs11.readFileSync(file, "utf8");
       } catch {
       }
       entry = { mtimeMs, tools: findFarmWebMCPTools(code, file) };
@@ -8709,8 +8914,8 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
 }
 
 // src/client-cache-persistence-build.ts
-import fs11 from "fs";
-import path16 from "path";
+import fs12 from "fs";
+import path17 from "path";
 var ADAPTER_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
 function resolveFarmClientCacheAdapterEntry(root, cache2) {
   const client = cache2?.client;
@@ -8721,7 +8926,7 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
       'cache.client.adapter must be a module path string, for example "./src/cache-adapter".'
     );
   }
-  const resolved = path16.resolve(root, adapter);
+  const resolved = path17.resolve(root, adapter);
   const found = resolveAdapterFile(resolved);
   if (!found) {
     throw new Error(
@@ -8734,10 +8939,10 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
   return { importPath: found.replace(/\\/g, "/"), options };
 }
 function resolveAdapterFile(resolved) {
-  if (fs11.existsSync(resolved) && fs11.statSync(resolved).isFile()) return resolved;
+  if (fs12.existsSync(resolved) && fs12.statSync(resolved).isFile()) return resolved;
   for (const extension of ADAPTER_EXTENSIONS) {
     const candidate = `${resolved}.${extension}`;
-    if (fs11.existsSync(candidate) && fs11.statSync(candidate).isFile()) return candidate;
+    if (fs12.existsSync(candidate) && fs12.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -8947,8 +9152,8 @@ async function readFarmNavigationStream(body, flushToken) {
 // src/docs/client-config.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path17 from "path";
-var parseAst3;
+import path18 from "path";
+var parseAst4;
 function propertyKeyName(property2) {
   if (property2.computed) return void 0;
   const key = property2.key;
@@ -8957,11 +9162,11 @@ function propertyKeyName(property2) {
   return void 0;
 }
 function redactFarmDocsClientConfig(code, filename) {
-  parseAst3 ?? (parseAst3 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
+  parseAst4 ?? (parseAst4 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
-  const extension = path17.extname(filename);
-  const program = parseAst3(code, {
+  const extension = path18.extname(filename);
+  const program = parseAst4(code, {
     lang: extension === ".tsx" || extension === ".jsx" ? "tsx" : "ts"
   });
   const edits = [];
@@ -9022,7 +9227,7 @@ function farmDocsClientConfigPlugin(configModule) {
 }
 
 // src/server/vite-config.ts
-import path18 from "path";
+import path19 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",
@@ -9049,9 +9254,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
   );
 }
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = path18.resolve(projectRoot);
+  const resolvedProjectRoot = path19.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = path18.relative(resolvedProjectRoot, path18.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = path19.relative(resolvedProjectRoot, path19.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -9073,7 +9278,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 }
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": path18.resolve(projectRoot, srcDir)
+    "@": path19.resolve(projectRoot, srcDir)
   };
 }
 function mergeNoExternal(farmValue, userValue) {
@@ -9221,6 +9426,7 @@ ${FARM_DARK_VARIANT}
 }
 
 export {
+  rewriteFarmPackageClientImports,
   withPackageClientBoundaryCache,
   usePackageClientBoundaryCacheFile,
   resolveModuleSourcePath,
@@ -9237,6 +9443,8 @@ export {
   createMarkdownPageHydrationPlanner,
   enforceFarmIsolatedHydrationRouteBudget,
   isIsolatableClientBoundarySource,
+  isFarmPackageClientBoundary,
+  collectFarmClientPackageImports,
   RouteManager,
   resolveDevGlobalStylesheetHref,
   resolveFarmNotFoundComponentPath,