@fails-components/webtransport 0.3.1 → 1.0.1

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.3.1",
+  "version": "1.0.1",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
-  "main": "lib/index.js",
-  "module": "lib/index.js",
+  "exports": {
+    ".": {
+      "node": "./lib/index.node.js",
+      "browser": "./lib/index.browser.js"
+    }
+  },
   "engines": {
     "node": ">=16.5"
   },
@@ -11,15 +15,14 @@
   "types": "./dist/lib/index.d.ts",
   "scripts": {
     "start": "node test/echoserver.js",
-    "test": "npm run test:node && npm run test:chromium",
-    "test:node": "node test/index.js node",
-    "test:chromium": "node test/index.js chromium",
+    "test": "npm run test:node && npm run test:node:http2 && npm run test:chromium && npm run test:chromium:http2:polyfill && npm run test:chromium:http2:ponyfill",
+    "test:node": "node test/index.js node http3",
+    "test:node:http2": "node test/index.js node http2",
+    "test:chromium": "node test/index.js chromium http3",
+    "test:chromium:http2:polyfill": "node test/index.js chromium http2 polyfill",
+    "test:chromium:http2:ponyfill": "node test/index.js chromium http2 ponyfill",
     "oldtest": "node old_test/test.js",
-    "install": "node build.js install",
-    "build": "node build.js build",
-    "rebuild": "node build.js rebuild",
-    "rebuild-debug": "node build.js rebuild-debug -D",
-    "build-debug": "node build.js build-debug",
+    "oldtesthttp2": "node old_test/test.js http2",
     "types": "tsc",
     "lint": "eslint lib test old_test"
   },
@@ -35,13 +38,11 @@
   "bugs": {
     "url": "https://github.com/fails-components/webtransport/issues"
   },
-  "homepage": "https://github.com/fails-components/webtransport#readme",
+  "homepage": "https://github.com/fails-components/webtransport/main/#readme",
   "dependencies": {
     "@types/debug": "^4.1.7",
     "bindings": "^1.5.0",
-    "debug": "^4.3.4",
-    "node-addon-api": "^4.3.0",
-    "prebuild-install": "^7.1.1"
+    "debug": "^4.3.4"
   },
   "devDependencies": {
     "@babel/core": "^7.17.10",
@@ -53,7 +54,6 @@
     "@types/node": "^18.15.3",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "cmake-js": "^6.3.2",
     "dirty-chai": "^2.0.1",
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^7.2.0",
@@ -77,6 +77,7 @@
     ]
   },
   "browser": {
-    "./test/fixtures/webtransport.js": "./test/fixtures/webtransport.browser.js"
+    "./test/fixtures/webtransport.js": "./test/fixtures/webtransport.browser.js",
+    "./lib/webstreams.js": "./lib/webstreams.browser.js"
   }
 }

package/readme.md

@@ -9,57 +9,121 @@ Macos tests on master ![master](https://github.com/fails-components/webtransport
 
 (c) 2022- Marten Richter
 
-The package provides Webtransport support to node.js .
+The package provides Webtransport support to node.js.
 
 This package is part of FAILS.
-A web based lecture system developed out of university lectures.
+A web-based lecture system developed out of university lectures.
 
 While FAILS as a whole is licensed via GNU Affero GPL version 3.0, this package is licensed under a BSD-style license that can be found in the LICENSE file, while code taken from other projects is still under their respective license (see LICENSE file for details).
-This package is licensed more permissive, since it can be useful outside of the FAILS environment.
+This package is licensed more permissive since it can be useful outside of the FAILS environment.
 
-This module is a C++ node binding to libquiche [https://github.com/google/quiche](https://github.com/google/quiche)(note there is a second library with a similar purpose and the same name), which provides besides other network protocols HTTP/3 support.
-This packages currently only provides support for HTTP/3 WebTransport with an interface similar to the browser side (but not all features implemented), for server as well as for client, see `test/test.js`, `test/testsuite.js`, `test/echoclient.js`, `test/echoserver.js`  for examples.
-Note, the client implementation only supports certificates checking via certificateHashes.
-It may be possible in the future to also support normal HTTP/3 not so much effort, however there is no intention from the author to implement this, since it will not be needed by FAILS. However PR request are welcome and will be supported by advise from the author.
-The package should be considered as a ducttape style solution, until a bullet proof native support of HTTP/3 and WebTransport is provided by node itself.
+This module started as a C++ node binding to libquiche [https://github.com/google/quiche](https://github.com/google/quiche) (note there is a second library with a similar purpose and the same name), which provides besides other network protocols HTTP/3 support. Now it can also handle Webtransport over HTTP/2 and a WebSocket mapping of the HTTP/2 protocol together with a polyfill and ponyfill for the browsers without reliable WebTransport support or no WebTRansport support at all.
+This package currently provides support for WebTransport with an interface similar to the browser side (but not all features implemented), for the server as well as for the client, see `old_test/test.js`, `old_test/testsuite.js`, `old_test/echoclient.js`, `old_test/echoserver.js`  for examples.
+Note, that the client implementation only supports certificate checking via `certificateHashes`, however experimental support for rootCA-based checking is introduced with version 1.0.0.
+It may be possible in the future to also support normal HTTP/3 with not so much effort, however, there is no intention from the author to implement this since it will not be needed by FAILS. However, PR requests are welcome and will be supported by advice from the author.
+The package for the HTTP/3 should be considered as a duct tape-style solution until a bulletproof native support of HTTP/3 and WebTransport is provided by node itself.
 
-If you need a ponyfill checkout the sister package [https://github.com/fails-components/webtransport-ponyfill-websocket/](https://github.com/fails-components/webtransport-ponyfill-websocket/),
-that provides a mapping of the Webtransport interfaces to Websocket connections.
+If you need a ponyfill check out the sister package [https://github.com/fails-components/webtransport-ponyfill-websocket/](https://github.com/fails-components/webtransport-ponyfill-websocket/), which provides a mapping of the Webtransport interfaces to Websocket connections.
 
+## Changes for Version 1.x.x
+
+The interface for version 1.x.x is not changed compared to 0.x.x.
+However, it was heavily internally rewritten. 
+For example, the implementation does not use a separate event loop for quiche implementation anymore. Instead, it uses node.js native datagram sockets and the event loop of node.js.
+So even though not intended, the library may behave unintended differently in detail.
+
+Furthermore, support for WebTransport over http/2 was added, which has to be considered experimental (and the protocol may change anytime), as there is yet no released browser implementation.
+Note, that it is only partially implemented and also some http2 features require changes of node.js itself.
+Use for the server side either `HttpServer` for http/2 and http/3 support (including WebTransport over WebSocket), Http3Server for http/3 only and Http2Server for http/2 only.
+For the client side pass the options `forceReliable`, `requireUnreliable` etc. to force/select a type of transport.
+
+ **Note, that the http/2 webtransport protocol (not supported by any browser yet), is implemented without the support of receiving initial settings, which can cause a problem with the initial flow control of the WebTransport streams. This is a current limitation in node.js. Note, that for sending the required initial setting you need a very recent (unreleased) version of node.js.** This limitation does not apply to the polyfill/ponyfill and the websocket protocol.
+
+### Ponyfill/Polyfill
+Together with an experimental http/2 implementation of WebTransport, the underlying http/2 capsule protocol had been mapped to the WebSocket protocol, so that the packages can also be used as a ponyfill/polyfill on the browser side.
+Please use `WebTransportPonyfill` for a WebSocket only or `WebTransportPolyfill` as a replacement for `WebTransport`, which automatically falls back to the browser's implementation, if the corresponding features are natively supported in the browser.
 
 
 ## Installation and usage
-You can install the package directly via npm from node.js or github packages:
 
-```bash
+### Installation
+
+You can install the package directly via npm from node.js or GitHub packages:
+In the case of GitHub packages, please add this to your `.npmrc`` file
+```
+@fails-components:registry=https://npm.pkg.github.com
+```
+In this case, you need to be authenticated against Github.
+
+For installation simply run:
+```
 npm install @fails-components/webtransport
 ```
-In case of github packages, please add to your `.npmrc` file
+this will install the main package for node.js or the ponyfill and polyfill for the browser.
+Starting with version 1.0, the binary required for Webtransport for node.js through libquiche is moved to a separate package,
+which you need to install manually in addition to this package:
 ```
-@fails-components:registry=https://npm.pkg.github.com
+npm install @fails-components/webtransport-transport-http3-quiche
 ```
-In this case you need to be authenticated against github.
+this allows a faster installation for people only interested in the http2 WebTransport support or the ponyfill/polyfill mapping the http2 protocol to WebSocket. 
 
-The package provides prebuild binaries for `windows`, `linux` and `macos` for the platform `x64` and `ia32` (only windows).
-Other platforms may be possible via crosscompiling in the github actions, if someone needs this, PRs are welcome.
+The package `webtransport-transport-http3-quiche` provides prebuild binaries for `windows`, `linux` and `macos` for the platform `x64` and `ia32` (only Windows).
+Other platforms may be possible via cross-compiling in the GitHub actions, if someone needs this, PRs are welcome.
 
-Of course you can also build the binary on your system.
-If you are running the compiling install as root, you need to use `--unsafe-perm` as flag.
-Installing the package without prebuild requires a full building environment including clang-9, perl6, python, golang,  ninja-build, icu. See the `Dockerfile` or `Dockerfile.development` for required debian packages.
-This should work for Windows, linux and Mac OS X.
-(You may want to check out the building dependencies (especially for windows) for BoringSSl, zlib, abseil on their respective websites).
+Of course, you can also build the binary on your system.
+If you are running the compiling install as root, you need to use `--`unsafe-perm` as a flag.
+Installing the package without prebuild requires a full building environment including clang-9, perl6, python, golang,  `ninja-build, `and `icu``.` See the `Dockerfile` or `Dockerfile.development` for required Debian packages.
+This should work for Windows, Linux and Mac OS X.
+(You may want to check out the building dependencies (especially for Windows) for BoringSSl, zlib, abseil on their respective websites).
 
 Of course,  PR for patches and for compiling instructions and necessary changes are welcome for all possible environments.
 
-** Warning the build time takes more than 15 minutes, on windows even longer! (Due to the building of the third party libraries). **
+**Warning the build time takes more than 15 minutes, on Windows and Mac even longer! (Due to the building of the third-party libraries).**
 
-In the directory `test` you find a simple echo server code. That answers to a series of WebTransport echos. Furthermore some example browser code and finally a unit test of the library including certificate generation.
+In the directory `old_test` you find a simple echo server code. That answers to a series of WebTransport echos. Furthermore some example browser code and finally a unit test of the library including certificate generation.
 
-When testing remember you might need to start chromium based browser with certain flags to accept your http/3 certificate with errors, e.g.:
+When testing remember you might need to start a Chromium-based browser with certain flags to accept your http/3 certificate with errors, e.g.:
 ```
 chrome --ignore-certificate-errors-spki-list=FINGERPRINTOFYOURCERTIFICATE --ignore-certificate-errors --v=2 --enable-logging=stderr --origin-to-force-quic-on=192.168.1.50:8080
 ```
-of course replace IP and fingerprint of your certificate accordingly. However, the author never got this to work and is using this without flags, but supplies instead a fingerprint when opening a WebTransport session. (PR welcome).
+of course, replace the IP and fingerprint of your certificate accordingly. However, the author never got this to work (except for http/2 websocket support, and uses only the `--ignore-certificate-errors` flag) and is using this without flags, but supplies instead a fingerprint when opening a WebTransport session. (PRs welcome).
+
+### Setting up a server
+To setup a server use either the class `HttpServer`, `Http3Server` or `Http2Server`.
+While `HttpServer` creates a server supporting http/2 and http/3 (so listening for TCP/IP and UDP), `Http3Server` only supports http/3 and  `Http2Server` supports http/2. (Though `HttpServer` is merely a proxy to separate server objects).
+
+For example:
+```
+const server = new Http3Server({
+      port: 0,
+      host: '127.0.0.1',
+      secret: 'mysecret',
+      cert: certificate.cert, // unclear if it is the correct format
+      privKey: certificate.private
+    })
+```
+create a new server listening on a random port (port `0` triggers that behavior) on host `127.0.0.1`. The secret is only relevant for http/3 and the underlying QUIC connection, the best is to choose a random value. `cert` and `privKey` are the certificate and private key for the server.
+
+Other but more expert options include:
+* `certhttp2` and `privKeyhttp2`: For providing a different certificate for the http/2 as the  http/2 implementation does not support certificate matching by fingerprints.
+* `initialStreamFlowControlWindow`, `initialSessionFlowControlWindow`, `streamShouldAutoTuneReceiveWindow`, `sessionShouldAutoTuneReceiveWindow`, `streamFlowControlWindowSizeLimit`, `sessionFlowControlWindowSizeLimit`: As expert's option for tweaking the internal flow control.
+
+The method `setRequestHandler(callback)` sets a callback, that inspects incoming headers and allows to change the incoming path header and also to throw an error if the session should not be opened. This method is considered to be experimental.
+In general, the HTTP header is attached as the `header` property to the WebTransport Session object.
+
+The method `updateCert(cert, privKey, http2only)` allows to change the certificate, while the server is running (not supported by all transports).
+
+With the methods `startServer` and `stopServer` the server can be started and stopped.
+`address()` gives information about the current server address.
+
+The properties `ready` and `closed` are Promises, that allow you to wait for the Server to be ready or closed.
+
+The method `sessionStream(path, args)` allows to register a `path` to receive WebTransportSessions, it returns a `ReadableStream` of `WebTransportSession` objects.
+The args object can be empty, or have the property `noAutoPaths` prevent the creation of new path streams (internal option, do not use in production).
+The `WebTransportSession` should behave most like a WebTransport object on the browser according to the spec with few additions and some missing features.
+
+### Using a client
+The `WebTransport` object for node or the `WebTransportPonyfill`,  `WebTransportPolyfill` objects for the browser, behave like the `WebTransport` client object for the browser with few additions and some missing features.
 
 ## Specification divergence
 
@@ -76,7 +140,7 @@ They are:
 * [getStats()](https://www.w3.org/TR/webtransport/#dom-webtransport-getstats)
 * [reliability](https://www.w3.org/TR/webtransport/#dom-webtransport-reliability)
 
-The WebTransport client only supports certification validation using fingerprints. Without a fingerprint it will accept any server without certificate checking.
+The WebTransport client only supports certification validation using fingerprints. Without a fingerprint, an experimental implementation for http/3 checks the certificates against the root certificates integrated with node.
 
 ### WebTransportDatagramDuplexStream
 
@@ -88,9 +152,9 @@ The WebTransport client only supports certification validation using fingerprint
 
 ## Development notes
 
-### Tests
+### Test
 
-The unit test suite can be run on both node.js and Chrome to ensure behaviour is consistent between the two environments.
+The unit test suite can be run on both node.js and Chrome to ensure behavior is consistent between the two environments.
 
 [Mocha](https://www.npmjs.com/package/mocha) is used as a test runner in both environments, in the browser it is run via [playwright-test](https://www.npmjs.com/package/playwright-test).
 
@@ -130,7 +194,7 @@ Disable headless mode to watch tests run in Chromium:
 $ npm run test:chromium -- --debug
 ```
 
-### Logging
+### Logging
 
 This module uses the [debug](https://www.npmjs.com/package/debug) module for logging.
 

package/test/bidirectional-streams.spec.js

@@ -7,7 +7,12 @@ import { writeStream } from './fixtures/write-stream.js'
 import { readCertHash } from './fixtures/read-cert-hash.js'
 import WebTransport from './fixtures/webtransport.js'
 import * as ui8 from 'uint8arrays'
-import { KNOWN_BYTES, KNOWN_BYTES_LENGTH } from './fixtures/known-bytes.js'
+import {
+  KNOWN_BYTES,
+  KNOWN_BYTES_LENGTH,
+  KNOWN_BYTES_LONG,
+  KNOWN_BYTES_LONG_LENGTH
+} from './fixtures/known-bytes.js'
 
 /**
  * @template T
@@ -15,10 +20,8 @@ import { KNOWN_BYTES, KNOWN_BYTES_LENGTH } from './fixtures/known-bytes.js'
  */
 
 describe('bidirectional streams', function () {
-  // FIXME: sometimes there are seemingly arbitrary 5s delays in
-  // communicating with the server under node.js
-  this.timeout(30000)
-
+  let forceReliable = false
+  if (process.env.USE_HTTP2 === 'true') forceReliable = true
   /** @type {import('../lib/dom').WebTransport | undefined} */
   let client
 
@@ -40,7 +43,9 @@ describe('bidirectional streams', function () {
             algorithm: 'sha-256',
             value: readCertHash(process.env.CERT_HASH)
           }
-        ]
+        ],
+        // @ts-ignore
+        forceReliable
       }
     )
     await client.ready
@@ -55,9 +60,44 @@ describe('bidirectional streams', function () {
     )
   })
 
-  it('sends and receives data over an incoming bidirectional stream', async () => {
-    /** @type {Deferred<Uint8Array[]>} */
+  it('sends and receives data over an outgoing bidirectional stream with big buffers', async () => {
+    // client context - connects to the server, opens a bidi stream, sends some data and reads the response
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/bidirectional_client_initiated_echo`,
+      {
+        serverCertificateHashes: [
+          {
+            algorithm: 'sha-256',
+            value: readCertHash(process.env.CERT_HASH)
+          }
+        ],
+        // @ts-ignore
+        forceReliable
+      }
+    )
+    await client.ready
+
+    const stream = await client.createBidirectionalStream()
+    await writeStream(stream.writable, KNOWN_BYTES_LONG)
+
+    const output = await readStream(stream.readable, KNOWN_BYTES_LONG_LENGTH)
+    const send = ui8.concat(KNOWN_BYTES_LONG)
+    const received = ui8.concat(output)
+    let failure = 0
+    for (let i = 0; i < Math.max(send.byteLength, received.byteLength); i++) {
+      if (send[i] !== received[i] && failure < 100) {
+        console.log('d: ', i, ' ,', send[i], ', ', received[i])
+        failure++
+      }
+    }
 
+    expect(ui8.concat(KNOWN_BYTES_LONG)).to.deep.equal(
+      ui8.concat(output),
+      'Did not receive the same bytes we sent'
+    )
+  })
+
+  it('sends and receives data over an incoming bidirectional stream', async () => {
     // client context - waits for the server to open a bidi stream then pipes it back to them
     client = new WebTransport(
       `${process.env.SERVER_URL}/bidirectional_server_initiated_echo`,
@@ -67,7 +107,9 @@ describe('bidirectional streams', function () {
             algorithm: 'sha-256',
             value: readCertHash(process.env.CERT_HASH)
           }
-        ]
+        ],
+        // @ts-ignore
+        forceReliable
       }
     )
     await client.ready

package/test/datagrams.spec.js

@@ -14,6 +14,8 @@ import { pTimeout } from './fixtures/p-timeout.js'
 describe('datagrams', function () {
   /** @type {import('../lib/dom').WebTransport | undefined} */
   let client
+  let forceReliable = false
+  if (process.env.USE_HTTP2 === 'true') forceReliable = true
 
   // @ts-ignore
   afterEach(async () => {
@@ -32,7 +34,9 @@ describe('datagrams', function () {
             algorithm: 'sha-256',
             value: readCertHash(process.env.CERT_HASH)
           }
-        ]
+        ],
+        // @ts-ignore
+        forceReliable
       }
     )
     await client.ready
@@ -73,7 +77,9 @@ describe('datagrams', function () {
             algorithm: 'sha-256',
             value: readCertHash(process.env.CERT_HASH)
           }
-        ]
+        ],
+        // @ts-ignore
+        forceReliable
       }
     )
     await client.ready

package/test/fixtures/known-bytes.js

@@ -13,3 +13,32 @@ export const KNOWN_BYTES_LENGTH = KNOWN_BYTES.reduce(
   (accumulator, currentValue) => accumulator + currentValue.length,
   0
 )
+
+const createBytesChunk = function (/** @type {number} */ length) {
+  const workArray = new Array(length / 2)
+  for (let i = 0; i < length / 4; i++) {
+    workArray[2 * i + 1] = length % 0xffff
+    workArray[2 * i] = i
+  }
+  const helper = new Uint16Array(workArray)
+  const toreturn = new Uint8Array(
+    helper.buffer,
+    helper.byteOffset,
+    helper.byteLength
+  )
+  return toreturn
+}
+
+export const KNOWN_BYTES_LONG = [
+  createBytesChunk(60000), // 96, 234
+  createBytesChunk(12), // 0, 12
+  createBytesChunk(50000), // 195, 80
+  createBytesChunk(1600), // 6, 64
+  createBytesChunk(20000), // 78, 32
+  createBytesChunk(30000) // 117, 48
+]
+
+export const KNOWN_BYTES_LONG_LENGTH = KNOWN_BYTES_LONG.reduce(
+  (accumulator, currentValue) => accumulator + currentValue.length,
+  0
+)

package/test/fixtures/read-stream.js

@@ -1,6 +1,6 @@
 /**
  * @template T
- * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ * @typedef {import('../../lib/webstreams').ReadableStream<T>} ReadableStream<T>
  */
 
 /**

package/test/fixtures/reader-value.js

@@ -1,6 +1,6 @@
 /**
  * @template T
- * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ * @typedef {import('../../lib/webstreams').ReadableStream<T>} ReadableStream<T>
  */
 
 /**

package/test/fixtures/server.js

@@ -1,5 +1,5 @@
 import { generateWebTransportCertificate } from './certificate.js'
-import { Http3Server } from '../../lib/index.js'
+import { Http2Server, Http3Server } from '../../lib/index.node.js'
 import { pTimeout } from './p-timeout.js'
 import { getReaderStream, getReaderValue } from './reader-value.js'
 import { writeStream } from './write-stream.js'
@@ -24,15 +24,29 @@ export async function createServer() {
     throw new Error('Certificate generation failed')
   }
 
-  const server = new Http3Server({
-    /*   port: 8080,
+  /** @type {Http2Server|Http3Server} */
+  let server
+  if (process.env.USE_HTTP2 === 'true') {
+    server = new Http2Server({
+      /*   port: 8080,
+      host: '0.0.0.0', */
+      port: 0,
+      host: '127.0.0.1',
+      secret: 'mysecret',
+      cert: certificate.cert, // unclear if it is the correct format
+      privKey: certificate.private
+    })
+  } else {
+    server = new Http3Server({
+      /*   port: 8080,
     host: '0.0.0.0', */
-    port: 0,
-    host: '127.0.0.1',
-    secret: 'mysecret',
-    cert: certificate.cert, // unclear if it is the correct format
-    privKey: certificate.private
-  })
+      port: 0,
+      host: '127.0.0.1',
+      secret: 'mysecret',
+      cert: certificate.cert, // unclear if it is the correct format
+      privKey: certificate.private
+    })
+  }
 
   server.ready
     .then(async () => {
@@ -153,7 +167,7 @@ export async function createServer() {
             for await (const session of getReaderStream(
               server.sessionStream('/session_close')
             )) {
-              session.close()
+              await session.close()
             }
           },
 

package/test/fixtures/webtransport.browser.js

@@ -1,2 +1,20 @@
-// @ts-expect-error not TypeScript's dom.d.ts yet
-export default WebTransport // eslint-disable-line no-undef
+import {
+  WebTransportPolyfill,
+  WebTransportPonyfill
+} from '../../lib/webtransport.browser'
+
+/** @type {import('../../lib/dom').WebTransport} */
+// @ts-ignore
+// eslint-disable-next-line no-undef
+let webtransport = WebTransport
+if (process.env.USE_POLYFILL === 'true') {
+  // @ts-ignore
+  webtransport = WebTransportPolyfill
+}
+
+if (process.env.USE_PONYFILL === 'true') {
+  // @ts-ignore
+  webtransport = WebTransportPonyfill
+}
+
+export default webtransport // eslint-disable-line no-undef

package/test/fixtures/webtransport.js

@@ -1,3 +1,3 @@
-import { WebTransport } from '../../lib/index.js'
+import { WebTransport } from '../../lib/index.node.js'
 
 export default WebTransport

package/test/index.js

@@ -5,11 +5,16 @@ import { execa } from 'execa'
  * getting stuck waiting for the custom event loop to end.
  */
 async function startServer() {
+  let http2 = false
+  if (process.argv[3] === 'http2') http2 = true
   return new Promise((resolve, reject) => {
     let foundAddress = false
 
     const server = execa('node', ['./test/fixtures/server.js'], {
-      stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+      stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+      env: {
+        USE_HTTP2: http2 ? 'true' : 'false'
+      }
     })
     server.on('message', (data) => {
       if (!foundAddress) {
@@ -27,6 +32,21 @@ async function startServer() {
  */
 async function runTests(certificate, serverAddress) {
   const env = process.argv[2]
+  let http2 = false
+  if (process.argv[3] === 'http2') http2 = true
+  let polyfill = false
+  let ponyfill = false
+  let slice = 4
+  if (process.argv.length > 3 && process.argv[4] === 'polyfill') {
+    polyfill = true
+    slice++
+    if (env === 'node') throw new Error('Polyfill not supported on node')
+  }
+  if (process.argv.length > 3 && process.argv[4] === 'ponyfill') {
+    ponyfill = true
+    slice++
+    if (env === 'node') throw new Error('Ponyfill not supported on node')
+  }
   /** @type {string} */
   let command = ''
   /** @type {string[]} */
@@ -37,14 +57,14 @@ async function runTests(certificate, serverAddress) {
     args = [
       process.env.CI ? '--no-colors' : '--colors',
       './test/*.spec.js',
-      './test/*.node.js',
-      ...process.argv.slice(3)
+      ...process.argv.slice(4)
     ]
     const tests = execa(command, args, {
       env: {
         DEBUG_COLORS: process.env.CI ? '' : 'true',
         CERT_HASH: certificate,
-        SERVER_URL: serverAddress
+        SERVER_URL: serverAddress,
+        USE_HTTP2: http2 ? 'true' : 'false'
       },
       stdio: ['inherit', 'inherit', 'inherit']
     })
@@ -52,12 +72,18 @@ async function runTests(certificate, serverAddress) {
     await tests
   } else if (env === 'chromium') {
     command = 'playwright-test'
-    args = ['./test/*.spec.js', ...process.argv.slice(3)]
+    const otheropts = []
+    if (polyfill || ponyfill)
+      otheropts.push('--config', './test/pw-no-https-errors.json')
+    args = ['./test/*.spec.js', ...otheropts, ...process.argv.slice(slice)]
     const tests = execa(command, args, {
       env: {
         DEBUG_COLORS: process.env.CI ? '' : 'true',
         CERT_HASH: certificate,
-        SERVER_URL: serverAddress
+        SERVER_URL: serverAddress,
+        USE_HTTP2: http2 ? 'true' : 'false',
+        USE_POLYFILL: polyfill ? 'true' : 'false',
+        USE_PONYFILL: ponyfill ? 'true' : 'false'
       },
       stdio: ['inherit', 'inherit', 'inherit']
     })
@@ -79,6 +105,7 @@ try {
   }
 
   if (err.failed || err.timedOut || err.isCancelled || err.isKilled) {
+    console.log('Error cause mocha process', err)
     success = false
   }
 } finally {

package/test/pw-no-https-errors.json

@@ -0,0 +1,5 @@
+{
+    "browserContextOptions": {
+        "ignoreHTTPSErrors": true
+    }
+}