undici 7.1.1 → 7.2.1

package/docs/docs/api/DiagnosticsChannel.md

@@ -40,7 +40,7 @@ diagnosticsChannel.channel('undici:request:bodySent').subscribe(({ request }) =>
 
 ## `undici:request:headers`
 
-This message is published after the response headers have been received, i.e. the response has been completed.
+This message is published after the response headers have been received.
 
 ```js
 import diagnosticsChannel from 'diagnostics_channel'

package/docs/docs/api/Dispatcher.md

@@ -652,7 +652,7 @@ return null
 
 A faster version of `Dispatcher.request`. This method expects the second argument `factory` to return a [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable) stream which the response will be written to. This improves performance by avoiding creating an intermediate [`stream.Readable`](https://nodejs.org/api/stream.html#stream_readable_streams) stream when the user expects to directly pipe the response body to a [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable) stream.
 
-As demonstrated in [Example 1 - Basic GET stream request](/docs/docs/api/Dispatcher.md#example-1---basic-get-stream-request), it is recommended to use the `option.opaque` property to avoid creating a closure for the `factory` method. This pattern works well with Node.js Web Frameworks such as [Fastify](https://fastify.io). See [Example 2 - Stream to Fastify Response](/docs/docs/api/Dispatch.md#example-2---stream-to-fastify-response) for more details.
+As demonstrated in [Example 1 - Basic GET stream request](/docs/docs/api/Dispatcher.md#example-1-basic-get-stream-request), it is recommended to use the `option.opaque` property to avoid creating a closure for the `factory` method. This pattern works well with Node.js Web Frameworks such as [Fastify](https://fastify.io). See [Example 2 - Stream to Fastify Response](/docs/docs/api/Dispatch.md#example-2-stream-to-fastify-response) for more details.
 
 Arguments:
 

package/lib/handler/cache-handler.js

@@ -6,9 +6,17 @@ const {
   parseVaryHeader,
   isEtagUsable
 } = require('../util/cache')
+const { parseHttpDate } = require('../util/date.js')
 
 function noop () {}
 
+// Status codes that we can use some heuristics on to cache
+const HEURISTICALLY_CACHEABLE_STATUS_CODES = [
+  200, 203, 204, 206, 300, 301, 308, 404, 405, 410, 414, 501
+]
+
+const MAX_RESPONSE_AGE = 2147483647000
+
 /**
  * @typedef {import('../../types/dispatcher.d.ts').default.DispatchHandler} DispatchHandler
  *
@@ -68,17 +76,23 @@ class CacheHandler {
     this.#handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
   }
 
+  /**
+   * @param {import('../../types/dispatcher.d.ts').default.DispatchController} controller
+   * @param {number} statusCode
+   * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
+   * @param {string} statusMessage
+   */
   onResponseStart (
     controller,
     statusCode,
-    headers,
+    resHeaders,
     statusMessage
   ) {
     const downstreamOnHeaders = () =>
       this.#handler.onResponseStart?.(
         controller,
         statusCode,
-        headers,
+        resHeaders,
         statusMessage
       )
 
@@ -87,97 +101,113 @@ class CacheHandler {
       statusCode >= 200 &&
       statusCode <= 399
     ) {
-      // https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-response
+      // Successful response to an unsafe method, delete it from cache
+      //  https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-response
       try {
-        this.#store.delete(this.#cacheKey).catch?.(noop)
+        this.#store.delete(this.#cacheKey)?.catch?.(noop)
       } catch {
         // Fail silently
       }
       return downstreamOnHeaders()
     }
 
-    const cacheControlHeader = headers['cache-control']
-    if (!cacheControlHeader && !headers['expires'] && !this.#cacheByDefault) {
-      // Don't have the cache control header or the cache is full
+    const cacheControlHeader = resHeaders['cache-control']
+    const heuristicallyCacheable = resHeaders['last-modified'] && HEURISTICALLY_CACHEABLE_STATUS_CODES.includes(statusCode)
+    if (
+      !cacheControlHeader &&
+      !resHeaders['expires'] &&
+      !heuristicallyCacheable &&
+      !this.#cacheByDefault
+    ) {
+      // Don't have anything to tell us this response is cachable and we're not
+      //  caching by default
       return downstreamOnHeaders()
     }
 
     const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {}
-    if (!canCacheResponse(this.#cacheType, statusCode, headers, cacheControlDirectives)) {
+    if (!canCacheResponse(this.#cacheType, statusCode, resHeaders, cacheControlDirectives)) {
       return downstreamOnHeaders()
     }
 
-    const age = getAge(headers)
-
     const now = Date.now()
-    const staleAt = determineStaleAt(this.#cacheType, now, headers, cacheControlDirectives) ?? this.#cacheByDefault
-    if (staleAt) {
-      let baseTime = now
-      if (headers['date']) {
-        const parsedDate = parseInt(headers['date'])
-        const date = new Date(isNaN(parsedDate) ? headers['date'] : parsedDate)
-        if (date instanceof Date && !isNaN(date)) {
-          baseTime = date.getTime()
-        }
-      }
+    const resAge = resHeaders.age ? getAge(resHeaders.age) : undefined
+    if (resAge && resAge >= MAX_RESPONSE_AGE) {
+      // Response considered stale
+      return downstreamOnHeaders()
+    }
+
+    const resDate = typeof resHeaders.date === 'string'
+      ? parseHttpDate(resHeaders.date)
+      : undefined
+
+    const staleAt =
+      determineStaleAt(this.#cacheType, now, resAge, resHeaders, resDate, cacheControlDirectives) ??
+      this.#cacheByDefault
+    if (staleAt === undefined || (resAge && resAge > staleAt)) {
+      return downstreamOnHeaders()
+    }
 
-      const absoluteStaleAt = staleAt + baseTime
+    const baseTime = resDate ? resDate.getTime() : now
+    const absoluteStaleAt = staleAt + baseTime
+    if (now >= absoluteStaleAt) {
+      // Response is already stale
+      return downstreamOnHeaders()
+    }
 
-      if (now >= absoluteStaleAt || (age && age >= staleAt)) {
-        // Response is already stale
+    let varyDirectives
+    if (this.#cacheKey.headers && resHeaders.vary) {
+      varyDirectives = parseVaryHeader(resHeaders.vary, this.#cacheKey.headers)
+      if (!varyDirectives) {
+        // Parse error
         return downstreamOnHeaders()
       }
+    }
 
-      let varyDirectives
-      if (this.#cacheKey.headers && headers.vary) {
-        varyDirectives = parseVaryHeader(headers.vary, this.#cacheKey.headers)
-        if (!varyDirectives) {
-          // Parse error
-          return downstreamOnHeaders()
-        }
-      }
+    const deleteAt = determineDeleteAt(baseTime, cacheControlDirectives, absoluteStaleAt)
+    const strippedHeaders = stripNecessaryHeaders(resHeaders, cacheControlDirectives)
+
+    /**
+     * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
+     */
+    const value = {
+      statusCode,
+      statusMessage,
+      headers: strippedHeaders,
+      vary: varyDirectives,
+      cacheControlDirectives,
+      cachedAt: resAge ? now - resAge : now,
+      staleAt: absoluteStaleAt,
+      deleteAt
+    }
 
-      const deleteAt = determineDeleteAt(cacheControlDirectives, absoluteStaleAt)
-      const strippedHeaders = stripNecessaryHeaders(headers, cacheControlDirectives)
+    if (typeof resHeaders.etag === 'string' && isEtagUsable(resHeaders.etag)) {
+      value.etag = resHeaders.etag
+    }
 
-      /**
-       * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
-       */
-      const value = {
-        statusCode,
-        statusMessage,
-        headers: strippedHeaders,
-        vary: varyDirectives,
-        cacheControlDirectives,
-        cachedAt: age ? now - (age * 1000) : now,
-        staleAt: absoluteStaleAt,
-        deleteAt
-      }
+    this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value)
+    if (!this.#writeStream) {
+      return downstreamOnHeaders()
+    }
 
-      if (typeof headers.etag === 'string' && isEtagUsable(headers.etag)) {
-        value.etag = headers.etag
-      }
+    const handler = this
+    this.#writeStream
+      .on('drain', () => controller.resume())
+      .on('error', function () {
+        // TODO (fix): Make error somehow observable?
+        handler.#writeStream = undefined
+
+        // Delete the value in case the cache store is holding onto state from
+        //  the call to createWriteStream
+        handler.#store.delete(handler.#cacheKey)
+      })
+      .on('close', function () {
+        if (handler.#writeStream === this) {
+          handler.#writeStream = undefined
+        }
 
-      this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value)
-
-      if (this.#writeStream) {
-        const handler = this
-        this.#writeStream
-          .on('drain', () => controller.resume())
-          .on('error', function () {
-            // TODO (fix): Make error somehow observable?
-            handler.#writeStream = undefined
-          })
-          .on('close', function () {
-            if (handler.#writeStream === this) {
-              handler.#writeStream = undefined
-            }
-
-            // TODO (fix): Should we resume even if was paused downstream?
-            controller.resume()
-          })
-      }
-    }
+        // TODO (fix): Should we resume even if was paused downstream?
+        controller.resume()
+      })
 
     return downstreamOnHeaders()
   }
@@ -207,18 +237,15 @@ class CacheHandler {
  *
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions['type']} cacheType
  * @param {number} statusCode
- * @param {Record<string, string | string[]>} headers
+ * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  */
-function canCacheResponse (cacheType, statusCode, headers, cacheControlDirectives) {
+function canCacheResponse (cacheType, statusCode, resHeaders, cacheControlDirectives) {
   if (statusCode !== 200 && statusCode !== 307) {
     return false
   }
 
-  if (
-    cacheControlDirectives['no-cache'] === true ||
-    cacheControlDirectives['no-store']
-  ) {
+  if (cacheControlDirectives['no-store']) {
     return false
   }
 
@@ -227,13 +254,13 @@ function canCacheResponse (cacheType, statusCode, headers, cacheControlDirective
   }
 
   // https://www.rfc-editor.org/rfc/rfc9111.html#section-4.1-5
-  if (headers.vary?.includes('*')) {
+  if (resHeaders.vary?.includes('*')) {
     return false
   }
 
   // https://www.rfc-editor.org/rfc/rfc9111.html#name-storing-responses-to-authen
-  if (headers.authorization) {
-    if (!cacheControlDirectives.public || typeof headers.authorization !== 'string') {
+  if (resHeaders.authorization) {
+    if (!cacheControlDirectives.public || typeof resHeaders.authorization !== 'string') {
       return false
     }
 
@@ -256,58 +283,77 @@ function canCacheResponse (cacheType, statusCode, headers, cacheControlDirective
 }
 
 /**
- * @param {Record<string, string | string[]>} headers
+ * @param {string | string[]} ageHeader
  * @returns {number | undefined}
  */
-function getAge (headers) {
-  if (!headers.age) {
-    return undefined
-  }
+function getAge (ageHeader) {
+  const age = parseInt(Array.isArray(ageHeader) ? ageHeader[0] : ageHeader)
 
-  const age = parseInt(Array.isArray(headers.age) ? headers.age[0] : headers.age)
-  if (isNaN(age) || age >= 2147483647) {
-    return undefined
-  }
-
-  return age
+  return isNaN(age) ? undefined : age * 1000
 }
 
 /**
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions['type']} cacheType
  * @param {number} now
- * @param {Record<string, string | string[]>} headers
+ * @param {number | undefined} age
+ * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
+ * @param {Date | undefined} responseDate
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  *
- * @returns {number | undefined} time that the value is stale at or undefined if it shouldn't be cached
+ * @returns {number | undefined} time that the value is stale at in seconds or undefined if it shouldn't be cached
  */
-function determineStaleAt (cacheType, now, headers, cacheControlDirectives) {
+function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheControlDirectives) {
   if (cacheType === 'shared') {
     // Prioritize s-maxage since we're a shared cache
     //  s-maxage > max-age > Expire
     //  https://www.rfc-editor.org/rfc/rfc9111.html#section-5.2.2.10-3
     const sMaxAge = cacheControlDirectives['s-maxage']
-    if (sMaxAge) {
-      return sMaxAge * 1000
+    if (sMaxAge !== undefined) {
+      return sMaxAge > 0 ? sMaxAge * 1000 : undefined
     }
   }
 
   const maxAge = cacheControlDirectives['max-age']
-  if (maxAge) {
-    return maxAge * 1000
+  if (maxAge !== undefined) {
+    return maxAge > 0 ? maxAge * 1000 : undefined
   }
 
-  if (headers.expires && typeof headers.expires === 'string') {
+  if (typeof resHeaders.expires === 'string') {
     // https://www.rfc-editor.org/rfc/rfc9111.html#section-5.3
-    const expiresDate = new Date(headers.expires)
-    if (expiresDate instanceof Date && Number.isFinite(expiresDate.valueOf())) {
+    const expiresDate = parseHttpDate(resHeaders.expires)
+    if (expiresDate) {
       if (now >= expiresDate.getTime()) {
         return undefined
       }
 
+      if (responseDate) {
+        if (responseDate >= expiresDate) {
+          return undefined
+        }
+
+        if (age !== undefined && age > (expiresDate - responseDate)) {
+          return undefined
+        }
+      }
+
       return expiresDate.getTime() - now
     }
   }
 
+  if (typeof resHeaders['last-modified'] === 'string') {
+    // https://www.rfc-editor.org/rfc/rfc9111.html#name-calculating-heuristic-fresh
+    const lastModified = new Date(resHeaders['last-modified'])
+    if (isValidDate(lastModified)) {
+      if (lastModified.getTime() >= now) {
+        return undefined
+      }
+
+      const responseAge = now - lastModified.getTime()
+
+      return responseAge * 0.1
+    }
+  }
+
   if (cacheControlDirectives.immutable) {
     // https://www.rfc-editor.org/rfc/rfc8246.html#section-2.2
     return 31536000
@@ -317,10 +363,11 @@ function determineStaleAt (cacheType, now, headers, cacheControlDirectives) {
 }
 
 /**
+ * @param {number} now
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  * @param {number} staleAt
  */
-function determineDeleteAt (cacheControlDirectives, staleAt) {
+function determineDeleteAt (now, cacheControlDirectives, staleAt) {
   let staleWhileRevalidate = -Infinity
   let staleIfError = -Infinity
   let immutable = -Infinity
@@ -334,7 +381,7 @@ function determineDeleteAt (cacheControlDirectives, staleAt) {
   }
 
   if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
-    immutable = 31536000
+    immutable = now + 31536000000
   }
 
   return Math.max(staleAt, staleWhileRevalidate, staleIfError, immutable)
@@ -342,11 +389,11 @@ function determineDeleteAt (cacheControlDirectives, staleAt) {
 
 /**
  * Strips headers required to be removed in cached responses
- * @param {Record<string, string | string[]>} headers
+ * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  * @returns {Record<string, string | string []>}
  */
-function stripNecessaryHeaders (headers, cacheControlDirectives) {
+function stripNecessaryHeaders (resHeaders, cacheControlDirectives) {
   const headersToRemove = [
     'connection',
     'proxy-authenticate',
@@ -360,14 +407,14 @@ function stripNecessaryHeaders (headers, cacheControlDirectives) {
     'age'
   ]
 
-  if (headers['connection']) {
-    if (Array.isArray(headers['connection'])) {
+  if (resHeaders['connection']) {
+    if (Array.isArray(resHeaders['connection'])) {
       // connection: a
       // connection: b
-      headersToRemove.push(...headers['connection'].map(header => header.trim()))
+      headersToRemove.push(...resHeaders['connection'].map(header => header.trim()))
     } else {
       // connection: a, b
-      headersToRemove.push(...headers['connection'].split(',').map(header => header.trim()))
+      headersToRemove.push(...resHeaders['connection'].split(',').map(header => header.trim()))
     }
   }
 
@@ -381,13 +428,21 @@ function stripNecessaryHeaders (headers, cacheControlDirectives) {
 
   let strippedHeaders
   for (const headerName of headersToRemove) {
-    if (headers[headerName]) {
-      strippedHeaders ??= { ...headers }
+    if (resHeaders[headerName]) {
+      strippedHeaders ??= { ...resHeaders }
       delete strippedHeaders[headerName]
     }
   }
 
-  return strippedHeaders ?? headers
+  return strippedHeaders ?? resHeaders
+}
+
+/**
+ * @param {Date} date
+ * @returns {boolean}
+ */
+function isValidDate (date) {
+  return date instanceof Date && Number.isFinite(date.valueOf())
 }
 
 module.exports = CacheHandler

package/lib/handler/retry-handler.js

@@ -133,7 +133,7 @@ class RetryHandler {
         ? Math.min(retryAfterHeader, maxTimeout)
         : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout)
 
-    setTimeout(() => cb(null), retryTimeout).unref()
+    setTimeout(() => cb(null), retryTimeout)
   }
 
   onResponseStart (controller, statusCode, headers, statusMessage) {
@@ -277,7 +277,7 @@ class RetryHandler {
   }
 
   onResponseError (controller, err) {
-    if (!controller || controller.aborted || isDisturbed(this.opts.body)) {
+    if (controller?.aborted || isDisturbed(this.opts.body)) {
       this.handler.onResponseError?.(controller, err)
       return
     }

package/lib/interceptor/cache.js

@@ -103,10 +103,14 @@ function handleUncachedResponse (
 }
 
 /**
+ * @param {import('../../types/dispatcher.d.ts').default.DispatchHandler} handler
+ * @param {import('../../types/dispatcher.d.ts').default.RequestOptions} opts
  * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
  * @param {number} age
+ * @param {any} context
+ * @param {boolean} isStale
  */
-function sendCachedValue (handler, opts, result, age, context) {
+function sendCachedValue (handler, opts, result, age, context, isStale) {
   // TODO (perf): Readable.from path can be optimized...
   const stream = util.isStream(result.body)
     ? result.body
@@ -160,8 +164,13 @@ function sendCachedValue (handler, opts, result, age, context) {
 
   // Add the age header
   // https://www.rfc-editor.org/rfc/rfc9111.html#name-age
-  // TODO (fix): What if headers.age already exists?
-  const headers = age != null ? { ...result.headers, age: String(age) } : result.headers
+  const headers = { ...result.headers, age: String(age) }
+
+  if (isStale) {
+    // Add warning header
+    //  https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Warning
+    headers.warning = '110 - "response is stale"'
+  }
 
   handler.onResponseStart?.(controller, result.statusCode, headers, result.statusMessage)
 
@@ -248,7 +257,7 @@ function handleResult (
       new CacheRevalidationHandler(
         (success, context) => {
           if (success) {
-            sendCachedValue(handler, opts, result, age, context)
+            sendCachedValue(handler, opts, result, age, context, true)
           } else if (util.isStream(result.body)) {
             result.body.on('error', () => {}).destroy()
           }
@@ -264,7 +273,7 @@ function handleResult (
     opts.body.on('error', () => {}).destroy()
   }
 
-  sendCachedValue(handler, opts, result, age, null)
+  sendCachedValue(handler, opts, result, age, null, false)
 }
 
 /**

package/lib/interceptor/dns.js

@@ -213,6 +213,10 @@ class DNSInstance {
     this.#records.set(origin.hostname, records)
   }
 
+  deleteRecords (origin) {
+    this.#records.delete(origin.hostname)
+  }
+
   getHandler (meta, opts) {
     return new DNSDispatchHandler(this, meta, opts)
   }
@@ -261,7 +265,7 @@ class DNSDispatchHandler extends DecoratorHandler {
         break
       }
       case 'ENOTFOUND':
-        this.#state.deleteRecord(this.#origin)
+        this.#state.deleteRecords(this.#origin)
       // eslint-disable-next-line no-fallthrough
       default:
         super.onResponseError(controller, err)
@@ -349,7 +353,7 @@ module.exports = interceptorOpts => {
 
       instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
         if (err) {
-          return handler.onError(err)
+          return handler.onResponseError(null, err)
         }
 
         let dispatchOpts = null

package/lib/util/cache.js

@@ -5,7 +5,6 @@ const {
 } = require('../core/util')
 
 /**
- *
  * @param {import('../../types/dispatcher.d.ts').default.DispatchOptions} opts
  */
 function makeCacheKey (opts) {

package/lib/util/date.js

@@ -0,0 +1,259 @@
+'use strict'
+
+const IMF_DAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
+const IMF_SPACES = [4, 7, 11, 16, 25]
+const IMF_MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
+const IMF_COLONS = [19, 22]
+
+const ASCTIME_SPACES = [3, 7, 10, 19]
+
+const RFC850_DAYS = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-date-time-formats
+ *
+ * @param {string} date
+ * @param {Date} [now]
+ * @returns {Date | undefined}
+ */
+function parseHttpDate (date, now) {
+  // Sun, 06 Nov 1994 08:49:37 GMT    ; IMF-fixdate
+  // Sun Nov  6 08:49:37 1994         ; ANSI C's asctime() format
+  // Sunday, 06-Nov-94 08:49:37 GMT   ; obsolete RFC 850 format
+
+  date = date.toLowerCase()
+
+  switch (date[3]) {
+    case ',': return parseImfDate(date)
+    case ' ': return parseAscTimeDate(date)
+    default: return parseRfc850Date(date, now)
+  }
+}
+
+/**
+ * @see https://httpwg.org/specs/rfc9110.html#preferred.date.format
+ *
+ * @param {string} date
+ * @returns {Date | undefined}
+ */
+function parseImfDate (date) {
+  if (date.length !== 29) {
+    return undefined
+  }
+
+  if (!date.endsWith('gmt')) {
+    // Unsupported timezone
+    return undefined
+  }
+
+  for (const spaceInx of IMF_SPACES) {
+    if (date[spaceInx] !== ' ') {
+      return undefined
+    }
+  }
+
+  for (const colonIdx of IMF_COLONS) {
+    if (date[colonIdx] !== ':') {
+      return undefined
+    }
+  }
+
+  const dayName = date.substring(0, 3)
+  if (!IMF_DAYS.includes(dayName)) {
+    return undefined
+  }
+
+  const dayString = date.substring(5, 7)
+  const day = Number.parseInt(dayString)
+  if (isNaN(day) || (day < 10 && dayString[0] !== '0')) {
+    // Not a number, 0, or it's less than 10 and didn't start with a 0
+    return undefined
+  }
+
+  const month = date.substring(8, 11)
+  const monthIdx = IMF_MONTHS.indexOf(month)
+  if (monthIdx === -1) {
+    return undefined
+  }
+
+  const year = Number.parseInt(date.substring(12, 16))
+  if (isNaN(year)) {
+    return undefined
+  }
+
+  const hourString = date.substring(17, 19)
+  const hour = Number.parseInt(hourString)
+  if (isNaN(hour) || (hour < 10 && hourString[0] !== '0')) {
+    return undefined
+  }
+
+  const minuteString = date.substring(20, 22)
+  const minute = Number.parseInt(minuteString)
+  if (isNaN(minute) || (minute < 10 && minuteString[0] !== '0')) {
+    return undefined
+  }
+
+  const secondString = date.substring(23, 25)
+  const second = Number.parseInt(secondString)
+  if (isNaN(second) || (second < 10 && secondString[0] !== '0')) {
+    return undefined
+  }
+
+  return new Date(Date.UTC(year, monthIdx, day, hour, minute, second))
+}
+
+/**
+ * @see https://httpwg.org/specs/rfc9110.html#obsolete.date.formats
+ *
+ * @param {string} date
+ * @returns {Date | undefined}
+ */
+function parseAscTimeDate (date) {
+  // This is assumed to be in UTC
+
+  if (date.length !== 24) {
+    return undefined
+  }
+
+  for (const spaceIdx of ASCTIME_SPACES) {
+    if (date[spaceIdx] !== ' ') {
+      return undefined
+    }
+  }
+
+  const dayName = date.substring(0, 3)
+  if (!IMF_DAYS.includes(dayName)) {
+    return undefined
+  }
+
+  const month = date.substring(4, 7)
+  const monthIdx = IMF_MONTHS.indexOf(month)
+  if (monthIdx === -1) {
+    return undefined
+  }
+
+  const dayString = date.substring(8, 10)
+  const day = Number.parseInt(dayString)
+  if (isNaN(day) || (day < 10 && dayString[0] !== ' ')) {
+    return undefined
+  }
+
+  const hourString = date.substring(11, 13)
+  const hour = Number.parseInt(hourString)
+  if (isNaN(hour) || (hour < 10 && hourString[0] !== '0')) {
+    return undefined
+  }
+
+  const minuteString = date.substring(14, 16)
+  const minute = Number.parseInt(minuteString)
+  if (isNaN(minute) || (minute < 10 && minuteString[0] !== '0')) {
+    return undefined
+  }
+
+  const secondString = date.substring(17, 19)
+  const second = Number.parseInt(secondString)
+  if (isNaN(second) || (second < 10 && secondString[0] !== '0')) {
+    return undefined
+  }
+
+  const year = Number.parseInt(date.substring(20, 24))
+  if (isNaN(year)) {
+    return undefined
+  }
+
+  return new Date(Date.UTC(year, monthIdx, day, hour, minute, second))
+}
+
+/**
+ * @see https://httpwg.org/specs/rfc9110.html#obsolete.date.formats
+ *
+ * @param {string} date
+ * @param {Date} [now]
+ * @returns {Date | undefined}
+ */
+function parseRfc850Date (date, now = new Date()) {
+  if (!date.endsWith('gmt')) {
+    // Unsupported timezone
+    return undefined
+  }
+
+  const commaIndex = date.indexOf(',')
+  if (commaIndex === -1) {
+    return undefined
+  }
+
+  if ((date.length - commaIndex - 1) !== 23) {
+    return undefined
+  }
+
+  const dayName = date.substring(0, commaIndex)
+  if (!RFC850_DAYS.includes(dayName)) {
+    return undefined
+  }
+
+  if (
+    date[commaIndex + 1] !== ' ' ||
+    date[commaIndex + 4] !== '-' ||
+    date[commaIndex + 8] !== '-' ||
+    date[commaIndex + 11] !== ' ' ||
+    date[commaIndex + 14] !== ':' ||
+    date[commaIndex + 17] !== ':' ||
+    date[commaIndex + 20] !== ' '
+  ) {
+    return undefined
+  }
+
+  const dayString = date.substring(commaIndex + 2, commaIndex + 4)
+  const day = Number.parseInt(dayString)
+  if (isNaN(day) || (day < 10 && dayString[0] !== '0')) {
+    // Not a number, or it's less than 10 and didn't start with a 0
+    return undefined
+  }
+
+  const month = date.substring(commaIndex + 5, commaIndex + 8)
+  const monthIdx = IMF_MONTHS.indexOf(month)
+  if (monthIdx === -1) {
+    return undefined
+  }
+
+  // As of this point year is just the decade (i.e. 94)
+  let year = Number.parseInt(date.substring(commaIndex + 9, commaIndex + 11))
+  if (isNaN(year)) {
+    return undefined
+  }
+
+  const currentYear = now.getUTCFullYear()
+  const currentDecade = currentYear % 100
+  const currentCentury = Math.floor(currentYear / 100)
+
+  if (year > currentDecade && year - currentDecade >= 50) {
+    // Over 50 years in future, go to previous century
+    year += (currentCentury - 1) * 100
+  } else {
+    year += currentCentury * 100
+  }
+
+  const hourString = date.substring(commaIndex + 12, commaIndex + 14)
+  const hour = Number.parseInt(hourString)
+  if (isNaN(hour) || (hour < 10 && hourString[0] !== '0')) {
+    return undefined
+  }
+
+  const minuteString = date.substring(commaIndex + 15, commaIndex + 17)
+  const minute = Number.parseInt(minuteString)
+  if (isNaN(minute) || (minute < 10 && minuteString[0] !== '0')) {
+    return undefined
+  }
+
+  const secondString = date.substring(commaIndex + 18, commaIndex + 20)
+  const second = Number.parseInt(secondString)
+  if (isNaN(second) || (second < 10 && secondString[0] !== '0')) {
+    return undefined
+  }
+
+  return new Date(Date.UTC(year, monthIdx, day, hour, minute, second))
+}
+
+module.exports = {
+  parseHttpDate
+}

package/lib/web/websocket/receiver.js

@@ -24,6 +24,7 @@ const { PerMessageDeflate } = require('./permessage-deflate')
 
 class ByteParser extends Writable {
   #buffers = []
+  #fragmentsBytes = 0
   #byteOffset = 0
   #loop = false
 
@@ -208,16 +209,14 @@ class ByteParser extends Writable {
           this.#state = parserStates.INFO
         } else {
           if (!this.#info.compressed) {
-            this.#fragments.push(body)
+            this.writeFragments(body)
 
             // If the frame is not fragmented, a message has been received.
             // If the frame is fragmented, it will terminate with a fin bit set
             // and an opcode of 0 (continuation), therefore we handle that when
             // parsing continuation frames, not here.
             if (!this.#info.fragmented && this.#info.fin) {
-              const fullMessage = Buffer.concat(this.#fragments)
-              websocketMessageReceived(this.#handler, this.#info.binaryType, fullMessage)
-              this.#fragments.length = 0
+              websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments())
             }
 
             this.#state = parserStates.INFO
@@ -228,7 +227,7 @@ class ByteParser extends Writable {
                 return
               }
 
-              this.#fragments.push(data)
+              this.writeFragments(data)
 
               if (!this.#info.fin) {
                 this.#state = parserStates.INFO
@@ -237,11 +236,10 @@ class ByteParser extends Writable {
                 return
               }
 
-              websocketMessageReceived(this.#handler, this.#info.binaryType, Buffer.concat(this.#fragments))
+              websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments())
 
               this.#loop = true
               this.#state = parserStates.INFO
-              this.#fragments.length = 0
               this.run(callback)
             })
 
@@ -265,34 +263,70 @@ class ByteParser extends Writable {
       return emptyBuffer
     }
 
-    if (this.#buffers[0].length === n) {
-      this.#byteOffset -= this.#buffers[0].length
+    this.#byteOffset -= n
+
+    const first = this.#buffers[0]
+
+    if (first.length > n) {
+      // replace with remaining buffer
+      this.#buffers[0] = first.subarray(n, first.length)
+      return first.subarray(0, n)
+    } else if (first.length === n) {
+      // prefect match
       return this.#buffers.shift()
+    } else {
+      let offset = 0
+      // If Buffer.allocUnsafe is used, extra copies will be made because the offset is non-zero.
+      const buffer = Buffer.allocUnsafeSlow(n)
+      while (offset !== n) {
+        const next = this.#buffers[0]
+        const length = next.length
+
+        if (length + offset === n) {
+          buffer.set(this.#buffers.shift(), offset)
+          break
+        } else if (length + offset > n) {
+          buffer.set(next.subarray(0, n - offset), offset)
+          this.#buffers[0] = next.subarray(n - offset)
+          break
+        } else {
+          buffer.set(this.#buffers.shift(), offset)
+          offset += length
+        }
+      }
+
+      return buffer
+    }
+  }
+
+  writeFragments (fragment) {
+    this.#fragmentsBytes += fragment.length
+    this.#fragments.push(fragment)
+  }
+
+  consumeFragments () {
+    const fragments = this.#fragments
+
+    if (fragments.length === 1) {
+      // single fragment
+      this.#fragmentsBytes = 0
+      return fragments.shift()
     }
 
-    const buffer = Buffer.allocUnsafe(n)
     let offset = 0
+    // If Buffer.allocUnsafe is used, extra copies will be made because the offset is non-zero.
+    const output = Buffer.allocUnsafeSlow(this.#fragmentsBytes)
 
-    while (offset !== n) {
-      const next = this.#buffers[0]
-      const { length } = next
-
-      if (length + offset === n) {
-        buffer.set(this.#buffers.shift(), offset)
-        break
-      } else if (length + offset > n) {
-        buffer.set(next.subarray(0, n - offset), offset)
-        this.#buffers[0] = next.subarray(n - offset)
-        break
-      } else {
-        buffer.set(this.#buffers.shift(), offset)
-        offset += next.length
-      }
+    for (let i = 0; i < fragments.length; ++i) {
+      const buffer = fragments[i]
+      output.set(buffer, offset)
+      offset += buffer.length
     }
 
-    this.#byteOffset -= n
+    this.#fragments = []
+    this.#fragmentsBytes = 0
 
-    return buffer
+    return output
   }
 
   parseCloseBody (data) {

package/lib/web/websocket/util.js

@@ -87,7 +87,7 @@ function toArrayBuffer (buffer) {
   if (buffer.byteLength === buffer.buffer.byteLength) {
     return buffer.buffer
   }
-  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+  return new Uint8Array(buffer).buffer
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.1.1",
+  "version": "7.2.1",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -69,7 +69,7 @@
     "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: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: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 && npm run test:cache-tests",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp -p \"test/busboy/*.js\"",
     "test:cache": "borp -p \"test/cache/*.js\"",
@@ -96,6 +96,7 @@
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt": "node test/wpt/start-fetch.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 && node test/wpt/start-eventsource.mjs",
     "test:wpt:withoutintl": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
+    "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
     "coverage:clean": "node ./scripts/clean-coverage.js",
@@ -106,7 +107,7 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.1.0",
+    "@fastify/busboy": "3.1.1",
     "@matteo.collina/tspl": "^0.1.1",
     "@sinonjs/fake-timers": "^12.0.0",
     "@types/node": "^18.19.50",

package/types/errors.d.ts

@@ -33,6 +33,22 @@ declare namespace Errors {
     code: 'UND_ERR_BODY_TIMEOUT'
   }
 
+  export class ResponseError extends UndiciError {
+    constructor (
+      message: string,
+      code: number,
+      options: {
+        headers?: IncomingHttpHeaders | string[] | null,
+        body?: null | Record<string, any> | string
+      }
+    )
+    name: 'ResponseError'
+    code: 'UND_ERR_RESPONSE'
+    statusCode: number
+    body: null | Record<string, any> | string
+    headers: IncomingHttpHeaders | string[] | null
+  }
+
   export class ResponseStatusCodeError extends UndiciError {
     constructor (
       message?: string,