@psnext/slingcli 3.3.20260911-1 → 3.3.20260914-1

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

@@ -1,46 +1,29 @@
-/**
- * A stream is an abstract interface for working with streaming data in Node.js.
- * The `node:stream` module provides an API for implementing the stream interface.
- *
- * There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v22.x/api/http.html#class-httpincomingmessage)
- * and [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) are both stream instances.
- *
- * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v22.x/api/events.html#class-eventemitter).
- *
- * To access the `node:stream` module:
- *
- * ```js
- * import stream from 'node:stream';
- * ```
- *
- * The `node:stream` module is useful for creating new types of stream instances.
- * It is usually not necessary to use the `node:stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/stream.js)
- */
-declare module "stream" {
+declare module "node:stream" {
+    import { Blob } from "node:buffer";
     import { Abortable, EventEmitter } from "node:events";
-    import { Blob as NodeBlob } from "node:buffer";
-    import * as streamPromises from "node:stream/promises";
-    import * as streamWeb from "node:stream/web";
-
-    type ComposeFnParam = (source: any) => void;
-
+    import { ByteReadableStream, toAsyncStreamable } from "node:stream/iter";
+    import * as promises from "node:stream/promises";
+    import * as web from "node:stream/web";
     class Stream extends EventEmitter {
+        /**
+         * @since v0.9.4
+         */
         pipe<T extends NodeJS.WritableStream>(
             destination: T,
-            options?: {
-                end?: boolean | undefined;
-            },
-        ): T;
-        compose<T extends NodeJS.ReadableStream>(
-            stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>,
-            options?: { signal: AbortSignal },
+            options?: Stream.PipeOptions,
         ): T;
     }
     namespace Stream {
-        export { Stream, streamPromises as promises };
+        export { promises, Stream };
     }
     namespace Stream {
+        interface PipeOptions {
+            /**
+             * End the writer when the reader ends.
+             * @default true
+             */
+            end?: boolean | undefined;
+        }
         interface StreamOptions<T extends Stream> extends Abortable {
             emitClose?: boolean | undefined;
             highWaterMark?: number | undefined;
@@ -53,19 +36,49 @@ declare module "stream" {
             encoding?: BufferEncoding | undefined;
             read?: ((this: T, size: number) => void) | undefined;
         }
-        interface ArrayOptions {
+        interface ReadableIteratorOptions {
+            /**
+             * When set to `false`, calling `return` on the async iterator,
+             * or exiting a `for await...of` iteration using a `break`,
+             * `return`, or `throw` will not destroy the stream.
+             * @default true
+             */
+            destroyOnReturn?: boolean | undefined;
+        }
+        interface ReadableOperatorOptions extends Abortable {
             /**
-             * The maximum concurrent invocations of `fn` to call on the stream at once.
+             * The maximum concurrent invocations of `fn` to call
+             * on the stream at once.
              * @default 1
              */
             concurrency?: number | undefined;
-            /** Allows destroying the stream if the signal is aborted. */
-            signal?: AbortSignal | undefined;
+            /**
+             * How many items to buffer while waiting for user consumption
+             * of the output.
+             * @default concurrency * 2 - 1
+             */
+            highWaterMark?: number | undefined;
+        }
+        /** @deprecated Use `ReadableOperatorOptions` instead. */
+        interface ArrayOptions extends ReadableOperatorOptions {}
+        interface ReadableToWebOptions {
+            strategy?: web.QueuingStrategy | undefined;
+            type?: web.ReadableStreamType | undefined;
+        }
+        interface ReadableEventMap {
+            "close": [];
+            "data": [chunk: any];
+            "end": [];
+            "error": [err: Error];
+            "pause": [];
+            "readable": [];
+            "resume": [];
         }
         /**
          * @since v0.9.4
          */
         class Readable extends Stream implements NodeJS.ReadableStream {
+            constructor(options?: ReadableOptions);
             /**
              * A utility method for creating Readable Streams out of iterators.
              * @since v12.3.0, v10.17.0
@@ -78,7 +91,7 @@ declare module "stream" {
              * @since v17.0.0
              */
             static fromWeb(
-                readableStream: streamWeb.ReadableStream,
+                readableStream: web.ReadableStream,
                 options?: Pick<ReadableOptions, "encoding" | "highWaterMark" | "objectMode" | "signal">,
             ): Readable;
             /**
@@ -86,16 +99,14 @@ declare module "stream" {
              * @since v17.0.0
              */
             static toWeb(
-                streamReadable: Readable,
-                options?: {
-                    strategy?: streamWeb.QueuingStrategy | undefined;
-                },
-            ): streamWeb.ReadableStream;
+                streamReadable: NodeJS.ReadableStream,
+                options?: ReadableToWebOptions,
+            ): web.ReadableStream;
             /**
              * Returns whether the stream has been read from or cancelled.
              * @since v16.8.0
              */
-            static isDisturbed(stream: Readable | NodeJS.ReadableStream): boolean;
+            static isDisturbed(stream: NodeJS.ReadableStream | web.ReadableStream): boolean;
             /**
              * Returns whether the stream was destroyed or errored before emitting `'end'`.
              * @since v16.8.0
@@ -118,16 +129,16 @@ declare module "stream" {
              */
             readonly readableEncoding: BufferEncoding | null;
             /**
-             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v22.x/api/stream.html#event-end) event is emitted.
+             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v26.x/api/stream.html#event-end) event is emitted.
              * @since v12.9.0
              */
             readonly readableEnded: boolean;
             /**
              * This property reflects the current state of a `Readable` stream as described
-             * in the [Three states](https://nodejs.org/docs/latest-v22.x/api/stream.html#three-states) section.
+             * in the [Three states](https://nodejs.org/docs/latest-v26.x/api/stream.html#three-states) section.
              * @since v9.4.0
              */
-            readonly readableFlowing: boolean | null;
+            readableFlowing: boolean | null;
             /**
              * Returns the value of `highWaterMark` passed when creating this `Readable`.
              * @since v9.3.0
@@ -160,7 +171,6 @@ declare module "stream" {
              * @since v18.0.0
              */
             readonly errored: Error | null;
-            constructor(opts?: ReadableOptions);
             _construct?(callback: (error?: Error | null) => void): void;
             _read(size: number): void;
             /**
@@ -444,16 +454,46 @@ declare module "stream" {
              */
             wrap(stream: NodeJS.ReadableStream): this;
             push(chunk: any, encoding?: BufferEncoding): boolean;
+            /**
+             * ```js
+             * import { Readable } from 'node:stream';
+             *
+             * async function* splitToWords(source) {
+             *   for await (const chunk of source) {
+             *     const words = String(chunk).split(' ');
+             *
+             *     for (const word of words) {
+             *       yield word;
+             *     }
+             *   }
+             * }
+             *
+             * const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
+             * const words = await wordsStream.toArray();
+             *
+             * console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']
+             * ```
+             *
+             * `readable.compose(s)` is equivalent to `stream.compose(readable, s)`.
+             *
+             * This method also allows for an `AbortSignal` to be provided, which will destroy
+             * the composed stream when aborted.
+             *
+             * See [`stream.compose(...streams)`](https://nodejs.org/docs/latest-v26.x/api/stream.html#streamcomposestreams) for more information.
+             * @since v19.1.0, v18.13.0
+             * @returns a stream composed with the stream `stream`.
+             */
+            compose(
+                stream: NodeJS.WritableStream | web.WritableStream | web.TransformStream | ((source: any) => void),
+                options?: Abortable,
+            ): Duplex;
             /**
              * The iterator created by this method gives users the option to cancel the destruction
              * of the stream if the `for await...of` loop is exited by `return`, `break`, or `throw`,
              * or if the iterator should destroy the stream if the stream emitted an error during iteration.
              * @since v16.3.0
-             * @param options.destroyOnReturn When set to `false`, calling `return` on the async iterator,
-             * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
-             * **Default: `true`**.
              */
-            iterator(options?: { destroyOnReturn?: boolean }): NodeJS.AsyncIterator<any>;
+            iterator(options?: ReadableIteratorOptions): NodeJS.AsyncIterator<any>;
             /**
              * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
              * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
@@ -461,7 +501,7 @@ declare module "stream" {
              * @param fn a function to map over every chunk in the stream. Async or not.
              * @returns a stream mapped with the function *fn*.
              */
-            map(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
+            map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable;
             /**
              * This method allows filtering the stream. For each chunk in the stream the *fn* function will be called
              * and if it returns a truthy value, the chunk will be passed to the result stream.
@@ -471,8 +511,8 @@ declare module "stream" {
              * @returns a stream filtered with the predicate *fn*.
              */
             filter(
-                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
-                options?: ArrayOptions,
+                fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+                options?: ReadableOperatorOptions,
             ): Readable;
             /**
              * This method allows iterating a stream. For each chunk in the stream the *fn* function will be called.
@@ -490,8 +530,8 @@ declare module "stream" {
              * @returns a promise for when the stream has finished.
              */
             forEach(
-                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>,
-                options?: ArrayOptions,
+                fn: (data: any, options?: Abortable) => void | Promise<void>,
+                options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
             ): Promise<void>;
             /**
              * This method allows easily obtaining the contents of a stream.
@@ -501,7 +541,7 @@ declare module "stream" {
              * @since v17.5.0
              * @returns a promise containing an array with the contents of the stream.
              */
-            toArray(options?: Pick<ArrayOptions, "signal">): Promise<any[]>;
+            toArray(options?: Abortable): Promise<any[]>;
             /**
              * This method is similar to `Array.prototype.some` and calls *fn* on each chunk in the stream
              * until the awaited return value is `true` (or any truthy value). Once an *fn* call on a chunk
@@ -512,8 +552,8 @@ declare module "stream" {
              * @returns a promise evaluating to `true` if *fn* returned a truthy value for at least one of the chunks.
              */
             some(
-                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
-                options?: ArrayOptions,
+                fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+                options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
             ): Promise<boolean>;
             /**
              * This method is similar to `Array.prototype.find` and calls *fn* on each chunk in the stream
@@ -526,12 +566,12 @@ declare module "stream" {
              * or `undefined` if no element was found.
              */
             find<T>(
-                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => data is T,
-                options?: ArrayOptions,
+                fn: (data: any, options?: Abortable) => data is T,
+                options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
             ): Promise<T | undefined>;
             find(
-                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
-                options?: ArrayOptions,
+                fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+                options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
             ): Promise<any>;
             /**
              * This method is similar to `Array.prototype.every` and calls *fn* on each chunk in the stream
@@ -543,8 +583,8 @@ declare module "stream" {
              * @returns a promise evaluating to `true` if *fn* returned a truthy value for every one of the chunks.
              */
             every(
-                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
-                options?: ArrayOptions,
+                fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+                options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
             ): Promise<boolean>;
             /**
              * This method returns a new stream by applying the given callback to each chunk of the stream
@@ -556,28 +596,24 @@ declare module "stream" {
              * @param fn a function to map over every chunk in the stream. May be async. May be a stream or generator.
              * @returns a stream flat-mapped with the function *fn*.
              */
-            flatMap(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
+            flatMap(
+                fn: (data: any, options?: Abortable) => any,
+                options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
+            ): Readable;
             /**
              * This method returns a new stream with the first *limit* chunks dropped from the start.
              * @since v17.5.0
              * @param limit the number of chunks to drop from the readable.
              * @returns a stream with *limit* chunks dropped from the start.
              */
-            drop(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
+            drop(limit: number, options?: Abortable): Readable;
             /**
              * This method returns a new stream with the first *limit* chunks.
              * @since v17.5.0
              * @param limit the number of chunks to take from the readable.
              * @returns a stream with *limit* chunks taken.
              */
-            take(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
-            /**
-             * This method returns a new stream with chunks of the underlying stream paired with a counter
-             * in the form `[index, chunk]`. The first index value is `0` and it increases by 1 for each chunk produced.
-             * @since v17.5.0
-             * @returns a stream of indexed pairs.
-             */
-            asIndexedPairs(options?: Pick<ArrayOptions, "signal">): Readable;
+            take(limit: number, options?: Abortable): Readable;
             /**
              * This method calls *fn* on each chunk of the stream in order, passing it the result from the calculation
              * on the previous element. It returns a promise for the final value of the reduction.
@@ -592,15 +628,11 @@ declare module "stream" {
              * @param initial the initial value to use in the reduction.
              * @returns a promise for the final value of the reduction.
              */
-            reduce<T = any>(
-                fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T,
-                initial?: undefined,
-                options?: Pick<ArrayOptions, "signal">,
-            ): Promise<T>;
-            reduce<T = any>(
-                fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T,
+            reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>;
+            reduce<T>(
+                fn: (previous: T, data: any, options?: Abortable) => T,
                 initial: T,
-                options?: Pick<ArrayOptions, "signal">,
+                options?: Abortable,
             ): Promise<T>;
             _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             /**
@@ -616,78 +648,92 @@ declare module "stream" {
              */
             destroy(error?: Error): this;
             /**
-             * Event emitter
-             * The defined events on documents including:
-             * 1. close
-             * 2. data
-             * 3. end
-             * 4. error
-             * 5. pause
-             * 6. readable
-             * 7. resume
-             */
-            addListener(event: "close", listener: () => void): this;
-            addListener(event: "data", listener: (chunk: any) => void): this;
-            addListener(event: "end", listener: () => void): this;
-            addListener(event: "error", listener: (err: Error) => void): this;
-            addListener(event: "pause", listener: () => void): this;
-            addListener(event: "readable", listener: () => void): this;
-            addListener(event: "resume", listener: () => void): this;
-            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            emit(event: "close"): boolean;
-            emit(event: "data", chunk: any): boolean;
-            emit(event: "end"): boolean;
-            emit(event: "error", err: Error): boolean;
-            emit(event: "pause"): boolean;
-            emit(event: "readable"): boolean;
-            emit(event: "resume"): boolean;
-            emit(event: string | symbol, ...args: any[]): boolean;
-            on(event: "close", listener: () => void): this;
-            on(event: "data", listener: (chunk: any) => void): this;
-            on(event: "end", listener: () => void): this;
-            on(event: "error", listener: (err: Error) => void): this;
-            on(event: "pause", listener: () => void): this;
-            on(event: "readable", listener: () => void): this;
-            on(event: "resume", listener: () => void): this;
-            on(event: string | symbol, listener: (...args: any[]) => void): this;
-            once(event: "close", listener: () => void): this;
-            once(event: "data", listener: (chunk: any) => void): this;
-            once(event: "end", listener: () => void): this;
-            once(event: "error", listener: (err: Error) => void): this;
-            once(event: "pause", listener: () => void): this;
-            once(event: "readable", listener: () => void): this;
-            once(event: "resume", listener: () => void): this;
-            once(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependListener(event: "close", listener: () => void): this;
-            prependListener(event: "data", listener: (chunk: any) => void): this;
-            prependListener(event: "end", listener: () => void): this;
-            prependListener(event: "error", listener: (err: Error) => void): this;
-            prependListener(event: "pause", listener: () => void): this;
-            prependListener(event: "readable", listener: () => void): this;
-            prependListener(event: "resume", listener: () => void): this;
-            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependOnceListener(event: "close", listener: () => void): this;
-            prependOnceListener(event: "data", listener: (chunk: any) => void): this;
-            prependOnceListener(event: "end", listener: () => void): this;
-            prependOnceListener(event: "error", listener: (err: Error) => void): this;
-            prependOnceListener(event: "pause", listener: () => void): this;
-            prependOnceListener(event: "readable", listener: () => void): this;
-            prependOnceListener(event: "resume", listener: () => void): this;
-            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            removeListener(event: "close", listener: () => void): this;
-            removeListener(event: "data", listener: (chunk: any) => void): this;
-            removeListener(event: "end", listener: () => void): this;
-            removeListener(event: "error", listener: (err: Error) => void): this;
-            removeListener(event: "pause", listener: () => void): this;
-            removeListener(event: "readable", listener: () => void): this;
-            removeListener(event: "resume", listener: () => void): this;
-            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+             * @returns `AsyncIterator` to fully consume the stream.
+             * @since v10.0.0
+             */
             [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
             /**
-             * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
+             * When the `--experimental-stream-iter` flag is enabled, `Readable` streams
+             * implement the `Stream.toAsyncStreamable` protocol, enabling efficient
+             * consumption by the `stream/iter` API.
+             *
+             * This provides a batched async iterator that drains the stream's internal
+             * buffer into `Uint8Array[]` batches, amortizing the per-chunk Promise overhead
+             * of the standard `Symbol.asyncIterator` path. For byte-mode streams, chunks
+             * are yielded directly as `Buffer` instances (which are `Uint8Array` subclasses).
+             * For object-mode or encoded streams, each chunk is normalized to `Uint8Array`
+             * before batching.
+             *
+             * The returned iterator is tagged as a validated source, so `from()`
+             * passes it through without additional normalization.
+             *
+             * ```js
+             * import { Readable } from 'node:stream';
+             * import { text, from } from 'node:stream/iter';
+             *
+             * const readable = new Readable({
+             *   read() { this.push('hello'); this.push(null); },
+             * });
+             *
+             * // Readable is automatically consumed via toAsyncStreamable
+             * console.log(await text(from(readable))); // 'hello'
+             * ```
+             *
+             * Without the `--experimental-stream-iter` flag, calling this method throws
+             * `ERR_STREAM_ITER_MISSING_FLAG`.
+             */
+            [toAsyncStreamable](): ByteReadableStream;
+            /**
+             * Calls `readable.destroy()` with an `AbortError` and returns
+             * a promise that fulfills when the stream is finished.
              * @since v20.4.0
              */
             [Symbol.asyncDispose](): Promise<void>;
+            // #region InternalEventEmitter
+            addListener<E extends keyof ReadableEventMap>(
+                eventName: E,
+                listener: (...args: ReadableEventMap[E]) => void,
+            ): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof ReadableEventMap>(eventName: E, ...args: ReadableEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof ReadableEventMap>(
+                eventName: E,
+                listener?: (...args: ReadableEventMap[E]) => void,
+            ): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof ReadableEventMap>(eventName: E): ((...args: ReadableEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof ReadableEventMap>(
+                eventName: E,
+                listener: (...args: ReadableEventMap[E]) => void,
+            ): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof ReadableEventMap>(
+                eventName: E,
+                listener: (...args: ReadableEventMap[E]) => void,
+            ): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof ReadableEventMap>(
+                eventName: E,
+                listener: (...args: ReadableEventMap[E]) => void,
+            ): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof ReadableEventMap>(eventName: E): ((...args: ReadableEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+            removeAllListeners<E extends keyof ReadableEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof ReadableEventMap>(
+                eventName: E,
+                listener: (...args: ReadableEventMap[E]) => void,
+            ): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            // #endregion
         }
         interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
             decodeStrings?: boolean | undefined;
@@ -703,38 +749,47 @@ declare module "stream" {
             writev?:
                 | ((
                     this: T,
-                    chunks: Array<{
+                    chunks: {
                         chunk: any;
                         encoding: BufferEncoding;
-                    }>,
+                    }[],
                     callback: (error?: Error | null) => void,
                 ) => void)
                 | undefined;
             final?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
         }
+        interface WritableEventMap {
+            "close": [];
+            "drain": [];
+            "error": [err: Error];
+            "finish": [];
+            "pipe": [src: Readable];
+            "unpipe": [src: Readable];
+        }
         /**
          * @since v0.9.4
          */
         class Writable extends Stream implements NodeJS.WritableStream {
+            constructor(options?: WritableOptions);
             /**
              * A utility method for creating a `Writable` from a web `WritableStream`.
              * @since v17.0.0
              */
             static fromWeb(
-                writableStream: streamWeb.WritableStream,
+                writableStream: web.WritableStream,
                 options?: Pick<WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">,
             ): Writable;
             /**
              * A utility method for creating a web `WritableStream` from a `Writable`.
              * @since v17.0.0
              */
-            static toWeb(streamWritable: Writable): streamWeb.WritableStream;
+            static toWeb(streamWritable: NodeJS.WritableStream): web.WritableStream;
             /**
              * Is `true` if it is safe to call `writable.write()`, which means
              * the stream has not been destroyed, errored, or ended.
              * @since v11.4.0
              */
-            readonly writable: boolean;
+            writable: boolean;
             /**
              * Returns whether the stream was destroyed or errored before emitting `'finish'`.
              * @since v18.0.0, v16.17.0
@@ -794,13 +849,12 @@ declare module "stream" {
              * @since v15.2.0, v14.17.0
              */
             readonly writableNeedDrain: boolean;
-            constructor(opts?: WritableOptions);
             _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             _writev?(
-                chunks: Array<{
+                chunks: {
                     chunk: any;
                     encoding: BufferEncoding;
-                }>,
+                }[],
                 callback: (error?: Error | null) => void,
             ): void;
             _construct?(callback: (error?: Error | null) => void): void;
@@ -985,64 +1039,56 @@ declare module "stream" {
              */
             destroy(error?: Error): this;
             /**
-             * Event emitter
-             * The defined events on documents including:
-             * 1. close
-             * 2. drain
-             * 3. error
-             * 4. finish
-             * 5. pipe
-             * 6. unpipe
-             */
-            addListener(event: "close", listener: () => void): this;
-            addListener(event: "drain", listener: () => void): this;
-            addListener(event: "error", listener: (err: Error) => void): this;
-            addListener(event: "finish", listener: () => void): this;
-            addListener(event: "pipe", listener: (src: Readable) => void): this;
-            addListener(event: "unpipe", listener: (src: Readable) => void): this;
-            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            emit(event: "close"): boolean;
-            emit(event: "drain"): boolean;
-            emit(event: "error", err: Error): boolean;
-            emit(event: "finish"): boolean;
-            emit(event: "pipe", src: Readable): boolean;
-            emit(event: "unpipe", src: Readable): boolean;
-            emit(event: string | symbol, ...args: any[]): boolean;
-            on(event: "close", listener: () => void): this;
-            on(event: "drain", listener: () => void): this;
-            on(event: "error", listener: (err: Error) => void): this;
-            on(event: "finish", listener: () => void): this;
-            on(event: "pipe", listener: (src: Readable) => void): this;
-            on(event: "unpipe", listener: (src: Readable) => void): this;
-            on(event: string | symbol, listener: (...args: any[]) => void): this;
-            once(event: "close", listener: () => void): this;
-            once(event: "drain", listener: () => void): this;
-            once(event: "error", listener: (err: Error) => void): this;
-            once(event: "finish", listener: () => void): this;
-            once(event: "pipe", listener: (src: Readable) => void): this;
-            once(event: "unpipe", listener: (src: Readable) => void): this;
-            once(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependListener(event: "close", listener: () => void): this;
-            prependListener(event: "drain", listener: () => void): this;
-            prependListener(event: "error", listener: (err: Error) => void): this;
-            prependListener(event: "finish", listener: () => void): this;
-            prependListener(event: "pipe", listener: (src: Readable) => void): this;
-            prependListener(event: "unpipe", listener: (src: Readable) => void): this;
-            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependOnceListener(event: "close", listener: () => void): this;
-            prependOnceListener(event: "drain", listener: () => void): this;
-            prependOnceListener(event: "error", listener: (err: Error) => void): this;
-            prependOnceListener(event: "finish", listener: () => void): this;
-            prependOnceListener(event: "pipe", listener: (src: Readable) => void): this;
-            prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this;
-            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            removeListener(event: "close", listener: () => void): this;
-            removeListener(event: "drain", listener: () => void): this;
-            removeListener(event: "error", listener: (err: Error) => void): this;
-            removeListener(event: "finish", listener: () => void): this;
-            removeListener(event: "pipe", listener: (src: Readable) => void): this;
-            removeListener(event: "unpipe", listener: (src: Readable) => void): this;
-            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+             * Calls `writable.destroy()` with an `AbortError` and returns
+             * a promise that fulfills when the stream is finished.
+             * @since v22.4.0, v20.16.0
+             */
+            [Symbol.asyncDispose](): Promise<void>;
+            // #region InternalEventEmitter
+            addListener<E extends keyof WritableEventMap>(
+                eventName: E,
+                listener: (...args: WritableEventMap[E]) => void,
+            ): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof WritableEventMap>(eventName: E, ...args: WritableEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof WritableEventMap>(
+                eventName: E,
+                listener?: (...args: WritableEventMap[E]) => void,
+            ): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof WritableEventMap>(eventName: E): ((...args: WritableEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof WritableEventMap>(
+                eventName: E,
+                listener: (...args: WritableEventMap[E]) => void,
+            ): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof WritableEventMap>(
+                eventName: E,
+                listener: (...args: WritableEventMap[E]) => void,
+            ): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof WritableEventMap>(
+                eventName: E,
+                listener: (...args: WritableEventMap[E]) => void,
+            ): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof WritableEventMap>(eventName: E): ((...args: WritableEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+            removeAllListeners<E extends keyof WritableEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof WritableEventMap>(
+                eventName: E,
+                listener: (...args: WritableEventMap[E]) => void,
+            ): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            // #endregion
         }
         interface DuplexOptions<T extends Duplex = Duplex> extends ReadableOptions<T>, WritableOptions<T> {
             allowHalfOpen?: boolean | undefined;
@@ -1052,6 +1098,10 @@ declare module "stream" {
             writableHighWaterMark?: number | undefined;
             writableCorked?: number | undefined;
         }
+        interface DuplexToWebOptions {
+            readableType?: web.ReadableStreamType | undefined;
+        }
+        interface DuplexEventMap extends ReadableEventMap, WritableEventMap {}
         /**
          * Duplex streams are streams that implement both the `Readable` and `Writable` interfaces.
          *
@@ -1063,17 +1113,7 @@ declare module "stream" {
          * @since v0.9.4
          */
         class Duplex extends Stream implements NodeJS.ReadWriteStream {
-            /**
-             * If `false` then the stream will automatically end the writable side when the
-             * readable side ends. Set initially by the `allowHalfOpen` constructor option,
-             * which defaults to `true`.
-             *
-             * This can be changed manually to change the half-open behavior of an existing
-             * `Duplex` stream instance, but must be changed before the `'end'` event is emitted.
-             * @since v0.9.4
-             */
-            allowHalfOpen: boolean;
-            constructor(opts?: DuplexOptions);
+            constructor(options?: DuplexOptions);
             /**
              * A utility method for creating duplex streams.
              *
@@ -1097,137 +1137,87 @@ declare module "stream" {
              */
             static from(
                 src:
-                    | Stream
-                    | NodeBlob
-                    | ArrayBuffer
+                    | NodeJS.ReadableStream
+                    | NodeJS.WritableStream
+                    | Blob
                     | string
                     | Iterable<any>
                     | AsyncIterable<any>
-                    | AsyncGeneratorFunction
+                    | ((source: AsyncIterable<any>) => AsyncIterable<any>)
+                    | ((source: AsyncIterable<any>) => Promise<void>)
                     | Promise<any>
-                    | Object,
+                    | web.ReadableWritablePair
+                    | web.ReadableStream
+                    | web.WritableStream,
             ): Duplex;
             /**
              * A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.
              * @since v17.0.0
              */
-            static toWeb(streamDuplex: Duplex): {
-                readable: streamWeb.ReadableStream;
-                writable: streamWeb.WritableStream;
-            };
+            static toWeb(streamDuplex: NodeJS.ReadWriteStream, options?: DuplexToWebOptions): web.ReadableWritablePair;
             /**
              * A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.
              * @since v17.0.0
              */
             static fromWeb(
-                duplexStream: {
-                    readable: streamWeb.ReadableStream;
-                    writable: streamWeb.WritableStream;
-                },
+                duplexStream: web.ReadableWritablePair,
                 options?: Pick<
                     DuplexOptions,
                     "allowHalfOpen" | "decodeStrings" | "encoding" | "highWaterMark" | "objectMode" | "signal"
                 >,
             ): Duplex;
             /**
-             * Event emitter
-             * The defined events on documents including:
-             * 1.  close
-             * 2.  data
-             * 3.  drain
-             * 4.  end
-             * 5.  error
-             * 6.  finish
-             * 7.  pause
-             * 8.  pipe
-             * 9.  readable
-             * 10. resume
-             * 11. unpipe
-             */
-            addListener(event: "close", listener: () => void): this;
-            addListener(event: "data", listener: (chunk: any) => void): this;
-            addListener(event: "drain", listener: () => void): this;
-            addListener(event: "end", listener: () => void): this;
-            addListener(event: "error", listener: (err: Error) => void): this;
-            addListener(event: "finish", listener: () => void): this;
-            addListener(event: "pause", listener: () => void): this;
-            addListener(event: "pipe", listener: (src: Readable) => void): this;
-            addListener(event: "readable", listener: () => void): this;
-            addListener(event: "resume", listener: () => void): this;
-            addListener(event: "unpipe", listener: (src: Readable) => void): this;
-            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            emit(event: "close"): boolean;
-            emit(event: "data", chunk: any): boolean;
-            emit(event: "drain"): boolean;
-            emit(event: "end"): boolean;
-            emit(event: "error", err: Error): boolean;
-            emit(event: "finish"): boolean;
-            emit(event: "pause"): boolean;
-            emit(event: "pipe", src: Readable): boolean;
-            emit(event: "readable"): boolean;
-            emit(event: "resume"): boolean;
-            emit(event: "unpipe", src: Readable): boolean;
-            emit(event: string | symbol, ...args: any[]): boolean;
-            on(event: "close", listener: () => void): this;
-            on(event: "data", listener: (chunk: any) => void): this;
-            on(event: "drain", listener: () => void): this;
-            on(event: "end", listener: () => void): this;
-            on(event: "error", listener: (err: Error) => void): this;
-            on(event: "finish", listener: () => void): this;
-            on(event: "pause", listener: () => void): this;
-            on(event: "pipe", listener: (src: Readable) => void): this;
-            on(event: "readable", listener: () => void): this;
-            on(event: "resume", listener: () => void): this;
-            on(event: "unpipe", listener: (src: Readable) => void): this;
-            on(event: string | symbol, listener: (...args: any[]) => void): this;
-            once(event: "close", listener: () => void): this;
-            once(event: "data", listener: (chunk: any) => void): this;
-            once(event: "drain", listener: () => void): this;
-            once(event: "end", listener: () => void): this;
-            once(event: "error", listener: (err: Error) => void): this;
-            once(event: "finish", listener: () => void): this;
-            once(event: "pause", listener: () => void): this;
-            once(event: "pipe", listener: (src: Readable) => void): this;
-            once(event: "readable", listener: () => void): this;
-            once(event: "resume", listener: () => void): this;
-            once(event: "unpipe", listener: (src: Readable) => void): this;
-            once(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependListener(event: "close", listener: () => void): this;
-            prependListener(event: "data", listener: (chunk: any) => void): this;
-            prependListener(event: "drain", listener: () => void): this;
-            prependListener(event: "end", listener: () => void): this;
-            prependListener(event: "error", listener: (err: Error) => void): this;
-            prependListener(event: "finish", listener: () => void): this;
-            prependListener(event: "pause", listener: () => void): this;
-            prependListener(event: "pipe", listener: (src: Readable) => void): this;
-            prependListener(event: "readable", listener: () => void): this;
-            prependListener(event: "resume", listener: () => void): this;
-            prependListener(event: "unpipe", listener: (src: Readable) => void): this;
-            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependOnceListener(event: "close", listener: () => void): this;
-            prependOnceListener(event: "data", listener: (chunk: any) => void): this;
-            prependOnceListener(event: "drain", listener: () => void): this;
-            prependOnceListener(event: "end", listener: () => void): this;
-            prependOnceListener(event: "error", listener: (err: Error) => void): this;
-            prependOnceListener(event: "finish", listener: () => void): this;
-            prependOnceListener(event: "pause", listener: () => void): this;
-            prependOnceListener(event: "pipe", listener: (src: Readable) => void): this;
-            prependOnceListener(event: "readable", listener: () => void): this;
-            prependOnceListener(event: "resume", listener: () => void): this;
-            prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this;
-            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            removeListener(event: "close", listener: () => void): this;
-            removeListener(event: "data", listener: (chunk: any) => void): this;
-            removeListener(event: "drain", listener: () => void): this;
-            removeListener(event: "end", listener: () => void): this;
-            removeListener(event: "error", listener: (err: Error) => void): this;
-            removeListener(event: "finish", listener: () => void): this;
-            removeListener(event: "pause", listener: () => void): this;
-            removeListener(event: "pipe", listener: (src: Readable) => void): this;
-            removeListener(event: "readable", listener: () => void): this;
-            removeListener(event: "resume", listener: () => void): this;
-            removeListener(event: "unpipe", listener: (src: Readable) => void): this;
-            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+             * If `false` then the stream will automatically end the writable side when the
+             * readable side ends. Set initially by the `allowHalfOpen` constructor option,
+             * which defaults to `true`.
+             *
+             * This can be changed manually to change the half-open behavior of an existing
+             * `Duplex` stream instance, but must be changed before the `'end'` event is emitted.
+             * @since v0.9.4
+             */
+            allowHalfOpen: boolean;
+            // #region InternalEventEmitter
+            addListener<E extends keyof DuplexEventMap>(
+                eventName: E,
+                listener: (...args: DuplexEventMap[E]) => void,
+            ): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof DuplexEventMap>(eventName: E, ...args: DuplexEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof DuplexEventMap>(
+                eventName: E,
+                listener?: (...args: DuplexEventMap[E]) => void,
+            ): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof DuplexEventMap>(eventName: E): ((...args: DuplexEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof DuplexEventMap>(
+                eventName: E,
+                listener: (...args: DuplexEventMap[E]) => void,
+            ): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof DuplexEventMap>(
+                eventName: E,
+                listener: (...args: DuplexEventMap[E]) => void,
+            ): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof DuplexEventMap>(eventName: E): ((...args: DuplexEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+            removeAllListeners<E extends keyof DuplexEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof DuplexEventMap>(
+                eventName: E,
+                listener: (...args: DuplexEventMap[E]) => void,
+            ): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            // #endregion
         }
         interface Duplex extends Readable, Writable {}
         /**
@@ -1268,7 +1258,7 @@ declare module "stream" {
          * @since v0.9.4
          */
         class Transform extends Duplex {
-            constructor(opts?: TransformOptions);
+            constructor(options?: TransformOptions);
             _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
             _flush(callback: TransformCallback): void;
         }
@@ -1356,7 +1346,9 @@ declare module "stream" {
          * @param signal A signal representing possible cancellation
          * @param stream A stream to attach a signal to.
          */
-        function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
+        function addAbortSignal<
+            T extends NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream,
+        >(signal: AbortSignal, stream: T): T;
         /**
          * Returns the default highWaterMark used by streams.
          * Defaults to `65536` (64 KiB), or `16` for `objectMode`.
@@ -1400,7 +1392,7 @@ declare module "stream" {
          * Especially useful in error handling scenarios where a stream is destroyed
          * prematurely (like an aborted HTTP request), and will not emit `'end'` or `'finish'`.
          *
-         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v22.x/api/stream.html#streamfinishedstream-options).
+         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v26.x/api/stream.html#streamfinishedstream-options).
          *
          * `stream.finished()` leaves dangling event listeners (in particular `'error'`, `'end'`, `'finish'` and `'close'`) after `callback` has been
          * invoked. The reason for this is so that unexpected `'error'` events (due to
@@ -1420,46 +1412,57 @@ declare module "stream" {
          * @returns A cleanup function which removes all registered listeners.
          */
         function finished(
-            stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
+            stream: NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream,
             options: FinishedOptions,
             callback: (err?: NodeJS.ErrnoException | null) => void,
         ): () => void;
         function finished(
-            stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
+            stream: NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream,
             callback: (err?: NodeJS.ErrnoException | null) => void,
         ): () => void;
         namespace finished {
-            function __promisify__(
-                stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
-                options?: FinishedOptions,
-            ): Promise<void>;
+            import __promisify__ = promises.finished;
+            export { __promisify__ };
         }
-        type PipelineSourceFunction<T> = () => Iterable<T> | AsyncIterable<T>;
-        type PipelineSource<T> = Iterable<T> | AsyncIterable<T> | NodeJS.ReadableStream | PipelineSourceFunction<T>;
-        type PipelineTransform<S extends PipelineTransformSource<any>, U> =
+        type PipelineSourceFunction<O> = (options?: Abortable) => Iterable<O> | AsyncIterable<O>;
+        type PipelineSource<O> =
+            | NodeJS.ReadableStream
+            | web.ReadableStream<O>
+            | web.TransformStream<any, O>
+            | Iterable<O>
+            | AsyncIterable<O>
+            | PipelineSourceFunction<O>;
+        type PipelineSourceArgument<T> = (T extends (...args: any[]) => infer R ? R : T) extends infer S
+            ? S extends web.TransformStream<any, infer O> ? web.ReadableStream<O> : S
+            : never;
+        type PipelineTransformGenerator<S extends PipelineTransformSource<any>, O> = (
+            source: PipelineSourceArgument<S>,
+            options?: Abortable,
+        ) => AsyncIterable<O>;
+        type PipelineTransformStreams<I, O> =
             | NodeJS.ReadWriteStream
-            | ((
-                source: S extends (...args: any[]) => Iterable<infer ST> | AsyncIterable<infer ST> ? AsyncIterable<ST>
-                    : S,
-            ) => AsyncIterable<U>);
-        type PipelineTransformSource<T> = PipelineSource<T> | PipelineTransform<any, T>;
-        type PipelineDestinationIterableFunction<T> = (source: AsyncIterable<T>) => AsyncIterable<any>;
-        type PipelineDestinationPromiseFunction<T, P> = (source: AsyncIterable<T>) => Promise<P>;
-        type PipelineDestination<S extends PipelineTransformSource<any>, P> = S extends
-            PipelineTransformSource<infer ST> ?
+            | web.TransformStream<I, O>;
+        type PipelineTransform<S extends PipelineTransformSource<any>, O> = S extends
+            PipelineSource<infer I> | PipelineTransformStreams<any, infer I> | ((...args: any[]) => infer I)
+            ? PipelineTransformStreams<I, O> | PipelineTransformGenerator<S, O>
+            : never;
+        type PipelineTransformSource<O> = PipelineSource<O> | PipelineTransform<any, O>;
+        type PipelineDestinationFunction<S extends PipelineTransformSource<any>, R> = (
+            source: PipelineSourceArgument<S>,
+            options?: Abortable,
+        ) => R;
+        type PipelineDestination<S extends PipelineTransformSource<any>, R> = S extends
+            PipelineSource<infer I> | PipelineTransform<any, infer I> ?
                 | NodeJS.WritableStream
-                | PipelineDestinationIterableFunction<ST>
-                | PipelineDestinationPromiseFunction<ST, P>
+                | web.WritableStream<I>
+                | web.TransformStream<I, any>
+                | PipelineDestinationFunction<S, R>
             : never;
-        type PipelineCallback<S extends PipelineDestination<any, any>> = S extends
-            PipelineDestinationPromiseFunction<any, infer P> ? (err: NodeJS.ErrnoException | null, value: P) => void
-            : (err: NodeJS.ErrnoException | null) => void;
-        type PipelinePromise<S extends PipelineDestination<any, any>> = S extends
-            PipelineDestinationPromiseFunction<any, infer P> ? Promise<P> : Promise<void>;
-        interface PipelineOptions {
-            signal?: AbortSignal | undefined;
-            end?: boolean | undefined;
-        }
+        type PipelineCallback<S extends PipelineDestination<any, any>> = (
+            err: NodeJS.ErrnoException | null,
+            value: S extends (...args: any[]) => PromiseLike<infer R> ? R : undefined,
+        ) => void;
+        type PipelineResult<S extends PipelineDestination<any, any>> = S extends NodeJS.WritableStream ? S : Duplex;
         /**
          * A module method to pipe between streams and generators forwarding errors and
          * properly cleaning up and provide a callback when the pipeline is complete.
@@ -1488,7 +1491,7 @@ declare module "stream" {
          * );
          * ```
          *
-         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v22.x/api/stream.html#streampipelinesource-transforms-destination-options).
+         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v26.x/api/stream.html#streampipelinesource-transforms-destination-options).
          *
          * `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
          *
@@ -1525,170 +1528,279 @@ declare module "stream" {
          * @since v10.0.0
          * @param callback Called when the pipeline is fully done.
          */
-        function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
-            source: A,
-            destination: B,
-            callback: PipelineCallback<B>,
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+        function pipeline<S extends PipelineSource<any>, D extends PipelineDestination<S, any>>(
+            source: S,
+            destination: D,
+            callback: PipelineCallback<D>,
+        ): PipelineResult<D>;
         function pipeline<
-            A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
-            B extends PipelineDestination<T1, any>,
+            S extends PipelineSource<any>,
+            T extends PipelineTransform<S, any>,
+            D extends PipelineDestination<T, any>,
         >(
-            source: A,
-            transform1: T1,
-            destination: B,
-            callback: PipelineCallback<B>,
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+            source: S,
+            transform: T,
+            destination: D,
+            callback: PipelineCallback<D>,
+        ): PipelineResult<D>;
         function pipeline<
-            A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
+            S extends PipelineSource<any>,
+            T1 extends PipelineTransform<S, any>,
             T2 extends PipelineTransform<T1, any>,
-            B extends PipelineDestination<T2, any>,
+            D extends PipelineDestination<T2, any>,
         >(
-            source: A,
+            source: S,
             transform1: T1,
             transform2: T2,
-            destination: B,
-            callback: PipelineCallback<B>,
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+            destination: D,
+            callback: PipelineCallback<D>,
+        ): PipelineResult<D>;
         function pipeline<
-            A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
+            S extends PipelineSource<any>,
+            T1 extends PipelineTransform<S, any>,
             T2 extends PipelineTransform<T1, any>,
             T3 extends PipelineTransform<T2, any>,
-            B extends PipelineDestination<T3, any>,
+            D extends PipelineDestination<T3, any>,
         >(
-            source: A,
+            source: S,
             transform1: T1,
             transform2: T2,
             transform3: T3,
-            destination: B,
-            callback: PipelineCallback<B>,
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+            destination: D,
+            callback: PipelineCallback<D>,
+        ): PipelineResult<D>;
         function pipeline<
-            A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
+            S extends PipelineSource<any>,
+            T1 extends PipelineTransform<S, any>,
             T2 extends PipelineTransform<T1, any>,
             T3 extends PipelineTransform<T2, any>,
             T4 extends PipelineTransform<T3, any>,
-            B extends PipelineDestination<T4, any>,
+            D extends PipelineDestination<T4, any>,
         >(
-            source: A,
+            source: S,
             transform1: T1,
             transform2: T2,
             transform3: T3,
             transform4: T4,
-            destination: B,
-            callback: PipelineCallback<B>,
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+            destination: D,
+            callback: PipelineCallback<D>,
+        ): PipelineResult<D>;
         function pipeline(
-            streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
+            streams: ReadonlyArray<PipelineSource<any> | PipelineTransform<any, any> | PipelineDestination<any, any>>,
             callback: (err: NodeJS.ErrnoException | null) => void,
         ): NodeJS.WritableStream;
         function pipeline(
-            stream1: NodeJS.ReadableStream,
-            stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
-            ...streams: Array<
-                NodeJS.ReadWriteStream | NodeJS.WritableStream | ((err: NodeJS.ErrnoException | null) => void)
-            >
+            ...streams: [
+                ...[PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>],
+                callback: ((err: NodeJS.ErrnoException | null) => void),
+            ]
         ): NodeJS.WritableStream;
         namespace pipeline {
-            function __promisify__<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
-                source: A,
-                destination: B,
-                options?: PipelineOptions,
-            ): PipelinePromise<B>;
-            function __promisify__<
-                A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                B extends PipelineDestination<T1, any>,
-            >(
-                source: A,
-                transform1: T1,
-                destination: B,
-                options?: PipelineOptions,
-            ): PipelinePromise<B>;
-            function __promisify__<
-                A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                T2 extends PipelineTransform<T1, any>,
-                B extends PipelineDestination<T2, any>,
-            >(
-                source: A,
-                transform1: T1,
-                transform2: T2,
-                destination: B,
-                options?: PipelineOptions,
-            ): PipelinePromise<B>;
-            function __promisify__<
-                A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                T2 extends PipelineTransform<T1, any>,
-                T3 extends PipelineTransform<T2, any>,
-                B extends PipelineDestination<T3, any>,
-            >(
-                source: A,
-                transform1: T1,
-                transform2: T2,
-                transform3: T3,
-                destination: B,
-                options?: PipelineOptions,
-            ): PipelinePromise<B>;
-            function __promisify__<
-                A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                T2 extends PipelineTransform<T1, any>,
-                T3 extends PipelineTransform<T2, any>,
-                T4 extends PipelineTransform<T3, any>,
-                B extends PipelineDestination<T4, any>,
-            >(
-                source: A,
-                transform1: T1,
-                transform2: T2,
-                transform3: T3,
-                transform4: T4,
-                destination: B,
-                options?: PipelineOptions,
-            ): PipelinePromise<B>;
-            function __promisify__(
-                streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
-                options?: PipelineOptions,
-            ): Promise<void>;
-            function __promisify__(
-                stream1: NodeJS.ReadableStream,
-                stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
-                ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
-            ): Promise<void>;
-        }
-        // TODO: this interface never existed; remove in next major
-        interface Pipe {
-            close(): void;
-            hasRef(): boolean;
-            ref(): void;
-            unref(): void;
+            import __promisify__ = promises.pipeline;
+            export { __promisify__ };
         }
+        type ComposeSource<O> =
+            | NodeJS.ReadableStream
+            | web.ReadableStream<O>
+            | Iterable<O>
+            | AsyncIterable<O>
+            | (() => AsyncIterable<O>);
+        type ComposeTransformStreams<I, O> = NodeJS.ReadWriteStream | web.TransformStream<I, O>;
+        type ComposeTransformGenerator<I, O> = (source: AsyncIterable<I>) => AsyncIterable<O>;
+        type ComposeTransform<S extends ComposeTransformSource<any>, O> = S extends
+            ComposeSource<infer I> | ComposeTransformStreams<any, infer I> | ComposeTransformGenerator<any, infer I>
+            ? ComposeTransformStreams<I, O> | ComposeTransformGenerator<I, O>
+            : never;
+        type ComposeTransformSource<O> = ComposeSource<O> | ComposeTransform<any, O>;
+        type ComposeDestination<S extends ComposeTransformSource<any>> = S extends ComposeTransformSource<infer I> ?
+                | NodeJS.WritableStream
+                | web.WritableStream<I>
+                | web.TransformStream<I, any>
+                | ((source: AsyncIterable<I>) => void)
+            : never;
+        /**
+         * Combines two or more streams into a `Duplex` stream that writes to the
+         * first stream and reads from the last. Each provided stream is piped into
+         * the next, using `stream.pipeline`. If any of the streams error then all
+         * are destroyed, including the outer `Duplex` stream.
+         *
+         * Because `stream.compose` returns a new stream that in turn can (and
+         * should) be piped into other streams, it enables composition. In contrast,
+         * when passing streams to `stream.pipeline`, typically the first stream is
+         * a readable stream and the last a writable stream, forming a closed
+         * circuit.
+         *
+         * If passed a `Function` it must be a factory method taking a `source`
+         * `Iterable`.
+         *
+         * ```js
+         * import { compose, Transform } from 'node:stream';
+         *
+         * const removeSpaces = new Transform({
+         *   transform(chunk, encoding, callback) {
+         *     callback(null, String(chunk).replace(' ', ''));
+         *   },
+         * });
+         *
+         * async function* toUpper(source) {
+         *   for await (const chunk of source) {
+         *     yield String(chunk).toUpperCase();
+         *   }
+         * }
+         *
+         * let res = '';
+         * for await (const buf of compose(removeSpaces, toUpper).end('hello world')) {
+         *   res += buf;
+         * }
+         *
+         * console.log(res); // prints 'HELLOWORLD'
+         * ```
+         *
+         * `stream.compose` can be used to convert async iterables, generators and
+         * functions into streams.
+         *
+         * * `AsyncIterable` converts into a readable `Duplex`. Cannot yield
+         *   `null`.
+         * * `AsyncGeneratorFunction` converts into a readable/writable transform `Duplex`.
+         *   Must take a source `AsyncIterable` as first parameter. Cannot yield
+         *   `null`.
+         * * `AsyncFunction` converts into a writable `Duplex`. Must return
+         *   either `null` or `undefined`.
+         *
+         * ```js
+         * import { compose } from 'node:stream';
+         * import { finished } from 'node:stream/promises';
+         *
+         * // Convert AsyncIterable into readable Duplex.
+         * const s1 = compose(async function*() {
+         *   yield 'Hello';
+         *   yield 'World';
+         * }());
+         *
+         * // Convert AsyncGenerator into transform Duplex.
+         * const s2 = compose(async function*(source) {
+         *   for await (const chunk of source) {
+         *     yield String(chunk).toUpperCase();
+         *   }
+         * });
+         *
+         * let res = '';
+         *
+         * // Convert AsyncFunction into writable Duplex.
+         * const s3 = compose(async function(source) {
+         *   for await (const chunk of source) {
+         *     res += chunk;
+         *   }
+         * });
+         *
+         * await finished(compose(s1, s2, s3));
+         *
+         * console.log(res); // prints 'HELLOWORLD'
+         * ```
+         *
+         * For convenience, the `readable.compose(stream)` method is available on
+         * `Readable` and `Duplex` streams as a wrapper for this function.
+         * @since v16.9.0
+         * @experimental
+         */
+        /* eslint-disable @definitelytyped/no-unnecessary-generics */
+        function compose(stream: ComposeSource<any> | ComposeDestination<any>): Duplex;
+        function compose<
+            S extends ComposeSource<any> | ComposeTransform<any, any>,
+            D extends ComposeTransform<S, any> | ComposeDestination<S>,
+        >(
+            source: S,
+            destination: D,
+        ): Duplex;
+        function compose<
+            S extends ComposeSource<any> | ComposeTransform<any, any>,
+            T extends ComposeTransform<S, any>,
+            D extends ComposeTransform<T, any> | ComposeDestination<T>,
+        >(source: S, transform: T, destination: D): Duplex;
+        function compose<
+            S extends ComposeSource<any> | ComposeTransform<any, any>,
+            T1 extends ComposeTransform<S, any>,
+            T2 extends ComposeTransform<T1, any>,
+            D extends ComposeTransform<T2, any> | ComposeDestination<T2>,
+        >(source: S, transform1: T1, transform2: T2, destination: D): Duplex;
+        function compose<
+            S extends ComposeSource<any> | ComposeTransform<any, any>,
+            T1 extends ComposeTransform<S, any>,
+            T2 extends ComposeTransform<T1, any>,
+            T3 extends ComposeTransform<T2, any>,
+            D extends ComposeTransform<T3, any> | ComposeDestination<T3>,
+        >(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): Duplex;
+        function compose<
+            S extends ComposeSource<any> | ComposeTransform<any, any>,
+            T1 extends ComposeTransform<S, any>,
+            T2 extends ComposeTransform<T1, any>,
+            T3 extends ComposeTransform<T2, any>,
+            T4 extends ComposeTransform<T3, any>,
+            D extends ComposeTransform<T4, any> | ComposeDestination<T4>,
+        >(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): Duplex;
+        function compose(
+            ...streams: [
+                ComposeSource<any>,
+                ...ComposeTransform<any, any>[],
+                ComposeDestination<any>,
+            ]
+        ): Duplex;
+        /* eslint-enable @definitelytyped/no-unnecessary-generics */
         /**
          * Returns whether the stream has encountered an error.
          * @since v17.3.0, v16.14.0
          */
-        function isErrored(stream: Readable | Writable | NodeJS.ReadableStream | NodeJS.WritableStream): boolean;
+        function isErrored(
+            stream: NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream,
+        ): boolean;
         /**
          * Returns whether the stream is readable.
          * @since v17.4.0, v16.14.0
          * @returns Only returns `null` if `stream` is not a valid `Readable`, `Duplex` or `ReadableStream`.
          */
-        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean | null;
+        function isReadable(stream: NodeJS.ReadableStream | web.ReadableStream): boolean | null;
         /**
          * Returns whether the stream is writable.
          * @since v20.0.0
          * @returns Only returns `null` if `stream` is not a valid `Writable`, `Duplex` or `WritableStream`.
          */
-        function isWritable(stream: Writable | NodeJS.WritableStream): boolean | null;
+        function isWritable(stream: NodeJS.WritableStream | web.WritableStream): boolean | null;
+    }
+    global {
+        namespace NodeJS {
+            // These interfaces are vestigial, and correspond roughly to the "streams2" interfaces
+            // from early versions of Node.js, but they are still used widely across the ecosystem.
+            // Accordingly, they are commonly used as "in-types" for @types/node APIs, so that
+            // eg. streams returned from older libraries will still be considered valid input to
+            // functions which accept stream arguments.
+            // It's not possible to change or remove these without astronomical levels of breakage.
+            interface ReadableStream extends EventEmitter {
+                readable: boolean;
+                read(size?: number): string | Buffer;
+                setEncoding(encoding: BufferEncoding): this;
+                pause(): this;
+                resume(): this;
+                isPaused(): boolean;
+                pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined }): T;
+                unpipe(destination?: WritableStream): this;
+                unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
+                wrap(oldStream: ReadableStream): this;
+                [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
+            }
+            interface WritableStream extends EventEmitter {
+                writable: boolean;
+                write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+                end(cb?: () => void): this;
+                end(data: string | Uint8Array, cb?: () => void): this;
+                end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
+            }
+            interface ReadWriteStream extends ReadableStream, WritableStream {}
+        }
     }
     export = Stream;
 }
-declare module "node:stream" {
-    import stream = require("stream");
+declare module "stream" {
+    import stream = require("node:stream");
     export = stream;
 }