@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102043356.6791d4e

package/dist/esm/modules/stream/streams.browser.js

@@ -0,0 +1,3267 @@
+/**
+ * Native Stream Implementation - Browser
+ *
+ * Uses Web Streams API (ReadableStream, WritableStream, TransformStream)
+ * for true native streaming in browsers.
+ *
+ * Supported browsers:
+ * - Chrome >= 89
+ * - Firefox >= 102
+ * - Safari >= 14.1
+ * - Edge >= 89
+ */
+import { EventEmitter } from "./event-emitter.js";
+import { PullStream as StandalonePullStream } from "./pull-stream.js";
+import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "./buffered-stream.js";
+import { concatUint8Arrays, getTextDecoder, textDecoder } from "./shared.js";
+// =============================================================================
+// Readable Stream Wrapper
+// =============================================================================
+/**
+ * A wrapper around Web ReadableStream that provides Node.js-like API
+ */
+export class Readable extends EventEmitter {
+    constructor(options) {
+        super();
+        this._reader = null;
+        this._buffer = [];
+        this._bufferIndex = 0;
+        this._unshiftBuffer = [];
+        this._bufferSize = 0;
+        this._reading = false;
+        this._ended = false;
+        this._destroyed = false;
+        this._errored = null;
+        this._closed = false;
+        this._paused = true;
+        this._flowing = false;
+        this._pipeTo = [];
+        this._pipeListeners = new Map();
+        this._encoding = null;
+        this._decoder = null;
+        this._didRead = false;
+        this._aborted = false;
+        // Whether this stream uses push() mode (true) or Web Stream mode (false)
+        this._pushMode = false;
+        // Whether this stream was created from an external Web Stream (true) or is controllable (false)
+        this._webStreamMode = false;
+        this.objectMode = options?.objectMode ?? false;
+        this.readableHighWaterMark = options?.highWaterMark ?? 16384;
+        this.autoDestroy = options?.autoDestroy ?? true;
+        this.emitClose = options?.emitClose ?? true;
+        // Store user-provided read function
+        if (options?.read) {
+            this._read = options.read.bind(this);
+            this._pushMode = true; // User will call push()
+        }
+        if (options?.stream) {
+            this._stream = options.stream;
+            this._webStreamMode = true; // Created from external Web Stream
+        }
+        else {
+            // Create a controllable stream
+            let controller;
+            this._stream = new ReadableStream({
+                start: ctrl => {
+                    controller = ctrl;
+                },
+                pull: async () => {
+                    // Signal that more data can be pushed
+                    this.emit("drain");
+                },
+                cancel: reason => {
+                    this._ended = true;
+                    this._aborted = true;
+                    if (this.emitClose) {
+                        this.emit("close");
+                    }
+                }
+            });
+            // Expose controller for push/end
+            this._controller = controller;
+        }
+    }
+    /**
+     * Create a Readable from an iterable (static factory method)
+     */
+    static from(iterable, options) {
+        const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
+        (async () => {
+            try {
+                for await (const chunk of iterable) {
+                    if (!readable.push(chunk)) {
+                        // Backpressure
+                        await new Promise(resolve => setTimeout(resolve, 0));
+                    }
+                }
+                readable.push(null);
+            }
+            catch (err) {
+                readable.destroy(err);
+            }
+        })();
+        return readable;
+    }
+    /**
+     * Check if a stream has been disturbed (read from)
+     */
+    static isDisturbed(stream) {
+        return stream._didRead || stream._ended || stream._destroyed;
+    }
+    /**
+     * Convert a Web ReadableStream to Node.js Readable
+     */
+    static fromWeb(webStream, options) {
+        return new Readable({ ...options, stream: webStream });
+    }
+    /**
+     * Convert a Node.js Readable to Web ReadableStream
+     */
+    static toWeb(nodeStream) {
+        return nodeStream.webStream;
+    }
+    /**
+     * Push data to the stream (when using controllable stream)
+     */
+    push(chunk) {
+        if (this._destroyed) {
+            return false;
+        }
+        // Mark as push mode when push() is called
+        this._pushMode = true;
+        const controller = this._controller;
+        if (chunk === null) {
+            // Prevent duplicate end handling
+            if (this._ended) {
+                return false;
+            }
+            this._ended = true;
+            if (controller) {
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Controller may already be closed
+                }
+            }
+            this.emit("end");
+            // Note: Don't call destroy() here, let the stream be consumed naturally
+            // The reader will return done:true when it finishes reading
+            return false;
+        }
+        if (this._flowing) {
+            // In flowing mode, emit data directly without buffering or enqueueing
+            // const chunkStr = chunk instanceof Uint8Array ? new TextDecoder().decode(chunk.slice(0, 50)) : String(chunk).slice(0, 50);
+            // console.log(`[Readable#${this._id}.push FLOWING] emit data size:${(chunk as any).length || (chunk as any).byteLength} start:"${chunkStr}"`);
+            this.emit("data", chunk);
+            // Check if stream was paused during emit (backpressure from consumer)
+            if (!this._flowing) {
+                return false;
+            }
+            // After emitting data, call _read again if available (Node.js behavior)
+            if (this._read && !this._ended) {
+                queueMicrotask(() => {
+                    if (this._flowing && !this._ended && !this._destroyed) {
+                        this._read(this.readableHighWaterMark);
+                    }
+                });
+            }
+            // In flowing mode, return true (no backpressure since data is immediately consumed)
+            return true;
+        }
+        else {
+            // In paused mode, buffer for later
+            const wasEmpty = this._bufferedLength() === 0;
+            // const chunkStrBuf = chunk instanceof Uint8Array ? new TextDecoder().decode((chunk as Uint8Array).slice(0, 50)) : String(chunk).slice(0, 50);
+            // console.log(`[Readable#${this._id}.push PAUSED->BUFFER] buffer len:${this._buffer.length}->${this._buffer.length + 1} start:"${chunkStrBuf}"`);
+            this._buffer.push(chunk);
+            if (!this.objectMode) {
+                this._bufferSize += this._getChunkSize(chunk);
+            }
+            // NOTE: Do NOT enqueue to Web Stream controller here!
+            // In push mode, _buffer is the only source of data for data events.
+            // Web Stream is only used for async iteration when not in push mode.
+            // Enqueueing here would cause data duplication when _startReading is also running.
+            // Emit readable event when buffer goes from empty to having data
+            if (wasEmpty) {
+                queueMicrotask(() => this.emit("readable"));
+            }
+            // Return false if buffer exceeds high water mark (backpressure signal)
+            // Fast path for object mode - just count items
+            if (this.objectMode) {
+                return this._bufferedLength() < this.readableHighWaterMark;
+            }
+            // For binary mode, use tracked buffer size (O(1))
+            return this._bufferSize < this.readableHighWaterMark;
+        }
+    }
+    /**
+     * Put a chunk back at the front of the buffer
+     * Note: unshift is allowed even after end, as it's used to put back already read data
+     */
+    unshift(chunk) {
+        if (this._destroyed) {
+            return;
+        }
+        this._bufferUnshift(chunk);
+        if (!this.objectMode) {
+            this._bufferSize += this._getChunkSize(chunk);
+        }
+    }
+    /**
+     * Read data from the stream
+     */
+    read(size) {
+        this._didRead = true;
+        if (this._bufferedLength() > 0) {
+            if (this.objectMode || size === undefined) {
+                const chunk = this._bufferShift();
+                if (!this.objectMode) {
+                    this._bufferSize -= this._getChunkSize(chunk);
+                }
+                return this._applyEncoding(chunk);
+            }
+            // For binary mode, handle size
+            const chunk = this._bufferShift();
+            if (!this.objectMode) {
+                this._bufferSize -= this._getChunkSize(chunk);
+            }
+            return this._applyEncoding(chunk);
+        }
+        return null;
+    }
+    _bufferedLength() {
+        return this._unshiftBuffer.length + (this._buffer.length - this._bufferIndex);
+    }
+    _bufferPeek() {
+        const unshiftLen = this._unshiftBuffer.length;
+        if (unshiftLen > 0) {
+            return this._unshiftBuffer[unshiftLen - 1];
+        }
+        return this._bufferIndex < this._buffer.length ? this._buffer[this._bufferIndex] : null;
+    }
+    _bufferShift() {
+        if (this._unshiftBuffer.length > 0) {
+            return this._unshiftBuffer.pop();
+        }
+        const chunk = this._buffer[this._bufferIndex++];
+        // Fast reset when emptied
+        if (this._bufferIndex === this._buffer.length) {
+            this._buffer.length = 0;
+            this._bufferIndex = 0;
+            return chunk;
+        }
+        // Occasionally compact to avoid unbounded growth of the unused prefix
+        if (this._bufferIndex > 1024 && this._bufferIndex * 2 > this._buffer.length) {
+            this._buffer = this._buffer.slice(this._bufferIndex);
+            this._bufferIndex = 0;
+        }
+        return chunk;
+    }
+    _bufferUnshift(chunk) {
+        if (this._bufferIndex === 0) {
+            // Avoid O(n) Array.unshift() by using a small front stack.
+            // Semantics: last unshifted chunk is returned first.
+            this._unshiftBuffer.push(chunk);
+            return;
+        }
+        this._bufferIndex--;
+        this._buffer[this._bufferIndex] = chunk;
+    }
+    _getChunkSize(chunk) {
+        // Keep semantics aligned with previous implementation:
+        // - Uint8Array counts by byteLength
+        // - other types count as 1
+        return chunk instanceof Uint8Array ? chunk.byteLength : 1;
+    }
+    /**
+     * Set encoding for string output
+     */
+    setEncoding(encoding) {
+        this._encoding = encoding;
+        // Fast path: reuse cached utf-8 decoder; otherwise lazy-create on first decode.
+        if (encoding === "utf-8" || encoding === "utf8") {
+            this._decoder = textDecoder;
+        }
+        else {
+            this._decoder = null;
+        }
+        return this;
+    }
+    _applyEncoding(chunk) {
+        if (this._encoding && chunk instanceof Uint8Array) {
+            // Use cached decoder instances (module-level for utf-8, cached per encoding otherwise).
+            if (!this._decoder) {
+                this._decoder = getTextDecoder(this._encoding);
+            }
+            return this._decoder.decode(chunk);
+        }
+        return chunk;
+    }
+    /**
+     * Wrap an old-style stream
+     */
+    wrap(stream) {
+        stream.on("data", (chunk) => {
+            if (!this.push(chunk)) {
+                stream.pause();
+            }
+        });
+        stream.on("end", () => this.push(null));
+        stream.on("error", (err) => this.destroy(err));
+        stream.on("close", () => this.destroy());
+        return this;
+    }
+    /**
+     * Pause the stream
+     */
+    pause() {
+        this._paused = true;
+        this._flowing = false;
+        return this;
+    }
+    /**
+     * Resume the stream
+     */
+    resume() {
+        this._paused = false;
+        this._flowing = true;
+        // Emit any buffered data first
+        while (this._bufferedLength() > 0 && this._flowing) {
+            const chunk = this._bufferShift();
+            if (!this.objectMode) {
+                this._bufferSize -= this._getChunkSize(chunk);
+            }
+            this.emit("data", chunk);
+        }
+        // If already ended, emit end event
+        if (this._ended && this._bufferedLength() === 0) {
+            this.emit("end");
+        }
+        else if (this._read) {
+            // Call user-provided read function asynchronously
+            // This allows multiple pipe() calls to register before data flows
+            queueMicrotask(() => {
+                if (this._flowing && !this._ended && !this._destroyed) {
+                    this._read(this.readableHighWaterMark);
+                }
+            });
+        }
+        else if (this._webStreamMode && !this._pushMode) {
+            // Only start reading from underlying Web Stream if:
+            // 1. Stream was created from external Web Stream (_webStreamMode)
+            // 2. Not in push mode (no one called push() yet)
+            this._startReading();
+        }
+        return this;
+    }
+    /**
+     * Override on() to automatically resume when 'data' listener is added
+     * This matches Node.js behavior where adding a 'data' listener puts
+     * the stream into flowing mode.
+     */
+    on(event, listener) {
+        super.on(event, listener);
+        // When a 'data' listener is added, switch to flowing mode
+        if (event === "data") {
+            this.resume();
+        }
+        return this;
+    }
+    /**
+     * Check if paused
+     */
+    isPaused() {
+        return this._paused;
+    }
+    /**
+     * Pipe to a writable stream, transform stream, or duplex stream
+     */
+    pipe(destination) {
+        // IMPORTANT:
+        // Do not rely on `instanceof` here.
+        // In bundled/minified builds, multiple copies of this module can exist,
+        // causing `instanceof Transform/Writable/Duplex` to fail even when the object
+        // is a valid destination.
+        const dest = destination;
+        // Get the actual writable target.
+        // Prefer internal `_writable` (Transform/Duplex wrappers), else treat the destination as writable-like.
+        const candidate = dest?._writable ?? dest;
+        const hasWrite = typeof candidate?.write === "function";
+        const hasEnd = typeof candidate?.end === "function";
+        const hasOn = typeof candidate?.on === "function";
+        const hasOnce = typeof candidate?.once === "function";
+        const hasOff = typeof candidate?.off === "function";
+        if (!hasWrite || !hasEnd || (!hasOnce && !hasOn) || (!hasOff && !candidate?.removeListener)) {
+            throw new Error("Readable.pipe: invalid destination");
+        }
+        const target = candidate;
+        this._pipeTo.push(target);
+        // Create listeners that we can later remove
+        const dataListener = (chunk) => {
+            const canWrite = target.write(chunk);
+            if (!canWrite) {
+                this.pause();
+                if (typeof target.once === "function") {
+                    target.once("drain", () => this.resume());
+                }
+                else {
+                    const resumeOnce = () => {
+                        if (typeof target.off === "function") {
+                            target.off("drain", resumeOnce);
+                        }
+                        else if (typeof target.removeListener === "function") {
+                            target.removeListener("drain", resumeOnce);
+                        }
+                        this.resume();
+                    };
+                    target.on("drain", resumeOnce);
+                }
+            }
+        };
+        const endListener = () => {
+            target.end();
+        };
+        const errorListener = (err) => {
+            if (typeof target.destroy === "function") {
+                target.destroy(err);
+            }
+            else {
+                // Best-effort: forward error to the destination if it supports events.
+                target.emit?.("error", err);
+            }
+        };
+        // Store listeners for later removal in unpipe
+        this._pipeListeners.set(target, {
+            data: dataListener,
+            end: endListener,
+            error: errorListener
+        });
+        this.on("data", dataListener);
+        this.once("end", endListener);
+        this.once("error", errorListener);
+        this.resume();
+        return destination;
+    }
+    /**
+     * Unpipe from destination
+     */
+    unpipe(destination) {
+        if (destination) {
+            const idx = this._pipeTo.indexOf(destination);
+            if (idx !== -1) {
+                this._pipeTo.splice(idx, 1);
+            }
+            // Remove the listeners
+            const listeners = this._pipeListeners.get(destination);
+            if (listeners) {
+                this.off("data", listeners.data);
+                this.off("end", listeners.end);
+                this.off("error", listeners.error);
+                this._pipeListeners.delete(destination);
+            }
+        }
+        else {
+            // Unpipe all
+            for (const target of this._pipeTo) {
+                const listeners = this._pipeListeners.get(target);
+                if (listeners) {
+                    this.off("data", listeners.data);
+                    this.off("end", listeners.end);
+                    this.off("error", listeners.error);
+                    this._pipeListeners.delete(target);
+                }
+            }
+            this._pipeTo = [];
+        }
+        // Pause the stream after unpipe
+        this.pause();
+        return this;
+    }
+    /**
+     * Destroy the stream
+     */
+    destroy(error) {
+        if (this._destroyed) {
+            return this;
+        }
+        this._destroyed = true;
+        this._ended = true;
+        if (error) {
+            this._errored = error;
+            this.emit("error", error);
+        }
+        if (this._reader) {
+            this._reader.cancel().catch(() => { });
+        }
+        this._closed = true;
+        this.emit("close");
+        return this;
+    }
+    /**
+     * Get the underlying Web ReadableStream
+     */
+    get webStream() {
+        return this._stream;
+    }
+    get readable() {
+        return !this._destroyed && !this._ended;
+    }
+    get readableEnded() {
+        return this._ended;
+    }
+    get readableLength() {
+        return this._bufferedLength();
+    }
+    /** Whether the stream has been destroyed */
+    get destroyed() {
+        return this._destroyed;
+    }
+    /** The error that destroyed the stream, or null */
+    get errored() {
+        return this._errored;
+    }
+    /** Whether the stream has been closed */
+    get closed() {
+        return this._closed;
+    }
+    /** Whether the stream is in flowing mode */
+    get readableFlowing() {
+        if (!this._paused && !this._ended) {
+            return this._flowing;
+        }
+        return this._flowing ? true : null;
+    }
+    /** Whether the stream was aborted */
+    get readableAborted() {
+        return this._aborted;
+    }
+    /** Whether read() has ever been called */
+    get readableDidRead() {
+        return this._didRead;
+    }
+    /** Current encoding or null */
+    get readableEncoding() {
+        return this._encoding;
+    }
+    /** Returns array of objects containing info about buffered data */
+    get readableObjectMode() {
+        return this.objectMode;
+    }
+    /**
+     * Get the internal buffer state (for debugging)
+     * Returns array of objects with length and chunk info
+     */
+    get readableBuffer() {
+        return {
+            length: this._bufferedLength(),
+            head: this._bufferPeek()
+        };
+    }
+    async _startReading() {
+        if (this._reading || this._destroyed || !this._flowing) {
+            return;
+        }
+        this._reading = true;
+        try {
+            if (!this._reader) {
+                this._reader = this._stream.getReader();
+            }
+            while (this._flowing && !this._destroyed && !this._pushMode) {
+                const { done, value } = await this._reader.read();
+                // Check _pushMode again after async read - if push() was called, stop reading
+                if (this._pushMode) {
+                    break;
+                }
+                if (done) {
+                    this._ended = true;
+                    this.emit("end");
+                    break;
+                }
+                if (value !== undefined) {
+                    // In flowing mode, emit data directly without buffering
+                    // Only buffer if not flowing (paused mode)
+                    if (this._flowing) {
+                        this.emit("data", value);
+                    }
+                    else {
+                        this._buffer.push(value);
+                        if (!this.objectMode) {
+                            this._bufferSize += this._getChunkSize(value);
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.emit("error", err);
+        }
+        finally {
+            this._reading = false;
+        }
+    }
+    /**
+     * Async iterator support
+     * Uses Web Stream reader for non-push mode, event-based for push mode
+     */
+    async *[Symbol.asyncIterator]() {
+        // First yield any buffered data
+        while (this._bufferedLength() > 0) {
+            const chunk = this._bufferShift();
+            if (!this.objectMode) {
+                this._bufferSize -= this._getChunkSize(chunk);
+            }
+            yield chunk;
+        }
+        // If already ended, we're done
+        if (this._ended) {
+            return;
+        }
+        // For controllable streams (not created from external Web Stream),
+        // use event-based iteration since data comes from push() calls
+        if (!this._webStreamMode) {
+            // Create a promise-based queue for incoming data
+            const dataQueue = [];
+            let resolveNext = null;
+            let rejectNext = null;
+            let done = false;
+            let streamError = null;
+            let dataQueueIndex = 0;
+            const dataHandler = (chunk) => {
+                if (resolveNext) {
+                    resolveNext(chunk);
+                    resolveNext = null;
+                    rejectNext = null;
+                }
+                else {
+                    dataQueue.push(chunk);
+                }
+            };
+            const endHandler = () => {
+                done = true;
+                if (resolveNext) {
+                    resolveNext(null);
+                    resolveNext = null;
+                    rejectNext = null;
+                }
+            };
+            const errorHandler = (err) => {
+                done = true;
+                streamError = err;
+                if (rejectNext) {
+                    rejectNext(err);
+                    resolveNext = null;
+                    rejectNext = null;
+                }
+            };
+            const closeHandler = () => {
+                // If stream closed without end event (e.g., after destroy()),
+                // treat it as done
+                done = true;
+                if (resolveNext) {
+                    resolveNext(null);
+                    resolveNext = null;
+                    rejectNext = null;
+                }
+            };
+            this.on("data", dataHandler);
+            this.on("end", endHandler);
+            this.on("error", errorHandler);
+            this.on("close", closeHandler);
+            try {
+                // Enter flowing mode
+                this.resume();
+                while (!done || dataQueueIndex < dataQueue.length) {
+                    // Check for error before processing
+                    if (streamError) {
+                        throw streamError;
+                    }
+                    if (dataQueueIndex < dataQueue.length) {
+                        const chunk = dataQueue[dataQueueIndex++];
+                        if (dataQueueIndex >= 1024 && dataQueueIndex * 2 >= dataQueue.length) {
+                            dataQueue.splice(0, dataQueueIndex);
+                            dataQueueIndex = 0;
+                        }
+                        yield chunk;
+                    }
+                    else if (!done) {
+                        const chunk = await new Promise((resolve, reject) => {
+                            resolveNext = resolve;
+                            rejectNext = reject;
+                        });
+                        if (chunk !== null) {
+                            yield chunk;
+                        }
+                    }
+                }
+                // Check for error after loop
+                if (streamError) {
+                    throw streamError;
+                }
+            }
+            finally {
+                this.off("data", dataHandler);
+                this.off("end", endHandler);
+                this.off("error", errorHandler);
+                this.off("close", closeHandler);
+            }
+            return;
+        }
+        // For Web Stream mode, use the underlying reader
+        if (!this._reader) {
+            this._reader = this._stream.getReader();
+        }
+        try {
+            while (true) {
+                const { done, value } = await this._reader.read();
+                if (done) {
+                    break;
+                }
+                yield value;
+            }
+        }
+        finally {
+            this._reader.releaseLock();
+        }
+    }
+    /**
+     * Explicit iterator method (same as Symbol.asyncIterator)
+     */
+    iterator(options) {
+        const destroyOnReturn = options?.destroyOnReturn ?? true;
+        const iterator = this[Symbol.asyncIterator]();
+        if (!destroyOnReturn) {
+            return iterator;
+        }
+        // Wrap to handle early return
+        return {
+            next: async () => {
+                return iterator.next();
+            },
+            return: async (value) => {
+                this.destroy();
+                return { done: true, value };
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            }
+        };
+    }
+    // =========================================================================
+    // Async Iterator Helper Methods (Node.js 16.6+)
+    // =========================================================================
+    /**
+     * Map each chunk through an async function
+     */
+    async *map(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            yield await fn(chunk, { signal });
+        }
+    }
+    /**
+     * Filter chunks through an async predicate
+     */
+    async *filter(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (await fn(chunk, { signal })) {
+                yield chunk;
+            }
+        }
+    }
+    /**
+     * FlatMap each chunk
+     */
+    async *flatMap(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            const result = await fn(chunk, { signal });
+            for await (const item of result) {
+                yield item;
+            }
+        }
+    }
+    /**
+     * Take the first n chunks
+     */
+    async *take(limit, options) {
+        const signal = options?.signal;
+        let count = 0;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (count >= limit) {
+                break;
+            }
+            yield chunk;
+            count++;
+        }
+    }
+    /**
+     * Drop the first n chunks
+     */
+    async *drop(limit, options) {
+        const signal = options?.signal;
+        let count = 0;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (count >= limit) {
+                yield chunk;
+            }
+            count++;
+        }
+    }
+    async reduce(fn, initial, options) {
+        const signal = options?.signal;
+        let accumulator = initial;
+        let first = true;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (first && accumulator === undefined) {
+                accumulator = chunk;
+                first = false;
+            }
+            else {
+                accumulator = await fn(accumulator, chunk, { signal });
+            }
+        }
+        if (accumulator === undefined) {
+            throw new TypeError("Reduce of empty stream with no initial value");
+        }
+        return accumulator;
+    }
+    /**
+     * Check if every chunk passes a predicate
+     */
+    async every(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (!(await fn(chunk, { signal }))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if some chunk passes a predicate
+     */
+    async some(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (await fn(chunk, { signal })) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Find first chunk that passes predicate
+     */
+    async find(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            if (await fn(chunk, { signal })) {
+                return chunk;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Execute function for each chunk (like forEach)
+     */
+    async forEach(fn, options) {
+        const signal = options?.signal;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            await fn(chunk, { signal });
+        }
+    }
+    /**
+     * Collect all chunks into an array
+     */
+    async toArray(options) {
+        const signal = options?.signal;
+        const result = [];
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            result.push(chunk);
+        }
+        return result;
+    }
+    /**
+     * Yield [index, value] pairs
+     */
+    async *asIndexedPairs(options) {
+        const signal = options?.signal;
+        let index = 0;
+        for await (const chunk of this) {
+            if (signal?.aborted) {
+                throw new Error("AbortError");
+            }
+            yield [index++, chunk];
+        }
+    }
+    compose(stream) {
+        if (typeof stream === "function") {
+            // It's an async generator function
+            const output = stream(this);
+            return Readable.from(output);
+        }
+        // It's a Duplex stream
+        this.pipe(stream);
+        return stream;
+    }
+}
+// =============================================================================
+// Writable Stream Wrapper
+// =============================================================================
+/**
+ * A wrapper around Web WritableStream that provides Node.js-like API
+ */
+export class Writable extends EventEmitter {
+    constructor(options) {
+        super();
+        this._writer = null;
+        this._ended = false;
+        this._finished = false;
+        this._destroyed = false;
+        this._errored = null;
+        this._closed = false;
+        this._pendingWrites = 0;
+        this._writableLength = 0;
+        this._corked = 0;
+        this._corkedChunks = [];
+        this._defaultEncoding = "utf8";
+        this._aborted = false;
+        this.objectMode = options?.objectMode ?? false;
+        this.writableHighWaterMark = options?.highWaterMark ?? 16384;
+        this.autoDestroy = options?.autoDestroy ?? true;
+        this.emitClose = options?.emitClose ?? true;
+        this._defaultEncoding = options?.defaultEncoding ?? "utf8";
+        // Store user-provided write function
+        if (options?.write) {
+            this._writeFunc = options.write.bind(this);
+        }
+        // Store user-provided final function
+        if (options?.final) {
+            this._finalFunc = options.final.bind(this);
+        }
+        if (options?.stream) {
+            this._stream = options.stream;
+        }
+        else {
+            // Create bound references to instance properties/methods for use in WritableStream callbacks
+            const getWriteFunc = () => this._writeFunc;
+            const getFinalFunc = () => this._finalFunc;
+            const getDefaultEncoding = () => this._defaultEncoding;
+            const setFinished = (value) => {
+                this._finished = value;
+            };
+            const setAborted = (value) => {
+                this._aborted = value;
+            };
+            const emitEvent = this.emit.bind(this);
+            const getEmitClose = () => this.emitClose;
+            const callWrite = (chunk) => this._write?.(chunk);
+            this._stream = new WritableStream({
+                write: async (chunk) => {
+                    // Use user-provided write function or default behavior
+                    const writeFunc = getWriteFunc();
+                    if (writeFunc) {
+                        await new Promise((resolve, reject) => {
+                            writeFunc(chunk, getDefaultEncoding(), err => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    else {
+                        // Override this in subclasses
+                        callWrite(chunk);
+                    }
+                },
+                close: async () => {
+                    // Call final function if provided
+                    const finalFunc = getFinalFunc();
+                    if (finalFunc) {
+                        await new Promise((resolve, reject) => {
+                            finalFunc(err => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    setFinished(true);
+                    emitEvent("finish");
+                    if (getEmitClose()) {
+                        emitEvent("close");
+                    }
+                },
+                abort: reason => {
+                    setAborted(true);
+                    emitEvent("error", reason);
+                }
+            });
+        }
+    }
+    /**
+     * Set default encoding for string writes
+     */
+    setDefaultEncoding(encoding) {
+        this._defaultEncoding = encoding;
+        return this;
+    }
+    /**
+     * Buffer writes until uncork() is called
+     */
+    cork() {
+        this._corked++;
+    }
+    /**
+     * Flush buffered writes from cork()
+     */
+    uncork() {
+        if (this._corked > 0) {
+            this._corked--;
+        }
+        if (this._corked === 0) {
+            // Flush all corked chunks
+            const chunks = this._corkedChunks;
+            this._corkedChunks = [];
+            for (const { chunk, callback } of chunks) {
+                this._doWrite(chunk, callback);
+            }
+        }
+    }
+    write(chunk, encodingOrCallback, callback) {
+        if (this._destroyed || this._ended) {
+            const err = new Error("Cannot write after stream destroyed/ended");
+            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+            cb?.(err);
+            return false;
+        }
+        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        // If corked, buffer the write
+        if (this._corked > 0) {
+            this._corkedChunks.push({ chunk, callback: cb });
+            const chunkSize = this._getChunkSize(chunk);
+            this._writableLength += chunkSize;
+            return this._writableLength < this.writableHighWaterMark;
+        }
+        return this._doWrite(chunk, cb);
+    }
+    _doWrite(chunk, callback) {
+        // Track pending writes for writableLength
+        const chunkSize = this._getChunkSize(chunk);
+        this._pendingWrites++;
+        this._writableLength += chunkSize;
+        this._getWriter()
+            .write(chunk)
+            .then(() => {
+            this._pendingWrites--;
+            this._writableLength -= chunkSize;
+            this.emit("drain");
+            callback?.(null);
+        })
+            .catch(err => {
+            this._pendingWrites--;
+            this._writableLength -= chunkSize;
+            this.emit("error", err);
+            callback?.(err);
+        });
+        // Return false if we've exceeded high water mark (for backpressure)
+        return this._writableLength < this.writableHighWaterMark;
+    }
+    _getChunkSize(chunk) {
+        if (this.objectMode) {
+            return 1;
+        }
+        if (chunk instanceof Uint8Array) {
+            return chunk.byteLength;
+        }
+        if (typeof chunk === "string") {
+            return chunk.length;
+        }
+        return 0;
+    }
+    end(chunkOrCallback, encodingOrCallback, callback) {
+        if (this._ended) {
+            return this;
+        }
+        this._ended = true;
+        const chunk = typeof chunkOrCallback !== "function" ? chunkOrCallback : undefined;
+        const cb = typeof chunkOrCallback === "function"
+            ? chunkOrCallback
+            : typeof encodingOrCallback === "function"
+                ? encodingOrCallback
+                : callback;
+        const finish = async () => {
+            try {
+                if (chunk !== undefined) {
+                    await this._getWriter().write(chunk);
+                }
+                await this._getWriter().close();
+                this._finished = true;
+                this.emit("finish");
+                if (cb) {
+                    cb();
+                }
+            }
+            catch (err) {
+                this.emit("error", err);
+            }
+        };
+        finish();
+        return this;
+    }
+    /**
+     * Destroy the stream
+     */
+    destroy(error) {
+        if (this._destroyed) {
+            return this;
+        }
+        this._destroyed = true;
+        this._ended = true;
+        if (error) {
+            this._errored = error;
+            this.emit("error", error);
+        }
+        if (this._writer) {
+            this._writer.abort(error).catch(() => { });
+        }
+        this._closed = true;
+        this.emit("close");
+        return this;
+    }
+    /**
+     * Get the underlying Web WritableStream
+     */
+    get webStream() {
+        return this._stream;
+    }
+    get writable() {
+        return !this._destroyed && !this._ended;
+    }
+    get writableEnded() {
+        return this._ended;
+    }
+    get writableFinished() {
+        return this._finished;
+    }
+    get writableLength() {
+        return this._writableLength;
+    }
+    /** Whether the stream has been destroyed */
+    get destroyed() {
+        return this._destroyed;
+    }
+    /** The error that destroyed the stream, or null */
+    get errored() {
+        return this._errored;
+    }
+    /** Whether the stream has been closed */
+    get closed() {
+        return this._closed;
+    }
+    /** Whether the stream needs drain (writableLength exceeds high water mark) */
+    get writableNeedDrain() {
+        return this._writableLength >= this.writableHighWaterMark;
+    }
+    /** How many times cork() has been called without uncork() */
+    get writableCorked() {
+        return this._corked;
+    }
+    /** Whether the stream was aborted */
+    get writableAborted() {
+        return this._aborted;
+    }
+    /** Whether the stream is in object mode */
+    get writableObjectMode() {
+        return this.objectMode;
+    }
+    /** Get default encoding */
+    get defaultEncoding() {
+        return this._defaultEncoding;
+    }
+    /**
+     * Get the internal buffer state (for debugging)
+     * Returns array of objects with length and chunk info
+     */
+    get writableBuffer() {
+        return {
+            length: this._corkedChunks.length,
+            head: this._corkedChunks.length > 0 ? this._corkedChunks[0].chunk : null
+        };
+    }
+    /**
+     * Write multiple chunks at once (batch write).
+     * Override in subclass to implement custom batch write logic.
+     */
+    _writev(chunks, callback) {
+        // Default implementation: write each chunk individually
+        let i = 0;
+        const writeNext = () => {
+            if (i >= chunks.length) {
+                callback(null);
+                return;
+            }
+            const { chunk } = chunks[i++];
+            this._doWrite(chunk, err => {
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                // Continue to next chunk
+                writeNext();
+            });
+        };
+        writeNext();
+    }
+    /**
+     * Batch write multiple chunks
+     */
+    writev(chunks, callback) {
+        if (this._destroyed || this._ended) {
+            const err = new Error("Cannot write after stream destroyed/ended");
+            callback?.(err);
+            return false;
+        }
+        this._writev(chunks, callback ?? (() => { }));
+        // Return backpressure indicator
+        return this._writableLength < this.writableHighWaterMark;
+    }
+    _getWriter() {
+        if (!this._writer) {
+            this._writer = this._stream.getWriter();
+        }
+        return this._writer;
+    }
+    // =========================================================================
+    // Static Methods (Node.js compatibility)
+    // =========================================================================
+    /**
+     * Convert a Web WritableStream to Node.js Writable
+     */
+    static fromWeb(webStream, options) {
+        return new Writable({ ...options, stream: webStream });
+    }
+    /**
+     * Convert a Node.js Writable to Web WritableStream
+     */
+    static toWeb(nodeStream) {
+        return nodeStream.webStream;
+    }
+}
+// =============================================================================
+// Cross-environment stream normalization
+// =============================================================================
+/**
+ * Normalize a user-provided writable into this module's Writable.
+ * Keeps Web/Node branching at the stream-module boundary.
+ */
+export function normalizeWritable(stream) {
+    if (stream instanceof Writable) {
+        return stream;
+    }
+    // Web WritableStream
+    if (stream?.getWriter) {
+        return new Writable({ stream: stream });
+    }
+    // Already a Node-like writable (e.g. StreamBuf)
+    return stream;
+}
+// =============================================================================
+// Transform Stream Wrapper
+// =============================================================================
+/**
+ * A wrapper around Web TransformStream that provides Node.js-like API
+ */
+export class Transform extends EventEmitter {
+    /**
+     * Push data to the readable side (Node.js compatibility)
+     * Can be called from within transform callback
+     */
+    push(chunk) {
+        if (chunk === null) {
+            return false;
+        }
+        if (this._transformController) {
+            // If we're in a transform callback, enqueue directly
+            this._transformController.enqueue(chunk);
+        }
+        else {
+            // Otherwise buffer for later
+            this._pushBuffer.push(chunk);
+        }
+        return true;
+    }
+    constructor(options) {
+        super();
+        this._ended = false;
+        this._destroyed = false;
+        this._errored = false;
+        // Buffer for Node.js style push() calls during transform
+        this._pushBuffer = [];
+        // Controller for enqueueing pushed data (set during transform execution)
+        this._transformController = null;
+        // Buffer for writes that occur after end() but before writable is closed
+        this._pendingEndWrites = [];
+        // Whether end() has been called but writable not yet closed
+        this._endPending = false;
+        // Track if we've already set up data forwarding
+        this._dataForwardingSetup = false;
+        /** @internal - whether we have a data event consumer */
+        this._hasDataConsumer = false;
+        /** @internal - whether we're auto-consuming the readable */
+        this._readableConsuming = false;
+        /** @internal - buffer for auto-consumed data */
+        this._autoConsumedBuffer = [];
+        this._autoConsumedBufferIndex = 0;
+        /** @internal - whether auto-consume has ended */
+        this._autoConsumeEnded = false;
+        /** @internal - promise that resolves when auto-consume finishes */
+        this._autoConsumePromise = null;
+        this.objectMode = options?.objectMode ?? false;
+        const userTransform = options?.transform;
+        const userFlush = options?.flush;
+        // Determine if transform function is Node.js style (has 3 params) or simple style
+        const isNodeStyleTransform = userTransform && userTransform.length >= 3;
+        const isNodeStyleFlush = userFlush && userFlush.length >= 1;
+        // Create bound references for use in TransformStream callbacks
+        const setController = (ctrl) => {
+            this._transformController = ctrl;
+        };
+        const emitEvent = (event, ...args) => {
+            if (event === "error") {
+                // Only emit error once to prevent duplicate events
+                if (this._errored) {
+                    return false;
+                }
+                this._errored = true;
+                // Also destroy the writable to prevent further writes
+                this._writable.destroy(args[0]);
+            }
+            return this.emit(event, ...args);
+        };
+        const getInstance = () => this;
+        // Check if subclass overrides _transform (for Node.js compatibility)
+        // We need to check this at runtime since the subclass constructor runs after super()
+        const hasSubclassTransform = () => {
+            // If userTransform was provided in options, use that
+            if (userTransform) {
+                return false;
+            }
+            // Check if _transform is overridden (not the base class no-op)
+            const proto = Object.getPrototypeOf(this);
+            return proto._transform !== Transform.prototype._transform;
+        };
+        const hasSubclassFlush = () => {
+            if (userFlush) {
+                return false;
+            }
+            const proto = Object.getPrototypeOf(this);
+            return proto._flush !== Transform.prototype._flush;
+        };
+        this._stream = new TransformStream({
+            transform: async (chunk, controller) => {
+                // Skip processing if already errored
+                if (this._errored) {
+                    return;
+                }
+                try {
+                    // Set controller for push() to use
+                    setController(controller);
+                    // Check for subclass _transform override first
+                    if (hasSubclassTransform()) {
+                        // Call subclass _transform method (Node.js style)
+                        await new Promise((resolve, reject) => {
+                            this._transform(chunk, "utf8", (err, data) => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    if (data !== undefined) {
+                                        controller.enqueue(data);
+                                    }
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    else if (userTransform) {
+                        if (isNodeStyleTransform) {
+                            // Node.js style: transform(chunk, encoding, callback)
+                            await new Promise((resolve, reject) => {
+                                userTransform.call(getInstance(), chunk, "utf8", (err, data) => {
+                                    if (err) {
+                                        reject(err);
+                                    }
+                                    else {
+                                        // If data provided via callback, enqueue it
+                                        if (data !== undefined) {
+                                            controller.enqueue(data);
+                                        }
+                                        resolve();
+                                    }
+                                });
+                            });
+                        }
+                        else {
+                            // Simple style: transform(chunk) => result
+                            const result = await userTransform(chunk);
+                            if (result !== undefined) {
+                                controller.enqueue(result);
+                            }
+                        }
+                    }
+                    else {
+                        // Default: pass through
+                        controller.enqueue(chunk);
+                    }
+                }
+                catch (err) {
+                    controller.error(err);
+                    emitEvent("error", err);
+                }
+                finally {
+                    setController(null);
+                }
+            },
+            flush: async (controller) => {
+                try {
+                    setController(controller);
+                    // Check for subclass _flush override first
+                    if (hasSubclassFlush()) {
+                        await new Promise((resolve, reject) => {
+                            this._flush((err, data) => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    if (data !== undefined) {
+                                        controller.enqueue(data);
+                                    }
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    else if (userFlush) {
+                        if (isNodeStyleFlush) {
+                            // Node.js style: flush(callback)
+                            await new Promise((resolve, reject) => {
+                                userFlush.call(getInstance(), (err, data) => {
+                                    if (err) {
+                                        reject(err);
+                                    }
+                                    else {
+                                        if (data !== undefined) {
+                                            controller.enqueue(data);
+                                        }
+                                        resolve();
+                                    }
+                                });
+                            });
+                        }
+                        else {
+                            // Simple style: flush() => result
+                            const result = await userFlush();
+                            if (result !== undefined && result !== null) {
+                                controller.enqueue(result);
+                            }
+                        }
+                    }
+                    // No flush defined - nothing to do
+                }
+                catch (err) {
+                    controller.error(err);
+                    emitEvent("error", err);
+                }
+                finally {
+                    setController(null);
+                }
+            }
+        });
+        this._readable = new Readable({
+            stream: this._stream.readable,
+            objectMode: this.objectMode
+        });
+        this._writable = new Writable({
+            stream: this._stream.writable,
+            objectMode: this.objectMode
+        });
+        // Forward non-data events (data forwarding is lazy to avoid premature flowing)
+        this._readable.on("end", () => this.emit("end"));
+        // Only forward errors if not already errored (to prevent duplicate events)
+        this._readable.on("error", err => {
+            if (!this._errored) {
+                this._errored = true;
+                this.emit("error", err);
+            }
+        });
+        this._writable.on("finish", () => this.emit("finish"));
+        this._writable.on("drain", () => this.emit("drain"));
+        // Only forward errors if not already errored (to prevent duplicate events)
+        this._writable.on("error", err => {
+            if (!this._errored) {
+                this._errored = true;
+                this.emit("error", err);
+            }
+        });
+    }
+    /**
+     * Override on to start flowing when data listener is added
+     */
+    on(event, listener) {
+        // Set up data forwarding when first external data listener is added
+        if (event === "data" && !this._dataForwardingSetup) {
+            this._dataForwardingSetup = true;
+            this._readable.on("data", data => this.emit("data", data));
+        }
+        super.on(event, listener);
+        // When data listener is added, mark as having consumer
+        // and start the readable in flowing mode
+        if (event === "data") {
+            this._hasDataConsumer = true;
+            this._readable.resume();
+        }
+        return this;
+    }
+    write(chunk, encodingOrCallback, callback) {
+        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        if (this._destroyed || this._errored) {
+            const err = new Error(this._errored ? "Cannot write after stream errored" : "Cannot write after stream destroyed");
+            queueMicrotask(() => this.emit("error", err));
+            cb?.(err);
+            return false;
+        }
+        // Ensure readable is being consumed to allow transform to execute
+        // This matches Node.js behavior where transform executes immediately on write
+        // Only auto-consume if no explicit consumer (data listener or pipe)
+        if (!this._readableConsuming && !this._hasDataConsumer) {
+            this._readableConsuming = true;
+            this._startAutoConsume();
+        }
+        // If end() was called but writable not yet closed, buffer the write
+        // This allows writes during data event handlers to be processed
+        if (this._endPending) {
+            this._pendingEndWrites.push({ chunk, callback: cb });
+            return true;
+        }
+        return this._writable.write(chunk, cb);
+    }
+    /** @internal - auto-consume readable to allow transform to execute */
+    _startAutoConsume() {
+        this._autoConsumePromise = (async () => {
+            try {
+                for await (const chunk of this._readable) {
+                    // Buffer the data for later retrieval
+                    this._autoConsumedBuffer.push(chunk);
+                    // Also emit data event for listeners
+                    this.emit("data", chunk);
+                }
+                this._autoConsumeEnded = true;
+                this.emit("end");
+            }
+            catch (err) {
+                this.emit("error", err);
+            }
+        })();
+    }
+    end(chunkOrCallback, encodingOrCallback, callback) {
+        if (this._ended) {
+            return this;
+        }
+        this._ended = true;
+        this._endPending = true;
+        const chunk = typeof chunkOrCallback === "function" ? undefined : chunkOrCallback;
+        const cb = typeof chunkOrCallback === "function"
+            ? chunkOrCallback
+            : typeof encodingOrCallback === "function"
+                ? encodingOrCallback
+                : callback;
+        if (cb) {
+            this.once("finish", cb);
+        }
+        if (chunk !== undefined) {
+            this._writable.write(chunk);
+        }
+        // Use setTimeout(0) instead of queueMicrotask to ensure all transform
+        // processing and data events complete before we close the writable.
+        // Microtasks run before the TransformStream processes data.
+        setTimeout(() => {
+            // Process any writes that occurred during data events
+            for (const { chunk: pendingChunk, callback } of this._pendingEndWrites) {
+                this._writable.write(pendingChunk, callback);
+            }
+            this._pendingEndWrites = [];
+            this._endPending = false;
+            this._writable.end();
+        }, 0);
+        return this;
+    }
+    /**
+     * Read from the transform stream
+     */
+    read(size) {
+        return this._readable.read(size);
+    }
+    /**
+     * Pipe to another stream (writable, transform, or duplex)
+     */
+    pipe(destination) {
+        // Mark as having consumer to prevent auto-consume conflict
+        this._hasDataConsumer = true;
+        return this._readable.pipe(destination);
+    }
+    /**
+     * Unpipe from destination
+     */
+    unpipe(destination) {
+        this._readable.unpipe(destination);
+        return this;
+    }
+    /**
+     * Check if paused
+     */
+    isPaused() {
+        return this._readable.isPaused();
+    }
+    /**
+     * Resume reading from the readable side
+     */
+    resume() {
+        this._readable.resume();
+        return this;
+    }
+    /**
+     * Pause reading from the readable side
+     */
+    pause() {
+        this._readable.pause();
+        return this;
+    }
+    /**
+     * Destroy the stream
+     */
+    destroy(error) {
+        if (this._destroyed) {
+            return;
+        }
+        this._destroyed = true;
+        this._readable.destroy(error);
+        this._writable.destroy(error);
+        queueMicrotask(() => this.emit("close"));
+    }
+    /**
+     * Get the underlying Web TransformStream
+     */
+    get webStream() {
+        return this._stream;
+    }
+    get readable() {
+        return this._readable.readable;
+    }
+    get writable() {
+        return this._writable.writable;
+    }
+    get readableEnded() {
+        return this._readable.readableEnded;
+    }
+    get writableEnded() {
+        return this._writable.writableEnded;
+    }
+    get writableFinished() {
+        return this._writable.writableFinished;
+    }
+    get readableLength() {
+        return this._readable.readableLength;
+    }
+    get writableLength() {
+        return this._writable.writableLength;
+    }
+    get readableHighWaterMark() {
+        return this._readable.readableHighWaterMark;
+    }
+    get writableHighWaterMark() {
+        return this._writable.writableHighWaterMark;
+    }
+    get readableObjectMode() {
+        return this._readable.readableObjectMode ?? this._readable.objectMode;
+    }
+    get readableFlowing() {
+        return this._readable.readableFlowing;
+    }
+    get destroyed() {
+        return this._destroyed;
+    }
+    /**
+     * Async iterator support
+     */
+    async *[Symbol.asyncIterator]() {
+        // If auto-consume is running, wait for it to finish and use its buffer
+        if (this._autoConsumePromise) {
+            await this._autoConsumePromise;
+            // Yield all buffered data
+            while (this._autoConsumedBufferIndex < this._autoConsumedBuffer.length) {
+                yield this._autoConsumedBuffer[this._autoConsumedBufferIndex++];
+            }
+            // Reset when drained to avoid prefix growth
+            this._autoConsumedBuffer.length = 0;
+            this._autoConsumedBufferIndex = 0;
+            return;
+        }
+        // Otherwise delegate to readable's iterator
+        yield* this._readable[Symbol.asyncIterator]();
+    }
+    // =========================================================================
+    // Static Methods (Node.js compatibility)
+    // =========================================================================
+    /**
+     * Convert a Web TransformStream to Node.js Transform
+     */
+    static fromWeb(webStream, options) {
+        const transform = new Transform(options);
+        // Connect the web stream - set the internal _stream property
+        transform._stream = webStream;
+        // Replace internal streams with the ones from the web stream
+        const newReadable = Readable.fromWeb(webStream.readable, { objectMode: options?.objectMode });
+        const newWritable = Writable.fromWeb(webStream.writable, { objectMode: options?.objectMode });
+        // Remove old event listeners before replacing
+        transform._readable.removeAllListeners();
+        transform._writable.removeAllListeners();
+        transform._readable = newReadable;
+        transform._writable = newWritable;
+        // Re-connect event forwarding
+        newReadable.on("data", (data) => transform.emit("data", data));
+        newReadable.on("end", () => transform.emit("end"));
+        newReadable.on("error", (err) => transform.emit("error", err));
+        newWritable.on("finish", () => transform.emit("finish"));
+        newWritable.on("drain", () => transform.emit("drain"));
+        newWritable.on("error", (err) => transform.emit("error", err));
+        return transform;
+    }
+    /**
+     * Convert a Node.js Transform to Web TransformStream
+     */
+    static toWeb(nodeStream) {
+        return nodeStream.webStream;
+    }
+    // =========================================================================
+    // Base Class Methods (for subclass override detection)
+    // =========================================================================
+    /**
+     * Base transform method - can be overridden by subclasses.
+     * Default behavior: pass through chunk unchanged.
+     */
+    _transform(chunk, encoding, callback) {
+        // Default: pass through unchanged
+        callback(null, chunk);
+    }
+    /**
+     * Base flush method - can be overridden by subclasses.
+     * Called when the stream ends to allow final processing.
+     */
+    _flush(callback) {
+        // Default: no-op
+        callback();
+    }
+}
+// =============================================================================
+// Duplex Stream
+// =============================================================================
+/**
+ * A duplex stream that combines readable and writable
+ */
+export class Duplex extends EventEmitter {
+    /**
+     * Create a Duplex stream from various sources
+     */
+    static from(source) {
+        // If it's already a Duplex, return as-is
+        if (source instanceof Duplex) {
+            return source;
+        }
+        const forwardReadableToDuplex = (readable, duplex) => {
+            const sink = new Writable({
+                objectMode: duplex.readableObjectMode,
+                write(chunk, _encoding, callback) {
+                    duplex.push(chunk);
+                    callback();
+                },
+                final(callback) {
+                    duplex.push(null);
+                    callback();
+                }
+            });
+            readable.on("error", err => duplex.emit("error", err));
+            readable.pipe(sink);
+        };
+        // If it has readable and/or writable properties
+        if (typeof source === "object" &&
+            source !== null &&
+            "readable" in source &&
+            "writable" in source) {
+            const duplex = new Duplex();
+            const pair = source;
+            if (pair.readable) {
+                forwardReadableToDuplex(pair.readable, duplex);
+            }
+            if (pair.writable) {
+                return new Duplex({
+                    objectMode: duplex.writableObjectMode,
+                    write(chunk, encoding, callback) {
+                        pair.writable.write(chunk, encoding, callback);
+                    },
+                    final(callback) {
+                        pair.writable.end(callback);
+                    }
+                });
+            }
+            return duplex;
+        }
+        // If it's an iterable
+        if (typeof source === "object" &&
+            source !== null &&
+            (Symbol.asyncIterator in source || Symbol.iterator in source)) {
+            const readable = Readable.from(source);
+            const duplex = new Duplex();
+            forwardReadableToDuplex(readable, duplex);
+            return duplex;
+        }
+        // If it's a Readable
+        if (source instanceof Readable) {
+            const duplex = new Duplex();
+            forwardReadableToDuplex(source, duplex);
+            return duplex;
+        }
+        // If it's a Writable
+        if (source instanceof Writable) {
+            return new Duplex({
+                objectMode: true,
+                write(chunk, encoding, callback) {
+                    source.write(chunk, encoding, callback);
+                },
+                final(callback) {
+                    source.end(callback);
+                }
+            });
+        }
+        throw new Error("Duplex.from: unsupported source type");
+    }
+    /**
+     * Create a Duplex from a Web ReadableWritablePair
+     */
+    static fromWeb(pair, options) {
+        const duplex = new Duplex(options);
+        // Replace internal streams
+        duplex._readable = new Readable({ stream: pair.readable });
+        duplex._writable = new Writable({ stream: pair.writable });
+        return duplex;
+    }
+    /**
+     * Convert a Node.js Duplex to Web ReadableWritablePair
+     */
+    static toWeb(duplex) {
+        return {
+            readable: duplex._readable.webStream,
+            writable: duplex._writable.webStream
+        };
+    }
+    constructor(options) {
+        super();
+        // Track if we've already set up data forwarding
+        this._dataForwardingSetup = false;
+        this.allowHalfOpen = options?.allowHalfOpen ?? true;
+        // Support shorthand objectMode option
+        const objectMode = options?.objectMode ?? false;
+        this.readableObjectMode = options?.readableObjectMode ?? objectMode;
+        this.writableObjectMode = options?.writableObjectMode ?? objectMode;
+        this._readable = new Readable({
+            highWaterMark: options?.readableHighWaterMark,
+            objectMode: this.readableObjectMode,
+            read: options?.read?.bind(this)
+        });
+        this._writable = new Writable({
+            highWaterMark: options?.writableHighWaterMark,
+            objectMode: this.writableObjectMode,
+            write: options?.write?.bind(this),
+            final: options?.final?.bind(this)
+        });
+        // Forward non-data events (data forwarding is lazy to avoid premature flowing)
+        this._readable.on("end", () => {
+            this.emit("end");
+            // If not allowHalfOpen, end the writable side too
+            if (!this.allowHalfOpen) {
+                this._writable.end();
+            }
+        });
+        this._readable.on("error", err => this.emit("error", err));
+        this._writable.on("finish", () => this.emit("finish"));
+        this._writable.on("drain", () => this.emit("drain"));
+        this._writable.on("close", () => {
+            // If not allowHalfOpen, destroy the readable side too
+            if (!this.allowHalfOpen && !this._readable.destroyed) {
+                this._readable.destroy();
+            }
+        });
+    }
+    /**
+     * Override on() to set up data forwarding lazily
+     */
+    on(event, listener) {
+        // Set up data forwarding when first external data listener is added
+        if (event === "data" && !this._dataForwardingSetup) {
+            this._dataForwardingSetup = true;
+            this._readable.on("data", chunk => this.emit("data", chunk));
+        }
+        return super.on(event, listener);
+    }
+    /**
+     * Push data to readable side
+     */
+    push(chunk) {
+        return this._readable.push(chunk);
+    }
+    /**
+     * Put a chunk back at the front of the buffer (readable side)
+     */
+    unshift(chunk) {
+        this._readable.unshift(chunk);
+    }
+    /**
+     * Read from readable side
+     */
+    read(size) {
+        return this._readable.read(size);
+    }
+    write(chunk, encodingOrCallback, callback) {
+        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        return this._writable.write(chunk, cb);
+    }
+    end(chunkOrCallback, encodingOrCallback, callback) {
+        const chunk = typeof chunkOrCallback === "function" ? undefined : chunkOrCallback;
+        const cb = typeof chunkOrCallback === "function"
+            ? chunkOrCallback
+            : typeof encodingOrCallback === "function"
+                ? encodingOrCallback
+                : callback;
+        if (cb) {
+            this.once("finish", cb);
+        }
+        if (chunk !== undefined) {
+            this._writable.write(chunk);
+        }
+        this._writable.end();
+        return this;
+    }
+    /**
+     * Cork the writable side
+     */
+    cork() {
+        this._writable.cork();
+    }
+    /**
+     * Uncork the writable side
+     */
+    uncork() {
+        this._writable.uncork();
+    }
+    /**
+     * Set encoding for readable side
+     */
+    setEncoding(encoding) {
+        this._readable.setEncoding(encoding);
+        return this;
+    }
+    /**
+     * Set default encoding for writable side
+     */
+    setDefaultEncoding(encoding) {
+        this._writable.setDefaultEncoding(encoding);
+        return this;
+    }
+    /**
+     * Pipe readable side to destination
+     */
+    pipe(destination) {
+        if (destination instanceof Transform) {
+            this._readable.pipe(destination._writable);
+            return destination;
+        }
+        this._readable.pipe(destination);
+        return destination;
+    }
+    /**
+     * Unpipe from destination
+     */
+    unpipe(destination) {
+        this._readable.unpipe(destination);
+        return this;
+    }
+    /**
+     * Pause the readable side
+     */
+    pause() {
+        this._readable.pause();
+        return this;
+    }
+    /**
+     * Resume the readable side
+     */
+    resume() {
+        this._readable.resume();
+        return this;
+    }
+    /**
+     * Check if paused
+     */
+    isPaused() {
+        return this._readable.isPaused();
+    }
+    /**
+     * Destroy both sides
+     */
+    destroy(error) {
+        this._readable.destroy(error);
+        this._writable.destroy(error);
+        return this;
+    }
+    get readable() {
+        return this._readable.readable;
+    }
+    get writable() {
+        return this._writable.writable;
+    }
+    get readableEnded() {
+        return this._readable.readableEnded;
+    }
+    get writableEnded() {
+        return this._writable.writableEnded;
+    }
+    get writableFinished() {
+        return this._writable.writableFinished;
+    }
+    get readableLength() {
+        return this._readable.readableLength;
+    }
+    get writableLength() {
+        return this._writable.writableLength;
+    }
+    get readableHighWaterMark() {
+        return this._readable.readableHighWaterMark;
+    }
+    get writableHighWaterMark() {
+        return this._writable.writableHighWaterMark;
+    }
+    get destroyed() {
+        return this._readable.destroyed && this._writable.destroyed;
+    }
+    get writableCorked() {
+        return this._writable.writableCorked;
+    }
+    get writableNeedDrain() {
+        return this._writable.writableNeedDrain;
+    }
+    /**
+     * Async iterator support
+     */
+    [Symbol.asyncIterator]() {
+        return this._readable[Symbol.asyncIterator]();
+    }
+}
+// =============================================================================
+// PassThrough Stream
+// =============================================================================
+/**
+ * A passthrough stream that passes data through unchanged
+ */
+export class PassThrough extends Transform {
+    constructor(options) {
+        super({
+            ...options,
+            transform: chunk => chunk
+        });
+    }
+}
+// =============================================================================
+// Collector Stream
+// =============================================================================
+/**
+ * A writable stream that collects all chunks
+ */
+export class Collector extends Writable {
+    constructor(options) {
+        const collectedChunks = [];
+        super({
+            ...options,
+            stream: new WritableStream({
+                write: chunk => {
+                    collectedChunks.push(chunk);
+                },
+                close: () => {
+                    // Finished
+                }
+            })
+        });
+        this.chunks = [];
+        this.chunks = collectedChunks;
+    }
+    write(chunk, encodingOrCallback, callback) {
+        if (this.writableEnded || this.writableFinished) {
+            const err = new Error("write after end");
+            this.emit("error", err);
+            return false;
+        }
+        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        // Synchronously push to chunks
+        this.chunks.push(chunk);
+        cb?.(null);
+        return true;
+    }
+    /**
+     * Get all collected data as a single Uint8Array (for binary mode)
+     */
+    toUint8Array() {
+        const chunks = this.chunks;
+        const len = chunks.length;
+        if (len === 0) {
+            return new Uint8Array(0);
+        }
+        if (len === 1 && chunks[0] instanceof Uint8Array) {
+            return chunks[0];
+        }
+        // If chunks are Uint8Arrays, concatenate them
+        if (chunks[0] instanceof Uint8Array) {
+            return concatUint8Arrays(chunks);
+        }
+        throw new Error("Collector contains non-binary data");
+    }
+    /**
+     * Get all collected data as a string
+     */
+    toString() {
+        const chunks = this.chunks;
+        const len = chunks.length;
+        if (len === 0) {
+            return "";
+        }
+        const first = chunks[0];
+        if (typeof first === "string") {
+            if (len === 1) {
+                return first;
+            }
+            return chunks.join("");
+        }
+        return textDecoder.decode(this.toUint8Array());
+    }
+    get isFinished() {
+        // Use inherited writable property
+        return this.writableFinished;
+    }
+}
+// =============================================================================
+// PullStream / BufferedStream / DataChunk helpers
+// =============================================================================
+export class PullStream extends StandalonePullStream {
+    // Keep constructor signature aligned with streams.browser.ts public API
+    constructor(options) {
+        super(options);
+    }
+}
+export class StringChunk extends StandaloneStringChunk {
+}
+export class BufferChunk extends StandaloneBufferChunk {
+}
+export class BufferedStream extends StandaloneBufferedStream {
+    constructor(options) {
+        super(options);
+    }
+}
+// =============================================================================
+// Stream Creation Functions
+// =============================================================================
+/**
+ * Create a readable stream with custom read implementation
+ */
+export function createReadable(options) {
+    const readable = new Readable(options);
+    // Override read behavior if provided
+    if (options?.read) {
+        const originalRead = readable.read.bind(readable);
+        readable.read = function (size) {
+            options.read(size ?? 16384);
+            return originalRead(size);
+        };
+    }
+    return readable;
+}
+/**
+ * Create a readable stream from an async iterable
+ */
+export function createReadableFromAsyncIterable(iterable, options) {
+    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
+    (async () => {
+        try {
+            for await (const chunk of iterable) {
+                if (!readable.push(chunk)) {
+                    // Backpressure - wait a bit
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                }
+            }
+            readable.push(null);
+        }
+        catch (err) {
+            readable.destroy(err);
+        }
+    })();
+    return readable;
+}
+/**
+ * Create a readable stream from an array
+ */
+export function createReadableFromArray(data, options) {
+    let index = 0;
+    const readable = new Readable({
+        ...options,
+        objectMode: options?.objectMode ?? true,
+        read() {
+            // Push data when read is called
+            while (index < data.length) {
+                if (!this.push(data[index++])) {
+                    // Backpressure - wait for next read
+                    return;
+                }
+            }
+            // All data pushed, end the stream
+            this.push(null);
+        }
+    });
+    return readable;
+}
+/**
+ * Create a writable stream with custom write implementation
+ */
+export function createWritable(options) {
+    // Create a custom WritableStream with user's handlers
+    const stream = new WritableStream({
+        write: async (chunk) => {
+            if (options?.write) {
+                return new Promise((resolve, reject) => {
+                    options.write(chunk, "utf8", err => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        },
+        close: async () => {
+            if (options?.final) {
+                return new Promise((resolve, reject) => {
+                    options.final(err => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        }
+    });
+    return new Writable({ ...options, stream });
+}
+/**
+ * Create a transform stream from a transform function
+ */
+export function createTransform(transformFn, options) {
+    return new Transform({
+        ...options,
+        transform: transformFn,
+        flush: options?.flush
+    });
+}
+/**
+ * Create a collector stream
+ */
+export function createCollector(options) {
+    return new Collector(options);
+}
+/**
+ * Create a passthrough stream
+ */
+export function createPassThrough(options) {
+    return new PassThrough(options);
+}
+/**
+ * Create a pull stream
+ */
+export function createPullStream(options) {
+    return new PullStream(options);
+}
+/**
+ * Create a buffered stream
+ */
+export function createBufferedStream(options) {
+    return new BufferedStream(options);
+}
+const isReadableStream = (value) => !!value && typeof value === "object" && typeof value.getReader === "function";
+const isAsyncIterable = (value) => {
+    if (!value || (typeof value !== "object" && typeof value !== "function")) {
+        return false;
+    }
+    return typeof value[Symbol.asyncIterator] === "function";
+};
+const isWritableStream = (value) => !!value && typeof value === "object" && typeof value.getWriter === "function";
+const isTransformStream = (value) => !!value &&
+    typeof value === "object" &&
+    !!value.readable &&
+    !!value.writable &&
+    isReadableStream(value.readable) &&
+    isWritableStream(value.writable);
+const isPipelineOptions = (value) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    // IMPORTANT:
+    // Do NOT use `"end" in obj` here because streams have `.end()` and would be
+    // misclassified as options, breaking argument parsing and potentially hanging.
+    if (typeof value.pipe === "function" ||
+        typeof value.write === "function" ||
+        typeof value.end === "function" ||
+        typeof value.getReader === "function" ||
+        typeof value.getWriter === "function") {
+        return false;
+    }
+    return (Object.prototype.hasOwnProperty.call(value, "signal") ||
+        Object.prototype.hasOwnProperty.call(value, "end"));
+};
+const toBrowserPipelineStream = (stream) => {
+    if (stream instanceof Readable ||
+        stream instanceof Writable ||
+        stream instanceof Transform ||
+        stream instanceof Duplex) {
+        return stream;
+    }
+    if (isTransformStream(stream)) {
+        return Transform.fromWeb(stream);
+    }
+    if (isReadableStream(stream)) {
+        return Readable.fromWeb(stream);
+    }
+    if (isWritableStream(stream)) {
+        return Writable.fromWeb(stream);
+    }
+    return stream;
+};
+/**
+ * Pipeline streams together with proper error handling and cleanup.
+ * Supports both callback and promise-based usage like Node.js.
+ *
+ * @example
+ * // Promise usage
+ * await pipeline(source, transform, destination);
+ *
+ * @example
+ * // With options
+ * await pipeline(source, transform, destination, { signal: controller.signal });
+ *
+ * @example
+ * // Callback usage
+ * pipeline(source, transform, destination, (err) => {
+ *   if (err) console.error('Pipeline failed', err);
+ * });
+ */
+export function pipeline(...args) {
+    // Parse arguments
+    let streams;
+    let options = {};
+    let callback;
+    const lastArg = args[args.length - 1];
+    if (typeof lastArg === "function") {
+        // Callback style: pipeline(s1, s2, s3, callback)
+        callback = lastArg;
+        streams = args.slice(0, -1);
+    }
+    else if (isPipelineOptions(lastArg)) {
+        // Options style: pipeline(s1, s2, s3, { signal })
+        options = lastArg;
+        streams = args.slice(0, -1);
+    }
+    else {
+        // No callback or options: pipeline(s1, s2, s3)
+        streams = args;
+    }
+    const promise = new Promise((resolve, reject) => {
+        if (streams.length < 2) {
+            const err = new Error("Pipeline requires at least 2 streams");
+            reject(err);
+            return;
+        }
+        const normalized = streams.map(toBrowserPipelineStream);
+        const source = normalized[0];
+        const destination = normalized[normalized.length - 1];
+        const transforms = normalized.slice(1, -1);
+        let completed = false;
+        const allStreams = [source, ...transforms, destination];
+        const cleanup = (error) => {
+            if (completed) {
+                return;
+            }
+            completed = true;
+            // Destroy all streams on error
+            if (error) {
+                for (const stream of allStreams) {
+                    if (typeof stream.destroy === "function") {
+                        stream.destroy(error);
+                    }
+                }
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        // Handle abort signal
+        if (options.signal) {
+            if (options.signal.aborted) {
+                cleanup(new Error("Pipeline aborted"));
+                return;
+            }
+            options.signal.addEventListener("abort", () => {
+                cleanup(new Error("Pipeline aborted"));
+            });
+        }
+        // Chain the streams
+        let current = source;
+        for (const transform of transforms) {
+            current.pipe(transform);
+            current = transform;
+        }
+        // Pipe to destination
+        if (options.end !== false) {
+            current.pipe(destination);
+        }
+        else {
+            // Don't end destination
+            current.on("data", chunk => destination.write(chunk));
+        }
+        // Handle completion
+        destination.on("finish", () => cleanup());
+        // Handle errors on all streams
+        for (const stream of allStreams) {
+            stream.on("error", (err) => cleanup(err));
+        }
+    });
+    // If callback provided, use it
+    if (callback) {
+        promise.then(() => callback(null)).catch(err => callback(err));
+    }
+    return promise;
+}
+/**
+ * Wait for a stream to finish, close, or error.
+ * Node.js compatible with support for options and callbacks.
+ *
+ * @example
+ * // Promise usage
+ * await finished(stream);
+ *
+ * @example
+ * // With options
+ * await finished(stream, { readable: false }); // Only wait for writable side
+ *
+ * @example
+ * // Callback usage
+ * finished(stream, (err) => {
+ *   if (err) console.error('Stream error', err);
+ * });
+ */
+export function finished(stream, optionsOrCallback, callback) {
+    let options = {};
+    let cb;
+    if (typeof optionsOrCallback === "function") {
+        cb = optionsOrCallback;
+    }
+    else if (optionsOrCallback) {
+        options = optionsOrCallback;
+        cb = callback;
+    }
+    const promise = new Promise((resolve, reject) => {
+        const normalizedStream = toBrowserPipelineStream(stream);
+        let resolved = false;
+        const done = (err) => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            if (err && !options.error) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        };
+        // Handle abort signal
+        if (options.signal) {
+            if (options.signal.aborted) {
+                done(new Error("Aborted"));
+                return;
+            }
+            options.signal.addEventListener("abort", () => {
+                done(new Error("Aborted"));
+            });
+        }
+        const checkReadable = options.readable !== false;
+        const checkWritable = options.writable !== false;
+        // Already finished?
+        if (checkReadable && normalizedStream.readableEnded) {
+            done();
+            return;
+        }
+        if (checkWritable && normalizedStream.writableFinished) {
+            done();
+            return;
+        }
+        // Listen for events
+        if (checkWritable) {
+            normalizedStream.on("finish", () => done());
+        }
+        if (checkReadable) {
+            normalizedStream.on("end", () => done());
+        }
+        normalizedStream.on("error", (err) => done(err));
+        normalizedStream.on("close", () => done());
+    });
+    // If callback provided, use it
+    if (cb) {
+        promise.then(() => cb(null)).catch(err => cb(err));
+    }
+    return promise;
+}
+// =============================================================================
+// Utility Functions
+// =============================================================================
+/**
+ * Convert a stream to a promise that resolves when finished
+ */
+export async function streamToPromise(stream) {
+    return finished(stream);
+}
+/**
+ * Collect all data from a readable stream into a Uint8Array
+ * (Browser equivalent of Node.js streamToBuffer)
+ */
+export async function streamToUint8Array(stream) {
+    let iterable;
+    if (isReadableStream(stream)) {
+        iterable = Readable.fromWeb(stream);
+    }
+    else if (isAsyncIterable(stream)) {
+        iterable = stream;
+    }
+    else {
+        throw new Error("streamToUint8Array: unsupported stream type");
+    }
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of iterable) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    // Fast paths
+    const len = chunks.length;
+    if (len === 0) {
+        return new Uint8Array(0);
+    }
+    if (len === 1) {
+        return chunks[0];
+    }
+    // Use precalculated total length
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0; i < len; i++) {
+        result.set(chunks[i], offset);
+        offset += chunks[i].length;
+    }
+    return result;
+}
+/**
+ * Alias for streamToUint8Array (Node.js compatibility)
+ */
+export const streamToBuffer = streamToUint8Array;
+/**
+ * Collect all data from a readable stream into a string
+ */
+export async function streamToString(stream, encoding) {
+    const buffer = await streamToUint8Array(stream);
+    return getTextDecoder(encoding).decode(buffer);
+}
+/**
+ * Drain a stream (consume all data without processing)
+ */
+export async function drainStream(stream) {
+    let iterable;
+    if (isReadableStream(stream)) {
+        iterable = Readable.fromWeb(stream);
+    }
+    else if (isAsyncIterable(stream)) {
+        iterable = stream;
+    }
+    else {
+        throw new Error("drainStream: unsupported stream type");
+    }
+    for await (const _chunk of iterable) {
+        // Consume data
+    }
+}
+/**
+ * Copy from a readable stream to a writable stream
+ */
+export async function copyStream(source, destination) {
+    return pipeline(source, destination);
+}
+// =============================================================================
+// Type Guards
+// =============================================================================
+/**
+ * Check if an object is a transform stream
+ */
+export function isTransform(obj) {
+    if (obj == null) {
+        return false;
+    }
+    if (obj instanceof Transform) {
+        return true;
+    }
+    const o = obj;
+    return (typeof o.read === "function" &&
+        typeof o.pipe === "function" &&
+        typeof o.write === "function" &&
+        typeof o.end === "function" &&
+        typeof o._transform === "function");
+}
+/**
+ * Check if an object is a duplex stream
+ * Note: In Node.js, Transform extends Duplex, so Transform is also a Duplex
+ */
+export function isDuplex(obj) {
+    if (obj == null) {
+        return false;
+    }
+    if (obj instanceof Duplex || obj instanceof Transform) {
+        return true;
+    }
+    const o = obj;
+    return (typeof o.read === "function" &&
+        typeof o.pipe === "function" &&
+        typeof o.write === "function" &&
+        typeof o.end === "function");
+}
+/**
+ * Check if an object is any kind of stream
+ */
+export function isStream(obj) {
+    if (obj == null) {
+        return false;
+    }
+    if (obj instanceof Readable || obj instanceof Writable) {
+        return true;
+    }
+    const o = obj;
+    return ((typeof o.read === "function" && typeof o.pipe === "function") ||
+        (typeof o.write === "function" && typeof o.end === "function"));
+}
+// =============================================================================
+// Additional Utility Functions (Node.js Compatibility)
+// =============================================================================
+/**
+ * Add abort signal handling to any stream
+ */
+export function addAbortSignal(signal, stream) {
+    if (signal.aborted) {
+        stream.destroy(new Error("Aborted"));
+        return stream;
+    }
+    const onAbort = () => {
+        stream.destroy(new Error("Aborted"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    // Clean up when stream is destroyed
+    stream.on("close", () => {
+        signal.removeEventListener("abort", onAbort);
+    });
+    return stream;
+}
+/**
+ * Create a duplex stream from a pair of readable and writable streams
+ */
+export function createDuplex(options) {
+    const readableObjectMode = options?.readableObjectMode ?? options?.objectMode;
+    const writableObjectMode = options?.writableObjectMode ?? options?.objectMode;
+    const duplex = new Duplex({
+        allowHalfOpen: options?.allowHalfOpen,
+        readableHighWaterMark: options?.readableHighWaterMark,
+        writableHighWaterMark: options?.writableHighWaterMark,
+        readableObjectMode,
+        writableObjectMode
+    });
+    // If custom readable/writable provided, pipe them
+    if (options?.readable) {
+        const readable = options.readable;
+        readable.on?.("data", (chunk) => duplex.push(chunk));
+        readable.on?.("end", () => duplex.push(null));
+        readable.on?.("error", (err) => duplex.destroy(err));
+    }
+    if (options?.writable) {
+        const writable = options.writable;
+        duplex.on("data", (chunk) => writable.write?.(chunk));
+        duplex.on("finish", () => writable.end?.());
+    }
+    // If custom read/write/final provided, override methods
+    if (options?.write) {
+        const _originalWrite = duplex.write.bind(duplex); // Keep bound reference for potential future use
+        duplex.write = function (chunk, encodingOrCallback, callback) {
+            const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : "utf8";
+            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : (callback ?? (() => { }));
+            options.write.call(duplex, chunk, encoding, cb);
+            return true;
+        };
+    }
+    if (options?.final) {
+        const originalEnd = duplex.end.bind(duplex);
+        duplex.end = function (chunkOrCallback, encodingOrCallback, callback) {
+            const cb = typeof chunkOrCallback === "function"
+                ? chunkOrCallback
+                : typeof encodingOrCallback === "function"
+                    ? encodingOrCallback
+                    : (callback ?? (() => { }));
+            if (chunkOrCallback !== undefined && typeof chunkOrCallback !== "function") {
+                duplex.write(chunkOrCallback);
+            }
+            // Call custom final handler
+            options.final.call(duplex, (err) => {
+                if (err) {
+                    duplex.emit("error", err);
+                }
+                else {
+                    duplex.emit("finish");
+                }
+                // Call original end to properly close writable side
+                originalEnd();
+                cb();
+            });
+            return duplex;
+        };
+    }
+    if (options?.destroy) {
+        const originalDestroy = duplex.destroy.bind(duplex);
+        duplex.destroy = function (error) {
+            options.destroy.call(duplex, error ?? null, (err) => {
+                if (err) {
+                    duplex.emit("error", err);
+                    originalDestroy(err);
+                }
+                else {
+                    originalDestroy(error);
+                }
+            });
+            return duplex;
+        };
+    }
+    return duplex;
+}
+/**
+ * Create a readable stream from a generator function
+ */
+export function createReadableFromGenerator(generator, options) {
+    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
+    (async () => {
+        try {
+            for await (const chunk of generator()) {
+                if (!readable.push(chunk)) {
+                    // Backpressure
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                }
+            }
+            readable.push(null);
+        }
+        catch (err) {
+            readable.destroy(err);
+        }
+    })();
+    return readable;
+}
+/**
+ * Create a readable stream from a Promise
+ */
+export function createReadableFromPromise(promise, options) {
+    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
+    promise
+        .then(value => {
+        readable.push(value);
+        readable.push(null);
+    })
+        .catch(err => {
+        readable.destroy(err);
+    });
+    return readable;
+}
+/**
+ * Compose multiple transform streams into one
+ * Data flows through each transform in sequence
+ */
+export function compose(...transforms) {
+    const len = transforms.length;
+    if (len === 0) {
+        return new Transform({
+            objectMode: true,
+            transform: chunk => chunk
+        });
+    }
+    const isNativeTransform = (stream) => stream instanceof Transform;
+    if (len === 1 && isNativeTransform(transforms[0])) {
+        return transforms[0];
+    }
+    // Chain the transforms: first → second → ... → last
+    const first = transforms[0];
+    const last = transforms[len - 1];
+    // Pipe all transforms together
+    for (let i = 0; i < len - 1; i++) {
+        transforms[i].pipe(transforms[i + 1]);
+    }
+    class ComposedTransform extends Transform {
+        constructor() {
+            super(...arguments);
+            this._dataForwarding = false;
+            this._endForwarding = false;
+        }
+        on(event, listener) {
+            if (event === "data" && !this._dataForwarding) {
+                this._dataForwarding = true;
+                last.on("data", (chunk) => this.emit("data", chunk));
+            }
+            if (event === "end" && !this._endForwarding) {
+                this._endForwarding = true;
+                last.on("end", () => this.emit("end"));
+            }
+            return super.on(event, listener);
+        }
+        write(chunk, encodingOrCallback, callback) {
+            if (typeof encodingOrCallback === "function") {
+                return first.write(chunk, encodingOrCallback);
+            }
+            return first.write(chunk, encodingOrCallback, callback);
+        }
+        end(chunkOrCallback, encodingOrCallback, callback) {
+            if (typeof chunkOrCallback === "function") {
+                first.end(chunkOrCallback);
+                return this;
+            }
+            if (typeof encodingOrCallback === "function") {
+                first.end(chunkOrCallback, encodingOrCallback);
+                return this;
+            }
+            first.end(chunkOrCallback, encodingOrCallback, callback);
+            return this;
+        }
+        pipe(destination) {
+            return last.pipe(destination);
+        }
+        destroy(error) {
+            for (const t of transforms) {
+                t.destroy(error);
+            }
+            super.destroy(error);
+        }
+        read(size) {
+            return typeof last.read === "function" ? last.read(size) : null;
+        }
+        async *[Symbol.asyncIterator]() {
+            const it = last?.[Symbol.asyncIterator]?.();
+            if (it) {
+                for await (const chunk of it) {
+                    yield chunk;
+                }
+                return;
+            }
+            yield* super[Symbol.asyncIterator]();
+        }
+    }
+    const composed = new ComposedTransform({
+        objectMode: first?.objectMode ?? true,
+        transform: chunk => chunk
+    });
+    // Forward errors from any transform
+    for (const t of transforms) {
+        t.on("error", (err) => {
+            composed.emit("error", err);
+        });
+    }
+    // Reflect underlying readability/writability like the previous duck-typed wrapper
+    Object.defineProperty(composed, "readable", {
+        get: () => last.readable
+    });
+    Object.defineProperty(composed, "writable", {
+        get: () => first.writable
+    });
+    return composed;
+}
+/**
+ * Wait for multiple streams to finish
+ */
+export async function finishedAll(streams) {
+    const len = streams.length;
+    if (len === 0) {
+        return;
+    }
+    if (len === 1) {
+        await finished(streams[0]);
+        return;
+    }
+    // Pre-allocate promise array
+    const promises = new Array(len);
+    for (let i = 0; i < len; i++) {
+        promises[i] = finished(streams[i]);
+    }
+    await Promise.all(promises);
+}
+// Reusable empty push callback for createEmptyReadable
+const pushNull = (readable) => {
+    readable.push(null);
+};
+/**
+ * Create a readable stream that emits nothing and immediately ends
+ */
+export function createEmptyReadable(options) {
+    const readable = new Readable(options);
+    queueMicrotask(() => pushNull(readable));
+    return readable;
+}
+// Reusable null write handler
+const nullWriteHandler = {
+    write: () => {
+        // Discard
+    }
+};
+/**
+ * Create a writable stream that discards all data (like /dev/null)
+ */
+export function createNullWritable(options) {
+    return new Writable({
+        ...options,
+        stream: new WritableStream(nullWriteHandler)
+    });
+}
+/**
+ * Promisified version of once for events
+ */
+export function once(emitter, event, options) {
+    return new Promise((resolve, reject) => {
+        let onAbort;
+        let resolved = false;
+        const cleanup = () => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            emitter.off(event, onEvent);
+            emitter.off("error", onError);
+            if (onAbort && options?.signal) {
+                options.signal.removeEventListener("abort", onAbort);
+            }
+        };
+        const onEvent = (...args) => {
+            cleanup();
+            resolve(args);
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        emitter.once(event, onEvent);
+        emitter.once("error", onError);
+        if (options?.signal) {
+            if (options.signal.aborted) {
+                cleanup();
+                reject(new Error("Aborted"));
+                return;
+            }
+            onAbort = () => {
+                cleanup();
+                reject(new Error("Aborted"));
+            };
+            options.signal.addEventListener("abort", onAbort);
+        }
+    });
+}
+/**
+ * Convert a callback-based stream operation to a promise
+ */
+export function promisify(fn) {
+    return new Promise((resolve, reject) => {
+        fn((error, result) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(result);
+            }
+        });
+    });
+}
+// =============================================================================
+// Default High Water Mark Management
+// =============================================================================
+let _defaultHighWaterMark = 16384; // 16KB default
+let _defaultHighWaterMarkObjectMode = 16; // 16 objects default
+/**
+ * Get the default high water mark for streams
+ */
+export function getDefaultHighWaterMark(objectMode) {
+    return objectMode ? _defaultHighWaterMarkObjectMode : _defaultHighWaterMark;
+}
+/**
+ * Set the default high water mark for streams
+ */
+export function setDefaultHighWaterMark(objectMode, value) {
+    if (objectMode) {
+        _defaultHighWaterMarkObjectMode = value;
+    }
+    else {
+        _defaultHighWaterMark = value;
+    }
+}
+// =============================================================================
+// Stream State Inspection Functions
+// =============================================================================
+/**
+ * Check if a stream has been destroyed
+ */
+export function isDestroyed(stream) {
+    return !!stream?.destroyed;
+}
+/**
+ * Check if a readable stream has been disturbed (read from)
+ */
+export function isDisturbed(stream) {
+    if (stream instanceof Readable) {
+        return Readable.isDisturbed(stream);
+    }
+    if (stream instanceof Duplex) {
+        return Readable.isDisturbed(stream._readable);
+    }
+    const s = stream;
+    return (s?.readableDidRead === true ||
+        s?._didRead === true ||
+        s?._ended === true ||
+        s?._destroyed === true);
+}
+/**
+ * Check if a stream has an error
+ */
+export function isErrored(stream) {
+    const err = stream?.errored;
+    return err !== null && err !== undefined;
+}
+/**
+ * Check if a stream is readable
+ */
+export function isReadable(stream) {
+    if (stream == null) {
+        return false;
+    }
+    if (stream instanceof Readable || stream instanceof Transform) {
+        return true;
+    }
+    if (stream instanceof Duplex) {
+        return stream._readable instanceof Readable;
+    }
+    const o = stream;
+    return typeof o.read === "function" && typeof o.pipe === "function";
+}
+/**
+ * Check if a stream is writable
+ */
+export function isWritable(stream) {
+    if (stream == null) {
+        return false;
+    }
+    if (stream instanceof Writable || stream instanceof Transform) {
+        return true;
+    }
+    if (stream instanceof Duplex) {
+        return stream._writable instanceof Writable;
+    }
+    const o = stream;
+    return typeof o.write === "function" && typeof o.end === "function";
+}
+// =============================================================================
+// Duplex Pair
+// =============================================================================
+/**
+ * Create a pair of connected Duplex streams
+ * Data written to one stream can be read from the other
+ */
+export function duplexPair(options) {
+    const stream1 = new Duplex(options);
+    const stream2 = new Duplex(options);
+    // Override write to push to the other stream's readable
+    stream1.write = function (chunk) {
+        // Push to stream2's readable side
+        stream2.push(chunk);
+        return true;
+    };
+    stream2.write = function (chunk) {
+        // Push to stream1's readable side
+        stream1.push(chunk);
+        return true;
+    };
+    // Override end to signal EOF to the other stream
+    const originalEnd1 = stream1.end.bind(stream1);
+    const originalEnd2 = stream2.end.bind(stream2);
+    stream1.end = function (chunk) {
+        if (chunk !== undefined && typeof chunk !== "function") {
+            stream2.push(chunk);
+        }
+        stream2.push(null);
+        return originalEnd1(typeof chunk === "function" ? chunk : undefined);
+    };
+    stream2.end = function (chunk) {
+        if (chunk !== undefined && typeof chunk !== "function") {
+            stream1.push(chunk);
+        }
+        stream1.push(null);
+        return originalEnd2(typeof chunk === "function" ? chunk : undefined);
+    };
+    return [stream1, stream2];
+}
+// =============================================================================
+// Stream Consumers (like stream.consumers in Node.js)
+// =============================================================================
+// Helper function to collect stream chunks with total length tracking
+async function collectStreamChunks(stream) {
+    const chunks = [];
+    let totalLength = 0;
+    let iterable;
+    if (isReadableStream(stream)) {
+        iterable = Readable.fromWeb(stream);
+    }
+    else if (isAsyncIterable(stream)) {
+        iterable = stream;
+    }
+    else {
+        throw new Error("collectStreamChunks: unsupported stream type");
+    }
+    for await (const chunk of iterable) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    return { chunks, totalLength };
+}
+// Helper to concatenate with known length (faster)
+function concatWithLength(chunks, totalLength) {
+    const len = chunks.length;
+    if (len === 0) {
+        return new Uint8Array(0);
+    }
+    if (len === 1) {
+        return chunks[0];
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0; i < len; i++) {
+        result.set(chunks[i], offset);
+        offset += chunks[i].length;
+    }
+    return result;
+}
+export const consumers = {
+    /**
+     * Consume entire stream as ArrayBuffer
+     */
+    async arrayBuffer(stream) {
+        const { chunks, totalLength } = await collectStreamChunks(stream);
+        const combined = concatWithLength(chunks, totalLength);
+        return combined.buffer.slice(combined.byteOffset, combined.byteOffset + combined.byteLength);
+    },
+    /**
+     * Consume entire stream as Blob
+     */
+    async blob(stream, options) {
+        const { chunks } = await collectStreamChunks(stream);
+        return new Blob(chunks, options);
+    },
+    /**
+     * Consume entire stream as Buffer (Uint8Array in browser)
+     */
+    async buffer(stream) {
+        const { chunks, totalLength } = await collectStreamChunks(stream);
+        return concatWithLength(chunks, totalLength);
+    },
+    /**
+     * Consume entire stream as JSON
+     */
+    async json(stream) {
+        const text = await consumers.text(stream);
+        return JSON.parse(text);
+    },
+    /**
+     * Consume entire stream as text
+     */
+    async text(stream, encoding) {
+        const { chunks, totalLength } = await collectStreamChunks(stream);
+        const combined = concatWithLength(chunks, totalLength);
+        const decoder = encoding ? getTextDecoder(encoding) : textDecoder;
+        return decoder.decode(combined);
+    }
+};
+// =============================================================================
+// Promises API (like stream/promises in Node.js)
+// =============================================================================
+export const promises = {
+    pipeline,
+    finished
+};