@farm.js/core 0.1.31 → 0.1.35

package/dist/chunk-OFZUJMCU.mjs

@@ -0,0 +1,601 @@
+import {
+  getFarmClientReference,
+  subscribeFarmServerTreeUpdates
+} from "./chunk-NRDBW4MP.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/client/server-tree.ts
+var MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+var SERVER_HTML_TAG = "farm-server-html";
+var FARM_SERVER_TREE_ATTRIBUTE = "data-farm-server-tree";
+var SERVER_TREE_CHUNK_ATTRIBUTE = "data-farm-server-tree-chunk";
+var SERVER_HTML_ATTRIBUTE = "data-farm-server-html";
+var PARSER_SENSITIVE_TAGS = /* @__PURE__ */ new Set([
+  "caption",
+  "colgroup",
+  "datalist",
+  "head",
+  "html",
+  "iframe",
+  "math",
+  "noscript",
+  "optgroup",
+  "option",
+  "script",
+  "select",
+  "style",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr"
+]);
+var _UnsupportedNode = class _UnsupportedNode extends Error {
+};
+__name(_UnsupportedNode, "UnsupportedNode");
+var UnsupportedNode = _UnsupportedNode;
+var _UnsupportedInParserSensitiveElement = class _UnsupportedInParserSensitiveElement extends Error {
+};
+__name(_UnsupportedInParserSensitiveElement, "UnsupportedInParserSensitiveElement");
+var UnsupportedInParserSensitiveElement = _UnsupportedInParserSensitiveElement;
+function getHooksDispatcherSlot(ReactRuntime) {
+  const runtime = ReactRuntime;
+  const react19 = runtime.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  if (react19 && "H" in react19) {
+    return {
+      get: /* @__PURE__ */ __name(() => react19.H, "get"),
+      set: /* @__PURE__ */ __name((value) => {
+        react19.H = value;
+      }, "set")
+    };
+  }
+  const react18 = runtime.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentDispatcher;
+  if (react18) {
+    return {
+      get: /* @__PURE__ */ __name(() => react18.current, "get"),
+      set: /* @__PURE__ */ __name((value) => {
+        react18.current = value;
+      }, "set")
+    };
+  }
+  return null;
+}
+__name(getHooksDispatcherSlot, "getHooksDispatcherSlot");
+var unsupportedHooksDispatcher = /* @__PURE__ */ new Proxy(
+  {},
+  {
+    get(_target, name) {
+      return () => {
+        throw new UnsupportedNode(`calls ${String(name)}()`);
+      };
+    }
+  }
+);
+function callServerComponent(ReactRuntime, render, props, forwardRef) {
+  const slot = getHooksDispatcherSlot(ReactRuntime);
+  const previous = slot?.get();
+  slot?.set(unsupportedHooksDispatcher);
+  try {
+    return forwardRef ? render(props, null) : render(props);
+  } finally {
+    slot?.set(previous);
+  }
+}
+__name(callServerComponent, "callServerComponent");
+function isThenable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+__name(isThenable, "isThenable");
+function serverHtmlNode(state, node, key, context) {
+  if (context.parserSensitive) throw new UnsupportedInParserSensitiveElement();
+  const id = state.nextId++;
+  state.serverHtml.set(id, node);
+  return key === null ? { $: "x", i: id } : { $: "x", i: id, k: String(key) };
+}
+__name(serverHtmlNode, "serverHtmlNode");
+async function resolveProps(state, props, context, host) {
+  const entries = await Promise.all(
+    Object.entries(props).map(async ([name, value]) => {
+      if (value === void 0) return null;
+      if (name === "ref") {
+        if (value === null) return null;
+        throw new UnsupportedNode("receives a ref");
+      }
+      if (host && typeof value === "function") {
+        throw new UnsupportedNode(`passes a function to <${String(name)}>`);
+      }
+      return [name, await resolveValue(state, value, context, /* @__PURE__ */ new Set())];
+    })
+  );
+  return Object.fromEntries(entries.filter((entry) => entry !== null));
+}
+__name(resolveProps, "resolveProps");
+async function resolveValue(state, value, context, seen) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : { $: "n", v: String(value) };
+  }
+  if (typeof value !== "object") throw new UnsupportedNode(`passes a ${typeof value} value`);
+  if (state.ReactRuntime.isValidElement(value)) {
+    return resolveElement(state, value, context);
+  }
+  if (isThenable(value)) {
+    try {
+      return { $: "P", v: await resolveValue(state, await value, context, seen) };
+    } catch (error) {
+      if (error instanceof UnsupportedInParserSensitiveElement) throw error;
+      throw new UnsupportedNode("passes a promise that does not resolve to a serializable value");
+    }
+  }
+  if (seen.has(value)) throw new UnsupportedNode("passes a circular value");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return await Promise.all(value.map((entry) => resolveValue(state, entry, context, seen)));
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new UnsupportedNode("passes a class instance");
+    }
+    const entries = await Promise.all(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).map(
+        async ([name, entry]) => [
+          name,
+          await resolveValue(state, entry, context, seen)
+        ]
+      )
+    );
+    const object = Object.fromEntries(entries);
+    return Object.prototype.hasOwnProperty.call(object, "$") ? { $: "o", v: object } : object;
+  } finally {
+    seen.delete(value);
+  }
+}
+__name(resolveValue, "resolveValue");
+async function resolveElement(state, element, context) {
+  const { ReactRuntime } = state;
+  const key = element.key === null || element.key === void 0 ? null : String(element.key);
+  const withKey = /* @__PURE__ */ __name((node) => key === null ? node : { ...node, k: key }, "withKey");
+  let type = element.type;
+  const props = element.props ?? {};
+  try {
+    if (typeof type === "string") {
+      const parserSensitive = context.parserSensitive || PARSER_SENSITIVE_TAGS.has(type);
+      try {
+        const { children, ...rest } = props;
+        const resolved2 = await resolveProps(state, rest, context, true);
+        if (children !== void 0) {
+          resolved2.children = await resolveValue(state, children, { parserSensitive }, /* @__PURE__ */ new Set());
+        }
+        return withKey({ $: "h", t: type, p: resolved2 });
+      } catch (error) {
+        if (error instanceof UnsupportedInParserSensitiveElement && !context.parserSensitive) {
+          return serverHtmlNode(state, element, key, context);
+        }
+        throw error;
+      }
+    }
+    if (type === ReactRuntime.Fragment || type === ReactRuntime.StrictMode) {
+      return withKey({
+        $: "f",
+        c: await resolveValue(state, props.children, context, /* @__PURE__ */ new Set())
+      });
+    }
+    if (type === ReactRuntime.Suspense) {
+      const id = state.nextId++;
+      const fallback = await resolveValue(state, props.fallback, context, /* @__PURE__ */ new Set());
+      const encoded = resolveValue(state, props.children, context, /* @__PURE__ */ new Set()).catch((error) => {
+        if (error instanceof UnsupportedNode) {
+          return serverHtmlNode(
+            state,
+            ReactRuntime.createElement(
+              ReactRuntime.Fragment,
+              null,
+              props.children
+            ),
+            null,
+            { parserSensitive: false }
+          );
+        }
+        throw error;
+      });
+      encoded.catch(() => {
+      });
+      state.chunks.set(id, { encoded });
+      return withKey({ $: "s", f: fallback, i: id });
+    }
+    const clientReference = getFarmClientReference(type);
+    if (clientReference) {
+      const { children, ...rest } = props;
+      const resolved2 = await resolveProps(state, rest, context, false);
+      if (children !== void 0) {
+        resolved2.children = await resolveValue(state, children, context, /* @__PURE__ */ new Set());
+      }
+      state.components.set(
+        `${clientReference.reference}#${clientReference.exportName}`,
+        clientReference.Component
+      );
+      return withKey({
+        $: "c",
+        r: clientReference.reference,
+        e: clientReference.exportName,
+        p: resolved2
+      });
+    }
+    let forwardRef = false;
+    while (type && typeof type === "object") {
+      const typeOf = type.$$typeof;
+      if (typeOf === MEMO_TYPE) {
+        type = type.type;
+        if (getFarmClientReference(type)) {
+          return resolveElement(
+            state,
+            ReactRuntime.createElement(type, {
+              ...props,
+              key: element.key
+            }),
+            context
+          );
+        }
+        continue;
+      }
+      if (typeOf === FORWARD_REF_TYPE) {
+        type = type.render;
+        forwardRef = true;
+        break;
+      }
+      throw new UnsupportedNode("is not a function component");
+    }
+    if (typeof type !== "function") throw new UnsupportedNode("is not a function component");
+    if (type.prototype?.isReactComponent) {
+      throw new UnsupportedNode("is a class component");
+    }
+    let rendered = callServerComponent(
+      ReactRuntime,
+      type,
+      props,
+      forwardRef
+    );
+    if (isThenable(rendered)) rendered = await rendered;
+    const resolved = await resolveValue(state, rendered, context, /* @__PURE__ */ new Set());
+    return key === null ? resolved : { $: "f", k: key, c: resolved };
+  } catch (error) {
+    if (error instanceof UnsupportedNode) return serverHtmlNode(state, element, key, context);
+    throw error;
+  }
+}
+__name(resolveElement, "resolveElement");
+function serializeTreePayload(value) {
+  return JSON.stringify(value).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(serializeTreePayload, "serializeTreePayload");
+var chunkComponents = /* @__PURE__ */ new WeakMap();
+function getChunkComponent(ReactRuntime) {
+  const existing = chunkComponents.get(ReactRuntime.createElement);
+  if (existing) return existing;
+  function FarmServerTreeChunk({ chunk }) {
+    if (chunk.status === "fulfilled") return chunk.value;
+    if (chunk.status === "rejected") throw chunk.reason;
+    const use = ReactRuntime.use;
+    if (typeof use === "function") return use(chunk.promise);
+    throw chunk.promise;
+  }
+  __name(FarmServerTreeChunk, "FarmServerTreeChunk");
+  chunkComponents.set(ReactRuntime.createElement, FarmServerTreeChunk);
+  return FarmServerTreeChunk;
+}
+__name(getChunkComponent, "getChunkComponent");
+function fulfilledThenable(value) {
+  const promise = Promise.resolve(value);
+  promise.status = "fulfilled";
+  promise.value = value;
+  return promise;
+}
+__name(fulfilledThenable, "fulfilledThenable");
+function createTreeChildren(ReactRuntime, children, resolver) {
+  if (children === void 0) return [];
+  const node = createTreeValue(ReactRuntime, children, resolver);
+  return Array.isArray(children) ? node : [node];
+}
+__name(createTreeChildren, "createTreeChildren");
+function createTreeProps(ReactRuntime, props, resolver, key) {
+  const { children, ...rest } = props;
+  const created = {};
+  for (const [name, value] of Object.entries(rest)) {
+    created[name] = createTreeValue(ReactRuntime, value, resolver);
+  }
+  if (typeof key === "string") created.key = key;
+  return { props: created, children: createTreeChildren(ReactRuntime, children, resolver) };
+}
+__name(createTreeProps, "createTreeProps");
+function createTreeValue(ReactRuntime, value, resolver) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value))
+    return value.map((entry) => createTreeValue(ReactRuntime, entry, resolver));
+  switch (value.$) {
+    case "h": {
+      const { props, children } = createTreeProps(
+        ReactRuntime,
+        value.p,
+        resolver,
+        value.k
+      );
+      return ReactRuntime.createElement(value.t, props, ...children);
+    }
+    case "c": {
+      const { props, children } = createTreeProps(
+        ReactRuntime,
+        value.p,
+        resolver,
+        value.k
+      );
+      return ReactRuntime.createElement(
+        resolver.component(value.r, value.e),
+        props,
+        ...children
+      );
+    }
+    case "f":
+      return ReactRuntime.createElement(
+        ReactRuntime.Fragment,
+        typeof value.k === "string" ? { key: value.k } : null,
+        ...createTreeChildren(ReactRuntime, value.c, resolver)
+      );
+    case "s":
+      return ReactRuntime.createElement(
+        ReactRuntime.Suspense,
+        {
+          ...typeof value.k === "string" ? { key: value.k } : {},
+          fallback: createTreeValue(
+            ReactRuntime,
+            value.f,
+            resolver
+          )
+        },
+        ReactRuntime.createElement(getChunkComponent(ReactRuntime), {
+          chunk: resolver.chunk(value.i)
+        })
+      );
+    case "x":
+      return resolver.serverHtml(value.i, typeof value.k === "string" ? value.k : null);
+    case "n":
+      return Number(value.v);
+    case "P":
+      return fulfilledThenable(createTreeValue(ReactRuntime, value.v, resolver));
+    case "o": {
+      const object = value.v;
+      return Object.fromEntries(
+        Object.entries(object).map(([name, entry]) => [
+          name,
+          createTreeValue(ReactRuntime, entry, resolver)
+        ])
+      );
+    }
+    default:
+      return Object.fromEntries(
+        Object.entries(value).map(([name, entry]) => [
+          name,
+          createTreeValue(ReactRuntime, entry, resolver)
+        ])
+      );
+  }
+}
+__name(createTreeValue, "createTreeValue");
+function createTreeScript(ReactRuntime, attribute, value, json) {
+  return ReactRuntime.createElement("script", {
+    type: "application/json",
+    [attribute]: value,
+    dangerouslySetInnerHTML: { __html: json }
+  });
+}
+__name(createTreeScript, "createTreeScript");
+function createTreePage(ReactRuntime, tree, json, resolver, key) {
+  return ReactRuntime.createElement(
+    ReactRuntime.Fragment,
+    key === void 0 ? null : { key },
+    createTreeValue(ReactRuntime, tree, resolver),
+    createTreeScript(ReactRuntime, FARM_SERVER_TREE_ATTRIBUTE, "", json)
+  );
+}
+__name(createTreePage, "createTreePage");
+async function renderFarmServerTreePage(ReactRuntime, element, options) {
+  const state = {
+    ReactRuntime,
+    nextId: 0,
+    components: /* @__PURE__ */ new Map(),
+    serverHtml: /* @__PURE__ */ new Map(),
+    chunks: /* @__PURE__ */ new Map()
+  };
+  const tree = await resolveValue(state, element, { parserSensitive: false }, /* @__PURE__ */ new Set());
+  const resolver = {
+    component(reference, exportName) {
+      const Component = state.components.get(`${reference}#${exportName}`);
+      if (!Component)
+        throw new Error(`client reference ${reference}#${exportName} was not resolved`);
+      return Component;
+    },
+    chunk(id) {
+      const entry = state.chunks.get(id);
+      if (entry.chunk) return entry.chunk;
+      const chunk = {
+        status: "pending",
+        promise: entry.encoded.then(
+          (encoded) => {
+            chunk.value = ReactRuntime.createElement(
+              ReactRuntime.Fragment,
+              null,
+              createTreeValue(ReactRuntime, encoded, resolver),
+              createTreeScript(
+                ReactRuntime,
+                SERVER_TREE_CHUNK_ATTRIBUTE,
+                String(id),
+                serializeTreePayload({ t: encoded })
+              )
+            );
+            chunk.status = "fulfilled";
+            return chunk.value;
+          },
+          (error) => {
+            chunk.status = "rejected";
+            chunk.reason = error;
+            throw error;
+          }
+        )
+      };
+      chunk.promise.catch(() => {
+      });
+      entry.chunk = chunk;
+      return chunk;
+    },
+    serverHtml(id, key) {
+      return ReactRuntime.createElement(
+        SERVER_HTML_TAG,
+        {
+          ...key === null ? {} : { key },
+          [SERVER_HTML_ATTRIBUTE]: String(id),
+          style: { display: "contents" }
+        },
+        options.isolate(state.serverHtml.get(id))
+      );
+    }
+  };
+  const page = createTreePage(
+    ReactRuntime,
+    tree,
+    serializeTreePayload({ v: 1, t: tree }),
+    resolver
+  );
+  return ReactRuntime.createElement(/* @__PURE__ */ __name(function FarmServerTreePage() {
+    return page;
+  }, "FarmServerTreePage"));
+}
+__name(renderFarmServerTreePage, "renderFarmServerTreePage");
+function collectReferences(value, references) {
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const entry of value) collectReferences(entry, references);
+    return;
+  }
+  if (value.$ === "c") references.add(`${value.r}#${value.e}`);
+  for (const entry of Object.values(value)) collectReferences(entry, references);
+}
+__name(collectReferences, "collectReferences");
+function parseHtml(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+__name(parseHtml, "parseHtml");
+function originalExport(module, exportName) {
+  const Component = module.__farm_client_boundary_originals__?.[exportName];
+  if (typeof Component !== "function" && typeof Component !== "object") {
+    throw new Error(`compiled original export ${exportName} was not found`);
+  }
+  return Component;
+}
+__name(originalExport, "originalExport");
+async function createFarmServerTreeElement(ReactRuntime, source, options) {
+  const root = typeof source === "string" ? parseHtml(source) : source;
+  const script = root.querySelector(`script[${FARM_SERVER_TREE_ATTRIBUTE}]`);
+  if (!script) return null;
+  const json = script.textContent ?? "";
+  const payload = JSON.parse(json);
+  if (payload.v !== 1) throw new Error("unsupported server tree payload version");
+  const chunks = /* @__PURE__ */ new Map();
+  for (const chunkScript of root.querySelectorAll(
+    `script[${SERVER_TREE_CHUNK_ATTRIBUTE}]`
+  )) {
+    const chunkJson = chunkScript.textContent ?? "";
+    chunks.set(Number(chunkScript.getAttribute(SERVER_TREE_CHUNK_ATTRIBUTE)), {
+      tree: JSON.parse(chunkJson).t,
+      json: chunkJson
+    });
+  }
+  const references = /* @__PURE__ */ new Set();
+  collectReferences(payload.t, references);
+  for (const chunk of chunks.values()) collectReferences(chunk.tree, references);
+  const components = /* @__PURE__ */ new Map();
+  await Promise.all(
+    Array.from(references, async (key) => {
+      const separator = key.lastIndexOf("#");
+      const reference = key.slice(0, separator);
+      components.set(key, originalExport(await options.load(reference), key.slice(separator + 1)));
+    })
+  );
+  const serverHtml = /* @__PURE__ */ new Map();
+  for (const container of root.querySelectorAll(`${SERVER_HTML_TAG}[${SERVER_HTML_ATTRIBUTE}]`)) {
+    serverHtml.set(Number(container.getAttribute(SERVER_HTML_ATTRIBUTE)), container.innerHTML);
+  }
+  const resolver = {
+    component(reference, exportName) {
+      const Component = components.get(`${reference}#${exportName}`);
+      if (!Component) throw new Error(`client reference ${reference}#${exportName} was not loaded`);
+      return Component;
+    },
+    chunk(id) {
+      const chunk = chunks.get(id);
+      if (!chunk) throw new Error(`server tree chunk ${id} was not found`);
+      const value = ReactRuntime.createElement(
+        ReactRuntime.Fragment,
+        null,
+        createTreeValue(ReactRuntime, chunk.tree, resolver),
+        createTreeScript(ReactRuntime, SERVER_TREE_CHUNK_ATTRIBUTE, String(id), chunk.json)
+      );
+      return { status: "fulfilled", value, promise: Promise.resolve(value) };
+    },
+    serverHtml(id, key) {
+      const html = serverHtml.get(id);
+      if (html === void 0) throw new Error(`server HTML ${id} was not found`);
+      return ReactRuntime.createElement(options.ServerHtml, {
+        ...key === null ? {} : { key },
+        as: SERVER_HTML_TAG,
+        [SERVER_HTML_ATTRIBUTE]: String(id),
+        style: { display: "contents" },
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: { __html: html }
+      });
+    }
+  };
+  const build = /* @__PURE__ */ __name(() => createTreePage(ReactRuntime, payload.t, json, resolver), "build");
+  build();
+  function FarmServerTreePage() {
+    const [, setVersion] = ReactRuntime.useState(0);
+    ReactRuntime.useEffect(() => {
+      const listener = /* @__PURE__ */ __name((reference, module) => {
+        let changed = false;
+        for (const key of components.keys()) {
+          const separator = key.lastIndexOf("#");
+          if (key.slice(0, separator) !== reference) continue;
+          components.set(key, originalExport(module, key.slice(separator + 1)));
+          changed = true;
+        }
+        if (changed) setVersion((version) => version + 1);
+        return changed;
+      }, "listener");
+      return subscribeFarmServerTreeUpdates(listener);
+    }, []);
+    return build();
+  }
+  __name(FarmServerTreePage, "FarmServerTreePage");
+  return ReactRuntime.createElement(
+    FarmServerTreePage,
+    options.key === void 0 ? null : { key: options.key }
+  );
+}
+__name(createFarmServerTreeElement, "createFarmServerTreeElement");
+
+export {
+  FARM_SERVER_TREE_ATTRIBUTE,
+  renderFarmServerTreePage,
+  createFarmServerTreeElement
+};

package/dist/{chunk-L4DVIHOC.mjs → chunk-OKZUAXHF.mjs}

@@ -27,7 +27,7 @@ import {
 } from "./chunk-ZMSZZXOR.mjs";
 import {
   getIntegrationSchemas
-} from "./chunk-JLCQGPXE.mjs";
+} from "./chunk-HMIJDL7S.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";

package/dist/{chunk-EM6SBQKM.cjs → chunk-OMVAU7NT.cjs}

@@ -419,6 +419,30 @@ async function readNodeRequestBody(request, limit) {
   });
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, readNodeRequestBody, "readNodeRequestBody");
+function createFarmNodeRequestBodyStream(request) {
+  let iterator;
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        _nullishCoalesce(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 _optionalChain([iterator, 'optionalAccess', _31 => _31.return, 'optionalCall', _32 => _32(reason)]);
+      }
+    },
+    // No eager pull: the request stays untouched until the handler reads it.
+    { highWaterMark: 0 }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmNodeRequestBodyStream, "createFarmNodeRequestBodyStream");
 function createFarmRequestBodyErrorResponse(error) {
   if (!(error instanceof FarmRequestBodyError)) return null;
   return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
@@ -432,7 +456,7 @@ function createFarmRequestBodyErrorResponse(error) {
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
 function validateContentLength(value, limit) {
-  const contentLength = _optionalChain([value, 'optionalAccess', _31 => _31.trim, 'call', _32 => _32()]);
+  const contentLength = _optionalChain([value, 'optionalAccess', _33 => _33.trim, 'call', _34 => _34()]);
   if (!contentLength) return;
   if (!/^\d+$/.test(contentLength)) {
     throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
@@ -467,4 +491,5 @@ _chunkS3JO3N4Hcjs.__name.call(void 0, throwIfAborted, "throwIfAborted");
 
 
 
-exports.setRequestContext = setRequestContext; exports.getRequestContext = getRequestContext; exports.hasRequestContext = hasRequestContext; exports.deleteRequestContext = deleteRequestContext; exports.clearRequestContext = clearRequestContext; exports.getRequestContextSnapshot = getRequestContextSnapshot; exports.copyRequestContext = copyRequestContext; exports.createFarmNodeRequestAbortSignal = createFarmNodeRequestAbortSignal; exports.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT; exports.matchesFarmIfNoneMatch = matchesFarmIfNoneMatch; exports.resolveFarmServerConfig = resolveFarmServerConfig; exports.parseBodySizeLimit = parseBodySizeLimit; exports.cloneFarmRequestWithContext = cloneFarmRequestWithContext; exports.bufferFarmRequestBody = bufferFarmRequestBody; exports.readFarmRequestBody = readFarmRequestBody; exports.readNodeRequestBody = readNodeRequestBody; exports.createFarmRequestBodyErrorResponse = createFarmRequestBodyErrorResponse;
+
+exports.setRequestContext = setRequestContext; exports.getRequestContext = getRequestContext; exports.hasRequestContext = hasRequestContext; exports.deleteRequestContext = deleteRequestContext; exports.clearRequestContext = clearRequestContext; exports.getRequestContextSnapshot = getRequestContextSnapshot; exports.copyRequestContext = copyRequestContext; exports.createFarmNodeRequestAbortSignal = createFarmNodeRequestAbortSignal; exports.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT; exports.matchesFarmIfNoneMatch = matchesFarmIfNoneMatch; exports.resolveFarmServerConfig = resolveFarmServerConfig; exports.parseBodySizeLimit = parseBodySizeLimit; exports.cloneFarmRequestWithContext = cloneFarmRequestWithContext; exports.bufferFarmRequestBody = bufferFarmRequestBody; exports.readFarmRequestBody = readFarmRequestBody; exports.readNodeRequestBody = readNodeRequestBody; exports.createFarmNodeRequestBodyStream = createFarmNodeRequestBodyStream; exports.createFarmRequestBodyErrorResponse = createFarmRequestBodyErrorResponse;

package/dist/{chunk-AHAJGAYD.mjs → chunk-PDOCJ6RY.mjs}

@@ -15,10 +15,10 @@ import {
 } from "./chunk-TVGP4BBZ.mjs";
 import {
   farmAcceptQuality
-} from "./chunk-JBC2FKRW.mjs";
+} from "./chunk-WWIKMBRN.mjs";
 import {
   matchesFarmIfNoneMatch
-} from "./chunk-XF7Q24PF.mjs";
+} from "./chunk-Y7RKTKYI.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";