@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-EMDGXYUD.mjs

@@ -0,0 +1,75 @@
+import {
+  resolveFarmThemeConfig
+} from "./chunk-YWPNIYUP.mjs";
+import {
+  _setFarmThemeServerSnapshotResolver
+} from "./chunk-QPNVDSFZ.mjs";
+import {
+  decodeCookieName
+} from "./chunk-AY2YD5ZX.mjs";
+import {
+  getCurrentRequestOrNull
+} from "./chunk-6HRAK7I5.mjs";
+
+// src/theme/server.ts
+var defaultThemeConfig = resolveFarmThemeConfig(void 0);
+function _setDefaultFarmThemeConfig(config, basePath = "/") {
+  defaultThemeConfig = resolveFarmThemeConfig(config, basePath);
+}
+function getTheme(request = getCurrentRequestOrNull()) {
+  if (!request) return defaultThemeConfig.default;
+  return readFarmThemePreference(request, defaultThemeConfig);
+}
+function getThemeSnapshot(request = getCurrentRequestOrNull()) {
+  const theme = request ? readFarmThemePreference(request, defaultThemeConfig) : defaultThemeConfig.default;
+  return {
+    theme,
+    resolvedTheme: theme === "system" ? void 0 : theme,
+    mounted: false
+  };
+}
+function readFarmThemePreference(request, config) {
+  if (!config.enabled) return config.default;
+  const stored = readCookie(request.headers.get("cookie"), config.storageKey);
+  return isFarmThemePreference(stored) ? stored : config.default;
+}
+function readCookie(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  for (const entry of cookieHeader.split(";")) {
+    const separator = entry.indexOf("=");
+    if (separator < 0) continue;
+    const key = decodeCookieName(entry.slice(0, separator).trim());
+    if (key !== name) continue;
+    return decodeCookieValue(entry.slice(separator + 1).trim());
+  }
+  return void 0;
+}
+function decodeCookieValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function isFarmThemePreference(value) {
+  return value === "light" || value === "dark" || value === "system";
+}
+_setFarmThemeServerSnapshotResolver(() => {
+  try {
+    return getThemeSnapshot();
+  } catch {
+    const theme = defaultThemeConfig.default;
+    return {
+      theme,
+      resolvedTheme: theme === "system" ? void 0 : theme,
+      mounted: false
+    };
+  }
+});
+
+export {
+  _setDefaultFarmThemeConfig,
+  getTheme,
+  getThemeSnapshot,
+  readFarmThemePreference
+};

package/dist/chunk-EOXPRC2C.cjs

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/client-observers.ts
+function notifyClientObserver(observer, args, label = "Client lifecycle") {
+  if (!observer) return;
+  const report = (error) => {
+    const reportError = globalThis.reportError;
+    if (typeof reportError === "function") {
+      try {
+        reportError.call(globalThis, error);
+        return;
+      } catch (e) {
+      }
+    }
+    try {
+      console.error(`[Farm.js] ${label} callback failed:`, error);
+    } catch (e2) {
+    }
+  };
+  try {
+    const result = observer(...args);
+    if (result && typeof result.then === "function")
+      void Promise.resolve(result).catch(report);
+  } catch (error) {
+    report(error);
+  }
+}
+
+// src/client-retry.ts
+var MAX_TIMER_DELAY = 2147483647;
+function resolveClientRetryCount(value) {
+  const count = _nullishCoalesce(value, () => ( 0));
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new RangeError("retry.count must be a non-negative safe integer");
+  }
+  return count;
+}
+function resolveClientRetryDelay(value) {
+  const delay = _nullishCoalesce(value, () => ( 0));
+  if (!Number.isFinite(delay) || delay < 0 || delay > MAX_TIMER_DELAY) {
+    throw new RangeError(`retry.delay must be between 0 and ${MAX_TIMER_DELAY} milliseconds`);
+  }
+  return delay;
+}
+
+
+
+
+
+exports.notifyClientObserver = notifyClientObserver; exports.resolveClientRetryCount = resolveClientRetryCount; exports.resolveClientRetryDelay = resolveClientRetryDelay;

package/dist/chunk-EQMTJBB7.cjs

@@ -0,0 +1,161 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/docs/search-client.ts
+var _fs = require('fs');
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function isFarmDocsSearchEnabled(docs) {
+  if (!_optionalChain([docs, 'optionalAccess', _ => _.enabled])) return false;
+  const search = docs.config.search;
+  if (search === false) return false;
+  return !(search && typeof search === "object" && search.enabled === false);
+}
+function resolveFarmDocsSearchClientModule(root) {
+  try {
+    const requireFromApp = _module.createRequire.call(void 0, _path2.default.join(_path2.default.resolve(root), "package.json"));
+    const themeEntry = requireFromApp.resolve("@farming-labs/theme");
+    const commandSearchModule = _path2.default.join(_path2.default.dirname(themeEntry), "docs-command-search.mjs");
+    if (_fs.existsSync.call(void 0, commandSearchModule)) return commandSearchModule;
+  } catch (e) {
+  }
+  return void 0;
+}
+function generateFarmDocsSearchBootstrapRuntime() {
+  return `(()=>{if(window.__farmDocsSearchBootstrap)return;window.__farmDocsSearchBootstrap=true;const queue=(trigger,event)=>{if(window.__FARM_DOCS_SEARCH_BRIDGE_ACTIVE__)return;event.preventDefault();event.stopPropagation();event.stopImmediatePropagation();window.__FARM_DOCS_SEARCH_PENDING__=trigger;window.__FARM_MOUNT_DOCS_SEARCH__?.()};document.addEventListener("click",(event)=>{const target=event.target instanceof Element?event.target.closest("[data-search-full]"):null;if(target)queue("button",event)},true);document.addEventListener("keydown",(event)=>{if((event.metaKey||event.ctrlKey)&&event.key.toLowerCase()==="k")queue("keyboard",event)},true)})();`;
+}
+function generateFarmDocsSearchClientRuntime(enabled, moduleId) {
+  if (!enabled || !moduleId) {
+    return `
+function isFarmDocsSearchPage() {
+  return false;
+}
+
+async function mountFarmDocsSearch() {
+  return false;
+}
+`;
+  }
+  return `
+let farmDocsSearchRoot = null;
+let farmDocsSearchContainer = null;
+let farmDocsSearchModulePromise = null;
+let farmDocsSearchPendingTrigger = window.__FARM_DOCS_SEARCH_PENDING__ === 'keyboard'
+  ? 'keyboard'
+  : window.__FARM_DOCS_SEARCH_PENDING__
+    ? 'button'
+    : null;
+let farmDocsSearchReady = false;
+
+function isFarmDocsSearchPage() {
+  return document.querySelector('[data-farm-docs-search-root]') instanceof HTMLElement;
+}
+
+function replayFarmDocsSearchOpen() {
+  const pendingTrigger = farmDocsSearchPendingTrigger;
+  farmDocsSearchPendingTrigger = null;
+  window.__FARM_DOCS_SEARCH_PENDING__ = null;
+  if (!pendingTrigger) return;
+
+  queueMicrotask(() => {
+    if (pendingTrigger === 'keyboard') {
+      document.dispatchEvent(
+        new KeyboardEvent('keydown', {
+          key: 'k',
+          metaKey: true,
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+    } else {
+      const trigger = document.querySelector('[data-search-full]');
+      if (trigger instanceof HTMLElement) trigger.click();
+    }
+  });
+}
+
+function FarmDocsSearchBridge({ component, api }) {
+  React.useEffect(() => {
+    farmDocsSearchReady = true;
+    replayFarmDocsSearchOpen();
+    return () => {
+      farmDocsSearchReady = false;
+    };
+  }, []);
+
+  return React.createElement(component, { api });
+}
+
+function queueFarmDocsSearchOpen(trigger, event) {
+  if (farmDocsSearchReady) return;
+  event.preventDefault();
+  event.stopPropagation();
+  event.stopImmediatePropagation();
+  farmDocsSearchPendingTrigger = trigger;
+  window.__FARM_DOCS_SEARCH_PENDING__ = trigger;
+  void mountFarmDocsSearch();
+}
+
+document.addEventListener(
+  'click',
+  (event) => {
+    const target = event.target instanceof Element
+      ? event.target.closest('[data-search-full]')
+      : null;
+    if (target) queueFarmDocsSearchOpen('button', event);
+  },
+  true,
+);
+
+document.addEventListener(
+  'keydown',
+  (event) => {
+    if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k') {
+      queueFarmDocsSearchOpen('keyboard', event);
+    }
+  },
+  true,
+);
+
+window.__FARM_DOCS_SEARCH_BRIDGE_ACTIVE__ = true;
+
+async function mountFarmDocsSearch() {
+  const container = document.querySelector('[data-farm-docs-search-root]');
+  if (!(container instanceof HTMLElement)) return false;
+  if (farmDocsSearchContainer === container && farmDocsSearchRoot) return true;
+
+  try {
+    farmDocsSearchModulePromise ||= import(${JSON.stringify(moduleId)});
+    const { DocsCommandSearch } = await farmDocsSearchModulePromise;
+    if (!container.isConnected) return false;
+
+    if (farmDocsSearchRoot) {
+      farmDocsSearchReady = false;
+      try {
+        farmDocsSearchRoot.unmount();
+      } catch {}
+    }
+
+    farmDocsSearchContainer = container;
+    farmDocsSearchRoot = createRoot(container);
+    farmDocsSearchRoot.render(
+      React.createElement(FarmDocsSearchBridge, {
+        component: DocsCommandSearch,
+        api: container.dataset.api || '/api/docs',
+      }),
+    );
+    return true;
+  } catch (error) {
+    farmDocsSearchModulePromise = null;
+    console.error('[Farm.js] Could not load docs search:', error);
+    return false;
+  }
+}
+
+window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
+`;
+}
+
+
+
+
+
+
+exports.isFarmDocsSearchEnabled = isFarmDocsSearchEnabled; exports.resolveFarmDocsSearchClientModule = resolveFarmDocsSearchClientModule; exports.generateFarmDocsSearchBootstrapRuntime = generateFarmDocsSearchBootstrapRuntime; exports.generateFarmDocsSearchClientRuntime = generateFarmDocsSearchClientRuntime;

package/dist/chunk-ERMUL73L.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/docs/fonts.ts
+var _crypto = require('crypto');
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var FARM_DOCS_FONT_SOURCES = [
+  {
+    family: "Geist Sans",
+    packagePath: "geist/dist/fonts/geist-sans/Geist-Variable.woff2"
+  },
+  {
+    family: "Geist Mono",
+    packagePath: "geist/dist/fonts/geist-mono/GeistMono-Variable.woff2"
+  }
+];
+function resolveFarmDocsFontAssets(root) {
+  return FARM_DOCS_FONT_SOURCES.flatMap(({ family, packagePath }) => {
+    const sourcePath = _path2.default.join(root, "node_modules", packagePath);
+    if (!_fs.existsSync.call(void 0, sourcePath)) return [];
+    const source = _fs.readFileSync.call(void 0, sourcePath);
+    const fingerprint = _crypto.createHash.call(void 0, "sha256").update(source).digest("hex").slice(0, 12);
+    const extension = _path2.default.extname(packagePath);
+    const baseName = _path2.default.basename(packagePath, extension);
+    return [
+      {
+        family,
+        sourcePath,
+        url: `/assets/fonts/${baseName}-h${fingerprint}${extension}`
+      }
+    ];
+  });
+}
+function toFarmDocsPublicFontAssets(assets) {
+  return assets.map(({ family, url }) => ({ family, url }));
+}
+
+
+
+
+exports.resolveFarmDocsFontAssets = resolveFarmDocsFontAssets; exports.toFarmDocsPublicFontAssets = toFarmDocsPublicFontAssets;

package/dist/chunk-ES2LD2YD.mjs

@@ -0,0 +1,203 @@
+// src/renderer.ts
+import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+var DEFAULT_RENDERER_CAPABILITIES = Object.freeze({
+  streaming: Object.freeze({ node: false, web: false }),
+  // Conservative default: assume a re-render rebuilds until a renderer states
+  // otherwise, so callers do not silently rely on reconciliation.
+  reconcilesRerenders: false,
+  functionComponents: false
+});
+function getFarmRendererCapabilities(renderer) {
+  const defaultStreaming = {
+    node: renderer?.capabilities?.streaming?.node ?? DEFAULT_RENDERER_CAPABILITIES.streaming.node,
+    web: renderer?.capabilities?.streaming?.web ?? DEFAULT_RENDERER_CAPABILITIES.streaming.web
+  };
+  const runtimes = Object.fromEntries(
+    ["node", "edge"].flatMap((runtime) => {
+      const override = renderer?.capabilities?.streaming?.runtimes?.[runtime];
+      if (!override) return [];
+      return [
+        [
+          runtime,
+          {
+            node: override.node ?? defaultStreaming.node,
+            web: override.web ?? defaultStreaming.web
+          }
+        ]
+      ];
+    })
+  );
+  return {
+    streaming: {
+      ...defaultStreaming,
+      ...Object.keys(runtimes).length > 0 ? { runtimes } : {}
+    },
+    reconcilesRerenders: renderer?.capabilities?.reconcilesRerenders ?? DEFAULT_RENDERER_CAPABILITIES.reconcilesRerenders,
+    functionComponents: renderer?.capabilities?.functionComponents ?? DEFAULT_RENDERER_CAPABILITIES.functionComponents
+  };
+}
+function getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime) {
+  const streaming = getFarmRendererCapabilities(renderer).streaming;
+  if (runtime === "unknown") return { node: streaming.node, web: streaming.web };
+  return streaming.runtimes?.[runtime] ?? { node: streaming.node, web: streaming.web };
+}
+function assertFarmRendererStreamingRuntime(name, renderer, runtimeModule, runtime) {
+  const declared = getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime);
+  const runtimeDeclaration = runtimeModule.capabilities?.streaming;
+  if (runtimeDeclaration) {
+    const advertised = getFarmRendererStreamingCapabilitiesForRuntime(
+      { capabilities: { streaming: runtimeDeclaration } },
+      runtime
+    );
+    if (declared.node && !advertised.node || declared.web && !advertised.web) {
+      throw new Error(
+        `Renderer \`${name}\` server module advertises ${JSON.stringify(advertised)} streaming for the ${runtime} runtime, which does not satisfy its descriptor ${JSON.stringify(declared)}.`
+      );
+    }
+  }
+  if (declared.node && typeof runtimeModule.renderToPipeableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Node streaming for the ${runtime} runtime but its server module does not export renderToPipeableStream().`
+    );
+  }
+  if (declared.web && typeof runtimeModule.renderToReadableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Web streaming for the ${runtime} runtime but its server module does not export renderToReadableStream().`
+    );
+  }
+  return declared;
+}
+var FARM_COMPONENT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function resolveFarmComponentExtensions(extensions = []) {
+  return Array.from(
+    new Set(
+      [...FARM_COMPONENT_EXTENSIONS, ...extensions].map((extension) => {
+        const normalized = extension.trim().toLowerCase();
+        return normalized.startsWith(".") ? normalized : `.${normalized}`;
+      })
+    )
+  ).filter((extension) => extension.length > 1);
+}
+function getFarmRendererComponentExtensions(renderer) {
+  return resolveFarmComponentExtensions(renderer?.componentExtensions);
+}
+var REACT_RENDERER = Object.freeze({
+  name: "react",
+  vite: "@farm.js/core/renderer/react/vite",
+  server: "@farm.js/core/renderer/react/server",
+  client: "@farm.js/core/renderer/react/client",
+  jsxImportSource: "react",
+  dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+  optimizeDeps: [
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime"
+  ],
+  capabilities: {
+    streaming: {
+      node: true,
+      web: false,
+      runtimes: { edge: { node: false, web: true } }
+    },
+    reconcilesRerenders: true,
+    functionComponents: true
+  }
+});
+function defineRenderer(renderer) {
+  return renderer;
+}
+function resolveFarmRenderer(renderer) {
+  const resolved = renderer || REACT_RENDERER;
+  const fields = ["name", "vite", "server", "client"];
+  for (const field of fields) {
+    if (typeof resolved[field] !== "string" || resolved[field].trim().length === 0) {
+      throw new TypeError(`Farm renderer \`${field}\` must be a non-empty string.`);
+    }
+  }
+  if (resolved.appSetup !== void 0 && (typeof resolved.appSetup !== "string" || resolved.appSetup.trim().length === 0)) {
+    throw new TypeError("Farm renderer `appSetup` must be a non-empty module path.");
+  }
+  return {
+    ...resolved,
+    componentExtensions: [...resolved.componentExtensions || []],
+    dedupe: [...resolved.dedupe || []],
+    optimizeDeps: [...resolved.optimizeDeps || []],
+    buildConcurrency: resolved.buildConcurrency || "parallel",
+    capabilities: getFarmRendererCapabilities(resolved),
+    options: resolved.options ? { ...resolved.options } : void 0
+  };
+}
+async function readFarmRendererWebStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let html = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    html += typeof value === "string" ? value : decoder.decode(value, { stream: true });
+  }
+  return html + decoder.decode();
+}
+function isReactRenderer(renderer) {
+  return !renderer || renderer.name === "react";
+}
+function resolveFarmRendererAppSetup(root, renderer) {
+  if (!renderer.appSetup) return null;
+  const filePath = path.resolve(root, renderer.appSetup);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Renderer \`${renderer.name}\` app setup module was not found: ${filePath}`);
+  }
+  return filePath;
+}
+function resolveFarmRendererModule(root, specifier) {
+  const requireFromApp = createRequire(path.join(path.resolve(root), "package.json"));
+  return requireFromApp.resolve(specifier);
+}
+function createFarmReactJsxPlugin() {
+  return {
+    name: "farm:react-jsx",
+    config(config) {
+      if (this && this.meta?.rolldownVersion) return;
+      if (config.esbuild === false || config.esbuild?.jsx !== void 0) return;
+      return { esbuild: { jsx: "automatic" } };
+    }
+  };
+}
+async function loadFarmRendererVitePlugins(renderer, root, options = {}) {
+  if (renderer.vite === REACT_RENDERER.vite) return [createFarmReactJsxPlugin()];
+  const modulePath = resolveFarmRendererModule(root, renderer.vite);
+  const rendererModule = await import(pathToFileURL(modulePath).href);
+  if (typeof rendererModule.createFarmRendererPlugin !== "function") {
+    throw new Error(
+      `Renderer \`${renderer.name}\` module ${renderer.vite} must export createFarmRendererPlugin().`
+    );
+  }
+  const created = await rendererModule.createFarmRendererPlugin({
+    ...options,
+    rendererOptions: renderer.options
+  });
+  if (!created) return [];
+  return Array.isArray(created) ? [...created] : [created];
+}
+
+export {
+  getFarmRendererCapabilities,
+  getFarmRendererStreamingCapabilitiesForRuntime,
+  assertFarmRendererStreamingRuntime,
+  FARM_COMPONENT_EXTENSIONS,
+  resolveFarmComponentExtensions,
+  getFarmRendererComponentExtensions,
+  REACT_RENDERER,
+  defineRenderer,
+  resolveFarmRenderer,
+  readFarmRendererWebStream,
+  isReactRenderer,
+  resolveFarmRendererAppSetup,
+  resolveFarmRendererModule,
+  loadFarmRendererVitePlugins
+};

package/dist/chunk-ETF5C6HR.cjs

@@ -0,0 +1,135 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkBPNOYILCcjs = require('./chunk-BPNOYILC.cjs');
+
+
+var _chunkXN2MB4QZcjs = require('./chunk-XN2MB4QZ.cjs');
+
+// src/server-components-status.ts
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var FARM_RSC_PACKAGES = [
+  "@farm.js/plugin",
+  "@vitejs/plugin-rsc",
+  "react-server-dom-webpack"
+];
+var FARM_RSC_INSTALL_HINT = `pnpm add ${FARM_RSC_PACKAGES.join(" ")}`;
+var FARM_RSC_BLOCKING_KEYS = [
+  "auth",
+  "integrations",
+  "headers",
+  "redirects",
+  "rewrites",
+  "routeRules",
+  "context",
+  // A Content Security Policy the RSC pipeline would not send.
+  "security"
+];
+var FARM_RSC_IGNORED_KEYS = [
+  "plugins",
+  "storage",
+  "schema",
+  "cron",
+  "workflows",
+  "docs",
+  "theme",
+  "observability"
+];
+function farmConfigUsesServerComponents(config) {
+  return _chunkBPNOYILCcjs.resolveFarmServerComponentsMode.call(void 0, _optionalChain([config, 'optionalAccess', _ => _.experimental, 'optionalAccess', _2 => _2.serverComponents])) === "rsc";
+}
+function findFarmAppPackageDir(root, packageName) {
+  for (let dir = _path2.default.resolve(root); ; dir = _path2.default.dirname(dir)) {
+    const candidate = _path2.default.join(dir, "node_modules", packageName);
+    if (_fs.existsSync.call(void 0, _path2.default.join(candidate, "package.json"))) return _fs.realpathSync.call(void 0, candidate);
+    if (_path2.default.dirname(dir) === dir) return void 0;
+  }
+}
+function isSet(value, key) {
+  if (key === "security") {
+    const csp = _optionalChain([value, 'optionalAccess', _3 => _3.csp]);
+    return csp !== void 0 && csp !== false && csp !== null;
+  }
+  if (value === void 0 || value === false || value === null) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value !== "object" || Object.keys(value).length > 0;
+}
+function inspectFarmServerComponents(config, root) {
+  const value = _optionalChain([config, 'optionalAccess', _4 => _4.experimental, 'optionalAccess', _5 => _5.serverComponents]);
+  const mode = _chunkBPNOYILCcjs.resolveFarmServerComponentsMode.call(void 0, value);
+  const enabled = mode === "rsc";
+  const explicit = enabled && _chunkBPNOYILCcjs.isExplicitFarmServerComponentsMode.call(void 0, value);
+  const missingPackages = enabled ? FARM_RSC_PACKAGES.filter((name) => !findFarmAppPackageDir(root, name)) : [];
+  return {
+    mode,
+    enabled,
+    explicit,
+    missingPackages,
+    // `true` predates the pipeline; `{ mode: "rsc" }` is new and fails with the install command.
+    fallback: enabled && !explicit && missingPackages.length > 0,
+    blockingKeys: enabled ? FARM_RSC_BLOCKING_KEYS.filter((key) => isSet(_optionalChain([config, 'optionalAccess', _6 => _6[key]]), key)).map(
+      (key) => key === "security" ? "security.csp" : key
+    ) : [],
+    ignoredKeys: enabled ? FARM_RSC_IGNORED_KEYS.filter((key) => isSet(_optionalChain([config, 'optionalAccess', _7 => _7[key]]))) : []
+  };
+}
+function formatKeys(keys) {
+  return keys.map((key) => `\`${key}\``).join(", ");
+}
+function formatFarmRscFallbackMessage(missingPackages, blockingKeys = []) {
+  if (blockingKeys.length > 0) {
+    return `experimental.serverComponents is true, but this app uses ${formatKeys(
+      blockingKeys
+    )}, which the RSC pipeline does not run yet, so it runs without React Server Components. Remove the flag, or move ${blockingKeys.length === 1 ? "that feature" : "those features"} out of farm.config to turn RSC on.`;
+  }
+  return `experimental.serverComponents is true, but ${missingPackages.join(", ")} ${missingPackages.length === 1 ? "is" : "are"} not installed, so the app runs without React Server Components. \`farm dev\` and \`farm build\` install them outside CI; in CI or with another tool, run ${FARM_RSC_INSTALL_HINT}.`;
+}
+function formatFarmRscBlockingMessage(blockingKeys) {
+  return `experimental.serverComponents runs on the RSC pipeline, which does not run ${formatKeys(
+    blockingKeys
+  )} yet. Serving the app without ${blockingKeys.length === 1 ? "it" : "them"} could expose what ${blockingKeys.length === 1 ? "it protects" : "they protect"}, so RSC does not start. Remove experimental.serverComponents to keep ${blockingKeys.length === 1 ? "it" : "them"}.`;
+}
+var warnedFallback = false;
+async function resolveFarmRscCheckConfig(config, root, mode) {
+  if (!_optionalChain([config, 'optionalAccess', _8 => _8.extends])) return config;
+  const { resolveFarmLayers } = await import("./layers-DMRXRL7F.cjs");
+  return (await resolveFarmLayers(config, { root, mode })).config;
+}
+function farmAppUsesRscPipeline(config, root) {
+  const status = inspectFarmServerComponents(config, root);
+  if (status.mode === "islands") return false;
+  if (!status.enabled) return false;
+  if (status.fallback) {
+    if (!warnedFallback) {
+      warnedFallback = true;
+      _chunkXN2MB4QZcjs.logger.warn(
+        `[Farm.js] ${formatFarmRscFallbackMessage(status.missingPackages, status.blockingKeys)}`
+      );
+    }
+    return false;
+  }
+  if (status.blockingKeys.length > 0) {
+    throw new Error(`[Farm.js] ${formatFarmRscBlockingMessage(status.blockingKeys)}`);
+  }
+  if (status.ignoredKeys.length > 0) {
+    _chunkXN2MB4QZcjs.logger.warn(
+      `[Farm.js] experimental.serverComponents runs on the RSC pipeline, which does not run ${formatKeys(
+        status.ignoredKeys
+      )} yet. ${status.ignoredKeys.length === 1 ? "It is" : "They are"} ignored.`
+    );
+  }
+  return true;
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_RSC_PACKAGES = FARM_RSC_PACKAGES; exports.FARM_RSC_INSTALL_HINT = FARM_RSC_INSTALL_HINT; exports.farmConfigUsesServerComponents = farmConfigUsesServerComponents; exports.findFarmAppPackageDir = findFarmAppPackageDir; exports.inspectFarmServerComponents = inspectFarmServerComponents; exports.formatFarmRscFallbackMessage = formatFarmRscFallbackMessage; exports.formatFarmRscBlockingMessage = formatFarmRscBlockingMessage; exports.resolveFarmRscCheckConfig = resolveFarmRscCheckConfig; exports.farmAppUsesRscPipeline = farmAppUsesRscPipeline;