@libp2p/interface 2.11.0-8484de8a2 → 2.11.0-87bc8d4fb

package/src/stream-muxer.ts

@@ -1,160 +1,68 @@
-import type { Stream, TypedEventTarget, MessageStream, AbortOptions } from './index.js'
-
-/**
- * User-facing message stream muxer options
- */
-export interface StreamMuxerOptions<MuxedStreamOptions extends StreamOptions = StreamOptions> {
-  /**
-   * Configuration options for each outgoing/incoming stream
-   */
-  streamOptions?: MuxedStreamOptions
-
-  /**
-   * libp2p is notified of incoming streams via the muxer's 'stream' event.
-   *
-   * During connection establishment there may be a small window where a muxer
-   * starts to process incoming stream data before a listener has been added for
-   * the 'stream' event.
-   *
-   * If no handler is registered for this event incoming streams can be missed
-   * so when this is the case muxers queue streams internally as "early
-   * streams", and will defer emitting the 'stream' event until after a listener
-   * has been registered.
-   *
-   * Allowing an unlimited amount of early streams can cause excessive memory
-   * consumption so this setting controls how many early streams to store when
-   * no 'stream' listener has been registered.
-   *
-   * If more streams than this are opened before a listener is added the muxed
-   * connection will be reset.
-   *
-   * @default 10
-   */
-  maxEarlyStreams?: number
-
-  /**
-   * Maximum size of a message in bytes that we'll send on a stream - this
-   * ensures that a single stream doesn't hog a connection
-   *
-   * @default 65_536
-   */
-  maxMessageSize?: number
+import type { Direction, Stream } from './connection.js'
+import type { AbortOptions, Logger } from './index.js'
+import type { Duplex } from 'it-stream-types'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
+export interface StreamMuxerFactory {
   /**
-   * Maximum number of concurrent inbound streams that we accept - if the peer
-   * tries to open more streams, those will be reset immediately
-   *
-   * @default 1_000
+   * The protocol used to select this muxer during connection opening
    */
-  maxInboundStreams?: number
+  protocol: string
 
   /**
-   * Maximum number of concurrent outbound streams that we accept - if the
-   * application tries to open more streams, the call to `newStream` will throw
-   *
-   * @default 1_000
+   * Creates a new stream muxer to be used with a new connection
    */
-  maxOutboundStreams?: number
+  createStreamMuxer(init?: StreamMuxerInit): StreamMuxer
 }
 
 /**
- * User-facing message stream options
+ * A libp2p stream muxer
  */
-export interface StreamOptions {
-  /**
-   * If no data is sent or received in this number of ms the stream will be
-   * reset and an 'error' event emitted.
-   *
-   * @default 120_000
-   */
-  inactivityTimeout?: number
-
-  /**
-   * The maximum number of bytes to store when paused or before a 'message'
-   * event handler is added.
-   *
-   * If the internal buffer overflows this value the stream will be reset.
-   *
-   * @default 4_194_304
-   */
-  maxReadBufferLength?: number
-
-  /**
-   * The maximum number of bytes to store when the remote end of the stream is
-   * applying backpressure, or when it is slow to accept new bytes.
-   *
-   * If the internal buffer overflows this value the stream will be reset.
-   *
-   * @default Infinity
-   */
-  maxWriteBufferLength?: number
-}
-
-export interface StreamMuxerFactory<Muxer extends StreamMuxer = StreamMuxer> {
+export interface StreamMuxer extends Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>> {
   /**
    * The protocol used to select this muxer during connection opening
    */
   protocol: string
 
   /**
-   * Creates a new stream muxer to be used with a new connection
-   */
-  createStreamMuxer(maConn: MessageStream): Muxer
-}
-
-export interface StreamMuxerEvents<MuxedStream extends Stream = Stream> {
-  /**
-   * An incoming stream was created
+   * A list of streams that are currently open. Closed streams will not be returned.
    */
-  stream: CustomEvent<MuxedStream>
-}
-
-export interface CreateStreamOptions extends AbortOptions, StreamOptions {
+  readonly streams: Stream[]
   /**
-   * If a single protocol was requested and the muxer has support for this,
-   * pre-negotiate the protocol using this value, otherwise multistream-select
-   * will be run over the stream after opening.
+   * Initiate a new stream with the given name. If no name is
+   * provided, the id of the stream will be used.
    */
-  protocol?: string
-}
+  newStream(name?: string): Stream | Promise<Stream>
 
-export type StreamMuxerStatus = 'open' | 'closing' | 'closed'
-
-/**
- * A libp2p stream muxer
- */
-export interface StreamMuxer<MuxedStream extends Stream = Stream> extends TypedEventTarget<StreamMuxerEvents<MuxedStream>> {
   /**
-   * The protocol used to select this muxer during connection opening
+   * Close or abort all tracked streams and stop the muxer
    */
-  protocol: string
+  close(options?: AbortOptions): Promise<void>
 
   /**
-   * A list of streams that are currently open
+   * Close or abort all tracked streams and stop the muxer
    */
-  streams: MuxedStream[]
+  abort(err: Error): void
+}
 
+export interface StreamMuxerInit {
   /**
-   * The status of the muxer
+   * A callback function invoked every time an incoming stream is opened
    */
-  status: StreamMuxerStatus
+  onIncomingStream?(stream: Stream): void
 
   /**
-   * Create a new stream
+   * A callback function invoke every time a stream ends
    */
-  createStream(options?: CreateStreamOptions): MuxedStream | Promise<MuxedStream>
+  onStreamEnd?(stream: Stream): void
 
   /**
-   * Immediately close the muxer, abort every open stream and discard any
-   * unsent/unread data.
+   * Outbound stream muxers are opened by the local node, inbound stream muxers are opened by the remote
    */
-  abort (err: Error): void
+  direction?: Direction
 
   /**
-   * Gracefully close the muxer. All open streams will be gracefully closed, and
-   * the returned promise will either resolve when any/all unsent data has been
-   * sent, or it will reject if the passed abort signal fires before this
-   * happens.
+   * The logger used by the connection
    */
-  close (options?: AbortOptions): Promise<void>
+  log?: Logger
 }

package/src/topology.ts

@@ -40,11 +40,11 @@ export interface Topology {
    * Invoked when a new connection is opened to a peer that supports the
    * registered protocol
    */
-  onConnect?(peerId: PeerId, conn: Connection): void | Promise<void>
+  onConnect?(peerId: PeerId, conn: Connection): void
 
   /**
    * Invoked when the last connection to a peer that supports the registered
    * protocol closes
    */
-  onDisconnect?(peerId: PeerId): void | Promise<void>
+  onDisconnect?(peerId: PeerId): void
 }

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,145 +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 an 'error' event emitted.
-     */
-    maxReadBufferLength: 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;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAA;IAE3B;;;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":""}