undici 6.2.1 → 6.3.0

package/README.md

@@ -119,7 +119,7 @@ Returns a promise with the result of the `Dispatcher.request` method.
 
 Calls `options.dispatcher.request(options)`.
 
-See [Dispatcher.request](./docs/api/Dispatcher.md#dispatcherrequestoptions-callback) for more details.
+See [Dispatcher.request](./docs/api/Dispatcher.md#dispatcherrequestoptions-callback) for more details, and [request examples](./examples/README.md) for examples.
 
 ### `undici.stream([url, options, ]factory): Promise`
 

package/docs/api/Debug.md

@@ -0,0 +1,62 @@
+# Debug
+
+Undici (and subsenquently `fetch` and `websocket`) exposes a debug statement that can be enabled by setting `NODE_DEBUG` within the environment.
+
+The flags availabile are:
+
+## `undici`
+
+This flag enables debug statements for the core undici library.
+
+```sh
+NODE_DEBUG=undici node script.js
+
+UNDICI 16241: connecting to nodejs.org using https:h1
+UNDICI 16241: connecting to nodejs.org using https:h1
+UNDICI 16241: connected to nodejs.org using https:h1
+UNDICI 16241: sending request to GET https://nodejs.org//
+UNDICI 16241: received response to GET https://nodejs.org// - HTTP 307
+UNDICI 16241: connecting to nodejs.org using https:h1
+UNDICI 16241: trailers received from GET https://nodejs.org//
+UNDICI 16241: connected to nodejs.org using https:h1
+UNDICI 16241: sending request to GET https://nodejs.org//en
+UNDICI 16241: received response to GET https://nodejs.org//en - HTTP 200
+UNDICI 16241: trailers received from GET https://nodejs.org//en
+```
+
+## `fetch`
+
+This flag enables debug statements for the `fetch` API.
+
+> **Note**: statements are pretty similar to the ones in the `undici` flag, but scoped to `fetch`
+
+```sh
+NODE_DEBUG=fetch node script.js
+
+FETCH 16241: connecting to nodejs.org using https:h1
+FETCH 16241: connecting to nodejs.org using https:h1
+FETCH 16241: connected to nodejs.org using https:h1
+FETCH 16241: sending request to GET https://nodejs.org//
+FETCH 16241: received response to GET https://nodejs.org// - HTTP 307
+FETCH 16241: connecting to nodejs.org using https:h1
+FETCH 16241: trailers received from GET https://nodejs.org//
+FETCH 16241: connected to nodejs.org using https:h1
+FETCH 16241: sending request to GET https://nodejs.org//en
+FETCH 16241: received response to GET https://nodejs.org//en - HTTP 200
+FETCH 16241: trailers received from GET https://nodejs.org//en
+```
+
+## `websocket`
+
+This flag enables debug statements for the `Websocket` API.
+
+> **Note**: statements can overlap with `UNDICI` ones if `undici` or `fetch` flag has been enabled as well.
+
+```sh
+NODE_DEBUG=fetch node script.js
+
+WEBSOCKET 18309: connecting to echo.websocket.org using https:h1
+WEBSOCKET 18309: connected to echo.websocket.org using https:h1
+WEBSOCKET 18309: sending request to GET https://echo.websocket.org//
+WEBSOCKET 18309: connection opened <ip_address>
+```

package/docs/api/DiagnosticsChannel.md

@@ -105,7 +105,7 @@ You can not assume that this event is related to any specific request.
 import diagnosticsChannel from 'diagnostics_channel'
 
 diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(({ connectParams, connector }) => {
-  // const { host, hostname, protocol, port, servername } = connectParams
+  // const { host, hostname, protocol, port, servername, version } = connectParams
   // connector is a function that creates the socket
 })
 ```
@@ -118,7 +118,7 @@ This message is published after a connection is established.
 import diagnosticsChannel from 'diagnostics_channel'
 
 diagnosticsChannel.channel('undici:client:connected').subscribe(({ socket, connectParams, connector }) => {
-  // const { host, hostname, protocol, port, servername } = connectParams
+  // const { host, hostname, protocol, port, servername, version } = connectParams
  // connector is a function that creates the socket
 })
 ```
@@ -131,7 +131,7 @@ This message is published if it did not succeed to create new connection
 import diagnosticsChannel from 'diagnostics_channel'
 
 diagnosticsChannel.channel('undici:client:connectError').subscribe(({ error, socket, connectParams, connector }) => {
-  // const { host, hostname, protocol, port, servername } = connectParams
+  // const { host, hostname, protocol, port, servername, version } = connectParams
   // connector is a function that creates the socket
   console.log(`Connect failed with ${error.message}`)
 })

package/index-fetch.js

@@ -4,7 +4,9 @@ const fetchImpl = require('./lib/fetch').fetch
 
 module.exports.fetch = function fetch (resource, init = undefined) {
   return fetchImpl(resource, init).catch((err) => {
-    Error.captureStackTrace(err, this)
+    if (typeof err === 'object') {
+      Error.captureStackTrace(err, this)
+    }
     throw err
   })
 }

package/lib/api/abort-signal.js

@@ -6,9 +6,9 @@ const kSignal = Symbol('kSignal')
 
 function abort (self) {
   if (self.abort) {
-    self.abort()
+    self.abort(self[kSignal]?.reason)
   } else {
-    self.onError(new RequestAbortedError())
+    self.onError(self[kSignal]?.reason ?? new RequestAbortedError())
   }
 }
 

package/lib/cache/cache.js

@@ -112,14 +112,12 @@ class Cache {
     // 5.5.2
     for (const response of responses) {
       // 5.5.2.1
-      const responseObject = new Response(response.body?.source ?? null)
-      const body = responseObject[kState].body
+      const responseObject = new Response(null)
       responseObject[kState] = response
-      responseObject[kState].body = body
       responseObject[kHeaders][kHeadersList] = response.headersList
       responseObject[kHeaders][kGuard] = 'immutable'
 
-      responseList.push(responseObject)
+      responseList.push(responseObject.clone())
     }
 
     // 6.
@@ -146,8 +144,6 @@ class Cache {
     webidl.brandCheck(this, Cache)
     webidl.argumentLengthCheck(arguments, 1, { header: 'Cache.addAll' })
 
-    requests = webidl.converters['sequence<RequestInfo>'](requests)
-
     // 1.
     const responsePromises = []
 
@@ -155,7 +151,17 @@ class Cache {
     const requestList = []
 
     // 3.
-    for (const request of requests) {
+    for (let request of requests) {
+      if (request === undefined) {
+        throw webidl.errors.conversionFailed({
+          prefix: 'Cache.addAll',
+          argument: 'Argument 1',
+          types: ['undefined is not allowed']
+        })
+      }
+
+      request = webidl.converters.RequestInfo(request)
+
       if (typeof request === 'string') {
         continue
       }

package/lib/client.js

@@ -9,6 +9,7 @@ const net = require('net')
 const http = require('http')
 const { pipeline } = require('stream')
 const util = require('./core/util')
+const { channels } = require('./core/diagnostics')
 const timers = require('./timers')
 const Request = require('./core/request')
 const DispatcherBase = require('./dispatcher-base')
@@ -108,21 +109,6 @@ const FastBuffer = Buffer[Symbol.species]
 
 const kClosedResolve = Symbol('kClosedResolve')
 
-const channels = {}
-
-try {
-  const diagnosticsChannel = require('diagnostics_channel')
-  channels.sendHeaders = diagnosticsChannel.channel('undici:client:sendHeaders')
-  channels.beforeConnect = diagnosticsChannel.channel('undici:client:beforeConnect')
-  channels.connectError = diagnosticsChannel.channel('undici:client:connectError')
-  channels.connected = diagnosticsChannel.channel('undici:client:connected')
-} catch {
-  channels.sendHeaders = { hasSubscribers: false }
-  channels.beforeConnect = { hasSubscribers: false }
-  channels.connectError = { hasSubscribers: false }
-  channels.connected = { hasSubscribers: false }
-}
-
 /**
  * @type {import('../types/client').default}
  */
@@ -1191,6 +1177,7 @@ async function connect (client) {
         hostname,
         protocol,
         port,
+        version: client[kHTTPConnVersion],
         servername: client[kServerName],
         localAddress: client[kLocalAddress]
       },
@@ -1284,6 +1271,7 @@ async function connect (client) {
           hostname,
           protocol,
           port,
+          version: client[kHTTPConnVersion],
           servername: client[kServerName],
           localAddress: client[kLocalAddress]
         },
@@ -1306,6 +1294,7 @@ async function connect (client) {
           hostname,
           protocol,
           port,
+          version: client[kHTTPConnVersion],
           servername: client[kServerName],
           localAddress: client[kLocalAddress]
         },
@@ -1658,19 +1647,6 @@ function writeH2 (client, session, request) {
     return false
   }
 
-  try {
-    // TODO(HTTP/2): Should we call onConnect immediately or on stream ready event?
-    request.onConnect((err) => {
-      if (request.aborted || request.completed) {
-        return
-      }
-
-      errorRequest(client, request, err || new RequestAbortedError())
-    })
-  } catch (err) {
-    errorRequest(client, request, err)
-  }
-
   if (request.aborted) {
     return false
   }
@@ -1682,9 +1658,34 @@ function writeH2 (client, session, request) {
   headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost]
   headers[HTTP2_HEADER_METHOD] = method
 
+  try {
+    // We are already connected, streams are pending.
+    // We can call on connect, and wait for abort
+    request.onConnect((err) => {
+      if (request.aborted || request.completed) {
+        return
+      }
+
+      err = err || new RequestAbortedError()
+
+      if (stream != null) {
+        util.destroy(stream, err)
+
+        h2State.openStreams -= 1
+        if (h2State.openStreams === 0) {
+          session.unref()
+        }
+      }
+
+      errorRequest(client, request, err)
+    })
+  } catch (err) {
+    errorRequest(client, request, err)
+  }
+
   if (method === 'CONNECT') {
     session.ref()
-    // we are already connected, streams are pending, first request
+    // We are already connected, streams are pending, first request
     // will create a new stream. We trigger a request to create the stream and wait until
     // `ready` event is triggered
     // We disabled endStream to allow the user to write to the stream

package/lib/compat/dispatcher-weakref.js

@@ -28,6 +28,8 @@ class CompatFinalizer {
       })
     }
   }
+
+  unregister (key) {}
 }
 
 module.exports = function () {

package/lib/core/diagnostics.js

@@ -0,0 +1,202 @@
+'use strict'
+const diagnosticsChannel = require('diagnostics_channel')
+const util = require('util')
+
+const undiciDebugLog = util.debuglog('undici')
+const fetchDebuglog = util.debuglog('fetch')
+const websocketDebuglog = util.debuglog('websocket')
+let isClientSet = false
+const channels = {
+  // Client
+  beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'),
+  connected: diagnosticsChannel.channel('undici:client:connected'),
+  connectError: diagnosticsChannel.channel('undici:client:connectError'),
+  sendHeaders: diagnosticsChannel.channel('undici:client:sendHeaders'),
+  // Request
+  create: diagnosticsChannel.channel('undici:request:create'),
+  bodySent: diagnosticsChannel.channel('undici:request:bodySent'),
+  headers: diagnosticsChannel.channel('undici:request:headers'),
+  trailers: diagnosticsChannel.channel('undici:request:trailers'),
+  error: diagnosticsChannel.channel('undici:request:error'),
+  // WebSocket
+  open: diagnosticsChannel.channel('undici:websocket:open'),
+  close: diagnosticsChannel.channel('undici:websocket:close'),
+  socketError: diagnosticsChannel.channel('undici:websocket:socket_error'),
+  ping: diagnosticsChannel.channel('undici:websocket:ping'),
+  pong: diagnosticsChannel.channel('undici:websocket:pong')
+}
+
+if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
+  const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog
+
+  // Track all Client events
+  diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connecting to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connected to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host },
+      error
+    } = evt
+    debuglog(
+      'connection to %s using %s%s errored - %s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version,
+      error.message
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('sending request to %s %s/%s', method, origin, path)
+  })
+
+  // Track Request events
+  diagnosticsChannel.channel('undici:request:headers').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      response: { statusCode }
+    } = evt
+    debuglog(
+      'received response to %s %s/%s - HTTP %d',
+      method,
+      origin,
+      path,
+      statusCode
+    )
+  })
+
+  diagnosticsChannel.channel('undici:request:trailers').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('trailers received from %s %s/%s', method, origin, path)
+  })
+
+  diagnosticsChannel.channel('undici:request:error').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      error
+    } = evt
+    debuglog(
+      'request to %s %s/%s errored - %s',
+      method,
+      origin,
+      path,
+      error.message
+    )
+  })
+
+  isClientSet = true
+}
+
+if (websocketDebuglog.enabled) {
+  if (!isClientSet) {
+    const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog
+    diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host }
+      } = evt
+      debuglog(
+        'connecting to %s%s using %s%s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host }
+      } = evt
+      debuglog(
+        'connected to %s%s using %s%s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host },
+        error
+      } = evt
+      debuglog(
+        'connection to %s%s using %s%s errored - %s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version,
+        error.message
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+      const {
+        request: { method, path, origin }
+      } = evt
+      debuglog('sending request to %s %s/%s', method, origin, path)
+    })
+  }
+
+  // Track all WebSocket events
+  diagnosticsChannel.channel('undici:websocket:open').subscribe(evt => {
+    const {
+      address: { address, port }
+    } = evt
+    websocketDebuglog('connection opened %s%s', address, port ? `:${port}` : '')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:close').subscribe(evt => {
+    const { websocket, code, reason } = evt
+    websocketDebuglog(
+      'closed connection to %s - %s %s',
+      websocket.url,
+      code,
+      reason
+    )
+  })
+
+  diagnosticsChannel.channel('undici:websocket:socket_error').subscribe(err => {
+    websocketDebuglog('connection errored - %s', err.message)
+  })
+
+  diagnosticsChannel.channel('undici:websocket:ping').subscribe(evt => {
+    websocketDebuglog('ping received')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:pong').subscribe(evt => {
+    websocketDebuglog('pong received')
+  })
+}
+
+module.exports = {
+  channels
+}

package/lib/core/request.js

@@ -7,6 +7,7 @@ const {
 const assert = require('assert')
 const { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require('./symbols')
 const util = require('./util')
+const { channels } = require('./diagnostics.js')
 const { headerNameLowerCasedRecord } = require('./constants')
 
 // headerCharRegex have been lifted from
@@ -25,25 +26,8 @@ const invalidPathRegex = /[^\u0021-\u00ff]/
 
 const kHandler = Symbol('handler')
 
-const channels = {}
-
 let extractBody
 
-try {
-  const diagnosticsChannel = require('diagnostics_channel')
-  channels.create = diagnosticsChannel.channel('undici:request:create')
-  channels.bodySent = diagnosticsChannel.channel('undici:request:bodySent')
-  channels.headers = diagnosticsChannel.channel('undici:request:headers')
-  channels.trailers = diagnosticsChannel.channel('undici:request:trailers')
-  channels.error = diagnosticsChannel.channel('undici:request:error')
-} catch {
-  channels.create = { hasSubscribers: false }
-  channels.bodySent = { hasSubscribers: false }
-  channels.headers = { hasSubscribers: false }
-  channels.trailers = { hasSubscribers: false }
-  channels.error = { hasSubscribers: false }
-}
-
 class Request {
   constructor (origin, {
     path,

package/lib/fetch/body.js

@@ -14,7 +14,7 @@ const { FormData } = require('./formdata')
 const { kState } = require('./symbols')
 const { webidl } = require('./webidl')
 const { Blob, File: NativeFile } = require('buffer')
-const { kBodyUsed } = require('../core/symbols')
+const { kBodyUsed, kHeadersList } = require('../core/symbols')
 const assert = require('assert')
 const { isErrored } = require('../core/util')
 const { isUint8Array, isArrayBuffer } = require('util/types')
@@ -369,10 +369,12 @@ function bodyMixinMethods (instance) {
 
       throwIfAborted(this[kState])
 
-      const contentType = this.headers.get('Content-Type')
+      const contentType = this.headers[kHeadersList].get('content-type', true)
+
+      const mimeType = contentType !== null ? parseMIMEType(contentType) : 'failure'
 
       // If mimeType’s essence is "multipart/form-data", then:
-      if (/multipart\/form-data/.test(contentType)) {
+      if (mimeType !== 'failure' && mimeType.essence === 'multipart/form-data') {
         const headers = {}
         for (const [key, value] of this.headers) headers[key] = value
 
@@ -430,7 +432,7 @@ function bodyMixinMethods (instance) {
         await busboyResolve
 
         return responseFormData
-      } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
+      } else if (mimeType !== 'failure' && mimeType.essence === 'application/x-www-form-urlencoded') {
         // Otherwise, if mimeType’s essence is "application/x-www-form-urlencoded", then:
 
         // 1. Let entries be the result of parsing bytes.

package/lib/fetch/dataURL.js

@@ -188,11 +188,28 @@ function stringPercentDecode (input) {
   return percentDecode(bytes)
 }
 
+/**
+ * @param {number} byte
+ */
 function isHexCharByte (byte) {
   // 0-9 A-F a-f
   return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) || (byte >= 0x61 && byte <= 0x66)
 }
 
+/**
+ * @param {number} byte
+ */
+function hexByteToNumber (byte) {
+  return (
+    // 0-9
+    byte >= 0x30 && byte <= 0x39
+      ? (byte - 48)
+    // Convert to uppercase
+    // ((byte & 0xDF) - 65) + 10
+      : ((byte & 0xDF) - 55)
+  )
+}
+
 // https://url.spec.whatwg.org/#percent-decode
 /** @param {Uint8Array} input */
 function percentDecode (input) {
@@ -224,11 +241,8 @@ function percentDecode (input) {
     } else {
       // 1. Let bytePoint be the two bytes after byte in input,
       // decoded, and then interpreted as hexadecimal number.
-      const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2])
-      const bytePoint = Number.parseInt(nextTwoBytes, 16)
-
       // 2. Append a byte whose value is bytePoint to output.
-      output[j++] = bytePoint
+      output[j++] = (hexByteToNumber(input[i + 1]) << 4) | hexByteToNumber(input[i + 2])
 
       // 3. Skip the next two bytes in input.
       i += 2
@@ -590,14 +604,18 @@ function isHTTPWhiteSpace (char) {
  * @param {boolean} [trailing=true]
  */
 function removeHTTPWhitespace (str, leading = true, trailing = true) {
-  let i = 0; let j = str.length
+  let lead = 0
+  let trail = str.length - 1
+
   if (leading) {
-    while (j > i && isHTTPWhiteSpace(str.charCodeAt(i))) --i
+    while (lead < str.length && isHTTPWhiteSpace(str.charCodeAt(lead))) lead++
   }
+
   if (trailing) {
-    while (j > i && isHTTPWhiteSpace(str.charCodeAt(j - 1))) --j
+    while (trail > 0 && isHTTPWhiteSpace(str.charCodeAt(trail))) trail--
   }
-  return i === 0 && j === str.length ? str : str.substring(i, j)
+
+  return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1)
 }
 
 /**
@@ -616,14 +634,18 @@ function isASCIIWhitespace (char) {
  * @param {boolean} [trailing=true]
  */
 function removeASCIIWhitespace (str, leading = true, trailing = true) {
-  let i = 0; let j = str.length
+  let lead = 0
+  let trail = str.length - 1
+
   if (leading) {
-    while (j > i && isASCIIWhitespace(str.charCodeAt(i))) --i
+    while (lead < str.length && isASCIIWhitespace(str.charCodeAt(lead))) lead++
   }
+
   if (trailing) {
-    while (j > i && isASCIIWhitespace(str.charCodeAt(j - 1))) --j
+    while (trail > 0 && isASCIIWhitespace(str.charCodeAt(trail))) trail--
   }
-  return i === 0 && j === str.length ? str : str.substring(i, j)
+
+  return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1)
 }
 
 module.exports = {

package/lib/fetch/file.js

@@ -211,10 +211,7 @@ webidl.converters.BlobPart = function (V, opts) {
       return webidl.converters.Blob(V, { strict: false })
     }
 
-    if (
-      ArrayBuffer.isView(V) ||
-      types.isAnyArrayBuffer(V)
-    ) {
+    if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
       return webidl.converters.BufferSource(V, opts)
     }
   }
@@ -282,10 +279,7 @@ function processBlobParts (parts, options) {
 
       // 3. Append the result of UTF-8 encoding s to bytes.
       bytes.push(encoder.encode(s))
-    } else if (
-      types.isAnyArrayBuffer(element) ||
-      types.isTypedArray(element)
-    ) {
+    } else if (ArrayBuffer.isView(element) || types.isArrayBuffer(element)) {
       // 2. If element is a BufferSource, get a copy of the
       //    bytes held by the buffer source, and append those
       //    bytes to bytes.

package/lib/fetch/index.js

@@ -1206,7 +1206,7 @@ async function httpFetch (fetchParams) {
     // encouraged to, transmit an RST_STREAM frame.
     // See, https://github.com/whatwg/fetch/issues/1288
     if (request.redirect !== 'manual') {
-      fetchParams.controller.connection.destroy()
+      fetchParams.controller.connection.destroy(undefined, false)
     }
 
     // 2. Switch on request’s redirect mode:
@@ -1718,10 +1718,12 @@ async function httpNetworkFetch (
   fetchParams.controller.connection = {
     abort: null,
     destroyed: false,
-    destroy (err) {
+    destroy (err, abort = true) {
       if (!this.destroyed) {
         this.destroyed = true
-        this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError'))
+        if (abort) {
+          this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError'))
+        }
       }
     }
   }
@@ -2152,7 +2154,8 @@ async function httpNetworkFetch (
           } else {
             const keys = Object.keys(rawHeaders)
             for (let i = 0; i < keys.length; ++i) {
-              headersList.append(keys[i], rawHeaders[keys[i]])
+              // The header names are already in lowercase.
+              headersList.append(keys[i], rawHeaders[keys[i]], true)
             }
             // For H2, The header names are already in lowercase,
             // so we can avoid the `HeadersList#get` call here.

package/lib/fetch/request.js

@@ -38,6 +38,8 @@ const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
   signal.removeEventListener('abort', abort)
 })
 
+let patchMethodWarning = false
+
 // https://fetch.spec.whatwg.org/#request-class
 class Request {
   // https://fetch.spec.whatwg.org/#dom-request
@@ -313,21 +315,36 @@ class Request {
       // 1. Let method be init["method"].
       let method = init.method
 
-      // 2. If method is not a method or method is a forbidden method, then
-      // throw a TypeError.
-      if (!isValidHTTPToken(method)) {
-        throw new TypeError(`'${method}' is not a valid HTTP method.`)
-      }
+      const mayBeNormalized = normalizeMethodRecord[method]
+
+      if (mayBeNormalized !== undefined) {
+        // Note: Bypass validation DELETE, GET, HEAD, OPTIONS, POST, PUT, PATCH and these lowercase ones
+        request.method = mayBeNormalized
+      } else {
+        // 2. If method is not a method or method is a forbidden method, then
+        // throw a TypeError.
+        if (!isValidHTTPToken(method)) {
+          throw new TypeError(`'${method}' is not a valid HTTP method.`)
+        }
 
-      if (forbiddenMethodsSet.has(method.toUpperCase())) {
-        throw new TypeError(`'${method}' HTTP method is unsupported.`)
+        if (forbiddenMethodsSet.has(method.toUpperCase())) {
+          throw new TypeError(`'${method}' HTTP method is unsupported.`)
+        }
+
+        // 3. Normalize method.
+        method = normalizeMethod(method)
+
+        // 4. Set request’s method to method.
+        request.method = method
       }
 
-      // 3. Normalize method.
-      method = normalizeMethodRecord[method] ?? normalizeMethod(method)
+      if (!patchMethodWarning && request.method === 'patch') {
+        process.emitWarning('Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.', {
+          code: 'UNDICI-FETCH-patch'
+        })
 
-      // 4. Set request’s method to method.
-      request.method = method
+        patchMethodWarning = true
+      }
     }
 
     // 26. If init["signal"] exists, then set signal to it.
@@ -371,6 +388,18 @@ class Request {
         const abort = function () {
           const ac = acRef.deref()
           if (ac !== undefined) {
+            // Currently, there is a problem with FinalizationRegistry.
+            // https://github.com/nodejs/node/issues/49344
+            // https://github.com/nodejs/node/issues/47748
+            // In the case of abort, the first step is to unregister from it.
+            // If the controller can refer to it, it is still registered.
+            // It will be removed in the future.
+            requestFinalizer.unregister(abort)
+
+            // Unsubscribe a listener.
+            // FinalizationRegistry will no longer be called, so this must be done.
+            this.removeEventListener('abort', abort)
+
             ac.abort(this.reason)
           }
         }
@@ -388,7 +417,11 @@ class Request {
         } catch {}
 
         util.addAbortListener(signal, abort)
-        requestFinalizer.register(ac, { signal, abort })
+        // The third argument must be a registry key to be unregistered.
+        // Without it, you cannot unregister.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+        // abort is used as the unregister key. (because it is unique)
+        requestFinalizer.register(ac, { signal, abort }, abort)
       }
     }
 
@@ -471,7 +504,7 @@ class Request {
       // 3, If Content-Type is non-null and this’s headers’s header list does
       // not contain `Content-Type`, then append `Content-Type`/Content-Type to
       // this’s headers.
-      if (contentType && !this[kHeaders][kHeadersList].contains('content-type')) {
+      if (contentType && !this[kHeaders][kHeadersList].contains('content-type', true)) {
         this[kHeaders].append('content-type', contentType)
       }
     }

package/lib/fetch/response.js

@@ -524,7 +524,7 @@ webidl.converters.XMLHttpRequestBodyInit = function (V) {
     return webidl.converters.Blob(V, { strict: false })
   }
 
-  if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) {
+  if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
     return webidl.converters.BufferSource(V)
   }
 

package/lib/fetch/util.js

@@ -584,7 +584,7 @@ function bytesMatch (bytes, metadataList) {
 // https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options
 // https://www.w3.org/TR/CSP2/#source-list-syntax
 // https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
-const parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/i
+const parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-(?<hash>[A-Za-z0-9+/]+={0,2}(?=\s|$))( +[!-~]*)?/i
 
 /**
  * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
@@ -681,7 +681,7 @@ function isCancelled (fetchParams) {
     fetchParams.controller.state === 'terminated'
 }
 
-const normalizeMethodRecord = {
+const normalizeMethodRecordBase = {
   delete: 'DELETE',
   DELETE: 'DELETE',
   get: 'GET',
@@ -696,7 +696,14 @@ const normalizeMethodRecord = {
   PUT: 'PUT'
 }
 
+const normalizeMethodRecord = {
+  ...normalizeMethodRecordBase,
+  patch: 'patch',
+  PATCH: 'PATCH'
+}
+
 // Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(normalizeMethodRecordBase, null)
 Object.setPrototypeOf(normalizeMethodRecord, null)
 
 /**
@@ -704,7 +711,7 @@ Object.setPrototypeOf(normalizeMethodRecord, null)
  * @param {string} method
  */
 function normalizeMethod (method) {
-  return normalizeMethodRecord[method.toLowerCase()] ?? method
+  return normalizeMethodRecordBase[method.toLowerCase()] ?? method
 }
 
 // https://infra.spec.whatwg.org/#serialize-a-javascript-value-to-a-json-string
@@ -1213,5 +1220,6 @@ module.exports = {
   readAllBytes,
   normalizeMethodRecord,
   simpleRangeHeaderValue,
-  buildContentRange
+  buildContentRange,
+  parseMetadata
 }

package/lib/fetch/webidl.js

@@ -614,15 +614,15 @@ webidl.converters.DataView = function (V, opts = {}) {
 // https://webidl.spec.whatwg.org/#BufferSource
 webidl.converters.BufferSource = function (V, opts = {}) {
   if (types.isAnyArrayBuffer(V)) {
-    return webidl.converters.ArrayBuffer(V, opts)
+    return webidl.converters.ArrayBuffer(V, { ...opts, allowShared: false })
   }
 
   if (types.isTypedArray(V)) {
-    return webidl.converters.TypedArray(V, V.constructor)
+    return webidl.converters.TypedArray(V, V.constructor, { ...opts, allowShared: false })
   }
 
   if (types.isDataView(V)) {
-    return webidl.converters.DataView(V, opts)
+    return webidl.converters.DataView(V, opts, { ...opts, allowShared: false })
   }
 
   throw new TypeError(`Could not convert ${V} to a BufferSource.`)

package/lib/proxy-agent.js

@@ -66,7 +66,7 @@ class ProxyAgent extends DispatcherBase {
     this[kProxyHeaders] = opts.headers || {}
 
     const resolvedUrl = new URL(opts.uri)
-    const { origin, port, host, username, password } = resolvedUrl
+    const { origin, port, username, password } = resolvedUrl
 
     if (opts.auth && opts.token) {
       throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
@@ -97,7 +97,7 @@ class ProxyAgent extends DispatcherBase {
             signal: opts.signal,
             headers: {
               ...this[kProxyHeaders],
-              host
+              host: requestedHost
             }
           })
           if (statusCode !== 200) {

package/lib/websocket/connection.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const diagnosticsChannel = require('diagnostics_channel')
 const { uid, states } = require('./constants')
 const {
   kReadyState,
@@ -9,6 +8,7 @@ const {
   kReceivedClose
 } = require('./symbols')
 const { fireEvent, failWebsocketConnection } = require('./util')
+const { channels } = require('../core/diagnostics')
 const { CloseEvent } = require('./events')
 const { makeRequest } = require('../fetch/request')
 const { fetching } = require('../fetch/index')
@@ -16,11 +16,6 @@ const { Headers } = require('../fetch/headers')
 const { getGlobalDispatcher } = require('../global')
 const { kHeadersList } = require('../core/symbols')
 
-const channels = {}
-channels.open = diagnosticsChannel.channel('undici:websocket:open')
-channels.close = diagnosticsChannel.channel('undici:websocket:close')
-channels.socketError = diagnosticsChannel.channel('undici:websocket:socket_error')
-
 /** @type {import('crypto')} */
 let crypto
 try {

package/lib/websocket/receiver.js

@@ -1,9 +1,9 @@
 'use strict'
 
 const { Writable } = require('stream')
-const diagnosticsChannel = require('diagnostics_channel')
 const { parserStates, opcodes, states, emptyBuffer } = require('./constants')
 const { kReadyState, kSentClose, kResponse, kReceivedClose } = require('./symbols')
+const { channels } = require('../core/diagnostics')
 const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require('./util')
 const { WebsocketFrameSend } = require('./frame')
 
@@ -12,10 +12,6 @@ const { WebsocketFrameSend } = require('./frame')
 // Copyright (c) 2013 Arnout Kazemier and contributors
 // Copyright (c) 2016 Luigi Pinca and contributors
 
-const channels = {}
-channels.ping = diagnosticsChannel.channel('undici:websocket:ping')
-channels.pong = diagnosticsChannel.channel('undici:websocket:pong')
-
 class ByteParser extends Writable {
   #buffers = []
   #byteOffset = 0

package/lib/websocket/websocket.js

@@ -627,7 +627,7 @@ webidl.converters.WebSocketSendData = function (V) {
       return webidl.converters.Blob(V, { strict: false })
     }
 
-    if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
+    if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
       return webidl.converters.BufferSource(V)
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "6.2.1",
+  "version": "6.3.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -75,16 +75,18 @@
     "build:wasm": "node build/wasm.js --docker",
     "lint": "standard | snazzy",
     "lint:fix": "standard --fix | snazzy",
-    "test": "node scripts/generate-pem && npm run test:tap && npm run test:node-fetch && npm run test:fetch && npm run test:cookies && npm run test:wpt && npm run test:websocket && npm run test:jest && npm run test:typescript",
-    "test:cookies": "node scripts/verifyVersion 16 || tap test/cookie/*.js",
-    "test:node-fetch": "node scripts/verifyVersion.js 16 || mocha --exit test/node-fetch",
-    "test:fetch": "node scripts/verifyVersion.js 16 || (npm run build:node && tap --expose-gc test/fetch/*.js && tap test/webidl/*.js)",
-    "test:jest": "node scripts/verifyVersion.js 14 || jest",
-    "test:tap": "tap test/*.js test/diagnostics-channel/*.js",
-    "test:tdd": "tap test/*.js test/diagnostics-channel/*.js -w",
-    "test:typescript": "node scripts/verifyVersion.js 14 || tsd && tsc --skipLibCheck test/imports/undici-import.ts",
-    "test:websocket": "node scripts/verifyVersion.js 18 || tap test/websocket/*.js",
-    "test:wpt": "node scripts/verifyVersion 18 || (node test/wpt/start-fetch.mjs && node test/wpt/start-FileAPI.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs)",
+    "test": "node scripts/generate-pem && npm run test:tap && npm run test:node-fetch && npm run test:fetch && npm run test:cookies && npm run test:wpt && npm run test:websocket && npm run test:jest && npm run test:typescript && npm run test:node-test",
+    "test:cookies": "borp --coverage -p \"test/cookie/*.js\"",
+    "test:node-fetch": "mocha --exit test/node-fetch",
+    "test:fetch": "npm run build:node && borp --expose-gc --coverage -p \"test/fetch/*.js\" && borp --coverage -p \"test/webidl/*.js\"",
+    "test:jest": "jest",
+    "test:tap": "tap test/*.js",
+    "test:node-test": "borp --coverage -p \"test/node-test/**/*.js\"",
+    "test:tdd": "tap test/*.js --coverage -w",
+    "test:tdd:node-test": "borp -p \"test/node-test/**/*.js\" -w",
+    "test:typescript": "tsd && tsc --skipLibCheck test/imports/undici-import.ts",
+    "test:websocket": "borp --coverage -p \"test/websocket/*.js\"",
+    "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-FileAPI.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs",
     "coverage": "nyc --reporter=text --reporter=html npm run test",
     "coverage:ci": "nyc --reporter=lcov npm run test",
     "bench": "PORT=3042 concurrently -k -s first npm:bench:server npm:bench:run",
@@ -96,10 +98,12 @@
     "fuzz": "jsfuzz test/fuzzing/fuzz.js corpus"
   },
   "devDependencies": {
+    "@matteo.collina/tspl": "^0.1.1",
     "@sinonjs/fake-timers": "^11.1.0",
     "@types/node": "^18.0.3",
     "abort-controller": "^3.0.0",
     "atomic-sleep": "^1.0.0",
+    "borp": "^0.5.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "chai-iterator": "^3.0.2",
@@ -129,7 +133,7 @@
     "standard": "^17.0.0",
     "table": "^6.8.0",
     "tap": "^16.1.0",
-    "tsd": "^0.29.0",
+    "tsd": "^0.30.1",
     "typescript": "^5.0.2",
     "wait-on": "^7.0.1",
     "ws": "^8.11.0"

package/types/balanced-pool.d.ts

@@ -4,6 +4,8 @@ import { URL } from 'url'
 
 export default BalancedPool
 
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
 declare class BalancedPool extends Dispatcher {
   constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
 
@@ -15,4 +17,13 @@ declare class BalancedPool extends Dispatcher {
   closed: boolean;
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
   destroyed: boolean;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: BalancedPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: BalancedPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }

package/types/client.d.ts

@@ -3,6 +3,8 @@ import { TlsOptions } from 'tls'
 import Dispatcher from './dispatcher'
 import buildConnector from "./connector";
 
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
  */
@@ -14,6 +16,15 @@ export class Client extends Dispatcher {
   closed: boolean;
   /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
   destroyed: boolean;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: ClientConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: ClientConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }
 
 export declare namespace Client {

package/types/dispatcher.d.ts

@@ -121,6 +121,7 @@ declare namespace Dispatcher {
     expectContinue?: boolean;
   }
   export interface ConnectOptions {
+    origin: string | URL;
     path: string;
     /** Default: `null` */
     headers?: IncomingHttpHeaders | string[] | null;

package/types/pool.d.ts

@@ -5,6 +5,8 @@ import Dispatcher from "./dispatcher";
 
 export default Pool
 
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
 declare class Pool extends Dispatcher {
   constructor(url: string | URL, options?: Pool.Options)
   /** `true` after `pool.close()` has been called. */
@@ -13,6 +15,15 @@ declare class Pool extends Dispatcher {
   destroyed: boolean;
   /** Aggregate stats for a Pool. */
   readonly stats: TPoolStats;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: PoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: PoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }
 
 declare namespace Pool {

package/types/proxy-agent.d.ts

@@ -1,9 +1,7 @@
 import Agent from './agent'
 import buildConnector from './connector';
-import Client from './client'
 import Dispatcher from './dispatcher'
 import { IncomingHttpHeaders } from './header'
-import Pool from './pool'
 
 export default ProxyAgent