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

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

@@ -1,52 +1,23 @@
 /**
- * Stream Module
+ * Stream Module (Node.js entry)
  *
- * Native stream implementations for Node.js and Browser.
+ * Public entrypoint for stream utilities and classes.
  *
- * - Node.js: Uses native `stream` module (Readable, Writable, Transform, Duplex, PassThrough)
- * - Browser: Uses Web Streams API (ReadableStream, WritableStream, TransformStream)
- *
- * Both implementations provide the same API for cross-platform compatibility.
+ * Notes:
+ * - This file is intentionally export-only (tree-shaking friendly).
+ * - Browser builds should import from `@stream/index.browser`.
  *
  * @example
- * ```typescript
- * import {
- *   Readable,
- *   Writable,
- *   Transform,
- *   Duplex,
- *   PassThrough,
- *   pipeline,
- *   createTransform,
- *   streamToUint8Array
- * } from './modules/stream.js';
- *
- * // Create a transform stream
- * const uppercase = createTransform<Uint8Array, Uint8Array>(chunk => {
- *   const text = new TextDecoder().decode(chunk);
- *   return new TextEncoder().encode(text.toUpperCase());
- * });
+ * ```ts
+ * import { pipeline, createTransform, createCollector } from "./index.browser.js";
  *
- * // Use pipeline for clean stream composition
- * await pipeline(readable, uppercase, writable);
+ * const upper = createTransform<Uint8Array, Uint8Array>(chunk => chunk);
+ * const out = createCollector<Uint8Array>();
+ * await pipeline(source, upper, out);
  * ```
  */
-// =============================================================================
-// Native Stream Classes and Functions (platform-specific)
-// =============================================================================
-import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.browser.js";
-export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
-import { EventEmitter } from "./event-emitter.js";
-export { EventEmitter };
-// =============================================================================
-// ChunkedBuilder (platform-independent)
-// =============================================================================
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-// =============================================================================
-// Utility Functions (platform-independent)
-// =============================================================================
-import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
-export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
-import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
-export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.browser.js";
+export { EventEmitter } from "./event-emitter.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";

package/dist/browser/modules/stream/internal/event-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Small event utilities for Node-style emitters.
+ *
+ * Prefer keeping this separate from the main stream implementation so other
+ * modules (e.g. archive) can reuse it without pulling in the whole stream API.
+ */
+type NodeStyleEmitter = {
+    on?: (event: string, listener: (...args: any[]) => void) => any;
+    once?: (event: string, listener: (...args: any[]) => void) => any;
+    off?: (event: string, listener: (...args: any[]) => void) => any;
+    removeListener?: (event: string, listener: (...args: any[]) => void) => any;
+};
+/**
+ * Resolve when an emitter fires `event`, reject on `error`.
+ */
+export declare function onceEvent(emitter: NodeStyleEmitter, event: string): Promise<void>;
+export {};

package/dist/browser/modules/stream/internal/event-utils.js

@@ -0,0 +1,40 @@
+/**
+ * Small event utilities for Node-style emitters.
+ *
+ * Prefer keeping this separate from the main stream implementation so other
+ * modules (e.g. archive) can reuse it without pulling in the whole stream API.
+ */
+function off(emitter, event, listener) {
+    if (typeof emitter.off === "function") {
+        emitter.off(event, listener);
+    }
+    else if (typeof emitter.removeListener === "function") {
+        emitter.removeListener(event, listener);
+    }
+}
+/**
+ * Resolve when an emitter fires `event`, reject on `error`.
+ */
+export function onceEvent(emitter, event) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const onDone = () => {
+            cleanup();
+            resolve();
+        };
+        const cleanup = () => {
+            off(emitter, "error", onError);
+            off(emitter, event, onDone);
+        };
+        if (typeof emitter.once === "function") {
+            emitter.once("error", onError);
+            emitter.once(event, onDone);
+            return;
+        }
+        emitter.on?.("error", onError);
+        emitter.on?.(event, onDone);
+    });
+}

package/dist/browser/modules/stream/internal/type-guards.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lightweight runtime type guards shared across modules.
+ *
+ * Keep this file dependency-free to maximize deduping in bundled builds.
+ */
+export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
+export declare function isWritableStream(value: unknown): value is WritableStream<unknown>;
+export declare function isAsyncIterable(value: unknown): value is AsyncIterable<unknown>;
+export declare function isTransformStream(value: unknown): value is TransformStream<unknown, unknown>;

package/dist/browser/modules/stream/internal/type-guards.js

@@ -0,0 +1,24 @@
+/**
+ * Lightweight runtime type guards shared across modules.
+ *
+ * Keep this file dependency-free to maximize deduping in bundled builds.
+ */
+export function isReadableStream(value) {
+    return !!value && typeof value === "object" && typeof value.getReader === "function";
+}
+export function isWritableStream(value) {
+    return !!value && typeof value === "object" && typeof value.getWriter === "function";
+}
+export function isAsyncIterable(value) {
+    return (!!value &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[Symbol.asyncIterator] === "function");
+}
+export function isTransformStream(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        !!value.readable &&
+        !!value.writable &&
+        isReadableStream(value.readable) &&
+        isWritableStream(value.writable));
+}

package/dist/browser/modules/stream/pull-stream.d.ts

@@ -5,16 +5,15 @@
  * Works identically in both browser and Node.js environments.
  */
 import { EventEmitter } from "@stream/event-emitter";
-export interface PullStreamOptions {
-    /** Enable object mode */
-    objectMode?: boolean;
-}
+import type { PullStreamOptions } from "@stream/types";
+export type { PullStreamOptions } from "@stream/types";
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
  */
 export declare class PullStream extends EventEmitter {
-    private _bufferChunks;
-    private _totalLength;
+    private _buffer;
+    private _bufferReadIndex;
+    private _bufferWriteIndex;
     protected finished: boolean;
     protected _match?: number;
     private _destroyed;

package/dist/browser/modules/stream/pull-stream.js

@@ -5,36 +5,41 @@
  * Works identically in both browser and Node.js environments.
  */
 import { EventEmitter } from "./event-emitter.js";
-import { concatUint8Arrays } from "./shared.js";
+const EMPTY_U8 = new Uint8Array(0);
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
  */
 export class PullStream extends EventEmitter {
     constructor(_options = {}) {
         super();
-        // Use chunked buffer storage to avoid repeated concat
-        this._bufferChunks = [];
-        this._totalLength = 0;
+        // Single growable buffer with read/write cursors.
+        // IMPORTANT: never mutate bytes that have already been returned via subarray
+        // (to keep views stable). When we need to reclaim prefix space, we allocate
+        // a new buffer and copy the remaining bytes.
+        this._buffer = new Uint8Array(0);
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
         this.finished = false;
         this._destroyed = false;
     }
-    // Consolidate chunks into single buffer when needed
+    // Maintain legacy protected accessor for subclasses.
+    // Returned value is a view of the readable region.
     get buffer() {
-        const len = this._bufferChunks.length;
-        if (len === 0) {
-            return new Uint8Array(0);
+        if (this._bufferReadIndex === this._bufferWriteIndex) {
+            return EMPTY_U8;
         }
-        if (len === 1) {
-            return this._bufferChunks[0];
-        }
-        // Consolidate multiple chunks
-        const buf = concatUint8Arrays(this._bufferChunks);
-        this._bufferChunks = [buf];
-        return buf;
+        return this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
     }
     set buffer(buf) {
-        this._bufferChunks = buf.length > 0 ? [buf] : [];
-        this._totalLength = buf.length;
+        if (buf.length === 0) {
+            this._buffer = EMPTY_U8;
+            this._bufferReadIndex = 0;
+            this._bufferWriteIndex = 0;
+            return;
+        }
+        this._buffer = buf;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = buf.length;
     }
     /**
      * Write data to the stream
@@ -44,8 +49,38 @@ export class PullStream extends EventEmitter {
             this.emit("error", new Error("Cannot write to destroyed stream"));
             return false;
         }
-        this._bufferChunks.push(chunk);
-        this._totalLength += chunk.length;
+        const chunkLen = chunk.length;
+        if (chunkLen === 0) {
+            this.emit("chunk");
+            return true;
+        }
+        // Fast path: first write can reuse caller buffer without copy.
+        if (this._buffer.length === 0) {
+            this._buffer = chunk;
+            this._bufferReadIndex = 0;
+            this._bufferWriteIndex = chunkLen;
+            this.emit("chunk");
+            return true;
+        }
+        const required = this._bufferWriteIndex + chunkLen;
+        if (required <= this._buffer.length) {
+            this._buffer.set(chunk, this._bufferWriteIndex);
+            this._bufferWriteIndex += chunkLen;
+            this.emit("chunk");
+            return true;
+        }
+        // Need a new buffer. We keep previously returned views stable by allocating.
+        const remaining = this._bufferWriteIndex - this._bufferReadIndex;
+        const nextLength = remaining + chunkLen;
+        const prevCap = this._buffer.length;
+        // Grow exponentially to avoid O(n^2) copying on many small writes.
+        const nextCap = Math.max(nextLength, prevCap > 0 ? prevCap * 2 : 1024);
+        const next = new Uint8Array(nextCap);
+        next.set(this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex), 0);
+        next.set(chunk, remaining);
+        this._buffer = next;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = nextLength;
         this.emit("chunk");
         return true;
     }
@@ -69,8 +104,9 @@ export class PullStream extends EventEmitter {
             return;
         }
         this._destroyed = true;
-        this._bufferChunks = [];
-        this._totalLength = 0;
+        this._buffer = EMPTY_U8;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
         if (error) {
             this.emit("error", error);
         }
@@ -95,19 +131,32 @@ export class PullStream extends EventEmitter {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
-                // Use _totalLength for fast check before consolidating
-                if (this._totalLength >= size) {
-                    const buf = this.buffer;
-                    const result = buf.subarray(0, size);
-                    this.buffer = buf.subarray(size);
+                if (size === 0) {
+                    resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
+                    return;
+                }
+                const available = this._bufferWriteIndex - this._bufferReadIndex;
+                if (available >= size) {
+                    const start = this._bufferReadIndex;
+                    const end = start + size;
+                    const result = this._buffer.subarray(start, end);
+                    this._bufferReadIndex = end;
+                    if (this._bufferReadIndex === this._bufferWriteIndex) {
+                        this._buffer = EMPTY_U8;
+                        this._bufferReadIndex = 0;
+                        this._bufferWriteIndex = 0;
+                    }
                     resolve(result);
                     return;
                 }
                 if (this.finished) {
                     // Return whatever we have
-                    const result = this.buffer;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
+                    const result = this._bufferReadIndex === this._bufferWriteIndex
+                        ? EMPTY_U8
+                        : this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
+                    this._buffer = EMPTY_U8;
+                    this._bufferReadIndex = 0;
+                    this._bufferWriteIndex = 0;
                     resolve(result);
                     return;
                 }
@@ -124,21 +173,36 @@ export class PullStream extends EventEmitter {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
-                const buf = this.buffer;
-                const matchIndex = this._indexOf(buf, pattern);
-                if (matchIndex !== -1) {
-                    this._match = matchIndex;
-                    const endIndex = includePattern ? matchIndex + pattern.length : matchIndex;
-                    const result = buf.subarray(0, endIndex);
-                    this.buffer = buf.subarray(includePattern ? endIndex : matchIndex + pattern.length);
+                // Match empty pattern without consuming anything.
+                if (pattern.length === 0) {
+                    this._match = 0;
+                    resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
+                    return;
+                }
+                const matchIndexAbs = this._indexOf(this._buffer, this._bufferReadIndex, this._bufferWriteIndex, pattern);
+                if (matchIndexAbs !== -1) {
+                    this._match = matchIndexAbs - this._bufferReadIndex;
+                    const patternLen = pattern.length;
+                    const resultEndAbs = includePattern ? matchIndexAbs + patternLen : matchIndexAbs;
+                    const consumeTo = matchIndexAbs + patternLen;
+                    const result = this._buffer.subarray(this._bufferReadIndex, resultEndAbs);
+                    this._bufferReadIndex = consumeTo;
+                    if (this._bufferReadIndex === this._bufferWriteIndex) {
+                        this._buffer = EMPTY_U8;
+                        this._bufferReadIndex = 0;
+                        this._bufferWriteIndex = 0;
+                    }
                     resolve(result);
                     return;
                 }
                 if (this.finished) {
                     // Pattern not found, return everything
-                    const result = buf;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
+                    const result = this._bufferReadIndex === this._bufferWriteIndex
+                        ? EMPTY_U8
+                        : this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
+                    this._buffer = EMPTY_U8;
+                    this._bufferReadIndex = 0;
+                    this._bufferWriteIndex = 0;
                     resolve(result);
                     return;
                 }
@@ -158,7 +222,7 @@ export class PullStream extends EventEmitter {
      * Get remaining buffer length
      */
     get length() {
-        return this._totalLength;
+        return this._bufferWriteIndex - this._bufferReadIndex;
     }
     /**
      * Check if stream is finished
@@ -175,13 +239,13 @@ export class PullStream extends EventEmitter {
     /**
      * Find pattern in Uint8Array (like Buffer.indexOf)
      */
-    _indexOf(haystack, needle, start = 0) {
+    _indexOf(haystack, start, end, needle) {
         const needleLen = needle.length;
         if (needleLen === 0) {
             return start;
         }
-        const haystackLen = haystack.length;
-        if (needleLen > haystackLen) {
+        const haystackLen = end;
+        if (needleLen > haystackLen - start) {
             return -1;
         }
         const first = needle[0];

package/dist/browser/modules/stream/shared.d.ts

@@ -31,7 +31,7 @@ export declare function uint8ArrayToString(arr: Uint8Array, encoding?: string):
 /**
  * Concatenate multiple Uint8Arrays efficiently
  */
-export declare function concatUint8Arrays(arrays: readonly Uint8Array[]): Uint8Array;
+export declare function concatUint8Arrays(arrays: readonly Uint8Array[], totalLength?: number): Uint8Array;
 /**
  * Compare two Uint8Arrays for equality
  */

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

@@ -54,7 +54,7 @@ export function uint8ArrayToString(arr, encoding) {
 /**
  * Concatenate multiple Uint8Arrays efficiently
  */
-export function concatUint8Arrays(arrays) {
+export function concatUint8Arrays(arrays, totalLength) {
     const len = arrays.length;
     if (len === 0) {
         return new Uint8Array(0);
@@ -63,9 +63,12 @@ export function concatUint8Arrays(arrays) {
         return arrays[0];
     }
     // Calculate total length with for loop for better performance
-    let totalLength = 0;
-    for (let i = 0; i < len; i++) {
-        totalLength += arrays[i].length;
+    if (totalLength === undefined) {
+        let sum = 0;
+        for (let i = 0; i < len; i++) {
+            sum += arrays[i].length;
+        }
+        totalLength = sum;
     }
     const result = new Uint8Array(totalLength);
     let offset = 0;

package/dist/browser/modules/stream/streams.browser.d.ts

@@ -10,11 +10,11 @@
  * - Safari >= 14.1
  * - Edge >= 89
  */
-import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, DataChunk, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "@stream/types";
+import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "@stream/types";
 import type { Writable as NodeWritable } from "stream";
 import { EventEmitter } from "@stream/event-emitter";
-import { PullStream as StandalonePullStream, type PullStreamOptions as StandalonePullStreamOptions } from "@stream/pull-stream";
-import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "@stream/buffered-stream";
+import { PullStream } from "@stream/pull-stream";
+import { BufferedStream, BufferChunk, StringChunk } from "@stream/buffered-stream";
 /**
  * A wrapper around Web ReadableStream that provides Node.js-like API
  */
@@ -27,6 +27,7 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _bufferSize;
     private _reading;
     private _ended;
+    private _endEmitted;
     private _destroyed;
     private _errored;
     private _closed;
@@ -71,6 +72,7 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
      * Push data to the stream (when using controllable stream)
      */
     push(chunk: T | null): boolean;
+    private _emitEndOnce;
     /**
      * 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
@@ -158,7 +160,8 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _startReading;
     /**
      * 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).
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
     /**
@@ -285,10 +288,12 @@ export declare class Writable<T = Uint8Array> extends EventEmitter {
     private _closed;
     private _pendingWrites;
     private _writableLength;
+    private _needDrain;
     private _corked;
     private _corkedChunks;
     private _defaultEncoding;
     private _aborted;
+    private _ownsStream;
     private _writeFunc?;
     private _finalFunc?;
     readonly objectMode: boolean;
@@ -398,53 +403,46 @@ export declare function normalizeWritable<T = Uint8Array>(stream: WritableLike |
  * A wrapper around Web TransformStream that provides Node.js-like API
  */
 export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extends EventEmitter {
-    private _stream;
     /** @internal - for pipe() support */
     readonly _readable: Readable<TOutput>;
     /** @internal - for pipe() support */
     readonly _writable: Writable<TInput>;
     readonly objectMode: boolean;
-    private _ended;
     private _destroyed;
+    private _ended;
     private _errored;
-    private _pushBuffer;
-    private _transformController;
-    private _pendingEndWrites;
-    private _endPending;
+    private _dataForwardingSetup;
+    private _endTimer;
+    private _webStream;
+    private _sideForwardingCleanup;
+    private _transformImpl;
+    private _flushImpl;
     /**
-     * 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: TOutput | null): boolean;
     constructor(options?: TransformStreamOptions & {
         transform?: ((chunk: TInput) => TOutput | Promise<TOutput>) | ((this: Transform<TInput, TOutput>, chunk: TInput, encoding: string, callback: (error?: Error | null, data?: TOutput) => void) => void);
         flush?: (() => TOutput | void | Promise<TOutput | void>) | ((this: Transform<TInput, TOutput>, callback: (error?: Error | null, data?: TOutput) => void) => void);
     });
-    private _dataForwardingSetup;
+    private _setupSideForwarding;
+    private _scheduleEnd;
+    private _emitErrorOnce;
+    private _hasSubclassTransform;
+    private _hasSubclassFlush;
+    private _runTransform;
+    private _runFlush;
     /**
-     * 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: string | symbol, listener: (...args: any[]) => void): this;
-    /** @internal - whether we have a data event consumer */
-    private _hasDataConsumer;
     /**
-     * Write data to the transform stream
-     * Note: Automatically starts consuming readable if no consumer to allow
-     * transform function to execute (Web Streams backpressure compatibility)
+     * Write to the writable side
      */
     write(chunk: TInput, callback?: (error?: Error | null) => void): boolean;
     write(chunk: TInput, encoding?: string, callback?: (error?: Error | null) => void): boolean;
-    /** @internal - whether we're auto-consuming the readable */
-    private _readableConsuming;
-    /** @internal - buffer for auto-consumed data */
-    private _autoConsumedBuffer;
-    private _autoConsumedBufferIndex;
-    /** @internal - whether auto-consume has ended */
-    private _autoConsumeEnded;
-    /** @internal - promise that resolves when auto-consume finishes */
-    private _autoConsumePromise;
-    /** @internal - auto-consume readable to allow transform to execute */
-    private _startAutoConsume;
     /**
      * End the transform stream
      * Delays closing to allow writes during data events to complete
@@ -456,10 +454,8 @@ export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extend
      * Read from the transform stream
      */
     read(size?: number): TOutput | null;
-    /** @internal - list of piped destinations for forwarding auto-consumed data */
-    private _pipeDestinations;
     /**
-     * Pipe to another stream (writable, transform, or duplex)
+     * Pipe readable side to destination
      */
     pipe<W extends Writable<TOutput> | Transform<TOutput, any> | Duplex<any, TOutput>>(destination: W): W;
     /**
@@ -554,6 +550,7 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         writable: WritableStream<W>;
     };
     private _dataForwardingSetup;
+    private _sideForwardingCleanup;
     constructor(options?: DuplexStreamOptions & {
         allowHalfOpen?: boolean;
         objectMode?: boolean;
@@ -561,6 +558,7 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         write?: (this: Duplex<TRead, TWrite>, chunk: TWrite, encoding: string, callback: (error?: Error | null) => void) => void;
         final?: (this: Duplex<TRead, TWrite>, callback: (error?: Error | null) => void) => void;
     });
+    private _setupSideForwarding;
     /**
      * Override on() to set up data forwarding lazily
      */
@@ -669,16 +667,7 @@ export declare class Collector<T = Uint8Array> extends Writable<T> {
     toString(): string;
     get isFinished(): boolean;
 }
-export declare class PullStream extends StandalonePullStream {
-    constructor(options?: PullStreamOptions | StandalonePullStreamOptions);
-}
-export declare class StringChunk extends StandaloneStringChunk implements DataChunk {
-}
-export declare class BufferChunk extends StandaloneBufferChunk implements DataChunk {
-}
-export declare class BufferedStream extends StandaloneBufferedStream {
-    constructor(options?: BufferedStreamOptions);
-}
+export { PullStream, BufferedStream, StringChunk, BufferChunk };
 /**
  * Create a readable stream with custom read implementation
  */
@@ -935,4 +924,3 @@ export declare const promises: {
     pipeline: typeof pipeline;
     finished: typeof finished;
 };
-export {};