got 14.4.9 → 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) => {
@@ -68,6 +70,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,10 +78,13 @@ 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))) {
+                        if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
                             throw new TypeError('The `afterResponse` hook returned an invalid value');
                         }
                     }
@@ -93,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;
@@ -108,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

@@ -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>;
@@ -88,18 +88,17 @@ 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?;
     private _bodySize?;
     private _unproxyEvents;
     private _isFromCache?;
-    private _cannotHaveBody;
     private _triggerRead;
     private readonly _jobs;
     private _cancelTimeouts;
@@ -107,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>;
@@ -119,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,6 +1,6 @@
 import process from 'node:process';
 import { Buffer } from 'node:buffer';
-import { Duplex } from 'node:stream';
+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';
@@ -17,10 +17,12 @@ 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']);
+// 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 = [
@@ -31,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'];
@@ -41,23 +54,24 @@ export default class Request extends Duplex {
     requestUrl;
     redirectUrls;
     retryCount;
+    _stopReading;
     _stopRetry;
     _downloadedSize;
     _uploadedSize;
-    _stopReading;
     _pipedServerResponses;
     _request;
     _responseSize;
     _bodySize;
     _unproxyEvents;
     _isFromCache;
-    _cannotHaveBody;
     _triggerRead;
     _cancelTimeouts;
     _removeListeners;
     _nativeResponse;
     _flushed;
     _aborted;
+    _expectedContentLength;
+    _byteCounter;
     // We need this because `this._request` if `undefined` when using cache
     _requestInitialized;
     constructor(url, options, defaults) {
@@ -71,7 +85,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;
@@ -110,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;
         }
@@ -221,19 +245,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));
@@ -356,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);
         }
@@ -374,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;
@@ -382,7 +445,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`);
@@ -463,10 +525,18 @@ export default class Request extends Duplex {
             || statusCode === 205
             || statusCode === 304;
         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);
         }
         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;
@@ -478,10 +548,18 @@ 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);
-        });
+        // 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.
@@ -491,13 +569,15 @@ 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));
+            }
         });
-        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()));
@@ -536,6 +616,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;
@@ -556,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;
                         }
@@ -601,6 +687,33 @@ 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
+        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);
+        });
+        this.emit('downloadProgress', this.downloadProgress);
         response.on('readable', () => {
             if (this._triggerRead) {
                 this._read();
@@ -612,9 +725,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) {
@@ -627,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;
@@ -669,11 +789,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);
@@ -709,7 +837,20 @@ export default class Request extends Duplex {
         if (is.nodeStream(body)) {
             body.pipe(currentRequest);
         }
-        else if (is.generator(body) || is.asyncGenerator(body)) {
+        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 {
                     for await (const chunk of body) {
@@ -722,11 +863,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();
         }
     }
@@ -783,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();
@@ -832,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;
@@ -846,7 +998,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;
@@ -886,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);
@@ -902,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) => {