@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-UAQD67HM.mjs

@@ -0,0 +1,154 @@
+// src/deployment.ts
+var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
+var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
+var FARM_DEPLOYMENT_COOKIE = "__farm_deployment";
+var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
+var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+function getFarmPresetRuntime(preset) {
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
+    return "edge";
+  }
+  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun" || preset === "self-host" || preset === "farm") {
+    return "node";
+  }
+  return "unknown";
+}
+var FarmDeploymentMismatchError = class extends Error {
+  constructor(clientDeploymentId, serverDeploymentId) {
+    super("The application was updated while this page was open. Refresh before trying again.");
+    this.clientDeploymentId = clientDeploymentId;
+    this.serverDeploymentId = serverDeploymentId;
+    this.name = "FarmDeploymentMismatchError";
+    this.code = FARM_DEPLOYMENT_MISMATCH_CODE;
+    this.retryable = false;
+  }
+};
+function normalizeFarmDeploymentId(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError("Farm deploymentId must be a non-empty string");
+  }
+  const normalized = value.trim();
+  if (normalized.length > 200 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new TypeError("Farm deploymentId must be at most 200 characters without control bytes");
+  }
+  return normalized;
+}
+function createFarmDeploymentRequestHeaders(deploymentId, init) {
+  const headers = new Headers(init);
+  if (deploymentId) {
+    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  }
+  return headers;
+}
+function getFarmRequestDeploymentId(request) {
+  const headerValue = request.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim();
+  if (headerValue) return headerValue;
+  if (isSafeRequestMethod(request.method)) return void 0;
+  return readCookie(request.headers.get("cookie"), FARM_DEPLOYMENT_COOKIE);
+}
+function getFarmDeploymentMismatch(request, serverDeploymentId) {
+  if (!serverDeploymentId) return null;
+  const clientDeploymentId = getFarmRequestDeploymentId(request);
+  if (!clientDeploymentId || clientDeploymentId === serverDeploymentId) return null;
+  return { clientDeploymentId, serverDeploymentId };
+}
+function createFarmDeploymentMismatchResponse(mismatch) {
+  return new Response(
+    JSON.stringify({
+      error: FARM_DEPLOYMENT_MISMATCH_CODE,
+      message: "The application deployment changed. Refresh before retrying this request."
+    }),
+    {
+      status: FARM_DEPLOYMENT_MISMATCH_STATUS,
+      headers: {
+        "Cache-Control": "no-store",
+        "Content-Type": "application/json; charset=utf-8",
+        [FARM_DEPLOYMENT_ID_HEADER]: mismatch.serverDeploymentId,
+        [FARM_DEPLOYMENT_MISMATCH_HEADER]: "1"
+      }
+    }
+  );
+}
+function withFarmDeploymentResponse(response, deploymentId, options = {}) {
+  if (!deploymentId) return response;
+  const headers = new Headers(response.headers);
+  headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  if (options.setCookie) {
+    headers.append(
+      "Set-Cookie",
+      createFarmDeploymentCookie(
+        deploymentId,
+        options.cookiePath ?? "/",
+        options.secureCookie ?? false
+      )
+    );
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function getFarmResponseDeploymentId(response) {
+  return response.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim() || void 0;
+}
+function isFarmDeploymentMismatchResponse(response, clientDeploymentId) {
+  const serverDeploymentId = getFarmResponseDeploymentId(response);
+  if (clientDeploymentId && serverDeploymentId && clientDeploymentId !== serverDeploymentId) {
+    return true;
+  }
+  return response.status === FARM_DEPLOYMENT_MISMATCH_STATUS && response.headers.get(FARM_DEPLOYMENT_MISMATCH_HEADER) === "1";
+}
+function createFarmDeploymentMismatchError(response, clientDeploymentId) {
+  return new FarmDeploymentMismatchError(
+    clientDeploymentId,
+    getFarmResponseDeploymentId(response) || "unknown"
+  );
+}
+function createFarmDeploymentCookie(deploymentId, path = "/", secure = false) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return [
+    `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
+    `Path=${normalizedPath}`,
+    "HttpOnly",
+    "SameSite=Lax",
+    secure ? "Secure" : ""
+  ].filter(Boolean).join("; ");
+}
+function readCookie(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  for (const part of cookieHeader.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator === -1 || part.slice(0, separator).trim() !== name) continue;
+    const value = part.slice(separator + 1).trim();
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isSafeRequestMethod(method) {
+  return ["GET", "HEAD", "OPTIONS", "QUERY"].includes(method.toUpperCase());
+}
+
+export {
+  FARM_DEPLOYMENT_ID_HEADER,
+  FARM_DEPLOYMENT_MISMATCH_HEADER,
+  FARM_DEPLOYMENT_COOKIE,
+  FARM_DEPLOYMENT_MISMATCH_CODE,
+  FARM_DEPLOYMENT_MISMATCH_STATUS,
+  getFarmPresetRuntime,
+  FarmDeploymentMismatchError,
+  normalizeFarmDeploymentId,
+  createFarmDeploymentRequestHeaders,
+  getFarmRequestDeploymentId,
+  getFarmDeploymentMismatch,
+  createFarmDeploymentMismatchResponse,
+  withFarmDeploymentResponse,
+  getFarmResponseDeploymentId,
+  isFarmDeploymentMismatchResponse,
+  createFarmDeploymentMismatchError,
+  createFarmDeploymentCookie
+};

package/dist/chunk-UB7RVEMX.mjs

@@ -0,0 +1,73 @@
+// src/platform-blocks.ts
+import { readFileSync } from "fs";
+import * as path from "path";
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function createPlatformBlockChecker(prefix) {
+  const fail = (message) => {
+    throw new TypeError(`${prefix}: ${message}`);
+  };
+  return {
+    fail,
+    checkKeys(value, allowed, where) {
+      for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+          fail(`unknown option ${where}${key}. Supported: ${[...allowed].join(", ")}.`);
+        }
+      }
+    },
+    optionalString(value, key) {
+      if (value === void 0) return void 0;
+      if (typeof value !== "string" || !value.trim()) fail(`${key} must be a non-empty string.`);
+      return value.trim();
+    }
+  };
+}
+function readAppPackageJson(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+    return isPlainObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function resolveAppPackageName(root, pkg) {
+  return typeof pkg.productName === "string" && pkg.productName.trim() || typeof pkg.name === "string" && pkg.name.replace(/^@[^/]+\//, "").trim() || path.basename(root);
+}
+function resolvePlatformProfile(profile = "production") {
+  if (typeof profile !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(profile)) {
+    throw new TypeError(`--profile must be a name such as "beta", got "${String(profile)}".`);
+  }
+  return profile;
+}
+async function resolvePlatformBlock(input, context, validate, cache) {
+  if (typeof input !== "function") return validate(input, context);
+  const fn = input;
+  const call = () => Promise.resolve().then(() => fn(context)).then((value) => validate(value, context));
+  if (!cache) return call();
+  const key = [
+    context.os,
+    context.mode,
+    context.command,
+    context.profile,
+    context.root,
+    String(fn)
+  ].join("\0");
+  let resolved = cache.get(key);
+  if (!resolved) {
+    resolved = call();
+    cache.set(key, resolved);
+    resolved.catch(() => cache.delete(key));
+  }
+  return resolved;
+}
+
+export {
+  isPlainObject,
+  createPlatformBlockChecker,
+  readAppPackageJson,
+  resolveAppPackageName,
+  resolvePlatformProfile,
+  resolvePlatformBlock
+};

package/dist/chunk-UIJOLBUL.mjs

@@ -0,0 +1,19 @@
+// src/app-markdown-config.ts
+import path from "path";
+function resolveMdxConfig(config) {
+  return {
+    components: config?.components,
+    markdownRoutes: config?.markdownRoutes ?? true,
+    className: config?.className ?? "farm-markdown"
+  };
+}
+function resolveFarmMdxComponentsModulePath(config, root) {
+  const components = config?.components;
+  if (typeof components !== "string") return void 0;
+  return path.isAbsolute(components) ? components : path.join(root, components);
+}
+
+export {
+  resolveMdxConfig,
+  resolveFarmMdxComponentsModulePath
+};

package/dist/chunk-UNJZGVPU.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/anonymous-client-address.ts
+var FARM_ANONYMOUS_CLIENT_ADDRESS = "192.0.2.1";
+
+
+
+exports.FARM_ANONYMOUS_CLIENT_ADDRESS = FARM_ANONYMOUS_CLIENT_ADDRESS;

package/dist/chunk-UPYIFH2H.cjs

@@ -0,0 +1,168 @@
+"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; }
+
+var _chunkR5U7OIPIcjs = require('./chunk-R5U7OIPI.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/middleware/cookie-header.ts
+function parseMiddlewareCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  for (const cookie of _chunkR5U7OIPIcjs.parseRequestCookieHeader.call(void 0, cookieHeader)) {
+    if (!Object.prototype.hasOwnProperty.call(cookies, cookie.name)) {
+      cookies[cookie.name] = cookie.value;
+    }
+  }
+  return cookies;
+}
+function applyCookieNamePrefixRequirements(name, options) {
+  if (name.startsWith("__Host-")) {
+    return { ...options, secure: true, path: "/", domain: void 0 };
+  }
+  if (name.startsWith("__Secure-")) {
+    return { ...options, secure: true };
+  }
+  return options;
+}
+function serializeMiddlewareCookie(name, value, options = {}) {
+  const resolved = applyCookieNamePrefixRequirements(name, options);
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (resolved.maxAge != null) cookie += `; Max-Age=${resolved.maxAge}`;
+  if (resolved.expires) cookie += `; Expires=${resolved.expires.toUTCString()}`;
+  cookie += `; Path=${resolved.path || "/"}`;
+  if (resolved.domain) cookie += `; Domain=${resolved.domain}`;
+  if (resolved.secure || resolved.sameSite === "none") cookie += "; Secure";
+  if (resolved.httpOnly) cookie += "; HttpOnly";
+  if (resolved.sameSite) {
+    cookie += `; SameSite=${resolved.sameSite.charAt(0).toUpperCase()}${resolved.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+function serializeMiddlewareCookieDeletion(name, options = {}) {
+  return serializeMiddlewareCookie(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+}
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return _chunkHNAISJFDcjs.createWebRequestFromFarmRequest.call(void 0, ctx.request, { origin: ctx.url.origin });
+}
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get routePathname() {
+      return ctx.routePathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module = middlewareModule;
+  const defaultExport = module.default;
+  const namedExport = module.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(_optionalChain([built, 'optionalAccess', _ => _.handlers])) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module.config || _optionalChain([built, 'optionalAccess', _2 => _2.config])
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module.config
+    };
+  }
+  return null;
+}
+
+
+
+
+
+
+exports.parseMiddlewareCookieHeader = parseMiddlewareCookieHeader; exports.serializeMiddlewareCookie = serializeMiddlewareCookie; exports.serializeMiddlewareCookieDeletion = serializeMiddlewareCookieDeletion; exports.normalizeMiddlewareModule = normalizeMiddlewareModule;

package/dist/chunk-UR25Z5Z6.mjs

@@ -0,0 +1,135 @@
+import {
+  isExplicitFarmServerComponentsMode,
+  resolveFarmServerComponentsMode
+} from "./chunk-PAKCHVUS.mjs";
+import {
+  logger
+} from "./chunk-JSDV2NUN.mjs";
+
+// src/server-components-status.ts
+import { existsSync, realpathSync } from "fs";
+import path from "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 resolveFarmServerComponentsMode(config?.experimental?.serverComponents) === "rsc";
+}
+function findFarmAppPackageDir(root, packageName) {
+  for (let dir = path.resolve(root); ; dir = path.dirname(dir)) {
+    const candidate = path.join(dir, "node_modules", packageName);
+    if (existsSync(path.join(candidate, "package.json"))) return realpathSync(candidate);
+    if (path.dirname(dir) === dir) return void 0;
+  }
+}
+function isSet(value, key) {
+  if (key === "security") {
+    const csp = value?.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 = config?.experimental?.serverComponents;
+  const mode = resolveFarmServerComponentsMode(value);
+  const enabled = mode === "rsc";
+  const explicit = enabled && isExplicitFarmServerComponentsMode(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(config?.[key], key)).map(
+      (key) => key === "security" ? "security.csp" : key
+    ) : [],
+    ignoredKeys: enabled ? FARM_RSC_IGNORED_KEYS.filter((key) => isSet(config?.[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 (!config?.extends) return config;
+  const { resolveFarmLayers } = await import("./layers-T55SA47E.mjs");
+  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;
+      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) {
+    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;
+}
+
+export {
+  FARM_RSC_PACKAGES,
+  FARM_RSC_INSTALL_HINT,
+  farmConfigUsesServerComponents,
+  findFarmAppPackageDir,
+  inspectFarmServerComponents,
+  formatFarmRscFallbackMessage,
+  formatFarmRscBlockingMessage,
+  resolveFarmRscCheckConfig,
+  farmAppUsesRscPipeline
+};

package/dist/chunk-UUMKLGUU.mjs

@@ -0,0 +1,69 @@
+// src/plugin-runtime-endpoint.ts
+function normalizeFarmPluginRuntimeEndpointPath(pathname, label = "Farm plugin runtime endpoint") {
+  if (typeof pathname !== "string" || pathname.trim() !== pathname || pathname.length === 0) {
+    throw new TypeError(`${label} path must be a non-empty pathname without surrounding spaces`);
+  }
+  if (!pathname.startsWith("/") || pathname.startsWith("//") || pathname.includes("?") || pathname.includes("#") || pathname.includes("*")) {
+    throw new TypeError(`${label} path must be an exact pathname such as "/status"`);
+  }
+  if (pathname.includes("\\") || Array.from(pathname).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  })) {
+    throw new TypeError(`${label} path cannot contain backslashes or control characters`);
+  }
+  for (const segment of pathname.split("/").slice(1)) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new TypeError(`${label} path contains a malformed percent escape`);
+    }
+    if (decoded.includes("/") || decoded.includes("\\")) {
+      throw new TypeError(`${label} path cannot contain percent-encoded path separators`);
+    }
+    if (Array.from(decoded).some((character) => {
+      const code = character.charCodeAt(0);
+      return code <= 31 || code >= 127 && code <= 159;
+    })) {
+      throw new TypeError(`${label} path cannot contain control characters`);
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new TypeError(`${label} path cannot contain dot segments`);
+    }
+  }
+  return normalizeRuntimeEndpointRequestPath(pathname);
+}
+function normalizeRuntimeEndpointRequestPath(pathname) {
+  return pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+function farmPluginMayAffectRuntimePath(plugin, pathname) {
+  const runtime = plugin.runtime;
+  const endpoints = runtime?.endpoints;
+  const hasUnscopedRequestHooks = Boolean(
+    plugin.init || plugin.ready || plugin.shutdown || runtime?.context || runtime?.before || runtime?.after || runtime?.error || plugin.router || plugin.render || plugin.beforeRouteMatch || plugin.afterRouteMatch || plugin.beforeRender || plugin.afterRender || plugin.onError || plugin.transformHTML || plugin.beforeRequest || plugin.afterResponse
+  );
+  if (hasUnscopedRequestHooks) return true;
+  if (Array.isArray(endpoints) && endpoints.length > 0) {
+    const normalizedPathname = normalizeRuntimeEndpointRequestPath(pathname);
+    return endpoints.some(
+      (endpoint) => normalizeFarmPluginRuntimeEndpointPath(
+        endpoint.path,
+        `Farm plugin "${plugin.name}" runtime endpoint`
+      ) === normalizedPathname
+    );
+  }
+  return Boolean(plugin.setup || runtime?.start || runtime?.close);
+}
+function _farmPluginsKeepResponsesPrivate(plugins) {
+  return plugins.some(
+    (plugin) => typeof plugin?.runtime?.before === "function" && plugin.runtime.cache !== "public"
+  );
+}
+
+export {
+  normalizeFarmPluginRuntimeEndpointPath,
+  normalizeRuntimeEndpointRequestPath,
+  farmPluginMayAffectRuntimePath,
+  _farmPluginsKeepResponsesPrivate
+};