@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-VE3FWJBO.mjs

@@ -0,0 +1,46 @@
+import {
+  formatOptionalPeerInstallHint,
+  isMissingPackageError,
+  withOptionalPeerCause
+} from "./chunk-NR63PD3P.mjs";
+
+// src/docs/engine.ts
+var FARMING_LABS_DOCS_INSTALL_HINT = formatOptionalPeerInstallHint(
+  "@farming-labs/docs",
+  "use the docs engine"
+);
+var engine;
+var loading;
+function loadFarmDocsEngine() {
+  loading ?? (loading = Promise.all([import("@farming-labs/docs"), import("@farming-labs/docs/server")]).then(
+    ([docs, server]) => {
+      engine = {
+        ...docs,
+        resolveApiReferenceOpenApiDiscovery: server.resolveApiReferenceOpenApiDiscovery
+      };
+      return engine;
+    },
+    (error) => {
+      loading = void 0;
+      if (!isMissingPackageError(error, "@farming-labs/docs")) throw error;
+      throw withOptionalPeerCause(
+        new Error(
+          `docs is enabled, but @farming-labs/docs is not installed. ${FARMING_LABS_DOCS_INSTALL_HINT}`
+        ),
+        error
+      );
+    }
+  ));
+  return loading;
+}
+function docsEngine() {
+  if (!engine) {
+    throw new Error("Farm docs engine was used before loadFarmDocsEngine() resolved.");
+  }
+  return engine;
+}
+
+export {
+  loadFarmDocsEngine,
+  docsEngine
+};

package/dist/chunk-VFXE6NWR.mjs

@@ -0,0 +1,87 @@
+// src/build/node-module-bundle.ts
+import { isBuiltin } from "module";
+import path from "path";
+import { stripVTControlCharacters } from "util";
+var NON_PACKAGE_SPECIFIER_RE = /^(?:[./\\#]|[A-Za-z]:[\\/])/;
+function isPackageSpecifier(specifier) {
+  return !specifier.startsWith("\0") && !NON_PACKAGE_SPECIFIER_RE.test(specifier) && !path.isAbsolute(specifier);
+}
+var DECLARATION_FILE_RE = /\.d\.(?:[^./\\]+\.)?[cm]?ts$/;
+function isDeclarationFile(id) {
+  return DECLARATION_FILE_RE.test(id.split("?", 1)[0]);
+}
+var packageResolvers = /* @__PURE__ */ new Map();
+async function resolvePackageWithoutTsconfig(source, importer, kind) {
+  const condition = kind === "require-call" ? "require" : "import";
+  let resolver = packageResolvers.get(condition);
+  if (!resolver) {
+    resolver = import("rolldown/experimental").then(
+      ({ ResolverFactory }) => new ResolverFactory({
+        conditionNames: [condition, "node", "default"],
+        mainFields: ["main", "module"]
+      })
+    );
+    packageResolvers.set(condition, resolver);
+  }
+  const result = await (await resolver).async(path.dirname(importer), source);
+  return result.path ?? null;
+}
+async function bundleNodeModule(options) {
+  const { rolldown } = await import("rolldown");
+  const plugins = options.externalPackages ? [externalizePackagesPlugin()] : [];
+  plugins.push(...options.plugins ?? []);
+  try {
+    const bundle = await rolldown({
+      cwd: options.root,
+      input: options.entry,
+      platform: "node",
+      logLevel: "silent",
+      external: options.external,
+      plugins,
+      // Package imports stay external by the path they were found at (as esbuild
+      // did), so a workspace symlink is not mistaken for a local alias target.
+      resolve: options.externalPackages ? { symlinks: false } : void 0,
+      transform: { target: options.target, jsx: { runtime: "automatic" } }
+    });
+    try {
+      await bundle.write({
+        file: options.outfile,
+        format: "esm",
+        sourcemap: "inline",
+        codeSplitting: false
+      });
+    } finally {
+      await bundle.close();
+    }
+  } catch (error) {
+    throw withPlainDiagnostics(error);
+  }
+}
+function externalizePackagesPlugin() {
+  return {
+    name: "farm-externalize-packages",
+    async resolveId(source, importer, extraOptions) {
+      if (!importer || !isPackageSpecifier(source) || isBuiltin(source)) return null;
+      const resolved = await this.resolve(source, importer, {
+        kind: extraOptions.kind,
+        skipSelf: true
+      });
+      if (resolved && !resolved.external && !resolved.id.startsWith("\0") && !resolved.id.split(/[\\/]/).includes("node_modules") && !isDeclarationFile(resolved.id)) {
+        return resolved;
+      }
+      return { id: source, external: true };
+    }
+  };
+}
+function withPlainDiagnostics(error) {
+  if (!(error instanceof Error)) return error;
+  error.message = stripVTControlCharacters(error.message);
+  if (typeof error.stack === "string") error.stack = stripVTControlCharacters(error.stack);
+  return error;
+}
+
+export {
+  isDeclarationFile,
+  resolvePackageWithoutTsconfig,
+  bundleNodeModule
+};

package/dist/chunk-VHIXGZYH.mjs

@@ -0,0 +1,9 @@
+// src/utils/file-module.ts
+import { pathToFileURL } from "url";
+function toFileModuleUrl(filePath) {
+  return pathToFileURL(filePath).href;
+}
+
+export {
+  toFileModuleUrl
+};

package/dist/chunk-VISQDC6W.mjs

@@ -0,0 +1,10 @@
+// src/config-entry.ts
+function defineConfig(config) {
+  return config;
+}
+var defineFarmConfig = defineConfig;
+
+export {
+  defineConfig,
+  defineFarmConfig
+};

package/dist/chunk-VIXTAVEA.mjs

@@ -0,0 +1,59 @@
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+var CURRENT_REQUEST_PEEK_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestPeek");
+var APP_REQUEST_VIEW_KEY = /* @__PURE__ */ Symbol.for("farm.appRequestView");
+function getGlobalState() {
+  return globalThis;
+}
+function _setCurrentRequestResolver(resolver, peek = resolver) {
+  const state = getGlobalState();
+  state[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+  state[CURRENT_REQUEST_PEEK_KEY] = peek;
+}
+function _resolveCurrentRequest() {
+  return getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY]?.();
+}
+function _peekCurrentRequest() {
+  const state = getGlobalState();
+  return (state[CURRENT_REQUEST_PEEK_KEY] ?? state[CURRENT_REQUEST_RESOLVER_KEY])?.();
+}
+function _setAppRequestView(view) {
+  getGlobalState()[APP_REQUEST_VIEW_KEY] = view;
+}
+function _resolveCurrentRequestForApp() {
+  const request = _peekCurrentRequest();
+  return request && _toAppRequestView(request);
+}
+function _toAppRequestView(request) {
+  const view = getGlobalState()[APP_REQUEST_VIEW_KEY];
+  return view ? view(request) : request;
+}
+var CSP_NONCE_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.cspNonceResolver");
+function _setCspNonceResolver(resolver) {
+  globalThis[CSP_NONCE_RESOLVER_KEY] = resolver;
+}
+function _resolveCurrentCspNonce() {
+  const resolver = globalThis[CSP_NONCE_RESOLVER_KEY];
+  return resolver?.();
+}
+var SHARED_CACHE_SCOPE_RUNNER_KEY = /* @__PURE__ */ Symbol.for("farm.sharedCacheScopeRunner");
+function _setSharedCacheScopeRunner(runner) {
+  globalThis[SHARED_CACHE_SCOPE_RUNNER_KEY] = runner;
+}
+function _runInSharedCacheScope(label, fn) {
+  const runner = globalThis[SHARED_CACHE_SCOPE_RUNNER_KEY];
+  return runner ? runner(label, fn) : fn();
+}
+
+export {
+  _setCurrentRequestResolver,
+  _resolveCurrentRequest,
+  _peekCurrentRequest,
+  _setAppRequestView,
+  _resolveCurrentRequestForApp,
+  _toAppRequestView,
+  _setCspNonceResolver,
+  _resolveCurrentCspNonce,
+  _setSharedCacheScopeRunner,
+  _runInSharedCacheScope
+};

package/dist/chunk-VM57CK74.cjs

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/nitro/native-mcp-source.ts
+function generateNativeMCPPluginSource(mcp) {
+  if (_optionalChain([mcp, 'optionalAccess', _ => _.enabled]) !== true) {
+    return { importSource: "", registerSource: "", pluginSource: "" };
+  }
+  return {
+    importSource: `import { createFarmMCPPlugin as __farmCreateMCPPlugin } from "@farm.js/mcp/internal";`,
+    registerSource: `function __farmMCPIsPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function __farmMergeMCPConfig(base, override) {
+  const output = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined) continue;
+    output[key] =
+      __farmMCPIsPlainObject(output[key]) && __farmMCPIsPlainObject(value)
+        ? __farmMergeMCPConfig(output[key], value)
+        : value;
+  }
+  return output;
+}
+
+const farmNativeMCPConfig = farmRuntimeConfigs.reduce((merged, runtimeConfig) => {
+  const value = runtimeConfig?.mcp;
+  if (value === undefined) return merged;
+  if (value === false) return false;
+  return __farmMergeMCPConfig(merged && merged !== false ? merged : {}, value);
+}, undefined);
+const farmNativeMCPPlugin =
+  farmNativeMCPConfig && farmNativeMCPConfig.enabled !== false
+    ? __farmCreateMCPPlugin(farmNativeMCPConfig)
+    : null;`,
+    pluginSource: `...(farmNativeMCPPlugin ? [farmNativeMCPPlugin] : []),`
+  };
+}
+
+
+
+exports.generateNativeMCPPluginSource = generateNativeMCPPluginSource;

package/dist/chunk-VOQ7XZZT.cjs

@@ -0,0 +1,157 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _chunkR5U7OIPIcjs = require('./chunk-R5U7OIPI.cjs');
+
+
+
+var _chunkOWQV6MLMcjs = require('./chunk-OWQV6MLM.cjs');
+
+
+var _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
+
+// src/i18n/resolver.ts
+function getFarmLocaleVaryHeaders(config, resolution) {
+  if (!config.enabled || resolution.source === "url") return [];
+  const headers = [];
+  if (config.detection.includes("cookie")) headers.push("Cookie");
+  if (config.detection.includes("accept-language")) headers.push("Accept-Language");
+  return headers;
+}
+function resolveFarmLocaleRequest(request, config, options = {}) {
+  const url = new URL(request.url);
+  if (!config.enabled) {
+    return {
+      locale: config.defaultLocale,
+      source: "default",
+      pathname: url.pathname,
+      persist: false
+    };
+  }
+  const pathMatch = _chunkOWQV6MLMcjs.resolveFarmLocalePath.call(void 0, url.pathname, config);
+  if (pathMatch.explicit && pathMatch.locale) {
+    const canonicalPath = _chunkOWQV6MLMcjs.localizeFarmPathname.call(void 0, pathMatch.pathname, pathMatch.locale, config);
+    const differsOnlyByTrailingSlash = canonicalPath !== url.pathname && (url.pathname.length > 1 ? url.pathname.replace(/\/+$/, "") : url.pathname) === canonicalPath;
+    const redirect = options.redirect !== false && canonicalPath !== url.pathname && !differsOnlyByTrailingSlash ? `${canonicalPath}${url.search}${url.hash}` : void 0;
+    return {
+      locale: pathMatch.locale,
+      source: "url",
+      pathname: pathMatch.pathname,
+      redirect,
+      // Locale-prefixed pages are canonical and can be cached publicly. Locale
+      // switchers persist the same choice before navigating in the browser.
+      persist: false
+    };
+  }
+  const detected = detectLocale(request, config);
+  const shouldRedirect = options.redirect !== false && !isInternalOrApiPath(_chunkD22BUQKWcjs.stripFarmBasePath.call(void 0, url.pathname, config.basePath)) && config.routing !== "none" && (config.routing === "prefix-always" || detected.locale !== config.defaultLocale);
+  return {
+    locale: detected.locale,
+    source: detected.source,
+    pathname: pathMatch.pathname,
+    redirect: shouldRedirect ? `${_chunkOWQV6MLMcjs.localizeFarmPathname.call(void 0, pathMatch.pathname, detected.locale, config)}${url.search}${url.hash}` : void 0,
+    persist: detected.source !== "default"
+  };
+}
+function createFarmLocaleCookie(locale, config) {
+  const cookie = config.cookie;
+  let value = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(locale)}`;
+  value += `; Max-Age=${cookie.maxAge}`;
+  value += `; Path=${cookie.path}`;
+  value += `; SameSite=${capitalize(cookie.sameSite)}`;
+  if (cookie.secure) value += "; Secure";
+  return value;
+}
+function matchFarmLocale(requested, locales) {
+  if (!requested) return void 0;
+  let canonical;
+  try {
+    canonical = Intl.getCanonicalLocales(requested)[0];
+  } catch (e) {
+    return void 0;
+  }
+  const exact = locales.find((locale) => locale.toLowerCase() === canonical.toLowerCase());
+  if (exact) return exact;
+  const language = _optionalChain([canonical, 'access', _ => _.split, 'call', _2 => _2("-"), 'access', _3 => _3[0], 'optionalAccess', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  const base = locales.find((locale) => locale.toLowerCase() === language);
+  if (base) return base;
+  return locales.find((locale) => _optionalChain([locale, 'access', _6 => _6.split, 'call', _7 => _7("-"), 'access', _8 => _8[0], 'optionalAccess', _9 => _9.toLowerCase, 'call', _10 => _10()]) === language);
+}
+function detectLocale(request, config) {
+  for (const signal of config.detection) {
+    if (signal === "url") continue;
+    if (signal === "cookie") {
+      const locale = matchFarmLocale(
+        readCookie(request.headers.get("cookie"), config.cookie.name),
+        config.locales
+      );
+      if (locale) return { locale, source: "cookie" };
+    }
+    if (signal === "accept-language") {
+      const locale = resolveAcceptLanguage(request.headers.get("accept-language"), config.locales);
+      if (locale) return { locale, source: "accept-language" };
+    }
+  }
+  return { locale: config.defaultLocale, source: "default" };
+}
+function resolveAcceptLanguage(header, locales) {
+  if (!header) return void 0;
+  const byRange = /* @__PURE__ */ new Map();
+  for (const [index, entry] of header.split(",").entries()) {
+    const [rawLocale = "", ...parameters] = entry.trim().split(";");
+    const locale = rawLocale.trim();
+    if (!locale) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.trim().split("=", 2);
+      if (_optionalChain([rawName, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12(), 'access', _13 => _13.toLowerCase, 'call', _14 => _14()]) !== "q") continue;
+      const value = _nullishCoalesce(_optionalChain([rawValue, 'optionalAccess', _15 => _15.trim, 'call', _16 => _16()]), () => ( ""));
+      quality = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/.test(value) ? Number(value) : 0;
+    }
+    const key = locale.toLowerCase();
+    const previous = byRange.get(key);
+    if (!previous || quality > previous.quality) {
+      byRange.set(key, { locale, quality, index: _nullishCoalesce(_optionalChain([previous, 'optionalAccess', _17 => _17.index]), () => ( index)) });
+    }
+  }
+  const candidates = [...byRange.values()].filter((candidate) => candidate.quality > 0).sort((a, b) => b.quality - a.quality || a.index - b.index);
+  const explicitRanges = [...byRange.values()].filter(({ locale }) => locale !== "*");
+  for (const candidate of candidates) {
+    if (candidate.locale === "*") {
+      const wildcardMatch = locales.find(
+        (locale2) => !explicitRanges.some((range) => matchFarmLocale(range.locale, [locale2]) !== void 0)
+      );
+      if (wildcardMatch) return wildcardMatch;
+      continue;
+    }
+    const locale = matchFarmLocale(candidate.locale, locales);
+    if (locale) return locale;
+  }
+  return void 0;
+}
+function readCookie(header, name) {
+  if (!header) return void 0;
+  for (const part of header.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    if (_chunkR5U7OIPIcjs.decodeCookieName.call(void 0, part.slice(0, separator).trim()) !== name) continue;
+    try {
+      return decodeURIComponent(part.slice(separator + 1).trim());
+    } catch (e2) {
+      return part.slice(separator + 1).trim();
+    }
+  }
+  return void 0;
+}
+function isInternalOrApiPath(pathname) {
+  return pathname === "/api" || pathname.startsWith("/api/") || pathname.startsWith("/__farm/") || pathname.startsWith("/_farm/");
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+
+
+
+
+
+exports.getFarmLocaleVaryHeaders = getFarmLocaleVaryHeaders; exports.resolveFarmLocaleRequest = resolveFarmLocaleRequest; exports.createFarmLocaleCookie = createFarmLocaleCookie; exports.matchFarmLocale = matchFarmLocale;

package/dist/chunk-VQJHT2ND.mjs

@@ -0,0 +1,40 @@
+import {
+  useRouter
+} from "./chunk-BQWBHWEW.mjs";
+import {
+  getRouter
+} from "./chunk-25T5VXOE.mjs";
+import {
+  applyFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/navigation.ts
+function useRouter2() {
+  const router = useRouter();
+  return {
+    push: router.push,
+    replace: router.replace,
+    back: router.back,
+    forward: router.forward,
+    refresh() {
+      if (typeof window === "undefined") return Promise.resolve();
+      return getRouter().refresh();
+    },
+    prefetch(href) {
+      if (typeof window === "undefined") return Promise.resolve();
+      return getRouter().prefetch(applyFarmBasePath(href));
+    }
+  };
+}
+function usePathname() {
+  return useRouter().pathname;
+}
+function useSearchParams() {
+  return useRouter().searchParams;
+}
+
+export {
+  useRouter2 as useRouter,
+  usePathname,
+  useSearchParams
+};

package/dist/chunk-VR6QLTTX.mjs

@@ -0,0 +1,59 @@
+// src/environment.ts
+var FarmEnvironmentError = class extends Error {
+  constructor(api, expected, actual) {
+    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);
+    this.api = api;
+    this.expected = expected;
+    this.actual = actual;
+    this.code = "FARM_ENVIRONMENT_MISMATCH";
+    this.name = "FarmEnvironmentError";
+  }
+};
+function createServerOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createServerOnlyFn", "server", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "server") {
+    return createMismatchFunction("createServerOnlyFn", "server");
+  }
+  assertFunction(implementation, "createServerOnlyFn");
+  return implementation;
+}
+function createClientOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createClientOnlyFn", "client", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "client") {
+    return createMismatchFunction("createClientOnlyFn", "client");
+  }
+  assertFunction(implementation, "createClientOnlyFn");
+  return implementation;
+}
+function createIsomorphicFn(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("createIsomorphicFn requires server and client functions");
+  }
+  assertFunction(options.server, "createIsomorphicFn server");
+  assertFunction(options.client, "createIsomorphicFn client");
+  return getRuntimeEnvironment() === "server" ? options.server : options.client;
+}
+function getRuntimeEnvironment() {
+  return typeof window === "undefined" ? "server" : "client";
+}
+function createMismatchFunction(api, expected, actual = expected === "server" ? "client" : "server") {
+  return function farmEnvironmentBoundary() {
+    throw new FarmEnvironmentError(api, expected, actual);
+  };
+}
+function assertFunction(value, label) {
+  if (typeof value !== "function") {
+    throw new TypeError(`${label} must be a function`);
+  }
+}
+
+export {
+  FarmEnvironmentError,
+  createServerOnlyFn,
+  createClientOnlyFn,
+  createIsomorphicFn
+};

package/dist/chunk-VVTJTMGQ.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 _chunkQMNWKQL4cjs = require('./chunk-QMNWKQL4.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;
+      _chunkQMNWKQL4cjs.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) {
+    _chunkQMNWKQL4cjs.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;