TimeoutNegativeWarning, Invalid state: Controller is already closed, server gets stuck in EADDRINUSE; node and Chromium clients behave differently

[guest271314]

Start WebTransport server.

Run WebTrasnport client using node (v25.0.0-nightly202507295335c101a9).

With node client things kind of work as expected, except for TimeoutNegativeWarning in the client

NODE_TLS_REJECT_UNAUTHORIZED=0 node --trace-warnings wt-client.js
WebTransport client ready
{ outgoingTotalLength: 2097152 }
Outgoing total length 2097152 written.
2097152 bytes written.
(node:64979) TimeoutNegativeWarning: -0.009 is a negative number.
Timeout duration was set to 1.
    at new Timeout (node:internal/timers:195:17)
    at setTimeout (node:timers:120:19)
    at globalThis.FAILSsetTimeoutAlarm (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/socket.js:10:10)
    at Socket.<anonymous> (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/clientsocket.js:52:21)
    at Socket.emit (node:events:507:28)
    at UDP.onMessage [as onmessage] (node:dgram:989:8)
{ incomingTotalLength: 2097152, outgoingTotalLength: 2097152 }
WritableStream close
[
  {
    status: 'fulfilled',
    value: { closeCode: 4999, reason: 'Done streaming.' }
  },
  { status: 'fulfilled', value: 'stream Promise' }
]

Notice the stream variable Promise from pipeTo() propagates.

In the server we also get the TimeoutNegative warning, intermittenly

node --trace-warnings index.js
server started
Promise { <pending> }
(node:64965) TimeoutNegativeWarning: -0.002 is a negative number.
Timeout duration was set to 1.
    at new Timeout (node:internal/timers:195:17)
    at setTimeout (node:timers:120:19)
    at globalThis.FAILSsetTimeoutAlarm (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/socket.js:10:10)
    at Socket.<anonymous> (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/serversocket.js:54:38)
    at Socket.emit (node:events:507:28)
    at UDP.onMessage [as onmessage] (node:dgram:989:8)
readable closed
writable closed
Stream 0
Session done
Clients 0
Promise { <pending> }
readable closed
writable closed
Stream 1
Session done
Clients 1

Now, run the same client code in Chromium (Version 141.0.7374.0 (Developer Build) (64-bit)) or Chrome and things go haywire. The server closes with Invalid state: Controller is already closed, then stream Promise does not propagate and is replaced with "The session is closed" which I didn't write, abort() in the WritableStream() piped to is called.

What this looks like in the server

node --trace-warnings index.js
server started
Promise { <pending> }
(node:64965) TimeoutNegativeWarning: -0.002 is a negative number.
Timeout duration was set to 1.
    at new Timeout (node:internal/timers:195:17)
    at setTimeout (node:timers:120:19)
    at globalThis.FAILSsetTimeoutAlarm (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/socket.js:10:10)
    at Socket.<anonymous> (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/serversocket.js:54:38)
    at Socket.emit (node:events:507:28)
    at UDP.onMessage [as onmessage] (node:dgram:989:8)
readable closed
writable closed
Stream 0
Session done
Clients 0
Promise { <pending> }
readable closed
writable closed
Stream 1
Session done
Clients 1
Promise { <pending> }
readable closed
writable closed
Stream 2
Session done
Clients 2
Promise { <pending> }
readable closed
writable closed
Stream 3
file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/serversocket.js:54
          const haschlos = this.cobj.recvPaket({
                                     ^

TypeError [ERR_INVALID_STATE]: Invalid state: Controller is already closed
    at ReadableStreamDefaultController.close (node:internal/webstreams/readablestream:1068:13)
    at HttpWTSession.onClose (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport/lib/session.js:559:30)
    at Socket.<anonymous> (file:///home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/serversocket.js:54:38)
    at Socket.emit (node:events:507:28)
    at UDP.onMessage [as onmessage] (node:dgram:989:8) {
  code: 'ERR_INVALID_STATE'
}

Node.js v25.0.0-nightly202507295335c101a9

What the Chromium client looks like

WebTransport client ready
VM2530:89 
{outgoingTotalLength: 2097152}
VM2530:94 Outgoing total length 2097152 written.
VM2530:98 2097152 bytes written.
VM2530:114 
{incomingTotalLength: 2097152, outgoingTotalLength: 2097152}
VM2530:125 
{reason: WebTransportError: The session is closed.
    at Object.write (<anonymous>:116:26)}
reason
: 
WebTransportError: The session is closed. at Object.write (<anonymous>:116:26)
[[Prototype]]
: 
Object
(2) [{…}, {…}]
0: 
status: "fulfilled"
value: {closeCode: 4999, reason: 'Done streaming.'}
1: 
status: 
"fulfilled"
value: "The session is closed."

Additionally, the server got stuck in EADDRINUSE after the server exited on commandline and after client closed

node --trace-warnings index.js
node:dgram:398
        const ex = new ExceptionWithHostPort(err, 'bind', ip, port);
                   ^

Error: bind EADDRINUSE 127.0.0.1:8080
    at node:dgram:398:20
    at process.processTicksAndRejections (node:internal/process/task_queues:91:21) {
  errno: -98,
  code: 'EADDRINUSE',
  syscall: 'bind',
  address: '127.0.0.1',
  port: 8080
}

Node.js v25.0.0-nightly202507295335c101a9

sudo ss -u -l -p | grep :8080
UNCONN 0      0                               127.0.0.1:8080               0.0.0.0:*    users:(("MainThread",pid=64205,fd=24))   

sudo kill -9 64205
user@debian:~/bin/webtransport-echo-server$ sudo kill -9 64205
kill: (64205): No such process
[1]+  Killed                  node index.js

The server source code

import { Http3Server } from "@fails-components/webtransport";
import certificates from "./cert.json" with {type:"json"};
const server = new Http3Server({
  port: 8080,
  host: "127.0.0.1",
  secret: certificates[0].secret,
  cert: certificates[0].pem,
  privKey: certificates[0].privateKey
});
await server.startServer();
await server.ready;
const address = server.address();
const sessionStream = server.sessionStream("/");
const sessionReader = sessionStream.getReader();
console.info("server started");
let streams = 0;
let clients = 0;
while (true) {
  try {
    const { value: session, done } = await sessionReader.read();
    if (done) {
      break;
    }
    console.log(session.closed);
    let incomingTotalLength = 0;
    let incomingCurrentLength = 0;
    const buffer = new ArrayBuffer(0, { maxByteLength: 4 });
    const view = new DataView(buffer);
    for await (const { readable, writable } of session.incomingBidirectionalStreams) {
      const writer = writable.getWriter();
      await readable.pipeTo(new WritableStream({
        async write(value) {
          if (incomingTotalLength === 0 && incomingCurrentLength === 0) {
            buffer.resize(4);
            for (let i = 0;i < 4; i++) {
              view.setUint8(i, value[i]);
            }
            incomingTotalLength = view.getUint32(0, true);
            value = value.subarray(4);
          }
          await writer.ready;
          await writer.write(value);
          incomingCurrentLength += value.length;
        },
        close() {
          console.log("readable closed");
        }
      }, { preventClose: false })).then(() => console.log("writable closed")).catch((e) => console.log(e));
      buffer.resize(0);
      incomingTotalLength = 0;
      incomingCurrentLength = 0;
      await writer.close();
      await writer.closed;
      console.log(`Stream ${streams++}`);
      break;
    }
    await session.closed.then(() => console.log("Session done")).catch((e) => e.message);
  } catch (e) {
    console.log(e);
  }
  console.log(`Clients ${clients++}`);
}

The client code

try {
  const serverCertificateHashes = [
    {
      algorithm: "sha-256",
      value: Uint8Array.of(0, 1, 2, ...)
    }
  ];
  if (!/Deno|Chrome|Firefox/i.test(navigator.userAgent)) {
    let { WebTransport, quicheLoaded } = await import("./node_modules/@fails-components/webtransport/lib/index.node.js");
    await quicheLoaded;
    globalThis.WebTransport = WebTransport;
  }
  const client = new WebTransport(`https://127.0.0.1:8080`, {
    serverCertificateHashes
  });
  await client.ready;
  console.log(`WebTransport client ready`);
  const encoder = new TextEncoder;
  let controller;
  const abortable = new AbortController;
  const {
    signal
  } = abortable;
  const { readable, writable } = await client.createBidirectionalStream();
  let str = "abcdefghijklmnopqrstuvwxyz";
  let data = new Uint8Array(2097152);
  let header = new Uint8Array(Uint32Array.from({
    length: 4
  }, (_, index) => data.length >> index * 8 & 255));
  let view = new DataView(header.buffer);
  let outgoingTotalLength = view.getUint32(0, true);
  console.log({ outgoingTotalLength });
  let incomingTotalLength = 0;
  const writer = writable.getWriter();
  await writer.ready;
  await writer.write(header).then(() => console.log(`Outgoing total length ${outgoingTotalLength} written.`));
  await writer.ready;
  await writer.write(data).then(() => console.log(`${data.length} bytes written.`)).catch((e) => console.log(e));
  await writer.ready;
  await writer.close();
  const stream = await readable.pipeThrough(new TextDecoderStream).pipeTo(new WritableStream({
    start(c) {
      controller = c;
    },
    async write(value, c) {
      incomingTotalLength += value.length;
      if (incomingTotalLength === outgoingTotalLength) {
        console.log({ incomingTotalLength, outgoingTotalLength });
        await client.close({ closeCode: 4999, reason: "Done streaming." });
      }
    },
    close() {
      console.log("WritableStream close");
    },
    abort(reason) {
      console.log({ reason });
    }
  }), { signal }).then(() => "stream Promise").catch((e) => e.message);
  if (!navigator.userAgent.includes("Deno")) {
    await Promise.allSettled([client.closed, stream]).then(console.log);
  } else {
    if (navigator.userAgent.includes("Deno")) {
      client.close();
      await Promise.allSettled([client.closed, stream]).then(console.log);
    }
  }
} catch (e) {
  console.log(e);
}

[martenrichter]

The timeout warning is caused by a change in node.js behaviour:
nodejs/node@f5ed338
and
nodejs/node@9256728
The first commit only adds a warning, so this was already present beforehand, but did not surface.
It can not be the source of your problems.

EADDRINUSE is a common issue that occurs occasionally after a crash and during development. It simply means the previous process is still active and has the socket in use.

Regarding the error of ReadableStreamController, it just tell you that it was closed twice.
One from your code:

await writer.close();

It happens through the connection of the pipe and the other through the incoming session closure.
So do not close it this way or unpipe it before closing the other stream. The writable should also be closed by the incoming remote closure.

[guest271314]

I'm just advising you about the warnings emitted by your code, and the wildly different results using the same server, and same code on different clients.

Regarding the error of ReadableStreamController, it just tell you that it was closed twice.
One from your code:

await writer.close();

It happens through the connection of the pipe and the other through the incoming session closure.
So do not close it this way or unpipe it before closing the other stream. The writable should also be closed by the incoming remote closure.

Not following you.

That doesn't tell me if node is right or chrome is right. They both can't be right at the same time when the yield different results.

[martenrichter]

Different results come because of different timings and race conditions.
So this is not surprising.
(Also, different implementations, I fixed several bugs in Chromium as well as in Firefox...., ).
In one setup, the closure from the client arrives earlier than in the other, and this causes the problem, with your manual close.
pipeTo is another story, as it also involves complex timings. Your code crashes because it closes the readable, and then in one setup, the remote command for closing all streams arrives. (The problem is that I can not detect if someone else has closed the readable beforehand, so you should avoid closing the readable, which you do through the connected writable.)

I will look to see if I can silence the setTimeout warning.

[guest271314]

I don't get how the same code can have so wildly different result in node and chrome. The server exits intermittenly when chrome is the client.

I'm still not sure which line of code you are talking about. That's standard streams usage I'm doing.

[martenrichter]

I don't get how the same code can have so wildly different result in node and chrome. The server exits intermittenly when chrome is the client.

Because it is not the same code under the hood, both implementations differ much in timing. And actually, you will also see this also depending on the network connection.

I'm still not sure which line of code you are talking about. That's standard streams usage I'm doing.

 await writer.close();

The writable is connected to the readable stream and closes the readable. But the readable is also closed by the session close inside my object and this handles the double closure. So far, I have not found a way to know if a stream is already closed.

[martenrichter]

However, I am not completely sure about it, if you can identify (by editing the code with logs) the exact line in:

webtransport/main/lib/session.js

Line 538 in 88088e0

onClose(args) {

(The line number of the error message seems to be of...)
Then it will help.
The timeouts should be addressed in the PR.

[guest271314]

So far, I have not found a way to know if a stream is already closed.

I suppose there's a few ways to do that.

Promise.race([stream.closed, Promise.resolve("Not closed")])

Making sure to call releaseLock() and then checking readable.locked or writer.locked.

You have to handle the case of a WritableStreamDefaultWriter not being created, and piping directly with {preventClose}. At one point I did use releaseLock() and of close().

I have noticed that Node.js WHATWG Streams implementation is different than Deno's and Chromium's.

I tend to test the same code in different runtimes - because the same code should work the same if implementers follow specifications - but they tend to do whatever they want for their own reasons.

But the readable is also closed by the session close inside my object and this handles the double closure. So far, I have not found a way to know if a stream is already closed.

Hmm.

I think I might get what you're saying. The code closes server-side and closed client-side. I will try closing client-side exclusively when I get all of the data echoed back to see if that changes anything.

[guest271314]

Still trying to figure out some stuff. While you're in there there should probably be a space here after "reason" so the literal word "reason" so args.error doesn't get concatenated to "reason", e.g., "reasonArgsError" at 568 in session.js

        ' and reason' +

[martenrichter]

Still trying to figure out some stuff. While you're in there there should probably be a space here after "reason" so the literal word "reason" so args.error doesn't get concatenated to "reason", e.g., "reasonArgsError" at 568 in session.js

        ' and reason' +

Ok (may be later) ,but the line number is off, it is 593 in current master:

webtransport/main/lib/session.js

Line 593 in 95181a5

' and reason' +

I have another idea.
It can be the lifetime of the "new WritableStream" that you pass into to pipeTo . As the Writable is currently the only way I see that the readable is closed beside from network commands.
(And actually, you can get a reader from the readable, I do not see the need for the pipeTo and the WritableStream, beside testing. Note, it may also be a problem with the pipeTo implementation, e.g. earlier versions of chromium had an issue with pipeTo, which I had to patch).

As your line numbers differ from the current branch, it would be good to know, which the actual line is where the error is thrown.

[guest271314]

Yeah, I did bun install -f --trust @fails-components/webtransport-transport-http3-quiche. I'll fetch this GitHub repository and retry. I'll try changing to an async iterator and use break to see if that changes anything.

[martenrichter]

Yeah, I did bun install -f --trust @fails-components/webtransport-transport-http3-quiche. I'll fetch this GitHub repository and retry. I'll try changing to an async iterator and use break to see if that changes anything.

It would also be ok, if you look at your local copy look at the line, and see what the github line is... (the strange thing is that if it is also off by approx 30), it is calling error on the controller and not close as in the log (but there may be functions inbetween).

[martenrichter]

If you are using 1.4.0 instead of 1.4.1. The line number would point at https://github.com/fails-components/webtransport/blob/5d96fcd442230ef4fa18625058c1280d8574a03b/main/lib/session.js#L559C11-L559C29
which means it is not the readable stream but the stream of incoming bidirectional streams.

It may happen, if onClose arrives twice.
Can you please turn on logging:
$ DEBUG=webtransport* node my-script.js .
It would mean that chromium sends out the close command twice.
Then I would have to protect the onClose for the case of a second call. (Though I thought the quiche already handles this.)

[guest271314]

I have another idea.
It can be the lifetime of the "new WritableStream" that you pass into to pipeTo . As the Writable is currently the only way I see that the readable is closed beside from network commands.
(And actually, you can get a reader from the readable, I do not see the need for the pipeTo and the WritableStream, beside testing. Note, it may also be a problem with the pipeTo implementation, e.g. earlier versions of chromium had an issue with pipeTo, which I had to patch).

Yeah. That's happened before... Those locked streams are tricky...

I got the code working as I expect, to an appreciable degree, by substituting reading the ReadableStream as an async iterable in both server and client.

I'm working with the same code code I had when I filed this issue. So I don't have the timer update thing running, yet.

node and chrome clients are similar enough now. deno does not propagate the closeCode or reason from the client to the server when close() is called client-side.

I'll get that new timer change code you just did and test again. For now here's the updated code and results.

@fails-component/webtransport

package.json

{
  "name": "webtransport-echo-server",
  "version": "1.0.0",
  "description": "A simple WebTransport server that supports bidi streams and just echos and received bytes back to the sender",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@fails-components/webtransport": "^1.0.10",
    "@fails-components/webtransport-transport-http3-quiche": "^1.4.1",
    "multiformats": "^13.1.0",
    "node-forge": "^1.3.1"
  },
  "trustedDependencies": [
    "@fails-components/webtransport-transport-http3-quiche"
  ]
}

Server

Node.js v25.0.0-nightly202507295335c101a9

import { Http3Server } from "@fails-components/webtransport";
import certificates from "./cert.json" with { type: "json" };
const server = new Http3Server({
  port: 8080,
  host: "127.0.0.1",
  secret: certificates[0].secret,
  cert: certificates[0].pem,
  privKey: certificates[0].privateKey
});
await server.startServer();
await server.ready;
const address = server.address();
const sessionStream = server.sessionStream("/");
const sessionReader = sessionStream.getReader();
console.info("WebTrasnport server started");
let streams = 0;
let clients = 0;
while (true) {
  try {
    const { value: session, done } = await sessionReader.read();
    if (done) {
      console.log({ done });
      break;
    }
    let incomingTotalLength = 0;
    let incomingCurrentLength = 0;
    const buffer = new ArrayBuffer(0, { maxByteLength: 4 });
    const view = new DataView(buffer);
    for await (const { readable, writable } of session.incomingBidirectionalStreams) {
      const writer = writable.getWriter();
      for await (let value of readable) {
        if (incomingTotalLength === 0 && incomingCurrentLength === 0) {
          buffer.resize(4);
          for (let i = 0;i < 4; i++) {
            view.setUint8(i, value[i]);
          }
          incomingTotalLength = view.getUint32(0, true);
          value = value.subarray(4);
        }
        await writer.ready;
        await writer.write(value);
        incomingCurrentLength += value.length;
        if (incomingTotalLength > 0 && incomingCurrentLength === incomingTotalLength) {
          console.log(`Echoed ${incomingCurrentLength}`);
          buffer.resize(0);
          incomingTotalLength = 0;
          incomingCurrentLength = 0;
          await writer.close();
          await writer.closed;
          break;
        }
      }
      const { closeCode, reason } = await session.closed;
      console.log(`Stream #${streams++}`);
      console.log(`{closeCode:${closeCode}, reason:"${reason}"}`);
    }
  } catch (e) {
    console.log(e);
  }
  console.log(`Clients ${clients++}`);
}

Client

The same code is run on each runtime. Yeah, I'm hardcoding the numbers in serverCertificateHashes ...

try {
  const serverCertificateHashes = [
    {
      algorithm: "sha-256",
      value: Uint8Array.of(189, 196, 96, 75, 199, 75, 229, 178, 2, 18, 115, 230, 66, 64, 129, 47, 29, 128, 103, 2, 222, 6, 222, 246, 190, 162, 146, 38, 249, 196, 157, 28)
    }
  ];
  if (!/Deno|Chrome|Firefox/i.test(navigator.userAgent)) {
    let { WebTransport, quicheLoaded } = await import("./node_modules/@fails-components/webtransport/lib/index.node.js");
    await quicheLoaded;
    globalThis.WebTransport = WebTransport;
  }
  const client = new WebTransport(`https://127.0.0.1:8080`, {
    serverCertificateHashes
  });
  await client.ready;
  console.log("WebTransport client ready");
  const { readable, writable } = await client.createBidirectionalStream();
  let data = new Uint8Array(20971520);
  let header = new Uint8Array(Uint32Array.from({
    length: 4
  }, (_, index) => data.length >> index * 8 & 255));
  let view = new DataView(header.buffer);
  let outgoingTotalLength = view.getUint32(0, true);
  console.log({ outgoingTotalLength });
  let incomingTotalLength = 0;
  const writer = writable.getWriter();
  await writer.ready;
  await writer.write(header).then(() => console.log(`Outgoing total length ${outgoingTotalLength} written.`));
  await writer.ready;
  await writer.write(data).then(() => console.log(`${data.length} bytes written.`)).catch((e) => console.log(e));
  await writer.ready;
  await writer.close();
  for await (const value of readable) {
    incomingTotalLength += value.length;
    if (incomingTotalLength === outgoingTotalLength) {
      console.log({ incomingTotalLength, outgoingTotalLength });
      break;
    }
  }
  client.close({ closeCode: 4999, reason: "Done streaming." });
  await client.closed.then(console.log).catch(console.warn);
} catch (e) {
  console.log(e);
}

Server logs

node index.js
WebTrasnport server started
(node:69323) TimeoutNegativeWarning: -0.001 is a negative number.
Timeout duration was set to 1.
(Use `node --trace-warnings ...` to show where the warning was created)
Echoed 20971520
Stream #0
{closeCode:4999, reason:"Done streaming."}
Clients 0
Echoed 20971520
Stream #1
{closeCode:0, reason:""}
Clients 1
Echoed 20971520
Stream #2
{closeCode:4999, reason:"Done streaming."}
Clients 2
Echoed 20971520
Stream #3
{closeCode:4999, reason:"Done streaming."}
Clients 3

Clients

Node.js v25.0.0-nightly202507295335c101a9

node wt-client.js
WebTransport client ready
{ outgoingTotalLength: 20971520 }
Outgoing total length 20971520 written.
20971520 bytes written.
(node:69331) TimeoutNegativeWarning: -0.004 is a negative number.
Timeout duration was set to 1.
(Use `node --trace-warnings ...` to show where the warning was created)
{ incomingTotalLength: 20971520, outgoingTotalLength: 20971520 }
{ closeCode: 4999, reason: 'Done streaming.' }

Deno 2.4.5+6314c3c (canary, release, x86_64-unknown-linux-gnu)

deno -A --unstable-net wt-client.js
WebTransport client ready
{ outgoingTotalLength: 20971520 }
Outgoing total length 20971520 written.
20971520 bytes written.
{ incomingTotalLength: 20971520, outgoingTotalLength: 20971520 }
[Object: null prototype] { closeCode: 0, reason: "" }

Bun 1.2.21

bun wt-client.js
WebTransport client ready
{
  outgoingTotalLength: 20971520,
}
Outgoing total length 20971520 written.
20971520 bytes written.
TimeoutNegativeWarning: -0.008 is a negative number.
Timeout duration was set to 1.
      at <anonymous> (/home/user/bin/webtransport-echo-server/node_modules/@fails-components/webtransport-transport-http3-quiche/lib/clientsocket.js:52:21)
      at emit (node:events:98:22)
      at data (node:dgram:170:22)

{
  incomingTotalLength: 20971520,
  outgoingTotalLength: 20971520,
}
terminate called after throwing an instance of 'Napi::Error'
  what():  Invalid state: Controller is already closed
Aborted

Chromium Version 141.0.7374.0 (Developer Build) (64-bit) (chrome)

VM493:17 WebTransport client ready
VM493:25 
{outgoingTotalLength: 20971520}
VM493:29 Outgoing total length 20971520 written.
VM493:31 20971520 bytes written.
VM493:37 
{incomingTotalLength: 20971520, outgoingTotalLength: 20971520}
{closeCode: 4999, reason: 'Done streaming.'}

[guest271314]

Alright, I'm gonna try to build this thing of yours. I'm on a live Linux USB. I'll run out of disk space trying to install LLVM. So I'll have to link to clang-20 I have on another USB. I don't need playwright. I don't have Docker installed. I got this GitHub repository, and other dependencies besides clang directly in the root file system. What's the roadmap?