@gcmdev/faxios 0.2.1 → 0.2.3

package/src/lib/adapters/fetch.ts

@@ -6,19 +6,19 @@ import { VERSION } from "../env/data.js";
 import composeSignals from "../helpers/composeSignals.js";
 import estimateDataURLDecodedBytes from "../helpers/estimateDataURLDecodedBytes.js";
 import {
-  progressEventReducer,
+  asyncDecorator,
   progressEventDecorator,
-  asyncDecorator
+  progressEventReducer
 } from "../helpers/progressEventReducer.js";
 import { toByteStringHeaderObject } from "../helpers/sanitizeHeaderValue.js";
 import { trackStream } from "../helpers/trackStream.js";
 import platform from "../platform.js";
 import type {
-  InternalFaxiosRequestConfig,
-  FaxiosRequestHeaders
+  FaxiosRequestHeaders,
+  InternalFaxiosRequestConfig
 } from "../types.js";
 import utils from "../utils.js";
-import { checkDeclaredContentLength, checkMaterializedSize, handleFetchCaughtError, cleanFormDataContentType, encodeBodyIfNeeded } from "./fetch-helpers.js";
+import { checkDeclaredContentLength, checkMaterializedSize, cleanFormDataContentType, encodeBodyIfNeeded, handleFetchCaughtError } from "./fetch-helpers.js";
 import type { ComposedSignal, PendingBodyErrorRef } from "./fetch-helpers.js";
 
 // btoa is a global in Node 16+ and browsers; accessed via globalThis for no-DOM lib compat
@@ -28,29 +28,29 @@ const _btoa: (data: string) => string = (
 type AnyConstructor = new (...args: Array<unknown>) => unknown;
 type FetchFn = (input: unknown, init?: unknown) => Promise<AnyResponse>;
 type AnyResponse = {
+  [key: string]: unknown;
+  arrayBuffer: () => Promise<ArrayBuffer>;
   body: unknown;
   headers: {
-    has: (name: string) => boolean;
-    get: (name: string) => string | null;
     [key: string]: unknown;
+    get: (name: string) => null | string;
+    has: (name: string) => boolean;
   };
   status: number;
   statusText: string;
-  arrayBuffer: () => Promise<ArrayBuffer>;
-  [key: string]: unknown;
 };
 type AnyRequest = {
+  [key: string]: unknown;
+  arrayBuffer: () => Promise<ArrayBuffer>;
+  body: null | { cancel: () => Promise<void>; };
   headers: {
+    get: (name: string) => null | string;
     has: (name: string) => boolean;
-    get: (name: string) => string | null;
   };
-  body: { cancel: () => Promise<void>; } | null;
-  arrayBuffer: () => Promise<ArrayBuffer>;
-  [key: string]: unknown;
 };
 type AnyReadableStream = {
-  cancel: () => Promise<void>;
   [key: string]: unknown;
+  cancel: () => Promise<void>;
 };
 type AnyTextEncoder = { encode: (str: string) => Uint8Array; };
 
@@ -58,10 +58,35 @@ const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
 const { isFunction } = utils;
 
+// Web stream bodies this adapter has sent. fetch can read a stream without leaving it locked,
+// and there's no portable "disturbed" check, so a second send is caught here.
+const sentStreamBodies = new WeakSet<object>();
+
+// A stream body can be read once. Middleware that calls next() again after a try read it
+// would send an empty body (Node stream) or get an uncoded TypeError from fetch (web stream).
+const rejectUsedStreamBody = (data: unknown, config: InternalFaxiosRequestConfig): void => {
+  const body = data as { bodyUsed?: unknown; destroyed?: unknown; locked?: unknown; readableDidRead?: unknown; readableEnded?: unknown; };
+  const isWebStream = utils.isReadableStream!(data);
+  if (
+    (isWebStream && (body.locked === true || sentStreamBodies.has(body))) ||
+    ((utils.isRequest!(data) || utils.isResponse!(data)) && body.bodyUsed === true) ||
+    (utils.isStream(data) && (body.readableDidRead === true || body.readableEnded === true || body.destroyed === true))
+  ) {
+    throw new FaxiosError(
+      "Request body stream was already used and can't be sent again; pass a new body for each try",
+      FaxiosError.ERR_BAD_REQUEST,
+      config
+    );
+  }
+  if (isWebStream) sentStreamBodies.add(body);
+};
+
+const isBrowserRuntime = platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv;
+
 // Server runtimes default User-Agent to their own (e.g. "node"), so name faxios there.
 // Browsers send their own User-Agent; setting one makes every cross-origin request
 // need a CORS preflight that most APIs don't allow.
-const setsUserAgent = !platform.hasStandardBrowserEnv && !platform.hasStandardBrowserWebWorkerEnv;
+const setsUserAgent = !isBrowserRuntime;
 const applyDefaultUserAgent = (headers: FaxiosRequestHeaders): void => {
   if (setsUserAgent) headers.set("User-Agent", "faxios/" + VERSION, false);
 };
@@ -116,8 +141,48 @@ const maybeWithAuthCredentials = (url: string): boolean => {
   return urlToCheck.includes("@");
 };
 
-// eslint-disable-next-line sonarjs/function-return-type
-const factory = (env: Record<string, unknown>) => {
+// RequestInit members faxios sets itself; the same keys in `fetchOptions` are ignored.
+const FAXIOS_INIT_KEYS: Record<string, true> = {
+  body: true,
+  credentials: true,
+  duplex: true,
+  headers: true,
+  method: true,
+  signal: true,
+};
+
+// Spec defaults written as own init members when the caller sets none. undici converts the init
+// into a plain dictionary and reads absent members from it, so an absent member still picks up a
+// polluted Object.prototype value; an own default leaves nothing to inherit.
+const REQUEST_INIT_DEFAULTS: Record<string, unknown> = {
+  cache: "default",
+  integrity: "",
+  keepalive: false,
+  mode: "cors",
+  redirect: "follow",
+  referrer: "about:client",
+  referrerPolicy: "",
+};
+
+// Where undici (Node's fetch) keeps its global dispatcher.
+const UNDICI_GLOBAL_DISPATCHER = Symbol.for("undici.globalDispatcher.1");
+
+type FetchEnv = {
+  fetch?: unknown;
+  Request?: unknown;
+  Response?: unknown;
+};
+
+type FetchAdapter = (config: InternalFaxiosRequestConfig) => Promise<unknown>;
+
+// Own reads only: a polluted Object.prototype.fetch must never become the transport.
+const readOwn = (obj: unknown, key: string): unknown =>
+  typeof obj === "object" && obj !== null && utils.hasOwnProp(obj, key) ? Reflect.get(obj, key) : undefined;
+const ownEnv = (config: unknown, key: keyof FetchEnv): unknown => readOwn(readOwn(config, "env"), key);
+
+// Feature detection depends only on the Request and Response constructors, so one adapter
+// serves every `env.fetch`. `env.fetch` is read for each request.
+const factory = (env: Omit<FetchEnv, "fetch">): FetchAdapter => {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   const globalObject: Record<string, unknown> = utils.global ?? globalThis;
   const ReadableStream = globalObject["ReadableStream"] as
@@ -127,38 +192,36 @@ const factory = (env: Record<string, unknown>) => {
     | (new () => AnyTextEncoder)
     | undefined;
 
-  env = utils.merge.call(
-    {
-      skipUndefined: true,
-    },
-    {
-      Request: globalObject["Request"],
-      Response: globalObject["Response"],
-    },
-    env
-  );
-
-  const {
-    fetch: envFetch,
-    Request,
-    Response,
-  } = env as {
-    fetch?: FetchFn;
-    Request?: AnyConstructor;
-    Response?: AnyConstructor;
-  };
-  const _globalFetch = (globalThis as unknown as Record<string, unknown>)[
-    "fetch"
-  ];
-  const isFetchSupported = envFetch
-    ? isFunction(envFetch)
-    : isFunction(_globalFetch);
+  // `undefined` falls back to the global constructor; `null` disables it.
+  const Request = (env.Request === undefined ? globalObject["Request"] : env.Request) as AnyConstructor | undefined;
+  const Response = (env.Response === undefined ? globalObject["Response"] : env.Response) as AnyConstructor | undefined;
   const isRequestSupported = isFunction(Request);
   const isResponseSupported = isFunction(Response);
 
-  if (!isFetchSupported) {
-    return false;
-  }
+  // Only members this runtime's Request exposes, so an engine that rejects members it doesn't
+  // implement (Cloudflare Workers) is never sent one.
+  const requestInitDefaults = Object.entries(REQUEST_INIT_DEFAULTS).filter(([ key ]) =>
+    isRequestSupported && utils.hasOwnInPrototypeChain((Request as AnyConstructor).prototype, key));
+
+  // Null prototype: WebIDL reads every RequestInit member with Get, which walks the prototype
+  // chain, so a plain object literal would let a polluted Object.prototype.redirect, .integrity,
+  // .mode or undici .dispatcher apply to every request. Every own enumerable key of fetchOptions
+  // is copied, so runtime extensions (Next.js `next`, Workers `cf`, Bun `tls`) still pass through;
+  // inherited keys never do. The caller sets signal, method, headers, body, duplex, credentials.
+  const initFromFetchOptions = (fetchOptions: unknown, envFetch: FetchFn | undefined): Record<string, unknown> => {
+    const init: Record<string, unknown> = Object.create(null);
+    for (const [ key, value ] of requestInitDefaults) init[key] = value;
+    // Node's global fetch reads `dispatcher` the same way; pin it to undici's own global one.
+    if (!envFetch && utils.hasOwnProp(globalThis, UNDICI_GLOBAL_DISPATCHER)) {
+      init["dispatcher"] = (globalThis as Record<PropertyKey, unknown>)[UNDICI_GLOBAL_DISPATCHER];
+    }
+    if (utils.isObject(fetchOptions)) {
+      for (const key of Object.keys(fetchOptions)) {
+        if (!utils.hasOwnProp(FAXIOS_INIT_KEYS, key)) init[key] = (fetchOptions as Record<string, unknown>)[key];
+      }
+    }
+    return init;
+  };
 
   const isReadableStreamSupported = isFunction(ReadableStream);
 
@@ -179,7 +242,7 @@ const factory = (env: Record<string, unknown>) => {
   // `fetch(request, init)`. undici (Node 26.11+) starts reading an async iterable in both,
   // so the first chunk goes to the discarded copy. One web stream is read only once.
   // Web stream bodies must yield bytes, so string chunks (e.g. `Readable.from(["a"])`) are encoded.
-  const from = (ReadableStream as { from?: (source: unknown) => unknown; } | undefined)?.from;
+  const from = (ReadableStream as undefined | { from?: (source: unknown) => unknown; })?.from;
   const streamFrom = typeof from === "function" ? from.bind(ReadableStream) : undefined;
   async function* toByteChunks(source: AsyncIterable<unknown>) {
     for await (const chunk of source) yield typeof chunk === "string" ? await encodeText(chunk) : chunk;
@@ -214,6 +277,13 @@ const factory = (env: Record<string, unknown>) => {
       return duplexAccessed && !hasContentType;
     });
 
+  // Outside browsers a FormData body under maxBodyLength is streamed and counted as fetch reads it;
+  // browsers can't send a stream body (see buildUploadStream).
+  const countsFormDataWhileSent = !isBrowserRuntime && supportsRequestStream;
+  // Bodies counted as fetch reads them when maxBodyLength is set.
+  const isCountedWhileSent = (body: unknown): boolean =>
+    utils.isReadableStream!(body) || utils.isStream(body) || (countsFormDataWhileSent && utils.isSpecCompliantForm(body));
+
   const supportsResponseStream =
     isResponseSupported &&
     isReadableStreamSupported &&
@@ -230,26 +300,22 @@ const factory = (env: Record<string, unknown>) => {
     stream: supportsResponseStream && ((res: AnyResponse) => res.body),
   };
 
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  isFetchSupported &&
-    (() => {
-      [ "text", "arrayBuffer", "blob", "formData", "stream" ].forEach(type => {
-        !resolvers[type] &&
-          (resolvers[type] = (res: AnyResponse, config?: unknown) => {
-            const method = (res as Record<string, unknown>)[type];
-
-            if (method) {
-              return (method as (this: AnyResponse) => unknown).call(res);
-            }
-
-            throw new FaxiosError(
-              `Response type '${type}' is not supported`,
-              FaxiosError.ERR_NOT_SUPPORT,
-              config as InternalFaxiosRequestConfig
-            );
-          });
+  [ "text", "arrayBuffer", "blob", "formData", "stream" ].forEach(type => {
+    !resolvers[type] &&
+      (resolvers[type] = (res: AnyResponse, config?: unknown) => {
+        const method = (res as Record<string, unknown>)[type];
+
+        if (method) {
+          return (method as (this: AnyResponse) => unknown).call(res);
+        }
+
+        throw new FaxiosError(
+          `Response type '${type}' is not supported`,
+          FaxiosError.ERR_NOT_SUPPORT,
+          config as InternalFaxiosRequestConfig
+        );
       });
-    })();
+  });
 
   const getBodyLength = async (body: unknown): Promise<number | undefined> => {
     if (body == null) {
@@ -260,16 +326,8 @@ const factory = (env: Record<string, unknown>) => {
       return (body as { size: number; }).size;
     }
 
-    if (utils.isSpecCompliantForm(body)) {
-      const _request = new (Request as AnyConstructor)(platform.origin, {
-        method: "POST",
-        body,
-      }) as AnyRequest;
-      return (await _request.arrayBuffer()).byteLength;
-    }
-
     if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {
-      return (body as ArrayBufferView | ArrayBuffer).byteLength;
+      return (body as ArrayBuffer | ArrayBufferView).byteLength;
     }
 
     if (utils.isURLSearchParams(body)) {
@@ -282,6 +340,23 @@ const factory = (env: Record<string, unknown>) => {
     return undefined;
   };
 
+  // The bytes of a FormData body's field values and files, from their sizes, without reading the
+  // body. A lower bound: the multipart body adds boundaries and part headers. Undefined for any
+  // other body.
+  const getFormDataFieldsLength = async (body: unknown): Promise<number | undefined> => {
+    if (!utils.isSpecCompliantForm(body)) {
+      return undefined;
+    }
+    let length = 0;
+    for (const [ , value ] of body as Iterable<[string, unknown]>) {
+      // A FormData value is a string or a File.
+      const size = utils.isString(value) ? undefined : utils.getSafeProp(value, "size");
+      // eslint-disable-next-line no-await-in-loop
+      length += typeof size === "number" ? size : (await encodeText(String(value))).byteLength;
+    }
+    return length;
+  };
+
   const resolveBodyLength = async (
     headers: FaxiosRequestHeaders,
     body: unknown
@@ -291,7 +366,7 @@ const factory = (env: Record<string, unknown>) => {
     return length == null ? getBodyLength(body) : length;
   };
 
-  const normalizeCredentials = (wc: string | boolean): string => {
+  const normalizeCredentials = (wc: boolean | string): string => {
     if (utils.isString(wc)) return wc as string;
     return wc ? "include" : "omit";
   };
@@ -303,7 +378,7 @@ const factory = (env: Record<string, unknown>) => {
     headers: FaxiosRequestHeaders,
     own: (key: string) => unknown
   ): string => {
-    let auth: { username: unknown; password: unknown; } | undefined;
+    let auth: undefined | { password: unknown; username: unknown; };
     const configAuth = own("auth");
     if (configAuth) {
       auth = {
@@ -372,10 +447,13 @@ const factory = (env: Record<string, unknown>) => {
     }
     // Enforce maxBodyLength against known-size bodies before dispatch using
     // the body's actual size — never a caller-declared Content-Length.
+    // A FormData body isn't measured, since that buffers it whole: its values alone over the limit
+    // reject it here, and where it's streamed the byte counter covers the multipart framing too.
     if (hasMaxBodyLength && method !== "get" && method !== "head") {
       const outboundLength = await getBodyLength(data);
-      if (typeof outboundLength === "number" && isFinite(outboundLength)) {
-        if (outboundLength > maxBodyLength) {
+      const checkedLength = outboundLength ?? await getFormDataFieldsLength(data);
+      if (typeof checkedLength === "number" && isFinite(checkedLength)) {
+        if (checkedLength > maxBodyLength) {
           throw new FaxiosError(
             "Request body larger than maxBodyLength limit",
             FaxiosError.ERR_BAD_REQUEST,
@@ -398,7 +476,7 @@ const factory = (env: Record<string, unknown>) => {
     onUploadProgress: unknown,
     _trackStream: (stream: unknown, onProgress?: (bytes: number) => void, flush?: () => void) => unknown
   ): unknown => {
-    let contentTypeHeader: string | null;
+    let contentTypeHeader: null | string;
     if (
       utils.isFormData(data) &&
       (contentTypeHeader = _request.headers.get("content-type"))
@@ -437,6 +515,10 @@ const factory = (env: Record<string, unknown>) => {
     request: unknown,
     pendingBodyErrorRef: PendingBodyErrorRef
   ): Promise<{ data: unknown; requestContentLength: number | undefined; }> => {
+    // Browsers can't be given a stream body for upload progress: Chromium sends one only over
+    // HTTP/2 or later and WebKit not at all, so the upload would fail. onUploadProgress isn't
+    // called there (#209).
+    const uploadProgress = isBrowserRuntime ? undefined : onUploadProgress;
     const _makeBodyLengthError = () =>
       new FaxiosError(
         "Request body larger than maxBodyLength limit",
@@ -460,14 +542,21 @@ const factory = (env: Record<string, unknown>) => {
           }
           onProgress && onProgress(loadedBytes);
         },
-        flush
+        (err?: unknown) => {
+          // A chunk trackStream rejected (not bytes) surfaces as the coded error, not ERR_NETWORK.
+          if (err instanceof FaxiosError && !pendingBodyErrorRef.value) {
+            err.config = config;
+            pendingBodyErrorRef.value = err;
+          }
+          flush && flush();
+        }
       );
 
     if (
       supportsRequestStream &&
       method !== "get" &&
       method !== "head" &&
-      (onUploadProgress || mustEnforceStreamBody)
+      (uploadProgress || mustEnforceStreamBody)
     ) {
       requestContentLength =
         requestContentLength == null
@@ -482,7 +571,7 @@ const factory = (env: Record<string, unknown>) => {
           body: data,
           duplex: "half",
         }) as AnyRequest;
-        data = applyUploadProgress(_request, data, headers, requestContentLength, onUploadProgress, _trackStream);
+        data = applyUploadProgress(_request, data, headers, requestContentLength, uploadProgress, _trackStream);
       }
     }
     else if (
@@ -520,11 +609,11 @@ const factory = (env: Record<string, unknown>) => {
     hasMaxContentLength: boolean,
     maxContentLength: number,
     isStreamResponse: boolean,
-    unsubscribe: (() => void) | false | undefined,
+    release: (err?: unknown) => void,
     config: InternalFaxiosRequestConfig,
     request: unknown
   ): AnyResponse => {
-    const needsWrapping = onDownloadProgress || hasMaxContentLength || (isStreamResponse && unsubscribe);
+    const needsWrapping = !!onDownloadProgress || hasMaxContentLength || isStreamResponse;
     if (!supportsResponseStream || !response.body || !needsWrapping) {
       return response;
     }
@@ -534,9 +623,15 @@ const factory = (env: Record<string, unknown>) => {
       options[prop] = response[prop];
     });
 
-    const responseContentLength = utils.toFiniteNumber(
-      (responseHeaders.getContentLength as () => unknown)()
-    );
+    // Content-Length is the encoded size; the stream yields decoded bytes, so
+    // the total is unknown when the body is content-encoded.
+    const contentEncoding = String(responseHeaders.get("content-encoding") ?? "").trim()
+      .toLowerCase();
+    const responseContentLength = contentEncoding && contentEncoding !== "identity"
+      ? undefined
+      : utils.toFiniteNumber(
+        (responseHeaders.getContentLength as () => unknown)()
+      );
 
     const [ onProgress, flush ] = onDownloadProgress
       ? progressEventDecorator(
@@ -571,23 +666,24 @@ const factory = (env: Record<string, unknown>) => {
         response.body,
         DEFAULT_CHUNK_SIZE,
         onChunkProgress,
-        () => {
+        (err?: unknown) => {
           flush && flush();
-          unsubscribe && unsubscribe();
+          release(err);
         }
       ),
       options
     ) as AnyResponse;
   };
 
-  const unsubscribeOnComplete = (isStreamResponse: boolean, unsubscribe: (() => void) | undefined) => {
-    if (!isStreamResponse) unsubscribe?.();
+  // A stream body releases the request when it ends; a response without a body has nothing to wait for.
+  const unsubscribeOnComplete = (isStreamResponse: boolean, response: AnyResponse, unsubscribe: () => void) => {
+    if (!isStreamResponse || response.body == null) unsubscribe();
   };
 
   return async (config: InternalFaxiosRequestConfig) => {
     const _resolved = prepareRequest(config) as InternalFaxiosRequestConfig & {
       fetchOptions?: Record<string, unknown>;
-      withCredentials?: string | boolean;
+      withCredentials?: boolean | string;
     };
     let {
       url,
@@ -604,7 +700,7 @@ const factory = (env: Record<string, unknown>) => {
       maxBodyLength,
     } = _resolved;
     let headers = _resolved.headers;
-    let withCredentials: string | boolean =
+    let withCredentials: boolean | string =
       _resolved.withCredentials ?? "same-origin";
 
     const hasMaxContentLength =
@@ -616,6 +712,7 @@ const factory = (env: Record<string, unknown>) => {
         ? (config as unknown as Record<string, unknown>)[key]
         : undefined;
 
+    const envFetch = ownEnv(config, "fetch") as FetchFn | undefined;
     const _fetch: FetchFn = (envFetch || (globalThis as unknown as Record<string, unknown>)["fetch"]) as FetchFn;
 
     if (timeout != null && !Number.isFinite(Number(timeout))) {
@@ -630,18 +727,23 @@ const factory = (env: Record<string, unknown>) => {
       responseType ? (responseType + "").toLowerCase() : "text"
     ) as typeof responseType;
 
+    // Owns the request's cleanup: aborting it on a failure aborts fetch, which releases the
+    // connection and any body still being sent or received.
+    const requestController = new AbortController();
     const composedSignal = composeSignals(
-      [ signal ],
+      [ signal, requestController.signal ],
       timeout,
       timeoutErrorMessage
-    ) as ComposedSignal | undefined;
+    ) as ComposedSignal;
 
-    const unsubscribe = composedSignal?.unsubscribe?.bind(composedSignal);
+    const unsubscribe = composedSignal.unsubscribe!.bind(composedSignal);
 
-    let request: Request | null = null;
+    let request: null | Request = null;
     const pendingBodyErrorRef: PendingBodyErrorRef = { value: null };
 
     try {
+      rejectUsedStreamBody(data, config);
+
       url = applyAuthToRequest(url!, headers, own);
 
       const preflightContentLength = await checkPreflightLimits(
@@ -658,8 +760,7 @@ const factory = (env: Record<string, unknown>) => {
 
       // A streamed body under maxBodyLength must be counted as fetch consumes
       // it; its size is never trusted from a caller-declared Content-Length.
-      const isStreamLike = utils.isReadableStream!(data) || utils.isStream(data);
-      const mustEnforceStreamBody = hasMaxBodyLength && isStreamLike;
+      const mustEnforceStreamBody = hasMaxBodyLength && isCountedWhileSent(data);
 
       ({ data } = await buildUploadStream(
         data,
@@ -696,25 +797,20 @@ const factory = (env: Record<string, unknown>) => {
       // Case-insensitive check: toByteStringHeaderObject may normalize to lowercase.
       data = toWebStream(await encodeBodyIfNeeded(data, serializedHeaders, encodeText));
 
-      const resolvedOptions = {
-        ...fetchOptions,
-        signal: composedSignal,
-        method: (method as string).toUpperCase(),
-        headers: serializedHeaders,
-        body: data,
-        duplex: "half",
-        credentials: isCredentialsSupported ? withCredentials : undefined,
-      };
+      const resolvedOptions = initFromFetchOptions(fetchOptions, envFetch);
+      resolvedOptions["signal"] = composedSignal;
+      resolvedOptions["method"] = (method as string).toUpperCase();
+      resolvedOptions["headers"] = serializedHeaders;
+      resolvedOptions["body"] = data;
+      resolvedOptions["duplex"] = "half";
+      resolvedOptions["credentials"] = isCredentialsSupported ? withCredentials : undefined;
 
       request = isRequestSupported
         ? new (Request as AnyConstructor)(url, resolvedOptions) as Request
         : null;
 
-      // Pass resolvedOptions (all own-properties) as the fetch init even when a
-      // Request object is supplied: undici re-reads RequestInit fields (method,
-      // headers, body, credentials) off Object.prototype when init is absent,
-      // so a polluted Object.prototype.method would override the Request's verb.
-      // An explicit own-property init neutralizes every such gadget.
+      // Pass resolvedOptions as the fetch init even when a Request object is supplied, so the
+      // same null-prototype members apply to both calls.
       let response = await (isRequestSupported
         ? _fetch(request, resolvedOptions)
         : _fetch(url, resolvedOptions));
@@ -727,6 +823,14 @@ const factory = (env: Record<string, unknown>) => {
         supportsResponseStream &&
         (responseType === "stream" || responseType === "response");
 
+      // A stream body outlives this call, so its end, error or cancel releases the request.
+      // A buffered body is released below, or by the catch on failure.
+      const releaseStreamBody = (bodyErr?: unknown): void => {
+        if (!isStreamResponse) return;
+        if (bodyErr !== undefined) requestController.abort(bodyErr);
+        unsubscribe();
+      };
+
       response = buildDownloadStream(
         response,
         responseHeaders,
@@ -734,7 +838,7 @@ const factory = (env: Record<string, unknown>) => {
         hasMaxContentLength,
         maxContentLength!,
         isStreamResponse,
-        unsubscribe,
+        releaseStreamBody,
         config,
         request
       );
@@ -755,12 +859,12 @@ const factory = (env: Record<string, unknown>) => {
         request
       );
 
-      unsubscribeOnComplete(isStreamResponse, unsubscribe);
+      unsubscribeOnComplete(isStreamResponse, response, unsubscribe);
 
       return await new Promise((resolve, reject) => {
         settle(resolve, reject, {
           data: responseData,
-          headers: FaxiosHeaders.from(response.headers),
+          headers: responseHeaders,
           status: response.status,
           statusText: response.statusText,
           config,
@@ -769,42 +873,57 @@ const factory = (env: Record<string, unknown>) => {
       });
     }
     catch (err) {
-      unsubscribe && unsubscribe();
-      throw handleFetchCaughtError(err, composedSignal, pendingBodyErrorRef, config, request);
+      let error: unknown = err;
+      try {
+        handleFetchCaughtError(err, composedSignal, pendingBodyErrorRef, config, request);
+      }
+      catch (classified) {
+        error = classified;
+      }
+      // Classify first: the abort below sets the composed signal's reason.
+      requestController.abort(error);
+      unsubscribe();
+      throw error;
     }
   };
 };
 
-const seedCache = new Map<unknown, unknown>();
+// One adapter per Request/Response pair. Weak keys let a per-request `env.Request` or
+// `env.Response` be collected. `undefined` (use the global) and any non-function (disabled)
+// get stand-in keys.
+const GLOBAL_CTOR = {};
+const NO_CTOR = {};
+const adapters = new WeakMap<object, WeakMap<object, FetchAdapter>>();
 
-export const getFetch = (config?: { env?: Record<string, unknown>; }) => {
-  const env: Record<string, unknown> = (config && config.env) || {};
-  const { fetch, Request, Response } = env as {
-    fetch?: unknown;
-    Request?: unknown;
-    Response?: unknown;
-  };
-  const seeds: Array<unknown> = [ Request, Response, fetch ];
-
-  const len = seeds.length;
-  let i = len;
-  let seed: unknown;
-  let target: unknown;
-  let map: Map<unknown, unknown> = seedCache;
+const ctorKey = (ctor: unknown): object => {
+  if (ctor === undefined) return GLOBAL_CTOR;
+  return isFunction(ctor) ? (ctor as object) : NO_CTOR;
+};
 
-  while (i--) {
-    seed = seeds[i];
-    target = map.get(seed);
+// `false` tells dispatchRequest that this runtime has no fetch.
+// eslint-disable-next-line sonarjs/function-return-type
+export const getFetch = (config?: { env?: Record<string, unknown>; }): false | FetchAdapter => {
+  const fetch = ownEnv(config, "fetch");
+  if (!isFunction(fetch || (globalThis as unknown as Record<string, unknown>)["fetch"])) {
+    return false;
+  }
 
-    if (target === undefined) {
-      target = i ? new Map<unknown, unknown>() : factory(env);
-      map.set(seed, target);
-    }
+  const Request = ownEnv(config, "Request");
+  const Response = ownEnv(config, "Response");
+  const requestKey = ctorKey(Request);
+  const responseKey = ctorKey(Response);
 
-    map = target as Map<unknown, unknown>;
+  let byResponse = adapters.get(requestKey);
+  if (!byResponse) {
+    byResponse = new WeakMap();
+    adapters.set(requestKey, byResponse);
   }
-
-  return target;
+  let adapter = byResponse.get(responseKey);
+  if (!adapter) {
+    adapter = factory({ Request, Response });
+    byResponse.set(responseKey, adapter);
+  }
+  return adapter;
 };
 
 getFetch();