@libp2p/interface 0.0.1-8b0e6bef → 0.0.1-b36ec7f2

package/dist/src/stream-muxer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/stream-muxer/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,WAAW,CAAA;CAC3D;AAED;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,cAAc,GAAG,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACzH;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAA;IAC1B;;;OAGG;IACH,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAEtD;;OAEG;IACH,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;CAC7B;AAED,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAE3C;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAEtC;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/stream-muxer/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,WAAW,CAAA;CAC3D;AAED;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,cAAc,GAAG,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACzH;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAA;IAC1B;;;OAGG;IACH,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAEtD;;OAEG;IACH,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhD;;OAEG;IACH,KAAK,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAE3C;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAEtC;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB"}

package/dist/src/stream-muxer/stream.d.ts

@@ -1,6 +1,13 @@
 import { Uint8ArrayList } from 'uint8arraylist';
-import type { Direction, Stream, StreamStat } from '../connection/index.js';
+import type { Direction, ReadStatus, Stream, StreamStatus, StreamTimeline, WriteStatus } from '../connection/index.js';
+import type { AbortOptions } from '../index.js';
 import type { Source } from 'it-stream-types';
+interface Logger {
+    (formatter: any, ...args: any[]): void;
+    error: (formatter: any, ...args: any[]) => void;
+    trace: (formatter: any, ...args: any[]) => void;
+    enabled: boolean;
+}
 export interface AbstractStreamInit {
     /**
      * A unique identifier for this stream
@@ -11,10 +18,9 @@ export interface AbstractStreamInit {
      */
     direction: Direction;
     /**
-     * The maximum allowable data size, any data larger than this will be
-     * chunked and sent in multiple data messages
+     * A Logger implementation used to log stream-specific information
      */
-    maxDataSize: number;
+    log: Logger;
     /**
      * User specific stream metadata
      */
@@ -23,31 +29,83 @@ export interface AbstractStreamInit {
      * Invoked when the stream ends
      */
     onEnd?: (err?: Error | undefined) => void;
+    /**
+     * Invoked when the readable end of the stream is closed
+     */
+    onCloseRead?: () => void;
+    /**
+     * Invoked when the writable end of the stream is closed
+     */
+    onCloseWrite?: () => void;
+    /**
+     * Invoked when the the stream has been reset by the remote
+     */
+    onReset?: () => void;
+    /**
+     * Invoked when the the stream has errored
+     */
+    onAbort?: (err: Error) => void;
+    /**
+     * How long to wait in ms for stream data to be written to the underlying
+     * connection when closing the writable end of the stream. (default: 500)
+     */
+    closeTimeout?: number;
 }
 export declare abstract class AbstractStream implements Stream {
     id: string;
-    stat: StreamStat;
+    direction: Direction;
+    timeline: StreamTimeline;
+    protocol?: string;
     metadata: Record<string, unknown>;
     source: AsyncGenerator<Uint8ArrayList, void, unknown>;
-    private readonly abortController;
-    private readonly resetController;
-    private readonly closeController;
-    private sourceEnded;
-    private sinkEnded;
-    private sinkSunk;
+    status: StreamStatus;
+    readStatus: ReadStatus;
+    writeStatus: WriteStatus;
+    private readonly sinkController;
+    private readonly sinkEnd;
     private endErr;
     private readonly streamSource;
     private readonly onEnd?;
-    private readonly maxDataSize;
+    private readonly onCloseRead?;
+    private readonly onCloseWrite?;
+    private readonly onReset?;
+    private readonly onAbort?;
+    protected readonly log: Logger;
     constructor(init: AbstractStreamInit);
+    sink(source: Source<Uint8ArrayList | Uint8Array>): Promise<void>;
     protected onSourceEnd(err?: Error): void;
     protected onSinkEnd(err?: Error): void;
-    close(): void;
-    closeRead(): void;
-    closeWrite(): void;
+    close(options?: AbortOptions): Promise<void>;
+    closeRead(options?: AbortOptions): Promise<void>;
+    closeWrite(options?: AbortOptions): Promise<void>;
+    /**
+     * Close immediately for reading and writing and send a reset message (local
+     * error)
+     */
     abort(err: Error): void;
+    /**
+     * Receive a reset message - close immediately for reading and writing (remote
+     * error)
+     */
     reset(): void;
-    sink(source: Source<Uint8ArrayList | Uint8Array>): Promise<void>;
+    _closeSinkAndSource(err?: Error): void;
+    _closeSink(err?: Error): void;
+    _closeSource(err?: Error): void;
+    /**
+     * The remote closed for writing so we should expect to receive no more
+     * messages
+     */
+    remoteCloseWrite(): void;
+    /**
+     * The remote closed for reading so we should not send any more
+     * messages
+     */
+    remoteCloseRead(): void;
+    /**
+     * The underlying muxer has closed, no more messages can be sent or will
+     * be received, close immediately to free up resources
+     */
+    destroy(): void;
     /**
      * When an extending class reads data from it's implementation-specific source,
      * call this method to allow the stream consumer to read the data.
@@ -62,24 +120,25 @@ export declare abstract class AbstractStream implements Stream {
      * Send a message to the remote muxer informing them a new stream is being
      * opened
      */
-    abstract sendNewStream(): void | Promise<void>;
+    abstract sendNewStream(options?: AbortOptions): void | Promise<void>;
     /**
      * Send a data message to the remote muxer
      */
-    abstract sendData(buf: Uint8ArrayList): void | Promise<void>;
+    abstract sendData(buf: Uint8ArrayList, options?: AbortOptions): void | Promise<void>;
     /**
      * Send a reset message to the remote muxer
      */
-    abstract sendReset(): void | Promise<void>;
+    abstract sendReset(options?: AbortOptions): void | Promise<void>;
     /**
      * Send a message to the remote muxer, informing them no more data messages
      * will be sent by this end of the stream
      */
-    abstract sendCloseWrite(): void | Promise<void>;
+    abstract sendCloseWrite(options?: AbortOptions): void | Promise<void>;
     /**
      * Send a message to the remote muxer, informing them no more data messages
      * will be read by this end of the stream
      */
-    abstract sendCloseRead(): void | Promise<void>;
+    abstract sendCloseRead(options?: AbortOptions): void | Promise<void>;
 }
+export {};
 //# sourceMappingURL=stream.d.ts.map

package/dist/src/stream-muxer/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/stream-muxer/stream.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAa7C,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,EAAE,EAAE,MAAM,CAAA;IAEV;;OAEG;IACH,SAAS,EAAE,SAAS,CAAA;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAElC;;OAEG;IACH,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,KAAK,IAAI,CAAA;CAC1C;AAMD,8BAAsB,cAAe,YAAW,MAAM;IAC7C,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,MAAM,EAAE,cAAc,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;IAE5D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IACjD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;IACvD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAmC;IAC1D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;gBAEvB,IAAI,EAAE,kBAAkB;IAwCrC,SAAS,CAAC,WAAW,CAAE,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI;IAsBzC,SAAS,CAAC,SAAS,CAAE,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI;IAuBvC,KAAK,IAAK,IAAI;IAQd,SAAS,IAAK,IAAI;IAWlB,UAAU,IAAK,IAAI;IA2BnB,KAAK,CAAE,GAAG,EAAE,KAAK,GAAG,IAAI;IASxB,KAAK,IAAK,IAAI;IAOR,IAAI,CAAE,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAyGvE;;;OAGG;IACH,UAAU,CAAE,IAAI,EAAE,cAAc,GAAG,IAAI;IAIvC;;;OAGG;IACH,oBAAoB,IAAK,MAAM;IAI/B;;;OAGG;IACH,QAAQ,CAAC,aAAa,IAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE/C;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAE,GAAG,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE7D;;OAEG;IACH,QAAQ,CAAC,SAAS,IAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3C;;;OAGG;IACH,QAAQ,CAAC,cAAc,IAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEhD;;;OAGG;IACH,QAAQ,CAAC,aAAa,IAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAChD"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/stream-muxer/stream.ts"],"names":[],"mappings":"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"}

package/dist/src/stream-muxer/stream.js

@@ -1,241 +1,297 @@
-// import { logger } from '@libp2p/logger'
 import { abortableSource } from 'abortable-iterator';
-import { anySignal } from 'any-signal';
 import { pushable } from 'it-pushable';
+import defer from 'p-defer';
 import { Uint8ArrayList } from 'uint8arraylist';
 import { CodeError } from '../errors.js';
-// const log = logger('libp2p:stream')
-const log = () => { };
-log.trace = () => { };
-log.error = () => { };
 const ERR_STREAM_RESET = 'ERR_STREAM_RESET';
-const ERR_STREAM_ABORT = 'ERR_STREAM_ABORT';
-const ERR_SINK_ENDED = 'ERR_SINK_ENDED';
-const ERR_DOUBLE_SINK = 'ERR_DOUBLE_SINK';
+const ERR_SINK_INVALID_STATE = 'ERR_SINK_INVALID_STATE';
 function isPromise(res) {
     return res != null && typeof res.then === 'function';
 }
 export class AbstractStream {
     id;
-    stat;
+    direction;
+    timeline;
+    protocol;
     metadata;
     source;
-    abortController;
-    resetController;
-    closeController;
-    sourceEnded;
-    sinkEnded;
-    sinkSunk;
+    status;
+    readStatus;
+    writeStatus;
+    sinkController;
+    sinkEnd;
     endErr;
     streamSource;
     onEnd;
-    maxDataSize;
+    onCloseRead;
+    onCloseWrite;
+    onReset;
+    onAbort;
+    log;
     constructor(init) {
-        this.abortController = new AbortController();
-        this.resetController = new AbortController();
-        this.closeController = new AbortController();
-        this.sourceEnded = false;
-        this.sinkEnded = false;
-        this.sinkSunk = false;
+        this.sinkController = new AbortController();
+        this.sinkEnd = defer();
+        this.log = init.log;
+        // stream status
+        this.status = 'open';
+        this.readStatus = 'ready';
+        this.writeStatus = 'ready';
         this.id = init.id;
         this.metadata = init.metadata ?? {};
-        this.stat = {
-            direction: init.direction,
-            timeline: {
-                open: Date.now()
-            }
+        this.direction = init.direction;
+        this.timeline = {
+            open: Date.now()
         };
-        this.maxDataSize = init.maxDataSize;
         this.onEnd = init.onEnd;
+        this.onCloseRead = init?.onCloseRead;
+        this.onCloseWrite = init?.onCloseWrite;
+        this.onReset = init?.onReset;
+        this.onAbort = init?.onAbort;
         this.source = this.streamSource = pushable({
-            onEnd: () => {
-                // already sent a reset message
-                if (this.stat.timeline.reset !== null) {
-                    const res = this.sendCloseRead();
-                    if (isPromise(res)) {
-                        res.catch(err => {
-                            log.error('error while sending close read', err);
-                        });
-                    }
+            onEnd: (err) => {
+                if (err != null) {
+                    this.log.trace('source ended with error', err);
+                }
+                else {
+                    this.log.trace('source ended');
                 }
-                this.onSourceEnd();
+                this.readStatus = 'closed';
+                this.onSourceEnd(err);
             }
         });
         // necessary because the libp2p upgrader wraps the sink function
         this.sink = this.sink.bind(this);
     }
+    async sink(source) {
+        if (this.writeStatus !== 'ready') {
+            throw new CodeError(`writable end state is "${this.writeStatus}" not "ready"`, ERR_SINK_INVALID_STATE);
+        }
+        try {
+            this.writeStatus = 'writing';
+            const options = {
+                signal: this.sinkController.signal
+            };
+            if (this.direction === 'outbound') { // If initiator, open a new stream
+                const res = this.sendNewStream(options);
+                if (isPromise(res)) {
+                    await res;
+                }
+            }
+            source = abortableSource(source, this.sinkController.signal, {
+                returnOnAbort: true
+            });
+            this.log.trace('sink reading from source');
+            for await (let data of source) {
+                data = data instanceof Uint8Array ? new Uint8ArrayList(data) : data;
+                const res = this.sendData(data, options);
+                if (isPromise(res)) { // eslint-disable-line max-depth
+                    await res;
+                }
+            }
+            this.log.trace('sink finished reading from source');
+            this.writeStatus = 'done';
+            this.log.trace('sink calling closeWrite');
+            await this.closeWrite(options);
+            this.onSinkEnd();
+        }
+        catch (err) {
+            this.log.trace('sink ended with error, calling abort with error', err);
+            this.abort(err);
+            throw err;
+        }
+        finally {
+            this.log.trace('resolve sink end');
+            this.sinkEnd.resolve();
+        }
+    }
     onSourceEnd(err) {
-        if (this.sourceEnded) {
+        if (this.timeline.closeRead != null) {
             return;
         }
-        this.stat.timeline.closeRead = Date.now();
-        this.sourceEnded = true;
-        log.trace('%s stream %s source end - err: %o', this.stat.direction, this.id, err);
+        this.timeline.closeRead = Date.now();
         if (err != null && this.endErr == null) {
             this.endErr = err;
         }
-        if (this.sinkEnded) {
-            this.stat.timeline.close = Date.now();
+        this.onCloseRead?.();
+        if (this.timeline.closeWrite != null) {
+            this.log.trace('source and sink ended');
+            this.timeline.close = Date.now();
             if (this.onEnd != null) {
                 this.onEnd(this.endErr);
             }
         }
+        else {
+            this.log.trace('source ended, waiting for sink to end');
+        }
     }
     onSinkEnd(err) {
-        if (this.sinkEnded) {
+        if (this.timeline.closeWrite != null) {
             return;
         }
-        this.stat.timeline.closeWrite = Date.now();
-        this.sinkEnded = true;
-        log.trace('%s stream %s sink end - err: %o', this.stat.direction, this.id, err);
+        this.timeline.closeWrite = Date.now();
         if (err != null && this.endErr == null) {
             this.endErr = err;
         }
-        if (this.sourceEnded) {
-            this.stat.timeline.close = Date.now();
+        this.onCloseWrite?.();
+        if (this.timeline.closeRead != null) {
+            this.log.trace('sink and source ended');
+            this.timeline.close = Date.now();
             if (this.onEnd != null) {
                 this.onEnd(this.endErr);
             }
         }
+        else {
+            this.log.trace('sink ended, waiting for source to end');
+        }
     }
     // Close for both Reading and Writing
-    close() {
-        log.trace('%s stream %s close', this.stat.direction, this.id);
-        this.closeRead();
-        this.closeWrite();
-    }
-    // Close for reading
-    closeRead() {
-        log.trace('%s stream %s closeRead', this.stat.direction, this.id);
-        if (this.sourceEnded) {
+    async close(options) {
+        this.log.trace('closing gracefully');
+        this.status = 'closing';
+        await Promise.all([
+            this.closeRead(options),
+            this.closeWrite(options)
+        ]);
+        this.status = 'closed';
+        this.log.trace('closed gracefully');
+    }
+    async closeRead(options = {}) {
+        if (this.readStatus === 'closing' || this.readStatus === 'closed') {
             return;
         }
-        this.streamSource.end();
+        this.log.trace('closing readable end of stream with starting read status "%s"', this.readStatus);
+        const readStatus = this.readStatus;
+        this.readStatus = 'closing';
+        if (readStatus === 'ready') {
+            this.log.trace('ending internal source queue');
+            this.streamSource.end();
+        }
+        if (this.status !== 'reset' && this.status !== 'aborted') {
+            this.log.trace('send close read to remote');
+            await this.sendCloseRead(options);
+        }
+        this.log.trace('closed readable end of stream');
     }
-    // Close for writing
-    closeWrite() {
-        log.trace('%s stream %s closeWrite', this.stat.direction, this.id);
-        if (this.sinkEnded) {
+    async closeWrite(options = {}) {
+        if (this.writeStatus === 'closing' || this.writeStatus === 'closed') {
             return;
         }
-        this.closeController.abort();
-        try {
-            // need to call this here as the sink method returns in the catch block
-            // when the close controller is aborted
-            const res = this.sendCloseWrite();
-            if (isPromise(res)) {
-                res.catch(err => {
-                    log.error('error while sending close write', err);
+        this.log.trace('closing writable end of stream with starting write status "%s"', this.writeStatus);
+        const writeStatus = this.writeStatus;
+        if (this.writeStatus === 'ready') {
+            this.log.trace('sink was never sunk, sink an empty array');
+            await this.sink([]);
+        }
+        this.writeStatus = 'closing';
+        if (writeStatus === 'writing') {
+            // stop reading from the source passed to `.sink` in the microtask queue
+            // - this lets any data queued by the user in the current tick get read
+            // before we exit
+            await new Promise((resolve, reject) => {
+                queueMicrotask(() => {
+                    this.log.trace('aborting source passed to .sink');
+                    this.sinkController.abort();
+                    this.sinkEnd.promise.then(resolve, reject);
                 });
-            }
+            });
         }
-        catch (err) {
-            log.trace('%s stream %s error sending close', this.stat.direction, this.id, err);
+        if (this.status !== 'reset' && this.status !== 'aborted') {
+            this.log.trace('send close write to remote');
+            await this.sendCloseWrite(options);
         }
-        this.onSinkEnd();
+        this.writeStatus = 'closed';
+        this.log.trace('closed writable end of stream');
     }
-    // Close for reading and writing (local error)
+    /**
+     * Close immediately for reading and writing and send a reset message (local
+     * error)
+     */
     abort(err) {
-        log.trace('%s stream %s abort', this.stat.direction, this.id, err);
-        // End the source with the passed error
-        this.streamSource.end(err);
-        this.abortController.abort();
-        this.onSinkEnd(err);
+        if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+            return;
+        }
+        this.log('abort with error', err);
+        // try to send a reset message
+        this.log('try to send reset to remote');
+        const res = this.sendReset();
+        if (isPromise(res)) {
+            res.catch((err) => {
+                this.log.error('error sending reset message', err);
+            });
+        }
+        this.status = 'aborted';
+        this.timeline.abort = Date.now();
+        this._closeSinkAndSource(err);
+        this.onAbort?.(err);
     }
-    // Close immediately for reading and writing (remote error)
+    /**
+     * Receive a reset message - close immediately for reading and writing (remote
+     * error)
+     */
     reset() {
+        if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+            return;
+        }
         const err = new CodeError('stream reset', ERR_STREAM_RESET);
-        this.resetController.abort();
-        this.streamSource.end(err);
-        this.onSinkEnd(err);
+        this.status = 'reset';
+        this._closeSinkAndSource(err);
+        this.onReset?.();
     }
-    async sink(source) {
-        if (this.sinkSunk) {
-            throw new CodeError('sink already called on stream', ERR_DOUBLE_SINK);
-        }
-        this.sinkSunk = true;
-        if (this.sinkEnded) {
-            throw new CodeError('stream closed for writing', ERR_SINK_ENDED);
-        }
-        const signal = anySignal([
-            this.abortController.signal,
-            this.resetController.signal,
-            this.closeController.signal
-        ]);
-        try {
-            source = abortableSource(source, signal);
-            if (this.stat.direction === 'outbound') { // If initiator, open a new stream
-                const res = this.sendNewStream();
-                if (isPromise(res)) {
-                    await res;
-                }
-            }
-            for await (let data of source) {
-                while (data.length > 0) {
-                    if (data.length <= this.maxDataSize) {
-                        const res = this.sendData(data instanceof Uint8Array ? new Uint8ArrayList(data) : data);
-                        if (isPromise(res)) { // eslint-disable-line max-depth
-                            await res;
-                        }
-                        break;
-                    }
-                    data = data instanceof Uint8Array ? new Uint8ArrayList(data) : data;
-                    const res = this.sendData(data.sublist(0, this.maxDataSize));
-                    if (isPromise(res)) {
-                        await res;
-                    }
-                    data.consume(this.maxDataSize);
-                }
-            }
+    _closeSinkAndSource(err) {
+        this._closeSink(err);
+        this._closeSource(err);
+    }
+    _closeSink(err) {
+        // if the sink function is running, cause it to end
+        if (this.writeStatus === 'writing') {
+            this.log.trace('end sink source');
+            this.sinkController.abort();
         }
-        catch (err) {
-            if (err.type === 'aborted' && err.message === 'The operation was aborted') {
-                if (this.closeController.signal.aborted) {
-                    return;
-                }
-                if (this.resetController.signal.aborted) {
-                    err.message = 'stream reset';
-                    err.code = ERR_STREAM_RESET;
-                }
-                if (this.abortController.signal.aborted) {
-                    err.message = 'stream aborted';
-                    err.code = ERR_STREAM_ABORT;
-                }
-            }
-            // Send no more data if this stream was remotely reset
-            if (err.code === ERR_STREAM_RESET) {
-                log.trace('%s stream %s reset', this.stat.direction, this.id);
-            }
-            else {
-                log.trace('%s stream %s error', this.stat.direction, this.id, err);
-                try {
-                    const res = this.sendReset();
-                    if (isPromise(res)) {
-                        await res;
-                    }
-                    this.stat.timeline.reset = Date.now();
-                }
-                catch (err) {
-                    log.trace('%s stream %s error sending reset', this.stat.direction, this.id, err);
-                }
-            }
+        this.onSinkEnd(err);
+    }
+    _closeSource(err) {
+        // if the source is not ending, end it
+        if (this.readStatus !== 'closing' && this.readStatus !== 'closed') {
+            this.log.trace('ending source with %d bytes to be read by consumer', this.streamSource.readableLength);
+            this.readStatus = 'closing';
             this.streamSource.end(err);
-            this.onSinkEnd(err);
-            throw err;
         }
-        finally {
-            signal.clear();
+    }
+    /**
+     * The remote closed for writing so we should expect to receive no more
+     * messages
+     */
+    remoteCloseWrite() {
+        if (this.readStatus === 'closing' || this.readStatus === 'closed') {
+            this.log('received remote close write but local source is already closed');
+            return;
         }
-        try {
-            const res = this.sendCloseWrite();
-            if (isPromise(res)) {
-                await res;
-            }
+        this.log.trace('remote close write');
+        this._closeSource();
+    }
+    /**
+     * The remote closed for reading so we should not send any more
+     * messages
+     */
+    remoteCloseRead() {
+        if (this.writeStatus === 'closing' || this.writeStatus === 'closed') {
+            this.log('received remote close read but local sink is already closed');
+            return;
         }
-        catch (err) {
-            log.trace('%s stream %s error sending close', this.stat.direction, this.id, err);
+        this.log.trace('remote close read');
+        this._closeSink();
+    }
+    /**
+     * The underlying muxer has closed, no more messages can be sent or will
+     * be received, close immediately to free up resources
+     */
+    destroy() {
+        if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+            this.log('received destroy but we are already closed');
+            return;
         }
-        this.onSinkEnd();
+        this.log.trace('muxer destroyed');
+        this._closeSinkAndSource();
     }
     /**
      * When an extending class reads data from it's implementation-specific source,