@libp2p/webtransport 5.0.51-8484de8a2 → 5.0.51-87bc8d4fb

package/src/muxer.ts

@@ -1,79 +1,103 @@
-import { AbstractStreamMuxer } from '@libp2p/utils'
 import { webtransportBiDiStreamToStream } from './stream.js'
-import type { WebTransportStream } from './stream.ts'
+import { inertDuplex } from './utils/inert-duplex.js'
 import type WebTransport from './webtransport.js'
-import type { CreateStreamOptions, MultiaddrConnection, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface'
+import type { Logger, Stream, StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
 
-const PROTOCOL = '/webtransport'
+export interface WebTransportMuxerInit {
+  maxInboundStreams: number
+}
 
-class WebTransportStreamMuxer extends AbstractStreamMuxer<WebTransportStream> {
-  private webTransport: WebTransport
-  private streamIDCounter: number
-  private reader: ReadableStreamDefaultReader<WebTransportBidirectionalStream>
+export function webtransportMuxer (wt: Pick<WebTransport, 'close' | 'createBidirectionalStream'>, reader: ReadableStreamDefaultReader<WebTransportBidirectionalStream>, log: Logger, config: WebTransportMuxerInit): StreamMuxerFactory {
+  let streamIDCounter = 0
+  log = log.newScope('muxer')
 
-  constructor (webTransport: WebTransport, maConn: MultiaddrConnection) {
-    super(maConn, {
-      protocol: PROTOCOL,
-      name: 'muxer'
-    })
+  return {
+    protocol: 'webtransport',
+    createStreamMuxer: (init?: StreamMuxerInit): StreamMuxer => {
+      // !TODO handle abort signal when WebTransport supports this.
+      const activeStreams: Stream[] = []
 
-    this.webTransport = webTransport
-    this.streamIDCounter = 0
-    this.reader = this.webTransport.incomingBidirectionalStreams.getReader()
+      Promise.resolve()
+        .then(async () => {
+          //! TODO unclear how to add backpressure here?
+          while (true) {
+            const { done, value: wtStream } = await reader.read()
 
-    Promise.resolve()
-      .then(async () => {
-        //! TODO unclear how to add backpressure here?
-        while (true) {
-          const { done, value } = await this.reader.read()
+            if (done) {
+              break
+            }
 
-          if (done || value == null) {
-            break
+            if (activeStreams.length >= config.maxInboundStreams) {
+              log(`too many inbound streams open - ${activeStreams.length}/${config.maxInboundStreams}, closing new incoming stream`)
+              // We've reached our limit, close this stream.
+              wtStream.writable.close().catch((err: Error) => {
+                log.error(`failed to close inbound stream that crossed our maxInboundStream limit: ${err.message}`)
+              })
+              wtStream.readable.cancel().catch((err: Error) => {
+                log.error(`failed to close inbound stream that crossed our maxInboundStream limit: ${err.message}`)
+              })
+            } else {
+              const stream = await webtransportBiDiStreamToStream(
+                wtStream,
+                String(streamIDCounter++),
+                'inbound',
+                activeStreams,
+                init?.onStreamEnd,
+                log
+              )
+              activeStreams.push(stream)
+              init?.onIncomingStream?.(stream)
+            }
           }
+        })
+        .catch(err => {
+          log.error('could not create a new stream', err)
+        })
 
-          this.onRemoteStream(
-            webtransportBiDiStreamToStream(
-              value,
-              String(this.streamIDCounter++),
-              'inbound',
-              this.log,
-              this.streamOptions
-            )
-          )
-        }
-      })
-      .catch(err => {
-        this.log.error('could not create a new stream - %e', err)
-      })
-  }
+      const muxer: StreamMuxer = {
+        protocol: 'webtransport',
+        streams: activeStreams,
+        newStream: async (name?: string): Promise<Stream> => {
+          log('new outgoing stream', name)
 
-  async onCreateStream (options: CreateStreamOptions): Promise<WebTransportStream> {
-    const wtStream = await this.webTransport.createBidirectionalStream()
-    options?.signal?.throwIfAborted()
+          const wtStream = await wt.createBidirectionalStream()
+          const stream = await webtransportBiDiStreamToStream(wtStream, String(streamIDCounter++), init?.direction ?? 'outbound', activeStreams, init?.onStreamEnd, log)
+          activeStreams.push(stream)
 
-    return webtransportBiDiStreamToStream(
-      wtStream,
-      String(this.streamIDCounter++),
-      'outbound',
-      this.log,
-      options
-    )
-  }
+          return stream
+        },
 
-  onData (): void {
+        /**
+         * Close all tracked streams and stop the muxer
+         */
+        close: async () => {
+          log('closing webtransport muxer gracefully')
 
-  }
+          try {
+            wt.close()
+          } catch (err: any) {
+            muxer.abort(err)
+          }
+        },
 
-  sendReset (): void {
-    this.webTransport.close()
-  }
-}
+        /**
+         * Abort all tracked streams and stop the muxer
+         */
+        abort: (err: Error) => {
+          log('closing webtransport muxer with err:', err)
 
-export function webtransportMuxer (webTransport: WebTransport): StreamMuxerFactory {
-  return {
-    protocol: PROTOCOL,
-    createStreamMuxer (maConn: MultiaddrConnection): StreamMuxer {
-      return new WebTransportStreamMuxer(webTransport, maConn)
+          try {
+            wt.close()
+          } catch (err: any) {
+            log.error('webtransport session threw error during close', err)
+          }
+        },
+
+        // This stream muxer is webtransport native. Therefore it doesn't plug in with any other duplex.
+        ...inertDuplex()
+      }
+
+      return muxer
     }
   }
 }

package/src/stream.ts

@@ -1,118 +1,85 @@
-import { AbstractStream } from '@libp2p/utils'
+import { AbstractStream } from '@libp2p/utils/abstract-stream'
 import { raceSignal } from 'race-signal'
-import type { AbortOptions, MessageStreamDirection, Logger, StreamOptions } from '@libp2p/interface'
-import type { AbstractStreamInit, SendResult } from '@libp2p/utils'
-import type { Uint8ArrayList } from 'uint8arraylist'
+import { Uint8ArrayList } from 'uint8arraylist'
+import type { AbortOptions, Direction, Logger, Stream } from '@libp2p/interface'
+import type { AbstractStreamInit } from '@libp2p/utils/abstract-stream'
 
 interface WebTransportStreamInit extends AbstractStreamInit {
-  stream: WebTransportBidirectionalStream
+  bidiStream: WebTransportBidirectionalStream
 }
 
-export class WebTransportStream extends AbstractStream {
+class WebTransportStream extends AbstractStream {
   private readonly writer: WritableStreamDefaultWriter<Uint8Array>
   private readonly reader: ReadableStreamDefaultReader<Uint8Array>
 
   constructor (init: WebTransportStreamInit) {
     super(init)
 
-    this.writer = init.stream.writable.getWriter()
-    this.reader = init.stream.readable.getReader()
+    this.writer = init.bidiStream.writable.getWriter()
+    this.reader = init.bidiStream.readable.getReader()
 
-    void this.writer.closed
-      .then(() => {
-        this.log('writer closed gracefully')
-      })
-      .catch((err) => {
-        // chrome/ff send different messages
-        if (err.message.includes('STOP_SENDING') || err.message.includes('StopSending')) {
-          // err.code === 0 so we may be able to use this to detect remote close
-          // read instead?
-          this.onRemoteCloseRead()
-        } else if (err.message.includes('RESET_STREAM') || err.message.includes('Reset')) {
-          this.onRemoteReset()
-        } else {
-          this.log('writer close promise rejected - %e', err)
-        }
-      })
-
-    this.readData()
-  }
-
-  private readData (): void {
     Promise.resolve()
       .then(async () => {
         while (true) {
           const result = await this.reader.read()
 
-          if (result.value != null) {
-            this.onData(result.value)
-          }
-
           if (result.done) {
-            this.log('remote closed write')
-            this.onRemoteCloseWrite()
+            init.log('remote closed write')
             return
           }
 
-          if (this.readStatus === 'paused') {
-            break
+          if (result.value != null) {
+            this.sourcePush(new Uint8ArrayList(result.value))
           }
         }
       })
       .catch(err => {
+        init.log.error('error reading from stream', err)
         this.abort(err)
       })
       .finally(() => {
-        this.reader.releaseLock()
+        this.remoteCloseWrite()
       })
-  }
-
-  sendData (data: Uint8ArrayList): SendResult {
-    // the streams spec recommends not waiting for data to be sent
-    // https://streams.spec.whatwg.org/#example-manual-write-dont-await
-    for (const buf of data) {
-      this.writer.write(buf)
-        .catch(err => {
-          this.abort(err)
-        })
-    }
 
-    this.log.trace('desired size after sending %d bytes is %d bytes', data.byteLength, this.writer.desiredSize)
-
-    // null means the stream has errored - https://streams.spec.whatwg.org/#writable-stream-default-writer-get-desired-size
-    if (this.writer.desiredSize == null) {
-      return {
-        sentBytes: data.byteLength,
-        canSendMore: false
-      }
-    }
+    void this.writer.closed
+      .then(() => {
+        init.log('writer closed')
+      })
+      .catch((err) => {
+        init.log('writer close promise rejected', err)
+      })
+      .finally(() => {
+        this.remoteCloseRead()
+      })
+  }
 
-    const canSendMore = this.writer.desiredSize > 0
+  sendNewStream (options?: AbortOptions | undefined): void {
+    // this is a no-op
+  }
 
-    if (!canSendMore) {
-      this.writer.ready.then(() => {
-        this.safeDispatchEvent('drain')
-      }, (err) => {
-        this.abort(err)
-      })
-    }
+  async sendData (buf: Uint8ArrayList, options?: AbortOptions): Promise<void> {
+    for (const chunk of buf) {
+      this.log('sendData waiting for writer to be ready')
+      await raceSignal(this.writer.ready, options?.signal)
 
-    return {
-      sentBytes: data.byteLength,
-      canSendMore
+      // the streams spec recommends not waiting for data to be sent
+      // https://streams.spec.whatwg.org/#example-manual-write-dont-await
+      this.writer.write(chunk)
+        .catch(err => {
+          this.log.error('error sending stream data', err)
+        })
     }
   }
 
-  sendReset (err: Error): void {
-    this.writer.abort(err)
-      .catch(err => {
-        this.log.error('error aborting writer - %e', err)
-      })
+  async sendReset (options?: AbortOptions): Promise<void> {
+    this.log('sendReset aborting writer')
+    await raceSignal(this.writer.abort(), options?.signal)
+    this.log('sendReset aborted writer')
   }
 
   async sendCloseWrite (options?: AbortOptions): Promise<void> {
     this.log('sendCloseWrite closing writer')
-    await raceSignal(this.writer.close().catch(() => {}), options?.signal)
+    await raceSignal(this.writer.close(), options?.signal)
     this.log('sendCloseWrite closed writer')
   }
 
@@ -121,23 +88,23 @@ export class WebTransportStream extends AbstractStream {
     await raceSignal(this.reader.cancel(), options?.signal)
     this.log('sendCloseRead cancelled reader')
   }
-
-  sendPause (): void {
-
-  }
-
-  sendResume (): void {
-    this.readData()
-  }
 }
 
-export function webtransportBiDiStreamToStream (stream: WebTransportBidirectionalStream, streamId: string, direction: MessageStreamDirection, log: Logger, options?: StreamOptions): WebTransportStream {
-  return new WebTransportStream({
-    ...options,
-    stream,
+export async function webtransportBiDiStreamToStream (bidiStream: WebTransportBidirectionalStream, streamId: string, direction: Direction, activeStreams: Stream[], onStreamEnd: undefined | ((s: Stream) => void), log: Logger): Promise<Stream> {
+  const stream = new WebTransportStream({
+    bidiStream,
     id: streamId,
     direction,
     log: log.newScope(`${direction}:${streamId}`),
-    protocol: ''
+    onEnd: () => {
+      const index = activeStreams.findIndex(s => s === stream)
+      if (index !== -1) {
+        activeStreams.splice(index, 1)
+      }
+
+      onStreamEnd?.(stream)
+    }
   })
+
+  return stream
 }

package/src/utils/inert-duplex.ts

@@ -0,0 +1,21 @@
+import type { Duplex, Source } from 'it-stream-types'
+
+// Duplex that does nothing. Needed to fulfill the interface
+export function inertDuplex (): Duplex<any, any, any> {
+  return {
+    source: {
+      [Symbol.asyncIterator] () {
+        return {
+          async next () {
+            // This will never resolve
+            return new Promise(() => { })
+          }
+        }
+      }
+    },
+    sink: async (source: Source<any>) => {
+      // This will never resolve
+      return new Promise(() => { })
+    }
+  }
+}

package/src/utils/parse-multiaddr.ts

@@ -1,6 +1,6 @@
 import { InvalidMultiaddrError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { getNetConfig } from '@libp2p/utils'
+import { protocols } from '@multiformats/multiaddr'
 import { WebTransport } from '@multiformats/multiaddr-matcher'
 import { bases, digest } from 'multiformats/basics'
 import type { PeerId } from '@libp2p/interface'
@@ -17,7 +17,7 @@ function decodeCerthashStr (s: string): MultihashDigest {
 export interface ParsedMultiaddr {
   url: string
   certhashes: MultihashDigest[]
-  remotePeer: PeerId
+  remotePeer?: PeerId
 }
 
 export function parseMultiaddr (ma: Multiaddr): ParsedMultiaddr {
@@ -25,28 +25,20 @@ export function parseMultiaddr (ma: Multiaddr): ParsedMultiaddr {
     throw new InvalidMultiaddrError('Invalid multiaddr, was not a WebTransport address')
   }
 
-  const certhashes: MultihashDigest[] = []
-  let remotePeer: PeerId | undefined
+  const parts = ma.stringTuples()
+  const certhashes = parts
+    .filter(([name, _]) => name === protocols('certhash').code)
+    .map(([_, value]) => decodeCerthashStr(value ?? ''))
 
-  for (const components of ma.getComponents()) {
-    if (components.name === 'certhash') {
-      certhashes.push(decodeCerthashStr(components.value ?? ''))
-    }
+  // only take the first peer id in the multiaddr as it may be a relay
+  const remotePeer = parts
+    .filter(([name, _]) => name === protocols('p2p').code)
+    .map(([_, value]) => peerIdFromString(value ?? ''))[0]
 
-    // only take the first peer id in the multiaddr as it may be a relay
-    if (components.name === 'p2p' && remotePeer == null) {
-      remotePeer = peerIdFromString(components.value ?? '')
-    }
-  }
-
-  if (remotePeer == null) {
-    throw new InvalidMultiaddrError('Remote peer must be present in multiaddr')
-  }
-
-  const opts = getNetConfig(ma)
+  const opts = ma.toOptions()
   let host = opts.host
 
-  if (opts.type === 'ip6' && host.includes(':')) {
+  if (opts.family === 6 && host?.includes(':')) {
     /**
      * This resolves cases where `new WebTransport()` fails to construct because of an invalid URL being passed.
      *

package/dist/src/session-to-conn.d.ts

@@ -1,11 +0,0 @@
-import type { MultiaddrConnection } from '@libp2p/interface';
-import type { AbstractMultiaddrConnectionInit } from '@libp2p/utils';
-export interface WebTransportSessionMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name' | 'stream'> {
-    cleanUpWTSession(metric: string): void;
-}
-/**
- * Convert a socket into a MultiaddrConnection
- * https://github.com/libp2p/interface-transport#multiaddrconnection
- */
-export declare const toMultiaddrConnection: (init: WebTransportSessionMultiaddrConnectionInit) => MultiaddrConnection;
-//# sourceMappingURL=session-to-conn.d.ts.map

package/dist/src/session-to-conn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-to-conn.d.ts","sourceRoot":"","sources":["../../src/session-to-conn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgB,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC1E,OAAO,KAAK,EAAE,+BAA+B,EAAc,MAAM,eAAe,CAAA;AAGhF,MAAM,WAAW,0CAA2C,SAAQ,IAAI,CAAC,+BAA+B,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC1H,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACvC;AAoCD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM,0CAA0C,KAAG,mBAExF,CAAA"}

package/dist/src/session-to-conn.js

@@ -1,35 +0,0 @@
-import { AbstractMultiaddrConnection } from '@libp2p/utils';
-class WebTransportSessionMultiaddrConnection extends AbstractMultiaddrConnection {
-    cleanUpWTSession;
-    constructor(init) {
-        super(init);
-        this.cleanUpWTSession = init.cleanUpWTSession;
-    }
-    sendData(data) {
-        return {
-            sentBytes: data.byteLength,
-            canSendMore: true
-        };
-    }
-    sendReset() {
-        this.cleanUpWTSession('abort');
-    }
-    async sendClose(options) {
-        this.cleanUpWTSession('close');
-        options?.signal?.throwIfAborted();
-    }
-    sendPause() {
-        // TODO: backpressure?
-    }
-    sendResume() {
-        // TODO: backpressure?
-    }
-}
-/**
- * Convert a socket into a MultiaddrConnection
- * https://github.com/libp2p/interface-transport#multiaddrconnection
- */
-export const toMultiaddrConnection = (init) => {
-    return new WebTransportSessionMultiaddrConnection(init);
-};
-//# sourceMappingURL=session-to-conn.js.map

package/dist/src/session-to-conn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-to-conn.js","sourceRoot":"","sources":["../../src/session-to-conn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAS3D,MAAM,sCAAuC,SAAQ,2BAA2B;IACtE,gBAAgB,CAA0B;IAElD,YAAa,IAAgD;QAC3D,KAAK,CAAC,IAAI,CAAC,CAAA;QAEX,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAA;IAC/C,CAAC;IAED,QAAQ,CAAE,IAAoB;QAC5B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,UAAU;YAC1B,WAAW,EAAE,IAAI;SAClB,CAAA;IACH,CAAC;IAED,SAAS;QACP,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAChC,CAAC;IAED,KAAK,CAAC,SAAS,CAAE,OAAsB;QACrC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAA;QAC9B,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA;IACnC,CAAC;IAED,SAAS;QACP,sBAAsB;IACxB,CAAC;IAED,UAAU;QACR,sBAAsB;IACxB,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,IAAgD,EAAuB,EAAE;IAC7G,OAAO,IAAI,sCAAsC,CAAC,IAAI,CAAC,CAAA;AACzD,CAAC,CAAA"}

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

@@ -1,18 +0,0 @@
-import { AbstractMessageStream } from '@libp2p/utils';
-import type { AbortOptions } from '@libp2p/interface';
-import type { MessageStreamInit, SendResult } from '@libp2p/utils';
-import type { Uint8ArrayList } from 'uint8arraylist';
-export interface WebTransportMessageStreamInit extends MessageStreamInit {
-    stream: WebTransportBidirectionalStream;
-}
-export declare class WebTransportMessageStream extends AbstractMessageStream {
-    private writer;
-    private reader;
-    constructor(init: WebTransportMessageStreamInit);
-    close(options?: AbortOptions): Promise<void>;
-    sendData(data: Uint8ArrayList): SendResult;
-    sendReset(err: Error): void;
-    sendPause(): void;
-    sendResume(): void;
-}
-//# sourceMappingURL=webtransport-message-stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"webtransport-message-stream.d.ts","sourceRoot":"","sources":["../../../src/utils/webtransport-message-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,6BAA8B,SAAQ,iBAAiB;IACtE,MAAM,EAAE,+BAA+B,CAAA;CACxC;AAED,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,MAAM,CAAkC;gBAEnC,IAAI,EAAE,6BAA6B;IAwB1C,KAAK,CAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAInD,QAAQ,CAAE,IAAI,EAAE,cAAc,GAAG,UAAU;IAY3C,SAAS,CAAE,GAAG,EAAE,KAAK,GAAG,IAAI;IAO5B,SAAS,IAAK,IAAI;IAIlB,UAAU,IAAK,IAAI;CAGpB"}

package/dist/src/utils/webtransport-message-stream.js

@@ -1,49 +0,0 @@
-import { AbstractMessageStream } from '@libp2p/utils';
-import { raceSignal } from 'race-signal';
-export class WebTransportMessageStream extends AbstractMessageStream {
-    writer;
-    reader;
-    constructor(init) {
-        super(init);
-        this.writer = init.stream.writable.getWriter();
-        this.reader = init.stream.readable.getReader();
-        Promise.resolve().then(async () => {
-            while (true) {
-                const { done, value } = await this.reader.read();
-                if (value != null) {
-                    this.onData(value);
-                }
-                if (done) {
-                    break;
-                }
-            }
-        })
-            .catch(err => {
-            this.abort(err);
-        });
-    }
-    async close(options) {
-        await raceSignal(this.writer.close(), options?.signal);
-    }
-    sendData(data) {
-        this.writer.write(data.subarray())
-            .catch(err => {
-            this.abort(err);
-        });
-        return {
-            sentBytes: data.byteLength,
-            canSendMore: true
-        };
-    }
-    sendReset(err) {
-        this.writer.abort(err)
-            .catch(err => {
-            this.log.error('could not send reset - %e', err);
-        });
-    }
-    sendPause() {
-    }
-    sendResume() {
-    }
-}
-//# sourceMappingURL=webtransport-message-stream.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"webtransport-message-stream.js","sourceRoot":"","sources":["../../../src/utils/webtransport-message-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AASxC,MAAM,OAAO,yBAA0B,SAAQ,qBAAqB;IAC1D,MAAM,CAAkC;IACxC,MAAM,CAAkC;IAEhD,YAAa,IAAmC;QAC9C,KAAK,CAAC,IAAI,CAAC,CAAA;QAEX,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAA;QAC9C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAA;QAE9C,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YAChC,OAAO,IAAI,EAAE,CAAC;gBACZ,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;gBAEhD,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;oBAClB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;gBACpB,CAAC;gBAED,IAAI,IAAI,EAAE,CAAC;oBACT,MAAK;gBACP,CAAC;YACH,CAAC;QACH,CAAC,CAAC;aACC,KAAK,CAAC,GAAG,CAAC,EAAE;YACX,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACjB,CAAC,CAAC,CAAA;IACN,CAAC;IAED,KAAK,CAAC,KAAK,CAAE,OAAsB;QACjC,MAAM,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAA;IACxD,CAAC;IAED,QAAQ,CAAE,IAAoB;QAC5B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;aAC/B,KAAK,CAAC,GAAG,CAAC,EAAE;YACX,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACjB,CAAC,CAAC,CAAA;QAEJ,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,UAAU;YAC1B,WAAW,EAAE,IAAI;SAClB,CAAA;IACH,CAAC;IAED,SAAS,CAAE,GAAU;QACnB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;aACnB,KAAK,CAAC,GAAG,CAAC,EAAE;YACX,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,2BAA2B,EAAE,GAAG,CAAC,CAAA;QAClD,CAAC,CAAC,CAAA;IACN,CAAC;IAED,SAAS;IAET,CAAC;IAED,UAAU;IAEV,CAAC;CACF"}

package/src/session-to-conn.ts

@@ -1,50 +0,0 @@
-import { AbstractMultiaddrConnection } from '@libp2p/utils'
-import type { AbortOptions, MultiaddrConnection } from '@libp2p/interface'
-import type { AbstractMultiaddrConnectionInit, SendResult } from '@libp2p/utils'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export interface WebTransportSessionMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name' | 'stream'> {
-  cleanUpWTSession(metric: string): void
-}
-
-class WebTransportSessionMultiaddrConnection extends AbstractMultiaddrConnection {
-  private cleanUpWTSession: (metric: string) => void
-
-  constructor (init: WebTransportSessionMultiaddrConnectionInit) {
-    super(init)
-
-    this.cleanUpWTSession = init.cleanUpWTSession
-  }
-
-  sendData (data: Uint8ArrayList): SendResult {
-    return {
-      sentBytes: data.byteLength,
-      canSendMore: true
-    }
-  }
-
-  sendReset (): void {
-    this.cleanUpWTSession('abort')
-  }
-
-  async sendClose (options?: AbortOptions): Promise<void> {
-    this.cleanUpWTSession('close')
-    options?.signal?.throwIfAborted()
-  }
-
-  sendPause (): void {
-    // TODO: backpressure?
-  }
-
-  sendResume (): void {
-    // TODO: backpressure?
-  }
-}
-
-/**
- * Convert a socket into a MultiaddrConnection
- * https://github.com/libp2p/interface-transport#multiaddrconnection
- */
-export const toMultiaddrConnection = (init: WebTransportSessionMultiaddrConnectionInit): MultiaddrConnection => {
-  return new WebTransportSessionMultiaddrConnection(init)
-}