@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1

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

@@ -14,40 +14,6 @@ import { EventEmitter } from "./event-emitter.js";
 import { PullStream as StandalonePullStream } from "./pull-stream.js";
 import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "./buffered-stream.js";
 import { concatUint8Arrays, getTextDecoder, textDecoder } from "./shared.js";
-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
 // =============================================================================
@@ -64,7 +30,6 @@ 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;
@@ -121,7 +86,20 @@ export class Readable extends EventEmitter {
      */
     static from(iterable, options) {
         const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-        pumpAsyncIterableToReadable(readable, toAsyncIterable(iterable));
+        (async () => {
+            try {
+                for await (const chunk of iterable) {
+                    if (!readable.push(chunk)) {
+                        // Backpressure
+                        await new Promise(resolve => setTimeout(resolve, 0));
+                    }
+                }
+                readable.push(null);
+            }
+            catch (err) {
+                readable.destroy(err);
+            }
+        })();
         return readable;
     }
     /**
@@ -166,30 +144,16 @@ export class Readable extends EventEmitter {
                     // Controller may already be closed
                 }
             }
-            // 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();
-            }
+            this.emit("end");
             // Note: Don't call destroy() here, let the stream be consumed naturally
             // The reader will return done:true when it finishes reading
             return false;
         }
-        // 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", this._applyEncoding(chunk));
+            this.emit("data", chunk);
             // Check if stream was paused during emit (backpressure from consumer)
             if (!this._flowing) {
                 return false;
@@ -214,8 +178,10 @@ export class Readable extends EventEmitter {
             if (!this.objectMode) {
                 this._bufferSize += this._getChunkSize(chunk);
             }
-            // NOTE: We still buffer for Node-style read()/data semantics.
-            // The internal Web ReadableStream is also fed via controller.enqueue() above.
+            // NOTE: Do NOT enqueue to Web Stream controller here!
+            // In push mode, _buffer is the only source of data for data events.
+            // Web Stream is only used for async iteration when not in push mode.
+            // Enqueueing here would cause data duplication when _startReading is also running.
             // Emit readable event when buffer goes from empty to having data
             if (wasEmpty) {
                 queueMicrotask(() => this.emit("readable"));
@@ -229,13 +195,6 @@ 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
@@ -260,22 +219,14 @@ export class Readable extends EventEmitter {
                 if (!this.objectMode) {
                     this._bufferSize -= this._getChunkSize(chunk);
                 }
-                const decoded = this._applyEncoding(chunk);
-                if (this._ended && this._bufferedLength() === 0) {
-                    queueMicrotask(() => this._emitEndOnce());
-                }
-                return decoded;
+                return this._applyEncoding(chunk);
             }
             // For binary mode, handle size
             const chunk = this._bufferShift();
             if (!this.objectMode) {
                 this._bufferSize -= this._getChunkSize(chunk);
             }
-            const decoded = this._applyEncoding(chunk);
-            if (this._ended && this._bufferedLength() === 0) {
-                queueMicrotask(() => this._emitEndOnce());
-            }
-            return decoded;
+            return this._applyEncoding(chunk);
         }
         return null;
     }
@@ -381,11 +332,11 @@ export class Readable extends EventEmitter {
             if (!this.objectMode) {
                 this._bufferSize -= this._getChunkSize(chunk);
             }
-            this.emit("data", this._applyEncoding(chunk));
+            this.emit("data", chunk);
         }
         // If already ended, emit end event
         if (this._ended && this._bufferedLength() === 0) {
-            this._emitEndOnce();
+            this.emit("end");
         }
         else if (this._read) {
             // Call user-provided read function asynchronously
@@ -448,36 +399,26 @@ 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();
-                // Install a removable, once-style drain listener.
-                if (!drainListener) {
-                    drainListener = () => {
-                        removeDrainListener();
+                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);
+                        }
                         this.resume();
                     };
-                    eventTarget.on("drain", drainListener);
-                    const entry = this._pipeListeners.get(dest);
-                    if (entry) {
-                        entry.drain = drainListener;
-                    }
+                    eventTarget.on("drain", resumeOnce);
                 }
             }
         };
@@ -497,8 +438,7 @@ export class Readable extends EventEmitter {
         this._pipeListeners.set(dest, {
             data: dataListener,
             end: endListener,
-            error: errorListener,
-            eventTarget
+            error: errorListener
         });
         this.on("data", dataListener);
         this.once("end", endListener);
@@ -521,14 +461,6 @@ 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);
             }
         }
@@ -540,14 +472,6 @@ 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);
                 }
             }
@@ -566,26 +490,12 @@ 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) {
-            const reader = this._reader;
-            this._reader = null;
-            reader
-                .cancel()
-                .catch(() => { })
-                .finally(() => {
-                try {
-                    reader.releaseLock();
-                }
-                catch {
-                    // Ignore if a read is still pending
-                }
-            });
+            this._reader.cancel().catch(() => { });
         }
         this._closed = true;
         this.emit("close");
@@ -664,38 +574,18 @@ 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._emitEndOnce();
-                    if (this._reader) {
-                        const reader = this._reader;
-                        this._reader = null;
-                        try {
-                            reader.releaseLock();
-                        }
-                        catch {
-                            // Ignore if a read is still pending
-                        }
-                    }
+                    this.emit("end");
                     break;
                 }
                 if (value !== undefined) {
                     // In flowing mode, emit data directly without buffering
                     // Only buffer if not flowing (paused mode)
                     if (this._flowing) {
-                        this.emit("data", this._applyEncoding(value));
+                        this.emit("data", value);
                     }
                     else {
                         this._buffer.push(value);
@@ -708,16 +598,6 @@ 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;
@@ -725,8 +605,7 @@ export class Readable extends EventEmitter {
     }
     /**
      * Async iterator support
-     * Uses a unified event-queue iterator with simple backpressure.
-     * This matches Node's behavior more closely (iterator drives flowing mode).
+     * Uses Web Stream reader for non-push mode, event-based for push mode
      */
     async *[Symbol.asyncIterator]() {
         // First yield any buffered data
@@ -735,124 +614,117 @@ export class Readable extends EventEmitter {
             if (!this.objectMode) {
                 this._bufferSize -= this._getChunkSize(chunk);
             }
-            yield this._applyEncoding(chunk);
+            yield chunk;
         }
+        // If already ended, we're done
         if (this._ended) {
             return;
         }
-        const highWaterMark = this.readableHighWaterMark;
-        const lowWaterMark = Math.max(0, Math.floor(highWaterMark / 2));
-        const chunkSizeForBackpressure = (chunk) => {
-            if (this.objectMode) {
-                return 1;
-            }
-            if (chunk instanceof Uint8Array) {
-                return chunk.byteLength;
-            }
-            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) {
-                if (streamError) {
-                    throw streamError;
+        // 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;
                 }
-                if (dataQueueIndex < dataQueue.length) {
-                    const chunk = dataQueue[dataQueueIndex++];
-                    queuedSize -= chunkSizeForBackpressure(chunk);
-                    if (dataQueueIndex >= 1024 && dataQueueIndex * 2 >= dataQueue.length) {
-                        dataQueue.splice(0, dataQueueIndex);
-                        dataQueueIndex = 0;
+            };
+            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 (pausedByIterator && queuedSize <= lowWaterMark && !done && !this._destroyed) {
-                        pausedByIterator = false;
-                        this.resume();
+                    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;
+                        }
                     }
-                    yield chunk;
-                    continue;
                 }
+                // Check for error after loop
+                if (streamError) {
+                    throw streamError;
+                }
+            }
+            finally {
+                this.off("data", dataHandler);
+                this.off("end", endHandler);
+                this.off("error", errorHandler);
+                this.off("close", closeHandler);
+            }
+            return;
+        }
+        // For Web Stream mode, use the underlying reader
+        if (!this._reader) {
+            this._reader = this._stream.getReader();
+        }
+        try {
+            while (true) {
+                const { done, value } = await this._reader.read();
                 if (done) {
                     break;
                 }
-                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;
+                yield value;
             }
         }
         finally {
-            this.off("data", dataHandler);
-            this.off("end", endHandler);
-            this.off("error", errorHandler);
-            this.off("close", closeHandler);
+            this._reader.releaseLock();
         }
     }
     /**
@@ -1071,32 +943,6 @@ 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
 // =============================================================================
@@ -1114,12 +960,10 @@ 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;
@@ -1135,10 +979,8 @@ 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;
@@ -1245,37 +1087,25 @@ export class Writable extends EventEmitter {
             this._writableLength += chunkSize;
             return this._writableLength < this.writableHighWaterMark;
         }
-        const ok = this._doWrite(chunk, cb);
-        if (!ok) {
-            this._needDrain = true;
-        }
-        return ok;
+        return this._doWrite(chunk, cb);
     }
     _doWrite(chunk, callback) {
         // Track pending writes for writableLength
         const chunkSize = this._getChunkSize(chunk);
         this._pendingWrites++;
         this._writableLength += chunkSize;
-        const writer = this._getWriter();
-        writer
+        this._getWriter()
             .write(chunk)
             .then(() => {
             this._pendingWrites--;
             this._writableLength -= chunkSize;
-            if (this._needDrain && this._writableLength < this.writableHighWaterMark) {
-                this._needDrain = false;
-                this.emit("drain");
-            }
+            this.emit("drain");
             callback?.(null);
         })
             .catch(err => {
             this._pendingWrites--;
             this._writableLength -= chunkSize;
-            // Avoid double-emitting if we're already in an errored/destroyed state.
-            if (!this._destroyed) {
-                this._errored = err;
-                this.emit("error", err);
-            }
+            this.emit("error", err);
             callback?.(err);
         });
         // Return false if we've exceeded high water mark (for backpressure)
@@ -1306,29 +1136,12 @@ export class Writable extends EventEmitter {
                 : callback;
         const finish = async () => {
             try {
-                const writer = this._getWriter();
                 if (chunk !== undefined) {
-                    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().write(chunk);
                 }
+                await this._getWriter().close();
+                this._finished = true;
+                this.emit("finish");
                 if (cb) {
                     cb();
                 }
@@ -1349,24 +1162,12 @@ export class Writable extends EventEmitter {
         }
         this._destroyed = true;
         this._ended = true;
-        if (error && !this._errored) {
+        if (error) {
             this._errored = error;
             this.emit("error", error);
         }
         if (this._writer) {
-            const writer = this._writer;
-            this._writer = null;
-            writer
-                .abort(error)
-                .catch(() => { })
-                .finally(() => {
-                try {
-                    writer.releaseLock();
-                }
-                catch {
-                    // Ignore
-                }
-            });
+            this._writer.abort(error).catch(() => { });
         }
         this._closed = true;
         this.emit("close");
@@ -1517,259 +1318,342 @@ export function normalizeWritable(stream) {
  */
 export class Transform extends EventEmitter {
     /**
-     * Push data to the readable side (Node.js compatibility).
-     * Intended to be called from within transform/flush.
+     * Push data to the readable side (Node.js compatibility)
+     * Can be called from within transform callback
      */
     push(chunk) {
-        return this._readable.push(chunk);
+        if (chunk === null) {
+            return false;
+        }
+        if (this._transformController) {
+            // If we're in a transform callback, enqueue directly
+            this._transformController.enqueue(chunk);
+        }
+        else {
+            // Otherwise buffer for later
+            this._pushBuffer.push(chunk);
+        }
+        return true;
     }
     constructor(options) {
         super();
-        this._destroyed = false;
         this._ended = false;
+        this._destroyed = false;
         this._errored = false;
+        // Buffer for Node.js style push() calls during transform
+        this._pushBuffer = [];
+        // Controller for enqueueing pushed data (set during transform execution)
+        this._transformController = null;
+        // Buffer for writes that occur after end() but before writable is closed
+        this._pendingEndWrites = [];
+        // Whether end() has been called but writable not yet closed
+        this._endPending = false;
+        // Track if we've already set up data forwarding
         this._dataForwardingSetup = false;
-        this._endTimer = null;
-        this._webStream = null;
-        this._sideForwardingCleanup = null;
+        /** @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.objectMode = options?.objectMode ?? false;
-        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));
-            }
-        });
-        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;
+        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._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;
+            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;
             }
-            const userTransform = this._transformImpl;
-            if (!userTransform) {
-                this.push(chunk);
-                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;
             }
-            const paramCount = userTransform.length;
-            if (paramCount >= 3) {
-                await new Promise((resolve, reject) => {
-                    userTransform.call(this, chunk, "utf8", (err, data) => {
-                        if (err) {
-                            reject(err);
-                            return;
-                        }
-                        if (data !== undefined) {
-                            this.push(data);
+            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();
+                                    }
+                                });
+                            });
                         }
-                        resolve();
-                    });
-                });
-                return;
-            }
-            if (paramCount === 2) {
-                await new Promise((resolve, reject) => {
-                    userTransform.call(this, chunk, (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;
-            }
-            const result = userTransform.call(this, chunk);
-            if (result && typeof result.then === "function") {
-                const awaited = await result;
-                if (awaited !== undefined) {
-                    this.push(awaited);
+                    }
+                    else {
+                        // Default: pass through
+                        controller.enqueue(chunk);
+                    }
                 }
-                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;
-                        }
-                        if (data !== undefined) {
-                            this.push(data);
-                        }
-                        resolve();
-                    });
-                });
-                return;
-            }
-            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;
+                catch (err) {
+                    controller.error(err);
+                    emitEvent("error", err);
+                }
+                finally {
+                    setController(null);
+                }
+            },
+            flush: async (controller) => {
+                try {
+                    setController(controller);
+                    // Check for subclass _flush override first
+                    if (hasSubclassFlush()) {
+                        await new Promise((resolve, reject) => {
+                            this._flush((err, data) => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    if (data !== undefined) {
+                                        controller.enqueue(data);
+                                    }
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    else if (userFlush) {
+                        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();
+                                    }
+                                });
+                            });
                         }
-                        if (data !== undefined) {
-                            this.push(data);
+                        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);
+                                }
+                            }
                         }
-                        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);
+                    }
+                    // No flush defined - nothing to do
                 }
-                return;
+                catch (err) {
+                    controller.error(err);
+                    emitEvent("error", err);
+                }
+                finally {
+                    setController(null);
+                }
+            }
+        });
+        this._readable = new Readable({
+            stream: this._stream.readable,
+            objectMode: this.objectMode
+        });
+        this._writable = new Writable({
+            stream: this._stream.writable,
+            objectMode: this.objectMode
+        });
+        // Forward non-data events (data forwarding is lazy to avoid premature flowing)
+        this._readable.on("end", () => this.emit("end"));
+        // Only forward errors if not already errored (to prevent duplicate events)
+        this._readable.on("error", err => {
+            if (!this._errored) {
+                this._errored = true;
+                this.emit("error", err);
             }
-            if (result !== undefined && result !== null) {
-                this.push(result);
+        });
+        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);
             }
-        }
-        catch (err) {
-            this._emitErrorOnce(err);
-            throw err;
-        }
+        });
     }
     /**
-     * Override on() to lazily forward readable 'data' events.
-     * Avoids starting flowing mode unless requested.
+     * Override on to start flowing when data listener is added
      */
     on(event, listener) {
+        // Set up data forwarding when first external data listener is added
         if (event === "data" && !this._dataForwardingSetup) {
             this._dataForwardingSetup = true;
-            this._readable.on("data", chunk => this.emit("data", chunk));
+            this._readable.on("data", data => this.emit("data", data));
         }
-        return super.on(event, listener);
+        super.on(event, listener);
+        // When data listener is added, mark as having consumer
+        // and start the readable in flowing mode
+        if (event === "data") {
+            this._hasDataConsumer = true;
+            this._readable.resume();
+        }
+        return this;
     }
     write(chunk, encodingOrCallback, callback) {
         const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-        // If end() has been requested, keep the close deferred as long as writes continue.
-        if (this._ended && !this._writable.writableEnded) {
-            this._scheduleEnd();
+        if (this._destroyed || this._errored) {
+            const err = new Error(this._errored ? "Cannot write after stream errored" : "Cannot write after stream destroyed");
+            queueMicrotask(() => this.emit("error", err));
+            cb?.(err);
+            return false;
+        }
+        // Ensure readable is being consumed to allow transform to execute
+        // This matches Node.js behavior where transform executes immediately on write
+        // Only auto-consume if no explicit consumer (data listener or pipe)
+        if (!this._readableConsuming && !this._hasDataConsumer) {
+            this._readableConsuming = true;
+            this._startAutoConsume();
+        }
+        // If end() was called but writable not yet closed, buffer the write
+        // This allows writes during data event handlers to be processed
+        if (this._endPending) {
+            this._pendingEndWrites.push({ chunk, callback: cb });
+            return true;
         }
         return this._writable.write(chunk, cb);
     }
+    /** @internal - auto-consume readable to allow transform to execute */
+    _startAutoConsume() {
+        this._autoConsumePromise = (async () => {
+            try {
+                for await (const chunk of this._readable) {
+                    // Buffer the data for later retrieval
+                    this._autoConsumedBuffer.push(chunk);
+                    // 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
@@ -1782,7 +1666,18 @@ export class Transform extends EventEmitter {
         if (chunk !== undefined) {
             this._writable.write(chunk);
         }
-        this._scheduleEnd();
+        // Use setTimeout(0) instead of queueMicrotask to ensure all transform
+        // processing and data events complete before we close the writable.
+        // Microtasks run before the TransformStream processes data.
+        setTimeout(() => {
+            // Process any writes that occurred during data events
+            for (const { chunk: pendingChunk, callback } of this._pendingEndWrites) {
+                this._writable.write(pendingChunk, callback);
+            }
+            this._pendingEndWrites = [];
+            this._endPending = false;
+            this._writable.end();
+        }, 0);
         return this;
     }
     /**
@@ -1792,9 +1687,31 @@ export class Transform extends EventEmitter {
         return this._readable.read(size);
     }
     /**
-     * Pipe readable side to destination
+     * Pipe to another stream (writable, transform, or duplex)
      */
     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);
     }
     /**
@@ -1832,10 +1749,6 @@ 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"));
@@ -1844,44 +1757,7 @@ export class Transform extends EventEmitter {
      * Get the underlying Web TransformStream
      */
     get webStream() {
-        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;
+        return this._stream;
     }
     get readable() {
         return this._readable.readable;
@@ -1923,6 +1799,19 @@ 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]();
     }
     // =========================================================================
@@ -1933,18 +1822,23 @@ export class Transform extends EventEmitter {
      */
     static fromWeb(webStream, options) {
         const transform = new Transform(options);
-        transform._webStream = webStream;
+        // Connect the web stream - set the internal _stream property
+        transform._stream = webStream;
         // Replace internal streams with the ones from the web stream
         const newReadable = Readable.fromWeb(webStream.readable, { objectMode: options?.objectMode });
         const newWritable = Writable.fromWeb(webStream.writable, { objectMode: options?.objectMode });
-        if (transform._sideForwardingCleanup) {
-            transform._sideForwardingCleanup();
-            transform._sideForwardingCleanup = null;
-        }
+        // Remove old event listeners before replacing
+        transform._readable.removeAllListeners();
+        transform._writable.removeAllListeners();
         transform._readable = newReadable;
         transform._writable = newWritable;
-        // Re-connect event forwarding (data forwarding remains lazy via Transform.on)
-        transform._setupSideForwarding();
+        // Re-connect event forwarding
+        newReadable.on("data", (data) => transform.emit("data", data));
+        newReadable.on("end", () => transform.emit("end"));
+        newReadable.on("error", (err) => transform.emit("error", err));
+        newWritable.on("finish", () => transform.emit("finish"));
+        newWritable.on("drain", () => transform.emit("drain"));
+        newWritable.on("error", (err) => transform.emit("error", err));
         return transform;
     }
     /**
@@ -2000,13 +1894,7 @@ export class Duplex extends EventEmitter {
                     callback();
                 }
             });
-            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.on("error", err => duplex.emit("error", err));
             readable.pipe(sink);
         };
         // If it has readable and/or writable properties
@@ -2014,25 +1902,21 @@ export class Duplex extends EventEmitter {
             source !== null &&
             "readable" in source &&
             "writable" in source) {
+            const duplex = new Duplex();
             const pair = source;
-            // 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) => {
+            if (pair.readable) {
+                forwardReadableToDuplex(pair.readable, duplex);
+            }
+            if (pair.writable) {
+                return new Duplex({
+                    objectMode: duplex.writableObjectMode,
+                    write(chunk, encoding, callback) {
                         pair.writable.write(chunk, encoding, callback);
-                    }
-                    : undefined,
-                final: pair.writable
-                    ? callback => {
+                    },
+                    final(callback) {
                         pair.writable.end(callback);
                     }
-                    : undefined
-            });
-            if (pair.readable) {
-                forwardReadableToDuplex(pair.readable, duplex);
+                });
             }
             return duplex;
         }
@@ -2070,22 +1954,9 @@ export class Duplex extends EventEmitter {
      */
     static fromWeb(pair, options) {
         const duplex = new Duplex(options);
-        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();
+        // Replace internal streams
+        duplex._readable = new Readable({ stream: pair.readable });
+        duplex._writable = new Writable({ stream: pair.writable });
         return duplex;
     }
     /**
@@ -2101,7 +1972,6 @@ 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;
@@ -2118,31 +1988,23 @@ 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)
-        registry.once(this._readable, "end", () => {
+        this._readable.on("end", () => {
             this.emit("end");
+            // If not allowHalfOpen, end the writable side too
             if (!this.allowHalfOpen) {
                 this._writable.end();
             }
         });
-        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", () => {
+        this._readable.on("error", err => this.emit("error", err));
+        this._writable.on("finish", () => this.emit("finish"));
+        this._writable.on("drain", () => this.emit("drain"));
+        this._writable.on("close", () => {
+            // If not allowHalfOpen, destroy the readable side too
             if (!this.allowHalfOpen && !this._readable.destroyed) {
                 this._readable.destroy();
             }
         });
-        this._sideForwardingCleanup = () => registry.cleanup();
     }
     /**
      * Override on() to set up data forwarding lazily
@@ -2261,10 +2123,6 @@ 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;
@@ -2427,16 +2285,36 @@ export class BufferedStream extends StandaloneBufferedStream {
  * Create a readable stream with custom read implementation
  */
 export function createReadable(options) {
-    // Readable already supports Node-style `read()` via the constructor option.
-    // Keep this helper minimal to avoid accidental double-read behavior.
-    return new Readable(options);
+    const readable = new Readable(options);
+    // Override read behavior if provided
+    if (options?.read) {
+        const originalRead = readable.read.bind(readable);
+        readable.read = function (size) {
+            options.read(size ?? 16384);
+            return originalRead(size);
+        };
+    }
+    return readable;
 }
 /**
  * Create a readable stream from an async iterable
  */
 export function createReadableFromAsyncIterable(iterable, options) {
     const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    pumpAsyncIterableToReadable(readable, iterable);
+    (async () => {
+        try {
+            for await (const chunk of iterable) {
+                if (!readable.push(chunk)) {
+                    // Backpressure - wait a bit
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                }
+            }
+            readable.push(null);
+        }
+        catch (err) {
+            readable.destroy(err);
+        }
+    })();
     return readable;
 }
 /**
@@ -2465,8 +2343,38 @@ export function createReadableFromArray(data, options) {
  * Create a writable stream with custom write implementation
  */
 export function createWritable(options) {
-    // Writable already supports Node-style `write()` / `final()` via the constructor.
-    return new Writable(options);
+    // Create a custom WritableStream with user's handlers
+    const stream = new WritableStream({
+        write: async (chunk) => {
+            if (options?.write) {
+                return new Promise((resolve, reject) => {
+                    options.write(chunk, "utf8", err => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        },
+        close: async () => {
+            if (options?.final) {
+                return new Promise((resolve, reject) => {
+                    options.final(err => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        }
+    });
+    return new Writable({ ...options, stream });
 }
 /**
  * Create a transform stream from a transform function
@@ -2601,17 +2509,11 @@ export function pipeline(...args) {
         const transforms = normalized.slice(1, -1);
         let completed = false;
         const allStreams = [source, ...transforms, destination];
-        const registry = createListenerRegistry();
-        let onAbort;
-        const cleanupWithSignal = (error) => {
+        const cleanup = (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) {
@@ -2628,11 +2530,12 @@ export function pipeline(...args) {
         // Handle abort signal
         if (options.signal) {
             if (options.signal.aborted) {
-                cleanupWithSignal(new Error("Pipeline aborted"));
+                cleanup(new Error("Pipeline aborted"));
                 return;
             }
-            onAbort = () => cleanupWithSignal(new Error("Pipeline aborted"));
-            options.signal.addEventListener("abort", onAbort);
+            options.signal.addEventListener("abort", () => {
+                cleanup(new Error("Pipeline aborted"));
+            });
         }
         // Chain the streams
         let current = source;
@@ -2646,35 +2549,13 @@ export function pipeline(...args) {
         }
         else {
             // Don't end destination
-            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);
+            current.on("data", chunk => destination.write(chunk));
         }
         // Handle completion
-        registry.once(destination, "finish", () => cleanupWithSignal());
+        destination.on("finish", () => cleanup());
         // Handle errors on all streams
         for (const stream of allStreams) {
-            registry.once(stream, "error", (err) => cleanupWithSignal(err));
+            stream.on("error", (err) => cleanup(err));
         }
     });
     // If callback provided, use it
@@ -2714,20 +2595,11 @@ 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);
             }
@@ -2741,8 +2613,9 @@ export function finished(stream, optionsOrCallback, callback) {
                 done(new Error("Aborted"));
                 return;
             }
-            onAbort = () => done(new Error("Aborted"));
-            options.signal.addEventListener("abort", onAbort);
+            options.signal.addEventListener("abort", () => {
+                done(new Error("Aborted"));
+            });
         }
         const checkReadable = options.readable !== false;
         const checkWritable = options.writable !== false;
@@ -2757,13 +2630,13 @@ export function finished(stream, optionsOrCallback, callback) {
         }
         // Listen for events
         if (checkWritable) {
-            registry.once(normalizedStream, "finish", () => done());
+            normalizedStream.on("finish", () => done());
         }
         if (checkReadable) {
-            registry.once(normalizedStream, "end", () => done());
+            normalizedStream.on("end", () => done());
         }
-        registry.once(normalizedStream, "error", (err) => done(err));
-        registry.once(normalizedStream, "close", () => done());
+        normalizedStream.on("error", (err) => done(err));
+        normalizedStream.on("close", () => done());
     });
     // If callback provided, use it
     if (cb) {
@@ -2785,8 +2658,38 @@ export async function streamToPromise(stream) {
  * (Browser equivalent of Node.js streamToBuffer)
  */
 export async function streamToUint8Array(stream) {
-    const { chunks, totalLength } = await collectStreamChunks(stream);
-    return concatWithLength(chunks, totalLength);
+    let iterable;
+    if (isReadableStream(stream)) {
+        iterable = Readable.fromWeb(stream);
+    }
+    else if (isAsyncIterable(stream)) {
+        iterable = stream;
+    }
+    else {
+        throw new Error("streamToUint8Array: unsupported stream type");
+    }
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of iterable) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    // Fast paths
+    const len = chunks.length;
+    if (len === 0) {
+        return new Uint8Array(0);
+    }
+    if (len === 1) {
+        return chunks[0];
+    }
+    // Use precalculated total length
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0; i < len; i++) {
+        result.set(chunks[i], offset);
+        offset += chunks[i].length;
+    }
+    return result;
 }
 /**
  * Alias for streamToUint8Array (Node.js compatibility)
@@ -2796,10 +2699,8 @@ export const streamToBuffer = streamToUint8Array;
  * Collect all data from a readable stream into a string
  */
 export async function streamToString(stream, encoding) {
-    const { chunks, totalLength } = await collectStreamChunks(stream);
-    const combined = concatWithLength(chunks, totalLength);
-    const decoder = encoding ? getTextDecoder(encoding) : textDecoder;
-    return decoder.decode(combined);
+    const buffer = await streamToUint8Array(stream);
+    return getTextDecoder(encoding).decode(buffer);
 }
 /**
  * Drain a stream (consume all data without processing)
@@ -2887,19 +2788,14 @@ 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"));
     };
-    const onClose = () => {
-        cleanup();
-    };
-    signal.addEventListener("abort", onAbort);
-    addEmitterListener(stream, "close", onClose, { once: true });
+    signal.addEventListener("abort", onAbort, { once: true });
+    // Clean up when stream is destroyed
+    stream.on("close", () => {
+        signal.removeEventListener("abort", onAbort);
+    });
     return stream;
 }
 /**
@@ -2908,68 +2804,60 @@ 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,
-        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)
+        writableObjectMode
     });
-    // If an underlying readable is provided, forward it into the duplex readable side.
+    // If custom readable/writable provided, pipe them
     if (options?.readable) {
         const readable = options.readable;
-        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);
+        readable.on?.("data", (chunk) => duplex.push(chunk));
+        readable.on?.("end", () => duplex.push(null));
+        readable.on?.("error", (err) => duplex.destroy(err));
+    }
+    if (options?.writable) {
+        const writable = options.writable;
+        duplex.on("data", (chunk) => writable.write?.(chunk));
+        duplex.on("finish", () => writable.end?.());
+    }
+    // If custom read/write/final provided, override methods
+    if (options?.write) {
+        const _originalWrite = duplex.write.bind(duplex); // Keep bound reference for potential future use
+        duplex.write = function (chunk, encodingOrCallback, callback) {
+            const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : "utf8";
+            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : (callback ?? (() => { }));
+            options.write.call(duplex, chunk, encoding, cb);
+            return true;
+        };
+    }
+    if (options?.final) {
+        const originalEnd = duplex.end.bind(duplex);
+        duplex.end = function (chunkOrCallback, encodingOrCallback, callback) {
+            const cb = typeof chunkOrCallback === "function"
+                ? chunkOrCallback
+                : typeof encodingOrCallback === "function"
+                    ? encodingOrCallback
+                    : (callback ?? (() => { }));
+            if (chunkOrCallback !== undefined && typeof chunkOrCallback !== "function") {
+                duplex.write(chunkOrCallback);
+            }
+            // Call custom final handler
+            options.final.call(duplex, (err) => {
+                if (err) {
+                    duplex.emit("error", err);
+                }
+                else {
+                    duplex.emit("finish");
+                }
+                // Call original end to properly close writable side
+                originalEnd();
+                cb();
+            });
+            return duplex;
+        };
     }
     if (options?.destroy) {
         const originalDestroy = duplex.destroy.bind(duplex);
@@ -2993,7 +2881,20 @@ export function createDuplex(options) {
  */
 export function createReadableFromGenerator(generator, options) {
     const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    pumpAsyncIterableToReadable(readable, generator());
+    (async () => {
+        try {
+            for await (const chunk of generator()) {
+                if (!readable.push(chunk)) {
+                    // Backpressure
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                }
+            }
+            readable.push(null);
+        }
+        catch (err) {
+            readable.destroy(err);
+        }
+    })();
     return readable;
 }
 /**
@@ -3023,8 +2924,8 @@ export function compose(...transforms) {
             transform: chunk => chunk
         });
     }
-    // Preserve identity: compose(single) returns the same transform.
-    if (len === 1) {
+    const isNativeTransform = (stream) => stream instanceof Transform;
+    if (len === 1 && isNativeTransform(transforms[0])) {
         return transforms[0];
     }
     // Chain the transforms: first → second → ... → last
@@ -3035,34 +2936,19 @@ export function compose(...transforms) {
         transforms[i].pipe(transforms[i + 1]);
     }
     class ComposedTransform extends Transform {
-        constructor(options) {
-            super(options);
+        constructor() {
+            super(...arguments);
             this._dataForwarding = false;
             this._endForwarding = false;
-            this._dataForwardCleanup = null;
-            this._endForwardCleanup = null;
-            this._errorForwardCleanup = [];
-            for (const t of transforms) {
-                const onError = (err) => {
-                    this.emit("error", err);
-                };
-                this._errorForwardCleanup.push(addEmitterListener(t, "error", onError));
-            }
         }
         on(event, listener) {
             if (event === "data" && !this._dataForwarding) {
                 this._dataForwarding = true;
-                const onData = (chunk) => {
-                    this.emit("data", chunk);
-                };
-                this._dataForwardCleanup = addEmitterListener(last, "data", onData);
+                last.on("data", (chunk) => this.emit("data", chunk));
             }
             if (event === "end" && !this._endForwarding) {
                 this._endForwarding = true;
-                const onEnd = () => {
-                    this.emit("end");
-                };
-                this._endForwardCleanup = addEmitterListener(last, "end", onEnd, { once: true });
+                last.on("end", () => this.emit("end"));
             }
             return super.on(event, listener);
         }
@@ -3088,18 +2974,6 @@ export function compose(...transforms) {
             return last.pipe(destination);
         }
         destroy(error) {
-            if (this._dataForwardCleanup) {
-                this._dataForwardCleanup();
-                this._dataForwardCleanup = null;
-            }
-            if (this._endForwardCleanup) {
-                this._endForwardCleanup();
-                this._endForwardCleanup = null;
-            }
-            for (let i = this._errorForwardCleanup.length - 1; i >= 0; i--) {
-                this._errorForwardCleanup[i]();
-            }
-            this._errorForwardCleanup.length = 0;
             for (const t of transforms) {
                 t.destroy(error);
             }
@@ -3123,6 +2997,12 @@ export function compose(...transforms) {
         objectMode: first?.objectMode ?? true,
         transform: chunk => chunk
     });
+    // Forward errors from any transform
+    for (const t of transforms) {
+        t.on("error", (err) => {
+            composed.emit("error", err);
+        });
+    }
     // Reflect underlying readability/writability like the previous duck-typed wrapper
     Object.defineProperty(composed, "readable", {
         get: () => last.readable