got 14.5.0 → 14.6.0

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

@@ -18,12 +18,14 @@ export default function asPromise(firstRequest) {
     let globalResponse;
     let normalizedOptions;
     const emitter = new EventEmitter();
+    let promiseSettled = false;
     const promise = new PCancelable((resolve, reject, onCancel) => {
         onCancel(() => {
             globalRequest.destroy();
         });
         onCancel.shouldReject = false;
         onCancel(() => {
+            promiseSettled = true;
             reject(new CancelError(globalRequest));
         });
         const makeRequest = (retryCount) => {
@@ -82,7 +84,7 @@ export default function asPromise(firstRequest) {
                             }
                             throw new RetryError(request);
                         });
-                        if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
+                        if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
                             throw new TypeError('The `afterResponse` hook returned an invalid value');
                         }
                     }
@@ -97,12 +99,27 @@ export default function asPromise(firstRequest) {
                     return;
                 }
                 request.destroy();
+                promiseSettled = true;
                 resolve(request.options.resolveBodyOnly ? response.body : response);
             });
+            let handledFinalError = false;
             const onError = (error) => {
                 if (promise.isCanceled) {
                     return;
                 }
+                // Route errors emitted directly on the stream (e.g., EPIPE from Node.js)
+                // through retry logic first, then handle them here after retries are exhausted.
+                // See https://github.com/sindresorhus/got/issues/1995
+                if (!request._stopReading) {
+                    request._beforeError(error);
+                    return;
+                }
+                // Allow the manual re-emission from Request to land only once.
+                if (handledFinalError) {
+                    return;
+                }
+                handledFinalError = true;
+                promiseSettled = true;
                 const { options } = request;
                 if (error instanceof HTTPError && !options.throwHttpErrors) {
                     const { response } = error;
@@ -112,10 +129,21 @@ export default function asPromise(firstRequest) {
                 }
                 reject(error);
             };
-            request.once('error', onError);
+            // Use .on() instead of .once() to keep the listener active across retries.
+            // When _stopReading is false, we return early and the error gets re-emitted
+            // after retry logic completes, so we need this listener to remain active.
+            // See https://github.com/sindresorhus/got/issues/1995
+            request.on('error', onError);
             const previousBody = request.options?.body;
             request.once('retry', (newRetryCount, error) => {
                 firstRequest = undefined;
+                // If promise already settled, don't retry
+                // This prevents the race condition in #1489 where a late error
+                // (e.g., ECONNRESET after successful response) triggers retry
+                // after the promise has already resolved/rejected
+                if (promiseSettled) {
+                    return;
+                }
                 const newBody = request.options.body;
                 if (previousBody === newBody && is.nodeStream(newBody)) {
                     error.message = 'Cannot retry with consumed body stream';

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

@@ -88,11 +88,11 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     requestUrl?: URL;
     redirectUrls: URL[];
     retryCount: number;
+    _stopReading: boolean;
     private _requestOptions;
     private _stopRetry;
     private _downloadedSize;
     private _uploadedSize;
-    private _stopReading;
     private readonly _pipedServerResponses;
     private _request?;
     private _responseSize?;
@@ -106,6 +106,8 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     private _nativeResponse?;
     private _flushed;
     private _aborted;
+    private _expectedContentLength?;
+    private _byteCounter?;
     private _requestInitialized;
     constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType);
     flush(): Promise<void>;
@@ -118,6 +120,7 @@ export default class Request extends Duplex implements RequestEvents<Request> {
         end?: boolean;
     }): T;
     unpipe<T extends NodeJS.WritableStream>(destination: T): this;
+    private _checkContentLengthMismatch;
     private _finalizeBody;
     private _onResponseBase;
     private _setRawBody;

package/dist/source/core/index.js

@@ -1,8 +1,6 @@
 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 { Duplex, Transform } from 'node:stream';
 import http, { ServerResponse } from 'node:http';
 import timer from '@szmarczak/http-timer';
 import CacheableRequest, { CacheError as CacheableCacheError, } from 'cacheable-request';
@@ -19,7 +17,7 @@ import calculateRetryDelay from './calculate-retry-delay.js';
 import Options from './options.js';
 import { isResponseOk } from './response.js';
 import isClientRequest from './utils/is-client-request.js';
-import isUnixSocketURL from './utils/is-unix-socket-url.js';
+import isUnixSocketURL, { getUnixSocketPath } 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']);
@@ -35,6 +33,17 @@ const proxiedRequestEvents = [
     'upgrade',
 ];
 const noop = () => { };
+/**
+Stream transform that counts bytes passing through.
+Used to track compressed bytes before decompression for content-length validation.
+*/
+class ByteCounter extends Transform {
+    count = 0;
+    _transform(chunk, _encoding, callback) {
+        this.count += chunk.length;
+        callback(null, chunk);
+    }
+}
 export default class Request extends Duplex {
     // @ts-expect-error - Ignoring for now.
     ['constructor'];
@@ -45,10 +54,10 @@ export default class Request extends Duplex {
     requestUrl;
     redirectUrls;
     retryCount;
+    _stopReading;
     _stopRetry;
     _downloadedSize;
     _uploadedSize;
-    _stopReading;
     _pipedServerResponses;
     _request;
     _responseSize;
@@ -61,6 +70,8 @@ export default class Request extends Duplex {
     _nativeResponse;
     _flushed;
     _aborted;
+    _expectedContentLength;
+    _byteCounter;
     // We need this because `this._request` if `undefined` when using cache
     _requestInitialized;
     constructor(url, options, defaults) {
@@ -112,7 +123,18 @@ export default class Request extends Duplex {
             }
             this.flush = async () => {
                 this.flush = async () => { };
-                this.destroy(error);
+                // Defer error emission to next tick to allow user to attach error handlers
+                process.nextTick(() => {
+                    // _beforeError requires options to access retry logic and hooks
+                    if (this.options) {
+                        this._beforeError(error);
+                    }
+                    else {
+                        // Options is undefined, skip _beforeError and destroy directly
+                        const requestError = error instanceof RequestError ? error : new RequestError(error.message, error, this);
+                        this.destroy(requestError);
+                    }
+                });
             };
             return;
         }
@@ -368,6 +390,19 @@ export default class Request extends Duplex {
         if (this._request) {
             this._request.destroy();
         }
+        // Workaround: http-timer only sets timings.end when the response emits 'end'.
+        // When a stream is destroyed before completion, the 'end' event may not fire,
+        // leaving timings.end undefined. This should ideally be fixed in http-timer
+        // by listening to the 'close' event, but we handle it here for now.
+        // Only set timings.end if there was no error or abort (to maintain semantic correctness).
+        const timings = this._request?.timings;
+        if (timings && is.undefined(timings.end) && !is.undefined(timings.response) && is.undefined(timings.error) && is.undefined(timings.abort)) {
+            timings.end = Date.now();
+            if (is.undefined(timings.phases.total)) {
+                timings.phases.download = timings.end - timings.response;
+                timings.phases.total = timings.end - timings.start;
+            }
+        }
         if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
             error = new RequestError(error.message, error, this);
         }
@@ -386,6 +421,22 @@ export default class Request extends Duplex {
         super.unpipe(destination);
         return this;
     }
+    _checkContentLengthMismatch() {
+        if (this.options.strictContentLength && this._expectedContentLength !== undefined) {
+            // Use ByteCounter's count when available (for compressed responses),
+            // otherwise use _downloadedSize (for uncompressed responses)
+            const actualSize = this._byteCounter?.count ?? this._downloadedSize;
+            if (actualSize !== this._expectedContentLength) {
+                this._beforeError(new ReadError({
+                    message: `Content-Length mismatch: expected ${this._expectedContentLength} bytes, received ${actualSize} bytes`,
+                    name: 'Error',
+                    code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH',
+                }, this));
+                return true;
+            }
+        }
+        return false;
+    }
     async _finalizeBody() {
         const { options } = this;
         const { headers } = options;
@@ -473,86 +524,19 @@ export default class Request extends Duplex {
             || statusCode === 204
             || statusCode === 205
             || statusCode === 304;
-        const nativeResponse = response;
         if (options.decompress && !hasNoBody) {
+            // When strictContentLength is enabled, track compressed bytes by listening to
+            // the native response's data events before decompression
+            if (options.strictContentLength) {
+                this._byteCounter = new ByteCounter();
+                this._nativeResponse.on('data', (chunk) => {
+                    this._byteCounter.count += chunk.length;
+                });
+            }
             response = decompressResponse(response);
         }
-        // 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.statusMessage = typedResponse.statusMessage || http.STATUS_CODES[statusCode]; // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing -- The status message can be empty.
         typedResponse.url = options.url.toString();
         typedResponse.requestUrl = this.requestUrl;
         typedResponse.redirectUrls = this.redirectUrls;
@@ -564,6 +548,18 @@ export default class Request extends Duplex {
         this._isFromCache = typedResponse.isFromCache;
         this._responseSize = Number(response.headers['content-length']) || undefined;
         this.response = typedResponse;
+        // Workaround for http-timer bug: when connecting to an IP address (no DNS lookup),
+        // http-timer sets lookup = connect instead of lookup = socket, resulting in
+        // dns = lookup - socket being a small positive number instead of 0.
+        // See https://github.com/sindresorhus/got/issues/2279
+        const { timings } = response;
+        if (timings?.lookup !== undefined && timings.socket !== undefined && timings.connect !== undefined && timings.lookup === timings.connect && timings.phases.dns !== 0) {
+            // Fix the DNS phase to be 0 and set lookup to socket time
+            timings.phases.dns = 0;
+            timings.lookup = timings.socket;
+            // Recalculate TCP time to be the full time from socket to connect
+            timings.phases.tcp = timings.connect - timings.socket;
+        }
         response.once('error', (error) => {
             this._aborted = true;
             // Force clean-up, because some packages don't do this.
@@ -573,11 +569,14 @@ export default class Request extends Duplex {
         });
         response.once('aborted', () => {
             this._aborted = true;
-            this._beforeError(new ReadError({
-                name: 'Error',
-                message: 'The server aborted pending request',
-                code: 'ECONNRESET',
-            }, this));
+            // Check if there's a content-length mismatch to provide a more specific error
+            if (!this._checkContentLengthMismatch()) {
+                this._beforeError(new ReadError({
+                    name: 'Error',
+                    message: 'The server aborted pending request',
+                    code: 'ECONNRESET',
+                }, this));
+            }
         });
         const rawCookies = response.headers['set-cookie'];
         if (is.object(options.cookieJar) && rawCookies) {
@@ -639,7 +638,11 @@ export default class Request extends Duplex {
                         return;
                     }
                     // Redirecting to a different site, clear sensitive data.
-                    if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) {
+                    // For UNIX sockets, different socket paths are also different origins.
+                    const isDifferentOrigin = redirectUrl.hostname !== url.hostname
+                        || redirectUrl.port !== url.port
+                        || getUnixSocketPath(url) !== getUnixSocketPath(redirectUrl);
+                    if (isDifferentOrigin) {
                         if ('host' in updatedOptions.headers) {
                             delete updatedOptions.headers.host;
                         }
@@ -684,13 +687,32 @@ export default class Request extends Duplex {
             this._beforeError(new HTTPError(typedResponse));
             return;
         }
+        // Store the expected content-length from the native response for validation.
+        // This is the content-length before decompression, which is what actually gets transferred.
+        // Skip storing for responses that shouldn't have bodies per RFC 9110.
+        // When decompression occurs, only store if strictContentLength is enabled.
+        const wasDecompressed = response !== this._nativeResponse;
+        if (!hasNoBody && (!wasDecompressed || options.strictContentLength)) {
+            const contentLengthHeader = this._nativeResponse.headers['content-length'];
+            if (contentLengthHeader !== undefined) {
+                const expectedLength = Number(contentLengthHeader);
+                if (!Number.isNaN(expectedLength) && expectedLength >= 0) {
+                    this._expectedContentLength = expectedLength;
+                }
+            }
+        }
         // Set up end listener AFTER redirect check to avoid emitting progress for redirect responses
-        const endStream = () => {
+        response.once('end', () => {
+            // Validate content-length if it was provided
+            // Per RFC 9112: "If the sender closes the connection before the indicated number
+            // of octets are received, the recipient MUST consider the message to be incomplete"
+            if (this._checkContentLengthMismatch()) {
+                return;
+            }
             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) {
@@ -715,12 +737,22 @@ export default class Request extends Duplex {
             if (destination.headersSent) {
                 continue;
             }
-            // eslint-disable-next-line guard-for-in
+            // Check if decompression actually occurred by comparing stream objects.
+            // decompressResponse wraps the response stream when it decompresses,
+            // so response !== this._nativeResponse indicates decompression happened.
+            const wasDecompressed = response !== this._nativeResponse;
             for (const key in response.headers) {
-                const isAllowed = options.decompress ? key !== 'content-encoding' : true;
-                const value = response.headers[key];
-                if (isAllowed) {
-                    destination.setHeader(key, value);
+                if (Object.hasOwn(response.headers, key)) {
+                    const value = response.headers[key];
+                    // When decompression occurred, skip content-encoding and content-length
+                    // as they refer to the compressed data, not the decompressed stream.
+                    if (wasDecompressed && (key === 'content-encoding' || key === 'content-length')) {
+                        continue;
+                    }
+                    // Skip if value is undefined
+                    if (value !== undefined) {
+                        destination.setHeader(key, value);
+                    }
                 }
             }
             destination.statusCode = statusCode;
@@ -805,6 +837,19 @@ export default class Request extends Duplex {
         if (is.nodeStream(body)) {
             body.pipe(currentRequest);
         }
+        else if (is.buffer(body)) {
+            // Buffer should be sent directly without conversion
+            this._writeRequest(body, undefined, () => { });
+            currentRequest.end();
+        }
+        else if (is.typedArray(body)) {
+            // Typed arrays should be treated like buffers, not iterated over
+            // Create a Uint8Array view over the data (Node.js streams accept Uint8Array)
+            const typedArray = body;
+            const uint8View = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+            this._writeRequest(uint8View, undefined, () => { });
+            currentRequest.end();
+        }
         else if (is.asyncIterable(body) || (is.iterable(body) && !is.string(body) && !isBuffer(body))) {
             (async () => {
                 try {
@@ -884,9 +929,15 @@ export default class Request extends Duplex {
                 response._readableState.autoDestroy = false;
                 if (request) {
                     const fix = () => {
+                        // For ResponseLike objects from cache, set complete to true if not already set.
+                        // For real HTTP responses, copy from the underlying response.
                         if (response.req) {
                             response.complete = response.req.res.complete;
                         }
+                        else if (response.complete === undefined) {
+                            // ResponseLike from cache should have complete = true
+                            response.complete = true;
+                        }
                     };
                     response.prependOnceListener('end', fix);
                     fix();
@@ -933,7 +984,7 @@ export default class Request extends Duplex {
         let request;
         for (const hook of options.hooks.beforeRequest) {
             // eslint-disable-next-line no-await-in-loop
-            const result = await hook(options);
+            const result = await hook(options, { retryCount: this.retryCount });
             if (!is.undefined(result)) {
                 // @ts-expect-error Skip the type mismatch to support abstract responses
                 request = () => result;
@@ -992,12 +1043,12 @@ export default class Request extends Duplex {
     }
     async _error(error) {
         try {
-            if (error instanceof HTTPError && !this.options.throwHttpErrors) {
+            if (this.options && error instanceof HTTPError && !this.options.throwHttpErrors) {
                 // This branch can be reached only when using the Promise API
                 // Skip calling the hooks on purpose.
                 // See https://github.com/sindresorhus/got/issues/2103
             }
-            else {
+            else if (this.options) {
                 for (const hook of this.options.hooks.beforeError) {
                     // eslint-disable-next-line no-await-in-loop
                     error = await hook(error);
@@ -1008,10 +1059,22 @@ export default class Request extends Duplex {
             error = new RequestError(error_.message, error_, this);
         }
         this.destroy(error);
+        // Manually emit error for Promise API to ensure it receives it.
+        // Node.js streams may not re-emit if an error was already emitted during retry attempts.
+        // Only emit for Promise API (_noPipe = true) to avoid double emissions in stream mode.
+        // Use process.nextTick to defer emission and allow destroy() to complete first.
+        // See https://github.com/sindresorhus/got/issues/1995
+        if (this._noPipe) {
+            process.nextTick(() => {
+                this.emit('error', error);
+            });
+        }
     }
     _writeRequest(chunk, encoding, callback) {
         if (!this._request || this._request.destroyed) {
-            // Probably the `ClientRequest` instance will throw
+            // When there's no request (e.g., using cached response from beforeRequest hook),
+            // we still need to call the callback to allow the stream to finish properly.
+            callback();
             return;
         }
         this._request.write(chunk, encoding, (error) => {

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

@@ -39,9 +39,34 @@ export type PromiseCookieJar = {
     getCookieString: (url: string) => Promise<string>;
     setCookie: (rawCookie: string, url: string) => Promise<unknown>;
 };
+/**
+Utility type to override specific properties in a type.
+
+Uses `Omit` to remove properties before adding them back to ensure proper type replacement rather than intersection, which handles edge cases with optional/required properties correctly.
+*/
+type OverrideProperties<T, U> = Omit<T, keyof U> & U;
+/**
+Represents the runtime state of Options as seen by hooks after normalization.
+
+Some Options properties accept multiple input types but are normalized to a single type internally by the Options class setters. This type reflects the actual runtime types that hooks receive, ensuring type safety when accessing options within hook functions.
+*/
+export type NormalizedOptions = OverrideProperties<Options, {
+    url: URL | undefined;
+    dnsCache: CacheableLookup | undefined;
+    cache: StorageAdapter | undefined;
+    prefixUrl: string;
+}>;
 export type InitHook = (init: OptionsInit, self: Options) => void;
-export type BeforeRequestHook = (options: Options) => Promisable<void | Response | ResponseLike>;
-export type BeforeRedirectHook = (updatedOptions: Options, plainResponse: PlainResponse) => Promisable<void>;
+export type BeforeRequestHookContext = {
+    /**
+    The current retry count.
+
+    It will be `0` for the initial request and increment for each retry.
+    */
+    retryCount: number;
+};
+export type BeforeRequestHook = (options: NormalizedOptions, context: BeforeRequestHookContext) => Promisable<void | Response | ResponseLike>;
+export type BeforeRedirectHook = (updatedOptions: NormalizedOptions, plainResponse: PlainResponse) => Promisable<void>;
 export type BeforeErrorHook = (error: RequestError) => Promisable<RequestError>;
 export type BeforeRetryHook = (error: RequestError, retryCount: number) => Promisable<void>;
 export type AfterResponseHook<ResponseType = unknown> = (response: Response<ResponseType>, retryWithMergedOptions: (options: OptionsInit) => never) => Promisable<Response | CancelableRequest<Response>>;
@@ -142,6 +167,8 @@ export type Hooks = {
     /**
     Called right before making the request with `options.createNativeRequestOptions()`.
 
+    The second argument is a context object containing request state information.
+
     This hook is especially useful in conjunction with `got.extend()` when you want to sign your request.
 
     @default []
@@ -162,7 +189,7 @@ export type Hooks = {
             json: {payload: 'old'},
             hooks: {
                 beforeRequest: [
-                    options => {
+                    (options, context) => {
                         options.body = JSON.stringify({payload: 'new'});
                         options.headers['content-length'] = options.body.length.toString();
                     }
@@ -172,6 +199,28 @@ export type Hooks = {
     );
     ```
 
+    **Example using `context.retryCount`:**
+
+    ```
+    import got from 'got';
+
+    await got('https://httpbin.org/status/500', {
+        retry: {
+            limit: 2
+        },
+        hooks: {
+            beforeRequest: [
+                (options, context) => {
+                    // Only log on the initial request, not on retries
+                    if (context.retryCount === 0) {
+                        console.log('Making initial request');
+                    }
+                }
+            ]
+        }
+    });
+    ```
+
     **Tip:**
     > - You can indirectly override the `request` function by early returning a [`ClientRequest`-like](https://nodejs.org/api/http.html#http_class_http_clientrequest) instance or a [`IncomingMessage`-like](https://nodejs.org/api/http.html#http_class_http_incomingmessage) instance. This is very useful when creating a custom cache mechanism.
     > - [Read more about this tip](https://github.com/sindresorhus/got/blob/main/documentation/cache.md#advanced-caching-mechanisms).
@@ -487,6 +536,27 @@ export type HttpsOptions = {
     dhparam?: SecureContextOptions['dhparam'];
     ecdhCurve?: SecureContextOptions['ecdhCurve'];
     certificateRevocationLists?: SecureContextOptions['crl'];
+    /**
+    Optionally affect the OpenSSL protocol behavior, which is not usually necessary. This should be used carefully if at all!
+
+    The value is a numeric bitmask of the `SSL_OP_*` options from OpenSSL.
+
+    For example, to allow connections to legacy servers that do not support secure renegotiation, you can use `crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT`.
+
+    @example
+    ```
+    import crypto from 'node:crypto';
+    import got from 'got';
+
+    // Allow connections to servers with legacy renegotiation
+    await got('https://legacy-server.com', {
+        https: {
+            secureOptions: crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT
+        }
+    });
+    ```
+    */
+    secureOptions?: number;
 };
 export type PaginateData<BodyType, ElementType> = {
     response: Response<BodyType>;
@@ -735,7 +805,7 @@ export default class Options {
 
     __Note #4__: This option is not enumerable and will not be merged with the instance defaults.
 
-    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`.
+    The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / typed array ([`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), etc.) / [`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`.
 
@@ -756,8 +826,8 @@ export default class Options {
     });
     ```
     */
-    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);
+    get body(): string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | ArrayBufferView | undefined;
+    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | ArrayBufferView | 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).
 
@@ -770,7 +840,9 @@ export default class Options {
     get form(): Record<string, any> | undefined;
     set form(value: Record<string, any> | undefined);
     /**
-    JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
+    JSON request body. If the `content-type` header is not set, it will be set to `application/json`.
+
+    __Important__: This option only affects the request body you send to the server. To parse the response as JSON, you must either call `.json()` on the promise or set `responseType: 'json'` in the options.
 
     __Note #1__: If you provide this option, `got.stream()` will be read-only.
 
@@ -1202,6 +1274,18 @@ export default class Options {
     set maxHeaderSize(value: number | undefined);
     get enableUnixSockets(): boolean;
     set enableUnixSockets(value: boolean);
+    /**
+    Throw an error if the server response's `content-length` header value doesn't match the number of bytes received.
+
+    This is useful for detecting truncated responses and follows RFC 9112 requirements for message completeness.
+
+    __Note__: Responses without a `content-length` header are not validated.
+    __Note__: When enabled and validation fails, a `ReadError` with code `ERR_HTTP_CONTENT_LENGTH_MISMATCH` will be thrown.
+
+    @default false
+    */
+    get strictContentLength(): boolean;
+    set strictContentLength(value: boolean);
     toJSON(): {
         headers: Headers;
         timeout: Delays;
@@ -1215,7 +1299,7 @@ export default class Options {
         h2session: ClientHttp2Session | undefined;
         decompress: boolean;
         prefixUrl: string | URL;
-        body: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | undefined;
+        body: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | ArrayBufferView | undefined;
         form: Record<string, any> | undefined;
         url: string | URL | undefined;
         cookieJar: PromiseCookieJar | ToughCookieJar | undefined;
@@ -1248,6 +1332,7 @@ export default class Options {
         setHost: boolean;
         maxHeaderSize: number | undefined;
         enableUnixSockets: boolean;
+        strictContentLength: boolean;
     };
     createNativeRequestOptions(): {
         ALPNProtocols: string[] | undefined;
@@ -1268,6 +1353,7 @@ export default class Options {
         dhparam: string | Buffer<ArrayBufferLike> | undefined;
         ecdhCurve: string | undefined;
         crl: string | Buffer<ArrayBufferLike> | (string | Buffer<ArrayBufferLike>)[] | undefined;
+        secureOptions: number | undefined;
         lookup: {
             (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
             (hostname: string, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
@@ -1314,7 +1400,6 @@ export default class Options {
         clientCertEngine?: string | undefined;
         privateKeyEngine?: string | undefined;
         privateKeyIdentifier?: string | undefined;
-        secureOptions?: number | undefined;
         secureProtocol?: string | undefined;
         sessionIdContext?: string | undefined;
         ticketKeys?: Buffer | undefined;

package/dist/source/core/options.js

@@ -11,11 +11,43 @@ import http2wrapper from 'http2-wrapper';
 import { isFormData } from 'form-data-encoder';
 import parseLinkHeader from './parse-link-header.js';
 const [major, minor] = process.versions.node.split('.').map(Number);
+/**
+Generic helper that wraps any assertion function to add context to error messages.
+*/
+function wrapAssertionWithContext(optionName, assertionFn) {
+    try {
+        assertionFn();
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            error.message = `Option '${optionName}': ${error.message}`;
+        }
+        throw error;
+    }
+}
+/**
+Helper function that wraps assert.any() to provide better error messages.
+When assertion fails, it includes the option name in the error message.
+*/
+function assertAny(optionName, validators, value) {
+    wrapAssertionWithContext(optionName, () => {
+        assert.any(validators, value);
+    });
+}
+/**
+Helper function that wraps assert.plainObject() to provide better error messages.
+When assertion fails, it includes the option name in the error message.
+*/
+function assertPlainObject(optionName, value) {
+    wrapAssertionWithContext(optionName, () => {
+        assert.plainObject(value);
+    });
+}
 function validateSearchParameters(searchParameters) {
     // eslint-disable-next-line guard-for-in
     for (const key in searchParameters) {
         const value = searchParameters[key];
-        assert.any([is.string, is.number, is.boolean, is.null, is.undefined], value);
+        assertAny(`searchParams.${key}`, [is.string, is.number, is.boolean, is.null, is.undefined], value);
     }
 }
 const globalCache = new Map();
@@ -179,6 +211,7 @@ const defaultInternals = {
         dhparam: undefined,
         ecdhCurve: undefined,
         certificateRevocationLists: undefined,
+        secureOptions: undefined,
     },
     encoding: undefined,
     resolveBodyOnly: false,
@@ -217,6 +250,7 @@ const defaultInternals = {
     maxHeaderSize: undefined,
     signal: undefined,
     enableUnixSockets: false,
+    strictContentLength: false,
 };
 const cloneInternals = (internals) => {
     const { hooks, retry } = internals;
@@ -336,9 +370,9 @@ export default class Options {
     _merging;
     _init;
     constructor(input, options, defaults) {
-        assert.any([is.string, is.urlInstance, is.object, is.undefined], input);
-        assert.any([is.object, is.undefined], options);
-        assert.any([is.object, is.undefined], defaults);
+        assertAny('input', [is.string, is.urlInstance, is.object, is.undefined], input);
+        assertAny('options', [is.object, is.undefined], options);
+        assertAny('defaults', [is.object, is.undefined], defaults);
         if (input instanceof Options || options instanceof Options) {
             throw new TypeError('The defaults must be passed as the third argument');
         }
@@ -456,7 +490,7 @@ export default class Options {
         return this._internals.request;
     }
     set request(value) {
-        assert.any([is.function, is.undefined], value);
+        assertAny('request', [is.function, is.undefined], value);
         this._internals.request = value;
     }
     /**
@@ -485,14 +519,14 @@ export default class Options {
         return this._internals.agent;
     }
     set agent(value) {
-        assert.plainObject(value);
+        assertPlainObject('agent', value);
         // eslint-disable-next-line guard-for-in
         for (const key in value) {
             if (!(key in this._internals.agent)) {
                 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, (v) => v === false], value[key]);
+            assertAny(`agent.${key}`, [is.object, is.undefined, (v) => v === false], value[key]);
         }
         if (this._merging) {
             Object.assign(this._internals.agent, value);
@@ -545,14 +579,14 @@ export default class Options {
         return this._internals.timeout;
     }
     set timeout(value) {
-        assert.plainObject(value);
+        assertPlainObject('timeout', value);
         // eslint-disable-next-line guard-for-in
         for (const key in value) {
             if (!(key in this._internals.timeout)) {
                 throw new Error(`Unexpected timeout option: ${key}`);
             }
             // @ts-expect-error - No idea why `value[key]` doesn't work here.
-            assert.any([is.number, is.undefined], value[key]);
+            assertAny(`timeout.${key}`, [is.number, is.undefined], value[key]);
         }
         if (this._merging) {
             Object.assign(this._internals.timeout, value);
@@ -606,7 +640,7 @@ export default class Options {
         return this._internals.prefixUrl;
     }
     set prefixUrl(value) {
-        assert.any([is.string, is.urlInstance], value);
+        assertAny('prefixUrl', [is.string, is.urlInstance], value);
         if (value === '') {
             this._internals.prefixUrl = '';
             return;
@@ -630,7 +664,7 @@ export default class Options {
 
     __Note #4__: This option is not enumerable and will not be merged with the instance defaults.
 
-    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`.
+    The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / typed array ([`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), etc.) / [`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`.
 
@@ -655,7 +689,7 @@ export default class Options {
         return this._internals.body;
     }
     set body(value) {
-        assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, is.iterable, is.asyncIterable, isFormData, is.undefined], value);
+        assertAny('body', [is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, is.iterable, is.asyncIterable, isFormData, is.typedArray, is.undefined], value);
         if (is.nodeStream(value)) {
             assert.truthy(value.readable);
         }
@@ -678,7 +712,7 @@ export default class Options {
         return this._internals.form;
     }
     set form(value) {
-        assert.any([is.plainObject, is.undefined], value);
+        assertAny('form', [is.plainObject, is.undefined], value);
         if (value !== undefined) {
             assert.undefined(this._internals.body);
             assert.undefined(this._internals.json);
@@ -686,7 +720,9 @@ export default class Options {
         this._internals.form = value;
     }
     /**
-    JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
+    JSON request body. If the `content-type` header is not set, it will be set to `application/json`.
+
+    __Important__: This option only affects the request body you send to the server. To parse the response as JSON, you must either call `.json()` on the promise or set `responseType: 'json'` in the options.
 
     __Note #1__: If you provide this option, `got.stream()` will be read-only.
 
@@ -724,7 +760,7 @@ export default class Options {
         return this._internals.url;
     }
     set url(value) {
-        assert.any([is.string, is.urlInstance, is.undefined], value);
+        assertAny('url', [is.string, is.urlInstance, is.undefined], value);
         if (value === undefined) {
             this._internals.url = undefined;
             return;
@@ -784,7 +820,7 @@ export default class Options {
         return this._internals.cookieJar;
     }
     set cookieJar(value) {
-        assert.any([is.object, is.undefined], value);
+        assertAny('cookieJar', [is.object, is.undefined], value);
         if (value === undefined) {
             this._internals.cookieJar = undefined;
             return;
@@ -871,7 +907,7 @@ export default class Options {
         return this._internals.searchParams;
     }
     set searchParams(value) {
-        assert.any([is.string, is.object, is.undefined], value);
+        assertAny('searchParams', [is.string, is.object, is.undefined], value);
         const url = this._internals.url;
         if (value === undefined) {
             this._internals.searchParams = undefined;
@@ -931,7 +967,7 @@ export default class Options {
         return this._internals.dnsLookup;
     }
     set dnsLookup(value) {
-        assert.any([is.function, is.undefined], value);
+        assertAny('dnsLookup', [is.function, is.undefined], value);
         this._internals.dnsLookup = value;
     }
     /**
@@ -948,7 +984,7 @@ export default class Options {
         return this._internals.dnsCache;
     }
     set dnsCache(value) {
-        assert.any([is.object, is.boolean, is.undefined], value);
+        assertAny('dnsCache', [is.object, is.boolean, is.undefined], value);
         if (value === true) {
             this._internals.dnsCache = getGlobalDnsCache();
         }
@@ -1018,7 +1054,7 @@ export default class Options {
             }
             const typedKnownHookEvent = knownHookEvent;
             const hooks = value[typedKnownHookEvent];
-            assert.any([is.array, is.undefined], hooks);
+            assertAny(`hooks.${knownHookEvent}`, [is.array, is.undefined], hooks);
             if (hooks) {
                 for (const hook of hooks) {
                     assert.function(hook);
@@ -1053,7 +1089,7 @@ export default class Options {
         return this._internals.followRedirect;
     }
     set followRedirect(value) {
-        assert.any([is.boolean, is.function], value);
+        assertAny('followRedirect', [is.boolean, is.function], value);
         this._internals.followRedirect = value;
     }
     get followRedirects() {
@@ -1083,7 +1119,7 @@ export default class Options {
         return this._internals.cache;
     }
     set cache(value) {
-        assert.any([is.object, is.string, is.boolean, is.undefined], value);
+        assertAny('cache', [is.object, is.string, is.boolean, is.undefined], value);
         if (value === true) {
             this._internals.cache = globalCache;
         }
@@ -1196,7 +1232,7 @@ export default class Options {
         return this._internals.headers;
     }
     set headers(value) {
-        assert.plainObject(value);
+        assertPlainObject('headers', value);
         if (this._merging) {
             Object.assign(this._internals.headers, lowercaseKeys(value));
         }
@@ -1340,15 +1376,15 @@ export default class Options {
         return this._internals.retry;
     }
     set retry(value) {
-        assert.plainObject(value);
-        assert.any([is.function, is.undefined], value.calculateDelay);
-        assert.any([is.number, is.undefined], value.maxRetryAfter);
-        assert.any([is.number, is.undefined], value.limit);
-        assert.any([is.array, is.undefined], value.methods);
-        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);
+        assertPlainObject('retry', value);
+        assertAny('retry.calculateDelay', [is.function, is.undefined], value.calculateDelay);
+        assertAny('retry.maxRetryAfter', [is.number, is.undefined], value.maxRetryAfter);
+        assertAny('retry.limit', [is.number, is.undefined], value.limit);
+        assertAny('retry.methods', [is.array, is.undefined], value.methods);
+        assertAny('retry.statusCodes', [is.array, is.undefined], value.statusCodes);
+        assertAny('retry.errorCodes', [is.array, is.undefined], value.errorCodes);
+        assertAny('retry.noise', [is.number, is.undefined], value.noise);
+        assertAny('retry.enforceRetryRules', [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}`);
         }
@@ -1377,7 +1413,7 @@ export default class Options {
         return this._internals.localAddress;
     }
     set localAddress(value) {
-        assert.any([is.string, is.undefined], value);
+        assertAny('localAddress', [is.string, is.undefined], value);
         this._internals.localAddress = value;
     }
     /**
@@ -1396,7 +1432,7 @@ export default class Options {
         return this._internals.createConnection;
     }
     set createConnection(value) {
-        assert.any([is.function, is.undefined], value);
+        assertAny('createConnection', [is.function, is.undefined], value);
         this._internals.createConnection = value;
     }
     /**
@@ -1408,11 +1444,11 @@ export default class Options {
         return this._internals.cacheOptions;
     }
     set cacheOptions(value) {
-        assert.plainObject(value);
-        assert.any([is.boolean, is.undefined], value.shared);
-        assert.any([is.number, is.undefined], value.cacheHeuristic);
-        assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
-        assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
+        assertPlainObject('cacheOptions', value);
+        assertAny('cacheOptions.shared', [is.boolean, is.undefined], value.shared);
+        assertAny('cacheOptions.cacheHeuristic', [is.number, is.undefined], value.cacheHeuristic);
+        assertAny('cacheOptions.immutableMinTimeToLive', [is.number, is.undefined], value.immutableMinTimeToLive);
+        assertAny('cacheOptions.ignoreCargoCult', [is.boolean, is.undefined], value.ignoreCargoCult);
         for (const key in value) {
             if (!(key in this._internals.cacheOptions)) {
                 throw new Error(`Cache option \`${key}\` does not exist`);
@@ -1432,25 +1468,26 @@ export default class Options {
         return this._internals.https;
     }
     set https(value) {
-        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);
-        assert.any([is.string, is.undefined], value.passphrase);
-        assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
-        assert.any([is.array, is.undefined], value.alpnProtocols);
-        assert.any([is.string, is.undefined], value.ciphers);
-        assert.any([is.string, is.buffer, is.undefined], value.dhparam);
-        assert.any([is.string, is.undefined], value.signatureAlgorithms);
-        assert.any([is.string, is.undefined], value.minVersion);
-        assert.any([is.string, is.undefined], value.maxVersion);
-        assert.any([is.boolean, is.undefined], value.honorCipherOrder);
-        assert.any([is.number, is.undefined], value.tlsSessionLifetime);
-        assert.any([is.string, is.undefined], value.ecdhCurve);
-        assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
+        assertPlainObject('https', value);
+        assertAny('https.rejectUnauthorized', [is.boolean, is.undefined], value.rejectUnauthorized);
+        assertAny('https.checkServerIdentity', [is.function, is.undefined], value.checkServerIdentity);
+        assertAny('https.serverName', [is.string, is.undefined], value.serverName);
+        assertAny('https.certificateAuthority', [is.string, is.object, is.array, is.undefined], value.certificateAuthority);
+        assertAny('https.key', [is.string, is.object, is.array, is.undefined], value.key);
+        assertAny('https.certificate', [is.string, is.object, is.array, is.undefined], value.certificate);
+        assertAny('https.passphrase', [is.string, is.undefined], value.passphrase);
+        assertAny('https.pfx', [is.string, is.buffer, is.array, is.undefined], value.pfx);
+        assertAny('https.alpnProtocols', [is.array, is.undefined], value.alpnProtocols);
+        assertAny('https.ciphers', [is.string, is.undefined], value.ciphers);
+        assertAny('https.dhparam', [is.string, is.buffer, is.undefined], value.dhparam);
+        assertAny('https.signatureAlgorithms', [is.string, is.undefined], value.signatureAlgorithms);
+        assertAny('https.minVersion', [is.string, is.undefined], value.minVersion);
+        assertAny('https.maxVersion', [is.string, is.undefined], value.maxVersion);
+        assertAny('https.honorCipherOrder', [is.boolean, is.undefined], value.honorCipherOrder);
+        assertAny('https.tlsSessionLifetime', [is.number, is.undefined], value.tlsSessionLifetime);
+        assertAny('https.ecdhCurve', [is.string, is.undefined], value.ecdhCurve);
+        assertAny('https.certificateRevocationLists', [is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
+        assertAny('https.secureOptions', [is.number, is.undefined], value.secureOptions);
         for (const key in value) {
             if (!(key in this._internals.https)) {
                 throw new Error(`HTTPS option \`${key}\` does not exist`);
@@ -1480,7 +1517,7 @@ export default class Options {
         if (value === null) {
             throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
         }
-        assert.any([is.string, is.undefined], value);
+        assertAny('encoding', [is.string, is.undefined], value);
         this._internals.encoding = value;
     }
     /**
@@ -1580,7 +1617,7 @@ export default class Options {
         return this._internals.maxHeaderSize;
     }
     set maxHeaderSize(value) {
-        assert.any([is.number, is.undefined], value);
+        assertAny('maxHeaderSize', [is.number, is.undefined], value);
         this._internals.maxHeaderSize = value;
     }
     get enableUnixSockets() {
@@ -1590,6 +1627,23 @@ export default class Options {
         assert.boolean(value);
         this._internals.enableUnixSockets = value;
     }
+    /**
+    Throw an error if the server response's `content-length` header value doesn't match the number of bytes received.
+
+    This is useful for detecting truncated responses and follows RFC 9112 requirements for message completeness.
+
+    __Note__: Responses without a `content-length` header are not validated.
+    __Note__: When enabled and validation fails, a `ReadError` with code `ERR_HTTP_CONTENT_LENGTH_MISMATCH` will be thrown.
+
+    @default false
+    */
+    get strictContentLength() {
+        return this._internals.strictContentLength;
+    }
+    set strictContentLength(value) {
+        assert.boolean(value);
+        this._internals.strictContentLength = value;
+    }
     // eslint-disable-next-line @typescript-eslint/naming-convention
     toJSON() {
         return { ...this._internals };
@@ -1648,6 +1702,7 @@ export default class Options {
             dhparam: https.dhparam,
             ecdhCurve: https.ecdhCurve,
             crl: https.certificateRevocationLists,
+            secureOptions: https.secureOptions,
             // HTTP options
             lookup: internals.dnsLookup ?? internals.dnsCache?.lookup,
             family: internals.dnsLookupIpVersion,

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

@@ -15,6 +15,9 @@ export default async function getBodySize(body, headers) {
     if (is.buffer(body)) {
         return body.length;
     }
+    if (is.typedArray(body)) {
+        return body.byteLength;
+    }
     if (isFormData(body)) {
         try {
             return await promisify(body.getLength.bind(body))();

package/dist/source/core/utils/is-unix-socket-url.d.ts

@@ -1 +1,17 @@
 export default function isUnixSocketURL(url: URL): boolean;
+/**
+Extract the socket path from a UNIX socket URL.
+
+@example
+```
+getUnixSocketPath(new URL('http://unix/foo:/path'));
+//=> '/foo'
+
+getUnixSocketPath(new URL('unix:/foo:/path'));
+//=> '/foo'
+
+getUnixSocketPath(new URL('http://example.com'));
+//=> undefined
+```
+*/
+export declare function getUnixSocketPath(url: URL): string | undefined;

package/dist/source/core/utils/is-unix-socket-url.js

@@ -2,3 +2,24 @@
 export default function isUnixSocketURL(url) {
     return url.protocol === 'unix:' || url.hostname === 'unix';
 }
+/**
+Extract the socket path from a UNIX socket URL.
+
+@example
+```
+getUnixSocketPath(new URL('http://unix/foo:/path'));
+//=> '/foo'
+
+getUnixSocketPath(new URL('unix:/foo:/path'));
+//=> '/foo'
+
+getUnixSocketPath(new URL('http://example.com'));
+//=> undefined
+```
+*/
+export function getUnixSocketPath(url) {
+    if (!isUnixSocketURL(url)) {
+        return undefined;
+    }
+    return /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`)?.groups?.socketPath;
+}

package/dist/source/create.js

@@ -139,7 +139,15 @@ const create = (defaults) => {
             }
             else {
                 normalizedOptions.merge(optionsToMerge);
-                assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
+                try {
+                    assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        error.message = `Option 'pagination.paginate.url': ${error.message}`;
+                    }
+                    throw error;
+                }
                 if (optionsToMerge.url !== undefined) {
                     normalizedOptions.prefixUrl = '';
                     normalizedOptions.url = optionsToMerge.url;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "14.5.0",
+	"version": "14.6.0",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -16,6 +16,7 @@
 	},
 	"scripts": {
 		"test": "xo && tsc --noEmit && NODE_OPTIONS='--import=tsx/esm' ava",
+		"test:coverage": "xo && tsc --noEmit && NODE_OPTIONS='--import=tsx/esm' c8 ava",
 		"release": "np",
 		"build": "del-cli dist && tsc",
 		"prepare": "npm run build"
@@ -40,6 +41,8 @@
 		"network",
 		"gzip",
 		"brotli",
+		"zstd",
+		"zstandard",
 		"requests",
 		"human-friendly",
 		"axios",
@@ -52,7 +55,7 @@
 		"@szmarczak/http-timer": "^5.0.1",
 		"cacheable-lookup": "^7.0.0",
 		"cacheable-request": "^13.0.12",
-		"decompress-response": "^6.0.0",
+		"decompress-response": "^10.0.0",
 		"form-data-encoder": "^4.0.2",
 		"http2-wrapper": "^2.2.1",
 		"keyv": "^5.5.3",
@@ -78,6 +81,7 @@
 		"benchmark": "^2.1.4",
 		"bluebird": "^3.7.2",
 		"body-parser": "^1.20.3",
+		"c8": "^10.1.3",
 		"create-cert": "^1.0.6",
 		"create-test-server": "^3.0.1",
 		"del-cli": "^6.0.0",
@@ -90,7 +94,6 @@
 		"nock": "^13.5.5",
 		"node-fetch": "^3.3.2",
 		"np": "^10.0.5",
-		"nyc": "^17.1.0",
 		"p-event": "^6.0.1",
 		"pem": "^1.14.8",
 		"pify": "^6.1.0",
@@ -117,17 +120,15 @@
 		},
 		"workerThreads": false
 	},
-	"nyc": {
+	"c8": {
 		"reporter": [
 			"text",
 			"html",
 			"lcov"
 		],
-		"extension": [
-			".ts"
-		],
 		"exclude": [
-			"**/test/**"
+			"test/**",
+			"dist/**"
 		]
 	},
 	"xo": {

package/readme.md

@@ -127,6 +127,7 @@ By default, Got will retry on failure. To disable this option, set [`options.ret
 
 #### Integration
 
+- [x] [Diagnostics Channel](documentation/diagnostics-channel.md)
 - [x] [TypeScript support](documentation/typescript.md)
 - [x] [AWS](documentation/tips.md#aws)
 - [x] [Testing](documentation/tips.md#testing)