deps: update undici to 6.20.0

PR-URL: #55329
Reviewed-By: Matteo Collina <[email protected]>
Reviewed-By: Michael Dawson <[email protected]>
Reviewed-By: Trivikram Kamat <[email protected]>
Reviewed-By: Matthew Aitken <[email protected]>
Reviewed-By: Rafael Gonzaga <[email protected]>

Author: nodejs-github-bot

deps/undici/src/.gitignore

@@ -84,3 +84,6 @@ undici-fetch.js
 .npmrc
 
 .tap
+
+# File generated by /test/request-timeout.js
+test/request-timeout.10mb.bin

deps/undici/src/.npmignore

@@ -11,3 +11,6 @@ lib/llhttp/llhttp.wasm
 !index.d.ts
 !docs/docs/**/*
 !scripts/strip-comments.js
+
+# File generated by /test/request-timeout.js
+test/request-timeout.10mb.bin

deps/undici/src/docs/docs/api/Dispatcher.md

@@ -984,6 +984,203 @@ client.dispatch(
 );
 ```
 
+##### `Response Error Interceptor`
+
+**Introduction**
+
+The Response Error Interceptor is designed to handle HTTP response errors efficiently. It intercepts responses and throws detailed errors for responses with status codes indicating failure (4xx, 5xx). This interceptor enhances error handling by providing structured error information, including response headers, data, and status codes.
+
+**ResponseError Class**
+
+The `ResponseError` class extends the `UndiciError` class and encapsulates detailed error information. It captures the response status code, headers, and data, providing a structured way to handle errors.
+
+**Definition**
+
+```js
+class ResponseError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message);
+    this.name = 'ResponseError';
+    this.message = message || 'Response error';
+    this.code = 'UND_ERR_RESPONSE';
+    this.statusCode = code;
+    this.data = data;
+    this.headers = headers;
+  }
+}
+```
+
+**Interceptor Handler**
+
+The interceptor's handler class extends `DecoratorHandler` and overrides methods to capture response details and handle errors based on the response status code.
+
+**Methods**
+
+- **onConnect**: Initializes response properties.
+- **onHeaders**: Captures headers and status code. Decodes body if content type is `application/json` or `text/plain`.
+- **onData**: Appends chunks to the body if status code indicates an error.
+- **onComplete**: Finalizes error handling, constructs a `ResponseError`, and invokes the `onError` method.
+- **onError**: Propagates errors to the handler.
+
+**Definition**
+
+```js
+class Handler extends DecoratorHandler {
+  // Private properties
+  #handler;
+  #statusCode;
+  #contentType;
+  #decoder;
+  #headers;
+  #body;
+
+  constructor (opts, { handler }) {
+    super(handler);
+    this.#handler = handler;
+  }
+
+  onConnect (abort) {
+    this.#statusCode = 0;
+    this.#contentType = null;
+    this.#decoder = null;
+    this.#headers = null;
+    this.#body = '';
+    return this.#handler.onConnect(abort);
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
+    this.#statusCode = statusCode;
+    this.#headers = headers;
+    this.#contentType = headers['content-type'];
+
+    if (this.#statusCode < 400) {
+      return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers);
+    }
+
+    if (this.#contentType === 'application/json' || this.#contentType === 'text/plain') {
+      this.#decoder = new TextDecoder('utf-8');
+    }
+  }
+
+  onData (chunk) {
+    if (this.#statusCode < 400) {
+      return this.#handler.onData(chunk);
+    }
+    this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? '';
+  }
+
+  onComplete (rawTrailers) {
+    if (this.#statusCode >= 400) {
+      this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? '';
+      if (this.#contentType === 'application/json') {
+        try {
+          this.#body = JSON.parse(this.#body);
+        } catch {
+          // Do nothing...
+        }
+      }
+
+      let err;
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        err = new ResponseError('Response Error', this.#statusCode, this.#headers, this.#body);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+
+      this.#handler.onError(err);
+    } else {
+      this.#handler.onComplete(rawTrailers);
+    }
+  }
+
+  onError (err) {
+    this.#handler.onError(err);
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) => opts.throwOnError
+  ? dispatch(opts, new Handler(opts, { handler }))
+  : dispatch(opts, handler);
+```
+
+**Tests**
+
+Unit tests ensure the interceptor functions correctly, handling both error and non-error responses appropriately.
+
+**Example Tests**
+
+- **No Error if `throwOnError` is False**:
+
+```js
+test('should not error if request is not meant to throw error', async (t) => {
+  const opts = { throwOnError: false };
+  const handler = { onError: () => {}, onData: () => {}, onComplete: () => {} };
+  const interceptor = createResponseErrorInterceptor((opts, handler) => handler.onComplete());
+  assert.doesNotThrow(() => interceptor(opts, handler));
+});
+```
+
+- **Error if Status Code is in Specified Error Codes**:
+
+```js
+test('should error if request status code is in the specified error codes', async (t) => {
+  const opts = { throwOnError: true, statusCodes: [500] };
+  const response = { statusCode: 500 };
+  let capturedError;
+  const handler = {
+    onError: (err) => { capturedError = err; },
+    onData: () => {},
+    onComplete: () => {}
+  };
+
+  const interceptor = createResponseErrorInterceptor((opts, handler) => {
+    if (opts.throwOnError && opts.statusCodes.includes(response.statusCode)) {
+      handler.onError(new Error('Response Error'));
+    } else {
+      handler.onComplete();
+    }
+  });
+
+  interceptor({ ...opts, response }, handler);
+
+  await new Promise(resolve => setImmediate(resolve));
+
+  assert(capturedError, 'Expected error to be captured but it was not.');
+  assert.strictEqual(capturedError.message, 'Response Error');
+  assert.strictEqual(response.statusCode, 500);
+});
+```
+
+- **No Error if Status Code is Not in Specified Error Codes**:
+
+```js
+test('should not error if request status code is not in the specified error codes', async (t) => {
+  const opts = { throwOnError: true, statusCodes: [500] };
+  const response = { statusCode: 404 };
+  const handler = {
+    onError: () => {},
+    onData: () => {},
+    onComplete: () => {}
+  };
+
+  const interceptor = createResponseErrorInterceptor((opts, handler) => {
+    if (opts.throwOnError && opts.statusCodes.includes(response.statusCode)) {
+      handler.onError(new Error('Response Error'));
+    } else {
+      handler.onComplete();
+    }
+  });
+
+  assert.doesNotThrow(() => interceptor({ ...opts, response }, handler));
+});
+```
+
+**Conclusion**
+
+The Response Error Interceptor provides a robust mechanism for handling HTTP response errors by capturing detailed error information and propagating it through a structured `ResponseError` class. This enhancement improves error handling and debugging capabilities in applications using the interceptor.
+
 ## Instance Events
 
 ### Event: `'connect'`

deps/undici/src/docs/docs/api/RetryHandler.md

@@ -19,7 +19,7 @@ Extends: [`Dispatch.DispatchOptions`](Dispatcher.md#parameter-dispatchoptions).
 
 #### `RetryOptions`
 
-- **retry** `(err: Error, context: RetryContext, callback: (err?: Error | null) => void) => void` (optional) - Function to be called after every retry. It should pass error if no more retries should be performed.
+- **retry** `(err: Error, context: RetryContext, callback: (err?: Error | null) => void) => number | null` (optional) - Function to be called after every retry. It should pass error if no more retries should be performed.
 - **maxRetries** `number` (optional) - Maximum number of retries. Default: `5`
 - **maxTimeout** `number` (optional) - Maximum number of milliseconds to wait before retrying. Default: `30000` (30 seconds)
 - **minTimeout** `number` (optional) - Minimum number of milliseconds to wait before retrying. Default: `500` (half a second)

deps/undici/src/lib/api/api-upgrade.js

@@ -50,9 +50,9 @@ class UpgradeHandler extends AsyncResource {
   }
 
   onUpgrade (statusCode, rawHeaders, socket) {
-    const { callback, opaque, context } = this
+    assert(statusCode === 101)
 
-    assert.strictEqual(statusCode, 101)
+    const { callback, opaque, context } = this
 
     removeSignal(this)
 

deps/undici/src/lib/core/connect.js

@@ -4,6 +4,9 @@ const net = require('node:net')
 const assert = require('node:assert')
 const util = require('./util')
 const { InvalidArgumentError, ConnectTimeoutError } = require('./errors')
+const timers = require('../util/timers')
+
+function noop () {}
 
 let tls // include tls conditionally since it is not always available
 
@@ -91,9 +94,11 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
       servername = servername || options.servername || util.getServerName(host) || null
 
       const sessionKey = servername || hostname
+      assert(sessionKey)
+
       const session = customSession || sessionCache.get(sessionKey) || null
 
-      assert(sessionKey)
+      port = port || 443
 
       socket = tls.connect({
         highWaterMark: 16384, // TLS in node can't have bigger HWM anyway...
@@ -104,7 +109,7 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
         // TODO(HTTP/2): Add support for h2c
         ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'],
         socket: httpSocket, // upgrade socket connection
-        port: port || 443,
+        port,
         host: hostname
       })
 
@@ -115,11 +120,14 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
         })
     } else {
       assert(!httpSocket, 'httpSocket can only be sent on TLS update')
+
+      port = port || 80
+
       socket = net.connect({
         highWaterMark: 64 * 1024, // Same as nodejs fs streams.
         ...options,
         localAddress,
-        port: port || 80,
+        port,
         host: hostname
       })
     }
@@ -130,12 +138,12 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
       socket.setKeepAlive(true, keepAliveInitialDelay)
     }
 
-    const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout)
+    const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
 
     socket
       .setNoDelay(true)
       .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () {
-        cancelTimeout()
+        queueMicrotask(clearConnectTimeout)
 
         if (callback) {
           const cb = callback
@@ -144,7 +152,7 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
         }
       })
       .on('error', function (err) {
-        cancelTimeout()
+        queueMicrotask(clearConnectTimeout)
 
         if (callback) {
           const cb = callback
@@ -157,36 +165,70 @@ function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, sess
   }
 }
 
-function setupTimeout (onConnectTimeout, timeout) {
-  if (!timeout) {
-    return () => {}
-  }
+/**
+ * @param {WeakRef<net.Socket>} socketWeakRef
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ * @returns {() => void}
+ */
+const setupConnectTimeout = process.platform === 'win32'
+  ? (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
 
-  let s1 = null
-  let s2 = null
-  const timeoutId = setTimeout(() => {
-    // setImmediate is added to make sure that we prioritize socket error events over timeouts
-    s1 = setImmediate(() => {
-      if (process.platform === 'win32') {
+      let s1 = null
+      let s2 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
         // Windows needs an extra setImmediate probably due to implementation differences in the socket logic
-        s2 = setImmediate(() => onConnectTimeout())
-      } else {
-        onConnectTimeout()
+          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts))
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+        clearImmediate(s2)
+      }
+    }
+  : (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
       }
-    })
-  }, timeout)
-  return () => {
-    clearTimeout(timeoutId)
-    clearImmediate(s1)
-    clearImmediate(s2)
-  }
-}
 
-function onConnectTimeout (socket) {
+      let s1 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+          onConnectTimeout(socketWeakRef.deref(), opts)
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+      }
+    }
+
+/**
+ * @param {net.Socket} socket
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ */
+function onConnectTimeout (socket, opts) {
   let message = 'Connect Timeout Error'
   if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
-    message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')})`
+    message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`
+  } else {
+    message += ` (attempted address: ${opts.hostname}:${opts.port},`
   }
+
+  message += ` timeout: ${opts.timeout}ms)`
+
   util.destroy(socket, new ConnectTimeoutError(message))
 }
 

deps/undici/src/lib/core/errors.js

@@ -195,6 +195,18 @@ class RequestRetryError extends UndiciError {
   }
 }
 
+class ResponseError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'ResponseError'
+    this.message = message || 'Response error'
+    this.code = 'UND_ERR_RESPONSE'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+}
+
 class SecureProxyConnectionError extends UndiciError {
   constructor (cause, message, options) {
     super(message, { cause, ...(options ?? {}) })
@@ -227,5 +239,6 @@ module.exports = {
   BalancedPoolMissingUpstreamError,
   ResponseExceededMaxSizeError,
   RequestRetryError,
+  ResponseError,
   SecureProxyConnectionError
 }

deps/undici/src/lib/core/util.js

@@ -233,7 +233,7 @@ function getServerName (host) {
     return null
   }
 
-  assert.strictEqual(typeof host, 'string')
+  assert(typeof host === 'string')
 
   const servername = getHostname(host)
   if (net.isIP(servername)) {

deps/undici/src/lib/dispatcher/client-h1.js

@@ -85,35 +85,35 @@ async function lazyllhttp () {
         return 0
       },
       wasm_on_status: (p, at, len) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
         return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
       wasm_on_message_begin: (p) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         return currentParser.onMessageBegin() || 0
       },
       wasm_on_header_field: (p, at, len) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
         return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
       wasm_on_header_value: (p, at, len) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
         return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
       wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0
       },
       wasm_on_body: (p, at, len) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
         return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
       wasm_on_message_complete: (p) => {
-        assert.strictEqual(currentParser.ptr, p)
+        assert(currentParser.ptr === p)
         return currentParser.onMessageComplete() || 0
       }
 
@@ -131,9 +131,17 @@ let currentBufferRef = null
 let currentBufferSize = 0
 let currentBufferPtr = null
 
-const TIMEOUT_HEADERS = 1
-const TIMEOUT_BODY = 2
-const TIMEOUT_IDLE = 3
+const USE_NATIVE_TIMER = 0
+const USE_FAST_TIMER = 1
+
+// Use fast timers for headers and body to take eventual event loop
+// latency into account.
+const TIMEOUT_HEADERS = 2 | USE_FAST_TIMER
+const TIMEOUT_BODY = 4 | USE_FAST_TIMER
+
+// Use native timers to ignore event loop latency for keep-alive
+// handling.
+const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
 
 class Parser {
   constructor (client, socket, { exports }) {
@@ -164,26 +172,39 @@ class Parser {
     this.maxResponseSize = client[kMaxResponseSize]
   }
 
-  setTimeout (value, type) {
-    this.timeoutType = type
-    if (value !== this.timeoutValue) {
-      timers.clearTimeout(this.timeout)
-      if (value) {
-        this.timeout = timers.setTimeout(onParserTimeout, value, this)
-        // istanbul ignore else: only for jest
-        if (this.timeout.unref) {
+  setTimeout (delay, type) {
+    // If the existing timer and the new timer are of different timer type
+    // (fast or native) or have different delay, we need to clear the existing
+    // timer and set a new one.
+    if (
+      delay !== this.timeoutValue ||
+      (type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)
+    ) {
+      // If a timeout is already set, clear it with clearTimeout of the fast
+      // timer implementation, as it can clear fast and native timers.
+      if (this.timeout) {
+        timers.clearTimeout(this.timeout)
+        this.timeout = null
+      }
+
+      if (delay) {
+        if (type & USE_FAST_TIMER) {
+          this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this))
+        } else {
+          this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this))
           this.timeout.unref()
         }
-      } else {
-        this.timeout = null
       }
-      this.timeoutValue = value
+
+      this.timeoutValue = delay
     } else if (this.timeout) {
       // istanbul ignore else: only for jest
       if (this.timeout.refresh) {
         this.timeout.refresh()
       }
     }
+
+    this.timeoutType = type
   }
 
   resume () {
@@ -288,7 +309,7 @@ class Parser {
     this.llhttp.llhttp_free(this.ptr)
     this.ptr = null
 
-    timers.clearTimeout(this.timeout)
+    this.timeout && timers.clearTimeout(this.timeout)
     this.timeout = null
     this.timeoutValue = null
     this.timeoutType = null
@@ -363,20 +384,19 @@ class Parser {
     const { upgrade, client, socket, headers, statusCode } = this
 
     assert(upgrade)
+    assert(client[kSocket] === socket)
+    assert(!socket.destroyed)
+    assert(!this.paused)
+    assert((headers.length & 1) === 0)
 
     const request = client[kQueue][client[kRunningIdx]]
     assert(request)
-
-    assert(!socket.destroyed)
-    assert(socket === client[kSocket])
-    assert(!this.paused)
     assert(request.upgrade || request.method === 'CONNECT')
 
     this.statusCode = null
     this.statusText = ''
     this.shouldKeepAlive = null
 
-    assert(this.headers.length % 2 === 0)
     this.headers = []
     this.headersSize = 0
 
@@ -433,7 +453,7 @@ class Parser {
       return -1
     }
 
-    assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS)
+    assert(this.timeoutType === TIMEOUT_HEADERS)
 
     this.statusCode = statusCode
     this.shouldKeepAlive = (
@@ -466,7 +486,7 @@ class Parser {
       return 2
     }
 
-    assert(this.headers.length % 2 === 0)
+    assert((this.headers.length & 1) === 0)
     this.headers = []
     this.headersSize = 0
 
@@ -523,7 +543,7 @@ class Parser {
     const request = client[kQueue][client[kRunningIdx]]
     assert(request)
 
-    assert.strictEqual(this.timeoutType, TIMEOUT_BODY)
+    assert(this.timeoutType === TIMEOUT_BODY)
     if (this.timeout) {
       // istanbul ignore else: only for jest
       if (this.timeout.refresh) {
@@ -556,19 +576,19 @@ class Parser {
       return
     }
 
+    assert(statusCode >= 100)
+    assert((this.headers.length & 1) === 0)
+
     const request = client[kQueue][client[kRunningIdx]]
     assert(request)
 
-    assert(statusCode >= 100)
-
     this.statusCode = null
     this.statusText = ''
     this.bytesRead = 0
     this.contentLength = ''
     this.keepAlive = ''
     this.connection = ''
 
-    assert(this.headers.length % 2 === 0)
     this.headers = []
     this.headersSize = 0
 
@@ -587,7 +607,7 @@ class Parser {
     client[kQueue][client[kRunningIdx]++] = null
 
     if (socket[kWriting]) {
-      assert.strictEqual(client[kRunning], 0)
+      assert(client[kRunning] === 0)
       // Response completed before request.
       util.destroy(socket, new InformationalError('reset'))
       return constants.ERROR.PAUSED
@@ -613,19 +633,19 @@ class Parser {
 }
 
 function onParserTimeout (parser) {
-  const { socket, timeoutType, client } = parser
+  const { socket, timeoutType, client, paused } = parser.deref()
 
   /* istanbul ignore else */
   if (timeoutType === TIMEOUT_HEADERS) {
     if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
-      assert(!parser.paused, 'cannot be paused while waiting for headers')
+      assert(!paused, 'cannot be paused while waiting for headers')
       util.destroy(socket, new HeadersTimeoutError())
     }
   } else if (timeoutType === TIMEOUT_BODY) {
-    if (!parser.paused) {
+    if (!paused) {
       util.destroy(socket, new BodyTimeoutError())
     }
-  } else if (timeoutType === TIMEOUT_IDLE) {
+  } else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
     assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue])
     util.destroy(socket, new InformationalError('socket idle timeout'))
   }
@@ -646,10 +666,10 @@ async function connectH1 (client, socket) {
   socket[kParser] = new Parser(client, socket, llhttpInstance)
 
   addListener(socket, 'error', function (err) {
-    const parser = this[kParser]
-
     assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
 
+    const parser = this[kParser]
+
     // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
     // to the user.
     if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
@@ -803,8 +823,8 @@ function resumeH1 (client) {
     }
 
     if (client[kSize] === 0) {
-      if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
-        socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE)
+      if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) {
+        socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE)
       }
     } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
       if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {

deps/undici/src/lib/dispatcher/client.js

@@ -385,6 +385,10 @@ function onError (client, err) {
   }
 }
 
+/**
+ * @param {Client} client
+ * @returns
+ */
 async function connect (client) {
   assert(!client[kConnecting])
   assert(!client[kHTTPContext])

deps/undici/src/lib/handler/retry-handler.js

@@ -192,8 +192,18 @@ class RetryHandler {
     if (this.resume != null) {
       this.resume = null
 
-      if (statusCode !== 206) {
-        return true
+      // Only Partial Content 206 supposed to provide Content-Range,
+      // any other status code that partially consumed the payload
+      // should not be retry because it would result in downstream
+      // wrongly concatanete multiple responses.
+      if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) {
+        this.abort(
+          new RequestRetryError('server does not support the range header and the payload was partially consumed', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
       }
 
       const contentRange = parseRangeHeader(headers['content-range'])

deps/undici/src/lib/interceptor/response-error.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const { parseHeaders } = require('../core/util')
+const DecoratorHandler = require('../handler/decorator-handler')
+const { ResponseError } = require('../core/errors')
+
+class Handler extends DecoratorHandler {
+  #handler
+  #statusCode
+  #contentType
+  #decoder
+  #headers
+  #body
+
+  constructor (opts, { handler }) {
+    super(handler)
+    this.#handler = handler
+  }
+
+  onConnect (abort) {
+    this.#statusCode = 0
+    this.#contentType = null
+    this.#decoder = null
+    this.#headers = null
+    this.#body = ''
+
+    return this.#handler.onConnect(abort)
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
+    this.#statusCode = statusCode
+    this.#headers = headers
+    this.#contentType = headers['content-type']
+
+    if (this.#statusCode < 400) {
+      return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage, headers)
+    }
+
+    if (this.#contentType === 'application/json' || this.#contentType === 'text/plain') {
+      this.#decoder = new TextDecoder('utf-8')
+    }
+  }
+
+  onData (chunk) {
+    if (this.#statusCode < 400) {
+      return this.#handler.onData(chunk)
+    }
+
+    this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
+  }
+
+  onComplete (rawTrailers) {
+    if (this.#statusCode >= 400) {
+      this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
+
+      if (this.#contentType === 'application/json') {
+        try {
+          this.#body = JSON.parse(this.#body)
+        } catch {
+          // Do nothing...
+        }
+      }
+
+      let err
+      const stackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      try {
+        err = new ResponseError('Response Error', this.#statusCode, this.#headers, this.#body)
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit
+      }
+
+      this.#handler.onError(err)
+    } else {
+      this.#handler.onComplete(rawTrailers)
+    }
+  }
+
+  onError (err) {
+    this.#handler.onError(err)
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) => opts.throwOnError
+  ? dispatch(opts, new Handler(opts, { handler }))
+  : dispatch(opts, handler)

deps/undici/src/lib/llhttp/wasm_build_env.txt

@@ -1,12 +1,12 @@
 
-> undici@6.19.8 prebuild:wasm
+> undici@6.20.0 prebuild:wasm
 > node build/wasm.js --prebuild
 
 > docker build --platform=linux/x86_64 -t llhttp_wasm_builder -f /home/runner/work/node/node/deps/undici/src/build/Dockerfile /home/runner/work/node/node/deps/undici/src
 
 
 
-> undici@6.19.8 build:wasm
+> undici@6.20.0 build:wasm
 > node build/wasm.js --docker
 
 > docker run --rm -t --platform=linux/x86_64 --user 1001:127 --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/lib/llhttp,target=/home/node/undici/lib/llhttp llhttp_wasm_builder node build/wasm.js

deps/undici/src/lib/mock/mock-utils.js

@@ -118,6 +118,10 @@ function matchKey (mockDispatch, { path, method, body, headers }) {
 function getResponseData (data) {
   if (Buffer.isBuffer(data)) {
     return data
+  } else if (data instanceof Uint8Array) {
+    return data
+  } else if (data instanceof ArrayBuffer) {
+    return data
   } else if (typeof data === 'object') {
     return JSON.stringify(data)
   } else {

deps/undici/src/lib/util/timers.js

@@ -87,11 +87,21 @@ function multipartFormDataParser (input, mimeType) {
   //    the first byte.
   const position = { position: 0 }
 
-  // Note: undici addition, allow \r\n before the body.
-  if (input[0] === 0x0d && input[1] === 0x0a) {
+  // Note: undici addition, allows leading and trailing CRLFs.
+  while (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
     position.position += 2
   }
 
+  let trailing = input.length
+
+  while (input[trailing - 1] === 0x0a && input[trailing - 2] === 0x0d) {
+    trailing -= 2
+  }
+
+  if (trailing !== input.length) {
+    input = input.subarray(0, trailing)
+  }
+
   // 5. While true:
   while (true) {
     // 5.1. If position points to a sequence of bytes starting with 0x2D 0x2D

deps/undici/src/lib/web/fetch/formdata-parser.js

@@ -2150,23 +2150,35 @@ async function httpNetworkFetch (
                   finishFlush: zlib.constants.Z_SYNC_FLUSH
                 }))
               } else if (coding === 'deflate') {
-                decoders.push(createInflate())
+                decoders.push(createInflate({
+                  flush: zlib.constants.Z_SYNC_FLUSH,
+                  finishFlush: zlib.constants.Z_SYNC_FLUSH
+                }))
               } else if (coding === 'br') {
-                decoders.push(zlib.createBrotliDecompress())
+                decoders.push(zlib.createBrotliDecompress({
+                  flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+                  finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
+                }))
               } else {
                 decoders.length = 0
                 break
               }
             }
           }
 
+          const onError = this.onError.bind(this)
+
           resolve({
             status,
             statusText,
             headersList,
             body: decoders.length
-              ? pipeline(this.body, ...decoders, () => { })
-              : this.body.on('error', () => { })
+              ? pipeline(this.body, ...decoders, (err) => {
+                if (err) {
+                  this.onError(err)
+                }
+              }).on('error', onError)
+              : this.body.on('error', onError)
           })
 
           return true

deps/undici/src/lib/web/fetch/index.js

@@ -1339,15 +1339,23 @@ function buildContentRange (rangeStart, rangeEnd, fullLength) {
 // interpreted as a zlib stream, otherwise it's interpreted as a
 // raw deflate stream.
 class InflateStream extends Transform {
+  #zlibOptions
+
+  /** @param {zlib.ZlibOptions} [zlibOptions] */
+  constructor (zlibOptions) {
+    super()
+    this.#zlibOptions = zlibOptions
+  }
+
   _transform (chunk, encoding, callback) {
     if (!this._inflateStream) {
       if (chunk.length === 0) {
         callback()
         return
       }
       this._inflateStream = (chunk[0] & 0x0F) === 0x08
-        ? zlib.createInflate()
-        : zlib.createInflateRaw()
+        ? zlib.createInflate(this.#zlibOptions)
+        : zlib.createInflateRaw(this.#zlibOptions)
 
       this._inflateStream.on('data', this.push.bind(this))
       this._inflateStream.on('end', () => this.push(null))
@@ -1366,8 +1374,12 @@ class InflateStream extends Transform {
   }
 }
 
-function createInflate () {
-  return new InflateStream()
+/**
+ * @param {zlib.ZlibOptions} [zlibOptions]
+ * @returns {InflateStream}
+ */
+function createInflate (zlibOptions) {
+  return new InflateStream(zlibOptions)
 }
 
 /**

deps/undici/src/lib/web/fetch/util.js

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "6.19.8",
+  "version": "6.20.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -105,7 +105,7 @@
     "@fastify/busboy": "2.1.1",
     "@matteo.collina/tspl": "^0.1.1",
     "@sinonjs/fake-timers": "^11.1.0",
-    "@types/node": "^18.0.3",
+    "@types/node": "~18.19.50",
     "abort-controller": "^3.0.0",
     "borp": "^0.15.0",
     "c8": "^10.0.0",

deps/undici/src/package-lock.json

@@ -2,8 +2,6 @@ import { MessageEvent, ErrorEvent } from './websocket'
 import Dispatcher from './dispatcher'
 
 import {
-  EventTarget,
-  Event,
   EventListenerOptions,
   AddEventListenerOptions,
   EventListenerOrEventListenerObject

deps/undici/src/package.json

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 
 import { Blob } from 'buffer'
-import { DOMException, Event, EventInit, EventTarget } from './patch'
+import { DOMException, EventInit } from './patch'
 
 export declare class FileReader {
   __proto__: EventTarget & FileReader

deps/undici/src/types/eventsource.d.ts

@@ -7,9 +7,11 @@ declare namespace Interceptors {
   export type DumpInterceptorOpts = { maxSize?: number }
   export type RetryInterceptorOpts = RetryHandler.RetryOptions
   export type RedirectInterceptorOpts = { maxRedirections?: number }
-  
+  export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
+
   export function createRedirectInterceptor(opts: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dump(opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function retry(opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function redirect(opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function responseError(opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
 }

deps/undici/src/types/filereader.d.ts

@@ -6,44 +6,6 @@ export type DOMException = typeof globalThis extends { DOMException: infer T }
  ? T
  : any
 
-export type EventTarget = typeof globalThis extends { EventTarget: infer T }
-  ? T
-  : {
-    addEventListener(
-      type: string,
-      listener: any,
-      options?: any,
-    ): void
-    dispatchEvent(event: Event): boolean
-    removeEventListener(
-      type: string,
-      listener: any,
-      options?: any | boolean,
-    ): void
-  }
-
-export type Event = typeof globalThis extends { Event: infer T }
-  ? T
-  : {
-    readonly bubbles: boolean
-    cancelBubble: () => void
-    readonly cancelable: boolean
-    readonly composed: boolean
-    composedPath(): [EventTarget?]
-    readonly currentTarget: EventTarget | null
-    readonly defaultPrevented: boolean
-    readonly eventPhase: 0 | 2
-    readonly isTrusted: boolean
-    preventDefault(): void
-    returnValue: boolean
-    readonly srcElement: EventTarget | null
-    stopImmediatePropagation(): void
-    stopPropagation(): void
-    readonly target: EventTarget | null
-    readonly timeStamp: number
-    readonly type: string
-  }
-
 export interface EventInit {
   bubbles?: boolean
   cancelable?: boolean

deps/undici/src/types/interceptors.d.ts

@@ -3,8 +3,6 @@
 import type { Blob } from 'buffer'
 import type { MessagePort } from 'worker_threads'
 import {
-  EventTarget,
-  Event,
   EventInit,
   EventListenerOptions,
   AddEventListenerOptions,

deps/undici/src/types/patch.d.ts

@@ -2,5 +2,5 @@
 // Refer to tools/dep_updaters/update-undici.sh
 #ifndef SRC_UNDICI_VERSION_H_
 #define SRC_UNDICI_VERSION_H_
-#define UNDICI_VERSION "6.19.8"
+#define UNDICI_VERSION "6.20.0"
 #endif  // SRC_UNDICI_VERSION_H_