@openclaw/slack 2026.10.10-beta.5 → 2026.10.10

package/node_modules/@slack/bolt/node_modules/body-parser/lib/read.js

@@ -17,7 +17,7 @@ const iconv = require('iconv-lite')
 const onFinished = require('on-finished')
 const zlib = require('node:zlib')
 const hasBody = require('type-is').hasBody
-const { getCharset } = require('./utils')
+const contentType = require('content-type')
 
 /**
  * Module exports.
@@ -25,6 +25,12 @@ const { getCharset } = require('./utils')
 
 module.exports = read
 
+/**
+ * @const
+ * whether current node version has zstandard support
+ */
+const hasZstandardSupport = 'createZstdDecompress' in zlib
+
 /**
  * Read a request into a buffer and parse.
  *
@@ -79,38 +85,53 @@ function read (req, res, next, parse, debug, options) {
   }
 
   let length
-  const opts = options
   let stream
 
-  // read options
-  const verify = opts.verify
+  const verify = options.verify
+
+  // assert charset is supported before creating the decompression stream, so an
+  // unsupported charset cannot leave a decoder piped with no error listener
+  if (verify && encoding !== null && !iconv.encodingExists(encoding)) {
+    return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
+      charset: encoding.toLowerCase(),
+      type: 'charset.unsupported'
+    }))
+  }
 
   try {
+    const contentEncoding = (req.headers['content-encoding'] || 'identity').toLowerCase()
+
+    debug('content-encoding "%s"', contentEncoding)
+
+    if (options.inflate === false && contentEncoding !== 'identity') {
+      throw createError(415, 'content encoding unsupported', {
+        encoding: contentEncoding,
+        type: 'encoding.unsupported'
+      })
+    }
+
     // get the content stream
-    stream = contentstream(req, debug, opts.inflate)
-    length = stream.length
-    stream.length = undefined
+    if (contentEncoding === 'identity') {
+      length = req.headers['content-length']
+      stream = req
+    } else {
+      stream = createDecompressionStream(contentEncoding, debug)
+      req.pipe(stream)
+    }
   } catch (err) {
     return next(err)
   }
 
   // set raw-body options
-  opts.length = length
-  opts.encoding = verify
-    ? null
-    : encoding
-
-  // assert charset is supported
-  if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) {
-    return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
-      charset: encoding.toLowerCase(),
-      type: 'charset.unsupported'
-    }))
+  const rawBodyOptions = {
+    length,
+    encoding: verify ? null : encoding,
+    limit: options.limit
   }
 
   // read body
   debug('read body')
-  getBody(stream, opts, function (error, body) {
+  getBody(stream, rawBodyOptions, function (error, body) {
     if (error) {
       let _error
 
@@ -138,6 +159,17 @@ function read (req, res, next, parse, debug, options) {
       return
     }
 
+    // detach and destroy the decompression stream to
+    // avoid decompression errors on the finished stream
+    if (stream !== req) {
+      req.unpipe(stream)
+      stream.on('error', () => {})
+      stream.destroy()
+
+      // consume any remaining bytes so the HTTP request can finish
+      req.resume()
+    }
+
     // verify
     if (verify) {
       try {
@@ -145,7 +177,7 @@ function read (req, res, next, parse, debug, options) {
         verify(req, res, body, encoding)
       } catch (err) {
         next(createError(403, err, {
-          body: body,
+          body,
           type: err.type || 'entity.verify.failed'
         }))
         return
@@ -172,38 +204,6 @@ function read (req, res, next, parse, debug, options) {
   })
 }
 
-/**
- * Get the content stream of the request.
- *
- * @param {Object} req
- * @param {Function} debug
- * @param {boolean} inflate
- * @returns {Object}
- * @private
- */
-function contentstream (req, debug, inflate) {
-  const encoding = (req.headers['content-encoding'] || 'identity').toLowerCase()
-  const length = req.headers['content-length']
-
-  debug('content-encoding "%s"', encoding)
-
-  if (inflate === false && encoding !== 'identity') {
-    throw createError(415, 'content encoding unsupported', {
-      encoding: encoding,
-      type: 'encoding.unsupported'
-    })
-  }
-
-  if (encoding === 'identity') {
-    req.length = length
-    return req
-  }
-
-  const stream = createDecompressionStream(encoding, debug)
-  req.pipe(stream)
-  return stream
-}
-
 /**
  * Create a decompression stream for the given encoding.
  * @param {string} encoding
@@ -222,12 +222,16 @@ function createDecompressionStream (encoding, debug) {
     case 'br':
       debug('brotli decompress body')
       return zlib.createBrotliDecompress()
-    default:
-      throw createError(415, 'unsupported content encoding "' + encoding + '"', {
-        encoding: encoding,
-        type: 'encoding.unsupported'
-      })
+    case 'zstd':
+      if (hasZstandardSupport) {
+        debug('zstd decompress body')
+        return zlib.createZstdDecompress()
+      }
   }
+  throw createError(415, 'unsupported content encoding "' + encoding + '"', {
+    encoding,
+    type: 'encoding.unsupported'
+  })
 }
 
 /**
@@ -245,3 +249,16 @@ function dump (req, callback) {
     req.resume()
   }
 }
+
+/**
+ * Get the charset of a request.
+ *
+ * @param {Object} req
+ * @returns {string | undefined}
+ * @private
+ */
+function getCharset (req) {
+  const header = req.headers['content-type']
+  if (!header) return undefined
+  return contentType.parse(header).parameters.charset?.toLowerCase()
+}

package/node_modules/@slack/bolt/node_modules/body-parser/lib/types/json.js

@@ -23,7 +23,7 @@ const { normalizeOptions } = require('../utils')
 module.exports = json
 
 /**
- * RegExp to match the first non-space in a string.
+ * RegExp to match the first non-whitespace character in a string.
  *
  * Allowed whitespace is defined in RFC 7159:
  *
@@ -33,7 +33,7 @@ module.exports = json
  *            %x0A /              ; Line feed or New line
  *            %x0D )              ; Carriage return
  */
-const FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/ // eslint-disable-line no-control-regex
+const FIRST_NON_WHITESPACE_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d]|$)/ // eslint-disable-line no-control-regex
 
 const JSON_SYNTAX_CHAR = '#'
 const JSON_SYNTAX_REGEXP = /#+/g
@@ -80,10 +80,12 @@ function createJsonParser (options) {
         return {}
       }
 
-      const first = firstchar(body)
-      if (first !== '{' && first !== '[') {
-        debug('strict violation')
-        throw createStrictSyntaxError(body, first)
+      if (body[0] !== '{' && body[0] !== '[') {
+        const first = firstNonWhitespaceChar(body)
+        if (first !== '{' && first !== '[') {
+          debug('strict violation')
+          throw createStrictSyntaxError(body, first)
+        }
       }
 
       try {
@@ -152,12 +154,10 @@ function createStrictSyntaxError (str, char) {
  * @returns {string|undefined}
  * @private
  */
-function firstchar (str) {
-  const match = FIRST_CHAR_REGEXP.exec(str)
+function firstNonWhitespaceChar (str) {
+  const match = FIRST_NON_WHITESPACE_REGEXP.exec(str)
 
-  return match
-    ? match[1]
-    : undefined
+  return match && match[1] ? match[1] : undefined
 }
 
 /**

package/node_modules/@slack/bolt/node_modules/body-parser/lib/types/urlencoded.js

@@ -98,12 +98,12 @@ function createQueryParser (options) {
     try {
       return qs.parse(body, {
         allowPrototypes: true,
-        arrayLimit: arrayLimit,
-        depth: depth,
-        charsetSentinel: charsetSentinel,
-        interpretNumericEntities: interpretNumericEntities,
+        arrayLimit,
+        depth,
+        charsetSentinel,
+        interpretNumericEntities,
         charset: encoding,
-        parameterLimit: parameterLimit,
+        parameterLimit,
         strictDepth: true
       })
     } catch (err) {

package/node_modules/@slack/bolt/node_modules/body-parser/lib/utils.js

@@ -5,31 +5,16 @@
  */
 
 const bytes = require('bytes')
-const contentType = require('content-type')
 const typeis = require('type-is')
 
 /**
  * Module exports.
  */
 module.exports = {
-  getCharset,
   normalizeOptions,
   passthrough
 }
 
-/**
- * Get the charset of a request.
- *
- * @param {Object} req
- * @returns {string | undefined}
- * @private
- */
-function getCharset (req) {
-  const header = req.headers['content-type']
-  if (!header) return undefined
-  return contentType.parse(header).parameters.charset?.toLowerCase()
-}
-
 /**
  * Get the simple type checker.
  *

package/node_modules/@slack/bolt/node_modules/body-parser/package.json

@@ -1,7 +1,7 @@
 {
   "name": "body-parser",
   "description": "Node.js body parsing middleware",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "contributors": [
     "Douglas Christopher Wilson <doug@somethingdoug.com>",
     "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
@@ -27,26 +27,21 @@
   },
   "dependencies": {
     "bytes": "^3.1.2",
-    "content-type": "^2.0.0",
+    "content-type": "^2.1.0",
     "debug": "^4.4.3",
     "http-errors": "^2.0.1",
-    "iconv-lite": "^0.7.2",
+    "iconv-lite": "^0.7.3",
     "on-finished": "^2.4.1",
-    "qs": "^6.15.2",
+    "qs": "^6.16.1",
     "raw-body": "^3.0.2",
     "type-is": "^2.1.0"
   },
   "devDependencies": {
-    "eslint": "^8.57.1",
-    "eslint-config-standard": "^14.1.1",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-markdown": "^3.0.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.6.0",
-    "eslint-plugin-standard": "^4.1.0",
+    "eslint": "^9.39.5",
     "mocha": "^11.7.6",
+    "neostandard": "^0.13.0",
     "nyc": "^17.1.0",
-    "supertest": "^7.2.2"
+    "supertest": "7.3.0"
   },
   "files": [
     "lib/",

package/node_modules/undici/README.md

@@ -86,6 +86,24 @@ Using [benchmark-http2.js](https://github.com/nodejs/undici/blob/main/benchmarks
 
 Node.js includes a built-in `fetch()` implementation powered by undici starting from Node.js v18. However, there are important differences between using the built-in fetch and installing undici as a separate module.
 
+### WebAssembly requirement
+
+Undici's HTTP/1 parser requires WebAssembly. There is no alternative parser when
+WebAssembly is unavailable, for example in Node.js configurations where
+`--jitless` disables it. The existence of `fetch` does not imply that it can make
+HTTP/1 requests in that environment.
+
+When the HTTP/1 parser is needed without WebAssembly, Client and dispatcher
+requests fail with an `Error` whose code is `ERR_WEBASSEMBLY_NOT_SUPPORTED`.
+`fetch` rejects with a `TypeError` carrying that error in `error.cause`. Importing
+Undici, accessing `fetch`, and using `Headers`, `FormData`, `Request`, or `Response`
+do not themselves require the HTTP/1 parser.
+
+The error is defined locally in Undici and does not depend on Node.js providing
+that error code. For built-in fetch, this behavior depends on the bundled Undici
+version. Node.js receives upstream fixes through its normal vendored Undici
+update, rather than changes to the generated bundle alone.
+
 ### Built-in Fetch (Node.js v18+)
 
 Node.js's built-in fetch is powered by a bundled version of undici:
@@ -773,14 +791,18 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
 
 ## Collaborators
 
-* [__Daniele Belardi__](https://github.com/dnlup), <https://www.npmjs.com/~dnlup>
-* [__Ethan Arrowood__](https://github.com/ethan-arrowood), <https://www.npmjs.com/~ethan_arrowood>
+* [__Aras Abbasi__](https://github.com/Uzlopak)
+* [__Carlos Fuentes__](https://github.com/metcoder95), <https://www.npmjs.com/~metcoder95>
+* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood), <https://www.npmjs.com/~ethan_arrowood>
 * [__Matteo Collina__](https://github.com/mcollina), <https://www.npmjs.com/~matteo.collina>
 * [__Matthew Aitken__](https://github.com/KhafraDev), <https://www.npmjs.com/~khaf>
+* [__Mert Can Altin__](https://github.com/mertcanaltin), <https://www.npmjs.com/~mertcanaltin>
 * [__Robert Nagy__](https://github.com/ronag), <https://www.npmjs.com/~ronag>
-* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
+* [__Trivikram Kamat__](https://github.com/trivikr), <https://www.npmjs.com/~trivikr>
+* [__tsctx__](https://github.com/tsctx)
 
 ## Past Collaborators
+* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
 * [__Tomas Della Vedova__](https://github.com/delvedor), <https://www.npmjs.com/~delvedor>
 
 ### Releasers

package/node_modules/undici/docs/docs/api/CacheStore.md

@@ -42,7 +42,8 @@ added: v7.0.0
 Stores cached responses in memory. The store enforces upper bounds on the total
 number of responses, the total size of all responses, and the size of any single
 response. When a limit is exceeded, the store evicts approximately half of its
-entries and emits a [`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
+entries, least recently used first, and emits a
+[`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
 
 ```mjs
 import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -163,7 +164,9 @@ added: v7.0.0
 -->
 
 Stores cached responses in a SQLite database using the [`node:sqlite`][] API.
-The constructor throws when [`node:sqlite`][] is not available.
+The constructor throws when [`node:sqlite`][] is not available. Response bodies
+larger than `compressThreshold` are stored compressed with zstd and
+decompressed when read back, saving database space.
 
 ```mjs
 import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -189,9 +192,16 @@ added: v7.0.0
   * `maxEntrySize` {number} The maximum size, in bytes, of a single response
     body. Responses whose body exceeds this value are not cached. Must not
     exceed `2000000000` (2 GB). **Default:** `2000000000` (2 GB).
+  * `compressThreshold` {number} The size, in bytes, above which a response
+    body is stored compressed with zstd. Responses with an easily compressible
+    Content-Type (e.g. json, xml, plain text) are compressed regardless of
+    size. Requires a Node version with zstd
+    support (22.19+); when unavailable, bodies are stored uncompressed.
+    **Default:** `1048576` (1 MiB).
 
-`maxCount` and `maxEntrySize` must be non-negative integers; a `TypeError` is
-thrown otherwise, or if `maxEntrySize` is greater than 2 GB.
+`maxCount`, `maxEntrySize`, and `compressThreshold` must be non-negative
+integers; a `TypeError` is thrown otherwise, or if `maxEntrySize` is greater
+than 2 GB.
 
 ### `sqliteCacheStore.close()`
 
@@ -225,7 +235,8 @@ added: v7.0.0
   See [`GetResult`](#getresult).
 
 Looks up a cached response for `key`, comparing the request method and every
-header named in the stored `vary` map.
+header named in the stored `vary` map. A body that was stored compressed is
+decompressed before being returned.
 
 ### `sqliteCacheStore.set(key, value)`
 
@@ -240,9 +251,11 @@ added: v7.0.0
 * Returns: {undefined}
 
 Writes a response into the database directly, without going through a stream. If
-the body exceeds `maxEntrySize`, nothing is stored. When an entry already exists
-for `key` it is overwritten; otherwise a new row is inserted and old entries are
-pruned to honour `maxCount`. This method is used internally by
+the body exceeds `maxEntrySize`, nothing is stored. A body larger than
+`compressThreshold`, or with an easily compressible Content-Type (e.g. json,
+xml, plain text), is compressed with zstd before being written. When an entry
+already exists for `key` it is overwritten; otherwise a new row is inserted and
+old entries are pruned to honour `maxCount`. This method is used internally by
 [`sqliteCacheStore.createWriteStream()`](#sqlitecachestorecreatewritestreamkey-value).
 
 ### `sqliteCacheStore.createWriteStream(key, value)`
@@ -260,7 +273,9 @@ added: v7.0.0
 
 Returns a {Writable} stream used to write the response body into the store. When
 the stream finishes, the buffered body is committed via
-[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value). If the body exceeds
+[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value), where bodies larger
+than `compressThreshold` or with an easily compressible Content-Type are
+compressed with zstd. If the body exceeds
 `maxEntrySize`, the stream is destroyed and nothing is stored.
 
 ### `sqliteCacheStore.delete(key)`

package/node_modules/undici/docs/docs/api/Client.md

@@ -116,8 +116,8 @@ added: v1.0.0
   * `maxConcurrentStreams` {number} _Deprecated: use h2Options.useH2c instead_ The maximum number of concurrent HTTP/2
     streams for a single session. Once h2 is negotiated this — not `pipelining`,
     which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
-    It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
-    frame. **Default:** `100`.
+    The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+    not raise it. **Default:** `100`.
   * `connectionWindowSize` {number} _Deprecated: use h2Options.connectionWindowSize instead_ The HTTP/2 connection-level flow-control
     window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
     positive integer. **Default:** `524288`.
@@ -130,8 +130,8 @@ added: v1.0.0
     * `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
       streams for a single session. Once h2 is negotiated this — not `pipelining`,
       which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
-      It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
-      frame. **Default:** `100`.
+      The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+      not raise it. **Default:** `100`.
     * `connectionWindowSize` {number} The HTTP/2 connection-level flow-control
       window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
       positive integer. **Default:** `524288`.
@@ -148,8 +148,13 @@ added: v1.0.0
       payloads, and decompressed (`permessage-deflate`) messages. Set to `0` to
       disable the limit. **Default:** `134217728`.
   * `eventSource` {Object} (optional) EventSource-specific configuration.
-    * `maxEventSize` {number} The maximum allowed event size, in bytes, for
-      EventSource messages. Set to `0` to disable the limit.
+    * `maxEventSize` {number} The maximum total bytes of data and metadata
+      field values retained for a pending EventSource event. Each unfinished
+      line is separately limited to this value plus seven syntax bytes, before
+      its line ending arrives. The number of `data:` lines per event and input
+      chunks buffered for an unfinished line are each limited to
+      `min(131072, max(1024, floor(maxEventSize / 128)))` to bound object overhead.
+      Set to `0` to disable these limits.
       **Default:** `buffer.kStringMaxLength`.
 * Returns: {Client}
 

package/node_modules/undici/docs/docs/api/Dispatcher.md

@@ -209,6 +209,9 @@ added: v4.0.0
   * `path` {string} The request path.
   * `method` {string} The HTTP method, e.g. `'GET'` or `'POST'`.
   * `body` {string|Buffer|Uint8Array|Readable|FormData|null} The request body.
+    Undici's network clients require a `FormData` body created by the same
+    undici package instance. A body from another source, including Node.js's
+    built-in `FormData`, is rejected with an `InvalidArgumentError`.
     **Default:** `null`.
   * `headers` {UndiciHeaders} Request headers. **Default:** `null`.
   * `query` {Object} Query string parameters embedded into the request URL. Both

package/node_modules/undici/docs/docs/api/Errors.md

@@ -18,7 +18,7 @@ if (err instanceof errors.ConnectTimeoutError) {
 }
 ```
 
-All errors, except [`HTTPParserError`][], extend [`UndiciError`][]. Each error
+All errors, except [`HTTPParserError`][] and `WebAssemblyNotSupportedError`, extend [`UndiciError`][]. Each error
 carries a stable `code` string (for example `UND_ERR_CONNECT_TIMEOUT`) and a
 `name`.
 
@@ -32,6 +32,37 @@ if (err.code === 'UND_ERR_CONNECT_TIMEOUT') {
 }
 ```
 
+## Timeout-related errors
+
+The timeout errors below are controlled by dispatcher/client options:
+
+| Error code | When it is thrown | Related option |
+| ---------- | ----------------- | -------------- |
+| `UND_ERR_CONNECT_TIMEOUT` | A connection could not be established before the connection timeout elapsed. | [`connect.timeout`](Client.md) |
+| `UND_ERR_HEADERS_TIMEOUT` | The full response headers were not received before the headers timeout elapsed. | [`headersTimeout`](Client.md) |
+| `UND_ERR_BODY_TIMEOUT` | While reading the response body, no new data arrived before the body timeout elapsed. | [`bodyTimeout`](Client.md) |
+| `UND_ERR_SOCKET` | A generic socket-level failure happened. | Inspect `error.socket` for connection details. |
+
+### Configuring timeouts for `fetch`
+
+If you are using `fetch` (including Node.js built-in `fetch`), configure timeouts
+through the global dispatcher:
+
+```js
+import { Agent, setGlobalDispatcher, fetch } from 'undici'
+
+setGlobalDispatcher(new Agent({
+  connect: { timeout: 10_000 }, // connection phase
+  headersTimeout: 15_000, // wait for response headers
+  bodyTimeout: 30_000 // wait between response body chunks
+}))
+
+await fetch('https://example.com/data')
+```
+
+You can inspect timeout error codes from `error.code` or (for wrapped fetch
+errors) from `error.cause?.code`.
+
 ## Class: `UndiciError`
 
 <!-- YAML
@@ -52,6 +83,35 @@ on a well-known symbol rather than the prototype chain.
 * `name` {string} Always `'UndiciError'`.
 * `code` {string} Always `'UND_ERR'`.
 
+## Class: `WebAssemblyNotSupportedError`
+
+* Extends: {Error}
+
+WebAssembly is unavailable when Undici initializes its HTTP/1 parser. Undici does
+not provide an alternative parser for environments without WebAssembly, including
+Node.js configurations where `--jitless` disables it. The check is performed when
+the parser is needed, not when importing Undici or accessing `fetch`.
+
+* `name` {string} Always `'Error'`.
+* `code` {string} Always `'ERR_WEBASSEMBLY_NOT_SUPPORTED'`.
+* `message` {string} By default `'WebAssembly is not supported in this environment, but is required for HTTP/1 parsing'`.
+
+Client and dispatcher requests report this error directly. `fetch` rejects with
+a `TypeError` whose `cause` is this error:
+
+```js
+try {
+  await fetch('http://localhost:3000')
+} catch (error) {
+  if (error.cause?.code === 'ERR_WEBASSEMBLY_NOT_SUPPORTED') {
+    // HTTP/1 parsing requires WebAssembly in this environment.
+  }
+}
+```
+
+`Headers`, `FormData`, `Request`, `Response`, and other operations that do not need
+the HTTP/1 parser remain usable without WebAssembly.
+
 ## Class: `ConnectTimeoutError`
 
 <!-- YAML
@@ -436,6 +496,7 @@ The response returned an error status code. This is raised, for example, when th
 * `code` {string} Always `'UND_ERR_RESPONSE'`.
 * `statusCode` {number} The HTTP status code of the response.
 * `body` {Object|string|null} The response body.
+* `bodyTruncated` {boolean} Whether `body` was truncated by a configured limit.
 * `headers` {Object|string[]|null} The response headers.
 
 ### `new ResponseError(message, code, options)`
@@ -445,6 +506,7 @@ The response returned an error status code. This is raised, for example, when th
 * `options` {Object}
   * `headers` {Object|string[]|null} The response headers. (optional)
   * `body` {Object|string|null} The response body. (optional)
+  * `bodyTruncated` {boolean} Whether `body` was truncated. **Default:** `false`.
 
 ## Class: `ProxyConnectionError`
 
@@ -512,6 +574,19 @@ The maximum number of allowed origins has been reached.
 * `name` {string} Always `'MaxOriginsReachedError'`.
 * `code` {string} Always `'UND_ERR_MAX_ORIGINS_REACHED'`.
 
+## Class: `MaxRedirectsError`
+
+<!-- YAML
+added: v8.12.0
+-->
+
+* Extends: {UndiciError}
+
+The maximum number of redirects has been reached.
+
+* `name` {string} Always `'MaxRedirectsError'`.
+* `code` {string} Always `'UND_ERR_REDIRECT_MAX'`.
+
 ## Class: `Socks5ProxyError`
 
 <!-- YAML

package/node_modules/undici/docs/docs/api/H2CClient.md

@@ -55,8 +55,9 @@ added: v7.7.0
   hostname, and port. Only the `http:` protocol is supported.
 * `options` {H2CClientOptions} (optional)
   * `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
-    streams for the session. It is advertised to the server and may be overridden
-    by a remote `SETTINGS` frame. Must be a positive integer. **Default:** `100`.
+    streams for the session. The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can
+    lower this limit, but not raise it. Must be a positive integer.
+    **Default:** `100`.
   * `pipelining` {number} The number of concurrent requests multiplexed over the
     single connection. For an `H2CClient` this is aliased to
     `maxConcurrentStreams` and may not exceed it. Must be a positive integer.