undici 7.0.0-alpha.1 → 7.0.0-alpha.10

package/lib/web/websocket/util.js

@@ -50,6 +50,7 @@ function isClosed (readyState) {
  * @param {EventTarget} target
  * @param {(...args: ConstructorParameters<typeof Event>) => Event} eventFactory
  * @param {EventInit | undefined} eventInitDict
+ * @returns {void}
  */
 function fireEvent (e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
   // 1. If eventConstructor is not given, then let eventConstructor be Event.
@@ -72,11 +73,16 @@ function fireEvent (e, target, eventFactory = (type, init) => new Event(type, in
  * @param {import('./websocket').Handler} handler
  * @param {number} type Opcode
  * @param {Buffer} data application data
+ * @returns {void}
  */
 function websocketMessageReceived (handler, type, data) {
   handler.onMessage(type, data)
 }
 
+/**
+ * @param {Buffer} buffer
+ * @returns {ArrayBuffer}
+ */
 function toArrayBuffer (buffer) {
   if (buffer.byteLength === buffer.buffer.byteLength) {
     return buffer.buffer
@@ -89,6 +95,7 @@ function toArrayBuffer (buffer) {
  * @see https://datatracker.ietf.org/doc/html/rfc2616
  * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
  * @param {string} protocol
+ * @returns {boolean}
  */
 function isValidSubprotocol (protocol) {
   // If present, this value indicates one
@@ -135,6 +142,7 @@ function isValidSubprotocol (protocol) {
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
  * @param {number} code
+ * @returns {boolean}
  */
 function isValidStatusCode (code) {
   if (code >= 1000 && code < 1015) {
@@ -150,15 +158,34 @@ function isValidStatusCode (code) {
 
 /**
  * @param {import('./websocket').Handler} handler
+ * @param {number} code
  * @param {string|undefined} reason
+ * @returns {void}
  */
-function failWebsocketConnection (handler, reason) {
-  handler.onFail(reason)
+function failWebsocketConnection (handler, code, reason) {
+  // If _The WebSocket Connection is Established_ prior to the point where
+  // the endpoint is required to _Fail the WebSocket Connection_, the
+  // endpoint SHOULD send a Close frame with an appropriate status code
+  // (Section 7.4) before proceeding to _Close the WebSocket Connection_.
+  if (isEstablished(handler.readyState)) {
+    // avoid circular require - performance is not important here
+    const { closeWebSocketConnection } = require('./connection')
+    closeWebSocketConnection(handler, code, reason, false)
+  }
+
+  handler.controller.abort()
+
+  if (handler.socket?.destroyed === false) {
+    handler.socket.destroy()
+  }
+
+  handler.onFail(code, reason)
 }
 
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5
  * @param {number} opcode
+ * @returns {boolean}
  */
 function isControlFrame (opcode) {
   return (
@@ -168,14 +195,27 @@ function isControlFrame (opcode) {
   )
 }
 
+/**
+ * @param {number} opcode
+ * @returns {boolean}
+ */
 function isContinuationFrame (opcode) {
   return opcode === opcodes.CONTINUATION
 }
 
+/**
+ * @param {number} opcode
+ * @returns {boolean}
+ */
 function isTextBinaryFrame (opcode) {
   return opcode === opcodes.TEXT || opcode === opcodes.BINARY
 }
 
+/**
+ *
+ * @param {number} opcode
+ * @returns {boolean}
+ */
 function isValidOpcode (opcode) {
   return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode)
 }
@@ -209,6 +249,7 @@ function parseExtensions (extensions) {
  * @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2
  * @description "client-max-window-bits = 1*DIGIT"
  * @param {string} value
+ * @returns {boolean}
  */
 function isValidClientWindowBits (value) {
   for (let i = 0; i < value.length; i++) {
@@ -222,22 +263,84 @@ function isValidClientWindowBits (value) {
   return true
 }
 
-// https://nodejs.org/api/intl.html#detecting-internationalization-support
-const hasIntl = typeof process.versions.icu === 'string'
-const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undefined
+/**
+ * @see https://whatpr.org/websockets/48/7b748d3...d5570f3.html#get-a-url-record
+ * @param {string} url
+ * @param {string} [baseURL]
+ */
+function getURLRecord (url, baseURL) {
+  // 1. Let urlRecord be the result of applying the URL parser to url with baseURL .
+  // 2. If urlRecord is failure, then throw a " SyntaxError " DOMException .
+  let urlRecord
+
+  try {
+    urlRecord = new URL(url, baseURL)
+  } catch (e) {
+    throw new DOMException(e, 'SyntaxError')
+  }
+
+  // 3. If urlRecord ’s scheme is " http ", then set urlRecord ’s scheme to " ws ".
+  // 4. Otherwise, if urlRecord ’s scheme is " https ", set urlRecord ’s scheme to " wss ".
+  if (urlRecord.protocol === 'http:') {
+    urlRecord.protocol = 'ws:'
+  } else if (urlRecord.protocol === 'https:') {
+    urlRecord.protocol = 'wss:'
+  }
+
+  // 5. If urlRecord ’s scheme is not " ws " or " wss ", then throw a " SyntaxError " DOMException .
+  if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
+    throw new DOMException('expected a ws: or wss: url', 'SyntaxError')
+  }
+
+  // If urlRecord ’s fragment is non-null, then throw a " SyntaxError " DOMException .
+  if (urlRecord.hash.length || urlRecord.href.endsWith('#')) {
+    throw new DOMException('hash', 'SyntaxError')
+  }
+
+  // Return urlRecord .
+  return urlRecord
+}
+
+// https://whatpr.org/websockets/48.html#validate-close-code-and-reason
+function validateCloseCodeAndReason (code, reason) {
+  // 1. If code is not null, but is neither an integer equal to
+  //    1000 nor an integer in the range 3000 to 4999, inclusive,
+  //    throw an "InvalidAccessError" DOMException.
+  if (code !== null) {
+    if (code !== 1000 && (code < 3000 || code > 4999)) {
+      throw new DOMException('invalid code', 'InvalidAccessError')
+    }
+  }
+
+  // 2. If reason is not null, then:
+  if (reason !== null) {
+    // 2.1. Let reasonBytes be the result of UTF-8 encoding reason.
+    // 2.2. If reasonBytes is longer than 123 bytes, then throw a
+    //      "SyntaxError" DOMException.
+    const reasonBytesLength = Buffer.byteLength(reason)
+
+    if (reasonBytesLength > 123) {
+      throw new DOMException(`Reason must be less than 123 bytes; received ${reasonBytesLength}`, 'SyntaxError')
+    }
+  }
+}
 
 /**
  * Converts a Buffer to utf-8, even on platforms without icu.
- * @param {Buffer} buffer
+ * @type {(buffer: Buffer) => string}
  */
-const utf8Decode = hasIntl
-  ? fatalDecoder.decode.bind(fatalDecoder)
-  : function (buffer) {
+const utf8Decode = (() => {
+  if (typeof process.versions.icu === 'string') {
+    const fatalDecoder = new TextDecoder('utf-8', { fatal: true })
+    return fatalDecoder.decode.bind(fatalDecoder)
+  }
+  return function (buffer) {
     if (isUtf8(buffer)) {
       return buffer.toString('utf-8')
     }
     throw new TypeError('Invalid utf-8 received.')
   }
+})()
 
 module.exports = {
   isConnecting,
@@ -256,5 +359,7 @@ module.exports = {
   isValidOpcode,
   parseExtensions,
   isValidClientWindowBits,
-  toArrayBuffer
+  toArrayBuffer,
+  getURLRecord,
+  validateCloseCodeAndReason
 }

package/lib/web/websocket/websocket.js

@@ -3,7 +3,7 @@
 const { webidl } = require('../fetch/webidl')
 const { URLSerializer } = require('../fetch/data-url')
 const { environmentSettingsObject } = require('../fetch/util')
-const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes, emptyBuffer } = require('./constants')
+const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes } = require('./constants')
 const {
   isConnecting,
   isEstablished,
@@ -13,7 +13,7 @@ const {
   failWebsocketConnection,
   utf8Decode,
   toArrayBuffer,
-  isClosed
+  getURLRecord
 } = require('./util')
 const { establishWebSocketConnection, closeWebSocketConnection } = require('./connection')
 const { ByteParser } = require('./receiver')
@@ -22,15 +22,13 @@ const { getGlobalDispatcher } = require('../../global')
 const { types } = require('node:util')
 const { ErrorEvent, CloseEvent, createFastMessageEvent } = require('./events')
 const { SendQueue } = require('./sender')
-const { WebsocketFrameSend } = require('./frame')
 const { channels } = require('../../core/diagnostics')
 
 /**
  * @typedef {object} Handler
  * @property {(response: any, extensions?: string[]) => void} onConnectionEstablished
- * @property {(reason: any) => void} onFail
+ * @property {(code: number, reason: any) => void} onFail
  * @property {(opcode: number, data: Buffer) => void} onMessage
- * @property {(code: number, reason: any, reasonByteLength: number) => void} onClose
  * @property {(error: Error) => void} onParserError
  * @property {() => void} onParserDrain
  * @property {(chunk: Buffer) => void} onSocketData
@@ -39,8 +37,9 @@ const { channels } = require('../../core/diagnostics')
  *
  * @property {number} readyState
  * @property {import('stream').Duplex} socket
- * @property {number} closeState
- * @property {boolean} receivedClose
+ * @property {Set<number>} closeState
+ * @property {import('../fetch/index').Fetch} controller
+ * @property {boolean} [wasEverConnected=false]
  */
 
 // https://websockets.spec.whatwg.org/#interface-definition
@@ -62,10 +61,9 @@ class WebSocket extends EventTarget {
   /** @type {Handler} */
   #handler = {
     onConnectionEstablished: (response, extensions) => this.#onConnectionEstablished(response, extensions),
-    onFail: (reason) => this.#onFail(reason),
+    onFail: (code, reason) => this.#onFail(code, reason),
     onMessage: (opcode, data) => this.#onMessage(opcode, data),
-    onClose: (code, reason, reasonByteLength) => this.#onClose(code, reason, reasonByteLength),
-    onParserError: (err) => this.#onParserError(err),
+    onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
     onParserDrain: () => this.#onParserDrain(),
     onSocketData: (chunk) => {
       if (!this.#parser.write(chunk)) {
@@ -85,12 +83,12 @@ class WebSocket extends EventTarget {
 
     readyState: states.CONNECTING,
     socket: null,
-    closeState: sentCloseFrameState.NOT_SENT,
-    receivedClose: false
+    closeState: new Set(),
+    controller: null,
+    wasEverConnected: false
   }
 
   #url
-  #controller
   #binaryType
   /** @type {import('./receiver').ByteParser} */
   #parser
@@ -102,6 +100,8 @@ class WebSocket extends EventTarget {
   constructor (url, protocols = []) {
     super()
 
+    webidl.util.markAsUncloneable(this)
+
     const prefix = 'WebSocket constructor'
     webidl.argumentLengthCheck(arguments, 1, prefix)
 
@@ -113,45 +113,16 @@ class WebSocket extends EventTarget {
     // 1. Let baseURL be this's relevant settings object's API base URL.
     const baseURL = environmentSettingsObject.settingsObject.baseUrl
 
-    // 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
-    let urlRecord
-
-    try {
-      urlRecord = new URL(url, baseURL)
-    } catch (e) {
-      // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
-      throw new DOMException(e, 'SyntaxError')
-    }
-
-    // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
-    if (urlRecord.protocol === 'http:') {
-      urlRecord.protocol = 'ws:'
-    } else if (urlRecord.protocol === 'https:') {
-      // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
-      urlRecord.protocol = 'wss:'
-    }
-
-    // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
-    if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
-      throw new DOMException(
-        `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
-        'SyntaxError'
-      )
-    }
-
-    // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
-    //    DOMException.
-    if (urlRecord.hash || urlRecord.href.endsWith('#')) {
-      throw new DOMException('Got fragment', 'SyntaxError')
-    }
+    // 2. Let urlRecord be the result of getting a URL record given url and baseURL.
+    const urlRecord = getURLRecord(url, baseURL)
 
-    // 8. If protocols is a string, set protocols to a sequence consisting
+    // 3. If protocols is a string, set protocols to a sequence consisting
     //    of just that string.
     if (typeof protocols === 'string') {
       protocols = [protocols]
     }
 
-    // 9. If any of the values in protocols occur more than once or otherwise
+    // 4. If any of the values in protocols occur more than once or otherwise
     //    fail to match the requirements for elements that comprise the value
     //    of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
     //    protocol, then throw a "SyntaxError" DOMException.
@@ -163,17 +134,16 @@ class WebSocket extends EventTarget {
       throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
     }
 
-    // 10. Set this's url to urlRecord.
+    // 5. Set this's url to urlRecord.
     this.#url = new URL(urlRecord.href)
 
-    // 11. Let client be this's relevant settings object.
+    // 6. Let client be this's relevant settings object.
     const client = environmentSettingsObject.settingsObject
 
-    // 12. Run this step in parallel:
-
-    //    1. Establish a WebSocket connection given urlRecord, protocols,
-    //       and client.
-    this.#controller = establishWebSocketConnection(
+    // 7. Run this step in parallel:
+    // 7.1. Establish a WebSocket connection given urlRecord, protocols,
+    //      and client.
+    this.#handler.controller = establishWebSocketConnection(
       urlRecord,
       protocols,
       client,
@@ -186,8 +156,6 @@ class WebSocket extends EventTarget {
     // be CONNECTING (0).
     this.#handler.readyState = WebSocket.CONNECTING
 
-    this.#handler.closeState = sentCloseFrameState.NOT_SENT
-
     // The extensions attribute must initially return the empty string.
 
     // The protocol attribute must initially return the empty string.
@@ -215,34 +183,14 @@ class WebSocket extends EventTarget {
       reason = webidl.converters.USVString(reason)
     }
 
-    // 1. If code is present, but is neither an integer equal to 1000 nor an
-    //    integer in the range 3000 to 4999, inclusive, throw an
-    //    "InvalidAccessError" DOMException.
-    if (code !== undefined) {
-      if (code !== 1000 && (code < 3000 || code > 4999)) {
-        throw new DOMException('invalid code', 'InvalidAccessError')
-      }
-    }
-
-    let reasonByteLength = 0
+    // 1. If code is the special value "missing", then set code to null.
+    code ??= null
 
-    // 2. If reason is present, then run these substeps:
-    if (reason !== undefined) {
-      // 1. Let reasonBytes be the result of encoding reason.
-      // 2. If reasonBytes is longer than 123 bytes, then throw a
-      //    "SyntaxError" DOMException.
-      reasonByteLength = Buffer.byteLength(reason)
-
-      if (reasonByteLength > 123) {
-        throw new DOMException(
-          `Reason must be less than 123 bytes; received ${reasonByteLength}`,
-          'SyntaxError'
-        )
-      }
-    }
+    // 2. If reason is the special value "missing", then set reason to the empty string.
+    reason ??= ''
 
-    // 3. Run the first matching steps from the following list:
-    closeWebSocketConnection(this.#handler, code, reason, reasonByteLength)
+    // 3. Close the WebSocket with this, code, and reason.
+    closeWebSocketConnection(this.#handler, code, reason, true)
   }
 
   /**
@@ -324,7 +272,7 @@ class WebSocket extends EventTarget {
       this.#sendQueue.add(data, () => {
         this.#bufferedAmount -= data.byteLength
       }, sendHints.typedArray)
-    } else if (data instanceof Blob) {
+    } else if (webidl.is.Blob(data)) {
       // If the WebSocket connection is established, and the WebSocket
       // closing handshake has not yet started, then the user agent must
       // send a WebSocket Message comprised of data using a binary frame
@@ -515,15 +463,7 @@ class WebSocket extends EventTarget {
     fireEvent('open', this)
   }
 
-  #onFail (reason) {
-    this.#controller.abort()
-
-    if (this.#handler.socket && !this.#handler.socket.destroyed) {
-      this.#handler.socket.destroy()
-    }
-
-    this.#handler.readyState = states.CLOSED
-
+  #onFail (code, reason) {
     if (reason) {
       // TODO: process.nextTick
       fireEvent('error', this, (type, init) => new ErrorEvent(type, init), {
@@ -531,6 +471,16 @@ class WebSocket extends EventTarget {
         message: reason
       })
     }
+
+    if (!this.#handler.wasEverConnected) {
+      this.#handler.readyState = states.CLOSED
+
+      // If the WebSocket connection could not be established, it is also said
+      // that _The WebSocket Connection is Closed_, but not _cleanly_.
+      fireEvent('close', this, (type, init) => new CloseEvent(type, init), {
+        wasClean: false, code, reason
+      })
+    }
   }
 
   #onMessage (type, data) {
@@ -548,7 +498,7 @@ class WebSocket extends EventTarget {
       try {
         dataForEvent = utf8Decode(data)
       } catch {
-        failWebsocketConnection(this.#handler, 'Received invalid UTF-8 in text frame.')
+        failWebsocketConnection(this.#handler, 1007, 'Received invalid UTF-8 in text frame.')
         return
       }
     } else if (type === opcodes.BINARY) {
@@ -574,81 +524,6 @@ class WebSocket extends EventTarget {
     })
   }
 
-  #onClose (code, reason, reasonByteLength) {
-    if (isClosing(this.#handler.readyState) || isClosed(this.#handler.readyState)) {
-      // If this's ready state is CLOSING (2) or CLOSED (3)
-      // Do nothing.
-    } else if (!isEstablished(this.#handler.readyState)) {
-      // If the WebSocket connection is not yet established
-      // Fail the WebSocket connection and set this's ready state
-      // to CLOSING (2).
-      failWebsocketConnection(this.#handler, 'Connection was closed before it was established.')
-      this.#handler.readyState = states.CLOSING
-    } else if (this.#handler.closeState === sentCloseFrameState.NOT_SENT) {
-      // If the WebSocket closing handshake has not yet been started
-      // Start the WebSocket closing handshake and set this's ready
-      // state to CLOSING (2).
-      // - If neither code nor reason is present, the WebSocket Close
-      //   message must not have a body.
-      // - If code is present, then the status code to use in the
-      //   WebSocket Close message must be the integer given by code.
-      // - If reason is also present, then reasonBytes must be
-      //   provided in the Close message after the status code.
-
-      this.#handler.closeState = sentCloseFrameState.PROCESSING
-
-      const frame = new WebsocketFrameSend()
-
-      // If neither code nor reason is present, the WebSocket Close
-      // message must not have a body.
-
-      // If code is present, then the status code to use in the
-      // WebSocket Close message must be the integer given by code.
-      if (code !== undefined && reason === undefined) {
-        frame.frameData = Buffer.allocUnsafe(2)
-        frame.frameData.writeUInt16BE(code, 0)
-      } else if (code !== undefined && reason !== undefined) {
-        // If reason is also present, then reasonBytes must be
-        // provided in the Close message after the status code.
-        frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
-        frame.frameData.writeUInt16BE(code, 0)
-        // the body MAY contain UTF-8-encoded data with value /reason/
-        frame.frameData.write(reason, 2, 'utf-8')
-      } else {
-        frame.frameData = emptyBuffer
-      }
-
-      this.#handler.socket.write(frame.createFrame(opcodes.CLOSE))
-
-      this.#handler.closeState = sentCloseFrameState.SENT
-
-      // Upon either sending or receiving a Close control frame, it is said
-      // that _The WebSocket Closing Handshake is Started_ and that the
-      // WebSocket connection is in the CLOSING state.
-      this.#handler.readyState = states.CLOSING
-    } else {
-      // Otherwise
-      // Set this's ready state to CLOSING (2).
-      this.#handler.readyState = states.CLOSING
-    }
-  }
-
-  #onParserError (err) {
-    let message
-    let code
-
-    if (err instanceof CloseEvent) {
-      message = err.reason
-      code = err.code
-    } else {
-      message = err.message
-    }
-
-    fireEvent('error', this, () => new ErrorEvent('error', { error: err, message }))
-
-    closeWebSocketConnection(this.#handler, code)
-  }
-
   #onParserDrain () {
     this.#handler.socket.resume()
   }
@@ -661,7 +536,9 @@ class WebSocket extends EventTarget {
     // If the TCP connection was closed after the
     // WebSocket closing handshake was completed, the WebSocket connection
     // is said to have been closed _cleanly_.
-    const wasClean = this.#handler.closeState === sentCloseFrameState.SENT && this.#handler.receivedClose
+    const wasClean =
+      this.#handler.closeState.has(sentCloseFrameState.SENT) &&
+      this.#handler.closeState.has(sentCloseFrameState.RECEIVED)
 
     let code = 1005
     let reason = ''
@@ -671,7 +548,7 @@ class WebSocket extends EventTarget {
     if (result && !result.error) {
       code = result.code ?? 1005
       reason = result.reason
-    } else if (!this.#handler.receivedClose) {
+    } else if (!this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
       // If _The WebSocket
       // Connection is Closed_ and no Close control frame was received by the
       // endpoint (such as could occur if the underlying transport connection
@@ -793,7 +670,7 @@ webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = functio
 
 webidl.converters.WebSocketSendData = function (V) {
   if (webidl.util.Type(V) === webidl.util.Types.OBJECT) {
-    if (V instanceof Blob) {
+    if (webidl.is.Blob(V)) {
       return V
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-alpha.10",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -62,22 +62,26 @@
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "build:node": "npx esbuild@0.19.10 index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
-    "prebuild:wasm": "node build/wasm.js --prebuild",
+    "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
     "build:wasm": "node build/wasm.js --docker",
     "generate-pem": "node scripts/generate-pem.js",
     "lint": "eslint --cache",
     "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE=  npm run test:typescript",
     "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp -p \"test/busboy/*.js\"",
     "test:cache": "borp -p \"test/cache/*.js\"",
+    "test:sqlite": "NODE_OPTIONS=--experimental-sqlite borp -p \"test/cache-interceptor/*.js\"",
+    "test:cache-interceptor": "borp -p \"test/cache-interceptor/*.js\"",
     "test:cookies": "borp -p \"test/cookie/*.js\"",
     "test:eventsource": "npm run build:node && borp --expose-gc -p \"test/eventsource/*.js\"",
     "test:fuzzing": "node test/fuzzing/fuzzing.test.js",
     "test:fetch": "npm run build:node && borp --timeout 180000 --expose-gc --concurrency 1 -p \"test/fetch/*.js\" && npm run test:webidl && npm run test:busboy",
+    "test:h2": "npm run test:h2:core && npm run test:h2:fetch",
+    "test:h2:core": "borp -p \"test/http2*.js\"",
+    "test:h2:fetch": "npm run build:node && borp -p \"test/fetch/http2*.js\"",
     "test:interceptors": "borp -p \"test/interceptors/*.js\"",
     "test:jest": "cross-env NODE_V8_COVERAGE= jest",
     "test:unit": "borp --expose-gc -p \"test/*.js\"",
@@ -104,13 +108,14 @@
   "devDependencies": {
     "@fastify/busboy": "3.0.0",
     "@matteo.collina/tspl": "^0.1.1",
-    "@sinonjs/fake-timers": "^11.1.0",
-    "@types/node": "~18.17.19",
+    "@sinonjs/fake-timers": "^12.0.0",
+    "@types/node": "^18.19.50",
     "abort-controller": "^3.0.0",
-    "borp": "^0.17.0",
+    "borp": "^0.19.0",
     "c8": "^10.0.0",
     "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
+    "esbuild": "^0.24.0",
     "eslint": "^9.9.0",
     "fast-check": "^3.17.1",
     "https-pem": "^3.0.0",
@@ -118,14 +123,13 @@
     "jest": "^29.0.2",
     "neostandard": "^0.11.2",
     "node-forge": "^1.3.1",
-    "pre-commit": "^1.2.2",
     "proxy": "^2.1.1",
-    "tsd": "^0.31.0",
-    "typescript": "^5.0.2",
+    "tsd": "^0.31.2",
+    "typescript": "^5.6.2",
     "ws": "^8.11.0"
   },
   "engines": {
-    "node": ">=18.17"
+    "node": ">=20.18.1"
   },
   "tsd": {
     "directory": "test/types",

package/types/agent.d.ts

@@ -11,7 +11,7 @@ declare class Agent extends Dispatcher {
   /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
   destroyed: boolean
   /** Dispatches a request. */
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
 }
 
 declare namespace Agent {