mcp: final protocol cleanup after removing screenshot tool

- Removed unused ImageContent from protocol. - Simplified CallToolResult back to only support TextContent. - Cleaned up CallToolResult usages in tools.zig.
mcp/cdp: fix inactivity timeout
2026-04-02 02:16:44 +00:00 · 2026-04-01 15:00:55 +02:00 · 2026-04-01 14:37:40 +02:00 · 2026-04-01 12:41:56 +02:00
37 changed files with 326 additions and 2503 deletions
--- a/.github/workflows/e2e-integration-test.yml
+++ b/.github/workflows/e2e-integration-test.yml
@@ -60,20 +60,7 @@ jobs:
      - run: chmod a+x ./lightpanda

      - name: run end to end integration tests
-        continue-on-error: true
        run: |
          ./lightpanda serve --log-level error & echo $! > LPD.pid
-          go run integration/main.go |tee result.log
+          go run integration/main.go
          kill `cat LPD.pid`
-
-      - name: Send result to slack
-        uses: slackapi/slack-github-action@v3.0.1
-        with:
-          errors: true
-          method: files.uploadV2
-          token: ${{ secrets.CI_SLACK_BOT_TOKEN }}
-          payload: |
-            channel_id: ${{ vars.E2E_SLACK_CHANNEL_ID }}
-            initial_comment: "Last e2e integration tests"
-            file: "./result.log"
-            filename: "e2e-integration-${{ github.sha }}.txt"
--- a/.github/workflows/wpt.yml
+++ b/.github/workflows/wpt.yml
@@ -153,34 +153,3 @@ jobs:

      - name: format and send json result
        run: /perf-fmt wpt ${{ github.sha }} wpt.json
-
-  wptdiff:
-    name: perf-fmt
-    needs: perf-fmt
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          repository: 'lightpanda-io/demo'
-          fetch-depth: 0
-
-      - run: |
-          cd ./wptdiff
-          CGO_ENABLED=0 go build
-
-      - run: |
-         ./wptdiff/wptdiff |tee diff.log
-
-      - name: Send regression to slack
-        uses: slackapi/slack-github-action@v3.0.1
-        with:
-          errors: true
-          method: files.uploadV2
-          token: ${{ secrets.CI_SLACK_BOT_TOKEN }}
-          payload: |
-            channel_id: ${{ vars.WPT_SLACK_CHANNEL_ID }}
-            initial_comment: "Last WPT regressions"
-            file: "./diff.log"
-            filename: "wpt-regression-${{ github.sha }}.txt"
--- a/build.zig
+++ b/build.zig
@@ -462,7 +462,6 @@ fn buildCurl(
        .CURL_DISABLE_SMTP = true,
        .CURL_DISABLE_TELNET = true,
        .CURL_DISABLE_TFTP = true,
-        .CURL_DISABLE_WEBSOCKETS = false, // Enable WebSocket support

        .ssize_t = null,
        ._FILE_OFFSET_BITS = 64,
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -5,8 +5,8 @@
    .minimum_zig_version = "0.15.2",
    .dependencies = .{
        .v8 = .{
-            .url = "https://github.com/lightpanda-io/zig-v8-fork/archive/99c1ddf2d0b15f141e92ea09abdfc8e0e5f441e6.tar.gz",
-            .hash = "v8-0.0.0-xddH63-BBABP05dni8oMrs9qQwuczHhNhXHbXXlPb95s",
+            .url = "https://github.com/lightpanda-io/zig-v8-fork/archive/refs/tags/v0.3.7.tar.gz",
+            .hash = "v8-0.0.0-xddH67uBBAD95hWsPQz3Ni1PlZjdywtPXrGUAp8rSKco",
        },
        // .v8 = .{ .path = "../zig-v8-fork" },
        .brotli = .{
--- a/src/App.zig
+++ b/src/App.zig
@@ -26,7 +26,7 @@ const Snapshot = @import("browser/js/Snapshot.zig");
 const Platform = @import("browser/js/Platform.zig");
 const Telemetry = @import("telemetry/telemetry.zig").Telemetry;

-const Network = @import("network/Network.zig");
+const Network = @import("network/Runtime.zig");
 pub const ArenaPool = @import("ArenaPool.zig");

 const App = @This();
--- a/src/Config.zig
+++ b/src/Config.zig
@@ -34,6 +34,7 @@ pub const RunMode = enum {
    mcp,
 };

+pub const MAX_LISTENERS = 16;
 pub const CDP_MAX_HTTP_REQUEST_SIZE = 4096;

 // max message size
@@ -159,6 +160,7 @@ pub fn userAgentSuffix(self: *const Config) ?[]const u8 {
 pub fn cdpTimeout(self: *const Config) usize {
    return switch (self.mode) {
        .serve => |opts| if (opts.timeout > 604_800) 604_800_000 else @as(usize, opts.timeout) * 1000,
+        .mcp => 10000, // Default timeout for MCP-CDP
        else => unreachable,
    };
 }
@@ -166,6 +168,7 @@ pub fn cdpTimeout(self: *const Config) usize {
 pub fn port(self: *const Config) u16 {
    return switch (self.mode) {
        .serve => |opts| opts.port,
+        .mcp => |opts| opts.cdp_port orelse 0,
        else => unreachable,
    };
 }
@@ -173,6 +176,7 @@ pub fn port(self: *const Config) u16 {
 pub fn advertiseHost(self: *const Config) []const u8 {
    return switch (self.mode) {
        .serve => |opts| opts.advertise_host orelse opts.host,
+        .mcp => "127.0.0.1",
        else => unreachable,
    };
 }
@@ -191,6 +195,7 @@ pub fn webBotAuth(self: *const Config) ?WebBotAuthConfig {
 pub fn maxConnections(self: *const Config) u16 {
    return switch (self.mode) {
        .serve => |opts| opts.cdp_max_connections,
+        .mcp => 16,
        else => unreachable,
    };
 }
@@ -198,6 +203,7 @@ pub fn maxConnections(self: *const Config) u16 {
 pub fn maxPendingConnections(self: *const Config) u31 {
    return switch (self.mode) {
        .serve => |opts| opts.cdp_max_pending_connections,
+        .mcp => 128,
        else => unreachable,
    };
 }
@@ -223,6 +229,7 @@ pub const Serve = struct {
 pub const Mcp = struct {
    common: Common = .{},
    version: mcp.Version = .default,
+    cdp_port: ?u16 = null,
 };

 pub const DumpFormat = enum {
@@ -676,6 +683,19 @@ fn parseMcpArgs(
            continue;
        }

+        if (std.mem.eql(u8, "--cdp-port", opt) or std.mem.eql(u8, "--cdp_port", opt)) {
+            const str = args.next() orelse {
+                log.fatal(.mcp, "missing argument value", .{ .arg = opt });
+                return error.InvalidArgument;
+            };
+
+            result.cdp_port = std.fmt.parseInt(u16, str, 10) catch |err| {
+                log.fatal(.mcp, "invalid argument value", .{ .arg = opt, .err = err });
+                return error.InvalidArgument;
+            };
+            continue;
+        }
+
        if (try parseCommonArg(allocator, opt, args, &result.common)) {
            continue;
        }
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -330,6 +330,11 @@ pub const Client = struct {
                    ms_remaining = self.ws.timeout_ms;
                },
                .done => {
+                    if (self.isBusy()) {
+                        last_message = milliTimestamp(.monotonic);
+                        ms_remaining = self.ws.timeout_ms;
+                        continue;
+                    }
                    const now = milliTimestamp(.monotonic);
                    const elapsed = now - last_message;
                    if (elapsed >= ms_remaining) {
@@ -343,6 +348,24 @@ pub const Client = struct {
        }
    }

+    fn isBusy(self: *const Client) bool {
+        if (self.http.active > 0 or self.http.intercepted > 0) {
+            return true;
+        }
+
+        const cdp = switch (self.mode) {
+            .cdp => |*c| c,
+            .http => return false,
+        };
+
+        const session = cdp.browser.session orelse return false;
+        if (session.browser.hasBackgroundTasks() or session.browser.msToNextMacrotask() != null) {
+            return true;
+        }
+
+        return false;
+    }
+
    fn blockingReadStart(ctx: *anyopaque) bool {
        const self: *Client = @ptrCast(@alignCast(ctx));
        self.ws.setBlocking(true) catch |err| {
--- a/src/TestWSServer.zig
+++ b/src/TestWSServer.zig
@@ -1,371 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const posix = std.posix;
-
-const TestWSServer = @This();
-
-shutdown: std.atomic.Value(bool),
-listener: ?posix.socket_t,
-
-pub fn init() TestWSServer {
-    return .{
-        .shutdown = .init(true),
-        .listener = null,
-    };
-}
-
-pub fn deinit(self: *TestWSServer) void {
-    if (self.listener) |socket| {
-        posix.close(socket);
-        self.listener = null;
-    }
-}
-
-pub fn stop(self: *TestWSServer) void {
-    self.shutdown.store(true, .release);
-    if (self.listener) |socket| {
-        posix.close(socket);
-        self.listener = null;
-    }
-}
-
-pub fn run(self: *TestWSServer, wg: *std.Thread.WaitGroup) void {
-    self.runImpl(wg) catch |err| {
-        std.debug.print("WebSocket echo server error: {}\n", .{err});
-    };
-}
-
-fn runImpl(self: *TestWSServer, wg: *std.Thread.WaitGroup) !void {
-    const socket = try posix.socket(posix.AF.INET, posix.SOCK.STREAM, 0);
-    errdefer posix.close(socket);
-
-    const addr = std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 9584);
-
-    try posix.setsockopt(socket, posix.SOL.SOCKET, posix.SO.REUSEADDR, &std.mem.toBytes(@as(c_int, 1)));
-    try posix.bind(socket, &addr.any, addr.getOsSockLen());
-    try posix.listen(socket, 8);
-
-    self.listener = socket;
-    self.shutdown.store(false, .release);
-    wg.finish();
-
-    while (!self.shutdown.load(.acquire)) {
-        var client_addr: posix.sockaddr = undefined;
-        var addr_len: posix.socklen_t = @sizeOf(posix.sockaddr);
-
-        const client = posix.accept(socket, &client_addr, &addr_len, 0) catch |err| {
-            if (self.shutdown.load(.acquire)) return;
-            std.debug.print("[WS Server] Accept error: {}\n", .{err});
-            continue;
-        };
-
-        const thread = std.Thread.spawn(.{}, handleClient, .{client}) catch |err| {
-            std.debug.print("[WS Server] Thread spawn error: {}\n", .{err});
-            posix.close(client);
-            continue;
-        };
-        thread.detach();
-    }
-}
-
-fn handleClient(client: posix.socket_t) void {
-    defer posix.close(client);
-
-    var buf: [4096]u8 = undefined;
-    const n = posix.read(client, &buf) catch return;
-
-    const request = buf[0..n];
-
-    // Find Sec-WebSocket-Key
-    const key_header = "Sec-WebSocket-Key: ";
-    const key_start = std.mem.indexOf(u8, request, key_header) orelse return;
-    const key_line_start = key_start + key_header.len;
-    const key_end = std.mem.indexOfScalarPos(u8, request, key_line_start, '\r') orelse return;
-    const key = request[key_line_start..key_end];
-
-    // Compute accept key
-    var hasher = std.crypto.hash.Sha1.init(.{});
-    hasher.update(key);
-    hasher.update("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
-    var hash: [20]u8 = undefined;
-    hasher.final(&hash);
-
-    var accept_key: [28]u8 = undefined;
-    _ = std.base64.standard.Encoder.encode(&accept_key, &hash);
-
-    // Send upgrade response
-    var resp_buf: [256]u8 = undefined;
-    const resp = std.fmt.bufPrint(&resp_buf, "HTTP/1.1 101 Switching Protocols\r\n" ++
-        "Upgrade: websocket\r\n" ++
-        "Connection: Upgrade\r\n" ++
-        "Sec-WebSocket-Accept: {s}\r\n\r\n", .{accept_key}) catch return;
-    _ = posix.write(client, resp) catch return;
-
-    // Message loop with larger buffer for big messages
-    var msg_buf: [128 * 1024]u8 = undefined;
-    var recv_buf = RecvBuffer{ .buf = &msg_buf };
-
-    while (true) {
-        const frame = recv_buf.readFrame(client) orelse break;
-
-        // Close frame - echo it back before closing
-        if (frame.opcode == 8) {
-            sendFrame(client, 8, "", frame.payload) catch {};
-            break;
-        }
-
-        // Handle commands or echo
-        if (frame.opcode == 1) { // Text
-            handleTextMessage(client, frame.payload) catch break;
-        } else if (frame.opcode == 2) { // Binary
-            handleBinaryMessage(client, frame.payload) catch break;
-        }
-    }
-}
-
-const Frame = struct {
-    opcode: u8,
-    payload: []u8,
-};
-
-const RecvBuffer = struct {
-    buf: []u8,
-    start: usize = 0,
-    end: usize = 0,
-
-    fn available(self: *RecvBuffer) []u8 {
-        return self.buf[self.start..self.end];
-    }
-
-    fn consume(self: *RecvBuffer, n: usize) void {
-        self.start += n;
-        if (self.start >= self.end) {
-            self.start = 0;
-            self.end = 0;
-        }
-    }
-
-    fn ensureBytes(self: *RecvBuffer, client: posix.socket_t, needed: usize) bool {
-        while (self.end - self.start < needed) {
-            // Compact buffer if needed
-            if (self.end >= self.buf.len - 1024) {
-                const avail = self.end - self.start;
-                std.mem.copyForwards(u8, self.buf[0..avail], self.buf[self.start..self.end]);
-                self.start = 0;
-                self.end = avail;
-            }
-
-            const n = posix.read(client, self.buf[self.end..]) catch return false;
-            if (n == 0) return false;
-            self.end += n;
-        }
-        return true;
-    }
-
-    fn readFrame(self: *RecvBuffer, client: posix.socket_t) ?Frame {
-        // Need at least 2 bytes for basic header
-        if (!self.ensureBytes(client, 2)) return null;
-
-        const data = self.available();
-        const opcode = data[0] & 0x0F;
-        const masked = (data[1] & 0x80) != 0;
-        var payload_len: usize = data[1] & 0x7F;
-        var header_size: usize = 2;
-
-        // Extended payload length
-        if (payload_len == 126) {
-            if (!self.ensureBytes(client, 4)) return null;
-            const d = self.available();
-            payload_len = @as(usize, d[2]) << 8 | d[3];
-            header_size = 4;
-        } else if (payload_len == 127) {
-            if (!self.ensureBytes(client, 10)) return null;
-            const d = self.available();
-            payload_len = @as(usize, d[2]) << 56 |
-                @as(usize, d[3]) << 48 |
-                @as(usize, d[4]) << 40 |
-                @as(usize, d[5]) << 32 |
-                @as(usize, d[6]) << 24 |
-                @as(usize, d[7]) << 16 |
-                @as(usize, d[8]) << 8 |
-                d[9];
-            header_size = 10;
-        }
-
-        const mask_size: usize = if (masked) 4 else 0;
-        const total_frame_size = header_size + mask_size + payload_len;
-
-        if (!self.ensureBytes(client, total_frame_size)) return null;
-
-        const frame_data = self.available();
-
-        // Get mask key if present
-        var mask_key: [4]u8 = undefined;
-        if (masked) {
-            @memcpy(&mask_key, frame_data[header_size..][0..4]);
-        }
-
-        // Get payload and unmask
-        const payload_start = header_size + mask_size;
-        const payload = frame_data[payload_start..][0..payload_len];
-
-        if (masked) {
-            for (payload, 0..) |*b, i| {
-                b.* ^= mask_key[i % 4];
-            }
-        }
-
-        self.consume(total_frame_size);
-
-        return .{ .opcode = opcode, .payload = payload };
-    }
-};
-
-fn handleTextMessage(client: posix.socket_t, payload: []const u8) !void {
-    // Command: force-close - close socket immediately without close frame
-    if (std.mem.eql(u8, payload, "force-close")) {
-        return error.ForceClose;
-    }
-
-    // Command: send-large:N - send a message of N bytes
-    if (std.mem.startsWith(u8, payload, "send-large:")) {
-        const size_str = payload["send-large:".len..];
-        const size = std.fmt.parseInt(usize, size_str, 10) catch return error.InvalidCommand;
-        try sendLargeMessage(client, size);
-        return;
-    }
-
-    // Command: close:CODE:REASON - send close frame with specific code/reason
-    if (std.mem.startsWith(u8, payload, "close:")) {
-        const rest = payload["close:".len..];
-        if (std.mem.indexOf(u8, rest, ":")) |sep| {
-            const code = std.fmt.parseInt(u16, rest[0..sep], 10) catch 1000;
-            const reason = rest[sep + 1 ..];
-            try sendCloseFrame(client, code, reason);
-        }
-        return;
-    }
-
-    // Default: echo with "echo-" prefix
-    const prefix = "echo-";
-    try sendFrame(client, 1, prefix, payload);
-}
-
-fn handleBinaryMessage(client: posix.socket_t, payload: []const u8) !void {
-    // Echo binary data back with byte 0xEE prepended as marker
-    const marker = [_]u8{0xEE};
-    try sendFrame(client, 2, &marker, payload);
-}
-
-fn sendFrame(client: posix.socket_t, opcode: u8, prefix: []const u8, payload: []const u8) !void {
-    const total_len = prefix.len + payload.len;
-
-    // Build header
-    var header: [10]u8 = undefined;
-    var header_len: usize = 2;
-
-    header[0] = 0x80 | opcode; // FIN + opcode
-
-    if (total_len <= 125) {
-        header[1] = @intCast(total_len);
-    } else if (total_len <= 65535) {
-        header[1] = 126;
-        header[2] = @intCast((total_len >> 8) & 0xFF);
-        header[3] = @intCast(total_len & 0xFF);
-        header_len = 4;
-    } else {
-        header[1] = 127;
-        header[2] = @intCast((total_len >> 56) & 0xFF);
-        header[3] = @intCast((total_len >> 48) & 0xFF);
-        header[4] = @intCast((total_len >> 40) & 0xFF);
-        header[5] = @intCast((total_len >> 32) & 0xFF);
-        header[6] = @intCast((total_len >> 24) & 0xFF);
-        header[7] = @intCast((total_len >> 16) & 0xFF);
-        header[8] = @intCast((total_len >> 8) & 0xFF);
-        header[9] = @intCast(total_len & 0xFF);
-        header_len = 10;
-    }
-
-    _ = try posix.write(client, header[0..header_len]);
-    if (prefix.len > 0) {
-        _ = try posix.write(client, prefix);
-    }
-    if (payload.len > 0) {
-        _ = try posix.write(client, payload);
-    }
-}
-
-fn sendLargeMessage(client: posix.socket_t, size: usize) !void {
-    // Build header
-    var header: [10]u8 = undefined;
-    var header_len: usize = 2;
-
-    header[0] = 0x81; // FIN + text
-
-    if (size <= 125) {
-        header[1] = @intCast(size);
-    } else if (size <= 65535) {
-        header[1] = 126;
-        header[2] = @intCast((size >> 8) & 0xFF);
-        header[3] = @intCast(size & 0xFF);
-        header_len = 4;
-    } else {
-        header[1] = 127;
-        header[2] = @intCast((size >> 56) & 0xFF);
-        header[3] = @intCast((size >> 48) & 0xFF);
-        header[4] = @intCast((size >> 40) & 0xFF);
-        header[5] = @intCast((size >> 32) & 0xFF);
-        header[6] = @intCast((size >> 24) & 0xFF);
-        header[7] = @intCast((size >> 16) & 0xFF);
-        header[8] = @intCast((size >> 8) & 0xFF);
-        header[9] = @intCast(size & 0xFF);
-        header_len = 10;
-    }
-
-    _ = try posix.write(client, header[0..header_len]);
-
-    // Send payload in chunks - pattern of 'A'-'Z' repeating
-    var sent: usize = 0;
-    var chunk: [4096]u8 = undefined;
-    while (sent < size) {
-        const to_send = @min(chunk.len, size - sent);
-        for (chunk[0..to_send], 0..) |*b, i| {
-            b.* = @intCast('A' + ((sent + i) % 26));
-        }
-        _ = try posix.write(client, chunk[0..to_send]);
-        sent += to_send;
-    }
-}
-
-fn sendCloseFrame(client: posix.socket_t, code: u16, reason: []const u8) !void {
-    const reason_len = @min(reason.len, 123); // Max 123 bytes for reason
-    const payload_len = 2 + reason_len;
-
-    var frame: [129]u8 = undefined; // 2 header + 2 code + 123 reason + 2 padding
-    frame[0] = 0x88; // FIN + close
-    frame[1] = @intCast(payload_len);
-    frame[2] = @intCast((code >> 8) & 0xFF);
-    frame[3] = @intCast(code & 0xFF);
-    if (reason_len > 0) {
-        @memcpy(frame[4..][0..reason_len], reason[0..reason_len]);
-    }
-
-    _ = try posix.write(client, frame[0 .. 4 + reason_len]);
-}
--- a/src/browser/HttpClient.zig
+++ b/src/browser/HttpClient.zig
@@ -28,10 +28,9 @@ const URL = @import("URL.zig");
 const Config = @import("../Config.zig");
 const Notification = @import("../Notification.zig");
 const CookieJar = @import("webapi/storage/Cookie.zig").Jar;
-const WebSocket = @import("webapi/net/WebSocket.zig");

 const http = @import("../network/http.zig");
-const Network = @import("../network/Network.zig");
+const Runtime = @import("../network/Runtime.zig");
 const Robots = @import("../network/Robots.zig");

 const IS_DEBUG = builtin.mode == .Debug;
@@ -87,7 +86,7 @@ queue: std.DoublyLinkedList = .{},
 // The main app allocator
 allocator: Allocator,

-network: *Network,
+network: *Runtime,

 // Queue of requests that depend on a robots.txt.
 // Allows us to fetch the robots.txt just once.
@@ -114,8 +113,6 @@ obey_robots: bool,

 cdp_client: ?CDPClient = null,

-max_response_size: usize,
-
 // libcurl can monitor arbitrary sockets, this lets us use libcurl to poll
 // both HTTP data as well as messages from an CDP connection.
 // Furthermore, we have some tension between blocking scripts and request
@@ -134,7 +131,7 @@ pub const CDPClient = struct {
    blocking_read_end: *const fn (*anyopaque) bool,
 };

-pub fn init(allocator: Allocator, network: *Network) !*Client {
+pub fn init(allocator: Allocator, network: *Runtime) !*Client {
    var transfer_pool = std.heap.MemoryPool(Transfer).init(allocator);
    errdefer transfer_pool.deinit();

@@ -156,7 +153,6 @@ pub fn init(allocator: Allocator, network: *Network) !*Client {
        .http_proxy = http_proxy,
        .tls_verify = network.config.tlsVerifyHost(),
        .obey_robots = network.config.obeyRobots(),
-        .max_response_size = network.config.httpMaxResponseSize() orelse std.math.maxInt(u32),
    };

    return client;
@@ -225,18 +221,16 @@ fn _abort(self: *Client, comptime abort_all: bool, frame_id: u32) void {
        while (n) |node| {
            n = node.next;
            const conn: *http.Connection = @fieldParentPtr("node", node);
-            switch (conn.transport) {
-                .http => |transfer| {
-                    if ((comptime abort_all) or transfer.req.frame_id == frame_id) {
-                        transfer.kill();
-                    }
-                },
-                .websocket => |ws| {
-                    if ((comptime abort_all) or ws._page._frame_id == frame_id) {
-                        ws.kill();
-                    }
-                },
-                .none => unreachable,
+            var transfer = Transfer.fromConnection(conn) catch |err| {
+                // Let's cleanup what we can
+                self.removeConn(conn);
+                log.err(.http, "get private info", .{ .err = err, .source = "abort" });
+                continue;
+            };
+            if (comptime abort_all) {
+                transfer.kill();
+            } else if (transfer.req.frame_id == frame_id) {
+                transfer.kill();
            }
        }
    }
@@ -642,6 +636,7 @@ fn makeTransfer(self: *Client, req: Request) !*Transfer {
        .req = req,
        .ctx = req.ctx,
        .client = self,
+        .max_response_size = self.network.config.httpMaxResponseSize(),
    };
    return transfer;
 }
@@ -668,11 +663,15 @@ fn makeRequest(self: *Client, conn: *http.Connection, transfer: *Transfer) anyer
    // fails BEFORE `curl_multi_add_handle` succeeds, the we still need to do
    // cleanup. But if things fail after `curl_multi_add_handle`, we expect
    // perfom to pickup the failure and cleanup.
-    self.trackConn(conn) catch |err| {
+    self.in_use.append(&conn.node);
+    self.handles.add(conn) catch |err| {
        transfer._conn = null;
        transfer.deinit();
+        self.in_use.remove(&conn.node);
+        self.releaseConn(conn);
        return err;
    };
+    self.active += 1;

    if (transfer.req.start_callback) |cb| {
        cb(transfer) catch |err| {
@@ -696,7 +695,7 @@ fn perform(self: *Client, timeout_ms: c_int) anyerror!PerformStatus {
        break :blk try self.handles.perform();
    };

-    // Process dirty connections — return them to Network pool.
+    // Process dirty connections — return them to Runtime pool.
    while (self.dirty.popFirst()) |node| {
        const conn: *http.Connection = @fieldParentPtr("node", node);
        self.handles.remove(conn) catch |err| {
@@ -736,7 +735,7 @@ fn processOneMessage(self: *Client, msg: http.Handles.MultiMessage, transfer: *T
    // Also check on RecvError: proxy may send 407 with headers before
    // closing the connection (CONNECT tunnel not yet established).
    if (msg.err == null or msg.err.? == error.RecvError) {
-        transfer.detectAuthChallenge(msg.conn);
+        transfer.detectAuthChallenge(&msg.conn);
    }

    // In case of auth challenge
@@ -835,7 +834,7 @@ fn processOneMessage(self: *Client, msg: http.Handles.MultiMessage, transfer: *T
    if (!transfer._header_done_called) {
        // In case of request w/o data, we need to call the header done
        // callback now.
-        const proceed = try transfer.headerDoneCallback(msg.conn);
+        const proceed = try transfer.headerDoneCallback(&msg.conn);
        if (!proceed) {
            transfer.requestFailed(error.Abort, true);
            return true;
@@ -872,63 +871,30 @@ fn processOneMessage(self: *Client, msg: http.Handles.MultiMessage, transfer: *T

 fn processMessages(self: *Client) !bool {
    var processed = false;
-    while (try self.handles.readMessage()) |msg| {
-        switch (msg.conn.transport) {
-            .http => |transfer| {
-                const done = self.processOneMessage(msg, transfer) catch |err| blk: {
-                    log.err(.http, "process_messages", .{ .err = err, .req = transfer });
-                    transfer.requestFailed(err, true);
-                    if (transfer._detached_conn) |c| {
-                        // Conn was removed from handles during redirect reconfiguration
-                        // but not re-added. Release it directly to avoid double-remove.
-                        self.in_use.remove(&c.node);
-                        self.active -= 1;
-                        self.releaseConn(c);
-                        transfer._detached_conn = null;
-                    }
-                    break :blk true;
-                };
-                if (done) {
-                    transfer.deinit();
-                    processed = true;
-                }
-            },
-            .websocket => |ws| {
-                if (msg.err) |err| switch (err) {
-                    error.GotNothing => ws.disconnected(null),
-                    else => ws.disconnected(err),
-                } else {
-                    // Clean close - no error
-                    ws.disconnected(null);
-                }
-
-                return true;
-            },
-            .none => unreachable,
+    while (self.handles.readMessage()) |msg| {
+        const transfer = try Transfer.fromConnection(&msg.conn);
+        const done = self.processOneMessage(msg, transfer) catch |err| blk: {
+            log.err(.http, "process_messages", .{ .err = err, .req = transfer });
+            transfer.requestFailed(err, true);
+            if (transfer._detached_conn) |c| {
+                // Conn was removed from handles during redirect reconfiguration
+                // but not re-added. Release it directly to avoid double-remove.
+                self.in_use.remove(&c.node);
+                self.active -= 1;
+                self.releaseConn(c);
+                transfer._detached_conn = null;
+            }
+            break :blk true;
+        };
+        if (done) {
+            transfer.deinit();
+            processed = true;
        }
    }
    return processed;
 }

-pub fn trackConn(self: *Client, conn: *http.Connection) !void {
-    self.in_use.append(&conn.node);
-    // Set private pointer so readMessage can find the Connection.
-    // Must be done each time since curl_easy_reset clears it when
-    // connections are returned to pool.
-    conn.setPrivate(conn) catch |err| {
-        self.in_use.remove(&conn.node);
-        self.releaseConn(conn);
-        return err;
-    };
-    self.handles.add(conn) catch |err| {
-        self.in_use.remove(&conn.node);
-        self.releaseConn(conn);
-        return err;
-    };
-    self.active += 1;
-}
-
-pub fn removeConn(self: *Client, conn: *http.Connection) void {
+fn removeConn(self: *Client, conn: *http.Connection) void {
    self.in_use.remove(&conn.node);
    self.active -= 1;
    if (self.handles.remove(conn)) {
@@ -961,6 +927,7 @@ pub const Request = struct {
    resource_type: ResourceType,
    credentials: ?[:0]const u8 = null,
    notification: *Notification,
+    max_response_size: ?usize = null,

    // This is only relevant for intercepted requests. If a request is flagged
    // as blocking AND is intercepted, then it'll be up to us to wait until
@@ -1013,6 +980,8 @@ pub const Transfer = struct {

    aborted: bool = false,

+    max_response_size: ?usize = null,
+
    // We'll store the response header here
    response_header: ?ResponseHead = null,

@@ -1143,7 +1112,7 @@ pub const Transfer = struct {
        const req = &self.req;

        // Set callbacks and per-client settings on the pooled connection.
-        try conn.setWriteCallback(Transfer.dataCallback);
+        try conn.setCallbacks(Transfer.dataCallback);
        try conn.setFollowLocation(false);
        try conn.setProxy(client.http_proxy);
        try conn.setTlsVerify(client.tls_verify, client.use_proxy);
@@ -1171,7 +1140,7 @@ pub const Transfer = struct {
            try conn.setCookies(@ptrCast(cookies.ptr));
        }

-        conn.transport = .{ .http = self };
+        try conn.setPrivate(self);

        // add credentials
        if (req.credentials) |creds| {
@@ -1371,9 +1340,11 @@ pub const Transfer = struct {
            }
        }

-        if (transfer.getContentLength()) |cl| {
-            if (cl > transfer.client.max_response_size) {
-                return error.ResponseTooLarge;
+        if (transfer.max_response_size) |max_size| {
+            if (transfer.getContentLength()) |cl| {
+                if (cl > max_size) {
+                    return error.ResponseTooLarge;
+                }
            }
        }

@@ -1396,7 +1367,10 @@ pub const Transfer = struct {
        }

        const conn: *http.Connection = @ptrCast(@alignCast(data));
-        var transfer = conn.transport.http;
+        var transfer = fromConnection(conn) catch |err| {
+            log.err(.http, "get private info", .{ .err = err, .source = "body callback" });
+            return http.writefunc_error;
+        };

        if (!transfer._first_data_received) {
            transfer._first_data_received = true;
@@ -1413,9 +1387,11 @@ pub const Transfer = struct {

            // Pre-size buffer from Content-Length.
            if (transfer.getContentLength()) |cl| {
-                if (cl > transfer.client.max_response_size) {
-                    transfer._callback_error = error.ResponseTooLarge;
-                    return http.writefunc_error;
+                if (transfer.max_response_size) |max_size| {
+                    if (cl > max_size) {
+                        transfer._callback_error = error.ResponseTooLarge;
+                        return http.writefunc_error;
+                    }
                }
                transfer._stream_buffer.ensureTotalCapacity(transfer.arena.allocator(), cl) catch {};
            }
@@ -1424,9 +1400,11 @@ pub const Transfer = struct {
        if (transfer._skip_body) return @intCast(chunk_len);

        transfer.bytes_received += chunk_len;
-        if (transfer.bytes_received > transfer.client.max_response_size) {
-            transfer._callback_error = error.ResponseTooLarge;
-            return http.writefunc_error;
+        if (transfer.max_response_size) |max_size| {
+            if (transfer.bytes_received > max_size) {
+                transfer._callback_error = error.ResponseTooLarge;
+                return http.writefunc_error;
+            }
        }

        const chunk = buffer[0..chunk_len];
@@ -1455,6 +1433,11 @@ pub const Transfer = struct {
        return .{ .list = .{ .list = self.response_header.?._injected_headers } };
    }

+    fn fromConnection(conn: *const http.Connection) !*Transfer {
+        const private = try conn.getPrivate();
+        return @ptrCast(@alignCast(private));
+    }
+
    pub fn fulfill(transfer: *Transfer, status: u16, headers: []const http.Header, body: ?[]const u8) !void {
        if (transfer._conn != null) {
            // should never happen, should have been intercepted/paused, and then
--- a/src/browser/ScriptManager.zig
+++ b/src/browser/ScriptManager.zig
@@ -22,7 +22,7 @@ const builtin = @import("builtin");

 const log = @import("../log.zig");
 const HttpClient = @import("HttpClient.zig");
-const http = @import("../network/http.zig");
+const net_http = @import("../network/http.zig");
 const String = @import("../string.zig").String;

 const js = @import("js/js.zig");
@@ -136,7 +136,7 @@ fn clearList(list: *std.DoublyLinkedList) void {
    }
 }

-fn getHeaders(self: *ScriptManager) !http.Headers {
+fn getHeaders(self: *ScriptManager) !net_http.Headers {
    var headers = try self.client.newHeaders();
    try self.page.headersForRequest(&headers);
    return headers;
--- a/src/browser/URL.zig
+++ b/src/browser/URL.zig
@@ -25,72 +25,28 @@ const ResolveOpts = struct {
 };

 // path is anytype, so that it can be used with both []const u8 and [:0]const u8
-pub fn resolve(allocator: Allocator, base: [:0]const u8, source_path: anytype, comptime opts: ResolveOpts) ![:0]const u8 {
-    const PT = @TypeOf(source_path);
-
-    var path: [:0]const u8 = if (comptime !isNullTerminated(PT) or opts.always_dupe) try allocator.dupeZ(u8, source_path) else source_path;
-
-    if (base.len == 0) {
-        return processResolved(allocator, path, opts);
-    }
-
-    // Minimum is "x:" and skip relative path (very common case)
-    if (path.len >= 2 and path[0] != '/') {
-        if (std.mem.indexOfScalar(u8, path[0..], ':')) |scheme_path_end| {
-            scheme_check: {
-                const scheme_path = path[0..scheme_path_end];
-                //from "ws" to "https"
-                if (scheme_path_end >= 2 and scheme_path_end <= 5) {
-                    const has_double_slashes: bool = scheme_path_end + 3 <= path.len and path[scheme_path_end + 1] == '/' and path[scheme_path_end + 2] == '/';
-                    const special_schemes = [_][]const u8{ "https", "http", "ws", "wss", "file", "ftp" };
-
-                    for (special_schemes) |special_scheme| {
-                        if (std.ascii.eqlIgnoreCase(scheme_path, special_scheme)) {
-                            const base_scheme_end = std.mem.indexOf(u8, base, "://") orelse 0;
-
-                            if (base_scheme_end > 0 and std.mem.eql(u8, base[0..base_scheme_end], scheme_path) and !has_double_slashes) {
-                                //Skip ":" and exit as relative state
-                                path = path[scheme_path_end + 1 ..];
-                                break :scheme_check;
-                            } else {
-                                var rest_start: usize = scheme_path_end + 1;
-                                //Skip any slashas after "scheme:"
-                                while (rest_start < path.len and (path[rest_start] == '/' or path[rest_start] == '\\')) {
-                                    rest_start += 1;
-                                }
-                                // A special scheme (exclude "file") must contain at least any chars after "://"
-                                if (rest_start == path.len and !std.ascii.eqlIgnoreCase(scheme_path, "file")) {
-                                    return error.TypeError;
-                                }
-                                //File scheme allow empty host
-                                const separator: []const u8 = if (!has_double_slashes and std.ascii.eqlIgnoreCase(scheme_path, "file")) ":///" else "://";
-
-                                path = try std.mem.joinZ(allocator, "", &.{ scheme_path, separator, path[rest_start..] });
-                                return processResolved(allocator, path, opts);
-                            }
-                        }
-                    }
-                }
-                if (scheme_path.len > 0) {
-                    for (scheme_path[1..]) |c| {
-                        if (!std.ascii.isAlphanumeric(c) and c != '+' and c != '-' and c != '.') {
-                            //Exit as relative state
-                            break :scheme_check;
-                        }
-                    }
-                }
-                //path is complete http url
-                return processResolved(allocator, path, opts);
-            }
+pub fn resolve(allocator: Allocator, base: [:0]const u8, path: anytype, comptime opts: ResolveOpts) ![:0]const u8 {
+    const PT = @TypeOf(path);
+    if (base.len == 0 or isCompleteHTTPUrl(path)) {
+        if (comptime opts.always_dupe or !isNullTerminated(PT)) {
+            const duped = try allocator.dupeZ(u8, path);
+            return processResolved(allocator, duped, opts);
        }
+        if (comptime opts.encode) {
+            return processResolved(allocator, path, opts);
+        }
+        return path;
    }

    if (path.len == 0) {
-        if (opts.always_dupe) {
-            const dupe = try allocator.dupeZ(u8, base);
-            return processResolved(allocator, dupe, opts);
+        if (comptime opts.always_dupe) {
+            const duped = try allocator.dupeZ(u8, base);
+            return processResolved(allocator, duped, opts);
        }
-        return processResolved(allocator, base, opts);
+        if (comptime opts.encode) {
+            return processResolved(allocator, base, opts);
+        }
+        return base;
    }

    if (path[0] == '?') {
@@ -107,7 +63,14 @@ pub fn resolve(allocator: Allocator, base: [:0]const u8, source_path: anytype, c
    if (std.mem.startsWith(u8, path, "//")) {
        // network-path reference
        const index = std.mem.indexOfScalar(u8, base, ':') orelse {
-            return processResolved(allocator, path, opts);
+            if (comptime isNullTerminated(PT)) {
+                if (comptime opts.encode) {
+                    return processResolved(allocator, path, opts);
+                }
+                return path;
+            }
+            const duped = try allocator.dupeZ(u8, path);
+            return processResolved(allocator, duped, opts);
        };
        const protocol = base[0 .. index + 1];
        const result = try std.mem.joinZ(allocator, "", &.{ protocol, path });
@@ -133,7 +96,6 @@ pub fn resolve(allocator: Allocator, base: [:0]const u8, source_path: anytype, c
    // trailing space so that we always have space to append the null terminator
    // and so that we can compare the next two characters without needing to length check
    var out = try std.mem.join(allocator, "", &.{ normalized_base, "/", path, "  " });
-
    const end = out.len - 2;

    const path_marker = path_start + 1;
@@ -1608,182 +1570,3 @@ test "URL: getOrigin" {
        }
    }
 }
-
-test "URL: resolve path scheme" {
-    const Case = struct {
-        base: [:0]const u8,
-        path: [:0]const u8,
-        expected: [:0]const u8,
-        expected_error: bool = false,
-    };
-
-    const cases = [_]Case{
-        //same schemes and path as relative path (one slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:/about",
-            .expected = "https://www.example.com/about",
-        },
-        //same schemes and path as relative path (without slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:about",
-            .expected = "https://www.example.com/about",
-        },
-        //same schemes and path as absolute path (two slashes)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https://about",
-            .expected = "https://about",
-        },
-        //different schemes and path as absolute (without slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "http:about",
-            .expected = "http://about",
-        },
-        //different schemes and path as absolute (with one slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "http:/about",
-            .expected = "http://about",
-        },
-        //different schemes and path as absolute (with two slashes)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "http://about",
-            .expected = "http://about",
-        },
-        //same schemes and path as absolute (with more slashes)
-        .{
-            .base = "https://site/",
-            .path = "https://path",
-            .expected = "https://path",
-        },
-        //path scheme is not special and path as absolute (without additional slashes)
-        .{
-            .base = "http://localhost/",
-            .path = "data:test",
-            .expected = "data:test",
-        },
-        //different schemes and path as absolute (pathscheme=ws)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "ws://about",
-            .expected = "ws://about",
-        },
-        //different schemes and path as absolute (path scheme=wss)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "wss://about",
-            .expected = "wss://about",
-        },
-        //different schemes and path as absolute (path scheme=ftp)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "ftp://about",
-            .expected = "ftp://about",
-        },
-        //different schemes and path as absolute (path scheme=file)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file://path/to/file",
-            .expected = "file://path/to/file",
-        },
-        //different schemes and path as absolute (path scheme=file, host is empty)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file:/path/to/file",
-            .expected = "file:///path/to/file",
-        },
-        //different schemes and path as absolute (path scheme=file, host is empty)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file:/",
-            .expected = "file:///",
-        },
-        //different schemes without :// and normalize "file" scheme, absolute path
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file:path/to/file",
-            .expected = "file:///path/to/file",
-        },
-        //same schemes without :// in path and rest starts with scheme:/, relative path
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:/file:/relative/path/",
-            .expected = "https://www.example.com/file:/relative/path/",
-        },
-        //same schemes without :// in path and rest starts with scheme://, relative path
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:/http://relative/path/",
-            .expected = "https://www.example.com/http://relative/path/",
-        },
-        //same schemes without :// in path , relative state
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:relative:path",
-            .expected = "http://www.example.com/relative:path",
-        },
-        //repeat different schemes in path
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:http:/relative/path/",
-            .expected = "http://www.example.com/http:/relative/path/",
-        },
-        //repeat different schemes in path
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:https://relative:path",
-            .expected = "http://www.example.com/https://relative:path",
-        },
-        //NOT required :// for blob scheme
-        .{
-            .base = "http://www.example.com/example",
-            .path = "blob:other",
-            .expected = "blob:other",
-        },
-        //NOT required :// for NON-special schemes and can contains "+" or "-" or "." in scheme
-        .{
-            .base = "http://www.example.com/example",
-            .path = "custom+foo:other",
-            .expected = "custom+foo:other",
-        },
-        //NOT required :// for NON-special schemes
-        .{
-            .base = "http://www.example.com/example",
-            .path = "blob:",
-            .expected = "blob:",
-        },
-        //NOT required :// for special scheme equal base scheme
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:",
-            .expected = "http://www.example.com/example",
-        },
-        //required :// for special scheme, so throw error.InvalidURL
-        .{
-            .base = "http://www.example.com/example",
-            .path = "https:",
-            .expected = "",
-            .expected_error = true,
-        },
-        //incorrect symbols in path scheme
-        .{
-            .base = "https://site",
-            .path = "http?://host/some",
-            .expected = "https://site/http?://host/some",
-        },
-    };
-
-    for (cases) |case| {
-        if (case.expected_error) {
-            const result = resolve(testing.arena_allocator, case.base, case.path, .{});
-            try testing.expectError(error.TypeError, result);
-        } else {
-            const result = try resolve(testing.arena_allocator, case.base, case.path, .{});
-            try testing.expectString(case.expected, result);
-        }
-    }
-}
--- a/src/browser/js/bridge.zig
+++ b/src/browser/js/bridge.zig
@@ -829,8 +829,6 @@ pub const JsApis = flattenTypes(&.{
    @import("../webapi/net/URLSearchParams.zig"),
    @import("../webapi/net/XMLHttpRequest.zig"),
    @import("../webapi/net/XMLHttpRequestEventTarget.zig"),
-    @import("../webapi/net/WebSocket.zig"),
-    @import("../webapi/event/CloseEvent.zig"),
    @import("../webapi/streams/ReadableStream.zig"),
    @import("../webapi/streams/ReadableStreamDefaultReader.zig"),
    @import("../webapi/streams/ReadableStreamDefaultController.zig"),
--- a/src/browser/tests/net/websocket.html
+++ b/src/browser/tests/net/websocket.html
@@ -1,240 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=basic_echo type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    ws.send('msg1');
-  });
-
-  ws.addEventListener('close', (e) => {
-    received.push(['close', e.code, e.reason]);
-    state.resolve();
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data);
-    ws.close(1000, 'bye');
-  });
-
-  await state.done(() => {
-    testing.expectEqual([
-      'echo-msg1',
-      ['close', 1000, 'bye'],
-    ], received);
-  });
-}
-</script>
-
-<script id=multiple_messages type=module>
-{
-  const state = await testing.async();
-  let received = [];
-  let sendCount = 0;
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    ws.send('first');
-    ws.send('second');
-    ws.send('third');
-    sendCount = 3;
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data);
-    if (received.length === sendCount) {
-      ws.close();
-    }
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([
-      'echo-first',
-      'echo-second',
-      'echo-third',
-    ], received);
-  });
-}
-</script>
-
-<script id=empty_message type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    ws.send('');
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    // Empty message echoed with "echo-" prefix
-    testing.expectEqual(['echo-'], received);
-  });
-}
-</script>
-
-<script id=boundary_125 type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    // 120 bytes + "echo-" prefix = 125 bytes response (single-byte length)
-    ws.send('A'.repeat(120));
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data.length);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([125], received);
-  });
-}
-</script>
-
-<script id=boundary_16bit type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    // 200 bytes message
-    ws.send('B'.repeat(200));
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data.length);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([205], received); // 200 + "echo-".length
-  });
-}
-</script>
-
-<script id=receive_large type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    // Ask server to send us a 10000 byte message
-    ws.send('send-large:10000');
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data.length);
-    // Verify pattern (A-Z repeating)
-    const expected_start = 'ABCDEFGHIJ';
-    received.push(e.data.substring(0, 10) === expected_start);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([10000, true], received);
-  });
-}
-</script>
-
-<script id=send_large type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    // Send 5000 byte message
-    ws.send('X'.repeat(5000));
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data.length);
-    // Check it starts with echo- and then our Xs
-    received.push(e.data.startsWith('echo-XXXXX'));
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([5005, true], received); // 5000 + "echo-".length
-  });
-}
-</script>
-
-<script id=binary_uint8array type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-  ws.binaryType = 'arraybuffer';
-
-  ws.addEventListener('open', () => {
-    const data = new Uint8Array([1, 2, 3, 4, 5]);
-    ws.send(data);
-  });
-
-  ws.addEventListener('message', (e) => {
-    const arr = new Uint8Array(e.data);
-    // Server prepends 0xEE marker to binary responses
-    received.push(arr[0]); // 0xEE marker
-    received.push(arr.length);
-    received.push(arr[1]); // Our first byte
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([0xEE, 6, 1], received);
-  });
-}
-</script>
--- a/src/browser/tests/net/websocket2.html
+++ b/src/browser/tests/net/websocket2.html
@@ -1,233 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=binary_arraybuffer type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-  ws.binaryType = 'arraybuffer';
-
-  ws.addEventListener('open', () => {
-    const buffer = new ArrayBuffer(4);
-    const view = new Uint8Array(buffer);
-    view[0] = 10;
-    view[1] = 20;
-    view[2] = 30;
-    view[3] = 40;
-    ws.send(buffer);
-  });
-
-  ws.addEventListener('message', (e) => {
-    const arr = new Uint8Array(e.data);
-    received.push(arr.length);
-    received.push(arr[1]); // First byte of our data (after 0xEE marker)
-    received.push(arr[4]); // Last byte of our data
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([5, 10, 40], received);
-  });
-}
-</script>
-
-<script id=binary_int32array type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-  ws.binaryType = 'arraybuffer';
-
-  ws.addEventListener('open', () => {
-    const arr = new Int32Array([0x01020304, 0x05060708]);
-    ws.send(arr);
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data.byteLength);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    // 1 marker byte + 8 bytes (2 x 4-byte int32)
-    testing.expectEqual([9], received);
-  });
-}
-</script>
-
-<script id=binary_int32array22 type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  console.warn('last-test');
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-  ws.binaryType = 'arraybuffer';
-
-  ws.addEventListener('open', () => {
-    const arr = new Int32Array([0x01020304, 0x05060708]);
-    ws.send(arr);
-  });
-
-  ws.addEventListener('message', (e) => {
-    received.push(e.data.byteLength);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    console.warn('aaa');
-    // 1 marker byte + 8 bytes (2 x 4-byte int32)
-    testing.expectEqual([9], received);
-  });
-}
-</script>
-
-<script id=binary_blob type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-  ws.binaryType = 'arraybuffer';
-
-  ws.addEventListener('open', () => {
-    const blob = new Blob(['hello'], { type: 'text/plain' });
-    ws.send(blob);
-  });
-
-  ws.addEventListener('message', (e) => {
-    const arr = new Uint8Array(e.data);
-    received.push(arr.length);
-    received.push(arr[0]); // 0xEE marker
-    // 'h' = 104, 'e' = 101, 'l' = 108
-    received.push(arr[1]); // 'h'
-    received.push(arr[2]); // 'e'
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([6, 0xEE, 104, 101], received);
-  });
-}
-</script>
-
-<script id=server_close type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    ws.send('close:1001:going away');
-  });
-
-  ws.addEventListener('close', (e) => {
-    received.push(e.code);
-    received.push(e.reason);
-    received.push(e.wasClean);
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([1001, 'going away', true], received);
-  });
-}
-</script>
-
-<script id=force_close type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    ws.send('force-close');
-  });
-
-  ws.addEventListener('close', (e) => {
-    received.push('closed');
-    received.push(e.wasClean);
-    state.resolve();
-  });
-
-  ws.addEventListener('error', () => {
-    received.push('error');
-  });
-
-  await state.done(() => {
-    // Connection was not cleanly closed
-    testing.expectEqual(['closed', false], received);
-  });
-}
-</script>
-
-<script id=ready_state type=module>
-{
-  const state = await testing.async();
-  let states = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-  states.push(ws.readyState); // CONNECTING = 0
-
-  ws.addEventListener('open', () => {
-    states.push(ws.readyState); // OPEN = 1
-    ws.close();
-    states.push(ws.readyState); // CLOSING = 2
-  });
-
-  ws.addEventListener('close', () => {
-    states.push(ws.readyState); // CLOSED = 3
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([0, 1, 2, 3], states);
-  });
-}
-</script>
-
-<script id=buffered_amount type=module>
-{
-  const state = await testing.async();
-  let results = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    results.push(ws.bufferedAmount); // Should be 0 initially
-    ws.send('test');
-    // bufferedAmount might be non-zero right after send
-    // but will go to 0 after message is sent
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual([0], results);
-  });
-}
-</script>
--- a/src/browser/tests/net/websocket3.html
+++ b/src/browser/tests/net/websocket3.html
@@ -1,77 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=handler_properties type=module>
-{
-  const state = await testing.async();
-  let received = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.onopen = () => {
-    ws.send('handler-test');
-  };
-
-  ws.onmessage = (e) => {
-    received.push(e.data);
-    ws.close();
-  };
-
-  ws.onclose = () => {
-    received.push('closed');
-    state.resolve();
-  };
-
-  await state.done(() => {
-    testing.expectEqual(['echo-handler-test', 'closed'], received);
-  });
-}
-</script>
-
-<script id=binary_type type=module>
-{
-  const state = await testing.async();
-  let results = [];
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/');
-
-  ws.addEventListener('open', () => {
-    results.push(ws.binaryType); // Default is 'blob'
-    ws.binaryType = 'arraybuffer';
-    results.push(ws.binaryType);
-    ws.binaryType = 'blob';
-    results.push(ws.binaryType);
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual(['blob', 'arraybuffer', 'blob'], results);
-  });
-}
-</script>
-
-<script id=url_property type=module>
-{
-  const state = await testing.async();
-  let result = null;
-
-  let ws = new WebSocket('ws://127.0.0.1:9584/path');
-
-  ws.addEventListener('open', () => {
-    result = ws.url;
-    ws.close();
-  });
-
-  ws.addEventListener('close', () => {
-    state.resolve();
-  });
-
-  await state.done(() => {
-    testing.expectEqual('ws://127.0.0.1:9584/path', result);
-  });
-}
-</script>
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -523,31 +523,6 @@ pub fn setDir(self: *Element, value: []const u8, page: *Page) !void {
    return self.setAttributeSafe(comptime .wrap("dir"), .wrap(value), page);
 }

-// ARIAMixin - ARIA attribute reflection
-pub fn getAriaAtomic(self: *const Element) ?[]const u8 {
-    return self.getAttributeSafe(comptime .wrap("aria-atomic"));
-}
-
-pub fn setAriaAtomic(self: *Element, value: ?[]const u8, page: *Page) !void {
-    if (value) |v| {
-        try self.setAttributeSafe(comptime .wrap("aria-atomic"), .wrap(v), page);
-    } else {
-        try self.removeAttribute(comptime .wrap("aria-atomic"), page);
-    }
-}
-
-pub fn getAriaLive(self: *const Element) ?[]const u8 {
-    return self.getAttributeSafe(comptime .wrap("aria-live"));
-}
-
-pub fn setAriaLive(self: *Element, value: ?[]const u8, page: *Page) !void {
-    if (value) |v| {
-        try self.setAttributeSafe(comptime .wrap("aria-live"), .wrap(v), page);
-    } else {
-        try self.removeAttribute(comptime .wrap("aria-live"), page);
-    }
-}
-
 pub fn getClassName(self: *const Element) []const u8 {
    return self.getAttributeSafe(comptime .wrap("class")) orelse "";
 }
@@ -1711,8 +1686,6 @@ pub const JsApi = struct {
    pub const localName = bridge.accessor(Element.getLocalName, null, .{});
    pub const id = bridge.accessor(Element.getId, Element.setId, .{});
    pub const slot = bridge.accessor(Element.getSlot, Element.setSlot, .{});
-    pub const ariaAtomic = bridge.accessor(Element.getAriaAtomic, Element.setAriaAtomic, .{});
-    pub const ariaLive = bridge.accessor(Element.getAriaLive, Element.setAriaLive, .{});
    pub const dir = bridge.accessor(Element.getDir, Element.setDir, .{});
    pub const className = bridge.accessor(Element.getClassName, Element.setClassName, .{});
    pub const classList = bridge.accessor(Element.getClassList, Element.setClassList, .{});
--- a/src/browser/webapi/Event.zig
+++ b/src/browser/webapi/Event.zig
@@ -80,7 +80,6 @@ pub const Type = union(enum) {
    promise_rejection_event: *@import("event/PromiseRejectionEvent.zig"),
    submit_event: *@import("event/SubmitEvent.zig"),
    form_data_event: *@import("event/FormDataEvent.zig"),
-    close_event: *@import("event/CloseEvent.zig"),
 };

 pub const Options = struct {
@@ -172,7 +171,6 @@ pub fn is(self: *Event, comptime T: type) ?*T {
        .promise_rejection_event => |e| return if (T == @import("event/PromiseRejectionEvent.zig")) e else null,
        .submit_event => |e| return if (T == @import("event/SubmitEvent.zig")) e else null,
        .form_data_event => |e| return if (T == @import("event/FormDataEvent.zig")) e else null,
-        .close_event => |e| return if (T == @import("event/CloseEvent.zig")) e else null,
        .ui_event => |e| {
            if (T == @import("event/UIEvent.zig")) {
                return e;
--- a/src/browser/webapi/EventTarget.zig
+++ b/src/browser/webapi/EventTarget.zig
@@ -45,7 +45,6 @@ pub const Type = union(enum) {
    visual_viewport: *@import("VisualViewport.zig"),
    file_reader: *@import("FileReader.zig"),
    font_face_set: *@import("css/FontFaceSet.zig"),
-    websocket: *@import("net/WebSocket.zig"),
 };

 pub fn init(page: *Page) !*EventTarget {
@@ -142,7 +141,6 @@ pub fn format(self: *EventTarget, writer: *std.Io.Writer) !void {
        .visual_viewport => writer.writeAll("<VisualViewport>"),
        .file_reader => writer.writeAll("<FileReader>"),
        .font_face_set => writer.writeAll("<FontFaceSet>"),
-        .websocket => writer.writeAll("<WebSocket>"),
    };
 }

@@ -162,7 +160,6 @@ pub fn toString(self: *EventTarget) []const u8 {
        .visual_viewport => return "[object VisualViewport]",
        .file_reader => return "[object FileReader]",
        .font_face_set => return "[object FontFaceSet]",
-        .websocket => return "[object WebSocket]",
    };
 }

--- a/src/browser/webapi/MessagePort.zig
+++ b/src/browser/webapi/MessagePort.zig
@@ -125,7 +125,7 @@ const PostMessageCallback = struct {
        const target = self.port.asEventTarget();
        if (page._event_manager.hasDirectListeners(target, "message", self.port._on_message)) {
            const event = (MessageEvent.initTrusted(comptime .wrap("message"), .{
-                .data = .{ .value = self.message },
+                .data = self.message,
                .origin = "",
                .source = null,
            }, page) catch |err| {
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -791,7 +791,7 @@ const PostMessageCallback = struct {
        const event_target = window.asEventTarget();
        if (page._event_manager.hasDirectListeners(event_target, "message", window._on_message)) {
            const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{
-                .data = .{ .value = self.message },
+                .data = self.message,
                .origin = self.origin,
                .source = self.source,
                .bubbles = false,
--- a/src/browser/webapi/element/Html.zig
+++ b/src/browser/webapi/element/Html.zig
@@ -391,14 +391,6 @@ pub fn setLang(self: *HtmlElement, value: []const u8, page: *Page) !void {
    try self.asElement().setAttributeSafe(comptime .wrap("lang"), .wrap(value), page);
 }

-pub fn getTitle(self: *HtmlElement) []const u8 {
-    return self.asElement().getAttributeSafe(comptime .wrap("title")) orelse "";
-}
-
-pub fn setTitle(self: *HtmlElement, value: []const u8, page: *Page) !void {
-    try self.asElement().setAttributeSafe(comptime .wrap("title"), .wrap(value), page);
-}
-
 pub fn getAttributeFunction(
    self: *HtmlElement,
    listener_type: GlobalEventHandler,
@@ -1239,7 +1231,6 @@ pub const JsApi = struct {
    pub const hidden = bridge.accessor(HtmlElement.getHidden, HtmlElement.setHidden, .{});
    pub const lang = bridge.accessor(HtmlElement.getLang, HtmlElement.setLang, .{});
    pub const tabIndex = bridge.accessor(HtmlElement.getTabIndex, HtmlElement.setTabIndex, .{});
-    pub const title = bridge.accessor(HtmlElement.getTitle, HtmlElement.setTitle, .{});

    pub const onabort = bridge.accessor(HtmlElement.getOnAbort, HtmlElement.setOnAbort, .{});
    pub const onanimationcancel = bridge.accessor(HtmlElement.getOnAnimationCancel, HtmlElement.setOnAnimationCancel, .{});
--- a/src/browser/webapi/element/html/Anchor.zig
+++ b/src/browser/webapi/element/html/Anchor.zig
@@ -174,14 +174,6 @@ pub fn setType(self: *Anchor, value: []const u8, page: *Page) !void {
    try self.asElement().setAttributeSafe(comptime .wrap("type"), .wrap(value), page);
 }

-pub fn getRel(self: *Anchor) []const u8 {
-    return self.asConstElement().getAttributeSafe(comptime .wrap("rel")) orelse "";
-}
-
-pub fn setRel(self: *Anchor, value: []const u8, page: *Page) !void {
-    try self.asElement().setAttributeSafe(comptime .wrap("rel"), .wrap(value), page);
-}
-
 pub fn getName(self: *const Anchor) []const u8 {
    return self.asConstElement().getAttributeSafe(comptime .wrap("name")) orelse "";
 }
@@ -226,7 +218,6 @@ pub const JsApi = struct {
    pub const pathname = bridge.accessor(Anchor.getPathname, Anchor.setPathname, .{});
    pub const search = bridge.accessor(Anchor.getSearch, Anchor.setSearch, .{});
    pub const hash = bridge.accessor(Anchor.getHash, Anchor.setHash, .{});
-    pub const rel = bridge.accessor(Anchor.getRel, Anchor.setRel, .{});
    pub const @"type" = bridge.accessor(Anchor.getType, Anchor.setType, .{});
    pub const text = bridge.accessor(Anchor.getText, Anchor.setText, .{});
    pub const relList = bridge.accessor(_getRelList, null, .{ .null_as_undefined = true });
--- a/src/browser/webapi/event/CloseEvent.zig
+++ b/src/browser/webapi/event/CloseEvent.zig
@@ -1,102 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const String = @import("../../../string.zig").String;
-
-const Page = @import("../../Page.zig");
-const Session = @import("../../Session.zig");
-const Event = @import("../Event.zig");
-const Allocator = std.mem.Allocator;
-
-const CloseEvent = @This();
-_proto: *Event,
-_code: u16 = 1000,
-_reason: []const u8 = "",
-_was_clean: bool = true,
-
-const CloseEventOptions = struct {
-    code: u16 = 1000,
-    reason: []const u8 = "",
-    wasClean: bool = true,
-};
-
-const Options = Event.inheritOptions(CloseEvent, CloseEventOptions);
-
-pub fn init(typ: []const u8, _opts: ?Options, page: *Page) !*CloseEvent {
-    const arena = try page.getArena(.{ .debug = "CloseEvent" });
-    errdefer page.releaseArena(arena);
-    const type_string = try String.init(arena, typ, .{});
-    return initWithTrusted(arena, type_string, _opts, false, page);
-}
-
-pub fn initTrusted(typ: String, _opts: ?Options, page: *Page) !*CloseEvent {
-    const arena = try page.getArena(.{ .debug = "CloseEvent.trusted" });
-    errdefer page.releaseArena(arena);
-    return initWithTrusted(arena, typ, _opts, true, page);
-}
-
-fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool, page: *Page) !*CloseEvent {
-    const opts = _opts orelse Options{};
-
-    const event = try page._factory.event(
-        arena,
-        typ,
-        CloseEvent{
-            ._proto = undefined,
-            ._code = opts.code,
-            ._reason = if (opts.reason.len > 0) try arena.dupe(u8, opts.reason) else "",
-            ._was_clean = opts.wasClean,
-        },
-    );
-
-    Event.populatePrototypes(event, opts, trusted);
-    return event;
-}
-
-pub fn asEvent(self: *CloseEvent) *Event {
-    return self._proto;
-}
-
-pub fn getCode(self: *const CloseEvent) u16 {
-    return self._code;
-}
-
-pub fn getReason(self: *const CloseEvent) []const u8 {
-    return self._reason;
-}
-
-pub fn getWasClean(self: *const CloseEvent) bool {
-    return self._was_clean;
-}
-
-pub const JsApi = struct {
-    const js = @import("../../js/js.zig");
-    pub const bridge = js.Bridge(CloseEvent);
-
-    pub const Meta = struct {
-        pub const name = "CloseEvent";
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-    };
-
-    pub const constructor = bridge.constructor(CloseEvent.init, .{});
-    pub const code = bridge.accessor(CloseEvent.getCode, null, .{});
-    pub const reason = bridge.accessor(CloseEvent.getReason, null, .{});
-    pub const wasClean = bridge.accessor(CloseEvent.getWasClean, null, .{});
-};
--- a/src/browser/webapi/event/MessageEvent.zig
+++ b/src/browser/webapi/event/MessageEvent.zig
@@ -30,22 +30,16 @@ const Allocator = std.mem.Allocator;
 const MessageEvent = @This();

 _proto: *Event,
-_data: ?Data = null,
+_data: ?js.Value.Temp = null,
 _origin: []const u8 = "",
 _source: ?*Window = null,

 const MessageEventOptions = struct {
-    data: ?Data = null,
+    data: ?js.Value.Temp = null,
    origin: ?[]const u8 = null,
    source: ?*Window = null,
 };

-pub const Data = union(enum) {
-    value: js.Value.Temp,
-    string: []const u8,
-    arraybuffer: js.ArrayBuffer,
-};
-
 const Options = Event.inheritOptions(MessageEvent, MessageEventOptions);

 pub fn init(typ: []const u8, opts_: ?Options, page: *Page) !*MessageEvent {
@@ -81,10 +75,7 @@ fn initWithTrusted(arena: Allocator, typ: String, opts_: ?Options, trusted: bool

 pub fn deinit(self: *MessageEvent, session: *Session) void {
    if (self._data) |d| {
-        switch (d) {
-            .value => |js_val| js_val.release(),
-            .string, .arraybuffer => {},
-        }
+        d.release();
    }
    self._proto.deinit(session);
 }
@@ -101,7 +92,7 @@ pub fn asEvent(self: *MessageEvent) *Event {
    return self._proto;
 }

-pub fn getData(self: *const MessageEvent) ?Data {
+pub fn getData(self: *const MessageEvent) ?js.Value.Temp {
    return self._data;
 }

--- a/src/browser/webapi/net/Headers.zig
+++ b/src/browser/webapi/net/Headers.zig
@@ -86,8 +86,8 @@ pub fn forEach(self: *Headers, cb_: js.Function, js_this_: ?js.Object) !void {
 }

 // TODO: do we really need 2 different header structs??
-const http = @import("../../../network/http.zig");
-pub fn populateHttpHeader(self: *Headers, allocator: Allocator, http_headers: *http.Headers) !void {
+const net_http = @import("../../../network/http.zig");
+pub fn populateHttpHeader(self: *Headers, allocator: Allocator, http_headers: *net_http.Headers) !void {
    for (self._list._entries.items) |entry| {
        const merged = try std.mem.concatWithSentinel(allocator, u8, &.{ entry.name.str(), ": ", entry.value.str() }, 0);
        try http_headers.add(merged);
--- a/src/browser/webapi/net/Request.zig
+++ b/src/browser/webapi/net/Request.zig
@@ -19,7 +19,7 @@
 const std = @import("std");

 const js = @import("../../js/js.zig");
-const http = @import("../../../network/http.zig");
+const net_http = @import("../../../network/http.zig");

 const URL = @import("../URL.zig");
 const Page = @import("../../Page.zig");
@@ -31,7 +31,7 @@ const Allocator = std.mem.Allocator;
 const Request = @This();

 _url: [:0]const u8,
-_method: http.Method,
+_method: net_http.Method,
 _headers: ?*Headers,
 _body: ?[]const u8,
 _arena: Allocator,
@@ -119,14 +119,14 @@ pub fn init(input: Input, opts_: ?InitOpts, page: *Page) !*Request {
    });
 }

-fn parseMethod(method: []const u8, page: *Page) !http.Method {
+fn parseMethod(method: []const u8, page: *Page) !net_http.Method {
    if (method.len > "propfind".len) {
        return error.InvalidMethod;
    }

    const lower = std.ascii.lowerString(&page.buf, method);

-    const method_lookup = std.StaticStringMap(http.Method).initComptime(.{
+    const method_lookup = std.StaticStringMap(net_http.Method).initComptime(.{
        .{ "get", .GET },
        .{ "post", .POST },
        .{ "delete", .DELETE },
--- a/src/browser/webapi/net/WebSocket.zig
+++ b/src/browser/webapi/net/WebSocket.zig
@@ -1,687 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const lp = @import("lightpanda");
-
-const log = @import("../../../log.zig");
-const http = @import("../../../network/http.zig");
-
-const js = @import("../../js/js.zig");
-const Blob = @import("../Blob.zig");
-const URL = @import("../../URL.zig");
-const Page = @import("../../Page.zig");
-const Session = @import("../../Session.zig");
-const HttpClient = @import("../../HttpClient.zig");
-
-const Event = @import("../Event.zig");
-const EventTarget = @import("../EventTarget.zig");
-const MessageEvent = @import("../event/MessageEvent.zig");
-const CloseEvent = @import("../event/CloseEvent.zig");
-
-const Allocator = std.mem.Allocator;
-const IS_DEBUG = @import("builtin").mode == .Debug;
-
-const WebSocket = @This();
-_rc: lp.RC(u8) = .{},
-_page: *Page,
-_proto: *EventTarget,
-_arena: Allocator,
-
-// Connection state
-_ready_state: ReadyState = .connecting,
-_url: [:0]const u8 = "",
-_binary_type: BinaryType = .blob,
-
-// Handshake tracking
-_got_101: bool = false,
-_got_upgrade: bool = false,
-
-_conn: ?*http.Connection,
-_http_client: *HttpClient,
-
-// buffered outgoing messages
-_send_queue: std.ArrayList(Message) = .empty,
-_send_offset: usize = 0,
-
-// buffered incoming frame
-_recv_buffer: std.ArrayList(u8) = .empty,
-
-// close info for event dispatch
-_close_code: u16 = 1000,
-_close_reason: []const u8 = "",
-
-// Event handlers
-_on_open: ?js.Function.Temp = null,
-_on_message: ?js.Function.Temp = null,
-_on_error: ?js.Function.Temp = null,
-_on_close: ?js.Function.Temp = null,
-
-pub const ReadyState = enum(u8) {
-    connecting = 0,
-    open = 1,
-    closing = 2,
-    closed = 3,
-};
-
-pub const BinaryType = enum {
-    blob,
-    arraybuffer,
-};
-
-pub fn init(url: []const u8, protocols_: ?[]const u8, page: *Page) !*WebSocket {
-    if (protocols_) |protocols| {
-        if (protocols.len > 0) {
-            log.warn(.not_implemented, "WS protocols", .{ .protocols = protocols });
-        }
-    }
-
-    {
-        if (url.len < 6) {
-            return error.SyntaxError;
-        }
-        const normalized_start = std.ascii.lowerString(&page.buf, url[0..6]);
-        if (!std.mem.startsWith(u8, normalized_start, "ws://") and !std.mem.startsWith(u8, normalized_start, "wss://")) {
-            return error.SyntaxError;
-        }
-    }
-
-    const arena = try page.getArena(.{ .debug = "WebSocket" });
-    errdefer page.releaseArena(arena);
-
-    const resolved_url = try URL.resolve(arena, page.base(), url, .{ .always_dupe = true, .encode = true });
-
-    const http_client = page._session.browser.http_client;
-    const conn = http_client.network.getConnection() orelse {
-        // TODO: figure out how/where we actually want to get WebSocket connections
-        // from. I feel like sharing this with the HTTP Connection Pool is a
-        // mistake.
-        return error.NoFreeConnection;
-    };
-
-    errdefer http_client.network.releaseConnection(conn);
-
-    try conn.setURL(resolved_url);
-    try conn.setConnectOnly(false);
-
-    try conn.setReadCallback(sendDataCallback, true);
-    try conn.setWriteCallback(receivedDataCallback);
-    try conn.setHeaderCallback(receivedHeaderCalllback);
-
-    const self = try page._factory.eventTargetWithAllocator(arena, WebSocket{
-        ._page = page,
-        ._conn = conn,
-        ._arena = arena,
-        ._proto = undefined,
-        ._url = resolved_url,
-        ._http_client = http_client,
-    });
-    conn.transport = .{ .websocket = self };
-    try http_client.trackConn(conn);
-
-    if (comptime IS_DEBUG) {
-        log.info(.http, "WS connecting", .{ .url = url });
-    }
-
-    // Unlike an XHR object where we only selectively reference the instance
-    // while the request is actually inflight, WS connection is "inflight" from
-    // the moment it's created.
-    self.acquireRef();
-
-    return self;
-}
-
-pub fn deinit(self: *WebSocket, session: *Session) void {
-    self.cleanup();
-
-    if (self._on_open) |func| {
-        func.release();
-    }
-    if (self._on_message) |func| {
-        func.release();
-    }
-    if (self._on_error) |func| {
-        func.release();
-    }
-    if (self._on_close) |func| {
-        func.release();
-    }
-
-    for (self._send_queue.items) |msg| {
-        msg.deinit(session);
-    }
-
-    session.releaseArena(self._arena);
-}
-
-// we're being aborted internally (e.g. page shutting down)
-pub fn kill(self: *WebSocket) void {
-    self.cleanup();
-}
-
-pub fn disconnected(self: *WebSocket, err_: ?anyerror) void {
-    const was_clean = self._ready_state == .closing and err_ == null;
-    self._ready_state = .closed;
-
-    if (err_) |err| {
-        log.warn(.http, "WS disconnected", .{ .err = err, .url = self._url });
-    } else {
-        log.info(.http, "WS disconnected", .{ .url = self._url, .reason = "closed" });
-    }
-
-    self.cleanup();
-
-    // Use 1006 (abnormal closure) if connection wasn't cleanly closed
-    const code = if (was_clean) self._close_code else 1006;
-    const reason = if (was_clean) self._close_reason else "";
-
-    self.dispatchCloseEvent(code, reason, was_clean) catch |err| {
-        log.err(.http, "WS close event dispatch failed", .{ .err = err });
-    };
-}
-
-fn cleanup(self: *WebSocket) void {
-    if (self._conn) |conn| {
-        self._http_client.removeConn(conn);
-        self._conn = null;
-        self.releaseRef(self._page._session);
-    }
-}
-
-pub fn releaseRef(self: *WebSocket, session: *Session) void {
-    self._rc.release(self, session);
-}
-
-pub fn acquireRef(self: *WebSocket) void {
-    self._rc.acquire();
-}
-
-fn asEventTarget(self: *WebSocket) *EventTarget {
-    return self._proto;
-}
-
-fn queueMessage(self: *WebSocket, msg: Message) !void {
-    const was_empty = self._send_queue.items.len == 0;
-    try self._send_queue.append(self._arena, msg);
-
-    if (was_empty) {
-        // Unpause the send callback so libcurl will request data
-        if (self._conn) |conn| {
-            try conn.pause(.{ .cont = true });
-        }
-    }
-}
-
-/// WebSocket send() accepts string, Blob, ArrayBuffer, or TypedArray
-const SendData = union(enum) {
-    blob: *Blob,
-    js_val: js.Value,
-};
-
-/// Union for extracting bytes from ArrayBuffer/TypedArray
-const BinaryData = union(enum) {
-    int8: []i8,
-    uint8: []u8,
-    int16: []i16,
-    uint16: []u16,
-    int32: []i32,
-    uint32: []u32,
-    int64: []i64,
-    uint64: []u64,
-
-    fn asBuffer(self: BinaryData) []u8 {
-        return switch (self) {
-            .int8 => |b| @as([*]u8, @ptrCast(b.ptr))[0..b.len],
-            .uint8 => |b| b,
-            .int16 => |b| @as([*]u8, @ptrCast(b.ptr))[0 .. b.len * 2],
-            .uint16 => |b| @as([*]u8, @ptrCast(b.ptr))[0 .. b.len * 2],
-            .int32 => |b| @as([*]u8, @ptrCast(b.ptr))[0 .. b.len * 4],
-            .uint32 => |b| @as([*]u8, @ptrCast(b.ptr))[0 .. b.len * 4],
-            .int64 => |b| @as([*]u8, @ptrCast(b.ptr))[0 .. b.len * 8],
-            .uint64 => |b| @as([*]u8, @ptrCast(b.ptr))[0 .. b.len * 8],
-        };
-    }
-};
-
-pub fn send(self: *WebSocket, data: SendData) !void {
-    if (self._ready_state != .open) {
-        return error.InvalidStateError;
-    }
-
-    // Get a dedicated arena for this message
-    const arena = try self._page._session.getArena(.{ .debug = "WebSocket message" });
-    errdefer self._page._session.releaseArena(arena);
-
-    switch (data) {
-        .blob => |blob| {
-            try self.queueMessage(.{ .binary = .{
-                .arena = arena,
-                .data = try arena.dupe(u8, blob._slice),
-            } });
-        },
-        .js_val => |js_val| {
-            if (js_val.isString()) |str| {
-                try self.queueMessage(.{ .text = .{
-                    .arena = arena,
-                    .data = try str.toSliceWithAlloc(arena),
-                } });
-            } else {
-                const binary = try js_val.toZig(BinaryData);
-                try self.queueMessage(.{ .binary = .{
-                    .arena = arena,
-                    .data = try arena.dupe(u8, binary.asBuffer()),
-                } });
-            }
-        },
-    }
-}
-
-pub fn close(self: *WebSocket, code_: ?u16, reason_: ?[]const u8) !void {
-    if (self._ready_state == .closing or self._ready_state == .closed) {
-        return;
-    }
-
-    const code = code_ orelse 1000;
-    const reason = reason_ orelse "";
-
-    if (self._ready_state == .connecting) {
-        // Connection not yet established - fail it
-        self._ready_state = .closed;
-        self.cleanup();
-        try self.dispatchCloseEvent(code, reason, false);
-        return;
-    }
-
-    self._ready_state = .closing;
-    self._close_code = code;
-    self._close_reason = try self._arena.dupe(u8, reason);
-    try self.queueMessage(.close);
-}
-
-pub fn getUrl(self: *const WebSocket) []const u8 {
-    return self._url;
-}
-
-pub fn getReadyState(self: *const WebSocket) u16 {
-    return @intFromEnum(self._ready_state);
-}
-
-pub fn getBufferedAmount(self: *const WebSocket) u32 {
-    var buffered: u32 = 0;
-    for (self._send_queue.items) |msg| {
-        switch (msg) {
-            .text, .binary => |byte_msg| buffered += @intCast(byte_msg.data.len),
-            .close => buffered += @intCast(2 + self._close_reason.len),
-        }
-    }
-    return buffered;
-}
-
-pub fn getProtocol(self: *const WebSocket) []const u8 {
-    return self._protocol;
-}
-
-pub fn getExtensions(self: *const WebSocket) []const u8 {
-    return self._extensions;
-}
-
-pub fn getBinaryType(self: *const WebSocket) []const u8 {
-    return @tagName(self._binary_type);
-}
-
-pub fn setBinaryType(self: *WebSocket, value: []const u8) void {
-    if (std.meta.stringToEnum(BinaryType, value)) |bt| {
-        self._binary_type = bt;
-    }
-}
-
-pub fn getOnOpen(self: *const WebSocket) ?js.Function.Temp {
-    return self._on_open;
-}
-
-pub fn setOnOpen(self: *WebSocket, cb_: ?js.Function) !void {
-    if (self._on_open) |old| old.release();
-    if (cb_) |cb| {
-        self._on_open = try cb.tempWithThis(self);
-    } else {
-        self._on_open = null;
-    }
-}
-
-pub fn getOnMessage(self: *const WebSocket) ?js.Function.Temp {
-    return self._on_message;
-}
-
-pub fn setOnMessage(self: *WebSocket, cb_: ?js.Function) !void {
-    if (self._on_message) |old| old.release();
-    if (cb_) |cb| {
-        self._on_message = try cb.tempWithThis(self);
-    } else {
-        self._on_message = null;
-    }
-}
-
-pub fn getOnError(self: *const WebSocket) ?js.Function.Temp {
-    return self._on_error;
-}
-
-pub fn setOnError(self: *WebSocket, cb_: ?js.Function) !void {
-    if (self._on_error) |old| old.release();
-    if (cb_) |cb| {
-        self._on_error = try cb.tempWithThis(self);
-    } else {
-        self._on_error = null;
-    }
-}
-
-pub fn getOnClose(self: *const WebSocket) ?js.Function.Temp {
-    return self._on_close;
-}
-
-pub fn setOnClose(self: *WebSocket, cb_: ?js.Function) !void {
-    if (self._on_close) |old| old.release();
-    if (cb_) |cb| {
-        self._on_close = try cb.tempWithThis(self);
-    } else {
-        self._on_close = null;
-    }
-}
-
-fn dispatchOpenEvent(self: *WebSocket) !void {
-    const page = self._page;
-    const target = self.asEventTarget();
-
-    if (page._event_manager.hasDirectListeners(target, "open", self._on_open)) {
-        const event = try Event.initTrusted(.wrap("open"), .{}, page);
-        try page._event_manager.dispatchDirect(target, event, self._on_open, .{ .context = "WebSocket open" });
-    }
-}
-
-fn dispatchMessageEvent(self: *WebSocket, data: []const u8, frame_type: http.WsFrameType) !void {
-    const page = self._page;
-    const target = self.asEventTarget();
-
-    if (page._event_manager.hasDirectListeners(target, "message", self._on_message)) {
-        const msg_data: MessageEvent.Data = if (frame_type == .binary and self._binary_type == .arraybuffer)
-            .{ .arraybuffer = .{ .values = data } }
-        else
-            .{ .string = data };
-
-        const event = try MessageEvent.initTrusted(.wrap("message"), .{
-            .data = msg_data,
-            .origin = "",
-        }, page);
-        try page._event_manager.dispatchDirect(target, event.asEvent(), self._on_message, .{ .context = "WebSocket message" });
-    }
-}
-
-fn dispatchCloseEvent(self: *WebSocket, code: u16, reason: []const u8, was_clean: bool) !void {
-    const page = self._page;
-    const target = self.asEventTarget();
-
-    if (page._event_manager.hasDirectListeners(target, "close", self._on_close)) {
-        const event = try CloseEvent.initTrusted(.wrap("close"), .{
-            .code = code,
-            .reason = reason,
-            .wasClean = was_clean,
-        }, page);
-        try page._event_manager.dispatchDirect(target, event.asEvent(), self._on_close, .{ .context = "WebSocket close" });
-    }
-}
-
-fn sendDataCallback(buffer: [*]u8, buf_count: usize, buf_len: usize, data: *anyopaque) usize {
-    if (comptime IS_DEBUG) {
-        std.debug.assert(buf_count == 1);
-    }
-    const conn: *http.Connection = @ptrCast(@alignCast(data));
-    return _sendDataCallback(conn, buffer[0..buf_len]) catch |err| {
-        log.warn(.http, "WS send callback", .{ .err = err });
-        return http.readfunc_pause;
-    };
-}
-
-fn _sendDataCallback(conn: *http.Connection, buf: []u8) !usize {
-    lp.assert(buf.len >= 2, "WS short buffer", .{ .len = buf.len });
-
-    const self = conn.transport.websocket;
-
-    if (self._send_queue.items.len == 0) {
-        // No data to send - pause until queueMessage is called
-        return http.readfunc_pause;
-    }
-
-    const msg = &self._send_queue.items[0];
-
-    switch (msg.*) {
-        .close => {
-            const code = self._close_code;
-            const reason = self._close_reason;
-
-            // Close frame: 2 bytes for code (big-endian) + optional reason
-            // Truncate reason to fit in buf (max 123 bytes per spec)
-            const reason_len: usize = @min(reason.len, 123, buf.len -| 2);
-            const frame_len = 2 + reason_len;
-            const to_copy = @min(buf.len, frame_len);
-
-            var close_payload: [125]u8 = undefined;
-            close_payload[0] = @intCast((code >> 8) & 0xFF);
-            close_payload[1] = @intCast(code & 0xFF);
-            if (reason_len > 0) {
-                @memcpy(close_payload[2..][0..reason_len], reason[0..reason_len]);
-            }
-
-            try conn.wsStartFrame(.close, to_copy);
-            @memcpy(buf[0..to_copy], close_payload[0..to_copy]);
-
-            _ = self._send_queue.orderedRemove(0);
-            return to_copy;
-        },
-        .text => |content| return self.writeContent(conn, buf, content, .text),
-        .binary => |content| return self.writeContent(conn, buf, content, .binary),
-    }
-}
-
-fn writeContent(self: *WebSocket, conn: *http.Connection, buf: []u8, byte_msg: Message.Content, frame_type: http.WsFrameType) !usize {
-    if (self._send_offset == 0) {
-        // start of the message
-        try conn.wsStartFrame(frame_type, byte_msg.data.len);
-    }
-
-    const remaining = byte_msg.data[self._send_offset..];
-    const to_copy = @min(remaining.len, buf.len);
-    @memcpy(buf[0..to_copy], remaining[0..to_copy]);
-
-    self._send_offset += to_copy;
-
-    if (self._send_offset >= byte_msg.data.len) {
-        const removed = self._send_queue.orderedRemove(0);
-        removed.deinit(self._page._session);
-        self._send_offset = 0;
-    }
-
-    return to_copy;
-}
-
-fn receivedDataCallback(buffer: [*]const u8, buf_count: usize, buf_len: usize, data: *anyopaque) usize {
-    if (comptime IS_DEBUG) {
-        std.debug.assert(buf_count == 1);
-    }
-    const conn: *http.Connection = @ptrCast(@alignCast(data));
-    _receivedDataCallback(conn, buffer[0..buf_len]) catch |err| {
-        log.warn(.http, "WS receive callback", .{ .err = err });
-        // TODO: are there errors, like an invalid frame, that we shouldn't treat
-        // as an error?
-        return http.writefunc_error;
-    };
-
-    return buf_len;
-}
-
-fn _receivedDataCallback(conn: *http.Connection, data: []const u8) !void {
-    const self = conn.transport.websocket;
-    const meta = conn.wsMeta() orelse {
-        log.err(.http, "WS missing meta", .{ .url = self._url });
-        return error.NoFrameMeta;
-    };
-
-    if (meta.offset == 0) {
-        // Start of new frame. Pre-allocate buffer
-        self._recv_buffer.clearRetainingCapacity();
-        if (meta.len > self._http_client.max_response_size) {
-            return error.MessageTooLarge;
-        }
-        try self._recv_buffer.ensureTotalCapacity(self._arena, meta.len);
-    }
-
-    try self._recv_buffer.appendSlice(self._arena, data);
-
-    if (meta.bytes_left > 0) {
-        // still more data waiting for this frame
-        return;
-    }
-
-    const message = self._recv_buffer.items;
-    switch (meta.frame_type) {
-        .text, .binary => try self.dispatchMessageEvent(message, meta.frame_type),
-        .close => {
-            // Parse close frame: 2-byte code (big-endian) + optional reason
-            self._close_code = if (message.len >= 2)
-                @as(u16, message[0]) << 8 | message[1]
-            else
-                1005; // No status code received
-            if (message.len > 2) {
-                self._close_reason = try self._arena.dupe(u8, message[2..]);
-            }
-            self._ready_state = .closing;
-            self.disconnected(null);
-        },
-        .ping, .pong, .cont => {},
-    }
-}
-
-// libcurl has no mechanism to signal that the connection is established. The
-// best option I could come up with was looking for an upgrade header response.
-fn receivedHeaderCalllback(buffer: [*]const u8, header_count: usize, buf_len: usize, data: *anyopaque) usize {
-    if (comptime IS_DEBUG) {
-        std.debug.assert(header_count == 1);
-    }
-    const conn: *http.Connection = @ptrCast(@alignCast(data));
-    const self = conn.transport.websocket;
-    const header = buffer[0..buf_len];
-
-    if (self._got_101 == false and std.mem.startsWith(u8, header, "HTTP/")) {
-        if (std.mem.indexOf(u8, header, " 101 ")) |_| {
-            self._got_101 = true;
-        }
-        return buf_len;
-    }
-
-    // Empty line = end of headers
-    if (buf_len <= 2) {
-        if (!self._got_101 or !self._got_upgrade) {
-            return 0;
-        }
-
-        self._ready_state = .open;
-        log.info(.http, "WS connected", .{ .url = self._url });
-
-        self.dispatchOpenEvent() catch |err| {
-            log.err(.http, "WS open event fail", .{ .err = err });
-        };
-        return buf_len;
-    }
-
-    if (self._got_upgrade) {
-        // dont' care about headers once we've gotten the upgrade header
-        return buf_len;
-    }
-
-    const colon = std.mem.indexOfScalarPos(u8, header, 0, ':') orelse {
-        // weird, continue...
-        return buf_len;
-    };
-
-    if (std.ascii.eqlIgnoreCase(header[0..colon], "upgrade") == false) {
-        return buf_len;
-    }
-
-    const value = std.mem.trim(u8, header[colon + 1 ..], " \t\r\n");
-    if (std.ascii.eqlIgnoreCase(value, "websocket")) {
-        self._got_upgrade = true;
-    }
-
-    return buf_len;
-}
-
-const Message = union(enum) {
-    close,
-    text: Content,
-    binary: Content,
-
-    const Content = struct {
-        arena: Allocator,
-        data: []const u8,
-    };
-    fn deinit(self: Message, session: *Session) void {
-        switch (self) {
-            .text, .binary => |msg| session.releaseArena(msg.arena),
-            .close => {},
-        }
-    }
-};
-
-pub const JsApi = struct {
-    pub const bridge = js.Bridge(WebSocket);
-
-    pub const Meta = struct {
-        pub const name = "WebSocket";
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-    };
-
-    pub const constructor = bridge.constructor(WebSocket.init, .{ .dom_exception = true });
-
-    pub const CONNECTING = bridge.property(@intFromEnum(ReadyState.connecting), .{ .template = true });
-    pub const OPEN = bridge.property(@intFromEnum(ReadyState.open), .{ .template = true });
-    pub const CLOSING = bridge.property(@intFromEnum(ReadyState.closing), .{ .template = true });
-    pub const CLOSED = bridge.property(@intFromEnum(ReadyState.closed), .{ .template = true });
-
-    pub const url = bridge.accessor(WebSocket.getUrl, null, .{});
-    pub const readyState = bridge.accessor(WebSocket.getReadyState, null, .{});
-    pub const bufferedAmount = bridge.accessor(WebSocket.getBufferedAmount, null, .{});
-    pub const binaryType = bridge.accessor(WebSocket.getBinaryType, WebSocket.setBinaryType, .{});
-
-    pub const protocol = bridge.property("", .{ .template = false });
-    pub const extensions = bridge.property("", .{ .template = false });
-
-    pub const onopen = bridge.accessor(WebSocket.getOnOpen, WebSocket.setOnOpen, .{});
-    pub const onmessage = bridge.accessor(WebSocket.getOnMessage, WebSocket.setOnMessage, .{});
-    pub const onerror = bridge.accessor(WebSocket.getOnError, WebSocket.setOnError, .{});
-    pub const onclose = bridge.accessor(WebSocket.getOnClose, WebSocket.setOnClose, .{});
-
-    pub const send = bridge.function(WebSocket.send, .{ .dom_exception = true });
-    pub const close = bridge.function(WebSocket.close, .{});
-};
-
-const testing = @import("../../../testing.zig");
-test "WebApi: WebSocket" {
-    // TEMP since we're currently limited to 10 concurrent connections
-    try testing.htmlRunner("net/websocket.html", .{});
-    try testing.htmlRunner("net/websocket2.html", .{});
-    try testing.htmlRunner("net/websocket3.html", .{});
-}
--- a/src/browser/webapi/net/XMLHttpRequest.zig
+++ b/src/browser/webapi/net/XMLHttpRequest.zig
@@ -22,7 +22,7 @@ const js = @import("../../js/js.zig");

 const log = @import("../../../log.zig");
 const HttpClient = @import("../../HttpClient.zig");
-const http = @import("../../../network/http.zig");
+const net_http = @import("../../../network/http.zig");

 const URL = @import("../../URL.zig");
 const Mime = @import("../../Mime.zig");
@@ -47,7 +47,7 @@ _transfer: ?*HttpClient.Transfer = null,
 _active_request: bool = false,

 _url: [:0]const u8 = "",
-_method: http.Method = .GET,
+_method: net_http.Method = .GET,
 _request_headers: *Headers,
 _request_body: ?[]const u8 = null,

@@ -406,7 +406,7 @@ fn httpStartCallback(transfer: *HttpClient.Transfer) !void {
    self._transfer = transfer;
 }

-fn httpHeaderCallback(transfer: *HttpClient.Transfer, header: http.Header) !void {
+fn httpHeaderCallback(transfer: *HttpClient.Transfer, header: net_http.Header) !void {
    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
    const joined = try std.fmt.allocPrint(self._arena, "{s}: {s}", .{ header.name, header.value });
    try self._response_headers.append(self._arena, joined);
@@ -574,7 +574,7 @@ fn stateChanged(self: *XMLHttpRequest, state: ReadyState, page: *Page) !void {
    }
 }

-fn parseMethod(method: []const u8) !http.Method {
+fn parseMethod(method: []const u8) !net_http.Method {
    if (std.ascii.eqlIgnoreCase(method, "get")) {
        return .GET;
    }
--- a/src/cdp/domains/fetch.zig
+++ b/src/cdp/domains/fetch.zig
@@ -23,7 +23,7 @@ const CDP = @import("../CDP.zig");
 const log = @import("../../log.zig");

 const HttpClient = @import("../../browser/HttpClient.zig");
-const http = @import("../../network/http.zig");
+const net_http = @import("../../network/http.zig");
 const Notification = @import("../../Notification.zig");

 const network = @import("network.zig");
@@ -224,7 +224,7 @@ fn continueRequest(cmd: *CDP.Command) !void {
        url: ?[]const u8 = null,
        method: ?[]const u8 = null,
        postData: ?[]const u8 = null,
-        headers: ?[]const http.Header = null,
+        headers: ?[]const net_http.Header = null,
        interceptResponse: bool = false,
    })) orelse return error.InvalidParams;

@@ -249,7 +249,7 @@ fn continueRequest(cmd: *CDP.Command) !void {
        try transfer.updateURL(try arena.dupeZ(u8, url));
    }
    if (params.method) |method| {
-        transfer.req.method = std.meta.stringToEnum(http.Method, method) orelse return error.InvalidParams;
+        transfer.req.method = std.meta.stringToEnum(net_http.Method, method) orelse return error.InvalidParams;
    }

    if (params.headers) |headers| {
@@ -326,7 +326,7 @@ fn fulfillRequest(cmd: *CDP.Command) !void {
    const params = (try cmd.params(struct {
        requestId: []const u8, // "INT-{d}"
        responseCode: u16,
-        responseHeaders: ?[]const http.Header = null,
+        responseHeaders: ?[]const net_http.Header = null,
        binaryResponseHeaders: ?[]const u8 = null,
        body: ?[]const u8 = null,
        responsePhrase: ?[]const u8 = null,
--- a/src/lightpanda.zig
+++ b/src/lightpanda.zig
@@ -18,7 +18,7 @@

 const std = @import("std");
 pub const App = @import("App.zig");
-pub const Network = @import("network/Network.zig");
+pub const Network = @import("network/Runtime.zig");
 pub const Server = @import("Server.zig");
 pub const Config = @import("Config.zig");
 pub const URL = @import("browser/URL.zig");
--- a/src/main.zig
+++ b/src/main.zig
@@ -144,11 +144,22 @@ fn run(allocator: Allocator, main_arena: Allocator) !void {

            app.network.run();
        },
-        .mcp => {
+        .mcp => |opts| {
            log.info(.mcp, "starting server", .{});

            log.opts.format = .logfmt;

+            var cdp_server: ?*lp.Server = null;
+            if (opts.cdp_port) |port| {
+                const address = std.net.Address.parseIp("127.0.0.1", port) catch |err| {
+                    log.fatal(.mcp, "invalid cdp address", .{ .err = err, .port = port });
+                    return;
+                };
+                cdp_server = try lp.Server.init(app, address);
+                try sighandler.on(lp.Server.shutdown, .{cdp_server.?});
+            }
+            defer if (cdp_server) |s| s.deinit();
+
            var worker_thread = try std.Thread.spawn(.{}, mcpThread, .{ allocator, app });
            defer worker_thread.join();

--- a/src/mcp/tools.zig
+++ b/src/mcp/tools.zig
@@ -9,57 +9,72 @@ const protocol = @import("protocol.zig");
 const Server = @import("Server.zig");
 const CDPNode = @import("../cdp/Node.zig");

+const goto_schema = protocol.minify(
+    \\{
+    \\  "type": "object",
+    \\  "properties": {
+    \\    "url": { "type": "string", "description": "The URL to navigate to, must be a valid URL." },
+    \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
+    \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." }
+    \\  },
+    \\  "required": ["url"]
+    \\}
+);
+
+const url_params_schema = protocol.minify(
+    \\{
+    \\  "type": "object",
+    \\  "properties": {
+    \\    "url": { "type": "string", "description": "Optional URL to navigate to before processing." },
+    \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
+    \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." }
+    \\  }
+    \\}
+);
+
+const evaluate_schema = protocol.minify(
+    \\{
+    \\  "type": "object",
+    \\  "properties": {
+    \\    "script": { "type": "string" },
+    \\    "url": { "type": "string", "description": "Optional URL to navigate to before evaluating." },
+    \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
+    \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." }
+    \\  },
+    \\  "required": ["script"]
+    \\}
+);
+
 pub const tool_list = [_]protocol.Tool{
    .{
        .name = "goto",
        .description = "Navigate to a specified URL and load the page in memory so it can be reused later for info extraction.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "url": { "type": "string", "description": "The URL to navigate to, must be a valid URL." }
-            \\  },
-            \\  "required": ["url"]
-            \\}
-        ),
+        .inputSchema = goto_schema,
+    },
+    .{
+        .name = "navigate",
+        .description = "Alias for goto. Navigate to a specified URL and load the page in memory.",
+        .inputSchema = goto_schema,
    },
    .{
        .name = "markdown",
        .description = "Get the page content in markdown format. If a url is provided, it navigates to that url first.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "url": { "type": "string", "description": "Optional URL to navigate to before fetching markdown." }
-            \\  }
-            \\}
-        ),
+        .inputSchema = url_params_schema,
    },
    .{
        .name = "links",
        .description = "Extract all links in the opened page. If a url is provided, it navigates to that url first.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "url": { "type": "string", "description": "Optional URL to navigate to before extracting links." }
-            \\  }
-            \\}
-        ),
+        .inputSchema = url_params_schema,
    },
    .{
        .name = "evaluate",
        .description = "Evaluate JavaScript in the current page context. If a url is provided, it navigates to that url first.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "script": { "type": "string" },
-            \\    "url": { "type": "string", "description": "Optional URL to navigate to before evaluating." }
-            \\  },
-            \\  "required": ["script"]
-            \\}
-        ),
+        .inputSchema = evaluate_schema,
+    },
+    .{
+        .name = "eval",
+        .description = "Alias for evaluate. Evaluate JavaScript in the current page context.",
+        .inputSchema = evaluate_schema,
    },
    .{
        .name = "semantic_tree",
@@ -69,6 +84,8 @@ pub const tool_list = [_]protocol.Tool{
            \\  "type": "object",
            \\  "properties": {
            \\    "url": { "type": "string", "description": "Optional URL to navigate to before fetching the semantic tree." },
+            \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
+            \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." },
            \\    "backendNodeId": { "type": "integer", "description": "Optional backend node ID to get the tree for a specific element instead of the document root." },
            \\    "maxDepth": { "type": "integer", "description": "Optional maximum depth of the tree to return. Useful for exploring high-level structure first." }
            \\  }
@@ -91,38 +108,17 @@ pub const tool_list = [_]protocol.Tool{
    .{
        .name = "interactiveElements",
        .description = "Extract interactive elements from the opened page. If a url is provided, it navigates to that url first.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "url": { "type": "string", "description": "Optional URL to navigate to before extracting interactive elements." }
-            \\  }
-            \\}
-        ),
+        .inputSchema = url_params_schema,
    },
    .{
        .name = "structuredData",
        .description = "Extract structured data (like JSON-LD, OpenGraph, etc) from the opened page. If a url is provided, it navigates to that url first.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "url": { "type": "string", "description": "Optional URL to navigate to before extracting structured data." }
-            \\  }
-            \\}
-        ),
+        .inputSchema = url_params_schema,
    },
    .{
        .name = "detectForms",
        .description = "Detect all forms on the page and return their structure including fields, types, and required status. If a url is provided, it navigates to that url first.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "url": { "type": "string", "description": "Optional URL to navigate to before detecting forms." }
-            \\  }
-            \\}
-        ),
+        .inputSchema = url_params_schema,
    },
    .{
        .name = "click",
@@ -189,15 +185,21 @@ pub fn handleList(server: *Server, arena: std.mem.Allocator, req: protocol.Reque

 const GotoParams = struct {
    url: [:0]const u8,
+    timeout: ?u32 = null,
+    waitUntil: ?lp.Config.WaitUntil = null,
 };

 const UrlParams = struct {
    url: ?[:0]const u8 = null,
+    timeout: ?u32 = null,
+    waitUntil: ?lp.Config.WaitUntil = null,
 };

 const EvaluateParams = struct {
    script: [:0]const u8,
    url: ?[:0]const u8 = null,
+    timeout: ?u32 = null,
+    waitUntil: ?lp.Config.WaitUntil = null,
 };

 const ToolStreamingText = struct {
@@ -274,6 +276,7 @@ const ToolAction = enum {
    structuredData,
    detectForms,
    evaluate,
+    eval,
    semantic_tree,
    click,
    fill,
@@ -291,6 +294,7 @@ const tool_map = std.StaticStringMap(ToolAction).initComptime(.{
    .{ "structuredData", .structuredData },
    .{ "detectForms", .detectForms },
    .{ "evaluate", .evaluate },
+    .{ "eval", .eval },
    .{ "semantic_tree", .semantic_tree },
    .{ "click", .click },
    .{ "fill", .fill },
@@ -324,7 +328,7 @@ pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Reque
        .interactiveElements => try handleInteractiveElements(server, arena, req.id.?, call_params.arguments),
        .structuredData => try handleStructuredData(server, arena, req.id.?, call_params.arguments),
        .detectForms => try handleDetectForms(server, arena, req.id.?, call_params.arguments),
-        .evaluate => try handleEvaluate(server, arena, req.id.?, call_params.arguments),
+        .eval, .evaluate => try handleEvaluate(server, arena, req.id.?, call_params.arguments),
        .semantic_tree => try handleSemanticTree(server, arena, req.id.?, call_params.arguments),
        .click => try handleClick(server, arena, req.id.?, call_params.arguments),
        .fill => try handleFill(server, arena, req.id.?, call_params.arguments),
@@ -335,7 +339,7 @@ pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Reque

 fn handleGoto(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgs(GotoParams, arena, arguments, server, id, "goto");
-    try performGoto(server, args.url, id);
+    try performGoto(server, args.url, id, args.timeout, args.waitUntil);

    const content = [_]protocol.TextContent([]const u8){.{ .text = "Navigated successfully." }};
    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
@@ -343,7 +347,7 @@ fn handleGoto(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arg

 fn handleMarkdown(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    const content = [_]protocol.TextContent(ToolStreamingText){.{
        .text = .{ .page = page, .action = .markdown },
@@ -355,7 +359,7 @@ fn handleMarkdown(server: *Server, arena: std.mem.Allocator, id: std.json.Value,

 fn handleLinks(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    const content = [_]protocol.TextContent(ToolStreamingText){.{
        .text = .{ .page = page, .action = .links },
@@ -370,9 +374,11 @@ fn handleSemanticTree(server: *Server, arena: std.mem.Allocator, id: std.json.Va
        url: ?[:0]const u8 = null,
        backendNodeId: ?u32 = null,
        maxDepth: ?u32 = null,
+        timeout: ?u32 = null,
+        waitUntil: ?lp.Config.WaitUntil = null,
    };
    const args = try parseArgsOrDefault(TreeParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    const content = [_]protocol.TextContent(ToolStreamingText){.{
        .text = .{
@@ -417,7 +423,7 @@ fn handleNodeDetails(server: *Server, arena: std.mem.Allocator, id: std.json.Val

 fn handleInteractiveElements(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    const elements = lp.interactive.collectInteractiveElements(page.document.asNode(), arena, page) catch |err| {
        log.err(.mcp, "elements collection failed", .{ .err = err });
@@ -438,7 +444,7 @@ fn handleInteractiveElements(server: *Server, arena: std.mem.Allocator, id: std.

 fn handleStructuredData(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    const data = lp.structured_data.collectStructuredData(page.document.asNode(), arena, page) catch |err| {
        log.err(.mcp, "struct data collection failed", .{ .err = err });
@@ -453,7 +459,7 @@ fn handleStructuredData(server: *Server, arena: std.mem.Allocator, id: std.json.

 fn handleDetectForms(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    const forms_data = lp.forms.collectForms(arena, page.document.asNode(), page) catch |err| {
        log.err(.mcp, "form collection failed", .{ .err = err });
@@ -474,7 +480,7 @@ fn handleDetectForms(server: *Server, arena: std.mem.Allocator, id: std.json.Val

 fn handleEvaluate(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
    const args = try parseArgs(EvaluateParams, arena, arguments, server, id, "evaluate");
-    const page = try ensurePage(server, id, args.url);
+    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);

    var ls: js.Local.Scope = undefined;
    page.js.localScope(&ls);
@@ -630,9 +636,9 @@ fn handleWaitForSelector(server: *Server, arena: std.mem.Allocator, id: std.json
    return server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
 }

-fn ensurePage(server: *Server, id: std.json.Value, url: ?[:0]const u8) !*lp.Page {
+fn ensurePage(server: *Server, id: std.json.Value, url: ?[:0]const u8, timeout: ?u32, waitUntil: ?lp.Config.WaitUntil) !*lp.Page {
    if (url) |u| {
-        try performGoto(server, u, id);
+        try performGoto(server, u, id, timeout, waitUntil);
    }
    return server.session.currentPage() orelse {
        try server.sendError(id, .PageNotLoaded, "Page not loaded");
@@ -668,7 +674,7 @@ fn parseArgs(comptime T: type, arena: std.mem.Allocator, arguments: ?std.json.Va
    };
 }

-fn performGoto(server: *Server, url: [:0]const u8, id: std.json.Value) !void {
+fn performGoto(server: *Server, url: [:0]const u8, id: std.json.Value, timeout: ?u32, waitUntil: ?lp.Config.WaitUntil) !void {
    const session = server.session;
    if (session.page != null) {
        session.removePage();
@@ -689,7 +695,10 @@ fn performGoto(server: *Server, url: [:0]const u8, id: std.json.Value) !void {
        try server.sendError(id, .InternalError, "Failed to start page runner");
        return error.NavigationFailed;
    };
-    runner.wait(.{ .ms = 2000 }) catch {
+    runner.wait(.{
+        .ms = timeout orelse 10000,
+        .until = waitUntil orelse .done,
+    }) catch {
        try server.sendError(id, .InternalError, "Timeout waiting for page load");
        return error.NavigationFailed;
    };
--- a/src/network/Runtime.zig
+++ b/src/network/Runtime.zig
@@ -26,11 +26,11 @@ const lp = @import("lightpanda");
 const Config = @import("../Config.zig");
 const libcurl = @import("../sys/libcurl.zig");

-const http = @import("http.zig");
+const net_http = @import("http.zig");
 const RobotStore = @import("Robots.zig").RobotStore;
 const WebBotAuth = @import("WebBotAuth.zig");

-const Network = @This();
+const Runtime = @This();

 const Listener = struct {
    socket: posix.socket_t,
@@ -46,11 +46,11 @@ const MAX_TICK_CALLBACKS = 16;
 allocator: Allocator,

 config: *const Config,
-ca_blob: ?http.Blob,
+ca_blob: ?net_http.Blob,
 robot_store: RobotStore,
 web_bot_auth: ?WebBotAuth,

-connections: []http.Connection,
+connections: []net_http.Connection,
 available: std.DoublyLinkedList = .{},
 conn_mutex: std.Thread.Mutex = .{},

@@ -63,8 +63,8 @@ wakeup_pipe: [2]posix.fd_t = .{ -1, -1 },
 shutdown: std.atomic.Value(bool) = .init(false),

 // Multi is a heavy structure that can consume up to 2MB of RAM.
-// Currently, Network is used sparingly, and we only create it on demand.
-// When Network becomes truly shared, it should become a regular field.
+// Currently, Runtime is used sparingly, and we only create it on demand.
+// When Runtime becomes truly shared, it should become a regular field.
 multi: ?*libcurl.CurlM = null,
 submission_mutex: std.Thread.Mutex = .{},
 submission_queue: std.DoublyLinkedList = .{},
@@ -200,7 +200,7 @@ fn globalDeinit() void {
    libcurl.curl_global_cleanup();
 }

-pub fn init(allocator: Allocator, config: *const Config) !Network {
+pub fn init(allocator: Allocator, config: *const Config) !Runtime {
    globalInit(allocator);
    errdefer globalDeinit();

@@ -213,18 +213,18 @@ pub fn init(allocator: Allocator, config: *const Config) !Network {
    @memset(pollfds, .{ .fd = -1, .events = 0, .revents = 0 });
    pollfds[0] = .{ .fd = pipe[0], .events = posix.POLL.IN, .revents = 0 };

-    var ca_blob: ?http.Blob = null;
+    var ca_blob: ?net_http.Blob = null;
    if (config.tlsVerifyHost()) {
        ca_blob = try loadCerts(allocator);
    }

    const count: usize = config.httpMaxConcurrent();
-    const connections = try allocator.alloc(http.Connection, count);
+    const connections = try allocator.alloc(net_http.Connection, count);
    errdefer allocator.free(connections);

    var available: std.DoublyLinkedList = .{};
    for (0..count) |i| {
-        connections[i] = try http.Connection.init(ca_blob, config);
+        connections[i] = try net_http.Connection.init(ca_blob, config);
        available.append(&connections[i].node);
    }

@@ -249,7 +249,7 @@ pub fn init(allocator: Allocator, config: *const Config) !Network {
    };
 }

-pub fn deinit(self: *Network) void {
+pub fn deinit(self: *Runtime) void {
    if (self.multi) |multi| {
        libcurl.curl_multi_cleanup(multi) catch {};
    }
@@ -282,7 +282,7 @@ pub fn deinit(self: *Network) void {
 }

 pub fn bind(
-    self: *Network,
+    self: *Runtime,
    address: net.Address,
    ctx: *anyopaque,
    on_accept: *const fn (ctx: *anyopaque, socket: posix.socket_t) void,
@@ -313,7 +313,7 @@ pub fn bind(
    };
 }

-pub fn onTick(self: *Network, ctx: *anyopaque, callback: *const fn (*anyopaque) void) void {
+pub fn onTick(self: *Runtime, ctx: *anyopaque, callback: *const fn (*anyopaque) void) void {
    self.callbacks_mutex.lock();
    defer self.callbacks_mutex.unlock();

@@ -328,7 +328,7 @@ pub fn onTick(self: *Network, ctx: *anyopaque, callback: *const fn (*anyopaque)
    self.wakeupPoll();
 }

-pub fn fireTicks(self: *Network) void {
+pub fn fireTicks(self: *Runtime) void {
    self.callbacks_mutex.lock();
    defer self.callbacks_mutex.unlock();

@@ -337,7 +337,7 @@ pub fn fireTicks(self: *Network) void {
    }
 }

-pub fn run(self: *Network) void {
+pub fn run(self: *Runtime) void {
    var drain_buf: [64]u8 = undefined;
    var running_handles: c_int = 0;

@@ -428,18 +428,18 @@ pub fn run(self: *Network) void {
    }
 }

-pub fn submitRequest(self: *Network, conn: *http.Connection) void {
+pub fn submitRequest(self: *Runtime, conn: *net_http.Connection) void {
    self.submission_mutex.lock();
    self.submission_queue.append(&conn.node);
    self.submission_mutex.unlock();
    self.wakeupPoll();
 }

-fn wakeupPoll(self: *Network) void {
+fn wakeupPoll(self: *Runtime) void {
    _ = posix.write(self.wakeup_pipe[1], &.{1}) catch {};
 }

-fn drainQueue(self: *Network) void {
+fn drainQueue(self: *Runtime) void {
    self.submission_mutex.lock();
    defer self.submission_mutex.unlock();

@@ -455,7 +455,7 @@ fn drainQueue(self: *Network) void {
    };

    while (self.submission_queue.popFirst()) |node| {
-        const conn: *http.Connection = @fieldParentPtr("node", node);
+        const conn: *net_http.Connection = @fieldParentPtr("node", node);
        conn.setPrivate(conn) catch |err| {
            lp.log.err(.app, "curl set private", .{ .err = err });
            self.releaseConnection(conn);
@@ -468,12 +468,12 @@ fn drainQueue(self: *Network) void {
    }
 }

-pub fn stop(self: *Network) void {
+pub fn stop(self: *Runtime) void {
    self.shutdown.store(true, .release);
    self.wakeupPoll();
 }

-fn acceptConnections(self: *Network) void {
+fn acceptConnections(self: *Runtime) void {
    if (self.shutdown.load(.acquire)) {
        return;
    }
@@ -503,7 +503,7 @@ fn acceptConnections(self: *Network) void {
    }
 }

-fn preparePollFds(self: *Network, multi: *libcurl.CurlM) void {
+fn preparePollFds(self: *Runtime, multi: *libcurl.CurlM) void {
    const curl_fds = self.pollfds[PSEUDO_POLLFDS..];
    @memset(curl_fds, .{ .fd = -1, .events = 0, .revents = 0 });

@@ -514,14 +514,14 @@ fn preparePollFds(self: *Network, multi: *libcurl.CurlM) void {
    };
 }

-fn getCurlTimeout(self: *Network) i32 {
+fn getCurlTimeout(self: *Runtime) i32 {
    const multi = self.multi orelse return -1;
    var timeout_ms: c_long = -1;
    libcurl.curl_multi_timeout(multi, &timeout_ms) catch return -1;
    return @intCast(@min(timeout_ms, std.math.maxInt(i32)));
 }

-fn processCompletions(self: *Network, multi: *libcurl.CurlM) void {
+fn processCompletions(self: *Runtime, multi: *libcurl.CurlM) void {
    var msgs_in_queue: c_int = 0;
    while (libcurl.curl_multi_info_read(multi, &msgs_in_queue)) |msg| {
        switch (msg.data) {
@@ -537,7 +537,7 @@ fn processCompletions(self: *Network, multi: *libcurl.CurlM) void {
        var ptr: *anyopaque = undefined;
        libcurl.curl_easy_getinfo(easy, .private, &ptr) catch
            lp.assert(false, "curl getinfo private", .{});
-        const conn: *http.Connection = @ptrCast(@alignCast(ptr));
+        const conn: *net_http.Connection = @ptrCast(@alignCast(ptr));

        libcurl.curl_multi_remove_handle(multi, easy) catch {};
        self.releaseConnection(conn);
@@ -556,7 +556,7 @@ comptime {
    }
 }

-pub fn getConnection(self: *Network) ?*http.Connection {
+pub fn getConnection(self: *Runtime) ?*net_http.Connection {
    self.conn_mutex.lock();
    defer self.conn_mutex.unlock();

@@ -564,7 +564,7 @@ pub fn getConnection(self: *Network) ?*http.Connection {
    return @fieldParentPtr("node", node);
 }

-pub fn releaseConnection(self: *Network, conn: *http.Connection) void {
+pub fn releaseConnection(self: *Runtime, conn: *net_http.Connection) void {
    conn.reset(self.config, self.ca_blob) catch |err| {
        lp.assert(false, "couldn't reset curl easy", .{ .err = err });
    };
@@ -575,8 +575,8 @@ pub fn releaseConnection(self: *Network, conn: *http.Connection) void {
    self.available.append(&conn.node);
 }

-pub fn newConnection(self: *Network) !http.Connection {
-    return http.Connection.init(self.ca_blob, self.config);
+pub fn newConnection(self: *Runtime) !net_http.Connection {
+    return net_http.Connection.init(self.ca_blob, self.config);
 }

 // Wraps lines @ 64 columns. A PEM is basically a base64 encoded DER (which is
--- a/src/network/http.zig
+++ b/src/network/http.zig
@@ -28,9 +28,7 @@ pub const ENABLE_DEBUG = false;

 pub const Blob = libcurl.CurlBlob;
 pub const WaitFd = libcurl.CurlWaitFd;
-pub const readfunc_pause = libcurl.curl_readfunc_pause;
 pub const writefunc_error = libcurl.curl_writefunc_error;
-pub const WsFrameType = libcurl.WsFrameType;

 const Error = libcurl.Error;

@@ -213,19 +211,15 @@ pub const ResponseHead = struct {

 pub const Connection = struct {
    _easy: *libcurl.Curl,
-    transport: Transport,
    node: std.DoublyLinkedList.Node = .{},

-    pub const Transport = union(enum) {
-        none, // used for cases that manage their own connection, e.g. telemetry
-        http: *@import("../browser/HttpClient.zig").Transfer,
-        websocket: *@import("../browser/webapi/net/WebSocket.zig"),
-    };
-
-    pub fn init(ca_blob: ?libcurl.CurlBlob, config: *const Config) !Connection {
+    pub fn init(
+        ca_blob: ?libcurl.CurlBlob,
+        config: *const Config,
+    ) !Connection {
        const easy = libcurl.curl_easy_init() orelse return error.FailedToInitializeEasy;

-        var self = Connection{ ._easy = easy, .transport = .none };
+        const self = Connection{ ._easy = easy };
        errdefer self.deinit();

        try self.reset(config, ca_blob);
@@ -305,12 +299,7 @@ pub const Connection = struct {
        try libcurl.curl_easy_setopt(self._easy, .user_pwd, creds.ptr);
    }

-    pub fn setConnectOnly(self: *const Connection, connect_only: bool) !void {
-        const value: c_long = if (connect_only) 2 else 0;
-        try libcurl.curl_easy_setopt(self._easy, .connect_only, value);
-    }
-
-    pub fn setWriteCallback(
+    pub fn setCallbacks(
        self: *Connection,
        comptime data_cb: libcurl.CurlWriteFunction,
    ) !void {
@@ -318,49 +307,12 @@ pub const Connection = struct {
        try libcurl.curl_easy_setopt(self._easy, .write_function, data_cb);
    }

-    pub fn setReadCallback(
-        self: *Connection,
-        comptime data_cb: libcurl.CurlReadFunction,
-        upload: bool,
-    ) !void {
-        try libcurl.curl_easy_setopt(self._easy, .read_data, self);
-        try libcurl.curl_easy_setopt(self._easy, .read_function, data_cb);
-        if (upload) {
-            try libcurl.curl_easy_setopt(self._easy, .upload, true);
-        }
-    }
-
-    pub fn setHeaderCallback(
-        self: *Connection,
-        comptime data_cb: libcurl.CurlHeaderFunction,
-    ) !void {
-        try libcurl.curl_easy_setopt(self._easy, .header_data, self);
-        try libcurl.curl_easy_setopt(self._easy, .header_function, data_cb);
-    }
-
-    pub const PauseFlags = packed struct {
-        red: bool = false,
-        green: bool = false,
-        blue: bool = false,
-        alpha: bool = false,
-        // Optional padding to match a specific size, e.g., a u32
-        _padding: u28 = 0,
-    };
-
-    pub fn pause(
-        self: *Connection,
-        flags: libcurl.CurlPauseFlags,
-    ) !void {
-        try libcurl.curl_easy_pause(self._easy, flags);
-    }
-
    pub fn reset(
-        self: *Connection,
+        self: *const Connection,
        config: *const Config,
        ca_blob: ?libcurl.CurlBlob,
    ) !void {
        libcurl.curl_easy_reset(self._easy);
-        self.transport = .none;

        // timeouts
        try libcurl.curl_easy_setopt(self._easy, .timeout_ms, config.httpTimeout());
@@ -497,6 +449,12 @@ pub const Connection = struct {
        };
    }

+    pub fn getPrivate(self: *const Connection) !*anyopaque {
+        var private: *anyopaque = undefined;
+        try libcurl.curl_easy_getinfo(self._easy, .private, &private);
+        return private;
+    }
+
    // These are headers that may not be send to the users for inteception.
    pub fn secretHeaders(_: *const Connection, headers: *Headers, http_headers: *const Config.HttpHeaders) !void {
        if (http_headers.proxy_bearer_header) |hdr| {
@@ -513,14 +471,6 @@ pub const Connection = struct {
        try libcurl.curl_easy_perform(self._easy);
        return self.getResponseCode();
    }
-
-    pub fn wsStartFrame(self: *const Connection, frame_type: libcurl.WsFrameType, size: usize) !void {
-        try libcurl.curl_ws_start_frame(self._easy, frame_type, @intCast(size));
-    }
-
-    pub fn wsMeta(self: *const Connection) ?libcurl.WsFrameMeta {
-        return libcurl.curl_ws_meta(self._easy);
-    }
 };

 pub const Handles = struct {
@@ -558,21 +508,17 @@ pub const Handles = struct {
    }

    pub const MultiMessage = struct {
-        conn: *Connection,
+        conn: Connection,
        err: ?Error,
    };

-    pub fn readMessage(self: *Handles) !?MultiMessage {
+    pub fn readMessage(self: *Handles) ?MultiMessage {
        var messages_count: c_int = 0;
        const msg = libcurl.curl_multi_info_read(self.multi, &messages_count) orelse return null;
        return switch (msg.data) {
-            .done => |err| {
-                var private: *anyopaque = undefined;
-                try libcurl.curl_easy_getinfo(msg.easy_handle, .private, &private);
-                return .{
-                    .conn = @ptrCast(@alignCast(private)),
-                    .err = err,
-                };
+            .done => |err| .{
+                .conn = .{ ._easy = msg.easy_handle },
+                .err = err,
            },
            else => unreachable,
        };
--- a/src/sys/libcurl.zig
+++ b/src/sys/libcurl.zig
@@ -40,8 +40,6 @@ pub const CurlDebugFunction = fn (*Curl, CurlInfoType, [*c]u8, usize, *anyopaque
 pub const CurlHeaderFunction = fn ([*]const u8, usize, usize, *anyopaque) usize;
 pub const CurlWriteFunction = fn ([*]const u8, usize, usize, *anyopaque) usize;
 pub const curl_writefunc_error: usize = c.CURL_WRITEFUNC_ERROR;
-pub const curl_readfunc_pause: usize = c.CURL_READFUNC_PAUSE;
-pub const CurlReadFunction = fn ([*]u8, usize, usize, *anyopaque) usize;

 pub const FreeCallback = fn (ptr: ?*anyopaque) void;
 pub const StrdupCallback = fn (str: [*:0]const u8) ?[*:0]u8;
@@ -100,23 +98,6 @@ pub const CurlWaitFd = extern struct {
    revents: CurlWaitEvents,
 };

-pub const CurlPauseFlags = packed struct(c_short) {
-    recv: bool = false,
-    send: bool = false,
-    all: bool = false,
-    cont: bool = false,
-    _reserved: u12 = 0,
-
-    pub fn to_c(self: @This()) c_int {
-        var flags: c_int = 0;
-        if (self.recv) flags |= c.CURLPAUSE_RECV;
-        if (self.send) flags |= c.CURLPAUSE_SEND;
-        if (self.all) flags |= c.CURLPAUSE_ALL;
-        if (self.cont) flags |= c.CURLPAUSE_CONT;
-        return flags;
-    }
-};
-
 comptime {
    const debug_cb_check: c.curl_debug_callback = struct {
        fn cb(handle: ?*Curl, msg_type: c.curl_infotype, raw: [*c]u8, len: usize, user: ?*anyopaque) callconv(.c) c_int {
@@ -186,10 +167,6 @@ pub const CurlOption = enum(c.CURLoption) {
    header_function = c.CURLOPT_HEADERFUNCTION,
    write_data = c.CURLOPT_WRITEDATA,
    write_function = c.CURLOPT_WRITEFUNCTION,
-    read_data = c.CURLOPT_READDATA,
-    read_function = c.CURLOPT_READFUNCTION,
-    connect_only = c.CURLOPT_CONNECT_ONLY,
-    upload = c.CURLOPT_UPLOAD,
 };

 pub const CurlMOption = enum(c.CURLMoption) {
@@ -553,7 +530,6 @@ pub fn curl_easy_setopt(easy: *Curl, comptime option: CurlOption, value: anytype
    const code = switch (option) {
        .verbose,
        .post,
-        .upload,
        .http_get,
        .ssl_verify_host,
        .ssl_verify_peer,
@@ -575,7 +551,6 @@ pub fn curl_easy_setopt(easy: *Curl, comptime option: CurlOption, value: anytype
        .max_redirs,
        .follow_location,
        .post_field_size,
-        .connect_only,
        => blk: {
            const n: c_long = switch (@typeInfo(@TypeOf(value))) {
                .comptime_int, .int => @intCast(value),
@@ -618,7 +593,6 @@ pub fn curl_easy_setopt(easy: *Curl, comptime option: CurlOption, value: anytype

        .private,
        .header_data,
-        .read_data,
        .write_data,
        => blk: {
            const ptr: ?*anyopaque = switch (@typeInfo(@TypeOf(value))) {
@@ -657,22 +631,6 @@ pub fn curl_easy_setopt(easy: *Curl, comptime option: CurlOption, value: anytype
            break :blk c.curl_easy_setopt(easy, opt, cb);
        },

-        .read_function => blk: {
-            const cb: c.curl_write_callback = switch (@typeInfo(@TypeOf(value))) {
-                .null => null,
-                .@"fn" => |info| struct {
-                    fn cb(buffer: [*c]u8, count: usize, len: usize, user: ?*anyopaque) callconv(.c) usize {
-                        const user_arg = if (@typeInfo(info.params[3].type.?) == .optional)
-                            user
-                        else
-                            user orelse unreachable;
-                        return value(@ptrCast(buffer), count, len, user_arg);
-                    }
-                }.cb,
-                else => @compileError("expected Zig function or null for " ++ @tagName(option) ++ ", got " ++ @typeName(@TypeOf(value))),
-            };
-            break :blk c.curl_easy_setopt(easy, opt, cb);
-        },
        .write_function => blk: {
            const cb: c.curl_write_callback = switch (@typeInfo(@TypeOf(value))) {
                .null => null,
@@ -719,10 +677,6 @@ pub fn curl_easy_getinfo(easy: *Curl, comptime info: CurlInfo, out: anytype) Err
    try errorCheck(code);
 }

-pub fn curl_easy_pause(easy: *Curl, flags: CurlPauseFlags) Error!void {
-    try errorCheck(c.curl_easy_pause(easy, flags.to_c()));
-}
-
 pub fn curl_easy_header(
    easy: *Curl,
    name: [*:0]const u8,
@@ -850,79 +804,3 @@ pub fn curl_slist_free_all(list: ?*CurlSList) void {
        c.curl_slist_free_all(ptr);
    }
 }
-
-// WebSocket support (requires libcurl 7.86.0+)
-pub const WsFrameType = enum {
-    text,
-    binary,
-    cont,
-    close,
-    ping,
-    pong,
-
-    fn toInt(self: WsFrameType) c_uint {
-        return switch (self) {
-            .text => c.CURLWS_TEXT,
-            .binary => c.CURLWS_BINARY,
-            .cont => c.CURLWS_CONT,
-            .close => c.CURLWS_CLOSE,
-            .ping => c.CURLWS_PING,
-            .pong => c.CURLWS_PONG,
-        };
-    }
-
-    fn fromFlags(flags: c_int) WsFrameType {
-        const f: c_uint = @bitCast(flags);
-        if (f & c.CURLWS_TEXT != 0) return .text;
-        if (f & c.CURLWS_BINARY != 0) return .binary;
-        if (f & c.CURLWS_CLOSE != 0) return .close;
-        if (f & c.CURLWS_PING != 0) return .ping;
-        if (f & c.CURLWS_PONG != 0) return .pong;
-        if (f & c.CURLWS_CONT != 0) return .cont;
-        return .binary; // default fallback
-    }
-};
-
-pub const WsFrameMeta = struct {
-    frame_type: WsFrameType,
-    offset: usize,
-    bytes_left: usize,
-    len: usize,
-
-    fn from(frame: *const c.curl_ws_frame) WsFrameMeta {
-        return .{
-            .frame_type = WsFrameType.fromFlags(frame.flags),
-            .offset = @intCast(frame.offset),
-            .bytes_left = @intCast(frame.bytesleft),
-            .len = if (frame.len < 0)
-                std.math.maxInt(usize)
-            else
-                @intCast(frame.len),
-        };
-    }
-};
-
-pub fn curl_ws_send(easy: *Curl, buffer: []const u8, sent: *usize, fragsize: CurlOffT, frame_type: WsFrameType) Error!void {
-    try errorCheck(c.curl_ws_send(easy, buffer.ptr, buffer.len, sent, fragsize, frame_type.toInt()));
-}
-
-pub fn curl_ws_recv(easy: *Curl, buffer: []u8, recv: *usize, meta: *?WsFrameMeta) Error!void {
-    var c_meta: [*c]const c.curl_ws_frame = null;
-    const code = c.curl_ws_recv(easy, buffer.ptr, buffer.len, recv, &c_meta);
-    if (c_meta) |m| {
-        meta.* = WsFrameMeta.from(m);
-    } else {
-        meta.* = null;
-    }
-    try errorCheck(code);
-}
-
-pub fn curl_ws_meta(easy: *Curl) ?WsFrameMeta {
-    const ptr = c.curl_ws_meta(easy);
-    if (ptr == null) return null;
-    return WsFrameMeta.from(ptr);
-}
-
-pub fn curl_ws_start_frame(easy: *Curl, frame_type: WsFrameType, size: CurlOffT) Error!void {
-    try errorCheck(c.curl_ws_start_frame(easy, frame_type.toInt(), size));
-}
--- a/src/telemetry/lightpanda.zig
+++ b/src/telemetry/lightpanda.zig
@@ -8,7 +8,7 @@ const log = @import("../log.zig");
 const App = @import("../App.zig");
 const Config = @import("../Config.zig");
 const telemetry = @import("telemetry.zig");
-const Network = @import("../network/Network.zig");
+const Runtime = @import("../network/Runtime.zig");

 const URL = "https://telemetry.lightpanda.io";
 const BUFFER_SIZE = 1024;
@@ -17,7 +17,7 @@ const MAX_BODY_SIZE = 500 * 1024; // 500KB server limit
 const LightPanda = @This();

 allocator: Allocator,
-network: *Network,
+runtime: *Runtime,
 writer: std.Io.Writer.Allocating,

 /// Protects concurrent producers in send().
@@ -36,11 +36,11 @@ pub fn init(self: *LightPanda, app: *App, iid: ?[36]u8, run_mode: Config.RunMode
        .iid = iid,
        .run_mode = run_mode,
        .allocator = app.allocator,
-        .network = &app.network,
+        .runtime = &app.network,
        .writer = std.Io.Writer.Allocating.init(app.allocator),
    };

-    self.network.onTick(@ptrCast(self), flushCallback);
+    self.runtime.onTick(@ptrCast(self), flushCallback);
 }

 pub fn deinit(self: *LightPanda) void {
@@ -70,17 +70,17 @@ fn flushCallback(ctx: *anyopaque) void {
 }

 fn postEvent(self: *LightPanda) !void {
-    const conn = self.network.getConnection() orelse {
+    const conn = self.runtime.getConnection() orelse {
        return;
    };
-    errdefer self.network.releaseConnection(conn);
+    errdefer self.runtime.releaseConnection(conn);

    const h = self.head.load(.monotonic);
    const t = self.tail.load(.acquire);
    const dropped = self.dropped.swap(0, .monotonic);

    if (h == t and dropped == 0) {
-        self.network.releaseConnection(conn);
+        self.runtime.releaseConnection(conn);
        return;
    }
    errdefer _ = self.dropped.fetchAdd(dropped, .monotonic);
@@ -104,7 +104,7 @@ fn postEvent(self: *LightPanda) !void {
    try conn.setBody(self.writer.written());

    self.head.store(h + sent, .release);
-    self.network.submitRequest(conn);
+    self.runtime.submitRequest(conn);
 }

 fn writeEvent(self: *LightPanda, event: telemetry.Event) !bool {
--- a/src/testing.zig
+++ b/src/testing.zig
@@ -436,17 +436,19 @@ fn runWebApiTest(test_file: [:0]const u8) !void {
        if (js_val.isTrue()) {
            return;
        }
-        const sleep_ms: usize = switch (try runner.tick(.{ .ms = 20 })) {
-            .done => 20,
-            .ok => |next_ms| @min(next_ms, 20),
-        };
-
-        const ms_elapsed = timer.lap() / 1_000_000;
-        if (ms_elapsed >= wait_ms) {
-            return error.TestTimedOut;
+        switch (try runner.tick(.{ .ms = 20 })) {
+            .done => return error.TestNeverSignaledCompletion,
+            .ok => |next_ms| {
+                const ms_elapsed = timer.lap() / 1_000_000;
+                if (ms_elapsed >= wait_ms) {
+                    return error.TestTimedOut;
+                }
+                wait_ms -= @intCast(ms_elapsed);
+                if (next_ms > 0) {
+                    std.Thread.sleep(std.time.ns_per_ms * next_ms);
+                }
+            },
        }
-        wait_ms -= @intCast(ms_elapsed);
-        std.Thread.sleep(std.time.ns_per_ms * sleep_ms);
    }
 }

@@ -474,15 +476,12 @@ pub fn pageTest(comptime test_file: []const u8, opts: PageTestOpts) !*Page {

 const log = @import("log.zig");
 const TestHTTPServer = @import("TestHTTPServer.zig");
-const TestWSServer = @import("TestWSServer.zig");

 const Server = @import("Server.zig");
 var test_cdp_server: ?*Server = null;
 var test_cdp_server_thread: ?std.Thread = null;
 var test_http_server: ?TestHTTPServer = null;
 var test_http_server_thread: ?std.Thread = null;
-var test_ws_server: ?TestWSServer = null;
-var test_ws_server_thread: ?std.Thread = null;

 var test_config: Config = undefined;

@@ -515,16 +514,13 @@ test "tests:beforeAll" {
    test_session = try test_browser.newSession(test_notification);

    var wg: std.Thread.WaitGroup = .{};
-    wg.startMany(3);
+    wg.startMany(2);

    test_cdp_server_thread = try std.Thread.spawn(.{}, serveCDP, .{&wg});

    test_http_server = TestHTTPServer.init(testHTTPHandler);
    test_http_server_thread = try std.Thread.spawn(.{}, TestHTTPServer.run, .{ &test_http_server.?, &wg });

-    test_ws_server = TestWSServer.init();
-    test_ws_server_thread = try std.Thread.spawn(.{}, TestWSServer.run, .{ &test_ws_server.?, &wg });
-
    // need to wait for the servers to be listening, else tests will fail because
    // they aren't able to connect.
    wg.wait();
@@ -549,16 +545,6 @@ test "tests:afterAll" {
        server.deinit();
    }

-    if (test_ws_server) |*server| {
-        server.stop();
-    }
-    if (test_ws_server_thread) |thread| {
-        thread.join();
-    }
-    if (test_ws_server) |*server| {
-        server.deinit();
-    }
-
    @import("root").v8_peak_memory = test_browser.env.isolate.getHeapStatistics().total_physical_size;

    test_notification.deinit();