@cj-tech-master/excelts 4.2.1 → 4.2.2-canary.20260115044841.88820eb

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

@@ -11,9 +11,44 @@
  * - 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 { PullStream } from "./pull-stream.js";
+import { BufferedStream, BufferChunk, StringChunk } from "./buffered-stream.js";
 import { concatUint8Arrays, getTextDecoder, textDecoder } from "./shared.js";
+import { isAsyncIterable, isReadableStream, isTransformStream, isWritableStream } from "./internal/type-guards.js";
+const removeEmitterListener = (emitter, event, listener) => {
+    if (typeof emitter.off === "function") {
+        emitter.off(event, listener);
+    }
+    else if (typeof emitter.removeListener === "function") {
+        emitter.removeListener(event, listener);
+    }
+};
+const addEmitterListener = (emitter, event, listener, options) => {
+    if (options?.once && typeof emitter.once === "function") {
+        emitter.once(event, listener);
+    }
+    else {
+        emitter.on(event, listener);
+    }
+    return () => removeEmitterListener(emitter, event, listener);
+};
+const createListenerRegistry = () => {
+    const listeners = [];
+    return {
+        add: (emitter, event, listener) => {
+            listeners.push(addEmitterListener(emitter, event, listener));
+        },
+        once: (emitter, event, listener) => {
+            listeners.push(addEmitterListener(emitter, event, listener, { once: true }));
+        },
+        cleanup: () => {
+            for (let i = listeners.length - 1; i >= 0; i--) {
+                listeners[i]();
+            }
+            listeners.length = 0;
+        }
+    };
+};
 // =============================================================================
 // Readable Stream Wrapper
 // =============================================================================
@@ -30,6 +65,7 @@ export class Readable extends EventEmitter {
         this._bufferSize = 0;
         this._reading = false;
         this._ended = false;
+        this._endEmitted = false;
         this._destroyed = false;
         this._errored = null;
         this._closed = false;
@@ -86,20 +122,7 @@ export class Readable extends EventEmitter {
      */
     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);
-            }
-        })();
+        pumpAsyncIterableToReadable(readable, toAsyncIterable(iterable));
         return readable;
     }
     /**
@@ -144,16 +167,30 @@ export class Readable extends EventEmitter {
                     // Controller may already be closed
                 }
             }
-            this.emit("end");
+            // Emit 'end' only after buffered data is fully drained.
+            // This avoids premature 'end' when producers push null while paused.
+            if (this._bufferedLength() === 0) {
+                this._emitEndOnce();
+            }
             // Note: Don't call destroy() here, let the stream be consumed naturally
             // The reader will return done:true when it finishes reading
             return false;
         }
+        // Keep the internal Web ReadableStream in sync for controllable streams.
+        // For external Web streams (_webStreamMode=true), push() is not the data source.
+        if (controller && !this._webStreamMode) {
+            try {
+                controller.enqueue(chunk);
+            }
+            catch {
+                // Controller may be closed/errored; Node-side buffering/events still work.
+            }
+        }
         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);
+            this.emit("data", this._applyEncoding(chunk));
             // Check if stream was paused during emit (backpressure from consumer)
             if (!this._flowing) {
                 return false;
@@ -178,10 +215,8 @@ export class Readable extends EventEmitter {
             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.
+            // NOTE: We still buffer for Node-style read()/data semantics.
+            // The internal Web ReadableStream is also fed via controller.enqueue() above.
             // Emit readable event when buffer goes from empty to having data
             if (wasEmpty) {
                 queueMicrotask(() => this.emit("readable"));
@@ -195,6 +230,13 @@ export class Readable extends EventEmitter {
             return this._bufferSize < this.readableHighWaterMark;
         }
     }
+    _emitEndOnce() {
+        if (this._endEmitted) {
+            return;
+        }
+        this._endEmitted = true;
+        this.emit("end");
+    }
     /**
      * 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
@@ -219,14 +261,22 @@ export class Readable extends EventEmitter {
                 if (!this.objectMode) {
                     this._bufferSize -= this._getChunkSize(chunk);
                 }
-                return this._applyEncoding(chunk);
+                const decoded = this._applyEncoding(chunk);
+                if (this._ended && this._bufferedLength() === 0) {
+                    queueMicrotask(() => this._emitEndOnce());
+                }
+                return decoded;
             }
             // For binary mode, handle size
             const chunk = this._bufferShift();
             if (!this.objectMode) {
                 this._bufferSize -= this._getChunkSize(chunk);
             }
-            return this._applyEncoding(chunk);
+            const decoded = this._applyEncoding(chunk);
+            if (this._ended && this._bufferedLength() === 0) {
+                queueMicrotask(() => this._emitEndOnce());
+            }
+            return decoded;
         }
         return null;
     }
@@ -332,11 +382,11 @@ export class Readable extends EventEmitter {
             if (!this.objectMode) {
                 this._bufferSize -= this._getChunkSize(chunk);
             }
-            this.emit("data", chunk);
+            this.emit("data", this._applyEncoding(chunk));
         }
         // If already ended, emit end event
         if (this._ended && this._bufferedLength() === 0) {
-            this.emit("end");
+            this._emitEndOnce();
         }
         else if (this._read) {
             // Call user-provided read function asynchronously
@@ -399,26 +449,36 @@ export class Readable extends EventEmitter {
         }
         this._pipeTo.push(dest);
         // Create listeners that we can later remove
+        let drainListener;
+        const removeDrainListener = () => {
+            if (!drainListener) {
+                return;
+            }
+            if (typeof eventTarget.off === "function") {
+                eventTarget.off("drain", drainListener);
+            }
+            else if (typeof eventTarget.removeListener === "function") {
+                eventTarget.removeListener("drain", drainListener);
+            }
+            drainListener = undefined;
+        };
         const dataListener = (chunk) => {
             // Call destination's write() method (not internal _writable.write())
             // This ensures Transform.write() logic runs properly
             const canWrite = dest.write(chunk);
             if (!canWrite) {
                 this.pause();
-                if (typeof eventTarget.once === "function") {
-                    eventTarget.once("drain", () => this.resume());
-                }
-                else {
-                    const resumeOnce = () => {
-                        if (typeof eventTarget.off === "function") {
-                            eventTarget.off("drain", resumeOnce);
-                        }
-                        else if (typeof eventTarget.removeListener === "function") {
-                            eventTarget.removeListener("drain", resumeOnce);
-                        }
+                // Install a removable, once-style drain listener.
+                if (!drainListener) {
+                    drainListener = () => {
+                        removeDrainListener();
                         this.resume();
                     };
-                    eventTarget.on("drain", resumeOnce);
+                    eventTarget.on("drain", drainListener);
+                    const entry = this._pipeListeners.get(dest);
+                    if (entry) {
+                        entry.drain = drainListener;
+                    }
                 }
             }
         };
@@ -438,7 +498,8 @@ export class Readable extends EventEmitter {
         this._pipeListeners.set(dest, {
             data: dataListener,
             end: endListener,
-            error: errorListener
+            error: errorListener,
+            eventTarget
         });
         this.on("data", dataListener);
         this.once("end", endListener);
@@ -461,6 +522,14 @@ export class Readable extends EventEmitter {
                 this.off("data", listeners.data);
                 this.off("end", listeners.end);
                 this.off("error", listeners.error);
+                if (listeners.drain) {
+                    if (typeof listeners.eventTarget?.off === "function") {
+                        listeners.eventTarget.off("drain", listeners.drain);
+                    }
+                    else if (typeof listeners.eventTarget?.removeListener === "function") {
+                        listeners.eventTarget.removeListener("drain", listeners.drain);
+                    }
+                }
                 this._pipeListeners.delete(destination);
             }
         }
@@ -472,6 +541,14 @@ export class Readable extends EventEmitter {
                     this.off("data", listeners.data);
                     this.off("end", listeners.end);
                     this.off("error", listeners.error);
+                    if (listeners.drain) {
+                        if (typeof listeners.eventTarget?.off === "function") {
+                            listeners.eventTarget.off("drain", listeners.drain);
+                        }
+                        else if (typeof listeners.eventTarget?.removeListener === "function") {
+                            listeners.eventTarget.removeListener("drain", listeners.drain);
+                        }
+                    }
                     this._pipeListeners.delete(target);
                 }
             }
@@ -490,12 +567,26 @@ export class Readable extends EventEmitter {
         }
         this._destroyed = true;
         this._ended = true;
+        // Ensure we detach from destinations to avoid leaking listeners.
+        this.unpipe();
         if (error) {
             this._errored = error;
             this.emit("error", error);
         }
         if (this._reader) {
-            this._reader.cancel().catch(() => { });
+            const reader = this._reader;
+            this._reader = null;
+            reader
+                .cancel()
+                .catch(() => { })
+                .finally(() => {
+                try {
+                    reader.releaseLock();
+                }
+                catch {
+                    // Ignore if a read is still pending
+                }
+            });
         }
         this._closed = true;
         this.emit("close");
@@ -574,18 +665,38 @@ export class Readable extends EventEmitter {
                 const { done, value } = await this._reader.read();
                 // Check _pushMode again after async read - if push() was called, stop reading
                 if (this._pushMode) {
+                    if (this._reader) {
+                        const reader = this._reader;
+                        this._reader = null;
+                        try {
+                            reader.releaseLock();
+                        }
+                        catch {
+                            // Ignore if a read is still pending
+                        }
+                    }
                     break;
                 }
                 if (done) {
                     this._ended = true;
-                    this.emit("end");
+                    this._emitEndOnce();
+                    if (this._reader) {
+                        const reader = this._reader;
+                        this._reader = null;
+                        try {
+                            reader.releaseLock();
+                        }
+                        catch {
+                            // Ignore if a read is still pending
+                        }
+                    }
                     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);
+                        this.emit("data", this._applyEncoding(value));
                     }
                     else {
                         this._buffer.push(value);
@@ -598,6 +709,16 @@ export class Readable extends EventEmitter {
         }
         catch (err) {
             this.emit("error", err);
+            if (this._reader) {
+                const reader = this._reader;
+                this._reader = null;
+                try {
+                    reader.releaseLock();
+                }
+                catch {
+                    // Ignore if a read is still pending
+                }
+            }
         }
         finally {
             this._reading = false;
@@ -605,7 +726,8 @@ export class Readable extends EventEmitter {
     }
     /**
      * Async iterator support
-     * Uses Web Stream reader for non-push mode, event-based for push mode
+     * Uses a unified event-queue iterator with simple backpressure.
+     * This matches Node's behavior more closely (iterator drives flowing mode).
      */
     async *[Symbol.asyncIterator]() {
         // First yield any buffered data
@@ -614,117 +736,124 @@ export class Readable extends EventEmitter {
             if (!this.objectMode) {
                 this._bufferSize -= this._getChunkSize(chunk);
             }
-            yield chunk;
+            yield this._applyEncoding(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;
-                }
+        const highWaterMark = this.readableHighWaterMark;
+        const lowWaterMark = Math.max(0, Math.floor(highWaterMark / 2));
+        const chunkSizeForBackpressure = (chunk) => {
+            if (this.objectMode) {
+                return 1;
             }
-            finally {
-                this.off("data", dataHandler);
-                this.off("end", endHandler);
-                this.off("error", errorHandler);
-                this.off("close", closeHandler);
+            if (chunk instanceof Uint8Array) {
+                return chunk.byteLength;
             }
-            return;
-        }
-        // For Web Stream mode, use the underlying reader
-        if (!this._reader) {
-            this._reader = this._stream.getReader();
-        }
+            if (typeof chunk === "string") {
+                return chunk.length;
+            }
+            return 1;
+        };
+        const dataQueue = [];
+        let dataQueueIndex = 0;
+        let queuedSize = 0;
+        let resolveNext = null;
+        let rejectNext = null;
+        let done = false;
+        let pausedByIterator = false;
+        let streamError = null;
+        const dataHandler = (chunk) => {
+            // data events are already encoding-aware; do not decode again here.
+            if (resolveNext) {
+                resolveNext(chunk);
+                resolveNext = null;
+                rejectNext = null;
+            }
+            else {
+                dataQueue.push(chunk);
+            }
+            queuedSize += chunkSizeForBackpressure(chunk);
+            if (!pausedByIterator && queuedSize >= highWaterMark) {
+                pausedByIterator = true;
+                this.pause();
+            }
+        };
+        const endHandler = () => {
+            done = true;
+            if (resolveNext) {
+                resolveNext(null);
+                resolveNext = null;
+                rejectNext = null;
+            }
+        };
+        const closeHandler = () => {
+            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;
+            }
+        };
+        this.on("data", dataHandler);
+        this.on("end", endHandler);
+        this.on("error", errorHandler);
+        this.on("close", closeHandler);
         try {
+            // Iterator consumption should drive the stream.
+            this.resume();
             while (true) {
-                const { done, value } = await this._reader.read();
+                if (streamError) {
+                    throw streamError;
+                }
+                if (dataQueueIndex < dataQueue.length) {
+                    const chunk = dataQueue[dataQueueIndex++];
+                    queuedSize -= chunkSizeForBackpressure(chunk);
+                    if (dataQueueIndex >= 1024 && dataQueueIndex * 2 >= dataQueue.length) {
+                        dataQueue.splice(0, dataQueueIndex);
+                        dataQueueIndex = 0;
+                    }
+                    if (pausedByIterator && queuedSize <= lowWaterMark && !done && !this._destroyed) {
+                        pausedByIterator = false;
+                        this.resume();
+                    }
+                    yield chunk;
+                    continue;
+                }
                 if (done) {
                     break;
                 }
-                yield value;
+                const chunk = await new Promise((resolve, reject) => {
+                    resolveNext = resolve;
+                    rejectNext = reject;
+                });
+                if (chunk !== null) {
+                    queuedSize -= chunkSizeForBackpressure(chunk);
+                    if (pausedByIterator && queuedSize <= lowWaterMark && !done && !this._destroyed) {
+                        pausedByIterator = false;
+                        this.resume();
+                    }
+                    yield chunk;
+                }
+            }
+            if (streamError) {
+                throw streamError;
             }
         }
         finally {
-            this._reader.releaseLock();
+            this.off("data", dataHandler);
+            this.off("end", endHandler);
+            this.off("error", errorHandler);
+            this.off("close", closeHandler);
         }
     }
     /**
@@ -943,6 +1072,32 @@ export class Readable extends EventEmitter {
         return stream;
     }
 }
+function toAsyncIterable(iterable) {
+    if (iterable && typeof iterable[Symbol.asyncIterator] === "function") {
+        return iterable;
+    }
+    return (async function* () {
+        for (const item of iterable) {
+            yield item;
+        }
+    })();
+}
+function pumpAsyncIterableToReadable(readable, iterable) {
+    (async () => {
+        try {
+            for await (const chunk of iterable) {
+                if (!readable.push(chunk)) {
+                    // Simple backpressure: yield to consumer.
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                }
+            }
+            readable.push(null);
+        }
+        catch (err) {
+            readable.destroy(err);
+        }
+    })();
+}
 // =============================================================================
 // Writable Stream Wrapper
 // =============================================================================
@@ -960,10 +1115,12 @@ export class Writable extends EventEmitter {
         this._closed = false;
         this._pendingWrites = 0;
         this._writableLength = 0;
+        this._needDrain = false;
         this._corked = 0;
         this._corkedChunks = [];
         this._defaultEncoding = "utf8";
         this._aborted = false;
+        this._ownsStream = false;
         this.objectMode = options?.objectMode ?? false;
         this.writableHighWaterMark = options?.highWaterMark ?? 16384;
         this.autoDestroy = options?.autoDestroy ?? true;
@@ -979,8 +1136,10 @@ export class Writable extends EventEmitter {
         }
         if (options?.stream) {
             this._stream = options.stream;
+            this._ownsStream = false;
         }
         else {
+            this._ownsStream = true;
             // Create bound references to instance properties/methods for use in WritableStream callbacks
             const getWriteFunc = () => this._writeFunc;
             const getFinalFunc = () => this._finalFunc;
@@ -1087,25 +1246,37 @@ export class Writable extends EventEmitter {
             this._writableLength += chunkSize;
             return this._writableLength < this.writableHighWaterMark;
         }
-        return this._doWrite(chunk, cb);
+        const ok = this._doWrite(chunk, cb);
+        if (!ok) {
+            this._needDrain = true;
+        }
+        return ok;
     }
     _doWrite(chunk, callback) {
         // Track pending writes for writableLength
         const chunkSize = this._getChunkSize(chunk);
         this._pendingWrites++;
         this._writableLength += chunkSize;
-        this._getWriter()
+        const writer = this._getWriter();
+        writer
             .write(chunk)
             .then(() => {
             this._pendingWrites--;
             this._writableLength -= chunkSize;
-            this.emit("drain");
+            if (this._needDrain && this._writableLength < this.writableHighWaterMark) {
+                this._needDrain = false;
+                this.emit("drain");
+            }
             callback?.(null);
         })
             .catch(err => {
             this._pendingWrites--;
             this._writableLength -= chunkSize;
-            this.emit("error", err);
+            // Avoid double-emitting if we're already in an errored/destroyed state.
+            if (!this._destroyed) {
+                this._errored = err;
+                this.emit("error", err);
+            }
             callback?.(err);
         });
         // Return false if we've exceeded high water mark (for backpressure)
@@ -1136,12 +1307,29 @@ export class Writable extends EventEmitter {
                 : callback;
         const finish = async () => {
             try {
+                const writer = this._getWriter();
                 if (chunk !== undefined) {
-                    await this._getWriter().write(chunk);
+                    await writer.write(chunk);
+                }
+                await writer.close();
+                if (this._writer === writer) {
+                    this._writer = null;
+                    try {
+                        writer.releaseLock();
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                // If we own the underlying Web WritableStream, its `close()` handler already
+                // emits finish/close. For external streams, we must emit finish ourselves.
+                if (!this._ownsStream) {
+                    this._finished = true;
+                    this.emit("finish");
+                    if (this.emitClose) {
+                        this.emit("close");
+                    }
                 }
-                await this._getWriter().close();
-                this._finished = true;
-                this.emit("finish");
                 if (cb) {
                     cb();
                 }
@@ -1162,12 +1350,24 @@ export class Writable extends EventEmitter {
         }
         this._destroyed = true;
         this._ended = true;
-        if (error) {
+        if (error && !this._errored) {
             this._errored = error;
             this.emit("error", error);
         }
         if (this._writer) {
-            this._writer.abort(error).catch(() => { });
+            const writer = this._writer;
+            this._writer = null;
+            writer
+                .abort(error)
+                .catch(() => { })
+                .finally(() => {
+                try {
+                    writer.releaseLock();
+                }
+                catch {
+                    // Ignore
+                }
+            });
         }
         this._closed = true;
         this.emit("close");
@@ -1318,342 +1518,259 @@ export function normalizeWritable(stream) {
  */
 export class Transform extends EventEmitter {
     /**
-     * Push data to the readable side (Node.js compatibility)
-     * Can be called from within transform callback
+     * Push data to the readable side (Node.js compatibility).
+     * Intended to be called from within transform/flush.
      */
     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;
+        return this._readable.push(chunk);
     }
     constructor(options) {
         super();
-        this._ended = false;
         this._destroyed = false;
+        this._ended = 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;
-        /** @internal - list of piped destinations for forwarding auto-consumed data */
-        this._pipeDestinations = [];
+        this._endTimer = null;
+        this._webStream = null;
+        this._sideForwardingCleanup = null;
         this.objectMode = options?.objectMode ?? false;
-        const userTransform = options?.transform;
-        const userFlush = options?.flush;
-        // 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]);
+        this._transformImpl = options?.transform;
+        this._flushImpl = options?.flush;
+        this._readable = new Readable({
+            objectMode: this.objectMode
+        });
+        this._writable = new Writable({
+            objectMode: this.objectMode,
+            write: (chunk, _encoding, callback) => {
+                this._runTransform(chunk)
+                    .then(() => callback(null))
+                    .catch(err => callback(err));
+            },
+            final: callback => {
+                this._runFlush()
+                    .then(() => {
+                    this._readable.push(null);
+                    callback(null);
+                })
+                    .catch(err => callback(err));
             }
-            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;
+        });
+        this._setupSideForwarding();
+    }
+    _setupSideForwarding() {
+        if (this._sideForwardingCleanup) {
+            this._sideForwardingCleanup();
+            this._sideForwardingCleanup = null;
+        }
+        const registry = createListenerRegistry();
+        registry.once(this._readable, "end", () => this.emit("end"));
+        registry.add(this._readable, "error", err => this._emitErrorOnce(err));
+        registry.once(this._writable, "finish", () => this.emit("finish"));
+        registry.add(this._writable, "drain", () => this.emit("drain"));
+        registry.add(this._writable, "error", err => this._emitErrorOnce(err));
+        this._sideForwardingCleanup = () => registry.cleanup();
+    }
+    _scheduleEnd() {
+        if (this._destroyed || this._errored) {
+            return;
+        }
+        if (this._writable.writableEnded) {
+            return;
+        }
+        if (this._endTimer) {
+            clearTimeout(this._endTimer);
+        }
+        // Defer closing to allow writes triggered during 'data' callbacks.
+        this._endTimer = setTimeout(() => {
+            this._endTimer = null;
+            if (this._destroyed || this._errored || this._writable.writableEnded) {
+                return;
             }
-            // 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;
+            this._writable.end();
+        }, 0);
+    }
+    _emitErrorOnce(err) {
+        if (this._errored) {
+            return;
+        }
+        this._errored = true;
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.emit("error", error);
+        if (!this._destroyed) {
+            this._destroyed = true;
+            this._readable.destroy(error);
+            this._writable.destroy(error);
+            queueMicrotask(() => this.emit("close"));
+        }
+    }
+    _hasSubclassTransform() {
+        if (this._transformImpl) {
+            return false;
+        }
+        const proto = Object.getPrototypeOf(this);
+        return proto._transform !== Transform.prototype._transform;
+    }
+    _hasSubclassFlush() {
+        if (this._flushImpl) {
+            return false;
+        }
+        const proto = Object.getPrototypeOf(this);
+        return proto._flush !== Transform.prototype._flush;
+    }
+    async _runTransform(chunk) {
+        if (this._destroyed || this._errored) {
+            throw new Error(this._errored ? "Cannot write after stream errored" : "Cannot write after stream destroyed");
+        }
+        try {
+            if (this._hasSubclassTransform()) {
+                await new Promise((resolve, reject) => {
+                    this._transform(chunk, "utf8", (err, data) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        if (data !== undefined) {
+                            this.push(data);
+                        }
+                        resolve();
+                    });
+                });
+                return;
             }
-            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)
-                        // _transform signature is (chunk, encoding, callback)
-                        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) {
-                        const transformParamCount = userTransform.length;
-                        if (transformParamCount >= 3) {
-                            // 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 !== undefined) {
-                                            controller.enqueue(data);
-                                        }
-                                        resolve();
-                                    }
-                                });
-                            });
+            const userTransform = this._transformImpl;
+            if (!userTransform) {
+                this.push(chunk);
+                return;
+            }
+            const paramCount = userTransform.length;
+            if (paramCount >= 3) {
+                await new Promise((resolve, reject) => {
+                    userTransform.call(this, chunk, "utf8", (err, data) => {
+                        if (err) {
+                            reject(err);
+                            return;
                         }
-                        else if (transformParamCount === 2) {
-                            await new Promise((resolve, reject) => {
-                                userTransform.call(getInstance(), chunk, (err, data) => {
-                                    if (err) {
-                                        reject(err);
-                                    }
-                                    else {
-                                        if (data !== undefined) {
-                                            controller.enqueue(data);
-                                        }
-                                        resolve();
-                                    }
-                                });
-                            });
+                        if (data !== undefined) {
+                            this.push(data);
                         }
-                        else {
-                            // Simple style: transform(chunk) => result
-                            const result = userTransform.call(getInstance(), chunk);
-                            if (result && typeof result.then === "function") {
-                                const awaitedResult = await result;
-                                if (awaitedResult !== undefined) {
-                                    controller.enqueue(awaitedResult);
-                                }
-                            }
-                            else {
-                                if (result !== undefined) {
-                                    controller.enqueue(result);
-                                }
-                            }
+                        resolve();
+                    });
+                });
+                return;
+            }
+            if (paramCount === 2) {
+                await new Promise((resolve, reject) => {
+                    userTransform.call(this, chunk, (err, data) => {
+                        if (err) {
+                            reject(err);
+                            return;
                         }
-                    }
-                    else {
-                        // Default: pass through
-                        controller.enqueue(chunk);
-                    }
-                }
-                catch (err) {
-                    controller.error(err);
-                    emitEvent("error", err);
-                }
-                finally {
-                    setController(null);
+                        if (data !== undefined) {
+                            this.push(data);
+                        }
+                        resolve();
+                    });
+                });
+                return;
+            }
+            const result = userTransform.call(this, chunk);
+            if (result && typeof result.then === "function") {
+                const awaited = await result;
+                if (awaited !== undefined) {
+                    this.push(awaited);
                 }
-            },
-            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) {
-                        const flushParamCount = userFlush.length;
-                        if (flushParamCount >= 1) {
-                            // 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();
-                                    }
-                                });
-                            });
+                return;
+            }
+            if (result !== undefined) {
+                this.push(result);
+            }
+        }
+        catch (err) {
+            this._emitErrorOnce(err);
+            throw err;
+        }
+    }
+    async _runFlush() {
+        if (this._destroyed || this._errored) {
+            return;
+        }
+        try {
+            if (this._hasSubclassFlush()) {
+                await new Promise((resolve, reject) => {
+                    this._flush((err, data) => {
+                        if (err) {
+                            reject(err);
+                            return;
                         }
-                        else {
-                            // Simple style: flush() => result
-                            const result = userFlush.call(getInstance());
-                            if (result && typeof result.then === "function") {
-                                const awaitedResult = await result;
-                                if (awaitedResult !== undefined && awaitedResult !== null) {
-                                    controller.enqueue(awaitedResult);
-                                }
-                            }
-                            else {
-                                if (result !== undefined && result !== null) {
-                                    controller.enqueue(result);
-                                }
-                            }
+                        if (data !== undefined) {
+                            this.push(data);
                         }
-                    }
-                    // No flush defined - nothing to do
-                }
-                catch (err) {
-                    controller.error(err);
-                    emitEvent("error", err);
-                }
-                finally {
-                    setController(null);
-                }
+                        resolve();
+                    });
+                });
+                return;
             }
-        });
-        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);
+            const userFlush = this._flushImpl;
+            if (!userFlush) {
+                return;
+            }
+            const paramCount = userFlush.length;
+            if (paramCount >= 1) {
+                await new Promise((resolve, reject) => {
+                    userFlush.call(this, (err, data) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        if (data !== undefined) {
+                            this.push(data);
+                        }
+                        resolve();
+                    });
+                });
+                return;
+            }
+            const result = userFlush.call(this);
+            if (result && typeof result.then === "function") {
+                const awaited = await result;
+                if (awaited !== undefined && awaited !== null) {
+                    this.push(awaited);
+                }
+                return;
             }
-        });
-        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);
+            if (result !== undefined && result !== null) {
+                this.push(result);
             }
-        });
+        }
+        catch (err) {
+            this._emitErrorOnce(err);
+            throw err;
+        }
     }
     /**
-     * Override on to start flowing when data listener is added
+     * Override on() to lazily forward readable 'data' events.
+     * Avoids starting flowing mode unless requested.
      */
     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();
+            this._readable.on("data", chunk => this.emit("data", chunk));
         }
-        return this;
+        return super.on(event, listener);
     }
     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;
+        // If end() has been requested, keep the close deferred as long as writes continue.
+        if (this._ended && !this._writable.writableEnded) {
+            this._scheduleEnd();
         }
         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);
-                    // Forward to any piped destinations
-                    for (const dest of this._pipeDestinations) {
-                        dest.write(chunk);
-                    }
-                    // Also emit data event for listeners
-                    this.emit("data", chunk);
-                }
-                this._autoConsumeEnded = true;
-                // End all piped destinations
-                for (const dest of this._pipeDestinations) {
-                    dest.end();
-                }
-                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
@@ -1666,18 +1783,7 @@ export class Transform extends EventEmitter {
         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);
+        this._scheduleEnd();
         return this;
     }
     /**
@@ -1687,31 +1793,9 @@ export class Transform extends EventEmitter {
         return this._readable.read(size);
     }
     /**
-     * Pipe to another stream (writable, transform, or duplex)
+     * Pipe readable side to destination
      */
     pipe(destination) {
-        // Mark as having consumer to prevent new auto-consume from starting
-        this._hasDataConsumer = true;
-        // Get the writable target - handle both Transform (with internal _writable) and plain Writable
-        const dest = destination;
-        const target = dest?._writable ?? dest;
-        // Register destination for forwarding
-        this._pipeDestinations.push(target);
-        // If auto-consume is running or has run, we need to handle buffered data ourselves
-        if (this._readableConsuming) {
-            // Forward any buffered data from auto-consume to the destination
-            for (let i = 0; i < this._autoConsumedBuffer.length; i++) {
-                target.write(this._autoConsumedBuffer[i]);
-            }
-            // If auto-consume has ended, end the destination too
-            if (this._autoConsumeEnded) {
-                target.end();
-            }
-            // Don't call _readable.pipe() - auto-consume already consumed _readable
-            // Future data will be forwarded via the 'data' event listener below
-            return destination;
-        }
-        // No auto-consume running - use normal pipe through _readable
         return this._readable.pipe(destination);
     }
     /**
@@ -1749,6 +1833,10 @@ export class Transform extends EventEmitter {
             return;
         }
         this._destroyed = true;
+        if (this._sideForwardingCleanup) {
+            this._sideForwardingCleanup();
+            this._sideForwardingCleanup = null;
+        }
         this._readable.destroy(error);
         this._writable.destroy(error);
         queueMicrotask(() => this.emit("close"));
@@ -1757,7 +1845,44 @@ export class Transform extends EventEmitter {
      * Get the underlying Web TransformStream
      */
     get webStream() {
-        return this._stream;
+        if (this._webStream) {
+            return this._webStream;
+        }
+        // Web Streams interop layer.
+        const iterator = this[Symbol.asyncIterator]();
+        const readable = new ReadableStream({
+            pull: async (controller) => {
+                const { done, value } = await iterator.next();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            },
+            cancel: reason => {
+                this.destroy(reason instanceof Error ? reason : new Error(String(reason)));
+            }
+        });
+        const writable = new WritableStream({
+            write: chunk => new Promise((resolve, reject) => {
+                this.write(chunk, err => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }),
+            close: () => new Promise(resolve => {
+                this.end(() => resolve());
+            }),
+            abort: reason => {
+                this.destroy(reason instanceof Error ? reason : new Error(String(reason)));
+            }
+        });
+        this._webStream = { readable, writable };
+        return this._webStream;
     }
     get readable() {
         return this._readable.readable;
@@ -1799,19 +1924,6 @@ export class Transform extends EventEmitter {
      * 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]();
     }
     // =========================================================================
@@ -1822,23 +1934,18 @@ export class Transform extends EventEmitter {
      */
     static fromWeb(webStream, options) {
         const transform = new Transform(options);
-        // Connect the web stream - set the internal _stream property
-        transform._stream = webStream;
+        transform._webStream = 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();
+        if (transform._sideForwardingCleanup) {
+            transform._sideForwardingCleanup();
+            transform._sideForwardingCleanup = null;
+        }
         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));
+        // Re-connect event forwarding (data forwarding remains lazy via Transform.on)
+        transform._setupSideForwarding();
         return transform;
     }
     /**
@@ -1894,7 +2001,13 @@ export class Duplex extends EventEmitter {
                     callback();
                 }
             });
-            readable.on("error", err => duplex.emit("error", err));
+            const onError = (err) => {
+                duplex.emit("error", err);
+            };
+            const cleanupError = addEmitterListener(readable, "error", onError);
+            addEmitterListener(readable, "end", cleanupError, { once: true });
+            addEmitterListener(readable, "close", cleanupError, { once: true });
+            addEmitterListener(sink, "finish", cleanupError, { once: true });
             readable.pipe(sink);
         };
         // If it has readable and/or writable properties
@@ -1902,21 +2015,25 @@ export class Duplex extends EventEmitter {
             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) {
+            // Create one duplex that can bridge both sides.
+            // (Previous behavior returned a new writable-only Duplex and dropped the readable side.)
+            const duplex = new Duplex({
+                readableObjectMode: pair.readable?.readableObjectMode,
+                writableObjectMode: pair.writable?.writableObjectMode,
+                write: pair.writable
+                    ? (chunk, encoding, callback) => {
                         pair.writable.write(chunk, encoding, callback);
-                    },
-                    final(callback) {
+                    }
+                    : undefined,
+                final: pair.writable
+                    ? callback => {
                         pair.writable.end(callback);
                     }
-                });
+                    : undefined
+            });
+            if (pair.readable) {
+                forwardReadableToDuplex(pair.readable, duplex);
             }
             return duplex;
         }
@@ -1954,9 +2071,22 @@ export class Duplex extends EventEmitter {
      */
     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 });
+        const newReadable = new Readable({
+            stream: pair.readable,
+            objectMode: duplex.readableObjectMode
+        });
+        const newWritable = new Writable({
+            stream: pair.writable,
+            objectMode: duplex.writableObjectMode
+        });
+        if (duplex._sideForwardingCleanup) {
+            duplex._sideForwardingCleanup();
+            duplex._sideForwardingCleanup = null;
+        }
+        duplex._readable = newReadable;
+        duplex._writable = newWritable;
+        // Re-wire event forwarding (data forwarding remains lazy via Duplex.on)
+        duplex._setupSideForwarding();
         return duplex;
     }
     /**
@@ -1972,6 +2102,7 @@ export class Duplex extends EventEmitter {
         super();
         // Track if we've already set up data forwarding
         this._dataForwardingSetup = false;
+        this._sideForwardingCleanup = null;
         this.allowHalfOpen = options?.allowHalfOpen ?? true;
         // Support shorthand objectMode option
         const objectMode = options?.objectMode ?? false;
@@ -1988,23 +2119,31 @@ export class Duplex extends EventEmitter {
             write: options?.write?.bind(this),
             final: options?.final?.bind(this)
         });
+        this._setupSideForwarding();
+    }
+    _setupSideForwarding() {
+        if (this._sideForwardingCleanup) {
+            this._sideForwardingCleanup();
+            this._sideForwardingCleanup = null;
+        }
+        const registry = createListenerRegistry();
         // Forward non-data events (data forwarding is lazy to avoid premature flowing)
-        this._readable.on("end", () => {
+        registry.once(this._readable, "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
+        registry.add(this._readable, "error", err => this.emit("error", err));
+        registry.add(this._writable, "error", err => this.emit("error", err));
+        registry.once(this._writable, "finish", () => this.emit("finish"));
+        registry.add(this._writable, "drain", () => this.emit("drain"));
+        registry.once(this._writable, "close", () => {
             if (!this.allowHalfOpen && !this._readable.destroyed) {
                 this._readable.destroy();
             }
         });
+        this._sideForwardingCleanup = () => registry.cleanup();
     }
     /**
      * Override on() to set up data forwarding lazily
@@ -2123,6 +2262,10 @@ export class Duplex extends EventEmitter {
      * Destroy both sides
      */
     destroy(error) {
+        if (this._sideForwardingCleanup) {
+            this._sideForwardingCleanup();
+            this._sideForwardingCleanup = null;
+        }
         this._readable.destroy(error);
         this._writable.destroy(error);
         return this;
@@ -2263,21 +2406,8 @@ export class Collector extends Writable {
 // =============================================================================
 // 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);
-    }
-}
+// Standalone cross-platform helpers
+export { PullStream, BufferedStream, StringChunk, BufferChunk };
 // =============================================================================
 // Stream Creation Functions
 // =============================================================================
@@ -2285,36 +2415,16 @@ export class BufferedStream extends StandaloneBufferedStream {
  * 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;
+    // Readable already supports Node-style `read()` via the constructor option.
+    // Keep this helper minimal to avoid accidental double-read behavior.
+    return new Readable(options);
 }
 /**
  * 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);
-        }
-    })();
+    pumpAsyncIterableToReadable(readable, iterable);
     return readable;
 }
 /**
@@ -2343,38 +2453,8 @@ export function createReadableFromArray(data, options) {
  * 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 });
+    // Writable already supports Node-style `write()` / `final()` via the constructor.
+    return new Writable(options);
 }
 /**
  * Create a transform stream from a transform function
@@ -2410,20 +2490,6 @@ export function createPullStream(options) {
 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;
@@ -2509,11 +2575,17 @@ export function pipeline(...args) {
         const transforms = normalized.slice(1, -1);
         let completed = false;
         const allStreams = [source, ...transforms, destination];
-        const cleanup = (error) => {
+        const registry = createListenerRegistry();
+        let onAbort;
+        const cleanupWithSignal = (error) => {
             if (completed) {
                 return;
             }
             completed = true;
+            registry.cleanup();
+            if (onAbort && options.signal) {
+                options.signal.removeEventListener("abort", onAbort);
+            }
             // Destroy all streams on error
             if (error) {
                 for (const stream of allStreams) {
@@ -2530,12 +2602,11 @@ export function pipeline(...args) {
         // Handle abort signal
         if (options.signal) {
             if (options.signal.aborted) {
-                cleanup(new Error("Pipeline aborted"));
+                cleanupWithSignal(new Error("Pipeline aborted"));
                 return;
             }
-            options.signal.addEventListener("abort", () => {
-                cleanup(new Error("Pipeline aborted"));
-            });
+            onAbort = () => cleanupWithSignal(new Error("Pipeline aborted"));
+            options.signal.addEventListener("abort", onAbort);
         }
         // Chain the streams
         let current = source;
@@ -2549,13 +2620,35 @@ export function pipeline(...args) {
         }
         else {
             // Don't end destination
-            current.on("data", chunk => destination.write(chunk));
+            let paused = false;
+            let waitingForDrain = false;
+            const onDrain = () => {
+                waitingForDrain = false;
+                if (paused && typeof current.resume === "function") {
+                    paused = false;
+                    current.resume();
+                }
+            };
+            const onData = (chunk) => {
+                const ok = destination.write(chunk);
+                if (!ok && !waitingForDrain) {
+                    waitingForDrain = true;
+                    if (!paused && typeof current.pause === "function") {
+                        paused = true;
+                        current.pause();
+                    }
+                    registry.once(destination, "drain", onDrain);
+                }
+            };
+            const onEnd = () => cleanupWithSignal();
+            registry.add(current, "data", onData);
+            registry.once(current, "end", onEnd);
         }
         // Handle completion
-        destination.on("finish", () => cleanup());
+        registry.once(destination, "finish", () => cleanupWithSignal());
         // Handle errors on all streams
         for (const stream of allStreams) {
-            stream.on("error", (err) => cleanup(err));
+            registry.once(stream, "error", (err) => cleanupWithSignal(err));
         }
     });
     // If callback provided, use it
@@ -2595,11 +2688,20 @@ export function finished(stream, optionsOrCallback, callback) {
     const promise = new Promise((resolve, reject) => {
         const normalizedStream = toBrowserPipelineStream(stream);
         let resolved = false;
+        const registry = createListenerRegistry();
+        let onAbort;
+        const cleanup = () => {
+            registry.cleanup();
+            if (onAbort && options.signal) {
+                options.signal.removeEventListener("abort", onAbort);
+            }
+        };
         const done = (err) => {
             if (resolved) {
                 return;
             }
             resolved = true;
+            cleanup();
             if (err && !options.error) {
                 reject(err);
             }
@@ -2613,9 +2715,8 @@ export function finished(stream, optionsOrCallback, callback) {
                 done(new Error("Aborted"));
                 return;
             }
-            options.signal.addEventListener("abort", () => {
-                done(new Error("Aborted"));
-            });
+            onAbort = () => done(new Error("Aborted"));
+            options.signal.addEventListener("abort", onAbort);
         }
         const checkReadable = options.readable !== false;
         const checkWritable = options.writable !== false;
@@ -2630,13 +2731,13 @@ export function finished(stream, optionsOrCallback, callback) {
         }
         // Listen for events
         if (checkWritable) {
-            normalizedStream.on("finish", () => done());
+            registry.once(normalizedStream, "finish", () => done());
         }
         if (checkReadable) {
-            normalizedStream.on("end", () => done());
+            registry.once(normalizedStream, "end", () => done());
         }
-        normalizedStream.on("error", (err) => done(err));
-        normalizedStream.on("close", () => done());
+        registry.once(normalizedStream, "error", (err) => done(err));
+        registry.once(normalizedStream, "close", () => done());
     });
     // If callback provided, use it
     if (cb) {
@@ -2658,38 +2759,8 @@ export async function streamToPromise(stream) {
  * (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;
+    const [chunks, totalLength] = await collectStreamChunks(stream);
+    return concatUint8Arrays(chunks, totalLength);
 }
 /**
  * Alias for streamToUint8Array (Node.js compatibility)
@@ -2699,23 +2770,16 @@ 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);
+    const [chunks, totalLength] = await collectStreamChunks(stream);
+    const combined = concatUint8Arrays(chunks, totalLength);
+    const decoder = encoding ? getTextDecoder(encoding) : textDecoder;
+    return decoder.decode(combined);
 }
 /**
  * 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");
-    }
+    const iterable = toReadableAsyncIterable(stream, "drainStream");
     for await (const _chunk of iterable) {
         // Consume data
     }
@@ -2788,14 +2852,19 @@ export function addAbortSignal(signal, stream) {
         stream.destroy(new Error("Aborted"));
         return stream;
     }
+    const cleanup = () => {
+        signal.removeEventListener("abort", onAbort);
+        removeEmitterListener(stream, "close", onClose);
+    };
     const onAbort = () => {
+        cleanup();
         stream.destroy(new Error("Aborted"));
     };
-    signal.addEventListener("abort", onAbort, { once: true });
-    // Clean up when stream is destroyed
-    stream.on("close", () => {
-        signal.removeEventListener("abort", onAbort);
-    });
+    const onClose = () => {
+        cleanup();
+    };
+    signal.addEventListener("abort", onAbort);
+    addEmitterListener(stream, "close", onClose, { once: true });
     return stream;
 }
 /**
@@ -2804,60 +2873,68 @@ export function addAbortSignal(signal, stream) {
 export function createDuplex(options) {
     const readableObjectMode = options?.readableObjectMode ?? options?.objectMode;
     const writableObjectMode = options?.writableObjectMode ?? options?.objectMode;
+    const underlyingWritable = options?.writable;
     const duplex = new Duplex({
         allowHalfOpen: options?.allowHalfOpen,
         readableHighWaterMark: options?.readableHighWaterMark,
         writableHighWaterMark: options?.writableHighWaterMark,
         readableObjectMode,
-        writableObjectMode
+        writableObjectMode,
+        read: options?.read,
+        write: options?.write ??
+            (underlyingWritable
+                ? (chunk, encoding, callback) => {
+                    if (typeof underlyingWritable.write === "function") {
+                        underlyingWritable.write(chunk, encoding, callback);
+                        return;
+                    }
+                    // Best-effort sync sink
+                    try {
+                        underlyingWritable.write?.(chunk);
+                        callback(null);
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                }
+                : undefined),
+        final: options?.final ??
+            (underlyingWritable
+                ? (callback) => {
+                    if (typeof underlyingWritable.end === "function") {
+                        underlyingWritable.end((err) => callback(err ?? null));
+                    }
+                    else {
+                        underlyingWritable.end?.();
+                        callback(null);
+                    }
+                }
+                : undefined)
     });
-    // If custom readable/writable provided, pipe them
+    // If an underlying readable is provided, forward it into the duplex readable side.
     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;
-        };
+        const sink = new Writable({
+            objectMode: duplex.readableObjectMode,
+            write(chunk, _encoding, callback) {
+                duplex.push(chunk);
+                callback(null);
+            },
+            final(callback) {
+                duplex.push(null);
+                callback(null);
+            }
+        });
+        if (typeof readable?.on === "function") {
+            const onError = (err) => {
+                duplex.destroy(err);
+            };
+            const cleanupError = addEmitterListener(readable, "error", onError);
+            addEmitterListener(readable, "end", cleanupError, { once: true });
+            addEmitterListener(readable, "close", cleanupError, { once: true });
+            addEmitterListener(sink, "finish", cleanupError, { once: true });
+        }
+        readable.pipe?.(sink);
     }
     if (options?.destroy) {
         const originalDestroy = duplex.destroy.bind(duplex);
@@ -2881,20 +2958,7 @@ export function createDuplex(options) {
  */
 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);
-        }
-    })();
+    pumpAsyncIterableToReadable(readable, generator());
     return readable;
 }
 /**
@@ -2924,8 +2988,8 @@ export function compose(...transforms) {
             transform: chunk => chunk
         });
     }
-    const isNativeTransform = (stream) => stream instanceof Transform;
-    if (len === 1 && isNativeTransform(transforms[0])) {
+    // Preserve identity: compose(single) returns the same transform.
+    if (len === 1) {
         return transforms[0];
     }
     // Chain the transforms: first → second → ... → last
@@ -2935,74 +2999,118 @@ export function compose(...transforms) {
     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;
+    // A lightweight Transform wrapper that delegates:
+    // - writable side to `first`
+    // - readable side to `last`
+    // It forwards relevant events lazily to avoid per-chunk overhead when unused.
+    const composed = new Transform({
+        objectMode: first?.objectMode ?? true,
+        transform: chunk => chunk
+    });
+    const registry = createListenerRegistry();
+    // Always forward errors; they are critical for pipeline semantics.
+    for (const t of transforms) {
+        registry.add(t, "error", (err) => composed.emit("error", err));
+    }
+    // Forward writable-side backpressure/completion events from `first`.
+    registry.add(first, "drain", () => composed.emit("drain"));
+    registry.once(first, "finish", () => composed.emit("finish"));
+    // Forward readable-side events from `last` lazily.
+    let forwardData = false;
+    let forwardEnd = false;
+    let forwardReadable = false;
+    const ensureDataForwarding = () => {
+        if (forwardData) {
+            return;
         }
-        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);
+        forwardData = true;
+        registry.add(last, "data", (chunk) => composed.emit("data", chunk));
+    };
+    const ensureEndForwarding = () => {
+        if (forwardEnd) {
+            return;
         }
-        write(chunk, encodingOrCallback, callback) {
-            if (typeof encodingOrCallback === "function") {
-                return first.write(chunk, encodingOrCallback);
-            }
-            return first.write(chunk, encodingOrCallback, callback);
+        forwardEnd = true;
+        registry.once(last, "end", () => composed.emit("end"));
+    };
+    const ensureReadableForwarding = () => {
+        if (forwardReadable) {
+            return;
         }
-        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;
+        forwardReadable = true;
+        registry.add(last, "readable", () => composed.emit("readable"));
+    };
+    const originalOn = composed.on.bind(composed);
+    const originalOnce = composed.once.bind(composed);
+    composed.on = (event, listener) => {
+        if (event === "data") {
+            ensureDataForwarding();
         }
-        pipe(destination) {
-            return last.pipe(destination);
+        else if (event === "end") {
+            ensureEndForwarding();
         }
-        destroy(error) {
-            for (const t of transforms) {
-                t.destroy(error);
-            }
-            super.destroy(error);
+        else if (event === "readable") {
+            ensureReadableForwarding();
         }
-        read(size) {
-            return typeof last.read === "function" ? last.read(size) : null;
+        return originalOn(event, listener);
+    };
+    composed.once = (event, listener) => {
+        if (event === "data") {
+            ensureDataForwarding();
         }
-        async *[Symbol.asyncIterator]() {
-            const it = last?.[Symbol.asyncIterator]?.();
-            if (it) {
-                for await (const chunk of it) {
-                    yield chunk;
-                }
-                return;
+        else if (event === "end") {
+            ensureEndForwarding();
+        }
+        else if (event === "readable") {
+            ensureReadableForwarding();
+        }
+        return originalOnce(event, listener);
+    };
+    // Delegate core stream methods
+    const firstAny = first;
+    const lastAny = last;
+    composed.write = (chunk, encodingOrCallback, callback) => {
+        if (typeof encodingOrCallback === "function") {
+            return firstAny.write(chunk, encodingOrCallback);
+        }
+        return firstAny.write(chunk, encodingOrCallback, callback);
+    };
+    composed.end = (chunkOrCallback, encodingOrCallback, callback) => {
+        if (typeof chunkOrCallback === "function") {
+            firstAny.end(chunkOrCallback);
+            return composed;
+        }
+        if (typeof encodingOrCallback === "function") {
+            firstAny.end(chunkOrCallback, encodingOrCallback);
+            return composed;
+        }
+        firstAny.end(chunkOrCallback, encodingOrCallback, callback);
+        return composed;
+    };
+    composed.pipe = (destination) => {
+        return lastAny.pipe(destination);
+    };
+    composed.read = (size) => {
+        return typeof lastAny.read === "function" ? lastAny.read(size) : null;
+    };
+    composed[Symbol.asyncIterator] = async function* () {
+        const it = lastAny?.[Symbol.asyncIterator]?.();
+        if (it) {
+            for await (const chunk of it) {
+                yield chunk;
             }
-            yield* super[Symbol.asyncIterator]();
+            return;
         }
-    }
-    const composed = new ComposedTransform({
-        objectMode: first?.objectMode ?? true,
-        transform: chunk => chunk
+        yield* Transform.prototype[Symbol.asyncIterator].call(composed);
+    };
+    const originalDestroy = composed.destroy.bind(composed);
+    composed.destroy = ((error) => {
+        registry.cleanup();
+        for (const t of transforms) {
+            t.destroy(error);
+        }
+        originalDestroy(error);
     });
-    // 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
@@ -3248,77 +3356,54 @@ export function duplexPair(options) {
 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");
-    }
+    const iterable = toReadableAsyncIterable(stream, "collectStreamChunks");
     for await (const chunk of iterable) {
         chunks.push(chunk);
         totalLength += chunk.length;
     }
-    return { chunks, totalLength };
+    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];
+function toReadableAsyncIterable(stream, name) {
+    if (isReadableStream(stream)) {
+        return Readable.fromWeb(stream);
     }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0; i < len; i++) {
-        result.set(chunks[i], offset);
-        offset += chunks[i].length;
+    if (isAsyncIterable(stream)) {
+        return stream;
     }
-    return result;
+    throw new Error(`${name}: unsupported stream type`);
 }
 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);
+        const bytes = await streamToUint8Array(stream);
+        return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
     },
     /**
      * Consume entire stream as Blob
      */
     async blob(stream, options) {
-        const { chunks } = await collectStreamChunks(stream);
+        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);
+        return streamToUint8Array(stream);
     },
     /**
      * Consume entire stream as JSON
      */
     async json(stream) {
-        const text = await consumers.text(stream);
-        return JSON.parse(text);
+        return JSON.parse(await streamToString(stream));
     },
     /**
      * 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);
+        return streamToString(stream, encoding);
     }
 };
 // =============================================================================