@libp2p/mplex 1.0.0

package/LICENSE

@@ -0,0 +1,4 @@
+This project is dual licensed under MIT and Apache-2.0.
+
+MIT: https://www.opensource.org/licenses/mit
+Apache-2.0: https://www.apache.org/licenses/license-2.0

package/README.md

@@ -0,0 +1,186 @@
+# js-libp2p-mplex
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai)
+[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
+[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)
+[![](https://img.shields.io/codecov/c/github/libp2p/js-libp2p-mplex.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-mplex)
+[![Build Status](https://github.com/libp2p/js-libp2p-mplex/actions/workflows/js-test-and-release.yml/badge.svg?branch=main)](https://github.com/libp2p/js-libp2p-mplex/actions/workflows/js-test-and-release.yml)
+[![Dependency Status](https://david-dm.org/libp2p/js-libp2p-mplex.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mplex)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
+![](https://img.shields.io/badge/npm-%3E%3D6.0.0-orange.svg?style=flat-square)
+![](https://img.shields.io/badge/Node.js-%3E%3D10.0.0-orange.svg?style=flat-square)
+
+> JavaScript implementation of [mplex](https://github.com/libp2p/specs/tree/master/mplex).
+
+[![](https://github.com/libp2p/interface-stream-muxer/raw/master/img/badge.png)](https://github.com/libp2p/interface-stream-muxer)
+
+## Install
+
+```sh
+npm install @libp2p/mplex
+```
+
+## Usage
+
+```js
+import { Mplex } from '@libp2p/mplex'
+import { pipe } from 'it-pipe'
+
+const muxer = new Mplex({
+  onStream: stream => { // Receive a duplex stream from the remote
+    // ...receive data from the remote and optionally send data back
+  },
+  onStreamEnd: stream => {
+    // ...handle any tracking you may need of stream closures
+  }
+})
+
+pipe(conn, muxer, conn) // conn is duplex connection to another peer
+
+const stream = muxer.newStream() // Create a new duplex stream to the remote
+
+// Use the duplex stream to send some data to the remote...
+pipe([1, 2, 3], stream)
+```
+
+## API
+
+### `const muxer = new Mplex([options])`
+
+Create a new _duplex_ stream that can be piped together with a connection in order to allow multiplexed communications.
+
+e.g.
+
+```js
+import { Mplex } from '@libp2p/mplex'
+import { pipe } from 'it-pipe'
+
+// Create a duplex muxer
+const muxer = new Mplex()
+
+// Use the muxer in a pipeline
+pipe(conn, muxer, conn) // conn is duplex connection to another peer
+```
+
+`options` is an optional `Object` that may have the following properties:
+
+* `onStream` - A function called when receiving a new stream from the remote. e.g.
+    ```js
+    // Receive a new stream on the muxed connection
+    const onStream = stream => {
+      // Read from this stream and write back to it (echo server)
+      pipe(
+        stream,
+        source => (async function * () {
+          for await (const data of source) yield data
+        })(),
+        stream
+      )
+    }
+    const muxer = new Mplex({ onStream })
+    // ...
+    ```
+    **Note:** The `onStream` function can be passed in place of the `options` object. i.e.
+    ```js
+    new Mplex(stream => { /* ... */ })
+    ```
+* `onStreamEnd` - A function called when a stream ends
+    ```js
+    // Receive a notification when a stream ends
+    const onStreamEnd = stream => {
+      // Manage any tracking changes, etc
+    }
+    const muxer = new Mplex({ onStreamEnd })
+    // ...
+    ```
+* `signal` - An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) which can be used to abort the muxer, _including_ all of it's multiplexed connections. e.g.
+    ```js
+    const controller = new AbortController()
+    const muxer = new Mplex({ signal: controller.signal })
+
+    pipe(conn, muxer, conn)
+
+    controller.abort()
+    ```
+* `maxMsgSize` - The maximum size in bytes the data field of multiplexed messages may contain (default 1MB)
+
+### `muxer.onStream`
+
+Use this property as an alternative to passing `onStream` as an option to the `Mplex` constructor.
+
+### `muxer.onStreamEnd`
+
+Use this property as an alternative to passing `onStreamEnd` as an option to the `Mplex` constructor.
+
+### `muxer.streams`
+
+Returns an `Array` of streams that are currently open. Closed streams will not be returned.
+
+### `const stream = muxer.newStream([options])`
+
+Initiate a new stream with the remote. Returns a [duplex stream](https://gist.github.com/alanshaw/591dc7dd54e4f99338a347ef568d6ee9#duplex-it).
+
+e.g.
+
+```js
+// Create a new stream on the muxed connection
+const stream = muxer.newStream()
+
+// Use this new stream like any other duplex stream:
+pipe([1, 2, 3], stream, consume)
+```
+
+In addition to `sink` and `source` properties, this stream also has the following API, that will **normally _not_ be used by stream consumers**.
+
+#### `stream.close()`
+
+Closes the stream for **reading**. If iterating over the source of this stream in a `for await of` loop, it will return (exit the loop) after any buffered data has been consumed.
+
+This function is called automatically by the muxer when it receives a `CLOSE` message from the remote.
+
+The source will return normally, the sink will continue to consume.
+
+#### `stream.abort([err])`
+
+Closes the stream for **reading** _and_ **writing**. This should be called when a _local error_ has occurred.
+
+Note, if called without an error any buffered data in the source can still be consumed and the stream will end normally.
+
+This will cause a `RESET` message to be sent to the remote, _unless_ the sink has already ended.
+
+The sink will return and the source will throw if an error is passed or return normally if not.
+
+#### `stream.reset()`
+
+Closes the stream _immediately_ for **reading** _and_ **writing**. This should be called when a _remote error_ has occurred.
+
+This function is called automatically by the muxer when it receives a `RESET` message from the remote.
+
+The sink will return and the source will throw.
+
+#### `stream.timeline`
+
+Returns an `object` with `close` and `open` times of the stream.
+
+#### `stream.id`
+
+Returns a `string` with an identifier unique to **this** muxer. Identifiers are not unique across muxers.
+
+## Contribute
+
+The libp2p implementation in JavaScript is a work in progress. As such, there are a few things you can do right now to help out:
+
+ - Go through the modules and **check out existing issues**. This is especially useful for modules in active development. Some knowledge of IPFS/libp2p may be required, as well as the infrastructure behind it - for instance, you may need to read up on p2p and more complex operations like muxing to be able to help technically.
+ - **Perform code reviews**. More eyes will help a) speed the project along b) ensure quality and c) reduce possible future bugs.
+
+## License
+
+Licensed under either of
+
+ * Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT ([LICENSE-MIT](LICENSE-MIT) / http://opensource.org/licenses/MIT)
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

package/dist/src/decode.d.ts

@@ -0,0 +1,7 @@
+import type { Source } from 'it-stream-types';
+import type { Message } from './message-types.js';
+/**
+ * Decode a chunk and yield an _array_ of decoded messages
+ */
+export declare function decode(source: Source<Uint8Array>): AsyncGenerator<Message[], void, unknown>;
+//# sourceMappingURL=decode.d.ts.map

package/dist/src/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/decode.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAmHjD;;GAEG;AACH,wBAAwB,MAAM,CAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,4CAUzD"}

package/dist/src/decode.js

@@ -0,0 +1,93 @@
+import { MessageTypeNames, MessageTypes } from './message-types.js';
+import { Uint8ArrayList } from 'uint8arraylist';
+class Decoder {
+    constructor() {
+        this._buffer = new Uint8ArrayList();
+        this._headerInfo = null;
+    }
+    write(chunk) {
+        if (chunk == null || chunk.length === 0) {
+            return [];
+        }
+        this._buffer.append(chunk);
+        const msgs = [];
+        while (this._buffer.length !== 0) {
+            if (this._headerInfo == null) {
+                try {
+                    this._headerInfo = this._decodeHeader(this._buffer);
+                }
+                catch (_) {
+                    break; // We haven't received enough data yet
+                }
+            }
+            const { id, type, length, offset } = this._headerInfo;
+            const bufferedDataLength = this._buffer.length - offset;
+            if (bufferedDataLength < length) {
+                break; // not enough data yet
+            }
+            const msg = {
+                id,
+                type
+            };
+            if (type === MessageTypes.NEW_STREAM || type === MessageTypes.MESSAGE_INITIATOR || type === MessageTypes.MESSAGE_RECEIVER) {
+                msg.data = this._buffer.slice(offset, offset + length);
+            }
+            msgs.push(msg);
+            this._buffer.consume(offset + length);
+            this._headerInfo = null;
+        }
+        return msgs;
+    }
+    /**
+     * Attempts to decode the message header from the buffer
+     */
+    _decodeHeader(data) {
+        const { value: h, offset } = readVarInt(data);
+        const { value: length, offset: end } = readVarInt(data, offset);
+        const type = h & 7;
+        // @ts-expect-error h is a number not a CODE
+        if (MessageTypeNames[type] == null) {
+            throw new Error(`Invalid type received: ${type}`);
+        }
+        // @ts-expect-error h is a number not a CODE
+        return { id: h >> 3, type, offset: offset + end, length };
+    }
+}
+const MSB = 0x80;
+const REST = 0x7F;
+function readVarInt(buf, offset = 0) {
+    let res = 0;
+    let shift = 0;
+    let counter = offset;
+    let b;
+    const l = buf.length;
+    do {
+        if (counter >= l || shift > 49) {
+            offset = 0;
+            throw new RangeError('Could not decode varint');
+        }
+        b = buf.get(counter++);
+        res += shift < 28
+            ? (b & REST) << shift
+            : (b & REST) * Math.pow(2, shift);
+        shift += 7;
+    } while (b >= MSB);
+    offset = counter - offset;
+    return {
+        value: res,
+        offset
+    };
+}
+/**
+ * Decode a chunk and yield an _array_ of decoded messages
+ */
+export async function* decode(source) {
+    const decoder = new Decoder();
+    for await (const chunk of source) {
+        const msgs = decoder.write(chunk);
+        if (msgs.length > 0) {
+            yield msgs;
+        }
+    }
+}
+//# sourceMappingURL=decode.js.map

package/dist/src/decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/decode.ts"],"names":[],"mappings":"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"}

package/dist/src/encode.d.ts

@@ -0,0 +1,7 @@
+import { Message } from './message-types.js';
+import type { Source } from 'it-stream-types';
+/**
+ * Encode and yield one or more messages
+ */
+export declare function encode(source: Source<Message | Message[]>): AsyncGenerator<Uint8Array, void, undefined>;
+//# sourceMappingURL=encode.d.ts.map

package/dist/src/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/encode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAgB,MAAM,oBAAoB,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AA+D7C;;GAEG;AACH,wBAAwB,MAAM,CAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,OAAO,EAAE,CAAC,+CAUlE"}

package/dist/src/encode.js

@@ -0,0 +1,65 @@
+import varint from 'varint';
+import { MessageTypes } from './message-types.js';
+const POOL_SIZE = 10 * 1024;
+function allocUnsafe(size) {
+    if (globalThis.Buffer != null) {
+        return Buffer.allocUnsafe(size);
+    }
+    return new Uint8Array(size);
+}
+class Encoder {
+    constructor() {
+        this._pool = allocUnsafe(POOL_SIZE);
+        this._poolOffset = 0;
+    }
+    /**
+     * Encodes the given message and returns it and its header
+     */
+    write(msg) {
+        const pool = this._pool;
+        let offset = this._poolOffset;
+        varint.encode(msg.id << 3 | msg.type, pool, offset);
+        offset += varint.encode.bytes;
+        if ((msg.type === MessageTypes.NEW_STREAM || msg.type === MessageTypes.MESSAGE_INITIATOR || msg.type === MessageTypes.MESSAGE_RECEIVER) && msg.data != null) {
+            varint.encode(msg.data.length, pool, offset);
+        }
+        else {
+            varint.encode(0, pool, offset);
+        }
+        offset += varint.encode.bytes;
+        const header = pool.slice(this._poolOffset, offset);
+        if (POOL_SIZE - offset < 100) {
+            this._pool = allocUnsafe(POOL_SIZE);
+            this._poolOffset = 0;
+        }
+        else {
+            this._poolOffset = offset;
+        }
+        if ((msg.type === MessageTypes.NEW_STREAM || msg.type === MessageTypes.MESSAGE_INITIATOR || msg.type === MessageTypes.MESSAGE_RECEIVER) && msg.data != null) {
+            return [
+                header,
+                msg.data instanceof Uint8Array ? msg.data : msg.data.slice()
+            ];
+        }
+        return [
+            header
+        ];
+    }
+}
+const encoder = new Encoder();
+/**
+ * Encode and yield one or more messages
+ */
+export async function* encode(source) {
+    for await (const msg of source) {
+        if (Array.isArray(msg)) {
+            for (const m of msg) {
+                yield* encoder.write(m);
+            }
+        }
+        else {
+            yield* encoder.write(msg);
+        }
+    }
+}
+//# sourceMappingURL=encode.js.map

package/dist/src/encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/encode.ts"],"names":[],"mappings":"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"}

package/dist/src/index.d.ts

@@ -0,0 +1,66 @@
+import { Pushable } from 'it-pushable';
+import { Message } from './message-types.js';
+import type { AbortOptions } from '@libp2p/interfaces';
+import type { Sink } from 'it-stream-types';
+import type { Muxer } from '@libp2p/interfaces/stream-muxer';
+import type { Stream } from '@libp2p/interfaces/connection';
+import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics';
+export interface MplexStream extends Stream {
+    source: Pushable<Uint8Array>;
+}
+export interface MplexOptions extends AbortOptions {
+    onStream?: (...args: any[]) => void;
+    onStreamEnd?: (...args: any[]) => void;
+    maxMsgSize?: number;
+    metrics?: ComponentMetricsTracker;
+}
+export declare class Mplex implements Muxer {
+    static multicodec: string;
+    sink: Sink<Uint8Array>;
+    source: AsyncIterable<Uint8Array>;
+    private _streamId;
+    private readonly _streams;
+    private readonly _options;
+    private readonly _source;
+    constructor(options?: MplexOptions);
+    /**
+     * Returns a Map of streams and their ids
+     */
+    get streams(): Stream[];
+    /**
+     * Initiate a new stream with the given name. If no name is
+     * provided, the id of the stream will be used.
+     */
+    newStream(name?: string): Stream;
+    /**
+     * Called whenever an inbound stream is created
+     */
+    _newReceiverStream(options: {
+        id: number;
+        name: string;
+    }): MplexStream;
+    _newStream(options: {
+        id: number;
+        name: string;
+        type: 'initiator' | 'receiver';
+        registry: Map<number, MplexStream>;
+    }): MplexStream;
+    /**
+     * Creates a sink with an abortable source. Incoming messages will
+     * also have their size restricted. All messages will be varint decoded.
+     */
+    _createSink(): Sink<Uint8Array, Promise<void>>;
+    /**
+     * Creates a source that restricts outgoing message sizes
+     * and varint encodes them
+     */
+    _createSource(): AsyncGenerator<Uint8Array, void, undefined> & {
+        push: (value: Message) => import("it-pushable").PushableV<Message>;
+        end: (err?: Error | undefined) => import("it-pushable").PushableV<Message>;
+        return: () => {
+            done: boolean;
+        };
+    };
+    _handleIncoming(message: Message): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAa,MAAM,aAAa,CAAA;AAKjD,OAAO,EAAkC,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAK5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAA;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAsBzE,MAAM,WAAW,WAAY,SAAQ,MAAM;IACzC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAA;CAC7B;AAED,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;IACnC,WAAW,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;IACtC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,uBAAuB,CAAA;CAClC;AAED,qBAAa,KAAM,YAAW,KAAK;IACjC,MAAM,CAAC,UAAU,SAAiB;IAE3B,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;IACtB,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAExC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+E;IACxG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8D;gBAEzE,OAAO,CAAC,EAAE,YAAY;IA6BnC;;OAEG;IACH,IAAI,OAAO,aAUV;IAED;;;OAGG;IACH,SAAS,CAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAOjC;;OAEG;IACH,kBAAkB,CAAE,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAMzD,UAAU,CAAE,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;KAAE;IAmCrH;;;OAGG;IACH,WAAW;IA+BX;;;OAGG;IACH,aAAa;;;;;;;IAyCb,eAAe,CAAE,OAAO,EAAE,OAAO;CA0ClC"}

package/dist/src/index.js

@@ -0,0 +1,218 @@
+import { pipe } from 'it-pipe';
+import { pushableV } from 'it-pushable';
+import { abortableSource } from 'abortable-iterator';
+import { encode } from './encode.js';
+import { decode } from './decode.js';
+import { restrictSize } from './restrict-size.js';
+import { MessageTypes, MessageTypeNames } from './message-types.js';
+import { createStream } from './stream.js';
+import { toString as uint8ArrayToString } from 'uint8arrays';
+import { trackedMap } from '@libp2p/tracked-map';
+import { logger } from '@libp2p/logger';
+import each from 'it-foreach';
+const log = logger('libp2p:mplex');
+function printMessage(msg) {
+    const output = {
+        ...msg,
+        type: `${MessageTypeNames[msg.type]} (${msg.type})`
+    };
+    if (msg.type === MessageTypes.NEW_STREAM) {
+        output.data = uint8ArrayToString(msg.data instanceof Uint8Array ? msg.data : msg.data.slice());
+    }
+    if (msg.type === MessageTypes.MESSAGE_INITIATOR || msg.type === MessageTypes.MESSAGE_RECEIVER) {
+        output.data = uint8ArrayToString(msg.data instanceof Uint8Array ? msg.data : msg.data.slice(), 'base16');
+    }
+    return output;
+}
+export class Mplex {
+    constructor(options) {
+        options = options ?? {};
+        this._streamId = 0;
+        this._streams = {
+            /**
+             * Stream to ids map
+             */
+            initiators: trackedMap({ metrics: options.metrics, component: 'mplex', metric: 'initiatorStreams' }),
+            /**
+             * Stream to ids map
+             */
+            receivers: trackedMap({ metrics: options.metrics, component: 'mplex', metric: 'receiverStreams' })
+        };
+        this._options = options;
+        /**
+         * An iterable sink
+         */
+        this.sink = this._createSink();
+        /**
+         * An iterable source
+         */
+        const source = this._createSource();
+        this._source = source;
+        this.source = source;
+    }
+    /**
+     * Returns a Map of streams and their ids
+     */
+    get streams() {
+        // Inbound and Outbound streams may have the same ids, so we need to make those unique
+        const streams = [];
+        this._streams.initiators.forEach(stream => {
+            streams.push(stream);
+        });
+        this._streams.receivers.forEach(stream => {
+            streams.push(stream);
+        });
+        return streams;
+    }
+    /**
+     * Initiate a new stream with the given name. If no name is
+     * provided, the id of the stream will be used.
+     */
+    newStream(name) {
+        const id = this._streamId++;
+        name = name == null ? id.toString() : name.toString();
+        const registry = this._streams.initiators;
+        return this._newStream({ id, name, type: 'initiator', registry });
+    }
+    /**
+     * Called whenever an inbound stream is created
+     */
+    _newReceiverStream(options) {
+        const { id, name } = options;
+        const registry = this._streams.receivers;
+        return this._newStream({ id, name, type: 'receiver', registry });
+    }
+    _newStream(options) {
+        const { id, name, type, registry } = options;
+        log('new %s stream %s %s', type, id, name);
+        if (registry.has(id)) {
+            throw new Error(`${type} stream ${id} already exists!`);
+        }
+        const send = (msg) => {
+            if (log.enabled) {
+                log('%s stream %s send', type, id, printMessage(msg));
+            }
+            if (msg.type === MessageTypes.NEW_STREAM || msg.type === MessageTypes.MESSAGE_INITIATOR || msg.type === MessageTypes.MESSAGE_RECEIVER) {
+                msg.data = msg.data instanceof Uint8Array ? msg.data : msg.data.slice();
+            }
+            this._source.push(msg);
+        };
+        const onEnd = () => {
+            log('%s stream %s %s ended', type, id, name);
+            registry.delete(id);
+            if (this._options.onStreamEnd != null) {
+                this._options.onStreamEnd(stream);
+            }
+        };
+        const stream = createStream({ id, name, send, type, onEnd, maxMsgSize: this._options.maxMsgSize });
+        registry.set(id, stream);
+        return stream;
+    }
+    /**
+     * Creates a sink with an abortable source. Incoming messages will
+     * also have their size restricted. All messages will be varint decoded.
+     */
+    _createSink() {
+        const sink = async (source) => {
+            if (this._options.signal != null) {
+                source = abortableSource(source, this._options.signal);
+            }
+            try {
+                await pipe(source, source => each(source, (buf) => {
+                    // console.info('incoming', uint8ArrayToString(buf, 'base64'))
+                }), decode, restrictSize(this._options.maxMsgSize), async (source) => {
+                    for await (const msg of source) {
+                        this._handleIncoming(msg);
+                    }
+                });
+                this._source.end();
+            }
+            catch (err) {
+                log('error in sink', err);
+                this._source.end(err); // End the source with an error
+            }
+        };
+        return sink;
+    }
+    /**
+     * Creates a source that restricts outgoing message sizes
+     * and varint encodes them
+     */
+    _createSource() {
+        const onEnd = (err) => {
+            const { initiators, receivers } = this._streams;
+            // Abort all the things!
+            for (const s of initiators.values()) {
+                s.abort(err);
+            }
+            for (const s of receivers.values()) {
+                s.abort(err);
+            }
+        };
+        const source = pushableV({ onEnd });
+        /*
+        const p = pipe(
+          source,
+          source => each(source, (msgs) => {
+            if (log.enabled) {
+              msgs.forEach(msg => {
+                log('outgoing message', printMessage(msg))
+              })
+            }
+          }),
+          source => encode(source),
+          source => each(source, (buf) => {
+            console.info('outgoing', uint8ArrayToString(buf, 'base64'))
+          })
+        )
+    
+        return Object.assign(p, {
+          push: source.push,
+          end: source.end,
+          return: source.return
+        })
+    */
+        return Object.assign(encode(source), {
+            push: source.push,
+            end: source.end,
+            return: source.return
+        });
+    }
+    _handleIncoming(message) {
+        const { id, type } = message;
+        if (log.enabled) {
+            log('incoming message', printMessage(message));
+        }
+        // Create a new stream?
+        if (message.type === MessageTypes.NEW_STREAM) {
+            const stream = this._newReceiverStream({ id, name: uint8ArrayToString(message.data instanceof Uint8Array ? message.data : message.data.slice()) });
+            if (this._options.onStream != null) {
+                this._options.onStream(stream);
+            }
+            return;
+        }
+        const list = (type & 1) === 1 ? this._streams.initiators : this._streams.receivers;
+        const stream = list.get(id);
+        if (stream == null) {
+            return log('missing stream %s', id);
+        }
+        switch (type) {
+            case MessageTypes.MESSAGE_INITIATOR:
+            case MessageTypes.MESSAGE_RECEIVER:
+                stream.source.push(message.data.slice());
+                break;
+            case MessageTypes.CLOSE_INITIATOR:
+            case MessageTypes.CLOSE_RECEIVER:
+                stream.close();
+                break;
+            case MessageTypes.RESET_INITIATOR:
+            case MessageTypes.RESET_RECEIVER:
+                stream.reset();
+                break;
+            default:
+                log('unknown message type %s', type);
+        }
+    }
+}
+Mplex.multicodec = '/mplex/6.7.0';
+//# sourceMappingURL=index.js.map