@libp2p/interface 2.11.0-6059227cb → 2.11.0-87bc8d4fb

package/src/transport.ts

@@ -1,4 +1,6 @@
-import type { AbortOptions, ClearableSignal, ConnectionEncrypter, MultiaddrConnection, Connection, ConnectionLimits, StreamMuxerFactory, PeerId } from './index.js'
+import type { Connection, ConnectionLimits, MultiaddrConnection } from './connection.js'
+import type { AbortOptions, ClearableSignal, ConnectionEncrypter } from './index.js'
+import type { StreamMuxerFactory } from './stream-muxer.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 import type { ProgressOptions, ProgressEvent } from 'progress-events'
@@ -27,19 +29,16 @@ export interface Listener extends TypedEventTarget<ListenerEvents> {
    * Start a listener
    */
   listen(multiaddr: Multiaddr): Promise<void>
-
   /**
    * Get listen addresses
    */
   getAddrs(): Multiaddr[]
-
   /**
    * Close listener
    *
    * @returns {Promise<void>}
    */
   close(): Promise<void>
-
   /**
    * Allows transports to amend announce addresses - to add certificate hashes
    * or other metadata that cannot be known before runtime
@@ -135,6 +134,15 @@ export enum FaultTolerance {
  * Options accepted by the upgrader during connection establishment
  */
 export interface UpgraderOptions<ConnectionUpgradeEvents extends ProgressEvent = ProgressEvent> extends ProgressOptions<ConnectionUpgradeEvents>, Required<AbortOptions> {
+  /**
+   * If true the invoking transport is expected to implement it's own encryption
+   * and an encryption protocol will not attempted to be negotiated via
+   * multi-stream select
+   *
+   * @default false
+   */
+  skipEncryption?: boolean
+
   /**
    * If true no connection protection will be performed on the connection.
    */
@@ -164,23 +172,6 @@ export interface UpgraderOptions<ConnectionUpgradeEvents extends ProgressEvent =
   initiator?: boolean
 }
 
-/**
- * Options accepted by the upgrader during connection establishment
- */
-export interface UpgraderWithoutEncryptionOptions extends UpgraderOptions {
-  /**
-   * If true the invoking transport is expected to implement it's own encryption
-   * and an encryption protocol will not attempted to be negotiated via
-   * multi-stream select
-   */
-  skipEncryption: true
-
-  /**
-   * If `skipEncryption` is true, a remote PeerId must be supplied
-   */
-  remotePeer: PeerId
-}
-
 export type InboundConnectionUpgradeEvents =
 ProgressEvent<'upgrader:encrypt-inbound-connection'> |
 ProgressEvent<'upgrader:multiplex-inbound-connection'>
@@ -193,15 +184,13 @@ export interface Upgrader {
   /**
    * Upgrades an outbound connection created by the `dial` method of a transport
    */
-  upgradeOutbound(maConn: MultiaddrConnection, opts: UpgraderOptions<OutboundConnectionUpgradeEvents>): Promise<Connection>
-  upgradeOutbound(maConn: MultiaddrConnection, opts: UpgraderWithoutEncryptionOptions): Promise<Connection>
+  upgradeOutbound(maConn: MultiaddrConnection, opts?: UpgraderOptions<OutboundConnectionUpgradeEvents>): Promise<Connection>
 
   /**
    * Upgrades an inbound connection received by a transport listener and
    * notifies other libp2p components about the new connection
    */
-  upgradeInbound(maConn: MultiaddrConnection, opts: UpgraderOptions<InboundConnectionUpgradeEvents>): Promise<void>
-  upgradeInbound(maConn: MultiaddrConnection, opts: UpgraderWithoutEncryptionOptions): Promise<void>
+  upgradeInbound(maConn: MultiaddrConnection, opts?: UpgraderOptions<InboundConnectionUpgradeEvents>): Promise<void>
 
   /**
    * Used by transports that perform part of the upgrade process themselves and

package/dist/src/connection-protector.d.ts

@@ -1,9 +0,0 @@
-import type { AbortOptions, MessageStream } from './index.ts';
-export interface ConnectionProtector {
-    /**
-     * Takes a MessageStream and creates a private encryption stream between
-     * the two peers from the shared key the Protector instance was created with.
-     */
-    protect(connection: MessageStream, options?: AbortOptions): Promise<MessageStream>;
-}
-//# sourceMappingURL=connection-protector.d.ts.map

package/dist/src/connection-protector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-protector.d.ts","sourceRoot":"","sources":["../../src/connection-protector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE7D,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,CAAE,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;CACpF"}

package/dist/src/connection-protector.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=connection-protector.js.map

package/dist/src/connection-protector.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-protector.js","sourceRoot":"","sources":["../../src/connection-protector.ts"],"names":[],"mappings":""}

package/dist/src/events.d.ts

@@ -1,26 +0,0 @@
-import type { Uint8ArrayList } from 'uint8arraylist';
-/**
- * A custom implementation of MessageEvent as the Undici version does too much
- * validation in it's constructor so is very slow.
- */
-export declare class StreamMessageEvent extends Event {
-    data: Uint8Array | Uint8ArrayList;
-    constructor(data: Uint8Array | Uint8ArrayList, eventInitDict?: EventInit);
-}
-/**
- * An event dispatched when the stream is closed. The `error` property can be
- * inspected to discover if the closing was graceful or not, and the `remote`
- * property shows which end of the stream initiated the closure
- */
-export declare class StreamCloseEvent extends Event {
-    error?: Error;
-    local?: boolean;
-    constructor(local?: boolean, error?: Error, eventInitDict?: EventInit);
-}
-export declare class StreamAbortEvent extends StreamCloseEvent {
-    constructor(error: Error, eventInitDict?: EventInit);
-}
-export declare class StreamResetEvent extends StreamCloseEvent {
-    constructor(error: Error, eventInitDict?: EventInit);
-}
-//# sourceMappingURL=events.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IACpC,IAAI,EAAE,UAAU,GAAG,cAAc,CAAA;gBAE3B,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,aAAa,CAAC,EAAE,SAAS;CAK1E;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IAClC,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;gBAET,KAAK,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,EAAE,SAAS;CAMvE;AAED,qBAAa,gBAAiB,SAAQ,gBAAgB;gBACvC,KAAK,EAAE,KAAK,EAAE,aAAa,CAAC,EAAE,SAAS;CAGrD;AAED,qBAAa,gBAAiB,SAAQ,gBAAgB;gBACvC,KAAK,EAAE,KAAK,EAAE,aAAa,CAAC,EAAE,SAAS;CAGrD"}

package/dist/src/events.js

@@ -1,36 +0,0 @@
-/**
- * A custom implementation of MessageEvent as the Undici version does too much
- * validation in it's constructor so is very slow.
- */
-export class StreamMessageEvent extends Event {
-    data;
-    constructor(data, eventInitDict) {
-        super('message', eventInitDict);
-        this.data = data;
-    }
-}
-/**
- * An event dispatched when the stream is closed. The `error` property can be
- * inspected to discover if the closing was graceful or not, and the `remote`
- * property shows which end of the stream initiated the closure
- */
-export class StreamCloseEvent extends Event {
-    error;
-    local;
-    constructor(local, error, eventInitDict) {
-        super('close', eventInitDict);
-        this.error = error;
-        this.local = local;
-    }
-}
-export class StreamAbortEvent extends StreamCloseEvent {
-    constructor(error, eventInitDict) {
-        super(true, error, eventInitDict);
-    }
-}
-export class StreamResetEvent extends StreamCloseEvent {
-    constructor(error, eventInitDict) {
-        super(false, error, eventInitDict);
-    }
-}
-//# sourceMappingURL=events.js.map

package/dist/src/events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IACpC,IAAI,CAA6B;IAExC,YAAa,IAAiC,EAAE,aAAyB;QACvE,KAAK,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;QAE/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IAClC,KAAK,CAAQ;IACb,KAAK,CAAU;IAEtB,YAAa,KAAe,EAAE,KAAa,EAAE,aAAyB;QACpE,KAAK,CAAC,OAAO,EAAE,aAAa,CAAC,CAAA;QAE7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;CACF;AAED,MAAM,OAAO,gBAAiB,SAAQ,gBAAgB;IACpD,YAAa,KAAY,EAAE,aAAyB;QAClD,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,aAAa,CAAC,CAAA;IACnC,CAAC;CACF;AAED,MAAM,OAAO,gBAAiB,SAAQ,gBAAgB;IACpD,YAAa,KAAY,EAAE,aAAyB;QAClD,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,CAAC,CAAA;IACpC,CAAC;CACF"}

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

@@ -1,159 +0,0 @@
-import type { Logger, StreamCloseEvent, StreamMessageEvent, TypedEventTarget, AbortOptions } from './index.js';
-import type { Uint8ArrayList } from 'uint8arraylist';
-/**
- * The direction of the message stream
- */
-export type MessageStreamDirection = 'inbound' | 'outbound';
-/**
- * The states a message stream can be in
- */
-export type MessageStreamStatus = 'open' | 'closing' | 'closed' | 'aborted' | 'reset';
-/**
- * The states the readable end of a message stream can be in
- */
-export type MessageStreamReadStatus = 'readable' | 'paused' | 'closing' | 'closed';
-/**
- * The states the writable end of a message stream can be in
- */
-export type MessageStreamWriteStatus = 'writable' | 'closing' | 'closed';
-/**
- * An object that records the times of various events
- */
-export interface MessageStreamTimeline {
-    /**
-     * A timestamp of when the message stream was opened
-     */
-    open: number;
-    /**
-     * A timestamp of when the message stream was closed for both reading and
-     * writing by both ends of the stream
-     */
-    close?: number;
-}
-export interface MessageStreamEvents {
-    /**
-     * Data was received from the remote end of the message stream
-     */
-    message: StreamMessageEvent;
-    /**
-     * The local send buffer has emptied and the stream may be written to once
-     * more, unless it is currently closing.
-     */
-    drain: Event;
-    /**
-     * The underlying resource is closed - no further events will be emitted and
-     * the stream cannot be used to send or receive any more data.
-     *
-     * When the `.error` field is set, the `local` property of the event will be
-     * `true` value if the `.abort` was invoked, otherwise it means a remote error
-     * occurred and the peer sent a reset signal.
-     */
-    close: StreamCloseEvent;
-    /**
-     * Where the stream implementation supports half-closing, it may emit this
-     * event when the remote end of the stream closes it's writable end.
-     *
-     * After this event is received no further 'message' events will be emitted
-     * though the stream can still be written to, if it has not been closed at
-     * this end.
-     */
-    remoteCloseWrite: Event;
-    /**
-     * The outgoing write queue emptied - there are no more bytes queued for
-     * sending to the remote end of the stream.
-     */
-    idle: Event;
-}
-export interface MessageStream<Timeline extends MessageStreamTimeline = MessageStreamTimeline> extends TypedEventTarget<MessageStreamEvents>, AsyncIterable<Uint8Array | Uint8ArrayList> {
-    /**
-     * The current status of the message stream
-     */
-    status: MessageStreamStatus;
-    /**
-     * Timestamps of when stream events occurred
-     */
-    timeline: Timeline;
-    /**
-     * A logging implementation that can be used to log stream-specific messages
-     */
-    log: Logger;
-    /**
-     * Whether this stream is inbound or outbound
-     */
-    direction: MessageStreamDirection;
-    /**
-     * The maximum number of bytes to store when paused. If receipt of more bytes
-     * from the remote end of the stream causes the buffer size to exceed this
-     * value the stream will be reset and a 'close' event emitted.
-     *
-     * This value can be changed at runtime.
-     */
-    maxReadBufferLength: number;
-    /**
-     * When the `.send` method returns false it means that the underlying resource
-     * has signalled that it's write buffer is full. If the user continues to call
-     * `.send`, outgoing bytes are stored in an internal buffer until the
-     * underlying resource signals that it can accept more data.
-     *
-     * If the size of that internal buffer exceed this value the stream will be
-     * reset and a 'close' event emitted.
-     *
-     * This value can be changed at runtime.
-     */
-    maxWriteBufferLength?: number;
-    /**
-     * If no data is transmitted over the stream in this many ms, the stream will
-     * be aborted with an InactivityTimeoutError
-     */
-    inactivityTimeout: number;
-    /**
-     * If this property is `true`, the underlying transport has signalled that its
-     * write buffer is full and that `.send` should not be called again.
-     *
-     * A `drain` event will be emitted after which is its safe to call `.send`
-     * again to resume sending.
-     */
-    writableNeedsDrain: boolean;
-    /**
-     * Write data to the stream. If the method returns false it means the
-     * internal buffer is now full and the caller should wait for the 'drain'
-     * event before sending more data.
-     *
-     * This method may throw if:
-     * - The internal send buffer is full
-     * - The stream has previously been closed for writing locally or remotely
-     */
-    send(data: Uint8Array | Uint8ArrayList): boolean;
-    /**
-     * Stop accepting new data to send and return a promise that resolves when any
-     * unsent data has been written into the underlying resource.
-     */
-    close(options?: AbortOptions): Promise<void>;
-    /**
-     * Stop accepting new data to send, discard any unsent/unread data, and emit a
-     * 'close' event with the 'error' property set to the passed error.
-     */
-    abort(err: Error): void;
-    /**
-     * Stop emitting further 'message' events. Any received data will be stored in
-     * an internal buffer. If the buffer size reaches `maxReadBufferLength`, the
-     * stream will be reset and a StreamAbortEvent emitted.
-     *
-     * If the underlying resource supports it, the remote peer will be instructed
-     * to pause transmission of further data.
-     */
-    pause(): void;
-    /**
-     * Resume emitting 'message' events.
-     *
-     * If the underlying resource supports it, the remote peer will be informed
-     * that it is ok to start sending data again.
-     */
-    resume(): void;
-    /**
-     * Queue the passed data to be emitted as a 'message' event either during the
-     * next tick or sooner if data is received from the underlying resource.
-     */
-    push(buf: Uint8Array | Uint8ArrayList): void;
-}
-//# sourceMappingURL=message-stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"message-stream.d.ts","sourceRoot":"","sources":["../../src/message-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,UAAU,CAAA;AAE3D;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAA;AAErF;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAA;AAElF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAA;AAExE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,OAAO,EAAE,kBAAkB,CAAA;IAE3B;;;OAGG;IACH,KAAK,EAAE,KAAK,CAAA;IAEZ;;;;;;;OAOG;IACH,KAAK,EAAE,gBAAgB,CAAA;IAEvB;;;;;;;OAOG;IACH,gBAAgB,EAAE,KAAK,CAAA;IAEvB;;;OAGG;IACH,IAAI,EAAE,KAAK,CAAA;CACZ;AAED,MAAM,WAAW,aAAa,CAAC,QAAQ,SAAS,qBAAqB,GAAG,qBAAqB,CAAE,SAAQ,gBAAgB,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,UAAU,GAAG,cAAc,CAAC;IACtL;;OAEG;IACH,MAAM,EAAE,mBAAmB,CAAA;IAE3B;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAA;IAElB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IAEX;;OAEG;IACH,SAAS,EAAE,sBAAsB,CAAA;IAEjC;;;;;;OAMG;IACH,mBAAmB,EAAE,MAAM,CAAA;IAE3B;;;;;;;;;;OAUG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAE7B;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAA;IAEzB;;;;;;OAMG;IACH,kBAAkB,EAAE,OAAO,CAAA;IAE3B;;;;;;;;OAQG;IACH,IAAI,CAAE,IAAI,EAAE,UAAU,GAAG,cAAc,GAAG,OAAO,CAAA;IAEjD;;;OAGG;IACH,KAAK,CAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7C;;;OAGG;IACH,KAAK,CAAE,GAAG,EAAE,KAAK,GAAG,IAAI,CAAA;IAExB;;;;;;;OAOG;IACH,KAAK,IAAK,IAAI,CAAA;IAEd;;;;;OAKG;IACH,MAAM,IAAK,IAAI,CAAA;IAEf;;;OAGG;IACH,IAAI,CAAE,GAAG,EAAE,UAAU,GAAG,cAAc,GAAG,IAAI,CAAA;CAC9C"}

package/dist/src/message-stream.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=message-stream.js.map

package/dist/src/message-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"message-stream.js","sourceRoot":"","sources":["../../src/message-stream.ts"],"names":[],"mappings":""}

package/dist/src/multiaddr-connection.d.ts

@@ -1,25 +0,0 @@
-import type { MessageStream, MessageStreamTimeline } from './message-stream.ts';
-import type { Multiaddr } from '@multiformats/multiaddr';
-export interface MultiaddrConnectionTimeline extends MessageStreamTimeline {
-    /**
-     * When the MultiaddrConnection was upgraded to a Connection - the type of
-     * connection encryption and multiplexing was negotiated.
-     */
-    upgraded?: number;
-}
-/**
- * A MultiaddrConnection is returned by a transport after dialing a peer. It is
- * a low-level primitive and is the raw connection, typically without encryption
- * or stream multiplexing.
- */
-export interface MultiaddrConnection extends MessageStream<MultiaddrConnectionTimeline> {
-    /**
-     * The address of the remote end of the connection
-     */
-    remoteAddr: Multiaddr;
-    /**
-     * When stream life cycle events occurred
-     */
-    timeline: MultiaddrConnectionTimeline;
-}
-//# sourceMappingURL=multiaddr-connection.d.ts.map

package/dist/src/multiaddr-connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiaddr-connection.d.ts","sourceRoot":"","sources":["../../src/multiaddr-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,MAAM,WAAW,2BAA4B,SAAQ,qBAAqB;IACxE;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,aAAa,CAAC,2BAA2B,CAAC;IACrF;;OAEG;IACH,UAAU,EAAE,SAAS,CAAA;IAErB;;OAEG;IACH,QAAQ,EAAE,2BAA2B,CAAA;CACtC"}

package/dist/src/multiaddr-connection.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=multiaddr-connection.js.map

package/dist/src/multiaddr-connection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiaddr-connection.js","sourceRoot":"","sources":["../../src/multiaddr-connection.ts"],"names":[],"mappings":""}

package/dist/src/stream.d.ts

@@ -1,63 +0,0 @@
-import type { AbortOptions } from './index.ts';
-import type { MessageStream, MessageStreamReadStatus, MessageStreamWriteStatus } from './message-stream.js';
-/**
- * A Stream is a lightweight data channel between two peers that can be written
- * to and read from at both ends.
- *
- * It is half-closable - that is in order for it to be closed fully and any
- * associated memory reclaimed, both ends must close their writeable end of the
- * stream.
- *
- * It's also possible to close the readable end of the stream, but this depends
- * on the underlying stream muxer supporting this operation which not all do.
- */
-export interface Stream extends MessageStream {
-    /**
-     * Unique identifier for a stream. Identifiers are not unique across muxers.
-     */
-    id: string;
-    /**
-     * The protocol negotiated for this stream
-     */
-    protocol: string;
-    /**
-     * The status of the readable end of the stream
-     */
-    readStatus: MessageStreamReadStatus;
-    /**
-     * The status of the writable end of the stream
-     */
-    writeStatus: MessageStreamWriteStatus;
-    /**
-     * The status of the readable end of the remote end of the stream - n.b. this
-     * requires the underlying stream transport to support sending STOP_SENDING
-     * messages or similar.
-     */
-    remoteReadStatus: MessageStreamReadStatus;
-    /**
-     * The status of the writable end of the remote end of the stream
-     */
-    remoteWriteStatus: MessageStreamWriteStatus;
-    /**
-     * Close stream for writing and return a promise that resolves once any
-     * pending data has been passed to the underlying transport.
-     *
-     * Note that the stream itself will remain readable until the remote end also
-     * closes it's writable end.
-     *
-     * To close without waiting for the remote, call `.abort` instead. If you want
-     * to wait for data to be sent first, ensure if the `.writableStatus` property
-     * is not 'paused', if it is, wait for a `drain` event before aborting.
-     */
-    close(options?: AbortOptions): Promise<void>;
-    /**
-     * Send a message to the remote end of the stream informing them that any
-     * incoming data will be discarded so they should stop sending.
-     *
-     * This requires the underlying resource to support this operation - for
-     * example the QUIC, WebTransport, WebRTC transports do but anything
-     * multiplexed using Yamux or Mplex do not.
-     */
-    closeRead(options?: AbortOptions): Promise<void>;
-}
-//# sourceMappingURL=stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAE3G;;;;;;;;;;GAUG;AACH,MAAM,WAAW,MAAO,SAAQ,aAAa;IAC3C;;OAEG;IACH,EAAE,EAAE,MAAM,CAAA;IAEV;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,UAAU,EAAE,uBAAuB,CAAA;IAEnC;;OAEG;IACH,WAAW,EAAE,wBAAwB,CAAA;IAErC;;;;OAIG;IACH,gBAAgB,EAAE,uBAAuB,CAAA;IAEzC;;OAEG;IACH,iBAAiB,EAAE,wBAAwB,CAAA;IAE3C;;;;;;;;;;OAUG;IACH,KAAK,CAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7C;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjD"}

package/dist/src/stream.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=stream.js.map

package/dist/src/stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":""}

package/src/connection-protector.ts

@@ -1,9 +0,0 @@
-import type { AbortOptions, MessageStream } from './index.ts'
-
-export interface ConnectionProtector {
-  /**
-   * Takes a MessageStream and creates a private encryption stream between
-   * the two peers from the shared key the Protector instance was created with.
-   */
-  protect (connection: MessageStream, options?: AbortOptions): Promise<MessageStream>
-}

package/src/events.ts

@@ -1,44 +0,0 @@
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-/**
- * A custom implementation of MessageEvent as the Undici version does too much
- * validation in it's constructor so is very slow.
- */
-export class StreamMessageEvent extends Event {
-  public data: Uint8Array | Uint8ArrayList
-
-  constructor (data: Uint8Array | Uint8ArrayList, eventInitDict?: EventInit) {
-    super('message', eventInitDict)
-
-    this.data = data
-  }
-}
-
-/**
- * An event dispatched when the stream is closed. The `error` property can be
- * inspected to discover if the closing was graceful or not, and the `remote`
- * property shows which end of the stream initiated the closure
- */
-export class StreamCloseEvent extends Event {
-  public error?: Error
-  public local?: boolean
-
-  constructor (local?: boolean, error?: Error, eventInitDict?: EventInit) {
-    super('close', eventInitDict)
-
-    this.error = error
-    this.local = local
-  }
-}
-
-export class StreamAbortEvent extends StreamCloseEvent {
-  constructor (error: Error, eventInitDict?: EventInit) {
-    super(true, error, eventInitDict)
-  }
-}
-
-export class StreamResetEvent extends StreamCloseEvent {
-  constructor (error: Error, eventInitDict?: EventInit) {
-    super(false, error, eventInitDict)
-  }
-}