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

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

@@ -1,114 +0,0 @@
-declare module "node:stream/consumers" {
-    import { Blob, NonSharedBuffer } from "node:buffer";
-    import { ReadableStream } from "node:stream/web";
-    /**
-     * ```js
-     * import { arrayBuffer } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     * import { TextEncoder } from 'node:util';
-     *
-     * const encoder = new TextEncoder();
-     * const dataArray = encoder.encode('hello world from consumers!');
-     *
-     * const readable = Readable.from(dataArray);
-     * const data = await arrayBuffer(readable);
-     * console.log(`from readable: ${data.byteLength}`);
-     * // Prints: from readable: 76
-     * ```
-     * @since v16.7.0
-     * @returns Fulfills with an `ArrayBuffer` containing the full contents of the stream.
-     */
-    function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
-    /**
-     * ```js
-     * import { blob } from 'node:stream/consumers';
-     *
-     * const dataBlob = new Blob(['hello world from consumers!']);
-     *
-     * const readable = dataBlob.stream();
-     * const data = await blob(readable);
-     * console.log(`from readable: ${data.size}`);
-     * // Prints: from readable: 27
-     * ```
-     * @since v16.7.0
-     * @returns Fulfills with a `Blob` containing the full contents of the stream.
-     */
-    function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
-    /**
-     * ```js
-     * import { buffer } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     * import { Buffer } from 'node:buffer';
-     *
-     * const dataBuffer = Buffer.from('hello world from consumers!');
-     *
-     * const readable = Readable.from(dataBuffer);
-     * const data = await buffer(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 27
-     * ```
-     * @since v16.7.0
-     * @returns Fulfills with a `Buffer` containing the full contents of the stream.
-     */
-    function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
-    /**
-     * ```js
-     * import { bytes } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     * import { Buffer } from 'node:buffer';
-     *
-     * const dataBuffer = Buffer.from('hello world from consumers!');
-     *
-     * const readable = Readable.from(dataBuffer);
-     * const data = await bytes(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 27
-     * ```
-     * @since v25.6.0
-     * @returns Fulfills with a `Uint8Array` containing the full contents of the stream.
-     */
-    function bytes(
-        stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>,
-    ): Promise<NodeJS.NonSharedUint8Array>;
-    /**
-     * ```js
-     * import { json } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     *
-     * const items = Array.from(
-     *   {
-     *     length: 100,
-     *   },
-     *   () => ({
-     *     message: 'hello world from consumers!',
-     *   }),
-     * );
-     *
-     * const readable = Readable.from(JSON.stringify(items));
-     * const data = await json(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 100
-     * ```
-     * @since v16.7.0
-     * @returns Fulfills with the contents of the stream parsed as a
-     * UTF-8 encoded string that is then passed through `JSON.parse()`.
-     */
-    function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
-    /**
-     * ```js
-     * import { text } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     *
-     * const readable = Readable.from('Hello world from consumers!');
-     * const data = await text(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 27
-     * ```
-     * @since v16.7.0
-     * @returns Fulfills with the contents of the stream parsed as a UTF-8 encoded string.
-     */
-    function text(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<string>;
-}
-declare module "stream/consumers" {
-    export * from "node:stream/consumers";
-}

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

@@ -1,301 +0,0 @@
-declare module "node:stream/iter" {
-    // Symbols and custom typedefs
-    const broadcastProtocol: unique symbol;
-    const drainableProtocol: unique symbol;
-    const shareProtocol: unique symbol;
-    const shareSyncProtocol: unique symbol;
-    const toAsyncStreamable: unique symbol;
-    const toStreamable: unique symbol;
-    type Source =
-        | string
-        | ArrayBufferLike
-        | ArrayBufferView
-        | Iterable<SyncSource>
-        | AsyncIterable<Source>
-        | Streamable
-        | AsyncStreamable;
-    type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | Streamable;
-    type Transform = StatelessTransformFn | StatefulTransform;
-    type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform;
-    type TransformResult =
-        | string
-        | ArrayBufferLike
-        | ArrayBufferView
-        | Iterable<SyncTransformResult>
-        | AsyncIterable<TransformResult>;
-    type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult>;
-    interface AsyncStreamable {
-        [toAsyncStreamable](): Source;
-    }
-    interface Broadcastable {
-        [broadcastProtocol](options: BroadcastOptions): Broadcast;
-    }
-    interface Drainable {
-        [drainableProtocol](): Promise<boolean> | null;
-    }
-    interface Shareable {
-        [shareProtocol](options: ShareOptions): Share;
-    }
-    interface Streamable {
-        [toStreamable](): SyncSource;
-    }
-    interface SyncShareable {
-        [shareSyncProtocol](options: ShareSyncOptions): SyncShare;
-    }
-    // IDL dictionaries, enums, typedefs
-    type BackpressurePolicy = "strict" | "block" | "drop-oldest" | "drop-newest";
-    type ByteReadableStream = AsyncIterable<Uint8Array[]>;
-    type SyncByteReadableStream = Iterable<Uint8Array[]>;
-    interface WriteOptions {
-        signal?: AbortSignal;
-    }
-    interface PushStreamOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        signal?: AbortSignal;
-    }
-    interface PullOptions {
-        signal?: AbortSignal;
-    }
-    interface PipeToOptions {
-        signal?: AbortSignal;
-        preventClose?: boolean;
-        preventFail?: boolean;
-    }
-    interface PipeToSyncOptions {
-        preventClose?: boolean;
-        preventFail?: boolean;
-    }
-    interface ConsumeOptions {
-        signal?: AbortSignal;
-        limit?: number;
-    }
-    interface ConsumeSyncOptions {
-        limit?: number;
-    }
-    interface TextConsumeOptions extends ConsumeOptions {
-        encoding?: string;
-    }
-    interface TextConsumeSyncOptions extends ConsumeSyncOptions {
-        encoding?: string;
-    }
-    interface MergeOptions {
-        signal?: AbortSignal;
-    }
-    interface BroadcastOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        signal?: AbortSignal;
-    }
-    interface ShareOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        signal?: AbortSignal;
-    }
-    interface ShareSyncOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-    }
-    interface DuplexDirectionOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-    }
-    interface DuplexOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        a?: DuplexDirectionOptions;
-        b?: DuplexDirectionOptions;
-        signal?: AbortSignal;
-    }
-    interface TransformCallbackOptions {
-        signal: AbortSignal;
-    }
-    interface StatelessTransformFn {
-        (
-            chunks: Uint8Array[] | null,
-            options: TransformCallbackOptions,
-        ): Promise<TransformResult | null> | TransformResult | null;
-    }
-    interface SyncStatelessTransformFn {
-        (chunks: Uint8Array[] | null): SyncTransformResult | null;
-    }
-    interface StatefulTransform {
-        transform(
-            source: AsyncIterable<Uint8Array[] | null>,
-            options: TransformCallbackOptions,
-        ): AsyncIterable<TransformResult>;
-    }
-    interface SyncStatefulTransform {
-        transform(source: Iterable<Uint8Array[] | null>): Iterable<SyncTransformResult>;
-    }
-    // IDL interfaces
-    interface PushWriter extends Writer, Drainable {}
-    interface PushStreamResult {
-        writer: PushWriter;
-        readable: ByteReadableStream;
-    }
-    interface BroadcastWriter extends Writer, Drainable {}
-    interface BroadcastResult {
-        writer: BroadcastWriter;
-        broadcast: Broadcast;
-    }
-    interface Writer extends Disposable, AsyncDisposable {
-        readonly desiredSize: number | null;
-        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
-        writev(chunks: Array<Uint8Array | string>, options?: WriteOptions): Promise<void>;
-        writeSync(chunk: Uint8Array | string): boolean;
-        writevSync(chunks: Array<Uint8Array | string>): boolean;
-        end(options?: WriteOptions): Promise<number>;
-        endSync(): number;
-        fail(reason?: any): void;
-    }
-    interface PartialWriter extends Partial<Writer> {
-        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
-    }
-    interface SyncWriter extends Disposable {
-        readonly desiredSize: number | null;
-        writeSync(chunk: Uint8Array | string): number;
-        writevSync(chunks: Array<Uint8Array | string>): number;
-        endSync(): number;
-        fail(reason?: any): void;
-    }
-    interface PartialSyncWriter extends Partial<SyncWriter> {
-        writeSync(chunk: Uint8Array | string): number;
-    }
-    interface Broadcast extends Disposable {
-        readonly consumerCount: number;
-        readonly bufferSize: number;
-        push(...args: any[]): ByteReadableStream;
-        cancel(reason?: any): void;
-    }
-    interface Share extends Disposable {
-        readonly consumerCount: number;
-        readonly bufferSize: number;
-        pull(...args: any[]): ByteReadableStream;
-        cancel(reason?: any): void;
-    }
-    interface SyncShare extends Disposable {
-        readonly consumerCount: number;
-        readonly bufferSize: number;
-        pull(...args: any): SyncByteReadableStream;
-        cancel(reason?: any): void;
-    }
-    interface DuplexChannel extends AsyncDisposable {
-        readonly writer: Writer;
-        readonly readable: ByteReadableStream;
-        close(): Promise<void>;
-    }
-    // Push stream creation
-    function push(...transforms: Transform[]): PushStreamResult;
-    function push(...args: [...transforms: Transform[], options: PushStreamOptions]): PushStreamResult;
-    // Stream factories
-    function from(input: Source): ByteReadableStream;
-    function fromSync(input: SyncSource): SyncByteReadableStream;
-    // Pull pipelines
-    function pull(source: Source, ...transforms: Transform[]): ByteReadableStream;
-    function pull(
-        source: Source,
-        ...args: [...transforms: Transform[], options: PullOptions]
-    ): ByteReadableStream;
-    function pullSync(source: SyncSource, ...transforms: SyncTransform[]): SyncByteReadableStream;
-    // Pipe operations
-    function pipeTo(source: Source, writer: PartialWriter, options?: PipeToOptions): Promise<number>;
-    function pipeTo(source: Source, ...args: [...transforms: Transform[], writer: PartialWriter]): Promise<number>;
-    function pipeTo(
-        source: Source,
-        ...args: [...transforms: Transform[], writer: PartialWriter, options: PipeToOptions]
-    ): Promise<number>;
-    function pipeToSync(source: SyncSource, writer: PartialSyncWriter, options?: PipeToSyncOptions): number;
-    function pipeToSync(
-        source: SyncSource,
-        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter]
-    ): number;
-    function pipeToSync(
-        source: SyncSource,
-        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter, options: PipeToSyncOptions]
-    ): number;
-    // Consumers
-    function bytes(source: Source, options?: ConsumeOptions): Promise<Uint8Array>;
-    function bytesSync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array;
-    function text(source: Source, options?: TextConsumeOptions): Promise<string>;
-    function textSync(source: SyncSource, options?: TextConsumeSyncOptions): string;
-    function arrayBuffer(source: Source, options?: ConsumeOptions): Promise<ArrayBuffer>;
-    function arrayBufferSync(source: SyncSource, options?: ConsumeSyncOptions): ArrayBuffer;
-    function array(source: Source, options?: ConsumeOptions): Promise<Uint8Array[]>;
-    function arraySync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array[];
-    // Utilities
-    function tap(callback: StatelessTransformFn): StatelessTransformFn;
-    function tapSync(callback: SyncStatelessTransformFn): SyncStatelessTransformFn;
-    function merge(...sources: Source[]): ByteReadableStream;
-    function merge(...args: [...sources: Source[], options: MergeOptions]): ByteReadableStream;
-    function ondrain(drainable: any): Promise<boolean> | null;
-    // Multi-consumer
-    function broadcast(options?: BroadcastOptions): BroadcastResult;
-    function share(source: Source, options?: ShareOptions): Share;
-    function shareSync(source: SyncSource, options?: ShareSyncOptions): SyncShare;
-    // Duplex
-    function duplex(options?: DuplexOptions): [DuplexChannel, DuplexChannel];
-    // Node.js-specific extensions
-    namespace Broadcast {
-        /**
-         * Create a `Broadcast` from an existing source. The source is consumed
-         * automatically and pushed to all subscribers.
-         * @since v25.9.0
-         * @param options Same as `broadcast()`.
-         */
-        function from(
-            input: ByteReadableStream | SyncByteReadableStream | Broadcastable,
-            options?: BroadcastOptions,
-        ): BroadcastResult;
-    }
-    namespace Share {
-        /**
-         * Create a `Share` from an existing source.
-         * @since v25.9.0
-         * @param options Same as `share()`.
-         */
-        function from(input: ByteReadableStream | SyncByteReadableStream | Shareable, options?: ShareOptions): Share;
-    }
-    namespace SyncShare {
-        /**
-         * @since v25.9.0
-         */
-        function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare;
-    }
-    namespace Stream {
-        export {
-            array,
-            arrayBuffer,
-            arrayBufferSync,
-            arraySync,
-            broadcast,
-            broadcastProtocol,
-            bytes,
-            bytesSync,
-            drainableProtocol,
-            duplex,
-            from,
-            fromSync,
-            merge,
-            ondrain,
-            pipeTo,
-            pipeToSync,
-            pull,
-            pullSync,
-            push,
-            share,
-            shareProtocol,
-            shareSync,
-            shareSyncProtocol,
-            tap,
-            tapSync,
-            text,
-            textSync,
-            toAsyncStreamable,
-            toStreamable,
-        };
-    }
-}
-declare module "stream/iter" {
-    export * from "node:stream/iter";
-}

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

@@ -1,211 +0,0 @@
-declare module "node:stream/promises" {
-    import { Abortable } from "node:events";
-    import {
-        FinishedOptions as _FinishedOptions,
-        PipelineDestination,
-        PipelineSource,
-        PipelineTransform,
-    } from "node:stream";
-    import { ReadableStream, WritableStream } from "node:stream/web";
-    interface FinishedOptions extends _FinishedOptions {
-        /**
-         * If true, removes the listeners registered by this function before the promise is fulfilled.
-         * @default false
-         */
-        cleanup?: boolean | undefined;
-    }
-    /**
-     * ```js
-     * import { finished } from 'node:stream/promises';
-     * import { createReadStream } from 'node:fs';
-     *
-     * const rs = createReadStream('archive.tar');
-     *
-     * async function run() {
-     *   await finished(rs);
-     *   console.log('Stream is done reading.');
-     * }
-     *
-     * run().catch(console.error);
-     * 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).
-     *
-     * `stream.finished()` leaves dangling event listeners (in particular
-     * `'error'`, `'end'`, `'finish'` and `'close'`) after the returned promise is
-     * resolved or rejected. The reason for this is so that unexpected `'error'`
-     * events (due to incorrect stream implementations) do not cause unexpected
-     * crashes. If this is unwanted behavior then `options.cleanup` should be set to
-     * `true`:
-     *
-     * ```js
-     * await finished(rs, { cleanup: true });
-     * ```
-     * @since v15.0.0
-     * @returns Fulfills when the stream is no longer readable or writable.
-     */
-    function finished(
-        stream: NodeJS.ReadableStream | NodeJS.WritableStream | ReadableStream | WritableStream,
-        options?: FinishedOptions,
-    ): Promise<void>;
-    interface PipelineOptions extends Abortable {
-        end?: boolean | undefined;
-    }
-    type PipelineResult<S extends PipelineDestination<any, any>> = S extends (...args: any[]) => PromiseLike<infer R>
-        ? Promise<R>
-        : Promise<void>;
-    /**
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     * import { createGzip } from 'node:zlib';
-     *
-     * await pipeline(
-     *   createReadStream('archive.tar'),
-     *   createGzip(),
-     *   createWriteStream('archive.tar.gz'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * To use an `AbortSignal`, pass it inside an options object, as the last argument.
-     * When the signal is aborted, `destroy` will be called on the underlying pipeline,
-     * with an `AbortError`.
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     * import { createGzip } from 'node:zlib';
-     *
-     * const ac = new AbortController();
-     * const { signal } = ac;
-     * setImmediate(() => ac.abort());
-     * try {
-     *   await pipeline(
-     *     createReadStream('archive.tar'),
-     *     createGzip(),
-     *     createWriteStream('archive.tar.gz'),
-     *     { signal },
-     *   );
-     * } catch (err) {
-     *   console.error(err); // AbortError
-     * }
-     * ```
-     *
-     * The `pipeline` API also supports async generators:
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     *
-     * await pipeline(
-     *   createReadStream('lowercase.txt'),
-     *   async function* (source, { signal }) {
-     *     source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
-     *     for await (const chunk of source) {
-     *       yield await processChunk(chunk, { signal });
-     *     }
-     *   },
-     *   createWriteStream('uppercase.txt'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * Remember to handle the `signal` argument passed into the async generator.
-     * Especially in the case where the async generator is the source for the
-     * pipeline (i.e. first argument) or the pipeline will never complete.
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import fs from 'node:fs';
-     * await pipeline(
-     *   async function* ({ signal }) {
-     *     await someLongRunningfn({ signal });
-     *     yield 'asd';
-     *   },
-     *   fs.createWriteStream('uppercase.txt'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * The `pipeline` API provides [callback version](https://nodejs.org/docs/latest-v25.x/api/stream.html#streampipelinesource-transforms-destination-callback):
-     * @since v15.0.0
-     * @returns Fulfills when the pipeline is complete.
-     */
-    function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
-        source: A,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline<
-        A extends PipelineSource<any>,
-        T1 extends PipelineTransform<A, any>,
-        B extends PipelineDestination<T1, any>,
-    >(
-        source: A,
-        transform1: T1,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline<
-        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,
-    ): PipelineResult<B>;
-    function pipeline<
-        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,
-    ): PipelineResult<B>;
-    function pipeline<
-        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,
-    ): PipelineResult<B>;
-    function pipeline(
-        streams: readonly [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>],
-        options?: PipelineOptions,
-    ): Promise<void>;
-    function pipeline(
-        ...streams: [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>]
-    ): Promise<void>;
-    function pipeline(
-        ...streams: [
-            PipelineSource<any>,
-            ...PipelineTransform<any, any>[],
-            PipelineDestination<any, any>,
-            options: PipelineOptions,
-        ]
-    ): Promise<void>;
-}
-declare module "stream/promises" {
-    export * from "node:stream/promises";
-}