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

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

@@ -30,10 +30,10 @@ import {
   renderFarmLocaleAlternateLinks,
   resolveDefaultErrorStatus,
   routeBoundaryCoversDirectory
-} from "./chunk-7UPCJDB5.mjs";
+} from "./chunk-YUEYBL35.mjs";
 import {
   listFarmMCPLlmsTxtLinks
-} from "./chunk-E73PGHSR.mjs";
+} from "./chunk-4TKAIO2F.mjs";
 import {
   FARM_DEFAULT_MCP_PATH,
   collectFarmDefaultMCPPages,
@@ -41,7 +41,7 @@ import {
   farmConfigMountsMCP,
   isFarmDefaultMCPPathname,
   resolveFarmDefaultMCPServer
-} from "./chunk-KRRZJ77U.mjs";
+} from "./chunk-E5DXF5GE.mjs";
 import {
   createFarmMetadataImageResponse
 } from "./chunk-OZK2DS44.mjs";
@@ -64,10 +64,10 @@ import {
 import {
   createFarmMarkdownRouteModuleFromFile,
   loadFarmMdxComponents
-} from "./chunk-YVJV7Q2X.mjs";
+} from "./chunk-3BLEXUGE.mjs";
 import {
   isFarmMarkdownPageFile
-} from "./chunk-GW4YUIHW.mjs";
+} from "./chunk-3Z63X45F.mjs";
 import {
   _setDefaultFarmThemeConfig,
   getTheme
@@ -105,14 +105,14 @@ import {
   resolveFarmAgentCrawlers,
   resolveFarmAgentSitemap,
   resolveFarmPerformanceConfig
-} from "./chunk-KBRZAYI7.mjs";
+} from "./chunk-LDNSSHEG.mjs";
 import {
   collectFarmLlmsTxtPages,
   createFarmDefaultLlmsTxt,
   createFarmLlmsMarkdownReader,
   renderFarmLlmsFullTxt,
   resolveFarmLlmsTxtConfig
-} from "./chunk-LAZK6UV7.mjs";
+} from "./chunk-YAJTD3ZG.mjs";
 import {
   createFarmCspNonce,
   createFarmCspNonceRewriter,
@@ -152,7 +152,7 @@ import {
   farmRequestWantsMarkdown,
   getFarmMarkdownAlternatePath,
   resolveMarkdownConfig
-} from "./chunk-N77JBPLC.mjs";
+} from "./chunk-LPDKG6RA.mjs";
 import {
   initStorage
 } from "./chunk-TJVUTGED.mjs";
@@ -254,7 +254,7 @@ import {
 } from "./chunk-LM2YOGDK.mjs";
 import {
   FARM_VERSION
-} from "./chunk-6CYQQQGR.mjs";
+} from "./chunk-R4PHCZ3G.mjs";
 import {
   resolveFarmTrailingSlashRedirect,
   setFarmTrailingSlashPreference
@@ -326,15 +326,240 @@ import {
 } from "./chunk-AYP2YFVN.mjs";
 
 // src/utils/client-component.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/package-client-boundary-cache.ts
+import { AsyncLocalStorage } from "async_hooks";
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
+var SCHEMA_VERSION = 1;
+var NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;
+var PackageInspectionTrace = class {
+  constructor() {
+    this.files = /* @__PURE__ */ new Set();
+    this.stops = /* @__PURE__ */ new Set();
+    this.fileStamps = [];
+    this.directoryStamps = /* @__PURE__ */ new Map();
+  }
+  visit(file) {
+    this.files.add(file);
+    const directory = path.dirname(file);
+    if (!this.directoryStamps.has(directory)) {
+      this.directoryStamps.set(directory, stampPackagePath(directory, "directory"));
+    }
+    this.fileStamps.push(stampPackagePath(file, "file"));
+  }
+  /** The inspection reached `file` after it was already visited. */
+  stop(file) {
+    if (!this.files.has(file)) this.stops.add(file);
+  }
+  toEntry(result) {
+    const entry = {
+      result: { ...result },
+      files: Array.from(this.files),
+      stops: Array.from(this.stops)
+    };
+    const files = this.fileStamps.filter((stamp) => stamp !== void 0);
+    const directories = Array.from(this.directoryStamps.values()).filter(
+      (stamp) => stamp !== void 0
+    );
+    if (files.length === this.fileStamps.length && directories.length === this.directoryStamps.size) {
+      entry.stamps = { files, directories };
+    }
+    return entry;
+  }
+};
+function stampPackagePath(target, kind) {
+  if (!`${target}${path.sep}`.includes(NODE_MODULES_SEGMENT)) return void 0;
+  try {
+    const stat = fs.statSync(target, { throwIfNoEntry: false });
+    if (!stat || (kind === "file" ? !stat.isFile() : !stat.isDirectory())) return void 0;
+    return [target, stat.size, stat.mtimeMs, stat.ctimeMs];
+  } catch {
+    return void 0;
+  }
+}
+var PackageClientBoundaryCache = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.stored = /* @__PURE__ */ new Map();
+    this.storedPaths = [];
+    this.unchangedPaths = /* @__PURE__ */ new Map();
+    this.dirty = false;
+  }
+  load(file) {
+    this.file = file;
+    const stored = readStoredCache(file);
+    if (!stored) {
+      this.dirty = true;
+      return;
+    }
+    this.storedPaths = stored.paths;
+    this.stored = new Map(Object.entries(stored.entries));
+  }
+  /** An inspection of `key` that applies to `visited`. */
+  find(key, visited) {
+    let entries = this.entries.get(key);
+    const stored = this.stored.get(key);
+    if (stored) {
+      this.stored.delete(key);
+      entries ?? (entries = []);
+      this.entries.set(key, entries);
+      for (const entry of stored) {
+        const restored = this.restore(entry);
+        if (restored) entries.push(restored);
+        else this.dirty = true;
+      }
+    }
+    return entries?.find(
+      (entry) => entry.stops.every((file) => visited.has(file)) && !entry.files.some((file) => visited.has(file))
+    );
+  }
+  add(key, entry) {
+    const entries = this.entries.get(key);
+    if (entries) entries.push(entry);
+    else this.entries.set(key, [entry]);
+    if (entry.stamps) this.dirty = true;
+  }
+  async persist() {
+    const file = this.file;
+    if (!file || !this.dirty && this.stored.size === 0) return;
+    const paths = [];
+    const pathIndexes = /* @__PURE__ */ new Map();
+    const indexOf = (stamp) => {
+      let index = pathIndexes.get(stamp[0]);
+      if (index === void 0) {
+        index = paths.push(stamp) - 1;
+        pathIndexes.set(stamp[0], index);
+      }
+      return index;
+    };
+    const entries = {};
+    for (const [key, variants] of this.entries) {
+      const persisted = variants.flatMap(
+        ({ result, stops, stamps }) => stamps ? [
+          {
+            result,
+            files: stamps.files.map(indexOf),
+            directories: stamps.directories.map(indexOf),
+            stops
+          }
+        ] : []
+      );
+      if (persisted.length > 0) entries[key] = persisted;
+    }
+    const contents = JSON.stringify({
+      schema: SCHEMA_VERSION,
+      farm: FARM_VERSION,
+      paths,
+      entries
+    });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await fs.promises.mkdir(path.dirname(file), { recursive: true });
+      await fs.promises.writeFile(temporary, contents);
+      await fs.promises.rename(temporary, file);
+    } catch {
+      await fs.promises.rm(temporary, { force: true }).catch(() => {
+      });
+    }
+  }
+  restore(entry) {
+    const files = this.restoreStamps(entry.files, "file");
+    const directories = this.restoreStamps(entry.directories, "directory");
+    if (!files || !directories) return void 0;
+    return {
+      result: entry.result,
+      files: files.map(([file]) => file),
+      stops: entry.stops,
+      stamps: { files, directories }
+    };
+  }
+  restoreStamps(indexes, kind) {
+    const stamps = [];
+    for (const index of indexes) {
+      const stamp = this.storedPaths[index];
+      let unchanged = this.unchangedPaths.get(index);
+      if (unchanged === void 0) {
+        const current = stampPackagePath(stamp[0], kind);
+        unchanged = current !== void 0 && current[1] === stamp[1] && current[2] === stamp[2] && current[3] === stamp[3];
+        this.unchangedPaths.set(index, unchanged);
+      }
+      if (!unchanged) return void 0;
+      stamps.push(stamp);
+    }
+    return stamps;
+  }
+};
+function readStoredCache(file) {
+  let value;
+  try {
+    value = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord(value) || value.schema !== SCHEMA_VERSION || value.farm !== FARM_VERSION) {
+    return null;
+  }
+  const { paths, entries } = value;
+  if (!Array.isArray(paths) || !paths.every(isPathStamp) || !isRecord(entries)) return null;
+  const valid = {};
+  for (const [key, variants] of Object.entries(entries)) {
+    if (!Array.isArray(variants)) continue;
+    const usable = variants.filter((entry) => isStoredEntry(entry, paths.length));
+    if (usable.length > 0) valid[key] = usable;
+  }
+  return { schema: SCHEMA_VERSION, farm: FARM_VERSION, paths, entries: valid };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPathStamp(value) {
+  return Array.isArray(value) && value.length === 4 && typeof value[0] === "string" && path.isAbsolute(value[0]) && value.slice(1).every((part) => typeof part === "number" && Number.isFinite(part));
+}
+function isPathIndexList(value, pathCount) {
+  return Array.isArray(value) && value.length > 0 && value.every((index) => Number.isSafeInteger(index) && index >= 0 && index < pathCount);
+}
+function isStoredEntry(value, pathCount) {
+  if (!isRecord(value) || !isRecord(value.result)) return false;
+  const { isClientComponent, shouldHydrate, islandStrategy } = value.result;
+  return isPathIndexList(value.files, pathCount) && isPathIndexList(value.directories, pathCount) && Array.isArray(value.stops) && value.stops.every((file) => typeof file === "string" && path.isAbsolute(file)) && typeof isClientComponent === "boolean" && typeof shouldHydrate === "boolean" && (islandStrategy === null || isFarmIslandStrategy(islandStrategy)) && Object.keys(value.result).length === 3;
+}
+var STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/package-client-boundary-cache");
+function getStorage() {
+  const runtime = globalThis;
+  const existing = runtime[STORAGE_KEY];
+  if (existing instanceof AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new AsyncLocalStorage();
+  runtime[STORAGE_KEY] = storage;
+  return storage;
+}
+function getPackageClientBoundaryCache() {
+  return getStorage().getStore();
+}
+async function withPackageClientBoundaryCache(operation) {
+  const cache2 = new PackageClientBoundaryCache();
+  try {
+    return await getStorage().run(cache2, operation);
+  } finally {
+    await cache2.persist();
+  }
+}
+function usePackageClientBoundaryCacheFile(file) {
+  getPackageClientBoundaryCache()?.load(file);
+}
+
+// src/utils/client-component.ts
 function readIfExists(filePath) {
   try {
-    if (!filePath || !fs.existsSync(filePath)) {
+    if (!filePath || !fs2.existsSync(filePath)) {
       return null;
     }
-    return fs.readFileSync(filePath, "utf-8");
+    return fs2.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -353,21 +578,21 @@ function resolveModuleSourcePath(modulePath, root) {
     }
     if (modulePath.startsWith("/@fs/")) {
       const fsPath = withoutQuery.slice("/@fs/".length);
-      candidates.add(path.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
+      candidates.add(path2.normalize(/^[A-Za-z]:/.test(fsPath) ? fsPath : `/${fsPath}`));
     }
   }
   if (root && modulePath) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path.join(root, normalized));
-    candidates.add(path.resolve(root, normalized));
+    candidates.add(path2.join(root, normalized));
+    candidates.add(path2.resolve(root, normalized));
   }
   if (withoutQuery?.startsWith("/src/")) {
     const normalized = withoutQuery.replace(/^\/+/, "");
-    candidates.add(path.join(process.cwd(), normalized));
-    candidates.add(path.resolve(process.cwd(), normalized));
+    candidates.add(path2.join(process.cwd(), normalized));
+    candidates.add(path2.resolve(process.cwd(), normalized));
   }
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -384,8 +609,8 @@ var FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES = 4;
 function isolatedHydrationBoundaryLimit() {
   const benchmarkRoot = process.env.FARM_INTERNAL_ISOLATED_HYDRATION_BENCHMARK_ROOT;
   const benchmarkLimit = Number(process.env.FARM_INTERNAL_ISOLATED_HYDRATION_BENCHMARK_LIMIT);
-  const resolvedBenchmarkRoot = benchmarkRoot ? path.resolve(benchmarkRoot) : null;
-  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path.sep}`));
+  const resolvedBenchmarkRoot = benchmarkRoot ? path2.resolve(benchmarkRoot) : null;
+  const isBenchmarkFixture = process.env.FARM_INTERNAL_BENCHMARK === "isolated-hydration" && resolvedBenchmarkRoot !== null && (process.cwd() === resolvedBenchmarkRoot || process.cwd().startsWith(`${resolvedBenchmarkRoot}${path2.sep}`));
   return isBenchmarkFixture && Number.isSafeInteger(benchmarkLimit) && benchmarkLimit > FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES ? benchmarkLimit : FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES;
 }
 var RESOLVABLE_SOURCE_EXTENSIONS = [
@@ -1225,7 +1450,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
   let fallbackReason;
   let fallbackHint;
   let costGuardExceeded = false;
-  const projectRoot = root ? path.resolve(root) : void 0;
+  const projectRoot = root ? path2.resolve(root) : void 0;
   const visit = (moduleSourcePath) => {
     if (fallbackReason) return 0;
     const cached = estimates.get(moduleSourcePath);
@@ -1235,7 +1460,7 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
     const content = readIfExists(moduleSourcePath);
     const parsed = parseClientModuleMetadata(content, false);
     if (parsed.isClientComponent) {
-      if (projectRoot && !path.resolve(moduleSourcePath).startsWith(`${projectRoot}${path.sep}`)) {
+      if (projectRoot && !path2.resolve(moduleSourcePath).startsWith(`${projectRoot}${path2.sep}`)) {
         fallbackReason = `client boundary ${moduleSourcePath} is outside the application root`;
         fallbackHint = "Move the component into the application, or publish it as a package (package client components render as static HTML)";
         return 0;
@@ -1368,7 +1593,24 @@ function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandE
   };
 }
 function inspectPackageClientBoundary(resolvedPath, root, visited) {
+  const cache2 = getPackageClientBoundaryCache();
+  if (!cache2 || !resolvedPath || visited.has(resolvedPath)) {
+    return traversePackageClientBoundary(resolvedPath, root, visited);
+  }
+  const key = `${root ?? ""}\0${resolvedPath}`;
+  const cached = cache2.find(key, visited);
+  if (cached) {
+    for (const file of cached.files) visited.add(file);
+    return { ...cached.result };
+  }
+  const trace = new PackageInspectionTrace();
+  const result = traversePackageClientBoundary(resolvedPath, root, visited, trace);
+  cache2.add(key, trace.toEntry(result));
+  return result;
+}
+function traversePackageClientBoundary(resolvedPath, root, visited, trace) {
   if (!resolvedPath || visited.has(resolvedPath)) {
+    if (resolvedPath) trace?.stop(resolvedPath);
     return {
       isClientComponent: false,
       shouldHydrate: false,
@@ -1376,6 +1618,7 @@ function inspectPackageClientBoundary(resolvedPath, root, visited) {
     };
   }
   visited.add(resolvedPath);
+  trace?.visit(resolvedPath);
   const content = readIfExists(resolvedPath);
   const parsed = parseClientModuleMetadata(content, false);
   let importsClientBoundary = false;
@@ -1383,7 +1626,7 @@ function inspectPackageClientBoundary(resolvedPath, root, visited) {
   for (const specifier of getImportSpecifiers(content)) {
     if (!specifier.startsWith(".") && !specifier.startsWith("/")) continue;
     const importedPath = resolveImportedModuleSourcePath(resolvedPath, specifier, root);
-    const importedMetadata = inspectPackageClientBoundary(importedPath, root, visited);
+    const importedMetadata = traversePackageClientBoundary(importedPath, root, visited, trace);
     if (!importedMetadata.shouldHydrate) continue;
     importsClientBoundary = true;
     if (importedIslandStrategy === null) {
@@ -1482,7 +1725,7 @@ var ALIAS_IMPORT = /^(?:@\/|~\/|#)/;
 function warnUnresolvedAliasImport(importerPath, specifier, root) {
   if (!ALIAS_IMPORT.test(specifier) || warnedUnresolvedAliasImports.has(specifier)) return;
   warnedUnresolvedAliasImports.add(specifier);
-  const importer = root ? path.relative(root, importerPath) : importerPath;
+  const importer = root ? path2.relative(root, importerPath) : importerPath;
   logger.warn(
     `Could not resolve "${specifier}" (imported by ${importer}) while checking which pages need client JavaScript. If it holds client components, they will not hydrate. Map the alias in tsconfig.json "paths" or package.json "imports".`
   );
@@ -1491,7 +1734,7 @@ var projectImportAliasCache = /* @__PURE__ */ new Map();
 var PROJECT_ALIAS_FILES = ["tsconfig.json", "jsconfig.json", "package.json"];
 function resolveProjectAliasSourcePath(specifier, root) {
   if (!root) return void 0;
-  const projectRoot = path.resolve(root);
+  const projectRoot = path2.resolve(root);
   let match;
   for (const alias of getProjectImportAliases(projectRoot)) {
     const captured = matchProjectImportAlias(alias, specifier);
@@ -1501,7 +1744,7 @@ function resolveProjectAliasSourcePath(specifier, root) {
   if (!match) return void 0;
   const resolved = resolveSourceCandidate(
     match.alias.targets.map(
-      (target) => path.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+      (target) => path2.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
     )
   );
   return resolved && /\.d\.[cm]?ts$/.test(resolved) ? null : resolved;
@@ -1516,7 +1759,7 @@ function matchProjectImportAlias(alias, specifier) {
 function getProjectImportAliases(projectRoot) {
   const stamp = PROJECT_ALIAS_FILES.map((file) => {
     try {
-      return String(fs.statSync(path.join(projectRoot, file)).mtimeMs);
+      return String(fs2.statSync(path2.join(projectRoot, file)).mtimeMs);
     } catch {
       return "-";
     }
@@ -1534,7 +1777,7 @@ function getProjectImportAliases(projectRoot) {
       prefix: "@/",
       suffix: "",
       wildcard: true,
-      targets: [path.join(projectRoot, sourceDir, "*")]
+      targets: [path2.join(projectRoot, sourceDir, "*")]
     });
   }
   projectImportAliasCache.set(projectRoot, { stamp: cacheStamp, aliases });
@@ -1542,8 +1785,8 @@ function getProjectImportAliases(projectRoot) {
 }
 function readTsconfigPathAliases(projectRoot) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
-    const configPath = path.join(projectRoot, name);
-    if (!fs.existsSync(configPath)) continue;
+    const configPath = path2.join(projectRoot, name);
+    if (!fs2.existsSync(configPath)) continue;
     const resolved = readTsconfigPaths(configPath, /* @__PURE__ */ new Set());
     if (!resolved?.paths) return [];
     const base = resolved.baseUrl ?? resolved.pathsDirectory;
@@ -1555,7 +1798,7 @@ function readTsconfigPathAliases(projectRoot) {
           prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
           suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
           wildcard: wildcardIndex !== -1,
-          targets: targets.filter((target) => typeof target === "string").map((target) => path.resolve(base, target))
+          targets: targets.filter((target) => typeof target === "string").map((target) => path2.resolve(base, target))
         }
       ];
     });
@@ -1567,27 +1810,27 @@ function readTsconfigPaths(configPath, visited) {
   visited.add(configPath);
   const config = readJsonWithComments(configPath);
   if (!config) return null;
-  const directory = path.dirname(configPath);
+  const directory = path2.dirname(configPath);
   const parents = (Array.isArray(config.extends) ? config.extends : [config.extends]).filter(
     (parent) => typeof parent === "string" && parent.startsWith(".")
   );
   let inherited = null;
   for (const parent of parents) {
-    const parentPath = path.resolve(
+    const parentPath = path2.resolve(
       directory,
       parent.endsWith(".json") ? parent : `${parent}.json`
     );
     inherited = readTsconfigPaths(parentPath, visited) ?? inherited;
   }
   const options = config.compilerOptions ?? {};
-  const baseUrl = typeof options.baseUrl === "string" ? path.resolve(directory, options.baseUrl) : inherited?.baseUrl;
+  const baseUrl = typeof options.baseUrl === "string" ? path2.resolve(directory, options.baseUrl) : inherited?.baseUrl;
   if (options.paths && typeof options.paths === "object") {
     return { paths: options.paths, pathsDirectory: directory, baseUrl };
   }
   return inherited ? { ...inherited, baseUrl } : { pathsDirectory: directory, baseUrl };
 }
 function readPackageImportAliases(projectRoot) {
-  const imports = readPackageJson(path.join(projectRoot, "package.json"))?.imports;
+  const imports = readPackageJson(path2.join(projectRoot, "package.json"))?.imports;
   if (!imports || typeof imports !== "object") return [];
   return Object.entries(imports).flatMap(([pattern, value]) => {
     const target = resolveConditionalExportTarget(value);
@@ -1598,7 +1841,7 @@ function readPackageImportAliases(projectRoot) {
         prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
         suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
         wildcard: wildcardIndex !== -1,
-        targets: [path.resolve(projectRoot, target)]
+        targets: [path2.resolve(projectRoot, target)]
       }
     ];
   });
@@ -1606,7 +1849,7 @@ function readPackageImportAliases(projectRoot) {
 function readJsonWithComments(filePath) {
   let source;
   try {
-    source = fs.readFileSync(filePath, "utf8");
+    source = fs2.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -1644,7 +1887,7 @@ function resolveImportedModuleSourcePath(importerPath, specifier, root) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
   }
   const candidates = /* @__PURE__ */ new Set();
-  const basePath = specifier.startsWith(".") ? path.resolve(path.dirname(importerPath), specifier) : root ? path.resolve(root, specifier.replace(/^\/+/, "")) : path.resolve(specifier);
+  const basePath = specifier.startsWith(".") ? path2.resolve(path2.dirname(importerPath), specifier) : root ? path2.resolve(root, specifier.replace(/^\/+/, "")) : path2.resolve(specifier);
   candidates.add(basePath);
   return resolveSourceCandidate(candidates);
 }
@@ -1654,45 +1897,45 @@ function resolvePackageModuleSourcePath(importerPath, specifier, root) {
   const packageSubpath = packageParts.slice(packageName.startsWith("@") ? 2 : 1).join("/");
   const packageDirectory = findPackageDirectory(importerPath, packageName, root);
   if (!packageDirectory) return null;
-  const packageJsonPath = path.join(packageDirectory, "package.json");
+  const packageJsonPath = path2.join(packageDirectory, "package.json");
   const packageJson = readPackageJson(packageJsonPath);
   const exportKey = packageSubpath ? `./${packageSubpath}` : ".";
   const exportTarget = resolvePackageExport(packageJson?.exports, exportKey);
   const candidates = /* @__PURE__ */ new Set();
   if (exportTarget?.startsWith("./")) {
-    candidates.add(path.resolve(packageDirectory, exportTarget));
+    candidates.add(path2.resolve(packageDirectory, exportTarget));
   }
   if (packageSubpath) {
-    candidates.add(path.join(packageDirectory, packageSubpath));
+    candidates.add(path2.join(packageDirectory, packageSubpath));
   } else {
     for (const entry of [packageJson?.browser, packageJson?.module, packageJson?.main]) {
-      if (typeof entry === "string") candidates.add(path.resolve(packageDirectory, entry));
+      if (typeof entry === "string") candidates.add(path2.resolve(packageDirectory, entry));
     }
-    candidates.add(path.join(packageDirectory, "index"));
+    candidates.add(path2.join(packageDirectory, "index"));
   }
   return resolveSourceCandidate(candidates);
 }
 function findPackageDirectory(importerPath, packageName, root) {
   const searchRoots = /* @__PURE__ */ new Set();
-  let current = path.dirname(importerPath);
+  let current = path2.dirname(importerPath);
   while (true) {
     searchRoots.add(current);
-    const parent = path.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   if (root) {
-    current = path.resolve(root);
+    current = path2.resolve(root);
     while (true) {
       searchRoots.add(current);
-      const parent = path.dirname(current);
+      const parent = path2.dirname(current);
       if (parent === current) break;
       current = parent;
     }
   }
   for (const searchRoot of searchRoots) {
-    const packageDirectory = path.join(searchRoot, "node_modules", packageName);
-    if (fs.existsSync(path.join(packageDirectory, "package.json"))) {
+    const packageDirectory = path2.join(searchRoot, "node_modules", packageName);
+    if (fs2.existsSync(path2.join(packageDirectory, "package.json"))) {
       return packageDirectory;
     }
   }
@@ -1700,7 +1943,7 @@ function findPackageDirectory(importerPath, packageName, root) {
 }
 function readPackageJson(packageJsonPath) {
   try {
-    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -1758,11 +2001,11 @@ function resolveSourceCandidate(candidates) {
   for (const candidate of candidates) {
     const paths = [candidate];
     for (const extension of RESOLVABLE_SOURCE_EXTENSIONS) {
-      paths.push(`${candidate}${extension}`, path.join(candidate, `index${extension}`));
+      paths.push(`${candidate}${extension}`, path2.join(candidate, `index${extension}`));
     }
     for (const sourcePath of paths) {
       try {
-        if (fs.statSync(sourcePath).isFile()) return sourcePath;
+        if (fs2.statSync(sourcePath).isFile()) return sourcePath;
       } catch {
       }
     }
@@ -1772,12 +2015,12 @@ function resolveSourceCandidate(candidates) {
 
 // src/routing/route-manager.ts
 import { realpathSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 
 // src/static-metadata-image.ts
 import { createHash } from "crypto";
 import { readFile } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 import { imageSize } from "image-size";
 var STATIC_METADATA_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp"];
 var CONTENT_TYPES = {
@@ -1818,13 +2061,13 @@ async function inspectStaticMetadataImage(filePath) {
   };
 }
 function getStaticMetadataImageAltPath(filePath) {
-  return path2.join(
-    path2.dirname(filePath),
-    `${path2.basename(filePath, path2.extname(filePath))}.alt.txt`
+  return path3.join(
+    path3.dirname(filePath),
+    `${path3.basename(filePath, path3.extname(filePath))}.alt.txt`
   );
 }
 function getStaticMetadataImageExtension(filePath) {
-  const extension = path2.extname(filePath).slice(1).toLowerCase();
+  const extension = path3.extname(filePath).slice(1).toLowerCase();
   return STATIC_METADATA_IMAGE_EXTENSIONS.includes(extension) ? extension : null;
 }
 async function readAltText(filePath) {
@@ -2152,14 +2395,14 @@ var RouteManager = class {
    * Requests still fetch route data, but never inspect component source.
    */
   generateClientManifest(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path3.resolve(projectRoot);
+    const normalizedProjectRoot = path4.resolve(projectRoot);
     if (this.clientManifestCache?.projectRoot === normalizedProjectRoot) {
       return this.clientManifestCache.manifest;
     }
     const toUrlPath = (absolutePath) => {
       const rootRelative = toRootRelativeUrlPath(absolutePath, normalizedProjectRoot);
       if (rootRelative !== void 0) return rootRelative;
-      if (path3.isAbsolute(absolutePath)) {
+      if (path4.isAbsolute(absolutePath)) {
         const normalized = absolutePath.replace(/\\/g, "/");
         return normalized.startsWith("/") ? `/@fs${normalized}` : `/@fs/${normalized}`;
       }
@@ -2338,7 +2581,7 @@ var RouteManager = class {
     for (const { metadata } of [...layoutEntries, ...routeEntries]) {
       if (!metadata.hasIsolatedClientBoundaries && !metadata.serverTreeLayout) continue;
       for (const boundary of metadata.isolatedBoundaries) {
-        isolatedClientBoundaryModules.add(path3.resolve(boundary.modulePath));
+        isolatedClientBoundaryModules.add(path4.resolve(boundary.modulePath));
       }
     }
     const islandsErrors = [
@@ -2389,7 +2632,7 @@ var RouteManager = class {
   }
   /** @internal Client modules selected by the compiled hydration ownership plan. */
   getIsolatedClientBoundaryModules(projectRoot = this.config.root) {
-    const normalizedProjectRoot = path3.resolve(projectRoot);
+    const normalizedProjectRoot = path4.resolve(projectRoot);
     this.generateClientManifest(normalizedProjectRoot);
     return this.clientManifestCache?.isolatedClientBoundaryModules ?? /* @__PURE__ */ new Set();
   }
@@ -2398,7 +2641,7 @@ var RouteManager = class {
    * such a page whole would ship its server code to the browser, so it stays static instead.
    */
   getIslandsErrors(projectRoot = this.config.root) {
-    this.generateClientManifest(path3.resolve(projectRoot));
+    this.generateClientManifest(path4.resolve(projectRoot));
     return this.clientManifestCache?.islandsErrors ?? [];
   }
   /**
@@ -2529,19 +2772,19 @@ var RouteManager = class {
       const markdownFiles = group.files.filter(isFarmMarkdownPageFile);
       if (componentFiles.length > 1) {
         throw new Error(
-          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path4.join(appDir, file)).join(" and ")}.`
         );
       }
       if (markdownFiles.length > 1) {
         throw new Error(
-          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path4.join(appDir, file)).join(" and ")}.`
         );
       }
       const componentFile = componentFiles[0];
       const markdownFile = markdownFiles[0];
       const primaryFile = componentFile || markdownFile;
       if (!primaryFile) continue;
-      const modulePath = path3.join(appDir, primaryFile);
+      const modulePath = path4.join(appDir, primaryFile);
       const existing = this.routes.get(pattern);
       if (existing?.sourceRoot === source.root) {
         throw new Error(
@@ -2552,7 +2795,7 @@ var RouteManager = class {
         route: group.route,
         modulePath,
         ...markdownFile ? {
-          markdownSourcePath: path3.join(appDir, markdownFile)
+          markdownSourcePath: path4.join(appDir, markdownFile)
         } : {},
         pattern,
         ...getPageDirectoryField(group.route, pattern),
@@ -2567,7 +2810,7 @@ var RouteManager = class {
     ]) {
       for (const file of files) {
         const route = parseRoutePath(file);
-        const modulePath = path3.join(appDir, file);
+        const modulePath = path4.join(appDir, file);
         const pattern = createRouteDirectoryPattern(route);
         const existing = target.get(pattern);
         if (existing?.sourceRoot === source.root) {
@@ -2587,7 +2830,7 @@ var RouteManager = class {
     for (const file of [...pageFiles, ...slotDefaultFiles]) {
       const slot = parseRouteSlotFile(file);
       if (!slot) continue;
-      const modulePath = path3.join(appDir, file);
+      const modulePath = path4.join(appDir, file);
       const pattern = this.createRoutePattern(slot.route);
       const ownerPattern = this.createRoutePattern(slot.ownerRoute);
       const ownerDirectory = createRouteDirectoryPattern(slot.ownerRoute);
@@ -2613,11 +2856,11 @@ var RouteManager = class {
       });
     }
     for (const file of metadataImageFiles) {
-      const fileBase = path3.basename(file, path3.extname(file));
+      const fileBase = path4.basename(file, path4.extname(file));
       const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
       const fileName = kind === "twitter" ? "twitter-image" : "opengraph-image";
       const route = parseRoutePath(file);
-      const modulePath = path3.join(appDir, file);
+      const modulePath = path4.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${kind}:${pattern}`;
       const existing = this.metadataImages.get(key);
@@ -2642,11 +2885,11 @@ var RouteManager = class {
     }
     for (const file of metadataRouteFiles) {
       const descriptor = getApplicationMetadataRouteDescriptor(
-        path3.basename(file, path3.extname(file))
+        path4.basename(file, path4.extname(file))
       );
       if (!descriptor) continue;
       const route = parseRoutePath(file);
-      const modulePath = path3.join(appDir, file);
+      const modulePath = path4.join(appDir, file);
       const pattern = this.createRoutePattern(route);
       const key = `${descriptor.kind}:${pattern}`;
       const existing = this.metadataRoutes.get(key);
@@ -3057,12 +3300,12 @@ function toRealPath(filePath) {
 }
 
 // src/server/dev-styles.ts
-import * as fs2 from "fs";
-import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path5 from "path";
 function resolveDevGlobalStylesheetHref(root, srcDir = "src") {
-  const file = path4.join(root, srcDir, "app", "globals.css");
-  if (!fs2.existsSync(file)) return void 0;
-  return `/${path4.relative(root, file).split(path4.sep).join("/")}`;
+  const file = path5.join(root, srcDir, "app", "globals.css");
+  if (!fs3.existsSync(file)) return void 0;
+  return `/${path5.relative(root, file).split(path5.sep).join("/")}`;
 }
 var STYLE_EXTENSIONS = /\.(css|scss|sass|less|styl|stylus)(?:$|\?)/;
 var ALREADY_LINKED = "/src/app/globals.css";
@@ -3085,7 +3328,7 @@ function collectDevStylesheetUrls(modules, alreadyLinked = ALREADY_LINKED) {
 import { createHash as createHash2, timingSafeEqual } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 var FONT_IMPORTS = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/font"]);
@@ -3442,7 +3685,7 @@ ${FONT_SECTION_END}
         return resource;
       }
       const bytes2 = await fetchRemoteFont(url, input.integrity);
-      return this.createSelfHostedResource(bytes2, extension, path5.basename(url.pathname));
+      return this.createSelfHostedResource(bytes2, extension, path6.basename(url.pathname));
     }
     if (input.source.startsWith("/")) {
       return this.createPublicResource(input.moduleId, input.source);
@@ -3465,8 +3708,8 @@ ${FONT_SECTION_END}
     }
     return this.createSelfHostedResource(
       bytes,
-      path5.extname(resolvedPath),
-      path5.basename(resolvedPath)
+      path6.extname(resolvedPath),
+      path6.basename(resolvedPath)
     );
   }
   async createPublicResource(moduleId, source) {
@@ -3477,7 +3720,7 @@ ${FONT_SECTION_END}
       );
     }
     const publicPath = normalizePublicFontPath(source, moduleId);
-    const resolvedPath = path5.resolve(this.publicDir, `.${publicPath}`);
+    const resolvedPath = path6.resolve(this.publicDir, `.${publicPath}`);
     if (!isPathInside(this.publicDir, resolvedPath)) {
       throw fontError(moduleId, `public font path must stay inside publicDir`);
     }
@@ -3493,7 +3736,7 @@ ${FONT_SECTION_END}
         `could not read ${JSON.stringify(source)} from publicDir: ${error.message}`
       );
     }
-    const extension = path5.extname(resolvedPath).toLowerCase();
+    const extension = path6.extname(resolvedPath).toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
     const resource = {
       extension,
@@ -3508,7 +3751,7 @@ ${FONT_SECTION_END}
   createSelfHostedResource(bytes, extension, fileName) {
     const normalizedExtension = extension.toLowerCase();
     const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
-    const baseName = sanitizeFileName(path5.basename(fileName, extension)) || "font";
+    const baseName = sanitizeFileName(path6.basename(fileName, extension)) || "font";
     const outputFileName = `assets/fonts/${baseName}-h${hash}${normalizedExtension}`;
     const key = `${hash}${normalizedExtension}`;
     const existing = this.resources.get(key);
@@ -3861,24 +4104,24 @@ function verifyIntegrity(bytes, integrity) {
   if (!matches) throw new Error("downloaded font did not match its integrity value");
 }
 function resolveLocalFontPath(source, importer, root) {
-  if (source.startsWith(".")) return path5.resolve(path5.dirname(importer), source);
-  if (path5.isAbsolute(source)) {
+  if (source.startsWith(".")) return path6.resolve(path6.dirname(importer), source);
+  if (path6.isAbsolute(source)) {
     return source;
   }
   try {
     return createRequire(pathToFileURL(importer)).resolve(source);
   } catch {
     const segments = source.replace(/\\/g, "/").split("/");
-    if (segments.includes("..")) return path5.resolve(root, source);
-    let current = path5.dirname(importer);
-    const filesystemRoot = path5.parse(current).root;
+    if (segments.includes("..")) return path6.resolve(root, source);
+    let current = path6.dirname(importer);
+    const filesystemRoot = path6.parse(current).root;
     while (true) {
-      const candidate = path5.join(current, "node_modules", ...segments);
+      const candidate = path6.join(current, "node_modules", ...segments);
       if (existsSync2(candidate)) return candidate;
       if (current === filesystemRoot) break;
-      current = path5.dirname(current);
+      current = path6.dirname(current);
     }
-    return path5.resolve(root, "node_modules", ...segments);
+    return path6.resolve(root, "node_modules", ...segments);
   }
 }
 function replaceFontSection(css, section) {
@@ -3911,11 +4154,11 @@ function getGlobalMap(key) {
   return created;
 }
 function normalizeRoot(root) {
-  return path5.resolve(root).replace(/\\/g, "/");
+  return path6.resolve(root).replace(/\\/g, "/");
 }
 function normalizePublicDir(root, publicDir) {
   if (publicDir === false || publicDir === "") return false;
-  return path5.resolve(root, publicDir || "public");
+  return path6.resolve(root, publicDir || "public");
 }
 function normalizePublicFontPath(source, moduleId) {
   if (source.includes("?") || source.includes("#")) {
@@ -3924,8 +4167,8 @@ function normalizePublicFontPath(source, moduleId) {
   return `/${source.replace(/\\/g, "/").replace(/^\/+/, "")}`;
 }
 function isPathInside(parent, child) {
-  const relative3 = path5.relative(parent, child);
-  return relative3 === "" || !relative3.startsWith("..") && !path5.isAbsolute(relative3);
+  const relative3 = path6.relative(parent, child);
+  return relative3 === "" || !relative3.startsWith("..") && !path6.isAbsolute(relative3);
 }
 function normalizeBasePath(value) {
   if (!value || value === "/") return "/";
@@ -3935,7 +4178,7 @@ function joinBasePath(basePath, value) {
   return basePath === "/" ? value : `${basePath.replace(/\/$/, "")}${value}`;
 }
 function extensionFromPath(pathname) {
-  const extension = path5.extname(pathname).toLowerCase();
+  const extension = path6.extname(pathname).toLowerCase();
   if (!FONT_EXTENSION_RE.test(extension)) {
     throw new Error(`[Farm fonts] Remote font URL must end in .woff2, .woff, .ttf, or .otf`);
   }
@@ -4075,7 +4318,7 @@ function fontError(id, message) {
 }
 
 // src/integration-provider-build.ts
-import path6 from "path";
+import path7 from "path";
 function isRendererCompiledComponent(moduleId, rendererComponentExtensions) {
   const lowered = moduleId.toLowerCase();
   return rendererComponentExtensions.some((extension) => lowered.endsWith(extension.toLowerCase()));
@@ -4177,31 +4420,31 @@ function generateFarmIntegrationProviderServerModules(providers, root, rendererC
 }
 function resolveProviderModule(moduleId, root) {
   if (!moduleId.startsWith(".")) return moduleId;
-  return toViteModuleId(path6.resolve(root, moduleId), root);
+  return toViteModuleId(path7.resolve(root, moduleId), root);
 }
 
 // src/server/renderer.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as https from "https";
 import { isIP } from "net";
-import * as path9 from "path";
+import * as path10 from "path";
 import * as tls from "tls";
 import { Readable, Writable } from "stream";
 
 // src/not-found.ts
-import fs3 from "fs";
-import path7 from "path";
+import fs4 from "fs";
+import path8 from "path";
 function resolveFarmNotFoundComponentPath(config, appDirs) {
   const extensions = getFarmRendererComponentExtensions(config.renderer);
   const configuredPath = config.notFound?.component?.trim();
   if (configuredPath) {
-    const componentPath = path7.isAbsolute(configuredPath) ? path7.normalize(configuredPath) : path7.resolve(config.root, configuredPath);
+    const componentPath = path8.isAbsolute(configuredPath) ? path8.normalize(configuredPath) : path8.resolve(config.root, configuredPath);
     if (!extensions.some((extension) => componentPath.endsWith(extension))) {
       throw new Error(
         `notFound.component must use one of the configured renderer extensions: ${extensions.join(", ")}`
       );
     }
-    if (!fs3.existsSync(componentPath) || !fs3.statSync(componentPath).isFile()) {
+    if (!fs4.existsSync(componentPath) || !fs4.statSync(componentPath).isFile()) {
       throw new Error(`notFound.component was not found: ${componentPath}`);
     }
     return componentPath;
@@ -4209,8 +4452,8 @@ function resolveFarmNotFoundComponentPath(config, appDirs) {
   let discoveredPath = null;
   for (const appDir of appDirs) {
     for (const extension of extensions) {
-      const candidate = path7.join(appDir, `not-found${extension}`);
-      if (fs3.existsSync(candidate) && fs3.statSync(candidate).isFile()) {
+      const candidate = path8.join(appDir, `not-found${extension}`);
+      if (fs4.existsSync(candidate) && fs4.statSync(candidate).isFile()) {
         discoveredPath = candidate;
         break;
       }
@@ -4377,8 +4620,8 @@ body {
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/server/error-diagnostics.ts
-import * as fs4 from "fs";
-import * as path8 from "path";
+import * as fs5 from "fs";
+import * as path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var SECRET_VALUE_PATTERN = /\b(api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|secret[_-]?key|token|password|secret)\s*[:=]\s*([^\s,;]+)/gi;
 var BEARER_PATTERN = /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi;
@@ -4386,8 +4629,8 @@ function redactErrorText(value) {
   return value.replace(BEARER_PATTERN, "$1[REDACTED]").replace(SECRET_VALUE_PATTERN, "$1=[REDACTED]");
 }
 function isPathInsideRoot(root, filePath) {
-  const relative3 = path8.relative(root, filePath);
-  return relative3 === "" || !relative3.startsWith("..") && !path8.isAbsolute(relative3);
+  const relative3 = path9.relative(root, filePath);
+  return relative3 === "" || !relative3.startsWith("..") && !path9.isAbsolute(relative3);
 }
 function normalizeStackPath(value) {
   const withoutQuery = value.replace(/[?#].*$/, "");
@@ -4404,13 +4647,13 @@ function findStackLocation(stack, root) {
     );
     if (!match) continue;
     const candidate = normalizeStackPath(match[1]);
-    if (!candidate || candidate.includes(`${path8.sep}node_modules${path8.sep}`)) continue;
-    const absolutePath = path8.resolve(candidate);
-    if (!isPathInsideRoot(root, absolutePath) || !fs4.existsSync(absolutePath)) continue;
-    const relativePath = path8.relative(root, absolutePath).split(path8.sep).join("/");
+    if (!candidate || candidate.includes(`${path9.sep}node_modules${path9.sep}`)) continue;
+    const absolutePath = path9.resolve(candidate);
+    if (!isPathInsideRoot(root, absolutePath) || !fs5.existsSync(absolutePath)) continue;
+    const relativePath = path9.relative(root, absolutePath).split(path9.sep).join("/");
     return {
       absolutePath,
-      displayPath: relativePath || path8.basename(absolutePath),
+      displayPath: relativePath || path9.basename(absolutePath),
       line: Number(match[2]),
       column: Number(match[3])
     };
@@ -4419,7 +4662,7 @@ function findStackLocation(stack, root) {
 }
 function createSourceFrame(location) {
   try {
-    const sourceLines = fs4.readFileSync(location.absolutePath, "utf8").split(/\r?\n/);
+    const sourceLines = fs5.readFileSync(location.absolutePath, "utf8").split(/\r?\n/);
     if (location.line < 1 || location.line > sourceLines.length) return void 0;
     const start = Math.max(1, location.line - 2);
     const end = Math.min(sourceLines.length, location.line + 2);
@@ -4442,13 +4685,13 @@ function createSourceFrame(location) {
   }
 }
 function sanitizeStack(stack, root) {
-  const normalizedRoot = path8.resolve(root);
+  const normalizedRoot = path9.resolve(root);
   return redactErrorText(stack).split(normalizedRoot).join("<project>").replace(/<project>[^\s)]*/g, (segment) => segment.split("\\").join("/")).split("\n").filter((line, index) => index === 0 || !line.includes("node:internal")).slice(0, 14).join("\n");
 }
 function createDefaultErrorDiagnostics(error, root) {
   const normalizedError = error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown server rendering error");
   const rawStack = normalizedError.stack || `${normalizedError.name}: ${normalizedError.message}`;
-  const location = findStackLocation(rawStack, path8.resolve(root));
+  const location = findStackLocation(rawStack, path9.resolve(root));
   return {
     name: redactErrorText(normalizedError.name || "Error"),
     message: redactErrorText(normalizedError.message || "Unknown server rendering error"),
@@ -4702,7 +4945,7 @@ function createRouteStateProps(input) {
 function readAppPackageIdentity(root) {
   try {
     return JSON.parse(
-      fs5.readFileSync(path9.join(root || process.cwd(), "package.json"), "utf8")
+      fs6.readFileSync(path10.join(root || process.cwd(), "package.json"), "utf8")
     );
   } catch {
     return {};
@@ -5001,10 +5244,10 @@ var ServerRenderer = class {
    * Load SSG manifest from build output
    */
   loadSSGManifest() {
-    const manifestPath = path9.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
+    const manifestPath = path10.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
     let content;
     try {
-      content = fs5.readFileSync(manifestPath, "utf-8");
+      content = fs6.readFileSync(manifestPath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
@@ -5223,10 +5466,10 @@ var ServerRenderer = class {
       return true;
     }
     try {
-      const htmlPath = page.urlPath === "/" ? path9.join(this.config.root, this.config.outDir, "client", "index.html") : path9.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
-      if (fs5.existsSync(htmlPath)) {
-        const stat = fs5.statSync(htmlPath);
-        const html = fs5.readFileSync(htmlPath, "utf-8");
+      const htmlPath = page.urlPath === "/" ? path10.join(this.config.root, this.config.outDir, "client", "index.html") : path10.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
+      if (fs6.existsSync(htmlPath)) {
+        const stat = fs6.statSync(htmlPath);
+        const html = fs6.readFileSync(htmlPath, "utf-8");
         await this.cacheSSGPage(page, html, {
           document: true,
           createdAt: stat.mtimeMs
@@ -5961,11 +6204,11 @@ var ServerRenderer = class {
         if (isFarmIntegrationProviderComponentReference(provider.component)) {
           providerSourceModule = provider.component.module;
           const providerModuleId = provider.component.module.startsWith(".") ? toViteModuleId(
-            path9.resolve(this.config.root, provider.component.module),
+            path10.resolve(this.config.root, provider.component.module),
             this.config.root
           ) : provider.component.module;
           const providerModule = this.viteServer ? await loadFarmDevModule(this.viteServer, providerModuleId) : await importRuntimeModule(
-            provider.component.module.startsWith(".") ? pathToFileURL2(path9.resolve(this.config.root, provider.component.module)).href : provider.component.module
+            provider.component.module.startsWith(".") ? pathToFileURL2(path10.resolve(this.config.root, provider.component.module)).href : provider.component.module
           );
           ProviderComponent = providerModule[provider.component.export || "default"];
         } else if (typeof provider.component === "function") {
@@ -6232,7 +6475,7 @@ var ServerRenderer = class {
               logger.warn(`Could not read metadata for ${pattern} in sitemap.xml: ${error}`);
               return void 0;
             }),
-            fs5.promises.stat(route.modulePath).catch(() => void 0)
+            fs6.promises.stat(route.modulePath).catch(() => void 0)
           ]);
           return { pattern, module, lastModified: stat?.mtime.toISOString() };
         })
@@ -6298,7 +6541,7 @@ var ServerRenderer = class {
     const server = this.getDefaultMCPServer();
     const request2 = getCurrentRequestOrNull() ?? createWebRequestFromFarmRequest(req, { trustProxy: this.config.server?.trustProxy });
     try {
-      const { handleFarmDefaultMCPRequest } = await import("./agent-mcp-handler-WWCC4GLG.mjs");
+      const { handleFarmDefaultMCPRequest } = await import("./agent-mcp-handler-7JSKGSOW.mjs");
       const origin = new URL(request2.url).origin;
       const response = await handleFarmDefaultMCPRequest(request2, {
         server,
@@ -6483,7 +6726,7 @@ var ServerRenderer = class {
       res.end();
       return;
     }
-    res.write(await fs5.promises.readFile(image.modulePath));
+    res.write(await fs6.promises.readFile(image.modulePath));
     res.end();
   }
   async renderRouteErrorBoundary(req, res, options) {
@@ -7278,13 +7521,13 @@ window.__FARM_I18N__ = ${getFarmI18nClientSnapshot() ? serializeInlineValue(getF
       res.end(createFarmMarkdownErrorBody(404, pathname, this.config.basePath || "/"));
       return;
     }
-    const appDir = path9.join(this.config.root, this.config.srcDir, "app");
+    const appDir = path10.join(this.config.root, this.config.srcDir, "app");
     const notFoundExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     let layoutModule = null;
     try {
       for (const ext of notFoundExtensions) {
-        const layoutPath = path9.join(appDir, `layout${ext}`);
-        if (fs5.existsSync(layoutPath)) {
+        const layoutPath = path10.join(appDir, `layout${ext}`);
+        if (fs6.existsSync(layoutPath)) {
           layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
           break;
         }
@@ -7497,7 +7740,7 @@ ${clientScript}
 };
 
 // src/app.ts
-import path10 from "path";
+import path11 from "path";
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -7637,7 +7880,7 @@ var FarmApp = class {
     }
     const componentExtensions = getFarmRendererComponentExtensions(this.config.renderer);
     const rootLayoutPaths = appDirs.flatMap(
-      (appDir) => componentExtensions.map((extension) => path10.join(appDir, `layout${extension}`))
+      (appDir) => componentExtensions.map((extension) => path11.join(appDir, `layout${extension}`))
     );
     const hasRootLayout = await Promise.all(rootLayoutPaths.map((p) => fileExists(p))).then(
       (results) => results.some(Boolean)
@@ -7701,13 +7944,13 @@ function resolveFarmImageServerRuntime(images, preset) {
 }
 
 // src/app-manifest-packages.ts
-import fs6 from "fs";
-import path11 from "path";
+import fs7 from "fs";
+import path12 from "path";
 var FARM_PACKAGE = /^@(?:farm\.js|farming-labs)\/[a-z0-9._-]+$/;
 function resolveFarmAppPackages(root) {
   let manifest;
   try {
-    manifest = JSON.parse(fs6.readFileSync(path11.join(root, "package.json"), "utf8"));
+    manifest = JSON.parse(fs7.readFileSync(path12.join(root, "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -7722,13 +7965,13 @@ function resolveFarmAppPackages(root) {
     for (let dir = root; ; ) {
       try {
         const { version } = JSON.parse(
-          fs6.readFileSync(path11.join(dir, "node_modules", name, "package.json"), "utf8")
+          fs7.readFileSync(path12.join(dir, "node_modules", name, "package.json"), "utf8")
         );
         if (typeof version === "string" && /^[0-9A-Za-z.+-]{1,64}$/.test(version))
           versions[name] = version;
         break;
       } catch {
-        const parent = path11.dirname(dir);
+        const parent = path12.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -7738,9 +7981,9 @@ function resolveFarmAppPackages(root) {
 }
 
 // src/app-manifest-webmcp.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path12 from "path";
+import path13 from "path";
 import { globSync } from "tinyglobby";
 var WEBMCP_CLIENT = "@farm.js/webmcp/client";
 var DEFINERS = /* @__PURE__ */ new Set(["defineWebMCPTool", "registerWebMCPTool", "registerWebMCPTools"]);
@@ -7835,7 +8078,7 @@ function toolFromObject(object) {
 }
 function findFarmWebMCPTools(code, filename = "module.tsx") {
   if (!code.includes(WEBMCP_CLIENT)) return [];
-  const lang = LANGS[path12.extname(filename).slice(1)] ?? "tsx";
+  const lang = LANGS[path13.extname(filename).slice(1)] ?? "tsx";
   parseAst ?? (parseAst = createRequire2(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
@@ -7882,7 +8125,7 @@ function findFarmWebMCPTools(code, filename = "module.tsx") {
 }
 var cache = /* @__PURE__ */ new Map();
 function collectFarmWebMCPTools(root, srcDir = "src") {
-  const base = path12.resolve(root, srcDir);
+  const base = path13.resolve(root, srcDir);
   let files;
   try {
     files = globSync("**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", {
@@ -7899,7 +8142,7 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
   for (const file of files.sort()) {
     let mtimeMs;
     try {
-      mtimeMs = fs7.statSync(file).mtimeMs;
+      mtimeMs = fs8.statSync(file).mtimeMs;
     } catch {
       continue;
     }
@@ -7907,7 +8150,7 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
     if (!entry || entry.mtimeMs !== mtimeMs) {
       let code = "";
       try {
-        code = fs7.readFileSync(file, "utf8");
+        code = fs8.readFileSync(file, "utf8");
       } catch {
       }
       entry = { mtimeMs, tools: findFarmWebMCPTools(code, file) };
@@ -7923,8 +8166,8 @@ function collectFarmWebMCPTools(root, srcDir = "src") {
 }
 
 // src/client-plugin-build.ts
-import fs8 from "fs";
-import path13 from "path";
+import fs9 from "fs";
+import path14 from "path";
 var CLIENT_KEYS = [
   "public",
   "setup",
@@ -7944,10 +8187,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 = path13.resolve(root, srcDir);
+  const sourceRoot = path14.resolve(root, srcDir);
   for (const extension of APP_CLIENT_EXTENSIONS) {
-    const candidate = path13.join(sourceRoot, `client.${extension}`);
-    if (fs8.existsSync(candidate) && fs8.statSync(candidate).isFile()) return candidate;
+    const candidate = path14.join(sourceRoot, `client.${extension}`);
+    if (fs9.existsSync(candidate) && fs9.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -7968,11 +8211,11 @@ function resolveFarmClientPlugins(plugins, _root) {
     ];
   });
 }
-function generateFarmClientPluginEntryCode(plugins, root, srcDir = "src", appPublicData) {
+function generateFarmClientPluginEntryCode(plugins, root, srcDir = "src", appPublicData, platform = resolveFarmPlatform()) {
   const resolved = resolveFarmClientPlugins(plugins, root);
   const appClientEntry = root ? resolveFarmAppClientEntry(root, srcDir) : void 0;
   const appImport = appClientEntry ? `import farmAppClientDefinition from ${JSON.stringify(appClientEntry.replace(/\\/g, "/"))};` : "";
-  const mobileShell = resolveFarmPlatform() === "mobile";
+  const mobileShell = platform === "mobile";
   const imports = mobileShell ? [MOBILE_SHELL_CLIENT_IMPORT, appImport].filter(Boolean).join("\n") : appImport;
   const serializedPlugins = mobileShell ? [MOBILE_SHELL_CLIENT_REGISTRATION] : [];
   serializedPlugins.push(
@@ -8189,8 +8432,8 @@ function isArrayIndex(key) {
 }
 
 // src/client-cache-persistence-build.ts
-import fs9 from "fs";
-import path14 from "path";
+import fs10 from "fs";
+import path15 from "path";
 var ADAPTER_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
 function resolveFarmClientCacheAdapterEntry(root, cache2) {
   const client = cache2?.client;
@@ -8201,7 +8444,7 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
       'cache.client.adapter must be a module path string, for example "./src/cache-adapter".'
     );
   }
-  const resolved = path14.resolve(root, adapter);
+  const resolved = path15.resolve(root, adapter);
   const found = resolveAdapterFile(resolved);
   if (!found) {
     throw new Error(
@@ -8214,10 +8457,10 @@ function resolveFarmClientCacheAdapterEntry(root, cache2) {
   return { importPath: found.replace(/\\/g, "/"), options };
 }
 function resolveAdapterFile(resolved) {
-  if (fs9.existsSync(resolved) && fs9.statSync(resolved).isFile()) return resolved;
+  if (fs10.existsSync(resolved) && fs10.statSync(resolved).isFile()) return resolved;
   for (const extension of ADAPTER_EXTENSIONS) {
     const candidate = `${resolved}.${extension}`;
-    if (fs9.existsSync(candidate) && fs9.statSync(candidate).isFile()) return candidate;
+    if (fs10.existsSync(candidate) && fs10.statSync(candidate).isFile()) return candidate;
   }
   return void 0;
 }
@@ -8383,7 +8626,7 @@ async function buildFarmTreeLayouts(layouts, params, source, options) {
 // src/docs/client-config.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path15 from "path";
+import path16 from "path";
 var parseAst2;
 function propertyKeyName(property2) {
   if (property2.computed) return void 0;
@@ -8396,7 +8639,7 @@ function redactFarmDocsClientConfig(code, filename) {
   parseAst2 ?? (parseAst2 = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
     "rolldown/parseAst"
   ).parseAst);
-  const extension = path15.extname(filename);
+  const extension = path16.extname(filename);
   const program = parseAst2(code, {
     lang: extension === ".tsx" || extension === ".jsx" ? "tsx" : "ts"
   });
@@ -8458,7 +8701,7 @@ function farmDocsClientConfigPlugin(configModule) {
 }
 
 // src/server/vite-config.ts
-import path16 from "path";
+import path17 from "path";
 var FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
 var FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
   "react",
@@ -8485,9 +8728,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
   );
 }
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = path16.resolve(projectRoot);
+  const resolvedProjectRoot = path17.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = path16.relative(resolvedProjectRoot, path16.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = path17.relative(resolvedProjectRoot, path17.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -8509,7 +8752,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 }
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": path16.resolve(projectRoot, srcDir)
+    "@": path17.resolve(projectRoot, srcDir)
   };
 }
 function mergeNoExternal(farmValue, userValue) {
@@ -8657,6 +8900,8 @@ ${FARM_DARK_VARIANT}
 }
 
 export {
+  withPackageClientBoundaryCache,
+  usePackageClientBoundaryCacheFile,
   resolveModuleSourcePath,
   getFarmClientHydrationPlanOptions,
   describeSuppressedAsyncHydration,