@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/lib/dispatcher/client-h1.js

@@ -50,156 +50,90 @@ const {
   kMaxResponseSize,
   kOnError,
   kResume,
-  kHTTPContext,
-  kClosed
+  kHTTPContext
 } = require('../core/symbols.js')
 
 const constants = require('../llhttp/constants.js')
 const EMPTY_BUF = Buffer.alloc(0)
 const FastBuffer = Buffer[Symbol.species]
+const addListener = util.addListener
 const removeAllListeners = util.removeAllListeners
 const kIdleSocketValidation = Symbol('kIdleSocketValidation')
 const kIdleSocketValidationTimeout = Symbol('kIdleSocketValidationTimeout')
 const kSocketUsed = Symbol('kSocketUsed')
-const kTypeOfService = Symbol('kTypeOfService')
 
 let extractBody
 
-function lazyllhttp () {
+async function lazyllhttp () {
   const llhttpWasmData = process.env.JEST_WORKER_ID ? require('../llhttp/llhttp-wasm.js') : undefined
 
   let mod
+  try {
+    mod = await WebAssembly.compile(require('../llhttp/llhttp_simd-wasm.js'))
+  } catch (e) {
+    /* istanbul ignore next */
 
-  // We disable wasm SIMD on older versions of Node.js on ppc64 that are broken on Power >=9 architectures.
-  let useWasmSIMD = true
-  if (process.arch === 'ppc64') {
-    const [major, minor] = process.versions.node.split('.').map(n => parseInt(n, 10))
-    if (major < 24 || (major === 24 && minor < 12)) {
-      useWasmSIMD = false
-    }
-  }
-  // The Env Variable UNDICI_NO_WASM_SIMD allows explicitly overriding the default behavior
-  if (process.env.UNDICI_NO_WASM_SIMD === '1') {
-    useWasmSIMD = false
-  } else if (process.env.UNDICI_NO_WASM_SIMD === '0') {
-    useWasmSIMD = true
-  }
-
-  if (useWasmSIMD) {
-    try {
-      mod = new WebAssembly.Module(require('../llhttp/llhttp_simd-wasm.js'))
-    } catch {
-    }
-  }
-
-  if (!mod) {
     // We could check if the error was caused by the simd option not
     // being enabled, but the occurring of this other error
     // * https://github.com/emscripten-core/emscripten/issues/11495
     // got me to remove that check to avoid breaking Node 12.
-    mod = new WebAssembly.Module(llhttpWasmData || require('../llhttp/llhttp-wasm.js'))
+    mod = await WebAssembly.compile(llhttpWasmData || require('../llhttp/llhttp-wasm.js'))
   }
 
-  return new WebAssembly.Instance(mod, {
+  return await WebAssembly.instantiate(mod, {
     env: {
-      /**
-       * @param {number} p
-       * @param {number} at
-       * @param {number} len
-       * @returns {number}
-       */
+      /* eslint-disable camelcase */
+
       wasm_on_url: (p, at, len) => {
+        /* istanbul ignore next */
         return 0
       },
-      /**
-       * @param {number} p
-       * @param {number} at
-       * @param {number} len
-       * @returns {number}
-       */
       wasm_on_status: (p, at, len) => {
         assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
-        return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len))
+        return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
-      /**
-       * @param {number} p
-       * @returns {number}
-       */
       wasm_on_message_begin: (p) => {
         assert(currentParser.ptr === p)
-        return currentParser.onMessageBegin()
+        return currentParser.onMessageBegin() || 0
       },
-      /**
-       * @param {number} p
-       * @param {number} at
-       * @param {number} len
-       * @returns {number}
-       */
       wasm_on_header_field: (p, at, len) => {
         assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
-        return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len))
+        return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
-      /**
-       * @param {number} p
-       * @param {number} at
-       * @param {number} len
-       * @returns {number}
-       */
       wasm_on_header_value: (p, at, len) => {
         assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
-        return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len))
+        return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
-      /**
-       * @param {number} p
-       * @param {number} statusCode
-       * @param {0|1} upgrade
-       * @param {0|1} shouldKeepAlive
-       * @returns {number}
-       */
       wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
         assert(currentParser.ptr === p)
-        return currentParser.onHeadersComplete(statusCode, upgrade === 1, shouldKeepAlive === 1)
+        return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0
       },
-      /**
-       * @param {number} p
-       * @param {number} at
-       * @param {number} len
-       * @returns {number}
-       */
       wasm_on_body: (p, at, len) => {
         assert(currentParser.ptr === p)
         const start = at - currentBufferPtr + currentBufferRef.byteOffset
-        return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len))
+        return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
       },
-      /**
-       * @param {number} p
-       * @returns {number}
-       */
       wasm_on_message_complete: (p) => {
         assert(currentParser.ptr === p)
-        return currentParser.onMessageComplete()
+        return currentParser.onMessageComplete() || 0
       }
 
+      /* eslint-enable camelcase */
     }
   })
 }
 
 let llhttpInstance = null
+let llhttpPromise = lazyllhttp()
+llhttpPromise.catch()
 
-/**
- * @type {Parser|null}
- */
 let currentParser = null
 let currentBufferRef = null
-/**
- * @type {number}
- */
 let currentBufferSize = 0
 let currentBufferPtr = null
-let currentBuffer = null
 
 const USE_NATIVE_TIMER = 0
 const USE_FAST_TIMER = 1
@@ -214,24 +148,17 @@ const TIMEOUT_BODY = 4 | USE_FAST_TIMER
 const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
 
 class Parser {
-  /**
-     * @param {import('./client.js')} client
-     * @param {import('net').Socket} socket
-     * @param {*} llhttp
-     */
   constructor (client, socket, { exports }) {
+    assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0)
+
     this.llhttp = exports
     this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE)
     this.client = client
-    /**
-     * @type {import('net').Socket}
-     */
     this.socket = socket
     this.timeout = null
-    this.timeoutWeakRef = new WeakRef(this)
     this.timeoutValue = null
     this.timeoutType = null
-    this.statusCode = 0
+    this.statusCode = null
     this.statusText = ''
     this.upgrade = false
     this.headers = []
@@ -244,8 +171,8 @@ class Parser {
     this.bytesRead = 0
 
     this.keepAlive = ''
-    this.contentLength = -1
-    this.connectionKeepAlive = false
+    this.contentLength = ''
+    this.connection = ''
     this.maxResponseSize = client[kMaxResponseSize]
   }
 
@@ -266,15 +193,16 @@ class Parser {
 
       if (delay) {
         if (type & USE_FAST_TIMER) {
-          this.timeout = timers.setFastTimeout(onParserTimeout, delay, this.timeoutWeakRef)
+          this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this))
         } else {
-          this.timeout = setTimeout(onParserTimeout, delay, this.timeoutWeakRef)
-          this.timeout?.unref()
+          this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this))
+          this.timeout.unref()
         }
       }
 
       this.timeoutValue = delay
     } else if (this.timeout) {
+      // istanbul ignore else: only for jest
       if (this.timeout.refresh) {
         this.timeout.refresh()
       }
@@ -289,12 +217,13 @@ class Parser {
     }
 
     assert(this.ptr != null)
-    assert(currentParser === null)
+    assert(currentParser == null)
 
     this.llhttp.llhttp_resume(this.ptr)
 
     assert(this.timeoutType === TIMEOUT_BODY)
     if (this.timeout) {
+      // istanbul ignore else: only for jest
       if (this.timeout.refresh) {
         this.timeout.refresh()
       }
@@ -315,36 +244,22 @@ class Parser {
     }
   }
 
-  /**
-   * @param {Buffer} chunk
-   */
-  execute (chunk) {
-    assert(currentParser === null)
+  execute (data) {
     assert(this.ptr != null)
+    assert(currentParser == null)
     assert(!this.paused)
 
     const { socket, llhttp } = this
 
-    // Allocate a new buffer if the current buffer is too small.
-    if (chunk.length > currentBufferSize) {
+    if (data.length > currentBufferSize) {
       if (currentBufferPtr) {
         llhttp.free(currentBufferPtr)
       }
-      // Allocate a buffer that is a multiple of 4096 bytes.
-      currentBufferSize = Math.ceil(chunk.length / 4096) * 4096
+      currentBufferSize = Math.ceil(data.length / 4096) * 4096
       currentBufferPtr = llhttp.malloc(currentBufferSize)
     }
 
-    if (
-      currentBuffer === null ||
-      currentBuffer.buffer !== llhttp.memory.buffer ||
-      currentBuffer.byteOffset !== currentBufferPtr ||
-      currentBuffer.byteLength !== currentBufferSize
-    ) {
-      currentBuffer = new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize)
-    }
-
-    currentBuffer.set(chunk)
+    new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data)
 
     // Call `execute` on the wasm parser.
     // We pass the `llhttp_parser` pointer address, the pointer address of buffer view data,
@@ -354,24 +269,30 @@ class Parser {
       let ret
 
       try {
-        currentBufferRef = chunk
+        currentBufferRef = data
         currentParser = this
-        ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, chunk.length)
+        ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length)
+        /* eslint-disable-next-line no-useless-catch */
+      } catch (err) {
+        /* istanbul ignore next: difficult to make a test case for */
+        throw err
       } finally {
         currentParser = null
         currentBufferRef = null
       }
 
+      const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr
+
       if (ret !== constants.ERROR.OK) {
-        const data = chunk.subarray(llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr)
+        const body = data.subarray(offset)
 
         if (ret === constants.ERROR.PAUSED_UPGRADE) {
-          this.onUpgrade(data)
+          this.onUpgrade(body)
         } else if (ret === constants.ERROR.PAUSED) {
           this.paused = true
-          socket.unshift(data)
+          socket.unshift(body)
         } else {
-          throw this.createError(ret, data)
+          throw this.createError(ret, body)
         }
       }
     } catch (err) {
@@ -382,32 +303,10 @@ class Parser {
   finish () {
     assert(currentParser === null)
     assert(this.ptr != null)
+    assert(!this.paused)
 
     const { llhttp } = this
 
-    // The peer closed the connection. If the body parser was paused by
-    // backpressure we must finish parsing before signalling EOF, otherwise
-    // llhttp_finish() would crash (it used to assert !paused) or report a
-    // half-parsed message. Backpressure is advisory here: onData keeps buffering
-    // delivered bytes into the response stream, so resume across pauses and
-    // drain whatever is still buffered on the socket. A Content-Length/chunked
-    // body reaches on_message_complete during execute(); an EOF-delimited body
-    // stays paused (its length is unknown) and is completed by llhttp_finish().
-    if (this.paused) {
-      let data
-      do {
-        llhttp.llhttp_resume(this.ptr)
-        this.paused = false
-        data = this.socket.read() || EMPTY_BUF
-        this.execute(data)
-      } while (this.paused && data.length > 0)
-
-      if (this.paused) {
-        llhttp.llhttp_resume(this.ptr)
-        this.paused = false
-      }
-    }
-
     let ret
 
     try {
@@ -432,7 +331,7 @@ class Parser {
   createError (ret, data) {
     const { llhttp, contentLength, bytesRead } = this
 
-    if (contentLength !== -1 && bytesRead !== contentLength) {
+    if (contentLength && bytesRead !== parseInt(contentLength, 10)) {
       return new ResponseContentLengthMismatchError()
     }
 
@@ -450,8 +349,8 @@ class Parser {
   }
 
   destroy () {
-    assert(currentParser === null)
     assert(this.ptr != null)
+    assert(currentParser == null)
 
     this.llhttp.llhttp_free(this.ptr)
     this.ptr = null
@@ -464,21 +363,14 @@ class Parser {
     this.paused = false
   }
 
-  /**
-   * @param {Buffer} buf
-   * @returns {0}
-   */
   onStatus (buf) {
     this.statusText = buf.toString()
-    return 0
   }
 
-  /**
-   * @returns {0|-1}
-   */
   onMessageBegin () {
     const { socket, client } = this
 
+    /* istanbul ignore next: difficult to make a test case for */
     if (socket.destroyed) {
       return -1
     }
@@ -493,14 +385,8 @@ class Parser {
       return -1
     }
     request.onResponseStarted()
-
-    return 0
   }
 
-  /**
-   * @param {Buffer} buf
-   * @returns {number}
-   */
   onHeaderField (buf) {
     const len = this.headers.length
 
@@ -511,14 +397,8 @@ class Parser {
     }
 
     this.trackHeader(buf.length)
-
-    return 0
   }
 
-  /**
-   * @param {Buffer} buf
-   * @returns {number}
-   */
   onHeaderValue (buf) {
     let len = this.headers.length
 
@@ -535,27 +415,15 @@ class Parser {
       if (headerName === 'keep-alive') {
         this.keepAlive += buf.toString()
       } else if (headerName === 'connection') {
-        this.connectionKeepAlive =
-          this.headers[len - 1].length === 10 &&
-          util.bufferToLowerCasedHeaderName(this.headers[len - 1]) === 'keep-alive'
+        this.connection += buf.toString()
       }
     } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === 'content-length') {
-      if (this.contentLength === -1) {
-        this.contentLength = 0
-      }
-      for (let i = 0; i < buf.length; i++) {
-        this.contentLength = (this.contentLength * 10) + (buf[i] - 0x30)
-      }
+      this.contentLength += buf.toString()
     }
 
     this.trackHeader(buf.length)
-
-    return 0
   }
 
-  /**
-   * @param {number} len
-   */
   trackHeader (len) {
     this.headersSize += len
     if (this.headersSize >= this.headersMaxSize) {
@@ -563,9 +431,6 @@ class Parser {
     }
   }
 
-  /**
-   * @param {Buffer} head
-   */
   onUpgrade (head) {
     const { upgrade, client, socket, headers, statusCode, statusText } = this
 
@@ -579,9 +444,9 @@ class Parser {
     assert(request)
     assert(request.upgrade || request.method === 'CONNECT')
 
-    this.statusCode = 0
+    this.statusCode = null
     this.statusText = ''
-    this.shouldKeepAlive = false
+    this.shouldKeepAlive = null
 
     this.headers = []
     this.headersSize = 0
@@ -602,24 +467,19 @@ class Parser {
     client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade'))
 
     try {
-      request.onRequestUpgrade(statusCode, headers, socket, statusText)
-    } catch (err) {
-      util.errorRequest(client, request, err)
-      util.destroy(socket, err)
+      request.onUpgrade(statusCode, headers, socket, statusText)
+    } catch (error) {
+      util.errorRequest(client, request, error)
+      util.destroy(socket, error)
     }
 
     client[kResume]()
   }
 
-  /**
-   * @param {number} statusCode
-   * @param {boolean} upgrade
-   * @param {boolean} shouldKeepAlive
-   * @returns {number}
-   */
   onHeadersComplete (statusCode, upgrade, shouldKeepAlive) {
     const { client, socket, headers, statusText } = this
 
+    /* istanbul ignore next: difficult to make a test case for */
     if (socket.destroyed) {
       return -1
     }
@@ -631,6 +491,7 @@ class Parser {
 
     const request = client[kQueue][client[kRunningIdx]]
 
+    /* istanbul ignore next: difficult to make a test case for */
     if (!request) {
       return -1
     }
@@ -655,7 +516,7 @@ class Parser {
     this.shouldKeepAlive = (
       shouldKeepAlive ||
       // Override llhttp value which does not allow keepAlive for HEAD.
-      (request.method === 'HEAD' && !socket[kReset] && this.connectionKeepAlive)
+      (request.method === 'HEAD' && !socket[kReset] && this.connection.toLowerCase() === 'keep-alive')
     )
 
     if (this.statusCode >= 200) {
@@ -664,6 +525,7 @@ class Parser {
         : client[kBodyTimeout]
       this.setTimeout(bodyTimeout, TIMEOUT_BODY)
     } else if (this.timeout) {
+      // istanbul ignore else: only for jest
       if (this.timeout.refresh) {
         this.timeout.refresh()
       }
@@ -706,7 +568,7 @@ class Parser {
       socket[kReset] = true
     }
 
-    const pause = request.onResponseStart(statusCode, headers, this.resume, statusText) === false
+    const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false
 
     if (request.aborted) {
       return -1
@@ -728,10 +590,6 @@ class Parser {
     return pause ? constants.ERROR.PAUSED : 0
   }
 
-  /**
-   * @param {Buffer} buf
-   * @returns {number}
-   */
   onBody (buf) {
     const { client, socket, statusCode, maxResponseSize } = this
 
@@ -744,6 +602,7 @@ class Parser {
 
     assert(this.timeoutType === TIMEOUT_BODY)
     if (this.timeout) {
+      // istanbul ignore else: only for jest
       if (this.timeout.refresh) {
         this.timeout.refresh()
       }
@@ -758,16 +617,11 @@ class Parser {
 
     this.bytesRead += buf.length
 
-    if (request.onResponseData(buf) === false) {
+    if (request.onData(buf) === false) {
       return constants.ERROR.PAUSED
     }
-
-    return 0
   }
 
-  /**
-   * @returns {number}
-   */
   onMessageComplete () {
     const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this
 
@@ -776,7 +630,7 @@ class Parser {
     }
 
     if (upgrade) {
-      return 0
+      return
     }
 
     assert(statusCode >= 100)
@@ -785,29 +639,30 @@ class Parser {
     const request = client[kQueue][client[kRunningIdx]]
     assert(request)
 
-    this.statusCode = 0
+    this.statusCode = null
     this.statusText = ''
     this.bytesRead = 0
-    this.contentLength = -1
+    this.contentLength = ''
     this.keepAlive = ''
-    this.connectionKeepAlive = false
+    this.connection = ''
 
     this.headers = []
     this.headersSize = 0
 
     if (statusCode < 200) {
-      return 0
+      return
     }
 
-    if (request.method !== 'HEAD' && contentLength !== -1 && bytesRead !== contentLength) {
+    /* istanbul ignore next: should be handled by llhttp? */
+    if (request.method !== 'HEAD' && contentLength && bytesRead !== parseInt(contentLength, 10)) {
       util.destroy(socket, new ResponseContentLengthMismatchError())
       return -1
     }
 
-    request.onResponseEnd(headers)
+    request.onComplete(headers)
 
     client[kQueue][client[kRunningIdx]++] = null
-    socket[kSocketUsed] = client[kPending] === 0
+    socket[kSocketUsed] = true
 
     if (socket[kWriting]) {
       assert(client[kRunning] === 0)
@@ -828,23 +683,17 @@ class Parser {
       // We must wait a full event loop cycle to reuse this socket to make sure
       // that non-spec compliant servers are not closing the connection even if they
       // said they won't.
-      setImmediate(client[kResume])
+      setImmediate(() => client[kResume]())
     } else {
       client[kResume]()
     }
-
-    return 0
   }
 }
 
-function onParserTimeout (parserWeakRef) {
-  const parser = parserWeakRef.deref()
-  if (!parser) {
-    return
-  }
-
-  const { socket, timeoutType, client, paused } = parser
+function onParserTimeout (parser) {
+  const { socket, timeoutType, client, paused } = parser.deref()
 
+  /* istanbul ignore else */
   if (timeoutType === TIMEOUT_HEADERS) {
     if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
       assert(!paused, 'cannot be paused while waiting for headers')
@@ -860,24 +709,12 @@ function onParserTimeout (parserWeakRef) {
   }
 }
 
-/**
- * @param {import ('./client.js')} client
- * @param {import('net').Socket} socket
- * @returns
- */
-function connectH1 (client, socket) {
+async function connectH1 (client, socket) {
   client[kSocket] = socket
 
   if (!llhttpInstance) {
-    llhttpInstance = lazyllhttp()
-  }
-
-  if (socket.errored) {
-    throw socket.errored
-  }
-
-  if (socket.destroyed) {
-    throw new SocketError('destroyed')
+    llhttpInstance = await llhttpPromise
+    llhttpPromise = null
   }
 
   socket[kNoRef] = false
@@ -889,45 +726,116 @@ function connectH1 (client, socket) {
   socket[kSocketUsed] = false
   socket[kParser] = new Parser(client, socket, llhttpInstance)
 
-  util.addListener(socket, 'error', onHttpSocketError)
-  util.addListener(socket, 'readable', onHttpSocketReadable)
-  util.addListener(socket, 'end', onHttpSocketEnd)
-  util.addListener(socket, 'close', onHttpSocketClose)
+  addListener(socket, 'error', function (err) {
+    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) {
+      const parserErr = parser.finish()
+      if (parserErr) {
+        this[kError] = parserErr
+        this[kClient][kOnError](parserErr)
+      }
+      return
+    }
+
+    this[kError] = err
+
+    this[kClient][kOnError](err)
+  })
+  addListener(socket, 'readable', function () {
+    const parser = this[kParser]
+
+    if (parser) {
+      parser.readMore()
+    }
+  })
+  addListener(socket, 'end', function () {
+    const parser = this[kParser]
+
+    if (parser.statusCode && !parser.shouldKeepAlive) {
+      const parserErr = parser.finish()
+      if (parserErr) {
+        util.destroy(this, parserErr)
+      }
+      return
+    }
+
+    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+  })
+  addListener(socket, 'close', function () {
+    const client = this[kClient]
+    const parser = this[kParser]
+
+    clearIdleSocketValidation(this)
+
+    if (parser) {
+      if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
+        this[kError] = parser.finish() || this[kError]
+      }
+
+      this[kParser].destroy()
+      this[kParser] = null
+    }
+
+    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+    client[kSocket] = null
+    client[kHTTPContext] = null // TODO (fix): This is hacky...
+
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+
+      // Fail entire queue.
+      const requests = client[kQueue].splice(client[kRunningIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(client, request, err)
+      }
+    } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
+      // Fail head of pipeline.
+      const request = client[kQueue][client[kRunningIdx]]
+      client[kQueue][client[kRunningIdx]++] = null
+
+      util.errorRequest(client, request, err)
+    }
+
+    client[kPendingIdx] = client[kRunningIdx]
+
+    assert(client[kRunning] === 0)
 
-  socket[kClosed] = false
-  socket.on('close', onSocketClose)
+    client.emit('disconnect', client[kUrl], [client], err)
+
+    client[kResume]()
+  })
+
+  let closed = false
+  socket.on('close', () => {
+    closed = true
+  })
 
   return {
     version: 'h1',
     defaultPipelining: 1,
-    write (request) {
-      return writeH1(client, request)
+    write (...args) {
+      return writeH1(client, ...args)
     },
     resume () {
       resumeH1(client)
     },
-    /**
-     * @param {Error|undefined} err
-     * @param {() => void} callback
-     */
     destroy (err, callback) {
-      if (socket[kClosed]) {
+      if (closed) {
         queueMicrotask(callback)
       } else {
-        socket.on('close', callback)
-        socket.destroy(err)
+        socket.destroy(err).on('close', callback)
       }
     },
-    /**
-     * @returns {boolean}
-     */
     get destroyed () {
       return socket.destroyed
     },
-    /**
-     * @param {import('../core/request.js')} request
-     * @returns {boolean}
-     */
     busy (request) {
       if (socket[kWriting] || socket[kReset] || socket[kBlocking] || socket[kIdleSocketValidation] === 1) {
         return true
@@ -967,96 +875,6 @@ function connectH1 (client, socket) {
   }
 }
 
-function onHttpSocketError (err) {
-  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) {
-    const parserErr = parser.finish()
-    if (parserErr) {
-      this[kError] = parserErr
-      this[kClient][kOnError](parserErr)
-    }
-    return
-  }
-
-  this[kError] = err
-
-  this[kClient][kOnError](err)
-}
-
-function onHttpSocketReadable () {
-  this[kParser]?.readMore()
-}
-
-function onHttpSocketEnd () {
-  const parser = this[kParser]
-
-  if (parser.statusCode && !parser.shouldKeepAlive) {
-    const parserErr = parser.finish()
-    if (parserErr) {
-      util.destroy(this, parserErr)
-    }
-    return
-  }
-
-  util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
-}
-
-function onHttpSocketClose () {
-  const parser = this[kParser]
-
-  clearIdleSocketValidation(this)
-
-  if (parser) {
-    if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
-      this[kError] = parser.finish() || this[kError]
-    }
-
-    this[kParser].destroy()
-    this[kParser] = null
-  }
-
-  const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
-
-  const client = this[kClient]
-
-  client[kSocket] = null
-  client[kHTTPContext] = null // TODO (fix): This is hacky...
-
-  if (client.destroyed) {
-    assert(client[kPending] === 0)
-
-    // Fail entire queue.
-    const requests = client[kQueue].splice(client[kRunningIdx])
-    for (let i = 0; i < requests.length; i++) {
-      const request = requests[i]
-      util.errorRequest(client, request, err)
-    }
-  } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
-    // Fail head of pipeline.
-    const request = client[kQueue][client[kRunningIdx]]
-    client[kQueue][client[kRunningIdx]++] = null
-
-    util.errorRequest(client, request, err)
-  }
-
-  client[kPendingIdx] = client[kRunningIdx]
-
-  assert(client[kRunning] === 0)
-
-  client.emit('disconnect', client[kUrl], [client], err)
-
-  client[kResume]()
-}
-
-function onSocketClose () {
-  this[kClosed] = true
-}
-
 function clearIdleSocketValidation (socket) {
   if (socket[kIdleSocketValidationTimeout]) {
     clearImmediate(socket[kIdleSocketValidationTimeout])
@@ -1151,37 +969,6 @@ function shouldSendContentLength (method) {
   return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
 }
 
-function setTypeOfService (socket, request) {
-  if (typeof socket.setTypeOfService !== 'function') {
-    return
-  }
-
-  const typeOfService = request.typeOfService
-
-  if (typeOfService === undefined) {
-    return
-  }
-
-  const currentTypeOfService = socket[kTypeOfService]
-
-  if (currentTypeOfService === typeOfService) {
-    return
-  }
-
-  try {
-    socket.setTypeOfService(typeOfService)
-    socket[kTypeOfService] = typeOfService
-  } catch {
-    // QoS marking is best-effort. setTypeOfService() can throw synchronously on
-    // some platforms depending on socket state, but that must not abort the request.
-  }
-}
-
-/**
- * @param {import('./client.js')} client
- * @param {import('../core/request.js')} request
- * @returns
- */
 function writeH1 (client, request) {
   const { method, path, host, upgrade, blocking, reset } = request
 
@@ -1265,22 +1052,28 @@ function writeH1 (client, request) {
   clearIdleSocketValidation(socket)
 
   /**
-   * @param {Error} [err]
-   * @returns {void}
+   * @param {Error} [error]
    */
-  const abort = (err) => {
-    if (request.aborted || request.completed) {
+  const abort = (error) => {
+    if (request.aborted) {
+      return
+    }
+
+    if (request.completed) {
+      if (request.upgrade || request.method === 'CONNECT') {
+        util.destroy(socket, new InformationalError('aborted'))
+      }
       return
     }
 
-    util.errorRequest(client, request, err || new RequestAbortedError())
+    util.errorRequest(client, request, error || new RequestAbortedError())
 
     util.destroy(body)
     util.destroy(socket, new InformationalError('aborted'))
   }
 
   try {
-    request.onRequestStart(abort, null)
+    request.onConnect(abort)
   } catch (err) {
     util.errorRequest(client, request, err)
   }
@@ -1308,7 +1101,7 @@ function writeH1 (client, request) {
     socket[kReset] = reset
   }
 
-  if (client[kMaxRequests] && ++socket[kCounter] >= client[kMaxRequests]) {
+  if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
     socket[kReset] = true
   }
 
@@ -1316,8 +1109,6 @@ function writeH1 (client, request) {
     socket[kBlocking] = true
   }
 
-  setTypeOfService(socket, request)
-
   let header = `${method} ${path} HTTP/1.1\r\n`
 
   if (typeof host === 'string') {
@@ -1353,6 +1144,7 @@ function writeH1 (client, request) {
     channels.sendHeaders.publish({ request, headers: header, socket })
   }
 
+  /* istanbul ignore else: assertion */
   if (!body || bodyLength === 0) {
     writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload)
   } else if (util.isBuffer(body)) {
@@ -1374,16 +1166,6 @@ function writeH1 (client, request) {
   return true
 }
 
-/**
- * @param {AbortCallback} abort
- * @param {import('stream').Stream} body
- * @param {import('./client.js')} client
- * @param {import('../core/request.js')} request
- * @param {import('net').Socket} socket
- * @param {number} contentLength
- * @param {string} header
- * @param {boolean} expectsPayload
- */
 function writeStream (abort, body, client, request, socket, contentLength, header, expectsPayload) {
   assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
 
@@ -1391,10 +1173,6 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
 
   const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
 
-  /**
-   * @param {Buffer} chunk
-   * @returns {void}
-   */
   const onData = function (chunk) {
     if (finished) {
       return
@@ -1408,10 +1186,6 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
       util.destroy(this, err)
     }
   }
-
-  /**
-   * @returns {void}
-   */
   const onDrain = function () {
     if (finished) {
       return
@@ -1421,10 +1195,6 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
       body.resume()
     }
   }
-
-  /**
-   * @returns {void}
-   */
   const onClose = function () {
     // 'close' might be emitted *before* 'error' for
     // broken streams. Wait a tick to avoid this case.
@@ -1439,11 +1209,6 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
       queueMicrotask(() => onFinished(err))
     }
   }
-
-  /**
-   * @param {Error} [err]
-   * @returns
-   */
   const onFinished = function (err) {
     if (finished) {
       return
@@ -1494,9 +1259,9 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
     .on('error', onFinished)
 
   if (body.errorEmitted ?? body.errored) {
-    setImmediate(onFinished, body.errored)
+    setImmediate(() => onFinished(body.errored))
   } else if (body.endEmitted ?? body.readableEnded) {
-    setImmediate(onFinished, null)
+    setImmediate(() => onFinished(null))
   }
 
   if (body.closeEmitted ?? body.closed) {
@@ -1504,24 +1269,6 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
   }
 }
 
-/**
- * @typedef AbortCallback
- * @type {Function}
- * @param {Error} [err]
- * @returns {void}
- */
-
-/**
- * @param {AbortCallback} abort
- * @param {Uint8Array|null} body
- * @param {import('./client.js')} client
- * @param {import('../core/request.js')} request
- * @param {import('net').Socket} socket
- * @param {number} contentLength
- * @param {string} header
- * @param {boolean} expectsPayload
- * @returns {void}
- */
 function writeBuffer (abort, body, client, request, socket, contentLength, header, expectsPayload) {
   try {
     if (!body) {
@@ -1552,18 +1299,9 @@ function writeBuffer (abort, body, client, request, socket, contentLength, heade
   }
 }
 
-/**
- * @param {AbortCallback} abort
- * @param {Blob} body
- * @param {import('./client.js')} client
- * @param {import('../core/request.js')} request
- * @param {import('net').Socket} socket
- * @param {number} contentLength
- * @param {string} header
- * @param {boolean} expectsPayload
- * @returns {Promise<void>}
- */
 async function writeBlob (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength === body.size, 'blob body must have content length')
+
   try {
     if (contentLength != null && contentLength !== body.size) {
       throw new RequestContentLengthMismatchError()
@@ -1589,17 +1327,6 @@ async function writeBlob (abort, body, client, request, socket, contentLength, h
   }
 }
 
-/**
- * @param {AbortCallback} abort
- * @param {Iterable} body
- * @param {import('./client.js')} client
- * @param {import('../core/request.js')} request
- * @param {import('net').Socket} socket
- * @param {number} contentLength
- * @param {string} header
- * @param {boolean} expectsPayload
- * @returns {Promise<void>}
- */
 async function writeIterable (abort, body, client, request, socket, contentLength, header, expectsPayload) {
   assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
 
@@ -1650,17 +1377,6 @@ async function writeIterable (abort, body, client, request, socket, contentLengt
 }
 
 class AsyncWriter {
-  /**
-   *
-   * @param {object} arg
-   * @param {AbortCallback} arg.abort
-   * @param {import('net').Socket} arg.socket
-   * @param {import('../core/request.js')} arg.request
-   * @param {number} arg.contentLength
-   * @param {import('./client.js')} arg.client
-   * @param {boolean} arg.expectsPayload
-   * @param {string} arg.header
-   */
   constructor ({ abort, socket, request, contentLength, client, expectsPayload, header }) {
     this.socket = socket
     this.request = request
@@ -1674,10 +1390,6 @@ class AsyncWriter {
     socket[kWriting] = true
   }
 
-  /**
-   * @param {string|Uint8Array} chunk
-   * @returns
-   */
   write (chunk) {
     const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this
 
@@ -1689,7 +1401,7 @@ class AsyncWriter {
       return false
     }
 
-    const len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk)
+    const len = Buffer.byteLength(chunk)
     if (!len) {
       return true
     }
@@ -1731,6 +1443,7 @@ class AsyncWriter {
 
     if (!ret) {
       if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+        // istanbul ignore else: only for jest
         if (socket[kParser].timeout.refresh) {
           socket[kParser].timeout.refresh()
         }
@@ -1740,9 +1453,6 @@ class AsyncWriter {
     return ret
   }
 
-  /**
-   * @returns {void}
-   */
   end () {
     const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this
     request.onRequestSent()
@@ -1781,6 +1491,7 @@ class AsyncWriter {
     }
 
     if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+      // istanbul ignore else: only for jest
       if (socket[kParser].timeout.refresh) {
         socket[kParser].timeout.refresh()
       }
@@ -1789,10 +1500,6 @@ class AsyncWriter {
     client[kResume]()
   }
 
-  /**
-   * @param {Error} [err]
-   * @returns {void}
-   */
   destroy (err) {
     const { socket, client, abort } = this