got 14.4.8 → 14.5.0

package/dist/source/as-promise/index.js

@@ -68,6 +68,7 @@ export default function asPromise(firstRequest) {
                         // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
                         // eslint-disable-next-line no-await-in-loop
                         response = await hook(response, async (updatedOptions) => {
+                            const preserveHooks = updatedOptions.preserveHooks ?? false;
                             options.merge(updatedOptions);
                             options.prefixUrl = '';
                             if (updatedOptions.url) {
@@ -75,7 +76,10 @@ export default function asPromise(firstRequest) {
                             }
                             // Remove any further hooks for that request, because we'll call them anyway.
                             // The loop continues. We don't want duplicates (asPromise recursion).
-                            options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                            // Unless preserveHooks is true, in which case we keep the remaining hooks.
+                            if (!preserveHooks) {
+                                options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                            }
                             throw new RetryError(request);
                         });
                         if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {

package/dist/source/core/index.d.ts

@@ -2,7 +2,7 @@ import { Duplex } from 'node:stream';
 import { type ClientRequest } from 'node:http';
 import type { Socket } from 'node:net';
 import { type Timings } from '@szmarczak/http-timer';
-import Options from './options.js';
+import Options, { type OptionsInit } from './options.js';
 import { type PlainResponse, type Response } from './response.js';
 import { RequestError } from './errors.js';
 type Error = NodeJS.ErrnoException;
@@ -71,7 +71,7 @@ When this event is emitted, you should reset the stream you were writing to and
 
 See `got.options.retry` for more information.
 */
- & ((name: 'retry', listener: (retryCount: number, error: RequestError) => void) => T);
+ & ((name: 'retry', listener: (retryCount: number, error: RequestError, createRetryStream: (options?: OptionsInit) => Request) => void) => T);
 export type RequestEvents<T> = {
     on: GotEventFunction<T>;
     once: GotEventFunction<T>;
@@ -99,7 +99,6 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     private _bodySize?;
     private _unproxyEvents;
     private _isFromCache?;
-    private _cannotHaveBody;
     private _triggerRead;
     private readonly _jobs;
     private _cancelTimeouts;

package/dist/source/core/index.js

@@ -1,6 +1,8 @@
 import process from 'node:process';
 import { Buffer } from 'node:buffer';
 import { Duplex } from 'node:stream';
+import { gunzip, inflate, brotliDecompress } from 'node:zlib';
+import { promisify } from 'node:util';
 import http, { ServerResponse } from 'node:http';
 import timer from '@szmarczak/http-timer';
 import CacheableRequest, { CacheError as CacheableCacheError, } from 'cacheable-request';
@@ -21,6 +23,8 @@ import isUnixSocketURL from './utils/is-unix-socket-url.js';
 import { RequestError, ReadError, MaxRedirectsError, HTTPError, TimeoutError, UploadError, CacheError, AbortError, } from './errors.js';
 const supportsBrotli = is.string(process.versions.brotli);
 const methodsWithoutBody = new Set(['GET', 'HEAD']);
+// Methods that should auto-end streams when no body is provided
+const methodsWithoutBodyStream = new Set(['OPTIONS', 'DELETE', 'PATCH']);
 const cacheableStore = new WeakableMap();
 const redirectCodes = new Set([300, 301, 302, 303, 304, 307, 308]);
 const proxiedRequestEvents = [
@@ -51,7 +55,6 @@ export default class Request extends Duplex {
     _bodySize;
     _unproxyEvents;
     _isFromCache;
-    _cannotHaveBody;
     _triggerRead;
     _cancelTimeouts;
     _removeListeners;
@@ -71,7 +74,6 @@ export default class Request extends Duplex {
         this._uploadedSize = 0;
         this._stopReading = false;
         this._pipedServerResponses = new Set();
-        this._cannotHaveBody = false;
         this._unproxyEvents = noop;
         this._triggerRead = false;
         this._cancelTimeouts = noop;
@@ -221,19 +223,29 @@ export default class Request extends Duplex {
                         }
                     }
                     const retryOptions = options.retry;
-                    backoff = await retryOptions.calculateDelay({
+                    const computedValue = calculateRetryDelay({
                         attemptCount,
                         retryOptions,
                         error: typedError,
                         retryAfter,
-                        computedValue: calculateRetryDelay({
+                        computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
+                    });
+                    // When enforceRetryRules is true, respect the retry rules (limit, methods, statusCodes, errorCodes)
+                    // before calling the user's calculateDelay function. If computedValue is 0 (meaning retry is not allowed
+                    // based on these rules), skip calling calculateDelay entirely.
+                    // When false (default), always call calculateDelay, allowing it to override retry decisions.
+                    if (retryOptions.enforceRetryRules && computedValue === 0) {
+                        backoff = 0;
+                    }
+                    else {
+                        backoff = await retryOptions.calculateDelay({
                             attemptCount,
                             retryOptions,
                             error: typedError,
                             retryAfter,
-                            computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
-                        }),
-                    });
+                            computedValue,
+                        });
+                    }
                 }
                 catch (error_) {
                     void this._error(new RequestError(error_.message, error_, this));
@@ -382,7 +394,6 @@ export default class Request extends Duplex {
         const isJSON = !is.undefined(options.json);
         const isBody = !is.undefined(options.body);
         const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
-        this._cannotHaveBody = cannotHaveBody;
         if (isForm || isJSON || isBody) {
             if (cannotHaveBody) {
                 throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
@@ -449,10 +460,97 @@ export default class Request extends Duplex {
         const { options } = this;
         const { url } = options;
         this._nativeResponse = response;
-        if (options.decompress) {
+        const statusCode = response.statusCode;
+        const { method } = options;
+        // Skip decompression for responses that must not have bodies per RFC 9110:
+        // - HEAD responses (any status code)
+        // - 1xx (Informational): 100, 101, 102, 103, etc.
+        // - 204 (No Content)
+        // - 205 (Reset Content)
+        // - 304 (Not Modified)
+        const hasNoBody = method === 'HEAD'
+            || (statusCode >= 100 && statusCode < 200)
+            || statusCode === 204
+            || statusCode === 205
+            || statusCode === 304;
+        const nativeResponse = response;
+        if (options.decompress && !hasNoBody) {
             response = decompressResponse(response);
         }
-        const statusCode = response.statusCode;
+        // For revalidated cached responses (304 Not Modified), cacheable-request may return
+        // a ResponseLike object with the body stored in a .body property but not pushed into
+        // the stream. The stream is created and may be ended without data, and the 'end' event is
+        // never emitted, causing Got to hang waiting for it. Detect and fix this.
+        const nativeAsAny = nativeResponse;
+        if (nativeAsAny.body) {
+            // Mark the response as complete immediately (ResponseLike doesn't have req.res.complete)
+            nativeResponse.complete = true;
+            response.complete = true;
+            // Use setImmediate to check if this is a stuck revalidated response
+            setImmediate(() => {
+                // Check if the stream ended with no data (revalidated response)
+                if (nativeResponse.readableEnded && !nativeResponse.readableLength) {
+                    // The body is in nativeAsAny.body but was never pushed to the stream.
+                    // We need to push it to the native response so it flows through decompression if needed.
+                    try {
+                        // Push the body to the native stream
+                        nativeResponse.push(nativeAsAny.body);
+                        // eslint-disable-next-line unicorn/no-array-push-push
+                        nativeResponse.push(null);
+                        // Update download size with the cached body length
+                        let bodyLength = 0;
+                        if (Buffer.isBuffer(nativeAsAny.body)) {
+                            bodyLength = nativeAsAny.body.length;
+                        }
+                        else if (typeof nativeAsAny.body === 'string') {
+                            bodyLength = Buffer.byteLength(nativeAsAny.body);
+                        }
+                        this._downloadedSize += bodyLength;
+                    }
+                    catch {
+                        // If push fails (stream already ended), we need to decompress manually for compressed responses
+                        const encoding = nativeResponse.headers['content-encoding'];
+                        if (encoding && Buffer.isBuffer(nativeAsAny.body)) {
+                            // Decompress the body based on the encoding
+                            let decompressAsync;
+                            switch (encoding) {
+                                case 'gzip': {
+                                    decompressAsync = promisify(gunzip);
+                                    break;
+                                }
+                                case 'deflate': {
+                                    decompressAsync = promisify(inflate);
+                                    break;
+                                }
+                                case 'br': {
+                                    decompressAsync = promisify(brotliDecompress);
+                                    break;
+                                }
+                                default: {
+                                    break;
+                                }
+                            }
+                            if (decompressAsync) {
+                                // Decompress asynchronously and set rawBody
+                                void decompressAsync(nativeAsAny.body).then((decompressed) => {
+                                    response.rawBody = decompressed;
+                                    this._downloadedSize += nativeAsAny.body.length;
+                                    response.emit('end');
+                                }).catch(() => {
+                                    // Decompression failed, use compressed body as-is
+                                    response.rawBody = nativeAsAny.body;
+                                    response.emit('end');
+                                });
+                                return;
+                            }
+                        }
+                        // Not compressed or decompression not needed, set rawBody directly
+                        response.rawBody = nativeAsAny.body;
+                        response.emit('end');
+                    }
+                }
+            });
+        }
         const typedResponse = response;
         typedResponse.statusMessage = typedResponse.statusMessage ?? http.STATUS_CODES[statusCode];
         typedResponse.url = options.url.toString();
@@ -466,10 +564,6 @@ export default class Request extends Duplex {
         this._isFromCache = typedResponse.isFromCache;
         this._responseSize = Number(response.headers['content-length']) || undefined;
         this.response = typedResponse;
-        response.once('end', () => {
-            this._responseSize = this._downloadedSize;
-            this.emit('downloadProgress', this.downloadProgress);
-        });
         response.once('error', (error) => {
             this._aborted = true;
             // Force clean-up, because some packages don't do this.
@@ -485,7 +579,6 @@ export default class Request extends Duplex {
                 code: 'ECONNRESET',
             }, this));
         });
-        this.emit('downloadProgress', this.downloadProgress);
         const rawCookies = response.headers['set-cookie'];
         if (is.object(options.cookieJar) && rawCookies) {
             let promises = rawCookies.map(async (rawCookie) => options.cookieJar.setCookie(rawCookie, url.toString()));
@@ -524,6 +617,8 @@ export default class Request extends Duplex {
                     return;
                 }
                 this._request = undefined;
+                // Reset download progress for the new request
+                this._downloadedSize = 0;
                 const updatedOptions = new Options(undefined, undefined, this.options);
                 const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
                 const canRewrite = statusCode !== 307 && statusCode !== 308;
@@ -589,6 +684,14 @@ export default class Request extends Duplex {
             this._beforeError(new HTTPError(typedResponse));
             return;
         }
+        // Set up end listener AFTER redirect check to avoid emitting progress for redirect responses
+        const endStream = () => {
+            this._responseSize = this._downloadedSize;
+            this.emit('downloadProgress', this.downloadProgress);
+            this.push(null);
+        };
+        response.once('end', endStream);
+        this.emit('downloadProgress', this.downloadProgress);
         response.on('readable', () => {
             if (this._triggerRead) {
                 this._read();
@@ -600,9 +703,6 @@ export default class Request extends Duplex {
         this.on('pause', () => {
             response.pause();
         });
-        response.once('end', () => {
-            this.push(null);
-        });
         if (this._noPipe) {
             const success = await this._setRawBody();
             if (success) {
@@ -657,11 +757,19 @@ export default class Request extends Duplex {
         const { options } = this;
         const { timeout, url } = options;
         timer(request);
+        this._cancelTimeouts = timedOut(request, timeout, url);
         if (this.options.http2) {
             // Unset stream timeout, as the `timeout` option was used only for connection timeout.
-            request.setTimeout(0);
+            // We remove all 'timeout' listeners instead of calling setTimeout(0) because:
+            // 1. setTimeout(0) causes a memory leak (see https://github.com/sindresorhus/got/issues/690)
+            // 2. With HTTP/2 connection reuse, setTimeout(0) accumulates listeners on the socket
+            // 3. removeAllListeners('timeout') properly cleans up without the memory leak
+            request.removeAllListeners('timeout');
+            // For HTTP/2, wait for socket and remove timeout listeners from it
+            request.once('socket', (socket) => {
+                socket.removeAllListeners('timeout');
+            });
         }
-        this._cancelTimeouts = timedOut(request, timeout, url);
         const responseEventName = options.cache ? 'cacheableResponse' : 'response';
         request.once(responseEventName, (response) => {
             void this._onResponse(response);
@@ -697,7 +805,7 @@ export default class Request extends Duplex {
         if (is.nodeStream(body)) {
             body.pipe(currentRequest);
         }
-        else if (is.generator(body) || is.asyncGenerator(body)) {
+        else if (is.asyncIterable(body) || (is.iterable(body) && !is.string(body) && !isBuffer(body))) {
             (async () => {
                 try {
                     for await (const chunk of body) {
@@ -710,11 +818,16 @@ export default class Request extends Duplex {
                 }
             })();
         }
-        else if (!is.undefined(body)) {
-            this._writeRequest(body, undefined, () => { });
-            currentRequest.end();
+        else if (is.undefined(body)) {
+            // No body to send, end the request
+            const cannotHaveBody = methodsWithoutBody.has(this.options.method) && !(this.options.method === 'GET' && this.options.allowGetBody);
+            const shouldAutoEndStream = methodsWithoutBodyStream.has(this.options.method);
+            if ((this._noPipe ?? false) || cannotHaveBody || currentRequest !== this || shouldAutoEndStream) {
+                currentRequest.end();
+            }
         }
-        else if (this._cannotHaveBody || this._noPipe) {
+        else {
+            this._writeRequest(body, undefined, () => { });
             currentRequest.end();
         }
     }
@@ -834,7 +947,12 @@ export default class Request extends Duplex {
             this._requestOptions._request = request;
             this._requestOptions.cache = options.cache;
             this._requestOptions.body = options.body;
-            this._prepareCache(options.cache);
+            try {
+                this._prepareCache(options.cache);
+            }
+            catch (error) {
+                throw new CacheError(error, this);
+            }
         }
         // Cache support
         const function_ = options.cache ? this._createCacheableRequest : request;

package/dist/source/core/options.d.ts

@@ -7,13 +7,15 @@ import type { Socket } from 'node:net';
 import CacheableLookup from 'cacheable-lookup';
 import http2wrapper, { type ClientHttp2Session } from 'http2-wrapper';
 import { type FormDataLike } from 'form-data-encoder';
-import type { StorageAdapter } from 'cacheable-request';
+import type { KeyvStoreAdapter } from 'keyv';
+import type KeyvType from 'keyv';
 import type ResponseLike from 'responselike';
 import type { IncomingMessageWithTimings } from '@szmarczak/http-timer';
 import type { CancelableRequest } from '../as-promise/types.js';
 import type { PlainResponse, Response } from './response.js';
 import type { RequestError } from './errors.js';
 import type { Delays } from './timed-out.js';
+type StorageAdapter = KeyvStoreAdapter | KeyvType | Map<any, any>;
 type Promisable<T> = T | Promise<T>;
 export type DnsLookupIpVersion = undefined | 4 | 6;
 type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
@@ -272,9 +274,15 @@ export type Hooks = {
     > - When using the Stream API, this hook is ignored.
 
     **Note:**
-    > - Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. If the retry is successful, all remaining `afterResponse` hooks will be called. In case of an error, `beforeRetry` hooks will be called instead.
+    > - Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. By default, remaining `afterResponse` hooks are removed to prevent duplicate execution. To preserve remaining hooks on retry, set `preserveHooks: true` in the options passed to `retryWithMergedOptions`. In case of an error, `beforeRetry` hooks will be called instead.
     Meanwhile the `init`, `beforeRequest` , `beforeRedirect` as well as already executed `afterResponse` hooks will be skipped.
 
+    **Note:**
+    > - To preserve remaining `afterResponse` hooks after calling `retryWithMergedOptions`, set `preserveHooks: true` in the options passed to `retryWithMergedOptions`. This is useful when you want hooks to run on retried requests.
+
+    **Warning:**
+    > - Be cautious when using `preserveHooks: true`. If a hook unconditionally calls `retryWithMergedOptions` with `preserveHooks: true`, it will create an infinite retry loop. Always ensure hooks have proper conditional logic to avoid infinite retries.
+
     @example
     ```
     import got from 'got';
@@ -312,6 +320,37 @@ export type Hooks = {
         mutableDefaults: true
     });
     ```
+
+    @example
+    ```
+    // Example with preserveHooks
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            afterResponse: [
+                (response, retryWithMergedOptions) => {
+                    if (response.statusCode === 401) {
+                        return retryWithMergedOptions({
+                            headers: {
+                                authorization: getNewToken()
+                            },
+                            preserveHooks: true  // Keep remaining hooks
+                        });
+                    }
+
+                    return response;
+                },
+                (response) => {
+                    // This hook will run on the retried request
+                    // (the original request is interrupted when the first hook triggers a retry)
+                    console.log('Response received:', response.statusCode);
+                    return response;
+                }
+            ]
+        }
+    });
+    ```
     */
     afterResponse: AfterResponseHook[];
 };
@@ -337,6 +376,10 @@ Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.ra
 The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
 The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
 
+The `enforceRetryRules` property is a `boolean` that, when set to `true`, enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false` (default), `calculateDelay` receives the computed value but can override all retry logic.
+
+__Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect the default retry logic. When `true`, the retry rules are enforced automatically.
+
 By default, it retries *only* on the specified methods, status codes, and on these network errors:
 - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
 - `ECONNRESET`: Connection was forcibly closed by a peer.
@@ -360,6 +403,7 @@ export type RetryOptions = {
     backoffLimit: number;
     noise: number;
     maxRetryAfter?: number;
+    enforceRetryRules?: boolean;
 };
 export type CreateConnectionFunction = (options: NativeRequestOptions, oncreate: (error: NodeJS.ErrnoException, socket: Socket) => void) => Socket;
 export type CheckServerIdentityFunction = (hostname: string, certificate: DetailedPeerCertificate) => NodeJS.ErrnoException | void;
@@ -379,6 +423,24 @@ export type HttpsOptions = {
     rejectUnauthorized?: NativeRequestOptions['rejectUnauthorized'];
     checkServerIdentity?: CheckServerIdentityFunction;
     /**
+    Server name for the [Server Name Indication (SNI)](https://en.wikipedia.org/wiki/Server_Name_Indication) TLS extension.
+
+    This is useful when requesting to servers that don't have a proper domain name but use a certificate with a known CN/SAN.
+
+    @example
+    ```
+    import got from 'got';
+
+    // Request to IP address with specific servername for TLS
+    await got('https://192.168.1.100', {
+        https: {
+            serverName: 'example.com'
+        }
+    });
+    ```
+    */
+    serverName?: string;
+    /**
     Override the default Certificate Authorities ([from Mozilla](https://ccadb-public.secure.force.com/mozilla/IncludedCACertificateReport)).
 
     @example
@@ -551,6 +613,7 @@ export type OptionsError = NodeJS.ErrnoException & {
 export type OptionsInit = Except<Partial<InternalsType>, 'hooks' | 'retry'> & {
     hooks?: Partial<Hooks>;
     retry?: Partial<RetryOptions>;
+    preserveHooks?: boolean;
 };
 export default class Options {
     private _unixOptions?;
@@ -675,9 +738,26 @@ export default class Options {
     The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
 
     Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
+
+    You can use `Iterable` and `AsyncIterable` objects as request body, including Web [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream):
+
+    @example
+    ```
+    import got from 'got';
+
+    // Using an async generator
+    async function* generateData() {
+        yield 'Hello, ';
+        yield 'world!';
+    }
+
+    await got.post('https://httpbin.org/anything', {
+        body: generateData()
+    });
+    ```
     */
-    get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined;
-    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined);
+    get body(): string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | undefined;
+    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | undefined);
     /**
     The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
 
@@ -1005,6 +1085,10 @@ export default class Options {
     The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
     The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
 
+    The `enforceRetryRules` property is a `boolean` that, when set to `true`, enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false` (default), `calculateDelay` receives the computed value but can override all retry logic.
+
+    __Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect the default retry logic. When `true`, the retry rules are enforced automatically.
+
     By default, it retries *only* on the specified methods, status codes, and on these network errors:
 
     - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
@@ -1131,7 +1215,7 @@ export default class Options {
         h2session: ClientHttp2Session | undefined;
         decompress: boolean;
         prefixUrl: string | URL;
-        body: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined;
+        body: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | undefined;
         form: Record<string, any> | undefined;
         url: string | URL | undefined;
         cookieJar: PromiseCookieJar | ToughCookieJar | undefined;
@@ -1174,6 +1258,7 @@ export default class Options {
         pfx: PfxType;
         rejectUnauthorized: boolean | undefined;
         checkServerIdentity: CheckServerIdentityFunction | typeof checkServerIdentity;
+        servername: string | undefined;
         ciphers: string | undefined;
         honorCipherOrder: boolean | undefined;
         minVersion: import("tls").SecureVersion | undefined;
@@ -1192,7 +1277,11 @@ export default class Options {
             (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
         } | undefined;
         family: DnsLookupIpVersion;
-        agent: false | http.Agent | Agents | undefined;
+        agent: false | http.Agent | {
+            http2: {};
+            http?: HttpAgent | false;
+            https?: HttpsAgent | false;
+        } | undefined;
         setHost: boolean;
         method: Method;
         maxHeaderSize: number | undefined;
@@ -1229,7 +1318,6 @@ export default class Options {
         secureProtocol?: string | undefined;
         sessionIdContext?: string | undefined;
         ticketKeys?: Buffer | undefined;
-        servername?: string | undefined;
         shared?: boolean;
         cacheHeuristic?: number;
         immutableMinTimeToLive?: number;

package/dist/source/core/options.js

@@ -27,6 +27,39 @@ const getGlobalDnsCache = () => {
     globalDnsCache = new CacheableLookup();
     return globalDnsCache;
 };
+// Detects and wraps QuickLRU v7+ instances to make them compatible with the StorageAdapter interface
+const wrapQuickLruIfNeeded = (value) => {
+    // Check if this is QuickLRU v7+ using Symbol.toStringTag and the evict method (added in v7)
+    if (value?.[Symbol.toStringTag] === 'QuickLRU' && typeof value.evict === 'function') {
+        // QuickLRU v7+ uses set(key, value, {maxAge: number}) but StorageAdapter expects set(key, value, ttl)
+        // Wrap it to translate the interface
+        return {
+            get(key) {
+                return value.get(key);
+            },
+            set(key, cacheValue, ttl) {
+                if (ttl === undefined) {
+                    value.set(key, cacheValue);
+                }
+                else {
+                    value.set(key, cacheValue, { maxAge: ttl });
+                }
+                return true;
+            },
+            delete(key) {
+                return value.delete(key);
+            },
+            clear() {
+                return value.clear();
+            },
+            has(key) {
+                return value.has(key);
+            },
+        };
+    }
+    // QuickLRU v5 and other caches work as-is
+    return value;
+};
 const defaultInternals = {
     request: undefined,
     agent: {
@@ -115,6 +148,8 @@ const defaultInternals = {
         calculateDelay: ({ computedValue }) => computedValue,
         backoffLimit: Number.POSITIVE_INFINITY,
         noise: 100,
+        // TODO: Change default to `true` in the next major version to fix https://github.com/sindresorhus/got/issues/2243
+        enforceRetryRules: false,
     },
     localAddress: undefined,
     method: 'GET',
@@ -129,6 +164,7 @@ const defaultInternals = {
         alpnProtocols: undefined,
         rejectUnauthorized: undefined,
         checkServerIdentity: undefined,
+        serverName: undefined,
         certificateAuthority: undefined,
         key: undefined,
         certificate: undefined,
@@ -386,6 +422,10 @@ export default class Options {
                 if (key === 'url') {
                     continue;
                 }
+                // Never merge `preserveHooks` - it's a control flag, not a persistent option
+                if (key === 'preserveHooks') {
+                    continue;
+                }
                 if (!(key in this)) {
                     throw new Error(`Unexpected option: ${key}`);
                 }
@@ -452,7 +492,7 @@ export default class Options {
                 throw new TypeError(`Unexpected agent option: ${key}`);
             }
             // @ts-expect-error - No idea why `value[key]` doesn't work here.
-            assert.any([is.object, is.undefined], value[key]);
+            assert.any([is.object, is.undefined, (v) => v === false], value[key]);
         }
         if (this._merging) {
             Object.assign(this._internals.agent, value);
@@ -593,12 +633,29 @@ export default class Options {
     The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
 
     Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
+
+    You can use `Iterable` and `AsyncIterable` objects as request body, including Web [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream):
+
+    @example
+    ```
+    import got from 'got';
+
+    // Using an async generator
+    async function* generateData() {
+        yield 'Hello, ';
+        yield 'world!';
+    }
+
+    await got.post('https://httpbin.org/anything', {
+        body: generateData()
+    });
+    ```
     */
     get body() {
         return this._internals.body;
     }
     set body(value) {
-        assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormData, is.undefined], value);
+        assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, is.iterable, is.asyncIterable, isFormData, is.undefined], value);
         if (is.nodeStream(value)) {
             assert.truthy(value.readable);
         }
@@ -1034,7 +1091,7 @@ export default class Options {
             this._internals.cache = undefined;
         }
         else {
-            this._internals.cache = value;
+            this._internals.cache = wrapQuickLruIfNeeded(value);
         }
     }
     /**
@@ -1261,6 +1318,10 @@ export default class Options {
     The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
     The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
 
+    The `enforceRetryRules` property is a `boolean` that, when set to `true`, enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false` (default), `calculateDelay` receives the computed value but can override all retry logic.
+
+    __Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect the default retry logic. When `true`, the retry rules are enforced automatically.
+
     By default, it retries *only* on the specified methods, status codes, and on these network errors:
 
     - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
@@ -1287,6 +1348,7 @@ export default class Options {
         assert.any([is.array, is.undefined], value.statusCodes);
         assert.any([is.array, is.undefined], value.errorCodes);
         assert.any([is.number, is.undefined], value.noise);
+        assert.any([is.boolean, is.undefined], value.enforceRetryRules);
         if (value.noise && Math.abs(value.noise) > 100) {
             throw new Error(`The maximum acceptable retry noise is +/- 100ms, got ${value.noise}`);
         }
@@ -1373,6 +1435,7 @@ export default class Options {
         assert.plainObject(value);
         assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
         assert.any([is.function, is.undefined], value.checkServerIdentity);
+        assert.any([is.string, is.undefined], value.serverName);
         assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
         assert.any([is.string, is.object, is.array, is.undefined], value.key);
         assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
@@ -1539,7 +1602,17 @@ export default class Options {
         const url = internals.url;
         let agent;
         if (url.protocol === 'https:') {
-            agent = internals.http2 ? internals.agent : internals.agent.https;
+            if (internals.http2) {
+                // Ensure HTTP/2 agent is configured for connection reuse
+                // If no custom agent.http2 is provided, use the global agent for connection pooling
+                agent = {
+                    ...internals.agent,
+                    http2: internals.agent.http2 ?? http2wrapper.globalAgent,
+                };
+            }
+            else {
+                agent = internals.agent.https;
+            }
         }
         else {
             agent = internals.agent.http;
@@ -1565,6 +1638,7 @@ export default class Options {
             pfx: https.pfx,
             rejectUnauthorized: https.rejectUnauthorized,
             checkServerIdentity: https.checkServerIdentity ?? checkServerIdentity,
+            servername: https.serverName,
             ciphers: https.ciphers,
             honorCipherOrder: https.honorCipherOrder,
             minVersion: https.minVersion,

package/dist/source/core/utils/get-body-size.js

@@ -16,7 +16,20 @@ export default async function getBodySize(body, headers) {
         return body.length;
     }
     if (isFormData(body)) {
-        return promisify(body.getLength.bind(body))();
+        try {
+            return await promisify(body.getLength.bind(body))();
+        }
+        catch (error) {
+            const typedError = error;
+            throw new Error('Cannot determine content-length for form-data with stream(s) of unknown length. '
+                + 'This is a limitation of the `form-data` package. '
+                + 'To fix this, either:\n'
+                + '1. Use the `knownLength` option when appending streams:\n'
+                + '   form.append(\'file\', stream, {knownLength: 12345});\n'
+                + '2. Switch to spec-compliant FormData (formdata-node package)\n'
+                + 'See: https://github.com/form-data/form-data#alternative-submission-methods\n'
+                + `Original error: ${typedError.message}`);
+        }
     }
     return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "14.4.8",
+	"version": "14.5.0",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -51,13 +51,14 @@
 		"@sindresorhus/is": "^7.0.1",
 		"@szmarczak/http-timer": "^5.0.1",
 		"cacheable-lookup": "^7.0.0",
-		"cacheable-request": "^12.0.1",
+		"cacheable-request": "^13.0.12",
 		"decompress-response": "^6.0.0",
 		"form-data-encoder": "^4.0.2",
 		"http2-wrapper": "^2.2.1",
+		"keyv": "^5.5.3",
 		"lowercase-keys": "^3.0.0",
 		"p-cancelable": "^4.0.1",
-		"responselike": "^3.0.0",
+		"responselike": "^4.0.2",
 		"type-fest": "^4.26.1"
 	},
 	"devDependencies": {
@@ -93,6 +94,7 @@
 		"p-event": "^6.0.1",
 		"pem": "^1.14.8",
 		"pify": "^6.1.0",
+		"quick-lru": "^7.2.0",
 		"readable-stream": "^4.4.2",
 		"request": "^2.88.2",
 		"sinon": "^19.0.2",