@openclaw/discord 2026.9.8 → 2026.10.1-beta.2

package/node_modules/libopus-wasm/dist/index.js

@@ -46,6 +46,7 @@ const DEFAULT_CHANNELS = 2;
 const DEFAULT_FRAME_DURATION_MS = 20;
 const MAX_PACKET_DURATION_MS = 120;
 const DEFAULT_MAX_PACKET_BYTES = 4000;
+const MIN_I32 = -0x8000_0000;
 const MAX_I32 = 0x7fff_ffff;
 const DEFAULT_SAMPLE_RATE = 48_000;
 const DECODER_INTEGER_CTL_REQUESTS = new Set(Object.values(DecoderCtl));
@@ -110,6 +111,31 @@ export async function getPacketInfo(packet, options = {}) {
         module._free(packetPtr);
     }
 }
+class WasmBuffer {
+    module;
+    #bytes = 0;
+    #ptr = 0;
+    constructor(module) {
+        this.module = module;
+    }
+    ensure(requiredBytes) {
+        if (this.#ptr !== 0 && this.#bytes >= requiredBytes) {
+            return this.#ptr;
+        }
+        const nextPtr = checkedMalloc(this.module, requiredBytes);
+        this.free();
+        this.#ptr = nextPtr;
+        this.#bytes = requiredBytes;
+        return this.#ptr;
+    }
+    free() {
+        if (this.#ptr !== 0) {
+            this.module._free(this.#ptr);
+        }
+        this.#ptr = 0;
+        this.#bytes = 0;
+    }
+}
 class WasmOpusEncoder {
     application;
     channels;
@@ -117,18 +143,18 @@ class WasmOpusEncoder {
     sampleRate;
     #freed = false;
     #module;
-    #packetBytes = 0;
-    #packetPtr = 0;
-    #pcmBytes = 0;
-    #pcmPtr = 0;
+    #packet;
+    #pcm;
     #ptr;
     constructor(module, options) {
         this.#module = module;
+        this.#packet = new WasmBuffer(module);
+        this.#pcm = new WasmBuffer(module);
         this.application = options.application;
         this.channels = options.channels;
         this.frameSize = options.frameSize;
         this.sampleRate = options.sampleRate;
-        const errorPtr = module._malloc(4);
+        const errorPtr = checkedMalloc(module, 4);
         try {
             const ptr = module._oc_create_encoder(options.sampleRate, options.channels, options.application, errorPtr);
             const error = module.HEAP32[errorPtr >> 2] ?? 0;
@@ -176,8 +202,8 @@ class WasmOpusEncoder {
         }
         const maxPacketBytes = options.maxPacketBytes ?? DEFAULT_MAX_PACKET_BYTES;
         validateIntegerRange(maxPacketBytes, 1, MAX_I32, "maxPacketBytes");
-        const pcmPtr = this.#ensurePcmBytes(pcmBytes.byteLength);
-        const packetPtr = this.#ensurePacketBytes(maxPacketBytes);
+        const pcmPtr = this.#pcm.ensure(pcmBytes.byteLength);
+        const packetPtr = this.#packet.ensure(maxPacketBytes);
         this.#module.HEAPU8.set(pcmBytes, pcmPtr);
         const encodedBytes = this.#module._oc_encode(this.#ptr, pcmPtr, frameSize, packetPtr, maxPacketBytes);
         if (encodedBytes < 0) {
@@ -195,8 +221,8 @@ class WasmOpusEncoder {
         }
         const maxPacketBytes = options.maxPacketBytes ?? DEFAULT_MAX_PACKET_BYTES;
         validateIntegerRange(maxPacketBytes, 1, MAX_I32, "maxPacketBytes");
-        const pcmPtr = this.#ensurePcmBytes(pcm.byteLength);
-        const packetPtr = this.#ensurePacketBytes(maxPacketBytes);
+        const pcmPtr = this.#pcm.ensure(pcm.byteLength);
+        const packetPtr = this.#packet.ensure(maxPacketBytes);
         this.#module.HEAPF32.set(pcm, pcmPtr >> 2);
         const encodedBytes = this.#module._oc_encode_float(this.#ptr, pcmPtr, frameSize, packetPtr, maxPacketBytes);
         if (encodedBytes < 0) {
@@ -213,7 +239,7 @@ class WasmOpusEncoder {
     encoderCtl(request, value) {
         this.#assertLive();
         validateInteger(request, "request");
-        validateInteger(value, "value");
+        validateIntegerRange(value, MIN_I32, MAX_I32, "value");
         if (!ENCODER_INTEGER_CTL_REQUESTS.has(request)) {
             throw new RangeError("encoderCtl only supports integer setter requests");
         }
@@ -280,7 +306,8 @@ class WasmOpusEncoder {
         if (this.#freed) {
             return;
         }
-        this.#freeScratch();
+        this.#packet.free();
+        this.#pcm.free();
         this.#module._oc_destroy_encoder(this.#ptr);
         this.#freed = true;
     }
@@ -297,42 +324,6 @@ class WasmOpusEncoder {
             throw createOpusError(this.#module, code, operation);
         }
     }
-    #ensurePacketBytes(requiredBytes) {
-        if (this.#packetPtr !== 0 && this.#packetBytes >= requiredBytes) {
-            return this.#packetPtr;
-        }
-        const nextPtr = checkedMalloc(this.#module, requiredBytes);
-        if (this.#packetPtr !== 0) {
-            this.#module._free(this.#packetPtr);
-        }
-        this.#packetPtr = nextPtr;
-        this.#packetBytes = requiredBytes;
-        return this.#packetPtr;
-    }
-    #ensurePcmBytes(requiredBytes) {
-        if (this.#pcmPtr !== 0 && this.#pcmBytes >= requiredBytes) {
-            return this.#pcmPtr;
-        }
-        const nextPtr = checkedMalloc(this.#module, requiredBytes);
-        if (this.#pcmPtr !== 0) {
-            this.#module._free(this.#pcmPtr);
-        }
-        this.#pcmPtr = nextPtr;
-        this.#pcmBytes = requiredBytes;
-        return this.#pcmPtr;
-    }
-    #freeScratch() {
-        if (this.#packetPtr !== 0) {
-            this.#module._free(this.#packetPtr);
-        }
-        if (this.#pcmPtr !== 0) {
-            this.#module._free(this.#pcmPtr);
-        }
-        this.#packetPtr = 0;
-        this.#packetBytes = 0;
-        this.#pcmPtr = 0;
-        this.#pcmBytes = 0;
-    }
 }
 class WasmOpusDecoder {
     channels;
@@ -340,17 +331,17 @@ class WasmOpusDecoder {
     sampleRate;
     #freed = false;
     #module;
-    #packetBytes = 0;
-    #packetPtr = 0;
-    #pcmBytes = 0;
-    #pcmPtr = 0;
+    #packet;
+    #pcm;
     #ptr;
     constructor(module, options) {
         this.#module = module;
+        this.#packet = new WasmBuffer(module);
+        this.#pcm = new WasmBuffer(module);
         this.channels = options.channels;
         this.maxFrameSize = options.maxFrameSize;
         this.sampleRate = options.sampleRate;
-        const errorPtr = module._malloc(4);
+        const errorPtr = checkedMalloc(module, 4);
         try {
             const ptr = module._oc_create_decoder(options.sampleRate, options.channels, errorPtr);
             const error = module.HEAP32[errorPtr >> 2] ?? 0;
@@ -367,7 +358,7 @@ class WasmOpusDecoder {
         this.#assertLive();
         const frameSize = this.#resolveDecodeFrameSize(packet, options);
         const pcmBytes = frameSize * this.channels * 2;
-        const pcmPtr = this.#ensurePcmBytes(pcmBytes);
+        const pcmPtr = this.#pcm.ensure(pcmBytes);
         const { packetLength, packetPtr } = this.#copyPacket(packet, options.decodeFec);
         const decodedSamples = this.#module._oc_decode(this.#ptr, packetPtr, packetLength, pcmPtr, frameSize, options.decodeFec ? 1 : 0);
         if (decodedSamples < 0) {
@@ -380,7 +371,7 @@ class WasmOpusDecoder {
         this.#assertLive();
         const frameSize = this.#resolveDecodeFrameSize(packet, options);
         const pcmBytes = frameSize * this.channels * 4;
-        const pcmPtr = this.#ensurePcmBytes(pcmBytes);
+        const pcmPtr = this.#pcm.ensure(pcmBytes);
         const { packetLength, packetPtr } = this.#copyPacket(packet, options.decodeFec);
         const decodedSamples = this.#module._oc_decode_float(this.#ptr, packetPtr, packetLength, pcmPtr, frameSize, options.decodeFec ? 1 : 0);
         if (decodedSamples < 0) {
@@ -404,7 +395,7 @@ class WasmOpusDecoder {
     decoderCtl(request, value) {
         this.#assertLive();
         validateInteger(request, "request");
-        validateInteger(value, "value");
+        validateIntegerRange(value, MIN_I32, MAX_I32, "value");
         if (!DECODER_INTEGER_CTL_REQUESTS.has(request)) {
             throw new RangeError("decoderCtl only supports integer setter requests");
         }
@@ -417,7 +408,8 @@ class WasmOpusDecoder {
         if (this.#freed) {
             return;
         }
-        this.#freeScratch();
+        this.#packet.free();
+        this.#pcm.free();
         this.#module._oc_destroy_decoder(this.#ptr);
         this.#freed = true;
     }
@@ -439,46 +431,10 @@ class WasmOpusDecoder {
         if (packet.byteLength === 0) {
             throw new RangeError("packet must not be empty; use null or decodePacketLoss() for PLC");
         }
-        const packetPtr = this.#ensurePacketBytes(packet.byteLength);
+        const packetPtr = this.#packet.ensure(packet.byteLength);
         this.#module.HEAPU8.set(packet, packetPtr);
         return { packetLength: packet.byteLength, packetPtr };
     }
-    #ensurePacketBytes(requiredBytes) {
-        if (this.#packetPtr !== 0 && this.#packetBytes >= requiredBytes) {
-            return this.#packetPtr;
-        }
-        const nextPtr = checkedMalloc(this.#module, requiredBytes);
-        if (this.#packetPtr !== 0) {
-            this.#module._free(this.#packetPtr);
-        }
-        this.#packetPtr = nextPtr;
-        this.#packetBytes = requiredBytes;
-        return this.#packetPtr;
-    }
-    #ensurePcmBytes(requiredBytes) {
-        if (this.#pcmPtr !== 0 && this.#pcmBytes >= requiredBytes) {
-            return this.#pcmPtr;
-        }
-        const nextPtr = checkedMalloc(this.#module, requiredBytes);
-        if (this.#pcmPtr !== 0) {
-            this.#module._free(this.#pcmPtr);
-        }
-        this.#pcmPtr = nextPtr;
-        this.#pcmBytes = requiredBytes;
-        return this.#pcmPtr;
-    }
-    #freeScratch() {
-        if (this.#packetPtr !== 0) {
-            this.#module._free(this.#packetPtr);
-        }
-        if (this.#pcmPtr !== 0) {
-            this.#module._free(this.#pcmPtr);
-        }
-        this.#packetPtr = 0;
-        this.#packetBytes = 0;
-        this.#pcmPtr = 0;
-        this.#pcmBytes = 0;
-    }
     #resolveDecodeFrameSize(packet, options) {
         const frameSize = packet === null || options.decodeFec
             ? (options.frameSize ?? options.maxFrameSize ?? samplesForDuration(this.sampleRate, DEFAULT_FRAME_DURATION_MS))
@@ -550,6 +506,10 @@ function normalizeEncoderOptions(options) {
     const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
     const channels = options.channels ?? DEFAULT_CHANNELS;
     validateCodecOptions({ channels, sampleRate });
+    const application = options.application ?? Application.Audio;
+    if (!Object.values(Application).includes(application)) {
+        throw new RangeError("application must be Application.Voip, Application.Audio, or Application.RestrictedLowDelay");
+    }
     const frameSize = options.frameSize ?? samplesForDuration(sampleRate, DEFAULT_FRAME_DURATION_MS);
     validateEncodeFrameSize(frameSize, sampleRate, "frameSize");
     if (options.maxBandwidth !== undefined) {
@@ -564,7 +524,7 @@ function normalizeEncoderOptions(options) {
         throw new RangeError("signal must be Signal.Auto, Signal.Voice, or Signal.Music");
     }
     return {
-        application: options.application ?? Application.Audio,
+        application,
         bitrate: normalizeBitrate(options.bitrate ?? 64_000),
         channels,
         complexity,
@@ -608,7 +568,7 @@ function normalizeBitrate(bitrate) {
     if (bitrate === Bitrate.Auto || bitrate === Bitrate.Max) {
         return bitrate;
     }
-    validatePositiveInteger(bitrate, "bitrate");
+    validateIntegerRange(bitrate, 1, MAX_I32, "bitrate");
     return bitrate;
 }
 function validateBandwidth(bandwidth, name) {
@@ -646,11 +606,6 @@ function validateInteger(value, name) {
         throw new RangeError(`${name} must be an integer`);
     }
 }
-function validatePositiveInteger(value, name) {
-    if (!Number.isInteger(value) || value <= 0) {
-        throw new RangeError(`${name} must be a positive integer`);
-    }
-}
 function validateIntegerRange(value, min, max, name) {
     if (!Number.isInteger(value) || value < min || value > max) {
         throw new RangeError(`${name} must be an integer from ${min} to ${max}`);

package/node_modules/libopus-wasm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libopus-wasm",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Small, modern WASM bindings for libopus raw packet encode/decode.",
   "type": "module",
   "sideEffects": false,
@@ -36,11 +36,11 @@
   ],
   "devDependencies": {
     "@discordjs/opus": "0.10.0",
-    "@types/node": "26.4.1",
-    "@vitest/coverage-v8": "5.0.0",
+    "@types/node": "26.6.2",
+    "@vitest/coverage-v8": "5.0.1",
     "typescript": "^7.0.2",
-    "vite": "8.2.2",
-    "vitest": "5.0.0"
+    "vite": "8.3.0",
+    "vitest": "5.0.1"
   },
   "engines": {
     "node": ">=22"

package/node_modules/undici/README.md

@@ -378,7 +378,16 @@ The `body` mixins are the most common way to format the request/response body. M
 > The body returned from `undici.request` does not implement `.formData()`.
 
 > [!WARNING]
-> Calling `body.formData()` on a fetch response causes undici to buffer and parse the entire body. Since this is dictated by the spec, `body.formData()` must only be called on responses from trusted servers.
+> The body mixins `.arrayBuffer()`, `.blob()`, `.bytes()`, `.json()`, `.text()`,
+> and `.formData()` buffer the entire body in memory before returning. Where
+> applicable, they also decode or parse the payload and retain that
+> representation in memory. Calling these methods therefore means trusting that
+> the response body is small enough to fit in the available memory. Do not use
+> them for responses from untrusted or user-controlled sources. Instead, consume
+> the response body as a stream and enforce an application-specific size limit:
+> use `response.body` for fetch responses or the `body` returned by
+> `undici.request()`. For streaming decoded text, use `body.textStream()` on a
+> fetch `Request` or `Response`.
 
 Example usage:
 

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

@@ -56,16 +56,16 @@ changes:
     `Infinity`, no limit is enforced. Must be a number greater than `0`.
     **Default:** `Infinity`.
 
-`Agent` inherits all {PoolOptions} (and therefore all {ClientOptions}). The
-per-origin {Pool} it creates uses the default unlimited `connections`, so
-concurrent requests to the same origin are spread across separate {Client}
-instances on separate sockets.
+`Agent` inherits all {PoolOptions} (and therefore all {ClientOptions}). Each
+origin gets a separate {Pool}, with `connections` acting as the maximum number
+of clients that pool may create.
 
 > [!NOTE]
-> Because each concurrent request to an origin may use a different {Client},
-> HTTP/2 multiplexing on a shared session does not apply unless `connections` is
-> set to a small value (for example `connections: 1`). See {PoolOptions} and
-> {ClientOptions} for the full set of inherited options such as `allowH2`
+> For an h2-capable HTTPS origin, the per-origin pool waits for the first TLS
+> connection to finish ALPN negotiation. If the server selects h2, concurrent
+> requests share that session up to `maxConcurrentStreams`. If it selects
+> HTTP/1.1, normal connection fan-out resumes up to `connections`. See
+> {PoolOptions} and {ClientOptions} for inherited options such as `allowH2`
 > (default `true`) and `maxConcurrentStreams` (default `100`).
 
 ### `agent.closed`

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

@@ -120,7 +120,8 @@ diagnosticsChannel.channel('undici:request:bodySent').subscribe(({ request }) =>
 added: v6.3.0
 -->
 
-Published after the response headers have been received.
+Published after the response headers have been received. This includes a
+successful CONNECT or protocol upgrade response.
 
 * `message` {Object}
   * `request` {Object} The same object published by
@@ -128,8 +129,9 @@ Published after the response headers have been received.
   * `response` {Object} The response being received.
     * `statusCode` {number} The HTTP status code.
     * `statusText` {string} The HTTP status message.
-    * `headers` {Buffer[]} The raw response headers as an array of buffers,
-      alternating between header name and value.
+    * `headers` {Buffer[]|Object} HTTP/1.1 response headers are an array of
+      buffers alternating between header name and value. HTTP/2 response
+      headers are an object.
 
 ```mjs
 import diagnosticsChannel from 'node:diagnostics_channel'
@@ -137,7 +139,7 @@ import diagnosticsChannel from 'node:diagnostics_channel'
 diagnosticsChannel.channel('undici:request:headers').subscribe(({ request, response }) => {
   console.log('statusCode', response.statusCode)
   console.log(response.statusText)
-  console.log(response.headers.map((x) => x.toString()))
+  console.log(response.headers)
 })
 ```
 
@@ -168,8 +170,9 @@ diagnosticsChannel.channel('undici:request:bodyChunkReceived').subscribe(({ requ
 added: v6.3.0
 -->
 
-Published after the response body and trailers have been received, that is, once
-the response has fully completed.
+Published once the response has fully completed. After an upgraded socket has
+been passed to the request handler, this event is published with an empty
+`trailers` array.
 
 * `message` {Object}
   * `request` {Object} The same object published by

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

@@ -466,6 +466,15 @@ example, calling `text()` after `json()` throws a `TypeError`. The body also
 provides `dump({ limit })`, which discards up to `limit` bytes (default
 `131072`) without destroying the socket.
 
+> [!WARNING]
+> The `arrayBuffer()`, `blob()`, `bytes()`, `json()`, and `text()` methods buffer
+> the entire body in memory before returning. Where applicable, they also decode
+> or parse the payload and retain that representation in memory. Calling these
+> methods therefore means trusting that the body is small enough to fit in the
+> available memory. Do not use them for bodies received from untrusted or
+> user-controlled sources. Instead, process `body` as a `Readable` stream and
+> enforce an application-specific size limit.
+
 The body is always a `Readable`, even when empty. Deserializing an empty body
 with `json()` throws. To guard against this, verify the status code is not `204`
 and the `content-type` header starts with `application/json` before calling

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

@@ -446,6 +446,31 @@ The response returned an error status code. This is raised, for example, when th
   * `headers` {Object|string[]|null} The response headers. (optional)
   * `body` {Object|string|null} The response body. (optional)
 
+## Class: `ProxyConnectionError`
+
+<!-- YAML
+added: v8.10.1
+changes:
+  - version: v8.10.1
+    pr-url: https://github.com/nodejs/undici/pull/5707
+    description: Added to fail the request instead of retrying forever when the proxy connection is torn down.
+-->
+
+* Extends: {UndiciError}
+
+A connection to the proxy failed in a way that cannot be recovered on the
+same connection, so the request fails instead of being retried.
+
+* `name` {string} Always `'ProxyConnectionError'`.
+* `code` {string} Always `'UND_ERR_PRX_CONN'`.
+* `cause` {Error} The underlying error that caused the proxy connection to fail.
+
+### `new ProxyConnectionError(cause[, message[, options]])`
+
+* `cause` {Error} The underlying error. (optional)
+* `message` {string} The error message. (optional)
+* `options` {Object} Additional `Error` options merged with `cause`. (optional)
+
 ## Class: `SecureProxyConnectionError`
 
 <!-- YAML

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

@@ -596,6 +596,16 @@ properties for reading a body. Each consuming method reads the body once; after
 the body has been consumed, [`bodyUsed`](#bodybodyused) becomes `true` and
 calling another consuming method throws a `TypeError`.
 
+> [!WARNING]
+> The `arrayBuffer()`, `blob()`, `bytes()`, `formData()`, `json()`, and `text()`
+> methods buffer the entire body in memory before returning. Where applicable,
+> they also decode or parse the payload and retain that representation in
+> memory. Calling these methods therefore means trusting that the body is small
+> enough to fit in the available memory. Do not use them for bodies received
+> from untrusted or user-controlled sources. Instead, process `body.body` or
+> `body.textStream()` incrementally and enforce an application-specific size
+> limit.
+
 ### `body.arrayBuffer()`
 
 <!-- YAML

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

@@ -210,9 +210,10 @@ Automatically decompresses response bodies encoded with `gzip`, `x-gzip`,
     skipped. **Default:** `[204, 304]`.
   * `skipErrorResponses` {boolean} When `true`, responses with a status code
     >= 400 are not decompressed. **Default:** `true`.
-  * `maxSize` {number} Maximum decompressed response size in bytes. The request
-    fails with a `ResponseExceededMaxSizeError` if the decoded body exceeds
-    this limit. **Default:** `67108864` (64 MiB).
+  * `maxSize` {number} Maximum decompressed response size in bytes for each
+    decompression stage. The request fails with a
+    `ResponseExceededMaxSizeError` if a stage exceeds this limit. Set to `0` to
+    disable the limit. **Default:** `0`.
 
 **Returns:** {Dispatcher.DispatcherComposeInterceptor}
 

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

@@ -73,12 +73,11 @@ connector shared by every pooled client.
 
 > [!NOTE]
 > `Pool` inherits all {ClientOptions}, including `allowH2` and
-> `maxConcurrentStreams`. With the default unlimited `connections`, the pool
-> opens a new client - and therefore a new TCP/TLS socket - per concurrent
-> dispatch, which defeats HTTP/2 multiplexing over a shared session. To benefit
-> from h2 multiplexing on a single session, cap `connections` (for example
-> `connections: 1`) so that concurrent requests share a session up to
-> `maxConcurrentStreams`.
+> `maxConcurrentStreams`. For an h2-capable HTTPS origin, the pool waits for
+> the first TLS connection to finish ALPN negotiation before opening more
+> clients. If the server selects h2, concurrent requests share that session up
+> to `maxConcurrentStreams`. If it selects HTTP/1.1, the pool resumes normal
+> connection fan-out up to `connections`.
 
 ```mjs
 import { Pool } from 'undici'

package/node_modules/undici/docs/docs/index.md

@@ -380,7 +380,16 @@ The `body` mixins are the most common way to format the request/response body. M
 > The body returned from `undici.request` does not implement `.formData()`.
 
 > [!WARNING]
-> Calling `body.formData()` on a fetch response causes undici to buffer and parse the entire body. Since this is dictated by the spec, `body.formData()` must only be called on responses from trusted servers.
+> The body mixins `.arrayBuffer()`, `.blob()`, `.bytes()`, `.json()`, `.text()`,
+> and `.formData()` buffer the entire body in memory before returning. Where
+> applicable, they also decode or parse the payload and retain that
+> representation in memory. Calling these methods therefore means trusting that
+> the response body is small enough to fit in the available memory. Do not use
+> them for responses from untrusted or user-controlled sources. Instead, consume
+> the response body as a stream and enforce an application-specific size limit:
+> use `response.body` for fetch responses or the `body` returned by
+> `undici.request()`. For streaming decoded text, use `body.textStream()` on a
+> fetch `Request` or `Response`.
 
 Example usage:
 

package/node_modules/undici/lib/api/readable.js

@@ -5,7 +5,6 @@ const { addAbortListener } = require('node:events')
 const { Readable } = require('node:stream')
 const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require('../core/errors')
 const util = require('../core/util')
-const { ReadableStreamFrom } = require('../core/util')
 
 const kConsume = Symbol('kConsume')
 const kReading = Symbol('kReading')
@@ -246,7 +245,7 @@ class BodyReadable extends Readable {
    */
   get body () {
     if (!this[kBody]) {
-      this[kBody] = ReadableStreamFrom(this)
+      this[kBody] = ReadableStream.from(this)
       if (this[kConsume]) {
         // TODO: Is this the best way to force a lock?
         this[kBody].getReader() // Ensure stream is locked.

package/node_modules/undici/lib/core/request.js

@@ -368,10 +368,22 @@ class Request {
     }
   }
 
-  onRequestUpgrade (statusCode, headers, socket) {
+  /**
+   * @param {number} statusCode
+   * @param {Buffer[]|string[]|import('../../types/header.d.ts').IncomingHttpHeaders} headers
+   * @param {import('node:stream').Duplex} socket
+   * @param {string} [statusText]
+   */
+  onRequestUpgrade (statusCode, headers, socket, statusText = '') {
+    this.onFinally()
+
     assert(!this.aborted)
     assert(!this.completed)
 
+    if (channels.headers.hasSubscribers) {
+      channels.headers.publish({ request: this, response: { statusCode, headers, statusText } })
+    }
+
     const controller = this[kController]
     if (controller) {
       controller.rawHeaders = headers
@@ -379,7 +391,16 @@ class Request {
 
     const parsedHeaders = Array.isArray(headers) ? parseHeaders(headers) : headers
 
-    return this[kHandler].onRequestUpgrade?.(controller, statusCode, parsedHeaders, socket)
+    const result = this[kHandler].onRequestUpgrade?.(controller, statusCode, parsedHeaders, socket)
+
+    if (!this.aborted) {
+      this.completed = true
+      if (channels.trailers.hasSubscribers) {
+        channels.trailers.publish({ request: this, trailers: [] })
+      }
+    }
+
+    return result
   }
 
   onResponseEnd (trailers) {

package/node_modules/undici/lib/core/util.js

@@ -644,44 +644,6 @@ function getSocketInfo (socket) {
   }
 }
 
-/**
- * @param {Iterable} iterable
- * @returns {ReadableStream}
- */
-function ReadableStreamFrom (iterable) {
-  // We cannot use ReadableStream.from here because it does not return a byte stream.
-
-  let iterator
-  return new ReadableStream(
-    {
-      start () {
-        iterator = iterable[Symbol.asyncIterator]()
-      },
-      pull (controller) {
-        return iterator.next().then(({ done, value }) => {
-          if (done) {
-            return queueMicrotask(() => {
-              controller.close()
-              controller.byobRequest?.respond(0)
-            })
-          } else {
-            const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
-            if (buf.byteLength) {
-              return controller.enqueue(new Uint8Array(buf))
-            } else {
-              return this.pull(controller)
-            }
-          }
-        })
-      },
-      cancel () {
-        return iterator.return()
-      },
-      type: 'bytes'
-    }
-  )
-}
-
 /**
  * The object should be a FormData instance and contains all the required
  * methods.
@@ -1026,7 +988,6 @@ module.exports = {
   destroy,
   bodyLength,
   deepClone,
-  ReadableStreamFrom,
   isBuffer,
   assertRequestHandler,
   getSocketInfo,