@openclaw/slack 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/@types/node/quic.d.ts

@@ -123,6 +123,13 @@ declare module "node:quic" {
          */
         maxDatagramFrameSize?: bigint | number | undefined;
     }
+    interface SNIEntry {
+        keys: KeyObject | readonly KeyObject[];
+        certs: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView>;
+        ca?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
+        crl?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
+        verifyPrivateKey?: boolean | undefined;
+    }
     /**
      * @since v23.8.0
      */
@@ -133,12 +140,25 @@ declare module "node:quic" {
          */
         endpoint?: EndpointOptions | QuicEndpoint | undefined;
         /**
-         * The ALPN protocol identifier.
-         * @since v23.8.0
+         * The ALPN (Application-Layer Protocol Negotiation) identifier(s).
+         *
+         * For **client** sessions, this is a single string specifying the protocol
+         * the client wants to use (e.g. `'h3'`).
+         *
+         * For **server** sessions, this is an array of protocol names in preference
+         * order that the server supports (e.g. `['h3', 'h3-29']`). During the TLS
+         * handshake, the server selects the first protocol from its list that the
+         * client also supports.
+         *
+         * The negotiated ALPN determines which Application implementation is used
+         * for the session. `'h3'` and `'h3-*'` variants select the HTTP/3
+         * application; all other values select the default application.
+         * @since v26.1.0
          */
-        alpn?: string | undefined;
+        alpn?: string | readonly string[] | undefined;
         /**
-         * The CA certificates to use for sessions.
+         * The CA certificates to use for client sessions. For server sessions, CA
+         * certificates are specified per-identity in the `sessionOptions.sni` map.
          * @since v23.8.0
          */
         ca?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
@@ -151,7 +171,8 @@ declare module "node:quic" {
          */
         cc?: `${constants.cc}` | undefined;
         /**
-         * The TLS certificates to use for sessions.
+         * The TLS certificates to use for client sessions. For server sessions,
+         * certificates are specified per-identity in the `sessionOptions.sni` map.
          * @since v23.8.0
          */
         certs?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
@@ -161,7 +182,8 @@ declare module "node:quic" {
          */
         ciphers?: string | undefined;
         /**
-         * The CRL to use for sessions.
+         * The CRL to use for client sessions. For server sessions, CRLs are specified
+         * per-identity in the `sessionOptions.sni` map.
          * @since v23.8.0
          */
         crl?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
@@ -176,7 +198,8 @@ declare module "node:quic" {
          */
         keylog?: boolean | undefined;
         /**
-         * The TLS crypto keys to use for sessions.
+         * The TLS crypto keys to use for client sessions. For server sessions,
+         * keys are specified per-identity in the `sessionOptions.sni` map.
          * @since v23.8.0
          */
         keys?: KeyObject | readonly KeyObject[] | undefined;
@@ -224,10 +247,37 @@ declare module "node:quic" {
          */
         handshakeTimeout?: bigint | number | undefined;
         /**
-         * The peer server name to target.
-         * @since v23.8.0
+         * The peer server name to target (SNI). Defaults to `'localhost'`.
+         * @since v26.1.0
          */
-        sni?: string | undefined;
+        servername?: string | undefined;
+        /**
+         * An object mapping host names to TLS identity options for Server Name
+         * Indication (SNI) support. This is required for server sessions. The
+         * special key `'*'` specifies the default/fallback identity used when
+         * no other host name matches. Each entry may contain:
+         *
+         * ```js
+         * const endpoint = await listen(callback, {
+         *   sni: {
+         *     '*': { keys: [defaultKey], certs: [defaultCert] },
+         *     'api.example.com': { keys: [apiKey], certs: [apiCert] },
+         *     'www.example.com': { keys: [wwwKey], certs: [wwwCert], ca: [customCA] },
+         *   },
+         * });
+         * ```
+         *
+         * Shared TLS options (such as `ciphers`, `groups`, `keylog`, and `verifyClient`)
+         * are specified at the top level of the session options and apply to all
+         * identities. Each SNI entry overrides only the per-identity certificate
+         * fields.
+         *
+         * The SNI map can be replaced at runtime using `endpoint.setSNIContexts()`,
+         * which atomically swaps the map for new sessions while existing sessions
+         * continue to use their original identity.
+         * @since v26.1.0
+         */
+        sni?: Record<string, SNIEntry> | undefined;
         /**
          * True to enable TLS tracing output.
          * @since v23.8.0
@@ -249,7 +299,9 @@ declare module "node:quic" {
          */
         verifyClient?: boolean | undefined;
         /**
-         * True to require private key verification.
+         * True to require private key verification for client sessions. For server
+         * sessions, this option is specified per-identity in the
+         * `sessionOptions.sni` map.
          * @since v23.8.0
          */
         verifyPrivateKey?: boolean | undefined;
@@ -406,6 +458,9 @@ declare module "node:quic" {
          */
         validateAddress?: boolean | undefined;
     }
+    interface SetSNIContextsOptions {
+        replace?: boolean | undefined;
+    }
     /**
      * A `QuicEndpoint` encapsulates the local UDP-port binding for QUIC. It can be
      * used as both a client and a server.
@@ -468,6 +523,32 @@ declare module "node:quic" {
          * @since v23.8.0
          */
         readonly destroyed: boolean;
+        /**
+         * True if the endpoint is actively listening for incoming connections. Read only.
+         * @since v26.1.0
+         */
+        readonly listening: boolean;
+        /**
+         * Replaces or updates the SNI TLS contexts for this endpoint. This allows
+         * changing the TLS identity (key/certificate) used for specific host names
+         * without restarting the endpoint. Existing sessions are unaffected — only
+         * new sessions will use the updated contexts.
+         *
+         * ```js
+         * endpoint.setSNIContexts({
+         *   'api.example.com': { keys: [newApiKey], certs: [newApiCert] },
+         * });
+         *
+         * // Replace the entire SNI map
+         * endpoint.setSNIContexts({
+         *   'api.example.com': { keys: [newApiKey], certs: [newApiCert] },
+         * }, { replace: true });
+         * ```
+         * @since v26.1.0
+         * @param entries An object mapping host names to TLS identity options.
+         * Each entry must include `keys` and `certs`.
+         */
+        setSNIContexts(entries: Record<string, SNIEntry>, options?: SetSNIContextsOptions): void;
         /**
          * The statistics collected for an active session. Read only.
          * @since v23.8.0

package/node_modules/@types/node/readline.d.ts

@@ -20,7 +20,7 @@ declare module "node:readline" {
     }
     /**
      * Instances of the `readline.Interface` class are constructed using the `readline.createInterface()` method. Every instance is associated with a
-     * single `input` [Readable](https://nodejs.org/docs/latest-v25.x/api/stream.html#readable-streams) stream and a single `output` [Writable](https://nodejs.org/docs/latest-v25.x/api/stream.html#writable-streams) stream.
+     * single `input` [Readable](https://nodejs.org/docs/latest-v26.x/api/stream.html#readable-streams) stream and a single `output` [Writable](https://nodejs.org/docs/latest-v26.x/api/stream.html#writable-streams) stream.
      * The `output` stream is used to print prompts for user input that arrives on,
      * and is read from, the `input` stream.
      * @since v0.1.104
@@ -32,7 +32,7 @@ declare module "node:readline" {
          * > Instances of the `readline.Interface` class are constructed using the
          * > `readline.createInterface()` method.
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/readline.html#class-interfaceconstructor
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/readline.html#class-interfaceconstructor
          */
         protected constructor(
             input: NodeJS.ReadableStream,
@@ -46,7 +46,7 @@ declare module "node:readline" {
          * > Instances of the `readline.Interface` class are constructed using the
          * > `readline.createInterface()` method.
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/readline.html#class-interfaceconstructor
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/readline.html#class-interfaceconstructor
          */
         protected constructor(options: ReadLineOptions);
         readonly terminal: boolean;
@@ -221,7 +221,6 @@ declare module "node:readline" {
         [Symbol.asyncIterator](): NodeJS.AsyncIterator<string>;
     }
     interface Interface extends InternalEventEmitter<InterfaceEventMap> {}
-    type ReadLine = Interface; // type forwarded for backwards compatibility
     type Completer = (line: string) => CompleterResult;
     type AsyncCompleter = (
         line: string,
@@ -230,11 +229,11 @@ declare module "node:readline" {
     type CompleterResult = [string[], string];
     interface ReadLineOptions {
         /**
-         * The [`Readable`](https://nodejs.org/docs/latest-v25.x/api/stream.html#readable-streams) stream to listen to
+         * The [`Readable`](https://nodejs.org/docs/latest-v26.x/api/stream.html#readable-streams) stream to listen to
          */
         input: NodeJS.ReadableStream;
         /**
-         * The [`Writable`](https://nodejs.org/docs/latest-v25.x/api/stream.html#writable-streams) stream to write readline data to.
+         * The [`Writable`](https://nodejs.org/docs/latest-v26.x/api/stream.html#writable-streams) stream to write readline data to.
          */
         output?: NodeJS.WritableStream | undefined;
         /**
@@ -279,7 +278,7 @@ declare module "node:readline" {
          * `crlfDelay` will be coerced to a number no less than `100`.
          * It can be set to `Infinity`, in which case
          * `\r` followed by `\n` will always be considered a single newline
-         * (which may be reasonable for [reading files](https://nodejs.org/docs/latest-v25.x/api/readline.html#example-read-file-stream-line-by-line) with `\r\n` line delimiter).
+         * (which may be reasonable for [reading files](https://nodejs.org/docs/latest-v26.x/api/readline.html#example-read-file-stream-line-by-line) with `\r\n` line delimiter).
          * @default 100
          */
         crlfDelay?: number | undefined;
@@ -467,7 +466,7 @@ declare module "node:readline" {
         cols: number;
     }
     /**
-     * The `readline.clearLine()` method clears current line of given [TTY](https://nodejs.org/docs/latest-v25.x/api/tty.html) stream
+     * The `readline.clearLine()` method clears current line of given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) stream
      * in a specified direction identified by `dir`.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
@@ -475,7 +474,7 @@ declare module "node:readline" {
      */
     function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
     /**
-     * The `readline.clearScreenDown()` method clears the given [TTY](https://nodejs.org/docs/latest-v25.x/api/tty.html) stream from
+     * The `readline.clearScreenDown()` method clears the given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) stream from
      * the current position of the cursor down.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
@@ -484,7 +483,7 @@ declare module "node:readline" {
     function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
     /**
      * The `readline.cursorTo()` method moves cursor to the specified position in a
-     * given [TTY](https://nodejs.org/docs/latest-v25.x/api/tty.html) `stream`.
+     * given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) `stream`.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
@@ -492,12 +491,14 @@ declare module "node:readline" {
     function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
     /**
      * The `readline.moveCursor()` method moves the cursor _relative_ to its current
-     * position in a given [TTY](https://nodejs.org/docs/latest-v25.x/api/tty.html) `stream`.
+     * position in a given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) `stream`.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
     function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+    /** @deprecated This alias will be removed in a future version. Use `import { Interface } from 'node:readline'` instead. */
+    type ReadLine = Interface;
 }
 declare module "node:readline" {
     export * as promises from "node:readline/promises";

package/node_modules/@types/node/repl.d.ts

@@ -29,7 +29,7 @@ declare module "node:repl" {
          * The function to be used when evaluating each given line of input.
          * **Default:** an async wrapper for the JavaScript `eval()` function. An `eval` function can
          * error with `repl.Recoverable` to indicate the input was incomplete and prompt for
-         * additional lines. See the [custom evaluation functions](https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#custom-evaluation-functions)
+         * additional lines. See the [custom evaluation functions](https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#custom-evaluation-functions)
          * section for more details.
          */
         eval?: REPLEval | undefined;
@@ -62,13 +62,13 @@ declare module "node:repl" {
          * The function to invoke to format the output of each command before writing to `output`.
          * @default a wrapper for `util.inspect`
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_customizing_repl_output
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_customizing_repl_output
          */
         writer?: REPLWriter | undefined;
         /**
          * An optional function used for custom Tab auto completion.
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/readline.html#readline_use_of_the_completer_function
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/readline.html#readline_use_of_the_completer_function
          */
         completer?: Completer | AsyncCompleter | undefined;
         /**
@@ -161,7 +161,7 @@ declare module "node:repl" {
          *
          * `REPLServer` cannot be subclassed due to implementation specifics in NodeJS.
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_class_replserver
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_class_replserver
          */
         private constructor();
         /**
@@ -192,33 +192,33 @@ declare module "node:repl" {
         /**
          * A value indicating whether the REPL is currently in "editor mode".
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_commands_and_special_keys
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_commands_and_special_keys
          */
         readonly editorMode: boolean;
         /**
          * A value indicating whether the `_` variable has been assigned.
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly underscoreAssigned: boolean;
         /**
          * The last evaluation result from the REPL (assigned to the `_` variable inside of the REPL).
          *
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly last: any;
         /**
          * A value indicating whether the `_error` variable has been assigned.
          *
          * @since v9.8.0
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly underscoreErrAssigned: boolean;
         /**
          * The last error raised inside the REPL (assigned to the `_error` variable inside of the REPL).
          *
          * @since v9.8.0
-         * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly lastError: any;
         /**
@@ -408,7 +408,7 @@ declare module "node:repl" {
     /**
      * Indicates a recoverable error that a `REPLServer` can use to support multi-line input.
      *
-     * @see https://nodejs.org/dist/latest-v25.x/docs/api/repl.html#repl_recoverable_errors
+     * @see https://nodejs.org/dist/latest-v26.x/docs/api/repl.html#repl_recoverable_errors
      */
     class Recoverable extends SyntaxError {
         err: Error;

package/node_modules/@types/node/sqlite.d.ts

@@ -158,6 +158,13 @@ declare module "node:sqlite" {
          */
         onConflict?: ((conflictType: number) => number) | undefined;
     }
+    interface DeserializeOptions {
+        /**
+         * Name of the database to deserialize into.
+         * @default 'main'
+         */
+        dbName?: string | undefined;
+    }
     interface FunctionOptions {
         /**
          * If `true`, the [`SQLITE_DETERMINISTIC`](https://www.sqlite.org/c3ref/c_deterministic.html) flag is
@@ -336,7 +343,7 @@ declare module "node:sqlite" {
          * @param options Optional configuration settings for the function.
          * @param fn The JavaScript function to call when the SQLite function is
          * invoked. The return value of this function should be a valid SQLite data type:
-         * see [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v25.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite). The result defaults to
+         * see [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v26.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite). The result defaults to
          * `NULL` if the return value is `undefined`.
          */
         function(
@@ -445,6 +452,54 @@ declare module "node:sqlite" {
          * @since v22.5.0
          */
         open(): void;
+        /**
+         * Serializes the database into a binary representation, returned as a
+         * `Uint8Array`. This is useful for saving, cloning, or transferring an in-memory
+         * database. This method is a wrapper around [`sqlite3_serialize()`](https://sqlite.org/c3ref/serialize.html).
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
+         * const db = new DatabaseSync(':memory:');
+         * db.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
+         * db.exec("INSERT INTO t VALUES (1, 'hello')");
+         * const buffer = db.serialize();
+         * console.log(buffer.length); // Prints the byte length of the database
+         * ```
+         * @since v26.1.0
+         * @param dbName Name of the database to serialize. This can be `'main'`
+         * (the default primary database) or any other database that has been added with
+         * [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html). **Default:** `'main'`.
+         * @returns A binary representation of the database.
+         */
+        serialize(dbName?: string): NodeJS.NonSharedUint8Array;
+        /**
+         * Loads a serialized database into this connection, replacing the current
+         * database. The deserialized database is writable. Existing prepared statements
+         * are finalized before deserialization is attempted, even if the operation
+         * subsequently fails. This method is a wrapper around
+         * [`sqlite3_deserialize()`](https://sqlite.org/c3ref/deserialize.html).
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
+         * const original = new DatabaseSync(':memory:');
+         * original.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
+         * original.exec("INSERT INTO t VALUES (1, 'hello')");
+         * const buffer = original.serialize();
+         * original.close();
+         *
+         * const clone = new DatabaseSync(':memory:');
+         * clone.deserialize(buffer);
+         * console.log(clone.prepare('SELECT value FROM t').get());
+         * // Prints: { value: 'hello' }
+         * ```
+         * @since v26.1.0
+         * @param buffer A binary representation of a database, such as the
+         * output of `database.serialize()`.
+         * @param options Optional configuration for the deserialization.
+         */
+        deserialize(buffer: Uint8Array, options?: DeserializeOptions): void;
         /**
          * Compiles a SQL statement into a [prepared statement](https://www.sqlite.org/c3ref/stmt.html). This method is a wrapper
          * around [`sqlite3_prepare_v2()`](https://www.sqlite.org/c3ref/prepare.html).

package/node_modules/@types/node/stream/iter.d.ts

@@ -1,4 +1,6 @@
 declare module "node:stream/iter" {
+    import { Abortable } from "node:events";
+    import { Readable, Writable } from "node:stream";
     // Symbols and custom typedefs
     const broadcastProtocol: unique symbol;
     const drainableProtocol: unique symbol;
@@ -262,6 +264,154 @@ declare module "node:stream/iter" {
          */
         function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare;
     }
+    /**
+     * Converts a classic Readable stream (or duck-typed equivalent) into a
+     * stream/iter async iterable source that can be passed to `from()`,
+     * `pull()`, `text()`, etc.
+     *
+     * If the object implements the `toAsyncStreamable` protocol (as
+     * `stream.Readable` does), that protocol is used. Otherwise, the function
+     * duck-types on `read()` and `on()` (EventEmitter) and wraps the stream with
+     * a batched async iterator.
+     *
+     * The result is cached per instance -- calling `fromReadable()` twice with the
+     * same stream returns the same iterable.
+     *
+     * For object-mode or encoded Readable streams, chunks are automatically
+     * normalized to `Uint8Array`.
+     *
+     * ```js
+     * import { Readable } from 'node:stream';
+     * import { fromReadable, text } from 'node:stream/iter';
+     *
+     * const readable = new Readable({
+     *   read() { this.push('hello world'); this.push(null); },
+     * });
+     *
+     * const result = await text(fromReadable(readable));
+     * console.log(result); // 'hello world'
+     * ```
+     * @since v26.1.0
+     * @experimental
+     * @param readable A classic Readable stream or any object
+     * with `read()` and `on()` methods.
+     * @returns A stream/iter async iterable source.
+     */
+    function fromReadable(readable: NodeJS.ReadableStream): ByteReadableStream;
+    interface FromWritableOptions {
+        backpressure?: BackpressurePolicy | undefined;
+    }
+    /**
+     * Creates a stream/iter Writer adapter from a classic Writable stream (or
+     * duck-typed equivalent). The adapter can be passed to `pipeTo()` as a
+     * destination.
+     *
+     * Since all writes on a classic Writable are fundamentally asynchronous,
+     * the synchronous Writer methods (`writeSync`, `writevSync`, `endSync`) always
+     * return `false` or `-1`, deferring to the async path. The per-write
+     * `options.signal` parameter from the Writer interface is also ignored.
+     *
+     * The result is cached per instance -- calling `fromWritable()` twice with the
+     * same stream returns the same Writer.
+     *
+     * For duck-typed streams that do not expose `writableHighWaterMark`,
+     * `writableLength`, or similar properties, sensible defaults are used.
+     * Object-mode writables (if detectable) are rejected since the Writer
+     * interface is bytes-only.
+     *
+     * ```js
+     * import { Writable } from 'node:stream';
+     * import { from, fromWritable, pipeTo } from 'node:stream/iter';
+     *
+     * const writable = new Writable({
+     *   write(chunk, encoding, cb) { console.log(chunk.toString()); cb(); },
+     * });
+     *
+     * await pipeTo(from('hello world'),
+     *              fromWritable(writable, { backpressure: 'block' }));
+     * ```
+     * @since v26.1.0
+     * @experimental
+     * @param writable A classic Writable stream or any object
+     * with `write()` and `on()` methods.
+     * @returns A stream/iter Writer adapter.
+     */
+    function fromWritable(writable: NodeJS.WritableStream, options?: FromWritableOptions): Writer;
+    interface ToReadableOptions extends Abortable {
+        highWaterMark?: number | undefined;
+    }
+    /**
+     * Creates a byte-mode `stream.Readable` from an `AsyncIterable<Uint8Array[]>`
+     * (the native batch format used by the stream/iter API). Each `Uint8Array` in a
+     * yielded batch is pushed as a separate chunk into the Readable.
+     *
+     * ```js
+     * import { createWriteStream } from 'node:fs';
+     * import { from, pull, toReadable } from 'node:stream/iter';
+     * import { compressGzip } from 'node:zlib/iter';
+     *
+     * const source = pull(from('hello world'), compressGzip());
+     * const readable = toReadable(source);
+     *
+     * readable.pipe(createWriteStream('output.gz'));
+     * ```
+     * @since v26.1.0
+     * @experimental
+     * @param source An `AsyncIterable<Uint8Array[]>` source, such as
+     * the return value of `pull()` or `from()`.
+     */
+    function toReadable(source: Source, options?: ToReadableOptions): Readable;
+    interface ToReadableSyncOptions {
+        highWaterMark?: number | undefined;
+    }
+    /**
+     * Creates a byte-mode `stream.Readable` from a synchronous
+     * `Iterable<Uint8Array[]>`. The `_read()` method pulls from the iterator
+     * synchronously, so data is available immediately via `readable.read()`.
+     *
+     * ```js
+     * import { fromSync, toReadableSync } from 'node:stream/iter';
+     *
+     * const source = fromSync('hello world');
+     * const readable = toReadableSync(source);
+     *
+     * console.log(readable.read().toString()); // 'hello world'
+     * ```
+     * @since v26.1.0
+     * @experimental
+     * @param source An `Iterable<Uint8Array[]>` source, such as the
+     * return value of `pullSync()` or `fromSync()`.
+     */
+    function toReadableSync(source: SyncSource, options?: ToReadableSyncOptions): Readable;
+    /**
+     * Creates a classic `stream.Writable` backed by a stream/iter Writer.
+     *
+     * Each `_write()` / `_writev()` call attempts the Writer's synchronous method
+     * first (`writeSync` / `writevSync`), falling back to the async method if the
+     * sync path returns `false` or throws. Similarly, `_final()` tries `endSync()`
+     * before `end()`. When the sync path succeeds, the callback is deferred via
+     * `queueMicrotask` to preserve the async resolution contract.
+     *
+     * The Writable's `highWaterMark` is set to `Number.MAX_SAFE_INTEGER` to
+     * effectively disable its internal buffering, allowing the underlying Writer
+     * to manage backpressure directly.
+     *
+     * ```js
+     * import { push, toWritable } from 'node:stream/iter';
+     *
+     * const { writer, readable } = push();
+     * const writable = toWritable(writer);
+     *
+     * writable.write('hello');
+     * writable.end();
+     * ```
+     * @since v26.1.0
+     * @experimental
+     * @param writer A stream/iter Writer. Only the `write()` method is
+     * required; `end()`, `fail()`, `writeSync()`, `writevSync()`, `endSync()`,
+     * and `writev()` are optional.
+     */
+    function toWritable(writer: PartialWriter): Writable;
     namespace Stream {
         export {
             array,

package/node_modules/@types/node/stream/promises.d.ts

@@ -30,7 +30,7 @@ declare module "node:stream/promises" {
      * rs.resume(); // Drain the stream.
      * ```
      *
-     * The `finished` API also provides a [callback version](https://nodejs.org/docs/latest-v25.x/api/stream.html#streamfinishedstream-options-callback).
+     * The `finished` API also provides a [callback version](https://nodejs.org/docs/latest-v26.x/api/stream.html#streamfinishedstream-options-callback).
      *
      * `stream.finished()` leaves dangling event listeners (in particular
      * `'error'`, `'end'`, `'finish'` and `'close'`) after the returned promise is
@@ -129,7 +129,7 @@ declare module "node:stream/promises" {
      * console.log('Pipeline succeeded.');
      * ```
      *
-     * The `pipeline` API provides [callback version](https://nodejs.org/docs/latest-v25.x/api/stream.html#streampipelinesource-transforms-destination-callback):
+     * The `pipeline` API provides [callback version](https://nodejs.org/docs/latest-v26.x/api/stream.html#streampipelinesource-transforms-destination-callback):
      * @since v15.0.0
      * @returns Fulfills when the pipeline is complete.
      */

package/node_modules/@types/node/stream/web.d.ts

@@ -184,7 +184,7 @@ declare module "node:stream/web" {
         new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
         from<R = any>(iterable: Iterable<R> | AsyncIterable<R>): ReadableStream<R>;
     };
-    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
+    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, BuiltinIteratorReturn, unknown> {
         [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
     }
     interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {