@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-ZLAT2CWY.mjs

@@ -0,0 +1,135 @@
+import {
+  resolveFarmAPICanonicalPathname,
+  resolveFarmAPIServerRoutePath
+} from "./chunk-BTHHUD7Q.mjs";
+import {
+  matchAPIRoute
+} from "./chunk-O7BH5O46.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/mcp-catalog.ts
+var CATALOGS = /* @__PURE__ */ Symbol.for("farm.mcp.catalogs");
+function catalogs() {
+  const state = globalThis;
+  return state[CATALOGS] ?? (state[CATALOGS] = /* @__PURE__ */ new Map());
+}
+__name(catalogs, "catalogs");
+function _listFarmMCPCatalogs() {
+  return [...catalogs().values()];
+}
+__name(_listFarmMCPCatalogs, "_listFarmMCPCatalogs");
+function _publishFarmMCPCatalog(server, tools, details) {
+  const entry = { server, tools, ...details ? { details } : {} };
+  catalogs().set(server.path, entry);
+  return () => {
+    if (catalogs().get(server.path) === entry) catalogs().delete(server.path);
+  };
+}
+__name(_publishFarmMCPCatalog, "_publishFarmMCPCatalog");
+var SERVERS = /* @__PURE__ */ Symbol.for("farm.mcp.servers");
+function registeredServers() {
+  const state = globalThis;
+  return state[SERVERS] ?? (state[SERVERS] = /* @__PURE__ */ new Map());
+}
+__name(registeredServers, "registeredServers");
+function _listFarmRegisteredMCPServers() {
+  return [...registeredServers().values()];
+}
+__name(_listFarmRegisteredMCPServers, "_listFarmRegisteredMCPServers");
+function registerFarmMCPServer(server) {
+  const entry = validateFarmMCPServerRegistration(server);
+  const key = entry.path ?? entry.url;
+  registeredServers().set(key, entry);
+  return () => {
+    if (registeredServers().get(key) === entry) registeredServers().delete(key);
+  };
+}
+__name(registerFarmMCPServer, "registerFarmMCPServer");
+function validateFarmMCPServerRegistration(server) {
+  if (!server || typeof server !== "object") {
+    throw new TypeError("registerFarmMCPServer expects a server object.");
+  }
+  const text = /* @__PURE__ */ __name((key, required) => {
+    const value = server[key];
+    if (value === void 0 && !required) return void 0;
+    if (typeof value !== "string" || !value.trim()) {
+      throw new TypeError(`registerFarmMCPServer ${key} must be a non-empty string.`);
+    }
+    return value.trim();
+  }, "text");
+  const name = text("name", true);
+  const version = text("version", true);
+  const title = text("title", false);
+  const description = text("description", false);
+  const { path, url } = server;
+  if (path === void 0 === (url === void 0)) {
+    throw new TypeError("registerFarmMCPServer takes exactly one of path and url.");
+  }
+  let endpoint;
+  if (path !== void 0) {
+    if (typeof path !== "string" || !/^\/(?!\/)[^?#\\\s]*$/.test(path) || path.split("/").some((segment) => segment === "." || segment === "..")) {
+      throw new TypeError(
+        "registerFarmMCPServer path must be an absolute app path without a query, hash, or dot segments."
+      );
+    }
+    endpoint = { path: path.length > 1 ? path.replace(/\/+$/, "") : path };
+  } else {
+    let parsed;
+    try {
+      parsed = typeof url === "string" ? new URL(url) : void 0;
+    } catch {
+      parsed = void 0;
+    }
+    if (!parsed || parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.search || parsed.hash) {
+      throw new TypeError(
+        "registerFarmMCPServer url must be an absolute http(s) URL without credentials, a query, or a hash."
+      );
+    }
+    endpoint = { url: `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}` };
+  }
+  const { protocolVersions } = server;
+  if (protocolVersions !== void 0 && (!Array.isArray(protocolVersions) || protocolVersions.some((version2) => typeof version2 !== "string" || !version2.trim()))) {
+    throw new TypeError("registerFarmMCPServer protocolVersions must be non-empty strings.");
+  }
+  return Object.freeze({
+    name,
+    version,
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ...protocolVersions?.length ? { protocolVersions: Object.freeze([...protocolVersions]) } : {},
+    ...endpoint
+  });
+}
+__name(validateFarmMCPServerRegistration, "validateFarmMCPServerRegistration");
+function _findFarmMCPEndpointTool(method, pathname, serverBasePath) {
+  const upperMethod = method.toUpperCase();
+  for (const { server, tools } of catalogs().values()) {
+    const routes = /* @__PURE__ */ new Map();
+    for (const tool of tools) {
+      if (tool.kind === "endpoint" && tool.method === upperMethod) {
+        routes.set(tool.path, { path: tool.path, name: tool.name });
+      }
+    }
+    if (routes.size === 0) continue;
+    const canonical = serverBasePath ? resolveFarmAPICanonicalPathname(pathname, serverBasePath) : pathname;
+    const match = matchAPIRoute(routes, canonical);
+    if (match) {
+      return {
+        name: match.route.name,
+        endpoint: resolveFarmAPIServerRoutePath(server.path, serverBasePath)
+      };
+    }
+  }
+  return void 0;
+}
+__name(_findFarmMCPEndpointTool, "_findFarmMCPEndpointTool");
+
+export {
+  _listFarmMCPCatalogs,
+  _publishFarmMCPCatalog,
+  _listFarmRegisteredMCPServers,
+  registerFarmMCPServer,
+  _findFarmMCPEndpointTool
+};

package/dist/chunk-ZMMBIVQM.mjs

@@ -0,0 +1,505 @@
+import {
+  assertBrowserStableRoutePath
+} from "./chunk-55YI3RRB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/request-context.ts
+var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
+function getRequestContextStore() {
+  const globalState = globalThis;
+  if (!globalState[REQUEST_CONTEXT_STORE_KEY]) {
+    globalState[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
+  }
+  return globalState[REQUEST_CONTEXT_STORE_KEY];
+}
+__name(getRequestContextStore, "getRequestContextStore");
+function getBucket(target) {
+  const requestContextStore = getRequestContextStore();
+  let bucket = requestContextStore.get(target);
+  if (!bucket) {
+    bucket = {
+      privateData: /* @__PURE__ */ new Map(),
+      exposedData: /* @__PURE__ */ new Map()
+    };
+    requestContextStore.set(target, bucket);
+  }
+  return bucket;
+}
+__name(getBucket, "getBucket");
+function setRequestContext(target, key, value, options = {}) {
+  const bucket = getBucket(target);
+  bucket.privateData.set(key, value);
+  if (options.exposeToPage) {
+    bucket.exposedData.set(key, value);
+  }
+}
+__name(setRequestContext, "setRequestContext");
+function getRequestContext(target, key) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  return bucket?.privateData.get(key);
+}
+__name(getRequestContext, "getRequestContext");
+function hasRequestContext(target, key) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  return bucket?.privateData.has(key) ?? false;
+}
+__name(hasRequestContext, "hasRequestContext");
+function deleteRequestContext(target, key) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  if (!bucket) return false;
+  const removedPrivate = bucket.privateData.delete(key);
+  bucket.exposedData.delete(key);
+  return removedPrivate;
+}
+__name(deleteRequestContext, "deleteRequestContext");
+function clearRequestContext(target) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  if (!bucket) return;
+  bucket.privateData.clear();
+  bucket.exposedData.clear();
+}
+__name(clearRequestContext, "clearRequestContext");
+function getRequestContextSnapshot(target, options = {}) {
+  const requestContextStore = getRequestContextStore();
+  const bucket = requestContextStore.get(target);
+  if (!bucket) return /* @__PURE__ */ new Map();
+  if (options.exposedOnly) {
+    return new Map(bucket.exposedData);
+  }
+  return new Map(bucket.privateData);
+}
+__name(getRequestContextSnapshot, "getRequestContextSnapshot");
+function copyRequestContext(source, target) {
+  const bucket = getRequestContextStore().get(source);
+  if (!bucket || source === target) return;
+  for (const [key, value] of bucket.privateData) {
+    setRequestContext(target, key, value, { exposeToPage: bucket.exposedData.has(key) });
+  }
+}
+__name(copyRequestContext, "copyRequestContext");
+
+// src/server-http.ts
+function createFarmNodeRequestAbortSignal(req, res) {
+  const controller = new AbortController();
+  let disposed = false;
+  const dispose = /* @__PURE__ */ __name(() => {
+    if (disposed) return;
+    disposed = true;
+    req.off("aborted", abort);
+    res.off("close", abortOnEarlyClose);
+    res.off("finish", dispose);
+    controller.signal.removeEventListener("abort", dispose);
+  }, "dispose");
+  const abort = /* @__PURE__ */ __name(() => controller.abort(), "abort");
+  const abortOnEarlyClose = /* @__PURE__ */ __name(() => {
+    if (!res.writableEnded) abort();
+    dispose();
+  }, "abortOnEarlyClose");
+  if (req.aborted) {
+    controller.abort();
+    return controller.signal;
+  }
+  req.once("aborted", abort);
+  res.once("close", abortOnEarlyClose);
+  res.once("finish", dispose);
+  controller.signal.addEventListener("abort", dispose, { once: true });
+  return controller.signal;
+}
+__name(createFarmNodeRequestAbortSignal, "createFarmNodeRequestAbortSignal");
+var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
+var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
+var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
+var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
+var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
+var MAX_FARM_SERVER_TIMEOUT = 2147483647;
+function createFarmWeakETag(body) {
+  let hash = 2166136261;
+  for (let index = 0; index < body.length; index++) {
+    hash ^= body.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `W/"${(hash >>> 0).toString(16).padStart(8, "0")}"`;
+}
+__name(createFarmWeakETag, "createFarmWeakETag");
+function matchesFarmIfNoneMatch(value, etag) {
+  const expected = parseEntityTag(trimOptionalWhitespace(etag));
+  if (!expected) return false;
+  const values = Array.isArray(value) ? value : [value];
+  const combined = values.filter((header) => typeof header === "string").join(",");
+  const fieldValue = trimOptionalWhitespace(combined);
+  if (!fieldValue) return false;
+  if (fieldValue === "*") return true;
+  let matched = false;
+  let hasEntityTag = false;
+  for (const candidate of splitEntityTags(fieldValue)) {
+    const token = trimOptionalWhitespace(candidate);
+    if (!token) continue;
+    const parsed = parseEntityTag(token);
+    if (!parsed) return false;
+    hasEntityTag = true;
+    if (parsed === expected) matched = true;
+  }
+  return hasEntityTag && matched;
+}
+__name(matchesFarmIfNoneMatch, "matchesFarmIfNoneMatch");
+function trimOptionalWhitespace(value) {
+  return value.replace(/^[\t ]+|[\t ]+$/g, "");
+}
+__name(trimOptionalWhitespace, "trimOptionalWhitespace");
+function parseEntityTag(value) {
+  const opaqueTag = value.startsWith("W/") ? value.slice(2) : value;
+  if (opaqueTag.length < 2 || opaqueTag[0] !== '"' || opaqueTag.at(-1) !== '"') return null;
+  for (let index = 1; index < opaqueTag.length - 1; index++) {
+    const code = opaqueTag.charCodeAt(index);
+    if (code === 33 || code >= 35 && code <= 126 || code >= 128) continue;
+    return null;
+  }
+  return opaqueTag;
+}
+__name(parseEntityTag, "parseEntityTag");
+function splitEntityTags(value) {
+  const tags = [];
+  let start = 0;
+  let quoted = false;
+  for (let index = 0; index < value.length; index++) {
+    const character = value[index];
+    if (character === '"') {
+      quoted = !quoted;
+    } else if (character === "," && !quoted) {
+      tags.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  tags.push(value.slice(start));
+  return tags;
+}
+__name(splitEntityTags, "splitEntityTags");
+var _FarmRequestBodyError = class _FarmRequestBodyError extends Error {
+  constructor(code, status, message) {
+    super(message);
+    this.name = "FarmRequestBodyError";
+    this.code = code;
+    this.status = status;
+  }
+};
+__name(_FarmRequestBodyError, "FarmRequestBodyError");
+var FarmRequestBodyError = _FarmRequestBodyError;
+function resolveFarmServerConfig(config) {
+  const headersTimeout = parseFarmServerDuration(
+    config?.headersTimeout ?? DEFAULT_FARM_SERVER_HEADERS_TIMEOUT,
+    "server.headersTimeout"
+  );
+  const requestTimeout = parseFarmServerDuration(
+    config?.requestTimeout ?? DEFAULT_FARM_SERVER_REQUEST_TIMEOUT,
+    "server.requestTimeout"
+  );
+  if (headersTimeout > requestTimeout) {
+    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
+  }
+  return Object.freeze({
+    bodySizeLimit: parseBodySizeLimit(
+      config?.bodySizeLimit ?? DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
+      "server.bodySizeLimit"
+    ),
+    trustProxy: config?.trustProxy === true,
+    headersTimeout,
+    requestTimeout,
+    keepAliveTimeout: parseFarmServerDuration(
+      config?.keepAliveTimeout ?? DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT,
+      "server.keepAliveTimeout"
+    ),
+    gracefulShutdownTimeout: parseFarmServerDuration(
+      config?.gracefulShutdownTimeout ?? DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT,
+      "server.gracefulShutdownTimeout"
+    ),
+    health: resolveFarmServerHealthConfig(config?.health)
+  });
+}
+__name(resolveFarmServerConfig, "resolveFarmServerConfig");
+function parseFarmServerDuration(value, optionName = "duration") {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${optionName} must be a positive safe integer`);
+    }
+    if (value > MAX_FARM_SERVER_TIMEOUT) {
+      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
+  if (!match) {
+    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  const milliseconds = Math.floor(amount * multiplier);
+  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
+    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
+  }
+  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
+    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
+  }
+  return milliseconds;
+}
+__name(parseFarmServerDuration, "parseFarmServerDuration");
+function resolveFarmServerHealthConfig(config) {
+  if (config === false || config && "enabled" in config && config.enabled === false) {
+    return Object.freeze({
+      enabled: false,
+      livenessPath: "/_farm/health/live",
+      readinessPath: "/_farm/health/ready"
+    });
+  }
+  const livenessPath = normalizeHealthPath(
+    config?.livenessPath ?? "/_farm/health/live",
+    "server.health.livenessPath"
+  );
+  const readinessPath = normalizeHealthPath(
+    config?.readinessPath ?? "/_farm/health/ready",
+    "server.health.readinessPath"
+  );
+  if (livenessPath === readinessPath) {
+    throw new TypeError("server.health livenessPath and readinessPath must be different");
+  }
+  return Object.freeze({ enabled: true, livenessPath, readinessPath });
+}
+__name(resolveFarmServerHealthConfig, "resolveFarmServerHealthConfig");
+function normalizeHealthPath(value, optionName) {
+  const path = value.trim();
+  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
+    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
+  }
+  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
+  assertBrowserStableRoutePath(normalized);
+  return normalized;
+}
+__name(normalizeHealthPath, "normalizeHealthPath");
+function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${optionName} must be a positive safe integer`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
+  if (!match) {
+    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2] ?? "b";
+  const multiplier = {
+    b: 1,
+    kb: 1e3,
+    mb: 1e6,
+    gb: 1e9,
+    kib: 1024,
+    mib: 1048576,
+    gib: 1073741824
+  };
+  const bytes = Math.floor(amount * multiplier[unit]);
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
+  }
+  return bytes;
+}
+__name(parseBodySizeLimit, "parseBodySizeLimit");
+function cloneFarmRequestWithContext(request) {
+  const cloned = request.clone();
+  copyRequestContext(request, cloned);
+  return cloned;
+}
+__name(cloneFarmRequestWithContext, "cloneFarmRequestWithContext");
+async function bufferFarmRequestBody(request, limit) {
+  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
+    return request;
+  }
+  const bytes = await readFarmRequestBody(request, limit);
+  const body = new Uint8Array(bytes.byteLength);
+  body.set(bytes);
+  const buffered = new Request(request, {
+    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
+    body: body.buffer
+  });
+  copyRequestContext(request, buffered);
+  return buffered;
+}
+__name(bufferFarmRequestBody, "bufferFarmRequestBody");
+async function readFarmRequestBody(request, limit) {
+  try {
+    validateContentLength(request.headers.get("content-length"), limit);
+  } catch (error) {
+    void request.body?.cancel(error).catch(() => {
+    });
+    throw error;
+  }
+  throwIfAborted(request.signal);
+  if (!request.body) return new Uint8Array();
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  const cancelBodyRead = /* @__PURE__ */ __name(() => {
+    void reader.cancel(request.signal.reason).catch(() => {
+    });
+  }, "cancelBodyRead");
+  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
+  try {
+    while (true) {
+      throwIfAborted(request.signal);
+      const { done, value } = await reader.read();
+      throwIfAborted(request.signal);
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > limit) {
+        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+        void reader.cancel(error).catch(() => {
+        });
+        throw error;
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    if (request.signal.aborted) throwIfAborted(request.signal);
+    throw error;
+  } finally {
+    request.signal.removeEventListener("abort", cancelBodyRead);
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+__name(readFarmRequestBody, "readFarmRequestBody");
+async function readNodeRequestBody(request, limit) {
+  const rawContentLength = request.headers["content-length"];
+  const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
+  try {
+    validateContentLength(contentLength, limit);
+  } catch (error) {
+    request.resume?.();
+    throw error;
+  }
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    let settled = false;
+    const cleanup = /* @__PURE__ */ __name(() => {
+      request.removeListener?.("data", onData);
+      request.removeListener?.("end", onEnd);
+      request.removeListener?.("error", onError);
+    }, "cleanup");
+    const rejectOnce = /* @__PURE__ */ __name((error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      request.resume?.();
+      reject(error);
+    }, "rejectOnce");
+    const onData = /* @__PURE__ */ __name((chunk) => {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += bytes.byteLength;
+      if (total > limit) {
+        rejectOnce(new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large"));
+        return;
+      }
+      chunks.push(bytes);
+    }, "onData");
+    const onEnd = /* @__PURE__ */ __name(() => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(Buffer.concat(chunks, total));
+    }, "onEnd");
+    const onError = /* @__PURE__ */ __name((error) => rejectOnce(error), "onError");
+    request.on("data", onData);
+    request.on("end", onEnd);
+    request.on("error", onError);
+  });
+}
+__name(readNodeRequestBody, "readNodeRequestBody");
+function createFarmNodeRequestBodyStream(request) {
+  let iterator;
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        iterator ?? (iterator = request[Symbol.asyncIterator]());
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(
+          value instanceof Uint8Array ? value : new TextEncoder().encode(String(value))
+        );
+      },
+      async cancel(reason) {
+        await iterator?.return?.(reason);
+      }
+    },
+    // No eager pull: the request stays untouched until the handler reads it.
+    { highWaterMark: 0 }
+  );
+}
+__name(createFarmNodeRequestBodyStream, "createFarmNodeRequestBodyStream");
+function createFarmRequestBodyErrorResponse(error) {
+  if (!(error instanceof FarmRequestBodyError)) return null;
+  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
+    status: error.status,
+    headers: {
+      "cache-control": "no-store",
+      "content-type": "text/plain; charset=utf-8",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+__name(createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
+function validateContentLength(value, limit) {
+  const contentLength = value?.trim();
+  if (!contentLength) return;
+  if (!/^\d+$/.test(contentLength)) {
+    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
+  }
+  if (Number(contentLength) > limit) {
+    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+  }
+}
+__name(validateContentLength, "validateContentLength");
+function throwIfAborted(signal) {
+  if (!signal.aborted) return;
+  if (signal.reason !== void 0) throw signal.reason;
+  throw new DOMException("The operation was aborted", "AbortError");
+}
+__name(throwIfAborted, "throwIfAborted");
+
+export {
+  setRequestContext,
+  getRequestContext,
+  hasRequestContext,
+  deleteRequestContext,
+  clearRequestContext,
+  getRequestContextSnapshot,
+  copyRequestContext,
+  createFarmNodeRequestAbortSignal,
+  DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
+  createFarmWeakETag,
+  matchesFarmIfNoneMatch,
+  resolveFarmServerConfig,
+  parseBodySizeLimit,
+  cloneFarmRequestWithContext,
+  bufferFarmRequestBody,
+  readFarmRequestBody,
+  readNodeRequestBody,
+  createFarmNodeRequestBodyStream,
+  createFarmRequestBodyErrorResponse
+};