@libp2p/utils 4.0.7-05b52d69c → 4.0.7-0b4a2ee79

package/dist/src/stream-to-ma-conn.js

@@ -4,48 +4,71 @@
  */
 export function streamToMaConnection(props) {
     const { stream, remoteAddr, logger } = props;
-    const { sink, source } = stream;
     const log = logger.forComponent('libp2p:stream:converter');
-    const mapSource = (async function* () {
-        for await (const list of source) {
-            if (list instanceof Uint8Array) {
-                yield list;
-            }
-            else {
-                yield* list;
+    let closedRead = false;
+    let closedWrite = false;
+    // piggyback on `stream.close` invocations to close maconn
+    const streamClose = stream.close.bind(stream);
+    stream.close = async (options) => {
+        await streamClose(options);
+        close(true);
+    };
+    // piggyback on `stream.abort` invocations to close maconn
+    const streamAbort = stream.abort.bind(stream);
+    stream.abort = (err) => {
+        streamAbort(err);
+        close(true);
+    };
+    // piggyback on `stream.sink` invocations to close maconn
+    const streamSink = stream.sink.bind(stream);
+    stream.sink = async (source) => {
+        try {
+            await streamSink(source);
+        }
+        catch (err) {
+            // If aborted we can safely ignore
+            if (err.type !== 'aborted') {
+                // If the source errored the socket will already have been destroyed by
+                // toIterable.duplex(). If the socket errored it will already be
+                // destroyed. There's nothing to do here except log the error & return.
+                log(err);
             }
         }
-    }());
+        finally {
+            closedWrite = true;
+            close();
+        }
+    };
     const maConn = {
-        async sink(source) {
+        log,
+        sink: stream.sink,
+        source: (async function* () {
             try {
-                await sink(source);
-                close();
-            }
-            catch (err) {
-                // If aborted we can safely ignore
-                if (err.type !== 'aborted') {
-                    // If the source errored the socket will already have been destroyed by
-                    // toIterable.duplex(). If the socket errored it will already be
-                    // destroyed. There's nothing to do here except log the error & return.
-                    log(err);
+                for await (const list of stream.source) {
+                    if (list instanceof Uint8Array) {
+                        yield list;
+                    }
+                    else {
+                        yield* list;
+                    }
                 }
             }
-        },
-        source: mapSource,
+            finally {
+                closedRead = true;
+                close();
+            }
+        }()),
         remoteAddr,
         timeline: { open: Date.now(), close: undefined },
-        async close(options) {
-            close();
-            await stream.close(options);
-        },
-        abort(err) {
-            close();
-            stream.abort(err);
-        }
+        close: stream.close,
+        abort: stream.abort
     };
-    function close() {
-        if (maConn.timeline.close == null) {
+    function close(force) {
+        if (force === true) {
+            closedRead = true;
+            closedWrite = true;
+        }
+        if (closedRead && closedWrite && maConn.timeline.close == null) {
             maConn.timeline.close = Date.now();
         }
     }

package/dist/src/stream-to-ma-conn.js.map

@@ -1 +1 @@
-{"version":3,"file":"stream-to-ma-conn.js","sourceRoot":"","sources":["../../src/stream-to-ma-conn.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAE,KAAuB;IAC3D,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,KAAK,CAAA;IAC5C,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAA;IAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAA;IAE1D,MAAM,SAAS,GAAG,CAAC,KAAK,SAAU,CAAC;QACjC,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,MAAM,EAAE;YAC/B,IAAI,IAAI,YAAY,UAAU,EAAE;gBAC9B,MAAM,IAAI,CAAA;aACX;iBAAM;gBACL,KAAM,CAAC,CAAC,IAAI,CAAA;aACb;SACF;IACH,CAAC,EAAE,CAAC,CAAA;IAEJ,MAAM,MAAM,GAAwB;QAClC,KAAK,CAAC,IAAI,CAAE,MAAM;YAChB,IAAI;gBACF,MAAM,IAAI,CAAC,MAAM,CAAC,CAAA;gBAClB,KAAK,EAAE,CAAA;aACR;YAAC,OAAO,GAAQ,EAAE;gBACjB,kCAAkC;gBAClC,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE;oBAC1B,uEAAuE;oBACvE,gEAAgE;oBAChE,uEAAuE;oBACvE,GAAG,CAAC,GAAG,CAAC,CAAA;iBACT;aACF;QACH,CAAC;QACD,MAAM,EAAE,SAAS;QACjB,UAAU;QACV,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAChD,KAAK,CAAC,KAAK,CAAE,OAAsB;YACjC,KAAK,EAAE,CAAA;YACP,MAAM,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QAC7B,CAAC;QACD,KAAK,CAAE,GAAU;YACf,KAAK,EAAE,CAAA;YACP,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACnB,CAAC;KACF,CAAA;IAED,SAAS,KAAK;QACZ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,EAAE;YACjC,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;SACnC;IACH,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC"}
+{"version":3,"file":"stream-to-ma-conn.js","sourceRoot":"","sources":["../../src/stream-to-ma-conn.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAE,KAAuB;IAC3D,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,KAAK,CAAA;IAC5C,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAA;IAE1D,IAAI,UAAU,GAAG,KAAK,CAAA;IACtB,IAAI,WAAW,GAAG,KAAK,CAAA;IAEvB,0DAA0D;IAC1D,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAC7C,MAAM,CAAC,KAAK,GAAG,KAAK,EAAE,OAAO,EAAE,EAAE;QAC/B,MAAM,WAAW,CAAC,OAAO,CAAC,CAAA;QAC1B,KAAK,CAAC,IAAI,CAAC,CAAA;IACb,CAAC,CAAA;IAED,0DAA0D;IAC1D,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAC7C,MAAM,CAAC,KAAK,GAAG,CAAC,GAAG,EAAE,EAAE;QACrB,WAAW,CAAC,GAAG,CAAC,CAAA;QAChB,KAAK,CAAC,IAAI,CAAC,CAAA;IACb,CAAC,CAAA;IAED,yDAAyD;IACzD,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAC3C,MAAM,CAAC,IAAI,GAAG,KAAK,EAAE,MAAM,EAAE,EAAE;QAC7B,IAAI;YACF,MAAM,UAAU,CAAC,MAAM,CAAC,CAAA;SACzB;QAAC,OAAO,GAAQ,EAAE;YACjB,kCAAkC;YAClC,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE;gBAC1B,uEAAuE;gBACvE,gEAAgE;gBAChE,uEAAuE;gBACvE,GAAG,CAAC,GAAG,CAAC,CAAA;aACT;SACF;gBAAS;YACR,WAAW,GAAG,IAAI,CAAA;YAClB,KAAK,EAAE,CAAA;SACR;IACH,CAAC,CAAA;IAED,MAAM,MAAM,GAAwB;QAClC,GAAG;QACH,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,MAAM,EAAE,CAAC,KAAK,SAAU,CAAC;YACvB,IAAI;gBACF,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE;oBACtC,IAAI,IAAI,YAAY,UAAU,EAAE;wBAC9B,MAAM,IAAI,CAAA;qBACX;yBAAM;wBACL,KAAM,CAAC,CAAC,IAAI,CAAA;qBACb;iBACF;aACF;oBAAS;gBACR,UAAU,GAAG,IAAI,CAAA;gBACjB,KAAK,EAAE,CAAA;aACR;QACH,CAAC,EAAE,CAAC;QACJ,UAAU;QACV,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAChD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,KAAK,EAAE,MAAM,CAAC,KAAK;KACpB,CAAA;IAED,SAAS,KAAK,CAAE,KAAe;QAC7B,IAAI,KAAK,KAAK,IAAI,EAAE;YAClB,UAAU,GAAG,IAAI,CAAA;YACjB,WAAW,GAAG,IAAI,CAAA;SACnB;QAED,IAAI,UAAU,IAAI,WAAW,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,EAAE;YAC9D,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;SACnC;IACH,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@libp2p/utils",
-  "version": "4.0.7-05b52d69c",
+  "version": "4.0.7-0b4a2ee79",
   "description": "Package to aggregate shared logic and dependencies for the libp2p ecosystem",
   "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/utils#readme",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/utils#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/libp2p/js-libp2p.git"
@@ -40,6 +40,10 @@
       "types": "./src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./abstract-stream": {
+      "types": "./dist/src/abstract-stream.d.ts",
+      "import": "./dist/src/abstract-stream.js"
+    },
     "./address-sort": {
       "types": "./dist/src/address-sort.d.ts",
       "import": "./dist/src/address-sort.js"
@@ -48,10 +52,18 @@
       "types": "./dist/src/array-equals.d.ts",
       "import": "./dist/src/array-equals.js"
     },
+    "./close-source": {
+      "types": "./dist/src/close-source.d.ts",
+      "import": "./dist/src/close-source.js"
+    },
     "./ip-port-to-multiaddr": {
       "types": "./dist/src/ip-port-to-multiaddr.d.ts",
       "import": "./dist/src/ip-port-to-multiaddr.js"
     },
+    "./is-promise": {
+      "types": "./dist/src/is-promise.d.ts",
+      "import": "./dist/src/is-promise.js"
+    },
     "./multiaddr/is-loopback": {
       "types": "./dist/src/multiaddr/is-loopback.d.ts",
       "import": "./dist/src/multiaddr/is-loopback.js"
@@ -91,23 +103,30 @@
   },
   "dependencies": {
     "@chainsafe/is-ip": "^2.0.2",
-    "@libp2p/interface": "0.1.6-05b52d69c",
+    "@libp2p/interface": "0.1.6-0b4a2ee79",
     "@multiformats/multiaddr": "^12.1.10",
     "@multiformats/multiaddr-matcher": "^1.1.0",
+    "get-iterator": "^2.0.1",
     "is-loopback-addr": "^2.0.1",
+    "it-pushable": "^3.2.2",
     "it-stream-types": "^2.0.1",
     "p-queue": "^7.4.1",
     "private-ip": "^3.0.1",
+    "race-signal": "^1.0.1",
     "uint8arraylist": "^2.4.3"
   },
   "devDependencies": {
-    "@libp2p/logger": "3.1.0-05b52d69c",
-    "@libp2p/peer-id-factory": "3.0.8-05b52d69c",
+    "@libp2p/logger": "3.1.0-0b4a2ee79",
+    "@libp2p/peer-id-factory": "3.0.8-0b4a2ee79",
     "aegir": "^41.0.2",
+    "delay": "^6.0.0",
     "it-all": "^3.0.3",
+    "it-drain": "^3.0.5",
     "it-pair": "^2.0.6",
     "it-pipe": "^3.0.1",
     "p-defer": "^4.0.0",
+    "sinon": "^17.0.1",
+    "sinon-ts": "^2.0.0",
     "uint8arrays": "^4.0.6"
   }
 }

package/src/abstract-stream.ts

@@ -0,0 +1,509 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { type Pushable, pushable } from 'it-pushable'
+import defer, { type DeferredPromise } from 'p-defer'
+import { raceSignal } from 'race-signal'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { closeSource } from './close-source.js'
+import type { AbortOptions } from '@libp2p/interface'
+import type { Direction, ReadStatus, Stream, StreamStatus, StreamTimeline, WriteStatus } from '@libp2p/interface/connection'
+import type { Logger } from '@libp2p/logger'
+import type { Source } from 'it-stream-types'
+
+const ERR_STREAM_RESET = 'ERR_STREAM_RESET'
+const ERR_SINK_INVALID_STATE = 'ERR_SINK_INVALID_STATE'
+const DEFAULT_SEND_CLOSE_WRITE_TIMEOUT = 5000
+
+export interface AbstractStreamInit {
+  /**
+   * A unique identifier for this stream
+   */
+  id: string
+
+  /**
+   * The stream direction
+   */
+  direction: Direction
+
+  /**
+   * A Logger implementation used to log stream-specific information
+   */
+  log: Logger
+
+  /**
+   * User specific stream metadata
+   */
+  metadata?: Record<string, unknown>
+
+  /**
+   * 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
+
+  /**
+   * After the stream sink has closed, a limit on how long it takes to send
+   * a close-write message to the remote peer.
+   */
+  sendCloseWriteTimeout?: number
+}
+
+function isPromise <T = unknown> (thing: any): thing is Promise<T> {
+  if (thing == null) {
+    return false
+  }
+
+  return typeof thing.then === 'function' &&
+    typeof thing.catch === 'function' &&
+    typeof thing.finally === 'function'
+}
+
+export abstract class AbstractStream implements Stream {
+  public id: string
+  public direction: Direction
+  public timeline: StreamTimeline
+  public protocol?: string
+  public metadata: Record<string, unknown>
+  public source: AsyncGenerator<Uint8ArrayList, void, unknown>
+  public status: StreamStatus
+  public readStatus: ReadStatus
+  public writeStatus: WriteStatus
+  public readonly log: Logger
+
+  private readonly sinkController: AbortController
+  private readonly sinkEnd: DeferredPromise<void>
+  private readonly closed: DeferredPromise<void>
+  private endErr: Error | undefined
+  private readonly streamSource: Pushable<Uint8ArrayList>
+  private readonly onEnd?: (err?: Error | undefined) => void
+  private readonly onCloseRead?: () => void
+  private readonly onCloseWrite?: () => void
+  private readonly onReset?: () => void
+  private readonly onAbort?: (err: Error) => void
+  private readonly sendCloseWriteTimeout: number
+
+  constructor (init: AbstractStreamInit) {
+    this.sinkController = new AbortController()
+    this.sinkEnd = defer()
+    this.closed = 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.direction = init.direction
+    this.timeline = {
+      open: Date.now()
+    }
+    this.sendCloseWriteTimeout = init.sendCloseWriteTimeout ?? DEFAULT_SEND_CLOSE_WRITE_TIMEOUT
+
+    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<Uint8ArrayList>({
+      onEnd: (err) => {
+        if (err != null) {
+          this.log.trace('source ended with error', err)
+        } else {
+          this.log.trace('source ended')
+        }
+
+        this.onSourceEnd(err)
+      }
+    })
+
+    // necessary because the libp2p upgrader wraps the sink function
+    this.sink = this.sink.bind(this)
+  }
+
+  async sink (source: Source<Uint8ArrayList | Uint8Array>): Promise<void> {
+    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: AbortOptions = {
+        signal: this.sinkController.signal
+      }
+
+      if (this.direction === 'outbound') { // If initiator, open a new stream
+        const res = this.sendNewStream(options)
+
+        if (isPromise(res)) {
+          await res
+        }
+      }
+
+      const abortListener = (): void => {
+        closeSource(source, this.log)
+      }
+
+      try {
+        this.sinkController.signal.addEventListener('abort', abortListener)
+
+        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
+          }
+        }
+      } finally {
+        this.sinkController.signal.removeEventListener('abort', abortListener)
+      }
+
+      this.log.trace('sink finished reading from source, write status is "%s"', this.writeStatus)
+
+      if (this.writeStatus === 'writing') {
+        this.writeStatus = 'closing'
+
+        this.log.trace('send close write to remote')
+        await this.sendCloseWrite({
+          signal: AbortSignal.timeout(this.sendCloseWriteTimeout)
+        })
+
+        this.writeStatus = 'closed'
+      }
+
+      this.onSinkEnd()
+    } catch (err: any) {
+      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()
+    }
+  }
+
+  protected onSourceEnd (err?: Error): void {
+    if (this.timeline.closeRead != null) {
+      return
+    }
+
+    this.timeline.closeRead = Date.now()
+    this.readStatus = 'closed'
+
+    if (err != null && this.endErr == null) {
+      this.endErr = err
+    }
+
+    this.onCloseRead?.()
+
+    if (this.timeline.closeWrite != null) {
+      this.log.trace('source and sink ended')
+      this.timeline.close = Date.now()
+
+      if (this.status !== 'aborted' && this.status !== 'reset') {
+        this.status = 'closed'
+      }
+
+      if (this.onEnd != null) {
+        this.onEnd(this.endErr)
+      }
+
+      this.closed.resolve()
+    } else {
+      this.log.trace('source ended, waiting for sink to end')
+    }
+  }
+
+  protected onSinkEnd (err?: Error): void {
+    if (this.timeline.closeWrite != null) {
+      return
+    }
+
+    this.timeline.closeWrite = Date.now()
+    this.writeStatus = 'closed'
+
+    if (err != null && this.endErr == null) {
+      this.endErr = err
+    }
+
+    this.onCloseWrite?.()
+
+    if (this.timeline.closeRead != null) {
+      this.log.trace('sink and source ended')
+      this.timeline.close = Date.now()
+
+      if (this.status !== 'aborted' && this.status !== 'reset') {
+        this.status = 'closed'
+      }
+
+      if (this.onEnd != null) {
+        this.onEnd(this.endErr)
+      }
+
+      this.closed.resolve()
+    } else {
+      this.log.trace('sink ended, waiting for source to end')
+    }
+  }
+
+  // Close for both Reading and Writing
+  async close (options?: AbortOptions): Promise<void> {
+    this.log.trace('closing gracefully')
+
+    this.status = 'closing'
+
+    await Promise.all([
+      this.closeRead(options),
+      this.closeWrite(options)
+    ])
+
+    // wait for read and write ends to close
+    await raceSignal(this.closed.promise, options?.signal)
+
+    this.status = 'closed'
+
+    this.log.trace('closed gracefully')
+  }
+
+  async closeRead (options: AbortOptions = {}): Promise<void> {
+    if (this.readStatus === 'closing' || this.readStatus === 'closed') {
+      return
+    }
+
+    this.log.trace('closing readable end of stream with starting read status "%s"', this.readStatus)
+
+    const readStatus = this.readStatus
+    this.readStatus = 'closing'
+
+    if (this.status !== 'reset' && this.status !== 'aborted' && this.timeline.closeRead == null) {
+      this.log.trace('send close read to remote')
+      await this.sendCloseRead(options)
+    }
+
+    if (readStatus === 'ready') {
+      this.log.trace('ending internal source queue with %d queued bytes', this.streamSource.readableLength)
+      this.streamSource.end()
+    }
+
+    this.log.trace('closed readable end of stream')
+  }
+
+  async closeWrite (options: AbortOptions = {}): Promise<void> {
+    if (this.writeStatus === 'closing' || this.writeStatus === 'closed') {
+      return
+    }
+
+    this.log.trace('closing writable end of stream with starting write status "%s"', this.writeStatus)
+
+    if (this.writeStatus === 'ready') {
+      this.log.trace('sink was never sunk, sink an empty array')
+
+      await raceSignal(this.sink([]), options.signal)
+    }
+
+    if (this.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()
+          raceSignal(this.sinkEnd.promise, options.signal)
+            .then(resolve, reject)
+        })
+      })
+    }
+
+    this.writeStatus = 'closed'
+
+    this.log.trace('closed writable end of stream')
+  }
+
+  /**
+   * Close immediately for reading and writing and send a reset message (local
+   * error)
+   */
+  abort (err: Error): void {
+    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)
+  }
+
+  /**
+   * Receive a reset message - close immediately for reading and writing (remote
+   * error)
+   */
+  reset (): void {
+    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+      return
+    }
+
+    const err = new CodeError('stream reset', ERR_STREAM_RESET)
+
+    this.status = 'reset'
+    this.timeline.reset = Date.now()
+    this._closeSinkAndSource(err)
+    this.onReset?.()
+  }
+
+  _closeSinkAndSource (err?: Error): void {
+    this._closeSink(err)
+    this._closeSource(err)
+  }
+
+  _closeSink (err?: Error): void {
+    // if the sink function is running, cause it to end
+    if (this.writeStatus === 'writing') {
+      this.log.trace('end sink source')
+      this.sinkController.abort()
+    }
+
+    this.onSinkEnd(err)
+  }
+
+  _closeSource (err?: Error): void {
+    // 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)
+    }
+  }
+
+  /**
+   * The remote closed for writing so we should expect to receive no more
+   * messages
+   */
+  remoteCloseWrite (): void {
+    if (this.readStatus === 'closing' || this.readStatus === 'closed') {
+      this.log('received remote close write but local source is already closed')
+      return
+    }
+
+    this.log.trace('remote close write')
+    this._closeSource()
+  }
+
+  /**
+   * The remote closed for reading so we should not send any more
+   * messages
+   */
+  remoteCloseRead (): void {
+    if (this.writeStatus === 'closing' || this.writeStatus === 'closed') {
+      this.log('received remote close read but local sink is already closed')
+      return
+    }
+
+    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 (): void {
+    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+      this.log('received destroy but we are already closed')
+      return
+    }
+
+    this.log.trace('stream destroyed')
+
+    this._closeSinkAndSource()
+  }
+
+  /**
+   * When an extending class reads data from it's implementation-specific source,
+   * call this method to allow the stream consumer to read the data.
+   */
+  sourcePush (data: Uint8ArrayList): void {
+    this.streamSource.push(data)
+  }
+
+  /**
+   * Returns the amount of unread data - can be used to prevent large amounts of
+   * data building up when the stream consumer is too slow.
+   */
+  sourceReadableLength (): number {
+    return this.streamSource.readableLength
+  }
+
+  /**
+   * Send a message to the remote muxer informing them a new stream is being
+   * opened
+   */
+  abstract sendNewStream (options?: AbortOptions): void | Promise<void>
+
+  /**
+   * Send a data message to the remote muxer
+   */
+  abstract sendData (buf: Uint8ArrayList, options?: AbortOptions): void | Promise<void>
+
+  /**
+   * Send a reset message to the remote muxer
+   */
+  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 (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 (options?: AbortOptions): void | Promise<void>
+}