@fails-components/webtransport 1.0.0-rc.1 → 1.0.1

package/test/testinone.js

@@ -1,2854 +0,0 @@
-const SERVER_URL = 'https://127.0.0.1:8080'
-const CERT_HASH =
-  'CA:02:33:76:6C:0D:9B:2F:3C:49:82:CF:DE:7F:ED:CE:39:2B:48:9A:FE:67:8D:DD:2B:09:AF:33:E8:99:FE:EB'
-
-/**
- * WebTransport stream events
- * @typedef {import('../types').WebTransportStreamEventHandler} WebTransportStreamEventHandler
- * @typedef {import('../types').StreamRecvSignalEvent} StreamRecvSignalEvent
- * @typedef {import('../types').StreamReadEvent} StreamReadEvent
- * @typedef {import('../types').StreamWriteEvent} StreamWriteEvent
- * @typedef {import('../types').StreamNetworkFinishEvent} StreamNetworkFinishEvent
- *
- *  @typedef {import('../types').ReadDataInt} ReadDataInt
- */
-
-let processnextTick = (func) => setTimeout(func, 0)
-if (typeof process !== 'undefined') processnextTick = process.nextTick
-
-export class Http2WebTransportStream {
-  /**
-   * @param {{streamid: Number, capsuleParser: ParserBase}} args
-   * */
-  constructor({ streamid, capsuleParser }) {
-    /** @type {import('../stream').HttpWTStream} */
-    // @ts-ignore
-    this.jsobj = undefined // the creator will set this
-    this.readbuffer = new ArrayBuffer(64 * 1024)
-    this.readpos_ = 0
-    this.writepos_ = 0
-    this.bufferlen_ = 0
-    this.readbufsize_ = this.readbuffer.byteLength
-    this.streamid = streamid
-    /** @type {Array<ReadDataInt>} */
-    this.incomdata = []
-
-    this.capsuleParser = capsuleParser
-    /** @type {Array<Uint8Array>} */
-    this.outgochunks = []
-
-    this.final = false
-  }
-
-  /**
-   * @param {Object} obj
-   * @param {Uint8Array} obj.data
-   * @param {Boolean} obj.fin
-   */
-  recvData({ data, fin }) {
-    this.incomdata.push({ data, fin })
-    this.processRead()
-    if (this.incomdata.length > 0) {
-      // TODO tell the peer to stop sending by sending a capsule
-      // TODO SEND WT_STREAM_DATA_BLOCKED:
-    }
-  }
-
-  processRead() {
-    let bytesRead = 0
-    let fin = false
-
-    while (this.incomdata.length > 0 && this.bufferlen_ < this.readbufsize_) {
-      const cur = this.incomdata.shift()
-      if (cur.data) {
-        let len
-
-        if (this.writepos_ >= this.readpos_) {
-          len = Math.min(
-            this.readbufsize_ - this.writepos_,
-            cur.data.byteLength
-          )
-
-          const destview = new Uint8Array(
-            this.readbuffer,
-            0 + this.writepos_,
-            len
-          )
-          const srcview = new Uint8Array(
-            cur.data.buffer,
-            cur.data.byteOffset,
-            len
-          )
-          destview.set(srcview)
-
-          this.writepos_ = (this.writepos_ + len) % this.readbufsize_
-          this.bufferlen_ = this.bufferlen_ + len
-          bytesRead += len
-        } else {
-          // readpos_ > writepos_
-          len = Math.min(this.readpos_ - this.writepos_, cur.data.byteLength)
-          const destview = new Uint8Array(
-            this.readbuffer,
-            0 + this.writepos_,
-            len
-          )
-          const srcview = new Uint8Array(
-            cur.data.buffer,
-            cur.data.byteOffset,
-            len
-          )
-          destview.set(srcview)
-
-          this.writepos_ = (this.writepos_ + len) % this.readbufsize_
-          this.bufferlen_ = this.bufferlen_ + len
-          bytesRead += len
-        }
-        if (cur.data.byteLength !== len) {
-          this.incomdata.unshift({
-            data: new Uint8Array(
-              cur.data.buffer,
-              cur.data.byteOffset + len,
-              cur.data.byteLength - len
-            ),
-            fin: cur.fin
-          })
-          fin = false // next round
-        } else {
-          fin = fin || cur.fin
-        }
-      } else {
-        fin = fin || cur.fin
-      }
-    }
-
-    if (bytesRead > 0 || fin) {
-      this.jsobj.onStreamRead({
-        buffergrow: bytesRead,
-        fin,
-        success: true
-      })
-    }
-  }
-
-  /**
-   * @param {Number} bytesread
-   * @param {Number} pos
-   */
-  updateReadPos(bytesread, pos) {
-    this.readpos_ = pos
-    this.bufferlen_ -= bytesread
-    // well a good time to try to read again
-    this.processRead()
-  }
-
-  startReading() {}
-  stopReading() {}
-  /**
-   * @param {Number} code
-   */
-  stopSending(code) {
-    this.capsuleParser.writeCapsule({
-      type: ParserBase.WT_STOP_SENDING,
-      headerVints: [this.streamid, code],
-      payload: undefined
-    })
-    processnextTick(() =>
-      this.jsobj.onStreamNetworkFinish({
-        nettask: 'stopSending'
-      })
-    )
-  }
-
-  /**
-   * @param {Number} code
-   */
-  resetStream(code) {
-    this.capsuleParser.writeCapsule({
-      type: ParserBase.WT_RESET_STREAM,
-      headerVints: [this.streamid, code],
-      payload: undefined
-    })
-    processnextTick(() =>
-      this.jsobj.onStreamNetworkFinish({
-        nettask: 'resetStream'
-      })
-    )
-  }
-
-  /**
-   * @param {Uint8Array} buf
-   */
-  writeChunk(buf) {
-    this.outgochunks.push({ buf, fin: false })
-    this.drainWrites()
-  }
-
-  drainWrites() {
-    while (
-      this.outgochunks.length > 0 &&
-      (!this.capsuleParser.blocked || this.final)
-    ) {
-      const cur = this.outgochunks.shift()
-      const payload = cur.buf
-      this.capsuleParser.writeCapsule({
-        type: cur?.fin ? ParserBase.WT_STREAM_WFIN : ParserBase.WT_STREAM_WOFIN,
-        headerVints: [this.streamid],
-        payload
-      })
-      this.jsobj.onStreamWrite({
-        success: true
-      })
-    }
-  }
-
-  streamFinal() {
-    this.final = true
-    this.outgochunks.push({ fin: true })
-    this.drainWrites()
-    processnextTick(() =>
-      this.jsobj.onStreamNetworkFinish({
-        nettask: 'streamFinal'
-      })
-    )
-  }
-}
-
-/**
- * @param{Number} int
- * @returns {Number}
- */
-export function lengthVarInt(int) {
-  if (int < 64) return 1
-  if (int < 16384) return 2
-  if (int < 1073741824) return 4
-  /* if (int < 4611686018427387904 ) */
-  return 8
-}
-
-export class ParserBase {
-  static PADDING = 0x190b4d38
-  static WT_RESET_STREAM = 0x190b4d39
-  static WT_STOP_SENDING = 0x190b4d3a
-  static WT_STREAM_WOFIN = 0x190b4d3b
-  static WT_STREAM_WFIN = 0x190b4d3c
-  static WT_MAX_DATA = 0x190b4d3d
-  static WT_MAX_STREAM_DATA = 0x190b4d3e
-  static WT_MAX_STREAMS_BIDI = 0x190b4d3f
-  static WT_MAX_STREAMS_UNIDI = 0x190b4d40
-  static WT_DATA_BLOCKED = 0x190b4d41
-  static WT_STREAM_DATA_BLOCKED = 0x190b4d42
-  static WT_STREAMS_BLOCKED_UNIDI = 0x190b4d43
-  static WT_STREAMS_BLOCKED_BIDI = 0x190b4d44
-  static DATAGRAM = 0x00
-
-  /**
-   * @param {import('../types').ParserInit} arg
-   */
-  constructor({ nativesession, isclient }) {
-    this.session = nativesession
-    this.isclient = isclient
-    /** @type {boolean} */
-    this.blocked = false
-
-    this.wtstreams = new Map()
-  }
-
-  /**
-   * @abstract
-   * @param {Buffer|Uint8Array} data
-   */
-  parseData(data) {
-    throw new Error('Implement parseData in derived Class')
-  }
-
-  /**
-   * @abstract
-   * @param{{type: Number, headerVints: Array<Number>, payload: Uint8Array|undefined}} bs
-   */
-  writeCapsule({ type, headerVints, payload }) {
-    throw new Error('Implement writeCapsule in derived Class')
-  }
-
-  /**
-   * @param{{code: Number, reason: string}}arg
-   */
-  sendClose({ code, reason }) {}
-
-  /**
-   * @param {Number} streamid
-   */
-  newStream(streamid) {
-    const stream = new Http2WebTransportStream({
-      streamid,
-      capsuleParser: this
-    })
-    this.wtstreams.set(streamid, stream)
-    this.session.jsobj.onStream({
-      bidirectional: !(streamid & 0x2),
-      incoming: this.isclient ? !(streamid & 0x1) : !!(streamid & 0x1),
-      stream
-    })
-    return stream
-  }
-
-  drainWrites() {
-    for (const stream of this.wtstreams.values()) {
-      stream.drainWrites()
-    }
-  }
-}
-
-/**
- * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
- */
-function readVarInt(bs) {
-  let val = bs.buffer[bs.offset]
-  bs.offset++
-  const prefix = val >>> 6
-  const intlength = 1 << prefix
-
-  if (bs.offset + intlength - 1 > bs.size) {
-    return undefined
-  }
-  val = val & 0x3f
-  for (let i = 0; i < intlength - 1; i++) {
-    val = (val << 8) | bs.buffer[bs.offset]
-    bs.offset++
-  }
-  return val
-}
-
-/**
- * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
- * @param{Number} int
- */
-export function writeVarInt(bs, int) {
-  let numbytes = 8
-  let msb = 0xc0
-  if (int < 64) {
-    numbytes = 1
-    msb = 0x0
-  } else if (int < 16384) {
-    numbytes = 2
-    msb = 0x40
-  } else if (int < 1073741824) {
-    numbytes = 4
-    msb = 0x80
-  }
-  bs.buffer[bs.offset] = msb | ((int >>> ((numbytes - 1) * 8)) & 0xff)
-  bs.offset++
-
-  for (let i = numbytes - 2; i >= 0; i--) {
-    bs.buffer[bs.offset] = (int >>> (i * 8)) & 0xff
-    bs.offset++
-  }
-}
-
-export class BrowserParser extends ParserBase {
-  static WS_CONTINUE = 0x0
-  static WS_TEXT = 0x1
-  static WS_BINARY = 0x2
-  static WS_CLOSE = 0x8
-  static WS_PING = 0x9
-  static WS_PONG = 0xa
-  /**
-   * @param {import('../../types.js').ParserWebsocketInit} stream
-   */
-  constructor({ ws, nativesession, isclient }) {
-    super({ nativesession, isclient })
-    this.ws = ws
-    /** @type {Buffer|undefined} */
-    this.saveddata = undefined
-    /** @type {Number|undefined} */
-    this.rtype = undefined
-
-    this.closesend = false
-
-    this.ws.addEventListener('message', (event) => {
-      if (event.data instanceof ArrayBuffer) {
-        // binary frame
-        this.parseData(new Uint8Array(event.data, 0, event.data.byteLength))
-      } else {
-        // text frame
-        console.log('Illegal text frame', event.data)
-      }
-    })
-  }
-
-  /**
-   * @param {Uint8Array} data
-   */
-  parseData(data) {
-    const bufferstate = { offset: 0, size: data.byteLength, buffer: data }
-
-    const offsetend = bufferstate.size
-
-    const type = readVarInt(bufferstate)
-
-    // all safeguards passed now apply the mask
-
-    switch (type) {
-      case ParserBase.PADDING:
-        // only padding do nothing
-        break
-      case ParserBase.WT_RESET_STREAM:
-      case ParserBase.WT_STOP_SENDING:
-        {
-          const streamid = readVarInt(bufferstate)
-          const stream = this.wtstreams.get(streamid)
-          const code = readVarInt(bufferstate)
-          if (stream && typeof code !== 'undefined')
-            stream.jsobj.onStreamRecvSignal({
-              code,
-              nettask:
-                type === ParserBase.WT_RESET_STREAM
-                  ? 'resetStream'
-                  : 'stopSending'
-            })
-        }
-        break
-      case ParserBase.WT_STREAM_WOFIN:
-      case ParserBase.WT_STREAM_WFIN:
-        {
-          const streamid = readVarInt(bufferstate)
-
-          if (typeof streamid !== 'undefined') {
-            let object = this.wtstreams.get(streamid)
-            if (!object) {
-              object = this.newStream(streamid)
-            }
-            // TODO submit data
-            if (offsetend - bufferstate.offset >= 0) {
-              object.recvData({
-                data: new Uint8Array(
-                  bufferstate.buffer.buffer,
-                  bufferstate.buffer.byteOffset + bufferstate.offset,
-                  offsetend - bufferstate.offset
-                ),
-                fin: type === ParserBase.WT_STREAM_WFIN
-              })
-            }
-          }
-        }
-        break
-      case ParserBase.WT_MAX_DATA:
-        // this.recvSession({ maxdata: readVarInt(bufferstate), type })
-        break
-      case ParserBase.WT_MAX_STREAM_DATA:
-        /* {
-                  const streamid = readVarInt(bufferstate)
-                  const object = this.wtstreams.get(streamid)
-                  if (object)
-                    this.recvStream({
-                      maxstreamdata: readVarInt(bufferstate),
-                      type,
-                      object
-                    })
-                } */
-        break
-      case ParserBase.WT_MAX_STREAMS_BIDI:
-        // this.recvSession({ maxstreams: readVarInt(bufferstate), type })
-        break
-      case ParserBase.WT_MAX_STREAMS_UNIDI:
-        // this.recvSession({ maxstreams: readVarInt(bufferstate), type })
-        break
-      case ParserBase.WT_DATA_BLOCKED: // TODO
-        // this.recvSession({ maxdata: readVarInt(bufferstate), type })
-        break
-      case ParserBase.WT_STREAM_DATA_BLOCKED: // TODO
-        /* {
-                  const streamid = readVarInt(bufferstate)
-                  const object = this.wtstreams.get(streamid)
-                  if (object)
-                    this.recvStream({
-                      maxstreamdata: readVarInt(bufferstate),
-                      type,
-                      object
-                    })
-                } */
-        break
-      case ParserBase.WT_STREAMS_BLOCKED_UNIDI:
-        /* {
-                 const streamid = readVarInt(bufferstate)
-                  const object = this.wtstreams.get(streamid)
-                  if (object)
-                    this.recvStream({
-                      maxstreams: readVarInt(bufferstate),
-                      type,
-                      object
-                    })
-                } */
-        break
-      case ParserBase.WT_STREAMS_BLOCKED_BIDI:
-        /* {
-                  const streamid = readVarInt(bufferstate)
-                  const object = this.wtstreams.get(streamid)
-                  if (object)
-                    this.recvStream({
-                      maxstreams: readVarInt(bufferstate),
-                      type,
-                      streamid
-                    })
-                } */
-        break
-      case ParserBase.DATAGRAM:
-        this.session.jsobj.onDatagramReceived({
-          datagram: new Uint8Array(
-            bufferstate.buffer.buffer,
-            bufferstate.buffer.byteOffset + bufferstate.offset,
-            offsetend - bufferstate.offset
-          )
-        })
-
-        break
-      default:
-      // do nothing
-    }
-
-    bufferstate.offset = offsetend
-  }
-
-  /**
-   * @param{{type: Number, headerVints: Array<Number>, payload: Uint8Array|undefined}} bs
-   */
-  writeCapsule({ type, headerVints, payload }) {
-    let plength = 0
-    for (const ind in headerVints) plength += lengthVarInt(headerVints[ind])
-    plength += lengthVarInt(type)
-    const hlength = plength
-    if (payload) plength += payload.byteLength
-
-    const cdata = new Uint8Array(plength)
-    const bufferstate = { offset: 0, size: cdata.length, buffer: cdata }
-    writeVarInt(bufferstate, type)
-    for (const ind in headerVints) writeVarInt(bufferstate, headerVints[ind])
-    const dest = new Uint8Array(cdata.buffer, cdata.byteOffset + hlength)
-    if (payload) dest.set(payload)
-    this.ws.send(cdata)
-
-    /* const blocked = this.ws.bufferedAmount > 1024 * 256
-    // do something if blocked
-    if (blocked) this.blocked = true
-    return blocked */
-    return false
-  }
-
-  /**
-   * @param{{code: Number, reason: string}}arg
-   */
-  sendClose({ code, reason }) {
-    this.ws.close(1000, code.toString() + ':' + reason)
-  }
-}
-
-/**
- * @typedef {import('http2').Http2Stream} Http2Stream
- */
-
-export class Http2WebTransportSession {
-  /**
-   * @param {Object} obj
-   * @param {Http2Stream} [obj.stream]
-   * @param {WebSocket} [obj.ws]
-   * @param {boolean} obj.isclient
-   * @param {import('../types.js').CreateParserFunction} obj.createParser
-   */
-  constructor({ stream, ws, isclient, createParser }) {
-    // @ts-ignore
-    this.jsobj = undefined // the creator will set this
-    if (stream) {
-      this.stream = stream
-    } else if (ws) {
-      this.ws = ws
-    } else throw new Error('Neither stream or websocket supplied')
-    this.capsParser = createParser(this)
-    this.unidiId = 0
-    this.bidiId = 0
-    this.isclient = isclient
-    if (stream) {
-      if (isclient) {
-        stream.on('response', (headers) => {
-          processnextTick(() => {
-            if (headers[':status'] === 200) {
-              // on ready
-              this.jsobj.onReady({})
-            } else {
-              this.jsobj.onClose({
-                errorcode: headers[':status'],
-                error: 'Session stream errored'
-              })
-            }
-          })
-        })
-      } else {
-        processnextTick(() => {
-          this.jsobj.onReady({})
-        })
-      }
-      stream.on('close', () => {
-        if (!(this.jsobj.state === 'failed' || this.jsobj.state === 'closed')) {
-          this.jsobj.onClose({
-            errorcode: 0,
-            error: 'Session http/2 stream closed'
-          })
-        }
-      })
-    }
-  }
-
-  /**
-   * @param {Uint8Array} chunk
-   */
-  writeDatagram(chunk) {
-    this.capsParser.writeCapsule({
-      type: ParserBase.DATAGRAM,
-      headerVints: [],
-      payload: chunk
-    })
-    processnextTick(() => {
-      this.jsobj.onDatagramSend({})
-    })
-  }
-
-  orderUnidiStream() {
-    let streamid = 0x2 | (this.unidiId << 2)
-    if (this.isclient) streamid = streamid | 0x1
-    this.capsParser.writeCapsule({
-      type: ParserBase.WT_STREAM_WOFIN,
-      headerVints: [streamid],
-      payload: undefined
-    })
-    this.capsParser.newStream(streamid)
-    this.unidiId++
-  }
-
-  orderBidiStream() {
-    let streamid = 0x0 | (this.bidiId << 2)
-    if (this.isclient) streamid = streamid | 0x1
-    this.capsParser.writeCapsule({
-      type: ParserBase.WT_STREAM_WOFIN,
-      headerVints: [streamid],
-      payload: undefined
-    })
-    this.capsParser.newStream(streamid)
-    this.bidiId++
-  }
-
-  orderSessionStats() {
-    this.jsobj.onSessionStats({
-      timestamp: 0,
-      expiredOutgoing: 0n,
-      lostOutgoing: 0n,
-      // non Datagram
-      minRtt: 0,
-      smoothedRtt: 0,
-      rttVariation: 0,
-      estimatedSendRateBps: 0n
-    })
-  }
-
-  orderDatagramStats() {
-    this.jsobj.onDatagramStats({
-      timestamp: 0,
-      expiredOutgoing: 0n,
-      lostOutgoing: 0n
-    })
-  }
-
-  /*
-   * @returns {void}
-   */
-  notifySessionDraining() {}
-  /**
-   * @param {{ code: number, reason: string }} arg
-   */
-  close({ code, reason }) {
-    this.capsParser.sendClose({ code, reason }) // thid includes for ws closing the session!
-    // what to do with the reason
-    if (this.stream) {
-      if (this.stream.close) this.stream.close(code)
-      else if (this.stream.end) this.stream.end()
-      else throw new Error('http2:session not close method')
-    }
-  }
-}
-
-export class Http2WebTransportBrowser {
-  /**
-   * @param {import('../../types.js').NativeClientOptions} args
-   */
-  constructor(args) {
-    this.port = args?.port || 443
-    this.hostname = args?.host || 'localhost'
-    /** @type {import('../../session.js').HttpClient} */
-    // @ts-ignore
-    this.jsobj = undefined // the transport will set this
-    /** @type {WebSocket} */
-    // @ts-ignore
-    this.clientInt = undefined
-  }
-
-  /**
-   * @param {{path: string}} arg
-   */
-  createTransport({ path }) {
-    try {
-      let url = 'wss://' + this.hostname + ':' + this.port
-      if (path) url = url + '/' + path
-      // eslint-disable-next-line no-undef
-      this.clientInt = new WebSocket(url, ['webtransport'])
-    } catch (error) {
-      this.jsobj.onClientConnected({
-        success: false
-      })
-
-      return
-    }
-    this.clientInt.binaryType = 'arraybuffer'
-
-    this.clientInt.addEventListener('open', (event) => {
-      if (this.clientInt?.protocol === 'webtransport') {
-        this.jsobj.onClientWebTransportSupport({})
-        this.jsobj.onClientConnected({
-          success: true
-        })
-      } else {
-        if (this.clientInt) this.clientInt.close()
-        this.jsobj.onClientConnected({
-          success: false
-        })
-      }
-    })
-
-    this.clientInt.addEventListener('error', () => {
-      this.jsobj.onClientConnected({
-        success: false
-      })
-    })
-  }
-
-  /**
-   * @param {string} path
-   */
-  openWTSession(path) {
-    if (!this.clientInt) throw new Error('clientInt not present')
-    let sessobj
-
-    const retObj = {
-      session: new Http2WebTransportSession({
-        ws: this.clientInt,
-        isclient: true,
-        createParser: (
-          /** @type {Http2WebTransportSession} */ nativesession
-        ) => {
-          sessobj = nativesession
-          const session = new BrowserParser({
-            ws: this.clientInt,
-            nativesession,
-            isclient: true
-          })
-          if (this.clientInt)
-            this.clientInt.addEventListener('close', (event) => {
-              let code = event.code
-              let error = 'Session WebSocket closed'
-              if (event.reason) {
-                let tokens = event.reason.split(':')
-                if (tokens.length > 1) {
-                  code = parseInt(tokens[0])
-                  tokens = tokens.slice(1)
-                }
-                error = tokens.join(':')
-              }
-              nativesession.jsobj.onClose({
-                errorcode: code,
-                error
-              })
-            })
-          return session
-        }
-      }),
-      reliable: true
-    }
-    this.jsobj.onHttpWTSessionVisitor(retObj)
-
-    // @ts-ignore
-    sessobj.jsobj.onReady({})
-  }
-
-  closeClient() {
-    if (this.clientInt) this.clientInt.close()
-  }
-}
-
-/** @type {WeakMap<WebTransportBase, import('./session.js').HttpWTSession>} */
-
-/**
- * @typedef {import('./dom.js').WebTransportCloseInfo} WebTransportCloseInfo
- * @typedef {import('./dom.js').WebTransportBidirectionalStream} WebTransportBidirectionalStream
- * @typedef {import('./dom.js').WebTransportReceiveStream} WebTransportReceiveStream
- * @typedef {import('./session.js').HttpWTSession} HttpWTSession
- * @typedef { import('./session.js').HttpClient} HttpClient
- */
-
-/**
- * @template T
- * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
- */
-
-/**
- * @typedef {import('./dom.js').WebTransport} WebTransportInterface
- *
- * @implements {WebTransportInterface}
- */
-export class WebTransportBase {
-  /**
-   * @param {string} url
-   * @param {import('./dom.js').WebTransportOptions} [args]
-   */
-  constructor(url, args) {
-    if (!url) throw new Error('no URL supplied')
-
-    const ourl = new URL(url)
-
-    if (ourl.protocol !== 'https:') {
-      throw new Error('URL is not supported for webtransport')
-    }
-
-    const host = ourl.hostname
-    let port = ourl.port
-    if (port === '') port = '443'
-    const { sessionint, client } = this.createClient({ host, port, ...args })
-    this.ready = sessionint.ready
-    this.closed = sessionint.closed
-    this.draining = sessionint.draining
-
-    this.datagrams = sessionint.datagrams
-
-    this.incomingBidirectionalStreams = sessionint.incomingBidirectionalStreams
-
-    this.incomingUnidirectionalStreams =
-      sessionint.incomingUnidirectionalStreams
-
-    this.sessionint = sessionint
-
-    this.startUpConnection({ client, sessionint, ourl })
-  }
-
-  /**
-   * @param{import('./types.js').HttpWebTransportInit} args
-   * @return {{sessionint: HttpWTSession, client: HttpClient}}
-   * @abstract
-   */
-  createClient(args) {
-    throw new Error('Implement createClient')
-  }
-
-  /**
-   * @param{{client: HttpClient, sessionint: HttpWTSession, ourl: URL}} args
-   * @abstract
-   */
-  startUpConnection({ client, sessionint, ourl }) {
-    throw new Error('Implement createClient')
-  }
-
-  get reliability() {
-    const session = this.sessionint
-
-    if (!session) {
-      // should never happen as session is only removed when this instance is garbage collected
-      throw new Error('Http3WTSession was undefined')
-    }
-    return session.reliability
-  }
-
-  get congestionControl() {
-    const session = this.sessionint
-
-    if (!session) {
-      // should never happen as session is only removed when this instance is garbage collected
-      throw new Error('Http3WTSession was undefined')
-    }
-    return session.congestionControl
-  }
-
-  getStats() {
-    const session = this.sessionint
-
-    if (!session) {
-      // should never happen as session is only removed when this instance is garbage collected
-      throw new Error('Http3WTSession was undefined')
-    }
-    return session.getStats()
-  }
-
-  /**
-   * @param {WebTransportCloseInfo} [closeinfo]
-   */
-  close(closeinfo) {
-    const session = this.sessionint
-
-    if (!session) {
-      // should never happen as session is only removed when this instance is garbage collected
-      throw new Error('Http3WTSession was undefined')
-    }
-
-    return session.close(closeinfo)
-  }
-
-  createBidirectionalStream() {
-    const session = this.sessionint
-
-    if (!session) {
-      // should never happen as session is only removed when this instance is garbage collected
-      throw new Error('Http3WTSession was undefined')
-    }
-
-    return session.createBidirectionalStream()
-  }
-
-  createUnidirectionalStream() {
-    const session = this.sessionint
-
-    if (!session) {
-      // should never happen as session is only removed when this instance is garbage collected
-      throw new Error('Http3WTSession was undefined')
-    }
-
-    return session.createUnidirectionalStream()
-  }
-}
-
-export class WebTransportError extends Error {
-  /**
-   * @param {string} message
-   */
-  constructor(message) {
-    super(message)
-
-    this.name = this[Symbol.toStringTag] = 'WebTransportError'
-  }
-}
-
-/**
- * WebTransport stream events
- * @typedef {import('./types').WebTransportStreamEventHandler} WebTransportStreamEventHandler
- * @typedef {import('./types').StreamRecvSignalEvent} StreamRecvSignalEvent
- * @typedef {import('./types').StreamReadEvent} StreamReadEvent
- * @typedef {import('./types').StreamWriteEvent} StreamWriteEvent
- * @typedef {import('./types').StreamNetworkFinishEvent} StreamNetworkFinishEvent
- *
- * @typedef {import('./types').NativeHttpWTStream} NativeHttpWTStream
- *
- * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
- * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
- *
- * @typedef {import('./session').HttpWTSession} HttpWTSession
- *
- * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
- */
-
-export class HttpWTStream {
-  /**
-   * @param {object} args
-   * @param {NativeHttpWTStream} args.object
-   * @param {HttpWTSession} args.parentobj
-   * @param {object} args.transport
-   * @param {boolean} args.bidirectional
-   * @param {boolean} args.incoming
-   */
-  constructor(args) {
-    this.objint = args.object
-    this.objint.jsobj = this
-    this.parentobj = args.parentobj
-    this.transport = args.transport
-    this.bidirectional = args.bidirectional
-    this.incoming = args.incoming
-    this.closed = false
-
-    /** @type {Promise<void> | null} */
-    this.pendingoperation = null
-    this.pendingres = null
-
-    /** @type {WebTransportReceiveStream} */
-    this.readable // eslint-disable-line no-unused-expressions
-    /** @type {WebTransportSendStream} */
-    this.writable // eslint-disable-line no-unused-expressions
-
-    /** @type {Promise<void> | null} */
-    this.pendingoperationRead = null
-    this.pendingresRead = null
-
-    if (this.bidirectional || this.incoming) {
-      /** @type {Number} */
-      this.incomingbufferfilled = 0
-      /** @type {Number} */
-      this.incomingbufferreadpos = 0
-      if (!this.objint.readbuffer)
-        throw new Error('No readbuffer for read stream')
-      /** @type {WebTransportReceiveStream} */
-      // @ts-expect-error `getStats` property is missing from ReadableStream
-      this.readable = new ReadableStream(
-        {
-          start: (
-            /** @type {import("stream/web").ReadableByteStreamController} */ controller
-          ) => {
-            this.readableController = controller
-            this.objint.startReading()
-          },
-          pull: async (
-            /** @type {import("stream/web").ReadableByteStreamController} */ controller
-          ) => {
-            if (this.readableclosed) {
-              return Promise.resolve()
-            }
-
-            /** @type {Uint8Array} */
-            if (this.incomingbufferfilled === 0) {
-              this.pendingoperationRead = new Promise((resolve, reject) => {
-                this.pendingresRead = resolve
-              })
-              await this.pendingoperationRead
-            }
-            if (this.incomingbufferfilled === 0) return Promise.resolve()
-
-            this.drainBuffer()
-          },
-          cancel: (/** @type {{ code: number; }} */ reason) => {
-            /** @type {Promise<void>} */
-            const promise = new Promise((resolve, reject) => {
-              this.cancelres = resolve
-            })
-            let code = 0
-            if (reason && reason.code) {
-              if (reason.code < 0) code = 0
-              else if (reason.code > 255) code = 255
-              else code = reason.code
-            }
-            this.readableclosed = true
-            this.objint.stopSending(code)
-            return promise
-          },
-          type: 'bytes',
-          autoAllocateChunkSize: 4096 // lets take this as buffer size
-        }
-        // TODO fix stretegy
-      )
-      this.readable.getStats = () => {
-        return Promise.resolve({
-          timestamp: 0,
-          bytesReceived: 0n,
-          bytesRead: 0n
-        })
-      }
-      // @ts-ignore
-      this.parentobj.addReceiveStream(this.readable, this.readableController)
-    }
-    if (this.bidirectional || !this.incoming) {
-      /** @type {WebTransportSendStream} */
-      // @ts-expect-error `getStats` property is missing from WritableStream
-      this.writable = new WritableStream(
-        {
-          start: (controller) => {
-            this.writableController = controller
-          },
-          write: (chunk, controller) => {
-            if (this.writableclosed) {
-              return Promise.resolve()
-            }
-            let wchunk = chunk
-            if (wchunk instanceof ArrayBuffer) {
-              wchunk = new Uint8Array(wchunk)
-            }
-            if (wchunk instanceof Uint8Array) {
-              this.pendingoperation = new Promise((resolve, reject) => {
-                this.pendingres = resolve
-              })
-              this.parentobj
-                .waitForDatagramsSend()
-                .finally(() => {
-                  this.objint.writeChunk(wchunk)
-                })
-                .catch((/** @type {any} */ err) => {
-                  log.error(err)
-                })
-              return this.pendingoperation
-            } else {
-              log.trace('chunk info:', chunk)
-              throw new Error(
-                'chunk is not of instanceof Uint8Array or Arraybuffer'
-              )
-            }
-          },
-          close: () => {
-            if (this.writableclosed) {
-              return Promise.resolve()
-            }
-            this.objint.streamFinal()
-            this.pendingoperation = new Promise((resolve, reject) => {
-              this.pendingres = resolve
-            })
-            return this.pendingoperation
-          },
-          abort: (reason) => {
-            if (this.writableclosed) {
-              return new Promise((resolve, reject) => {
-                resolve()
-              })
-            }
-            let code = 0
-            if (reason && reason.code) {
-              if (reason.code < 0) code = 0
-              else if (reason.code > 255) code = 255
-              else code = reason.code
-            }
-            /** @type {Promise<void>} */
-            const promise = new Promise((resolve, reject) => {
-              this.abortres = resolve
-            })
-            this.objint.resetStream(code)
-            return promise
-          }
-        },
-        { highWaterMark: 4 }
-      )
-      this.writable.getStats = () => {
-        return Promise.resolve({
-          timestamp: 0,
-          bytesWritten: 0n,
-          bytesSent: 0n,
-          bytesAcknowledged: 0n
-        })
-      }
-      // @ts-ignore
-      this.parentobj.addSendStream(this.writable, this.writableController)
-    }
-
-    /** @type {(() => void) | null} */
-    this.cancelres = null
-    /** @type {(() => void) | null} */
-    this.pendingres = null
-    /** @type {(() => void) | null} */
-    this.abortres = null
-  }
-
-  drainBuffer() {
-    const byob = this.readableController.byobRequest
-    if (byob) {
-      // @ts-ignore
-      const view = byob?.view
-      // @ts-ignore
-      if (!(view instanceof Uint8Array)) {
-        throw new Error('byob view is not a Uint8Array')
-      }
-      let toread = Math.min(view.byteLength, this.incomingbufferfilled)
-      let read = 0
-      if (!this.objint.readbuffer)
-        throw new Error('No readbuffer in read for read stream')
-      if (
-        this.incomingbufferreadpos + toread >
-        this.objint.readbuffer.byteLength
-      ) {
-        /** @type {Number} */
-        const firstread =
-          this.objint.readbuffer.byteLength - this.incomingbufferreadpos
-        read += firstread
-        toread -= firstread
-        const destview = new Uint8Array(
-          view.buffer,
-          0 + view.byteOffset,
-          firstread
-        )
-        const srcview = new Uint8Array(
-          this.objint.readbuffer,
-          this.incomingbufferreadpos,
-          firstread
-        )
-        destview.set(srcview)
-        this.incomingbufferreadpos = 0
-      }
-      {
-        const destview = new Uint8Array(
-          view.buffer,
-          read + view.byteOffset,
-          toread
-        )
-        const srcview = new Uint8Array(
-          this.objint.readbuffer,
-          this.incomingbufferreadpos,
-          toread
-        )
-        destview.set(srcview)
-        read += toread
-        this.incomingbufferreadpos =
-          (this.incomingbufferreadpos + toread) %
-          this.objint.readbuffer.byteLength
-      }
-      // @ts-ignore
-      byob.respond(read)
-      this.incomingbufferfilled -= read
-      this.objint.updateReadPos(read, this.incomingbufferreadpos)
-    } else {
-      let toread = this.incomingbufferfilled
-      const toqueue = new Uint8Array(toread)
-      let read = 0
-      if (!this.objint.readbuffer)
-        throw new Error('No readbuffer in read for read stream')
-      if (
-        this.incomingbufferreadpos + toread >
-        this.objint.readbuffer.byteLength
-      ) {
-        /** @type {Number} */
-        const firstread =
-          this.objint.readbuffer.byteLength - this.incomingbufferreadpos
-        read += firstread
-        toread -= firstread
-        const destview = new Uint8Array(
-          toqueue.buffer,
-          0 + toqueue.byteOffset,
-          firstread
-        )
-        const srcview = new Uint8Array(
-          this.objint.readbuffer,
-          this.incomingbufferreadpos,
-          firstread
-        )
-        destview.set(srcview)
-        this.incomingbufferreadpos = 0
-      }
-      {
-        const destview = new Uint8Array(
-          toqueue.buffer,
-          read + toqueue.byteOffset,
-          toread
-        )
-        const srcview = new Uint8Array(
-          this.objint.readbuffer,
-          this.incomingbufferreadpos,
-          toread
-        )
-        destview.set(srcview)
-        read += toread
-        this.incomingbufferreadpos =
-          (this.incomingbufferreadpos + toread) %
-          this.objint.readbuffer.byteLength
-      }
-      this.readableController.enqueue(toqueue)
-
-      this.incomingbufferfilled -= read
-      this.pulledbytes += read
-      this.objint.updateReadPos(read, this.incomingbufferreadpos)
-    }
-  }
-
-  /**
-   * @param {import('./types').StreamRecvSignalEvent} args
-   * @returns {void}
-   */
-  onStreamRecvSignal(args) {
-    log('callback', args?.nettask)
-    log.trace('onStreamRecvSignal', args)
-    // check if transport is closed
-    let parentcleanup = true
-    const parentstate = this.parentobj.state
-    if (parentstate === 'closed' || parentstate === 'failed') {
-      log('no parent cleanup as parent was closed or failed')
-      parentcleanup = false
-    }
-    switch (args.nettask) {
-      case 'resetStream':
-        if (this.readable) {
-          if (parentcleanup)
-            this.parentobj.removeReceiveStream(
-              this.readable,
-              this.readableController
-            )
-          this.readableclosed = true
-          this.readableController.error(
-            new WebTransportError('Resetstream with code:' + (args.code || 0))
-          )
-        } else {
-          log.error('resetStream without readable')
-        }
-        break
-
-      case 'stopSending':
-        if (this.writable) {
-          if (parentcleanup)
-            this.parentobj.removeSendStream(
-              this.writable,
-              this.writableController
-            )
-
-          this.writableclosed = true
-          this.writableController.error(
-            new WebTransportError('StopSending with code:' + (args.code || 0))
-          )
-        } else {
-          log.error('stopSending without writable')
-        }
-        break
-      default:
-        log.error('unhandled onStreamRecvSignal')
-    }
-
-    if (this.pendingoperation) {
-      const res = this.pendingres
-      this.pendingoperation = null
-      this.pendingres = null
-      if (res != null) {
-        res()
-      }
-    }
-    if (this.pendingoperationRead) {
-      const res = this.pendingresRead
-      this.pendingoperationRead = null
-      this.pendingresRead = null
-      if (res != null) {
-        res()
-      }
-    }
-  }
-
-  /**
-   * @param {StreamReadEvent} args
-   * @returns {void}
-   */
-  onStreamRead(args) {
-    if (args.buffergrow && !this.readableclosed) {
-      log.trace('stream read received', args.buffergrow)
-      this.incomingbufferfilled += args.buffergrow
-      // console.log('stream read received', args.data, Date.now())
-      if (this.pendingoperationRead) {
-        // this.readableController.enqueue(data)
-        const res = this.pendingresRead
-        this.pendingoperationRead = null
-        this.pendingresRead = null
-        if (res) res()
-      }
-      if (
-        this.readableController.desiredSize != null &&
-        this.readableController.desiredSize < 0
-      )
-        this.objint.stopReading()
-    }
-    if (args.fin) {
-      if (this.incomingbufferfilled > 0) {
-        log.trace('Warning buffer filled and we got a fin')
-        if (this.pendingoperationRead || this.pendingresRead)
-          throw new Error('We have pendingoperationRead and a filled buffer?')
-
-        this.finalDrain()
-      }
-      if (this.cancelres) {
-        const res = this.cancelres
-        this.cancelres = null
-        res()
-      }
-      if (!this.readableclosed) {
-        this.readableController.close()
-        this.readableclosed = true
-      }
-    }
-  }
-
-  finalDrain() {
-    while (this.incomingbufferfilled > 0) this.drainBuffer()
-  }
-
-  /**
-   * @param {StreamWriteEvent} args
-   */
-  onStreamWrite(args) {
-    // we ignore success
-    if (this.pendingoperation) {
-      const res = this.pendingres
-      this.pendingoperation = null
-      this.pendingres = null
-      if (res != null) {
-        res()
-      }
-    }
-  }
-
-  /**
-   * @param {StreamNetworkFinishEvent} args
-   */
-  onStreamNetworkFinish(args) {
-    log('callback', args?.nettask)
-    log.trace('networkfinish args', args)
-    switch (args.nettask) {
-      case 'stopSending':
-        if (this.cancelres) {
-          const res = this.cancelres
-          this.cancelres = null
-          res()
-        }
-        this.stopSendingRecv = true
-        break
-      case 'resetStream':
-        if (this.abortres) {
-          const res = this.abortres
-          this.abortres = null
-          res()
-          if (this.readable)
-            this.parentobj.removeReceiveStream(
-              this.readable,
-              this.readableController
-            )
-          if (this.writable)
-            this.parentobj.removeSendStream(
-              this.writable,
-              this.writableController
-            )
-          this.readableclosed = true
-          this.parentobj.removeStreamObj(this)
-        }
-
-        break
-
-      case 'streamFinal':
-        if (this.pendingoperation) {
-          const res = this.pendingres
-          this.pendingoperation = null
-          this.pendingres = null
-          if (res != null) {
-            res()
-          }
-        }
-        break
-      default:
-        log.error('onStreamNetworkFinish unknown task', args.nettask)
-    }
-    // we could differentiate....
-  }
-}
-
-/**
- * WebTransport session events
- * @typedef {import('./types').WebTransportSessionEventHandler} WebTransportSessionEventHandler
- * @typedef {import('./types').SessionReadyEvent} SessionReadyEvent
- * @typedef {import('./types').SessionCloseEvent} SessionCloseEvent
- * @typedef {import('./types').DatagramReceivedEvent} DatagramReceivedEvent
- * @typedef {import('./types').DatagramSendEvent} DatagramSendEvent
- * @typedef {import('./types').GoawayReceivedEvent} GoawayReceivedEvent
- * @typedef {import('./types').DatagramStatsEvent} DatagramStatsEvent
- * @typedef {import('./types').SessionStatsEvent} SessionStatsEvent
- * @typedef {import('./types').NewStreamEvent} NewStreamEvent
- *
- * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
- * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
- * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
- * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
- * @typedef {import('./dom').WebTransportDatagramDuplexStream} WebTransportDatagramDuplexStream
- * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
- * @typedef {import('./dom').WebTransportCongestionControl} WebTransportCongestionControl
- * @typedef {import('./dom').WebTransportStats} WebTransportStats
- * @typedef {import('./dom').WebTransportDatagramStats} WebTransportDatagramStats
- *
- * @typedef {import('./types').NativeHttpWTSession} NativeHttpWTSession
- *
- * Public API
- * @typedef {import('./types').WebTransportSession} WebTransportSession
- *
- * @typedef {import('./server').HttpServer} HttpServer
- * @typedef {import('./client').HttpClient} HttpClient
- *
- * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
- */
-
-/**
- * @implements {WebTransportSessionEventHandler}
- * @implements {WebTransportSession}
- */
-export class HttpWTSession {
-  /**
-   * @param {object} args
-   * @param {import('./types').NativeHttpWTSession} [args.object]
-   * @param {HttpServer | HttpClient} args.parentobj
-   * @param {any | undefined} [args.header= undefined]
-   */
-  constructor(args) {
-    if (args.object) {
-      this.objint = args.object
-      this.objint.jsobj = this
-    }
-    this.parentobj = args.parentobj
-    /** @type {import('./types').WebTransportSessionState} */
-    this.state = 'connecting'
-
-    /** @type {((value?: any) => void) | null | undefined} */
-    this.readyResolve = null
-    /** @type {(() => void) | null | undefined} */
-    this.closeHook = null
-    /** @type {(any | null | undefined)} */
-    this.header = args.header
-
-    /** @type {Promise<void>} */
-    this.ready = new Promise((resolve, reject) => {
-      this.readyResolve = resolve
-      this.readyReject = reject
-    })
-    /** @type {WebTransportReliabilityMode} */
-    this.reliability = 'pending'
-    /** @type {WebTransportCongestionControl} */
-    this.congestionControl = 'default'
-    /** @type {Promise<WebTransportCloseInfo>} */
-    this.closed = new Promise((resolve, reject) => {
-      this.closedResolve = resolve
-      this.closedReject = reject
-    })
-
-    /** @type {Promise<undefined>} */
-    this.draining = new Promise((resolve, reject) => {
-      this.drainingResolve = resolve
-      this.drainingReject = reject
-    })
-
-    /** @type {ReadableStream<WebTransportBidirectionalStream>} */
-    this.incomingBidirectionalStreams = new ReadableStream({
-      /** @param {ReadableStreamDefaultController<WebTransportBidirectionalStream>} controller */
-      start: (controller) => {
-        this.incomBiDiController = controller
-      }
-    })
-    /** @type {ReadableStream<WebTransportReceiveStream>} */
-    this.incomingUnidirectionalStreams = new ReadableStream({
-      /** @param {ReadableStreamDefaultController<WebTransportReceiveStream>} controller */
-      start: (controller) => {
-        this.incomUniDiController = controller
-      }
-    })
-
-    /** @type {Array<() => void>} */
-    this.writeDatagramRes = []
-    /** @type {Array<(err?: Error) => void>} */
-    this.writeDatagramRej = []
-    /** @type {Array<Promise<void>>} */
-    this.writeDatagramProm = []
-
-    /** @type {WebTransportDatagramDuplexStream} */
-    this.datagrams = {
-      /** @type {ReadableStream<Uint8Array>} */
-      readable: new ReadableStream({
-        start: (
-          /** @type {import("stream/web").ReadableByteStreamController} */ controller
-        ) => {
-          this.incomDatagramController = controller
-        },
-        type: 'bytes'
-      }),
-      writable: new WritableStream({
-        start: (controller) => {
-          this.outgoDatagramController = controller
-        },
-        write: (chunk, controller) => {
-          if (this.state === 'closed') throw new Error('Session is closed')
-          if (chunk instanceof Uint8Array) {
-            /** @type {Promise<void>} */
-            const ret = new Promise((resolve, reject) => {
-              this.writeDatagramRes.push(resolve)
-              this.writeDatagramRej.push(reject)
-            })
-            this.writeDatagramProm.push(ret)
-            log.trace('b4 datagram write', chunk)
-            if (this.objint == null) {
-              throw new Error('this.objint is not set')
-            }
-            this.objint.writeDatagram(chunk)
-            return ret
-          } else throw new Error('chunk is not of type Uint8Array')
-        },
-        close: () => {
-          // do nothing
-        }
-      })
-    }
-
-    /** @type {Array<(stream: WebTransportBidirectionalStream) => void>} */
-    this.resolveBiDi = []
-    /** @type {Array<(stream: WebTransportSendStream) => void>} */
-    this.resolveUniDi = []
-    /** @type {Array<(err?: Error) => void>} */
-    this.rejectBiDi = []
-    /** @type {Array<(err?: Error) => void>} */
-    this.rejectUniDi = []
-
-    /** @type {Array<(stats: WebTransportStats) => void>} */
-    this.resolveSessionStats = []
-    /** @type {Array<(err?: Error) => void>} */
-    this.rejectSessionStats = []
-
-    /** @type {Array<(stats: WebTransportDatagramStats) => void>} */
-    this.resolveDatagramStats = []
-    /** @type {Array<(err?: Error) => void>} */
-    this.rejectDatagramStats = []
-
-    /** @type {Set<WebTransportSendStream>} */
-    this.sendStreams = new Set()
-    /** @type {Set<WebTransportReceiveStream>} */
-    this.receiveStreams = new Set()
-    /** @type {Set<HttpWTStream>} */
-    this.streamObjs = new Set()
-
-    /** @type {Set<WritableStreamDefaultController>} */
-    this.sendStreamsController = new Set()
-    /** @type {Set<ReadableStreamDefaultController>} */
-    this.receiveStreamsController = new Set()
-  }
-
-  /**
-   * @param {NativeHttpWTSession} object
-   * @param {boolean} reliable
-   */
-  setSessionObj(object, reliable) {
-    if (object) {
-      this.objint = object
-      this.objint.jsobj = this
-      this.reliable = !!reliable
-    }
-  }
-
-  getStats() {
-    if (this.objint == null) {
-      throw new Error('this.objint not set')
-    }
-    const prom = new Promise((resolve, reject) => {
-      this.resolveSessionStats.push(resolve)
-      this.rejectSessionStats.push(reject)
-    })
-    this.objint.orderSessionStats()
-    return prom
-  }
-
-  /**
-   * @param {SessionStatsEvent} evt
-   */
-  onSessionStats({
-    timestamp,
-    expiredOutgoing = BigInt(0),
-    lostOutgoing = BigInt(0),
-    // non Datagram
-    minRtt = 0,
-    smoothedRtt = 0,
-    rttVariation = 0,
-    estimatedSendRateBps
-  }) {
-    const res = this.resolveSessionStats.pop()
-    this.rejectSessionStats.pop()
-    if (res)
-      res({
-        timestamp,
-        bytesSent: BigInt(0),
-        packetsSent: BigInt(0),
-        packetsLost: BigInt(0),
-        numOutgoingStreamsCreated: 0,
-        numIncomingStreamsCreated: 0,
-        bytesReceived: BigInt(0),
-        packetsReceived: BigInt(0),
-        smoothedRtt,
-        rttVariation,
-        minRtt,
-        estimatedSendRate: estimatedSendRateBps,
-        datagrams: {
-          timestamp,
-          expiredOutgoing,
-          droppedIncoming: BigInt(0),
-          lostOutgoing
-        }
-      })
-  }
-
-  /**
-   * @param {DatagramStatsEvent} evt
-   */
-  onDatagramStats({
-    timestamp,
-    expiredOutgoing = BigInt(0),
-    lostOutgoing = BigInt(0)
-  }) {
-    const res = this.resolveDatagramStats.pop()
-    this.rejectDatagramStats.pop()
-    if (res)
-      res({
-        timestamp,
-        expiredOutgoing,
-        droppedIncoming: BigInt(0),
-        lostOutgoing
-      })
-  }
-
-  async waitForDatagramsSend() {
-    while (this.writeDatagramProm.length > 0) {
-      try {
-        await Promise.allSettled(this.writeDatagramProm)
-      } catch (error) {
-        log.error('datagram promise failed ', error)
-      }
-    }
-  }
-
-  notifySessionDraining() {
-    if (this.objint == null) {
-      throw new Error('this.objint not set')
-    }
-    this.objint.notifySessionDraining()
-  }
-
-  /**
-   * @param {HttpWTStream} stream
-   */
-  addStreamObj(stream) {
-    this.streamObjs.add(stream)
-  }
-
-  /**
-   * @param {HttpWTStream} stream
-   */
-  removeStreamObj(stream) {
-    this.streamObjs.delete(stream)
-  }
-
-  /**
-   * @param {WebTransportSendStream} stream
-   * @param {WritableStreamDefaultController} controller
-   */
-  addSendStream(stream, controller) {
-    this.sendStreams.add(stream)
-    this.sendStreamsController.add(controller)
-  }
-
-  /**
-   * @param {WebTransportSendStream} stream
-   * @param {WritableStreamDefaultController} controller
-   */
-  removeSendStream(stream, controller) {
-    this.sendStreams.delete(stream)
-    this.sendStreamsController.delete(controller)
-  }
-
-  /**
-   * @param {WebTransportReceiveStream } stream
-   * @param {ReadableStreamDefaultController} controller
-   */
-  addReceiveStream(stream, controller) {
-    this.receiveStreams.add(stream)
-    this.receiveStreamsController.add(controller)
-  }
-
-  /**
-   * @param {WebTransportReceiveStream } stream
-   * @param {ReadableStreamDefaultController} controller
-   */
-  removeReceiveStream(stream, controller) {
-    this.receiveStreams.delete(stream)
-    this.receiveStreamsController.delete(controller)
-  }
-
-  /**
-   * @returns {Promise<WebTransportBidirectionalStream>}
-   */
-  createBidirectionalStream() {
-    if (this.objint == null) {
-      throw new Error('this.objint not set')
-    }
-    /** @type {Promise<WebTransportBidirectionalStream>} */
-    const prom = new Promise((resolve, reject) => {
-      this.resolveBiDi.push(resolve)
-      this.rejectBiDi.push(reject)
-    })
-    this.objint.orderBidiStream()
-    return prom
-  }
-
-  /**
-   *@returns {Promise<WebTransportSendStream>}
-   */
-  createUnidirectionalStream() {
-    if (this.objint == null) {
-      throw new Error('this.objint not set')
-    }
-    /** @type {Promise<WebTransportSendStream>} */
-    const prom = new Promise((resolve, reject) => {
-      this.resolveUniDi.push(resolve)
-      this.rejectUniDi.push(reject)
-    })
-    this.objint.orderUnidiStream()
-    return prom
-  }
-
-  /**
-   * @param {object} [closeInfo]
-   * @param {number} closeInfo.closeCode
-   * @param {string} closeInfo.reason
-   * @returns {void}
-   */
-  close(closeInfo) {
-    log('closeinfo', closeInfo)
-    if (this.state === 'closed' || this.state === 'failed') return
-    if (this.objint) {
-      this.objint.close({
-        code: closeInfo?.closeCode ?? 0,
-        reason: closeInfo?.reason.substring(0, 1023) ?? ''
-      })
-    }
-  }
-
-  onReady(/* error */) {
-    this.state = 'connected'
-    if (!this.reliable) this.reliability = 'supports-unreliable'
-    else this.reliability = 'reliable-only'
-    if (this.readyResolve) this.readyResolve()
-    delete this.readyResolve
-  }
-
-  /**
-   * @param {SessionCloseEvent} args
-   */
-  onClose(args) {
-    delete this.objint // not valid any more
-
-    if (this.state !== 'connected') {
-      log.error(
-        'session was closed before state was "connected" - it was "%s"',
-        this.state
-      )
-      this.state = 'failed'
-
-      // make sure the event loop can still exit
-      if (this.closeHook) {
-        this.closeHook()
-        delete this.closeHook
-      }
-
-      // closed before connected
-      const error = new WebTransportError('Opening handshake failed.')
-      this.readyReject(error)
-      this.closedReject(error)
-      return
-    }
-
-    log('onClose')
-    this.streamObjs.forEach((ele) => ele.finalDrain())
-
-    const error = new WebTransportError('Session closed')
-
-    for (const rej of this.rejectBiDi) rej(error)
-    for (const rej of this.rejectUniDi) rej(error)
-    for (const rej of this.writeDatagramRej) rej(error)
-    for (const rej of this.rejectSessionStats) rej(error)
-    for (const rej of this.rejectDatagramStats) rej(error)
-
-    this.writeDatagramRej = []
-    this.writeDatagramRes = []
-    this.writeDatagramProm = []
-    this.resolveBiDi = []
-    this.resolveUniDi = []
-    this.rejectBiDi = []
-    this.rejectUniDi = []
-
-    this.resolveSessionStats = []
-    this.rejectSessionStats = []
-    this.resolveDatagramStats = []
-    this.rejectDatagramStats = []
-
-    this.incomBiDiController.close()
-    this.incomUniDiController.close()
-    this.incomDatagramController.close()
-    // this.outgoDatagramController.error(errorcode)
-    this.state = 'closed'
-
-    const wtError = new WebTransportError(
-      `Session closed (on process ${pid}) with code ` +
-        args.errorcode +
-        ' and reason' +
-        args.error
-    )
-
-    this.sendStreamsController.forEach((ele) => ele.error(wtError))
-    this.receiveStreamsController.forEach((ele) => ele.error(wtError))
-
-    this.streamObjs.forEach((ele) => (ele.readableclosed = true))
-
-    this.sendStreams.clear()
-    this.receiveStreams.clear()
-    this.sendStreamsController.clear()
-    this.receiveStreamsController.clear()
-    this.streamObjs.clear()
-
-    if (this.closedResolve)
-      this.closedResolve({
-        closeCode: args.errorcode,
-        reason: args.error ? args.error : ''
-      })
-    if (this.closeHook) {
-      this.closeHook()
-      delete this.closeHook
-    }
-  }
-
-  /**
-   * @param {NewStreamEvent} args
-   */
-  onStream(args) {
-    const strobj = new HttpWTStream({
-      object: args.stream,
-      parentobj: this,
-      transport: this.parentobj,
-      bidirectional: args.bidirectional,
-      incoming: args.incoming
-    })
-    this.addStreamObj(strobj)
-    if (args.incoming) {
-      if (args.bidirectional) {
-        this.incomBiDiController.enqueue(strobj)
-      } else {
-        this.incomUniDiController.enqueue(strobj.readable)
-      }
-    } else {
-      if (args.bidirectional) {
-        if (this.resolveBiDi.length === 0)
-          throw new Error('Got bidirectional stream without asking for it')
-        this.rejectBiDi.shift()
-        const curres = this.resolveBiDi.shift()
-
-        if (
-          curres != null &&
-          strobj.readable != null &&
-          strobj.writable != null
-        ) {
-          curres({
-            readable: strobj.readable,
-            writable: strobj.writable
-          })
-        }
-      } else {
-        if (this.resolveUniDi.length === 0)
-          throw new Error('Got unidirectional stream without asking for it')
-        this.rejectUniDi.shift()
-        const curres = this.resolveUniDi.shift()
-
-        if (curres != null && strobj.writable != null) {
-          curres(strobj.writable)
-        }
-      }
-    }
-  }
-
-  /**
-   * @param {DatagramReceivedEvent} args
-   */
-  onDatagramReceived(args) {
-    log.trace('datagram received', args.datagram)
-    // console.log('datagram received', args.datagram, Date.now())
-    if (this.incomDatagramController.byobRequest) {
-      /** @type {ReadableStreamBYOBRequest} */
-      const byob = this.incomDatagramController.byobRequest
-      /** @type {Uint8Array} */
-      // @ts-ignore
-      const view = byob?.view
-      // @ts-ignore
-      if (!(view instanceof Uint8Array))
-        throw new Error('byob view is not a Uint8Array')
-      if (view.byteLength < args.datagram.byteLength) {
-        throw new Error('supplied view is not large enough.')
-      }
-      const destview = new Uint8Array(
-        view.buffer,
-        0 + view.byteOffset,
-        args.datagram.byteLength
-      )
-      destview.set(args.datagram)
-      byob.respond(args.datagram.byteLength)
-    }
-    this.incomDatagramController.enqueue(new Uint8Array(args.datagram))
-  }
-
-  /**
-   * @param {DatagramSendEvent} args
-   */
-  onDatagramSend(args) {
-    if (this.state === 'closed') return
-    this.writeDatagramRej.shift()
-    this.writeDatagramProm.shift()
-    const res = this.writeDatagramRes.shift()
-
-    if (res != null) {
-      res()
-    }
-  }
-
-  /**
-   * @param {GoawayReceivedEvent} args
-   */
-  onGoAwayReceived(args) {
-    if (this.drainingResolve) this.drainingResolve(undefined)
-    this.state = 'draining'
-  }
-}
-
-const pid = typeof process !== 'undefined' ? process.pid : 0
-const log = console.log
-
-/**
- * @typedef {import('./session').HttpWTSession} HttpWTSession
- * @typedef {import('./types').HttpClientInit} HttpClientInit
- *
- * Http3Client events
- * @typedef {import('./types').HttpClientEventHandler} HttpClientEventHandler
- * @typedef {import('./types').ClientConnectedEvent} ClientConnectedEvent
- * @typedef {import('./types').ClientWebtransportSupportEvent} ClientWebtransportSupportEvent
- * @typedef {import('./types').HttpWTSessionVisitorEvent} HttpWTSessionVisitorEvent
- */
-
-/**
- * @implements {HttpClientEventHandler}
- */
-export class HttpClient {
-  /**
-   * @param {HttpClientInit} args
-   */
-  constructor(args) {
-    /** @type {HttpClientInit| undefined} */
-    this.args = args
-
-    /** @type {{ resolve: (value?: any) => void, reject: (err?: Error) => void} | null | undefined} */
-    this.sessionProm = null
-
-    /** @type {Promise<void> | undefined} */
-    this.sessionobj = new Promise((resolve, reject) => {
-      this.sessionProm = { resolve, reject }
-    }).catch(() => {}) // add default handler if no one cares
-    /** @type {HttpWTSession | null | undefined} */
-    this.sessionobjint = null
-    this.closeHookSession = this.closeHookSession.bind(this)
-
-    /** @type {{ resolve: (value?: any) => void, reject: (err?: Error) => void} | null | undefined} */
-    this.webtransportProm = null
-    /** @type {{ resolve: (value?: any) => void, reject: (err?: Error) => void} | null | undefined} */
-    this.quicconnectedProm = null
-
-    this._quicConnectTimeout = args.quicConnectTimeout ?? 8000
-    this._webTransportConnectTimeout = args.webTransportConnectTimeout ?? 2000
-  }
-
-  /**
-   * @param {Object} args
-   * @param {boolean} args.createTransport
-   * @param {string} args.path
-   */
-  async handleConnection({ createTransport, path }) {
-    if (createTransport) this.createTransportInt({ path })
-
-    this.quicconnected = new Promise((resolve, reject) => {
-      this.quicconnectedProm = { resolve, reject }
-    })
-    this.webtransport = new Promise((resolve, reject) => {
-      this.webtransportProm = { resolve, reject }
-    })
-
-    const timeout = setTimeout(() => {
-      if (this.quicconnectedProm) {
-        log.error('quic connection timeout')
-        this.quicconnectedProm.reject(
-          new WebTransportError('Opening handshake failed.')
-        )
-        delete this.quicconnectedProm
-      }
-    }, this._quicConnectTimeout)
-    try {
-      await this.quicconnected
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-
-  /**
-   * @param {HttpWTSession} sessionobj
-   * @param {string} path
-   * @returns
-   */
-  async createWTSession(sessionobj, path) {
-    // now create Webtransport session
-    const timeout = setTimeout(() => {
-      if (this.webtransportProm) {
-        log.error('webtransport connection timeout')
-        this.webtransportProm.reject(
-          new WebTransportError('Opening handshake failed.')
-        )
-        delete this.webtransportProm
-      }
-    }, this._webTransportConnectTimeout)
-    await this.webtransport // wait for webtransport support
-    clearTimeout(timeout)
-
-    // ok now we open the session
-    this.sessionobjint = sessionobj
-    this.transportInt.openWTSession(path)
-
-    // we wait for a new session
-    const sessobj = await this.sessionobj
-
-    delete this.sessionobj
-
-    return sessobj
-  }
-
-  closeHookSession() {
-    if (this.transportInt != null) {
-      this.transportInt.closeClient()
-    }
-
-    this.stopped = true
-  }
-
-  /**
-   * @param {import('./types').SessionCloseEvent} args
-   */
-  onClientError(args) {
-    if (this.sessionobjint != null) {
-      this.sessionobjint.onClose(args)
-    }
-  }
-
-  /**
-   * @param {ClientConnectedEvent} args
-   */
-  onClientConnected(args) {
-    this.transportIntSwitchToReliable = undefined
-    if (this.quicconnectedProm) {
-      if (args.success) this.quicconnectedProm.resolve()
-      else
-        this.quicconnectedProm.reject(
-          new WebTransportError('Opening handshake failed.')
-        )
-      delete this.quicconnectedProm
-    } else
-      throw new WebTransportError('Client connected with no pending promise')
-  }
-
-  /**
-   * @param {ClientWebtransportSupportEvent} args
-   */
-  onClientWebTransportSupport(args) {
-    if (this.webtransportProm) {
-      this.webtransportProm.resolve()
-      delete this.webtransportProm
-    }
-  }
-
-  /**
-   * @param {HttpWTSessionVisitorEvent} args
-   */
-  onHttpWTSessionVisitor(args) {
-    // create Http Visitor
-    if (args.session && this.sessionProm && this.sessionobjint) {
-      this.sessionobjint.setSessionObj(args.session, !!args.reliable)
-      args.session.jsobj.closeHook = this.closeHookSession
-      delete this.sessionobjint
-      this.sessionProm.resolve(args.session)
-      delete this.sessionProm
-    } else {
-      throw new WebTransportError(
-        'Http3WTSessionVisitor no object session or nor sessionprom'
-      )
-    }
-  }
-
-  /**
-   * @param{{path: string}} [args]
-   **/
-  createTransportInt(args) {
-    const path = args?.path
-    if (this.transportInt != null) {
-      return
-    }
-
-    try {
-      // @ts-ignore
-      if (this.args?.forceReliable || !this.args.createUnreliableClient) {
-        // internal option for unit tests only
-        // @ts-ignore
-        this.transportInt = this.args.createReliableClient(this)
-      } else {
-        // @ts-ignore
-        this.transportInt = this.args.createUnreliableClient(this)
-        if (!this.args?.requireUnreliable) {
-          const args = this.args
-          this.transportIntSwitchToReliable = () => {
-            if (this.transportInt != null) {
-              this.transportInt.closeClient()
-            }
-            // @ts-ignore
-            this.transportInt = args.createReliableClient(this)
-            this.transportInt.jsobj = this
-            if (this.transportInt.createTransport) {
-              this.transportInt.createTransport({ path })
-            }
-            this.transportIntSwitchToReliable = undefined
-          }
-        }
-      }
-    } catch (/** @type {any} */ err) {
-      const error = new WebTransportError('Opening handshake failed.')
-      error.stack = err.stack
-
-      throw error
-    }
-    delete this.args
-    this.transportInt.jsobj = this
-    if (this.transportInt.createTransport) {
-      this.transportInt.createTransport({ path })
-    }
-  }
-}
-
-/**
- * @typedef {import('./dom').WebTransport} WebTransport
- * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
- * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
- * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
- * @typedef {import('./error').WebTransportError} WebTransportError
- */
-
-/**
- * @template T
- * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
- */
-
-/**
- * @typedef {import('./dom').WebTransport} WebTransportInterface
- *
- * @implements {WebTransportInterface}
- */
-export class WebTransportPonyfill extends WebTransportBase {
-  /**
-   * @param{{client: HttpClient, sessionint: HttpWTSession, ourl: URL}} args
-   */
-  startUpConnection({ client, sessionint, ourl }) {
-    client
-      .handleConnection({ createTransport: true, path: ourl.pathname })
-      .then(() => client.createWTSession(sessionint, ourl.pathname))
-      .catch((error) => {
-        client.closeHookSession()
-        sessionint.readyReject(error)
-        sessionint.closedReject(error)
-      })
-  }
-
-  /**
-   * @param{import('./types.js').HttpWebTransportInit} args
-   * @return {{sessionint: HttpWTSession, client: HttpClient}}
-   */
-  createClient(args) {
-    const client = new HttpClient({
-      createReliableClient: (client) => {
-        // @ts-ignore
-        return new Http2WebTransportBrowser({ ...args })
-      },
-      ...args
-    })
-    const sessionint = new HttpWTSession({
-      /* object: args.session, */
-      parentobj: client
-    })
-    return { client, sessionint }
-  }
-}
-
-export class WebTransportPolyfill {
-  /**
-   * @param {string} url
-   * @param {import('./dom.js').WebTransportOptions} [args]
-   */
-  constructor(url, args) {
-    this.curtype = 'native'
-    this.closeset = false
-    this.allowFallback = true
-    this.initiatedFallback = false
-    this.args = args
-
-    this.closed = new Promise((resolve, reject) => {
-      this.closeRes = resolve
-      this.closeRej = reject
-    })
-
-    this.ready = new Promise((resolve, reject) => {
-      this.readyRes = resolve
-      this.readyRej = reject
-    })
-
-    this.draining = new Promise((resolve, reject) => {
-      this.drainingRes = resolve
-      this.drainingRej = reject
-    })
-
-    /** @type {WebTransport|WebTransportPonyfill} */
-    // @ts-ignore
-    // eslint-disable-next-line no-undef
-    this.curtransport = new WebTransport(url, args)
-
-    const initiateFallback = () => {
-      this.initiatedFallback = true
-      this.curtype = 'websocket'
-      this.curtransport = new WebTransportPonyfill(url, args)
-      this.curtransport.ready
-        .then((val) => this.readyRes(val))
-        .catch((error) => this.readyRej(error))
-      this.curtransport.closed
-        .then((val) => this.closeRes(val))
-        .catch((error) => this.closeRej(error))
-      this.curtransport.draining
-        .then((val) => this.drainingRes(val))
-        .catch((error) => this.drainingRej(error))
-    }
-
-    this.curtransport.ready
-      .then((val) => {
-        this.allowFallback = false
-        this.readyRes(val)
-      })
-      .catch((error) => {
-        if (this.allowFallback && !this.closeset) {
-          if (
-            !this.initiatedFallback &&
-            !this.curtransport?.reliability.supportsReliableOnly // way how browser signals support for http/2, no polyfill needed in this cases
-          ) {
-            initiateFallback()
-          }
-        } else {
-          this.readyRej(error)
-        }
-      })
-    this.curtransport.closed
-      .then((val) => {
-        if (this.curtype === 'native') this.closeRes(val)
-      })
-      .catch((error) => {
-        if (this.allowFallback && !this.closeset) {
-          if (
-            !this.initiatedFallback &&
-            !this.curtransport?.reliability?.supportsReliableOnly // way how browser signals support for http/2, no polyfill needed in this cases
-          ) {
-            initiateFallback()
-          }
-        } else {
-          this.closeRej(error)
-        }
-      })
-    if (this.curtransport.draining) {
-      // @ts-ignore
-      this.curtransport.draining
-        .then((/** @type {any} */ val) => {
-          if (this.curtype === 'native') this.drainingRes(val)
-        })
-        .catch((/** @type {WebTransportError} */ error) => {
-          if (this.curtype === 'native') this.drainingRej(error)
-        })
-    }
-    /** @type {import('./dom').WebTransportDatagramDuplexStream} */
-    // @ts-ignore
-    this.datagrams = {}
-    // @ts-ignore
-    // eslint-disable-next-line no-undef
-    this.datagrams.readable = new ReadableStream({
-      start: async (controller) => {
-        await this.ready
-        this.datagramsReader = this.curtransport.datagrams.readable.getReader()
-      },
-      pull: async (controller) => {
-        const { value, done } = await this.datagramsReader.read()
-        if (value) controller.enqueue(value)
-        if (done) controller.close()
-      },
-      cancel: async (reason) => {
-        await this.datagramsReader.cancel(reason)
-      }
-    })
-    // @ts-ignore
-    // eslint-disable-next-line no-undef
-    this.datagrams.writable = new WritableStream({
-      start: async (controller) => {
-        await this.ready
-        this.datagramsWriter = this.curtransport.datagrams.writable.getWriter()
-      },
-      write: async (chunk, controller) => {
-        await this.datagramsWriter.write(chunk)
-      },
-      abort: async (reason) => {
-        await this.datagramsWriter.abort(reason)
-      },
-      close: async () => {
-        await this.datagramsWriter.close()
-      }
-    })
-    // eslint-disable-next-line no-undef
-    this.incomingBidirectionalStreams = new ReadableStream({
-      start: async (controller) => {
-        await this.ready
-        this.incomingBidirectionalStreamsReader =
-          this.curtransport.incomingBidirectionalStreams.getReader()
-      },
-      pull: async (controller) => {
-        const { value, done } =
-          await this.incomingBidirectionalStreamsReader.read()
-        if (value) controller.enqueue(value)
-        if (done) controller.close()
-      },
-      cancel: async (reason) => {
-        await this.incomingBidirectionalStreamsReader.cancel(reason)
-      }
-    })
-    // eslint-disable-next-line no-undef
-    this.incomingUnidirectionalStreams = new ReadableStream({
-      start: async (controller) => {
-        await this.ready
-        this.incomingUnidirectionalStreamsReader =
-          this.curtransport.incomingUnidirectionalStreams.getReader()
-      },
-      pull: async (controller) => {
-        const { value, done } =
-          await this.incomingUnidirectionalStreamsReader.read()
-        if (value) controller.enqueue(value)
-        if (done) controller.close()
-      },
-      cancel: async (reason) => {
-        await this.incomingUnidirectionalStreamsReader.cancel(reason)
-      }
-    })
-  }
-
-  get congestionControl() {
-    // @ts-ignore
-    return this.curtransport?.congestionControl || undefined
-  }
-
-  get reliability() {
-    // @ts-ignore
-    return this.curtransport?.reliability || undefined
-  }
-
-  get supportsReliableOnly() {
-    return true
-  }
-
-  getStats() {
-    // @ts-ignore
-    return this.curtransport.getStats()
-  }
-
-  /**
-   * @param {WebTransportCloseInfo} [closeinfo]
-   */
-  close(closeinfo) {
-    this.closeset = true
-    this.curtransport.close(closeinfo)
-  }
-
-  async createBidirectionalStream() {
-    await this.ready
-    return await this.curtransport.createBidirectionalStream()
-  }
-
-  async createUnidirectionalStream() {
-    await this.ready
-    return await this.curtransport.createUnidirectionalStream()
-  }
-}
-
-// import { WebTransportPolyfill } from '../lib/index.browser'
-// @ts-nocheck
-let client
-
-const afterEach = async () => {
-  if (client != null) {
-    client.close()
-    client = undefined
-  }
-}
-
-class TimeoutError extends Error {
-  /**
-   * @param {string} message
-   */
-  constructor(message) {
-    super(message)
-
-    this.name = this[Symbol.toStringTag] = 'TimeoutError'
-  }
-}
-
-async function pTimeout(promise, timeout) {
-  let ref
-
-  const value = await Promise.race([
-    promise,
-    new Promise((resolve, reject) => {
-      ref = setTimeout(() => {
-        reject(new TimeoutError('timeout'))
-      }, timeout)
-    })
-  ])
-
-  clearTimeout(ref)
-
-  return value
-}
-
-async function getReaderValue(readableStream) {
-  const reader = readableStream.getReader()
-
-  try {
-    const { done, value } = await reader.read()
-
-    if (done) {
-      throw new Error('Stream ended')
-    }
-
-    if (!value) {
-      throw new Error('Stream value was undefined')
-    }
-
-    return value
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-async function readStream(readable, expected) {
-  const reader = readable.getReader()
-
-  try {
-    /** @type {T[]} */
-    const output = []
-
-    while (true) {
-      const { done, value } = await reader.read()
-
-      if (done) {
-        break
-      }
-
-      if (value != null) {
-        output.push(value)
-      }
-
-      if (expected != null && output.length === expected) {
-        break
-      }
-    }
-
-    return output
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-const KNOWN_BYTES = [
-  Uint8Array.from([0, 1, 2, 3, 4]),
-  Uint8Array.from([5, 6, 7, 8, 9]),
-  Uint8Array.from([10, 11, 12, 13, 14]),
-  Uint8Array.from([15, 16, 17, 18, 19]),
-  Uint8Array.from([20, 21, 22, 23, 24])
-]
-
-function readCertHash(certHash) {
-  return Uint8Array.from(`${certHash}`.split(':').map((i) => parseInt(i, 16)))
-}
-
-async function writeStream(writable, input) {
-  const writer = writable.getWriter()
-
-  for (const buf of input) {
-    await writer.ready
-    await writer.write(buf)
-  }
-
-  await writer.ready
-  await writer.releaseLock()
-  await writable.close()
-}
-
-async function main() {
-  {
-    client = new WebTransportPolyfill(
-      `${SERVER_URL}/bidirectional_client_initiated_echo`,
-      {
-        serverCertificateHashes: [
-          {
-            algorithm: 'sha-256',
-            value: readCertHash(CERT_HASH)
-          }
-        ]
-      }
-    )
-    await client.ready
-
-    const stream = await client.createBidirectionalStream()
-    await writeStream(stream.writable, KNOWN_BYTES)
-
-    await readStream(stream.readable, KNOWN_BYTES.length)
-  }
-  console.log('test 1 complete')
-  await afterEach()
-  {
-    // client context - waits for the server to open a bidi stream then pipes it back to them
-    client = new WebTransportPolyfill(
-      `${SERVER_URL}/bidirectional_server_initiated_echo`,
-      {
-        serverCertificateHashes: [
-          {
-            algorithm: 'sha-256',
-            value: readCertHash(CERT_HASH)
-          }
-        ]
-      }
-    )
-    await client.ready
-
-    const bidiStream = await getReaderValue(client.incomingBidirectionalStreams)
-
-    // redirect input to output
-    await bidiStream.readable.pipeTo(bidiStream.writable)
-
-    // the remote will close the session
-    await client.closed
-  }
-  console.log('test 2 complete')
-  await afterEach()
-  {
-    // client context - connects to the server, sends some datagrams and reads the response
-    client = new WebTransportPolyfill(`${SERVER_URL}/datagrams_client_send`, {
-      serverCertificateHashes: [
-        {
-          algorithm: 'sha-256',
-          value: readCertHash(CERT_HASH)
-        }
-      ]
-    })
-    await client.ready
-
-    const writer = client.datagrams.writable.getWriter()
-    let closed = false
-
-    // write datagrams until the server receives one and closes the connection
-    // eslint-disable-next-line promise/catch-or-return
-    Promise.resolve().then(async () => {
-      // eslint-disable-next-line no-unmodified-loop-condition
-      while (!closed) {
-        try {
-          await writer.ready
-          await writer.write(Uint8Array.from([0, 1, 2, 3, 4]))
-          await new Promise((resolve) => setTimeout(resolve, 100))
-        } catch {
-          // the session can be closed while we are writing
-        }
-      }
-    })
-
-    await client.closed
-    closed = true
-  }
-  console.log('test 3 complete')
-  await afterEach()
-  {
-    // client context - pipes the server's datagrams back to them
-    client = new WebTransportPolyfill(`${SERVER_URL}/datagrams_server_send`, {
-      serverCertificateHashes: [
-        {
-          algorithm: 'sha-256',
-          value: readCertHash(CERT_HASH)
-        }
-      ]
-    })
-    await client.ready
-
-    // datagram transport is unreliable, at least one message should make it through
-    const expected = 1
-
-    await pTimeout(readStream(client.datagrams.readable, expected), 1000)
-  }
-  console.log('test 4 complete')
-  await afterEach()
-
-  client = new WebTransportPolyfill(`${SERVER_URL}/session_close`, {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash(CERT_HASH)
-      }
-    ]
-  })
-  await client.ready
-
-  await client.closed
-  console.log('test 5 complete')
-
-  await afterEach()
-
-  client = new WebTransportPolyfill(`${SERVER_URL}/session_close_with_reason`, {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash(CERT_HASH)
-      }
-    ]
-  })
-  await client.ready
-
-  await client.closed
-  console.log('test 6 complete')
-  await afterEach()
-
-  client = new WebTransportPolyfill(`https://127.0.0.1:39821`, {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash(CERT_HASH)
-      }
-    ],
-    quicConnectTimeout: 100,
-    webTransportConnectTimeout: 100
-  })
-
-  await Promise.all([
-    client.closed.catch((err) => err),
-    client.ready.catch((err) => err)
-  ])
-  console.log('test 7 complete')
-  await afterEach()
-
-  client = new WebTransportPolyfill(`${SERVER_URL}/non_existant`, {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash(CERT_HASH)
-      }
-    ]
-  })
-
-  await Promise.all([
-    client.closed.catch((err) => err),
-    client.ready.catch((err) => err)
-  ])
-  console.log('test 8 complete')
-  await afterEach()
-
-  client = new WebTransportPolyfill(`${SERVER_URL}/session_close`, {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash(CERT_HASH + ':DE:AD:BE:EF')
-      }
-    ]
-  })
-
-  await Promise.all([
-    client.closed.catch((err) => err),
-    client.ready.catch((err) => err)
-  ])
-  console.log('test 10 complete')
-  await afterEach()
-  client = new WebTransportPolyfill(`${SERVER_URL}/session_close`, {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash('DE:AD:BE:EF:' + CERT_HASH?.substring(12))
-      }
-    ]
-  })
-
-  await Promise.all([
-    client.closed.catch((err) => err),
-    client.ready.catch((err) => err)
-  ])
-  console.log('test 11 complete')
-  await afterEach()
-  {
-    // client context - connects to the server, opens a bidi stream, sends some data and reads the response
-    try {
-      console.log('unidirectional mark1')
-      client = new WebTransportPolyfill(
-        `${SERVER_URL}/unidirectional_client_send`,
-        {
-          serverCertificateHashes: [
-            {
-              algorithm: 'sha-256',
-              value: readCertHash(CERT_HASH)
-            }
-          ]
-        }
-      )
-      console.log('unidirectional mark2')
-      await client.ready
-      console.log('unidirectional mark3')
-    } catch (error) {
-      console.log('Peak unidirectional error:', error)
-      throw error
-    }
-
-    const stream = await client.createUnidirectionalStream()
-    await writeStream(stream, KNOWN_BYTES)
-
-    // the remote will close the session
-    await client.closed
-  }
-  console.log('test 12 complete')
-  await afterEach()
-  {
-    client = new WebTransportPolyfill(
-      `${SERVER_URL}/unidirectional_server_send`,
-      {
-        serverCertificateHashes: [
-          {
-            algorithm: 'sha-256',
-            value: readCertHash(CERT_HASH)
-          }
-        ]
-      }
-    )
-    await client.ready
-
-    const stream = await getReaderValue(client.incomingUnidirectionalStreams)
-    await readStream(stream, KNOWN_BYTES.length)
-  }
-  console.log('test 13 complete')
-  await afterEach()
-  {
-    client = new WebTransportPolyfill(
-      `${SERVER_URL}/unidirectional_server_delay_before_read`,
-      {
-        serverCertificateHashes: [
-          {
-            algorithm: 'sha-256',
-            value: readCertHash(CERT_HASH)
-          }
-        ]
-      }
-    )
-    await client.ready
-
-    const clientStream = await client.createUnidirectionalStream()
-
-    const writer = clientStream.getWriter()
-
-    for (const buf of KNOWN_BYTES) {
-      await writer.ready
-      await writer.write(buf)
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 2000))
-
-    await writer.ready
-    await writer.close()
-
-    // the remote will close the session cleanly if everything was ok
-    await client.closed
-  }
-  console.log('test 14 complete')
-  await afterEach()
-}
-
-main().catch((error) => {
-  console.log('main error: ', error.toString())
-  console.dir(error)
-})