@gcmdev/faxios 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import type { CreateFaxiosDefaults } from "./lib/types.js";
 export { default as Faxios } from "./lib/core/Faxios.js";
 export { default as FaxiosError, isSchemaValidationError } from "./lib/core/FaxiosError.js";
 export type { SchemaValidationError } from "./lib/core/FaxiosError.js";
-export { default as CanceledError, default as Cancel } from "./lib/cancel/CanceledError.js";
+export { default as Cancel, default as CanceledError } from "./lib/cancel/CanceledError.js";
 export { default as isCancel } from "./lib/cancel/isCancel.js";
 export { default as isFaxiosError } from "./lib/helpers/isFaxiosError.js";
 export { default as toFormData } from "./lib/helpers/toFormData.js";
@@ -15,8 +15,8 @@ export { VERSION } from "./lib/env/data.js";
 export type { FaxiosInstance, FaxiosStatic } from "./lib/faxios.js";
 export type { StandardSchemaV1 } from "./lib/types/standard-schema.js";
 export type { BasePerCallConfig, DefineConfig, DefinedEndpoint, FaxiosLike, PerCallConfig } from "./lib/core/define.js";
-export type { RouteConfig, RouteMethodConfig, RouteBuilder } from "./lib/core/route.js";
-export type { FaxiosRequestConfig, InternalFaxiosRequestConfig, FaxiosResponse, FaxiosRequestHeaders, FaxiosResponseHeadersLike, FaxiosHeaderValue, Method, ResponseType, GenericHTMLFormElement, RawFaxiosRequestConfig, FaxiosPromise, CreateFaxiosDefaults, FaxiosConfigHeaders, RawFaxiosRequestHeaders, HeadersDefaults, FaxiosContext, FaxiosNext, FaxiosMiddleware, FaxiosPlugin } from "./lib/types.js";
+export type { RouteBuilder, RouteConfig, RouteMethodConfig } from "./lib/core/route.js";
+export type { CreateFaxiosDefaults, FaxiosConfigHeaders, FaxiosContext, FaxiosHeaderValue, FaxiosMiddleware, FaxiosNext, FaxiosPlugin, FaxiosPromise, FaxiosRequestConfig, FaxiosRequestHeaders, FaxiosResponse, FaxiosResponseHeadersLike, GenericHTMLFormElement, HeadersDefaults, InternalFaxiosRequestConfig, Method, RawFaxiosRequestConfig, RawFaxiosRequestHeaders, ResponseType } from "./lib/types.js";
 export declare const all: FaxiosStatic["all"];
 export declare const formToJSON: FaxiosStatic["formToJSON"];
 export declare const create: (instanceConfig?: CreateFaxiosDefaults) => FaxiosInstance;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,wBAAwB;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,wBAAwB;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB;AAM3D,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,6BAA6B;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,uBAAuB,EAAE,kCAAkC;AAC5F,YAAY,EAAE,qBAAqB,EAAE,kCAAkC;AACvE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,OAAO,IAAI,MAAM,EAAE,sCAAsC;AAC5F,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,iCAAiC;AAC/D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,uCAAuC;AAC1E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,oCAAoC;AACpE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,oCAAoC;AACvE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,wCAAwC;AAC5E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,kCAAkC;AACnE,OAAO,EAAE,OAAO,EAAE,0BAA0B;AAE5C,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,wBAAwB;AACpE,YAAY,EAAE,gBAAgB,EAAE,uCAAuC;AACvE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,aAAa,EAAE,6BAA6B;AACxH,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,YAAY,EAAE,4BAA4B;AAExF,YAAY,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,cAAc,EACd,oBAAoB,EACpB,yBAAyB,EACzB,iBAAiB,EACjB,MAAM,EACN,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,eAAe,EACf,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,YAAY,EACb,uBAAuB;AAKxB,eAAO,MAAM,GAAG,EAAE,YAAY,CAAC,KAAK,CAAc,CAAC;AACnD,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,YAAY,CAAqB,CAAC;AACxE,eAAO,MAAM,MAAM,EAAE,CAAC,cAAc,CAAC,EAAE,oBAAoB,KAAK,cAA8B,CAAC;AAE/F,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,wBAAwB;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,wBAAwB;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB;AAM3D,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,6BAA6B;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,uBAAuB,EAAE,kCAAkC;AAC5F,YAAY,EAAE,qBAAqB,EAAE,kCAAkC;AACvE,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,OAAO,IAAI,aAAa,EAAE,sCAAsC;AAC5F,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,iCAAiC;AAC/D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,uCAAuC;AAC1E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,oCAAoC;AACpE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,oCAAoC;AACvE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,wCAAwC;AAC5E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,kCAAkC;AACnE,OAAO,EAAE,OAAO,EAAE,0BAA0B;AAE5C,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,wBAAwB;AACpE,YAAY,EAAE,gBAAgB,EAAE,uCAAuC;AACvE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,aAAa,EAAE,6BAA6B;AACxH,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,4BAA4B;AAExF,YAAY,EACV,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,eAAe,EACf,2BAA2B,EAC3B,MAAM,EACN,sBAAsB,EACtB,uBAAuB,EACvB,YAAY,EACb,uBAAuB;AAKxB,eAAO,MAAM,GAAG,EAAE,YAAY,CAAC,KAAK,CAAc,CAAC;AACnD,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,YAAY,CAAqB,CAAC;AACxE,eAAO,MAAM,MAAM,EAAE,CAAC,cAAc,CAAC,EAAE,oBAAoB,KAAK,cAA8B,CAAC;AAE/F,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,CAAC"}

package/dist/index.js

@@ -7,7 +7,7 @@ import faxios from "./lib/faxios.js";
 // runtime instance forced TS to emit the broken inline `import("./x.ts")` form.
 export { default as Faxios } from "./lib/core/Faxios.js";
 export { default as FaxiosError, isSchemaValidationError } from "./lib/core/FaxiosError.js";
-export { default as CanceledError, default as Cancel } from "./lib/cancel/CanceledError.js";
+export { default as Cancel, default as CanceledError } from "./lib/cancel/CanceledError.js";
 export { default as isCancel } from "./lib/cancel/isCancel.js";
 export { default as isFaxiosError } from "./lib/helpers/isFaxiosError.js";
 export { default as toFormData } from "./lib/helpers/toFormData.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,oDAAoD;AACpD,OAAO,MAAM,wBAAwB;AAIrC,oEAAoE;AACpE,wEAAwE;AACxE,0EAA0E;AAC1E,gFAAgF;AAChF,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,6BAA6B;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,uBAAuB,EAAE,kCAAkC;AAE5F,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,OAAO,IAAI,MAAM,EAAE,sCAAsC;AAC5F,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,iCAAiC;AAC/D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,uCAAuC;AAC1E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,oCAAoC;AACpE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,oCAAoC;AACvE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,wCAAwC;AAC5E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,kCAAkC;AACnE,OAAO,EAAE,OAAO,EAAE,0BAA0B;AA6B5C,gFAAgF;AAChF,+EAA+E;AAC/E,yFAAyF;AACzF,MAAM,CAAC,MAAM,GAAG,GAAwB,MAAM,CAAC,GAAG,CAAC;AACnD,MAAM,CAAC,MAAM,UAAU,GAA+B,MAAM,CAAC,UAAU,CAAC;AACxE,MAAM,CAAC,MAAM,MAAM,GAA8D,MAAM,CAAC,MAAM,CAAC;AAE/F,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,oDAAoD;AACpD,OAAO,MAAM,wBAAwB;AAIrC,oEAAoE;AACpE,wEAAwE;AACxE,0EAA0E;AAC1E,gFAAgF;AAChF,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,6BAA6B;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,uBAAuB,EAAE,kCAAkC;AAE5F,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,OAAO,IAAI,aAAa,EAAE,sCAAsC;AAC5F,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,iCAAiC;AAC/D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,uCAAuC;AAC1E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,oCAAoC;AACpE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,oCAAoC;AACvE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,wCAAwC;AAC5E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,kCAAkC;AACnE,OAAO,EAAE,OAAO,EAAE,0BAA0B;AA6B5C,gFAAgF;AAChF,+EAA+E;AAC/E,yFAAyF;AACzF,MAAM,CAAC,MAAM,GAAG,GAAwB,MAAM,CAAC,GAAG,CAAC;AACnD,MAAM,CAAC,MAAM,UAAU,GAA+B,MAAM,CAAC,UAAU,CAAC;AACxE,MAAM,CAAC,MAAM,MAAM,GAA8D,MAAM,CAAC,MAAM,CAAC;AAE/F,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,CAAC"}

package/dist/lib/adapters/fetch-helpers.d.ts

@@ -1,6 +1,6 @@
 import FaxiosError from "../core/FaxiosError.js";
 import type FaxiosHeaders from "../core/FaxiosHeaders.js";
-import type { InternalFaxiosRequestConfig, FaxiosRequestHeaders } from "../types.js";
+import type { FaxiosRequestHeaders, InternalFaxiosRequestConfig } from "../types.js";
 export type ComposedSignal = AbortSignal & {
     unsubscribe?: () => void;
 };

package/dist/lib/adapters/fetch-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/adapters/fetch-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,+BAA+B;AACjD,OAAO,KAAK,aAAa,iCAAiC;AAC1D,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EAErB,oBAAoB;AAGrB,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;CAAE,CAAC;AACzE,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,CAAC,WAAW,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;KAAE,CAAC,GAAG,IAAI,CAAC;CAAE,CAAC;AAM5F,eAAO,MAAM,0BAA0B,GACrC,iBAAiB,aAAa,EAC9B,qBAAqB,OAAO,EAC5B,kBAAkB,MAAM,EACxB,QAAQ,2BAA2B,EACnC,SAAS,OAAO,KACf,IAaF,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAChC,cAAc,OAAO,EACrB,qBAAqB,OAAO,EAC5B,kBAAkB,MAAM,EACxB,kBAAkB,OAAO,EACzB,wBAAwB,OAAO,EAC/B,QAAQ,2BAA2B,EACnC,SAAS,OAAO,KACf,IAwBF,CAAC;AAGF,eAAO,MAAM,sBAAsB,GACjC,KAAK,OAAO,EACZ,gBAAgB,cAAc,GAAG,SAAS,EAC1C,qBAAqB,mBAAmB,EACxC,QAAQ,2BAA2B,EACnC,SAAS,OAAO,KACf,KAyDF,CAAC;AAGF,eAAO,MAAM,wBAAwB,GACnC,MAAM,OAAO,EACb,SAAS,oBAAoB,KAC5B,IAWF,CAAC;AAGF,eAAO,MAAM,kBAAkB,GAC7B,MAAM,OAAO,EACb,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,KACxD,OAAO,CAAC,OAAO,CAAC,GAAG,OAIrB,CAAC"}
+{"version":3,"file":"fetch-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/adapters/fetch-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,+BAA+B;AACjD,OAAO,KAAK,aAAa,iCAAiC;AAC1D,OAAO,KAAK,EACV,oBAAoB,EAEpB,2BAA2B,EAC5B,oBAAoB;AAGrB,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;CAAE,CAAC;AACzE,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,CAAC,WAAW,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;KAAE,CAAC,GAAG,IAAI,CAAC;CAAE,CAAC;AAM5F,eAAO,MAAM,0BAA0B,GACrC,iBAAiB,aAAa,EAC9B,qBAAqB,OAAO,EAC5B,kBAAkB,MAAM,EACxB,QAAQ,2BAA2B,EACnC,SAAS,OAAO,KACf,IAaF,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAChC,cAAc,OAAO,EACrB,qBAAqB,OAAO,EAC5B,kBAAkB,MAAM,EACxB,kBAAkB,OAAO,EACzB,wBAAwB,OAAO,EAC/B,QAAQ,2BAA2B,EACnC,SAAS,OAAO,KACf,IAwBF,CAAC;AAGF,eAAO,MAAM,sBAAsB,GACjC,KAAK,OAAO,EACZ,gBAAgB,cAAc,GAAG,SAAS,EAC1C,qBAAqB,mBAAmB,EACxC,QAAQ,2BAA2B,EACnC,SAAS,OAAO,KACf,KAyDF,CAAC;AAGF,eAAO,MAAM,wBAAwB,GACnC,MAAM,OAAO,EACb,SAAS,oBAAoB,KAC5B,IAWF,CAAC;AAGF,eAAO,MAAM,kBAAkB,GAC7B,MAAM,OAAO,EACb,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,KACxD,OAAO,CAAC,OAAO,CAAC,GAAG,OAIrB,CAAC"}

package/dist/lib/adapters/fetch.d.ts

@@ -1,4 +1,7 @@
+import type { InternalFaxiosRequestConfig } from "../types.js";
+type FetchAdapter = (config: InternalFaxiosRequestConfig) => Promise<unknown>;
 export declare const getFetch: (config?: {
     env?: Record<string, unknown>;
-}) => unknown;
+}) => false | FetchAdapter;
+export {};
 //# sourceMappingURL=fetch.d.ts.map

package/dist/lib/adapters/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/lib/adapters/fetch.ts"],"names":[],"mappings":"AA2wBA,eAAO,MAAM,QAAQ,GAAI,SAAS;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAAE,YA4BnE,CAAC"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/lib/adapters/fetch.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAEV,2BAA2B,EAC5B,oBAAoB;AA6JrB,KAAK,YAAY,GAAG,CAAC,MAAM,EAAE,2BAA2B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAytB9E,eAAO,MAAM,QAAQ,GAAI,SAAS;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAAE,KAAG,KAAK,GAAG,YAsB9E,CAAC"}

package/dist/lib/adapters/fetch.js

@@ -5,20 +5,37 @@ import { settle } from "../core/settle.js";
 import { VERSION } from "../env/data.js";
 import composeSignals from "../helpers/composeSignals.js";
 import estimateDataURLDecodedBytes from "../helpers/estimateDataURLDecodedBytes.js";
-import { progressEventReducer, progressEventDecorator, asyncDecorator } from "../helpers/progressEventReducer.js";
+import { asyncDecorator, progressEventDecorator, progressEventReducer } from "../helpers/progressEventReducer.js";
 import { toByteStringHeaderObject } from "../helpers/sanitizeHeaderValue.js";
 import { trackStream } from "../helpers/trackStream.js";
 import platform from "../platform.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";
 // btoa is a global in Node 16+ and browsers; accessed via globalThis for no-DOM lib compat
 const _btoa = globalThis["btoa"];
 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();
+// 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, config) => {
+    const body = data;
+    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) => {
     if (setsUserAgent)
         headers.set("User-Agent", "faxios/" + VERSION, false);
@@ -61,28 +78,68 @@ const maybeWithAuthCredentials = (url) => {
     // Only `@` indicates credentials in the authority; `:` alone is a port separator.
     return urlToCheck.includes("@");
 };
-// eslint-disable-next-line sonarjs/function-return-type
+// RequestInit members faxios sets itself; the same keys in `fetchOptions` are ignored.
+const FAXIOS_INIT_KEYS = {
+    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 = {
+    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");
+// Own reads only: a polluted Object.prototype.fetch must never become the transport.
+const readOwn = (obj, key) => typeof obj === "object" && obj !== null && utils.hasOwnProp(obj, key) ? Reflect.get(obj, key) : undefined;
+const ownEnv = (config, key) => 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) => {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     const globalObject = utils.global ?? globalThis;
     const ReadableStream = globalObject["ReadableStream"];
     const TextEncoder = globalObject["TextEncoder"];
-    env = utils.merge.call({
-        skipUndefined: true,
-    }, {
-        Request: globalObject["Request"],
-        Response: globalObject["Response"],
-    }, env);
-    const { fetch: envFetch, Request, Response, } = env;
-    const _globalFetch = globalThis["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);
+    const Response = (env.Response === undefined ? globalObject["Response"] : env.Response);
     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.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, envFetch) => {
+        const init = 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[UNDICI_GLOBAL_DISPATCHER];
+        }
+        if (utils.isObject(fetchOptions)) {
+            for (const key of Object.keys(fetchOptions)) {
+                if (!utils.hasOwnProp(FAXIOS_INIT_KEYS, key))
+                    init[key] = fetchOptions[key];
+            }
+        }
+        return init;
+    };
     const isReadableStreamSupported = isFunction(ReadableStream);
     const encodeText = typeof TextEncoder === "function"
         ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder())
@@ -119,26 +176,27 @@ const factory = (env) => {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             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) => utils.isReadableStream(body) || utils.isStream(body) || (countsFormDataWhileSent && utils.isSpecCompliantForm(body));
     const supportsResponseStream = isResponseSupported &&
         isReadableStreamSupported &&
         test(() => utils.isReadableStream(new Response("").body));
     const resolvers = {
         stream: supportsResponseStream && ((res) => res.body),
     };
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    isFetchSupported &&
-        (() => {
-            ["text", "arrayBuffer", "blob", "formData", "stream"].forEach(type => {
-                !resolvers[type] &&
-                    (resolvers[type] = (res, config) => {
-                        const method = res[type];
-                        if (method) {
-                            return method.call(res);
-                        }
-                        throw new FaxiosError(`Response type '${type}' is not supported`, FaxiosError.ERR_NOT_SUPPORT, config);
-                    });
+    ["text", "arrayBuffer", "blob", "formData", "stream"].forEach(type => {
+        !resolvers[type] &&
+            (resolvers[type] = (res, config) => {
+                const method = res[type];
+                if (method) {
+                    return method.call(res);
+                }
+                throw new FaxiosError(`Response type '${type}' is not supported`, FaxiosError.ERR_NOT_SUPPORT, config);
             });
-        })();
+    });
     const getBodyLength = async (body) => {
         if (body == null) {
             return 0;
@@ -146,13 +204,6 @@ const factory = (env) => {
         if (utils.isBlob(body)) {
             return body.size;
         }
-        if (utils.isSpecCompliantForm(body)) {
-            const _request = new Request(platform.origin, {
-                method: "POST",
-                body,
-            });
-            return (await _request.arrayBuffer()).byteLength;
-        }
         if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {
             return body.byteLength;
         }
@@ -164,6 +215,22 @@ const factory = (env) => {
         }
         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) => {
+        if (!utils.isSpecCompliantForm(body)) {
+            return undefined;
+        }
+        let length = 0;
+        for (const [, value] of body) {
+            // 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, body) => {
         const length = utils.toFiniteNumber(headers.getContentLength());
         return length == null ? getBodyLength(body) : length;
@@ -220,10 +287,13 @@ const factory = (env) => {
         }
         // 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, config, request);
                 }
                 return outboundLength;
@@ -248,6 +318,10 @@ const factory = (env) => {
     };
     // Set up request body streaming with upload progress and/or maxBodyLength enforcement.
     const buildUploadStream = async (data, url, method, headers, onUploadProgress, mustEnforceStreamBody, requestContentLength, hasMaxBodyLength, maxBodyLength, config, request, pendingBodyErrorRef) => {
+        // 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", FaxiosError.ERR_BAD_REQUEST, config, request);
         const _trackStream = (stream, onProgress, flush) => trackStream(stream, DEFAULT_CHUNK_SIZE, (loadedBytes) => {
             if (hasMaxBodyLength && loadedBytes > maxBodyLength) {
@@ -255,11 +329,18 @@ const factory = (env) => {
                 throw pendingBodyErrorRef.value;
             }
             onProgress && onProgress(loadedBytes);
-        }, flush);
+        }, (err) => {
+            // 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
                     ? await resolveBodyLength(headers, data)
@@ -272,7 +353,7 @@ const factory = (env) => {
                     body: data,
                     duplex: "half",
                 });
-                data = applyUploadProgress(_request, data, headers, requestContentLength, onUploadProgress, _trackStream);
+                data = applyUploadProgress(_request, data, headers, requestContentLength, uploadProgress, _trackStream);
             }
         }
         else if (mustEnforceStreamBody &&
@@ -292,8 +373,8 @@ const factory = (env) => {
         return { data, requestContentLength };
     };
     // Wrap the response body stream with download progress tracking and maxContentLength enforcement.
-    const buildDownloadStream = (response, responseHeaders, onDownloadProgress, hasMaxContentLength, maxContentLength, isStreamResponse, unsubscribe, config, request) => {
-        const needsWrapping = onDownloadProgress || hasMaxContentLength || (isStreamResponse && unsubscribe);
+    const buildDownloadStream = (response, responseHeaders, onDownloadProgress, hasMaxContentLength, maxContentLength, isStreamResponse, release, config, request) => {
+        const needsWrapping = !!onDownloadProgress || hasMaxContentLength || isStreamResponse;
         if (!supportsResponseStream || !response.body || !needsWrapping) {
             return response;
         }
@@ -301,7 +382,13 @@ const factory = (env) => {
         ["status", "statusText", "headers"].forEach(prop => {
             options[prop] = response[prop];
         });
-        const responseContentLength = utils.toFiniteNumber(responseHeaders.getContentLength());
+        // 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());
         const [onProgress, flush] = onDownloadProgress
             ? progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true))
             : [];
@@ -315,14 +402,15 @@ const factory = (env) => {
             }
             onProgress && onProgress(loadedBytes);
         };
-        return new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onChunkProgress, () => {
+        return new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onChunkProgress, (err) => {
             flush && flush();
-            unsubscribe && unsubscribe();
+            release(err);
         }), options);
     };
-    const unsubscribeOnComplete = (isStreamResponse, unsubscribe) => {
-        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, response, unsubscribe) => {
+        if (!isStreamResponse || response.body == null)
+            unsubscribe();
     };
     return async (config) => {
         const _resolved = prepareRequest(config);
@@ -334,22 +422,26 @@ const factory = (env) => {
         const own = (key) => utils.hasOwnProp(config, key)
             ? config[key]
             : undefined;
+        const envFetch = ownEnv(config, "fetch");
         const _fetch = (envFetch || globalThis["fetch"]);
         if (timeout != null && !Number.isFinite(Number(timeout))) {
             throw new FaxiosError("error trying to parse `config.timeout` to int", FaxiosError.ERR_BAD_OPTION_VALUE, config);
         }
         responseType = (responseType ? (responseType + "").toLowerCase() : "text");
-        const composedSignal = composeSignals([signal], timeout, timeoutErrorMessage);
-        const unsubscribe = composedSignal?.unsubscribe?.bind(composedSignal);
+        // 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, requestController.signal], timeout, timeoutErrorMessage);
+        const unsubscribe = composedSignal.unsubscribe.bind(composedSignal);
         let request = null;
         const pendingBodyErrorRef = { value: null };
         try {
+            rejectUsedStreamBody(data, config);
             url = applyAuthToRequest(url, headers, own);
             const preflightContentLength = await checkPreflightLimits(url, data, method, hasMaxContentLength, maxContentLength, hasMaxBodyLength, maxBodyLength, config, request);
             // 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, url, method, headers, onUploadProgress, mustEnforceStreamBody, preflightContentLength, hasMaxBodyLength, maxBodyLength, config, request, pendingBodyErrorRef));
             withCredentials = normalizeCredentials(withCredentials);
             // Cloudflare Workers throws when credentials are defined
@@ -364,23 +456,18 @@ const factory = (env) => {
             // Encoding as Uint8Array prevents the browser from injecting a content-type.
             // Case-insensitive check: toByteStringHeaderObject may normalize to lowercase.
             data = toWebStream(await encodeBodyIfNeeded(data, serializedHeaders, encodeText));
-            const resolvedOptions = {
-                ...fetchOptions,
-                signal: composedSignal,
-                method: method.toUpperCase(),
-                headers: serializedHeaders,
-                body: data,
-                duplex: "half",
-                credentials: isCredentialsSupported ? withCredentials : undefined,
-            };
+            const resolvedOptions = initFromFetchOptions(fetchOptions, envFetch);
+            resolvedOptions["signal"] = composedSignal;
+            resolvedOptions["method"] = method.toUpperCase();
+            resolvedOptions["headers"] = serializedHeaders;
+            resolvedOptions["body"] = data;
+            resolvedOptions["duplex"] = "half";
+            resolvedOptions["credentials"] = isCredentialsSupported ? withCredentials : undefined;
             request = isRequestSupported
                 ? new Request(url, resolvedOptions)
                 : 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));
@@ -388,17 +475,26 @@ const factory = (env) => {
             checkDeclaredContentLength(responseHeaders, hasMaxContentLength, maxContentLength, config, request);
             const isStreamResponse = supportsResponseStream &&
                 (responseType === "stream" || responseType === "response");
-            response = buildDownloadStream(response, responseHeaders, onDownloadProgress, hasMaxContentLength, maxContentLength, isStreamResponse, unsubscribe, config, request);
+            // 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) => {
+                if (!isStreamResponse)
+                    return;
+                if (bodyErr !== undefined)
+                    requestController.abort(bodyErr);
+                unsubscribe();
+            };
+            response = buildDownloadStream(response, responseHeaders, onDownloadProgress, hasMaxContentLength, maxContentLength, isStreamResponse, releaseStreamBody, config, request);
             responseType = responseType || "text";
             const resolverKey = utils.findKey(resolvers, responseType) || "text";
             const resolver = resolvers[resolverKey];
             const responseData = await (resolver && resolver(response, config));
             checkMaterializedSize(responseData, hasMaxContentLength, maxContentLength, isStreamResponse, supportsResponseStream, config, 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,
@@ -407,31 +503,53 @@ const factory = (env) => {
             });
         }
         catch (err) {
-            unsubscribe && unsubscribe();
-            throw handleFetchCaughtError(err, composedSignal, pendingBodyErrorRef, config, request);
+            let error = 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();
+// 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();
+const ctorKey = (ctor) => {
+    if (ctor === undefined)
+        return GLOBAL_CTOR;
+    return isFunction(ctor) ? ctor : NO_CTOR;
+};
+// `false` tells dispatchRequest that this runtime has no fetch.
+// eslint-disable-next-line sonarjs/function-return-type
 export const getFetch = (config) => {
-    const env = (config && config.env) || {};
-    const { fetch, Request, Response } = env;
-    const seeds = [Request, Response, fetch];
-    const len = seeds.length;
-    let i = len;
-    let seed;
-    let target;
-    let map = seedCache;
-    while (i--) {
-        seed = seeds[i];
-        target = map.get(seed);
-        if (target === undefined) {
-            target = i ? new Map() : factory(env);
-            map.set(seed, target);
-        }
-        map = target;
+    const fetch = ownEnv(config, "fetch");
+    if (!isFunction(fetch || globalThis["fetch"])) {
+        return false;
+    }
+    const Request = ownEnv(config, "Request");
+    const Response = ownEnv(config, "Response");
+    const requestKey = ctorKey(Request);
+    const responseKey = ctorKey(Response);
+    let byResponse = adapters.get(requestKey);
+    if (!byResponse) {
+        byResponse = new WeakMap();
+        adapters.set(requestKey, byResponse);
+    }
+    let adapter = byResponse.get(responseKey);
+    if (!adapter) {
+        adapter = factory({ Request, Response });
+        byResponse.set(responseKey, adapter);
     }
-    return target;
+    return adapter;
 };
 getFetch();
 //# sourceMappingURL=fetch.js.map