Merge pull request #2068 from lightpanda-io/refactor/markdown-anchor-rendering

markdown: simplify and optimize anchor rendering
2026-04-02 10:19:17 +00:00 · 2026-04-02 17:06:26 +08:00 · 2026-04-02 09:11:26 +02:00 · 2026-04-02 07:50:31 +08:00 · 2026-04-01 22:15:56 +02:00 · 2026-04-01 21:05:04 +08:00
23 changed files with 509 additions and 660 deletions
--- a/.github/workflows/e2e-integration-test.yml
+++ b/.github/workflows/e2e-integration-test.yml
@@ -60,7 +60,20 @@ 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
+          go run integration/main.go |tee result.log
          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,3 +153,34 @@ 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
@@ -46,8 +46,12 @@ pub fn build(b: *Build) !void {
    var stdout = std.fs.File.stdout().writer(&.{});
    try stdout.interface.print("Lightpanda {f}\n", .{version});

+    const version_string = b.fmt("{f}", .{version});
+    const version_encoded = std.mem.replaceOwned(u8, b.allocator, version_string, "+", "%2B") catch @panic("OOM");
+
    var opts = b.addOptions();
-    opts.addOption([]const u8, "version", b.fmt("{f}", .{version}));
+    opts.addOption([]const u8, "version", version_string);
+    opts.addOption([]const u8, "version_encoded", version_encoded);
    opts.addOption(?[]const u8, "snapshot_path", snapshot_path);

    const enable_tsan = b.option(bool, "tsan", "Enable Thread Sanitizer") orelse false;
@@ -85,6 +89,15 @@ pub fn build(b: *Build) !void {
        break :blk mod;
    };

+    // Check compilation
+    const check = b.step("check", "Check if lightpanda compiles");
+
+    const check_lib = b.addLibrary(.{
+        .name = "lightpanda_check",
+        .root_module = lightpanda_module,
+    });
+    check.dependOn(&check_lib.step);
+
    {
        // browser
        const exe = b.addExecutable(.{
@@ -103,6 +116,12 @@ pub fn build(b: *Build) !void {
        });
        b.installArtifact(exe);

+        const exe_check = b.addLibrary(.{
+            .name = "lightpanda_exe_check",
+            .root_module = exe.root_module,
+        });
+        check.dependOn(&exe_check.step);
+
        const run_cmd = b.addRunArtifact(exe);
        if (b.args) |args| {
            run_cmd.addArgs(args);
@@ -132,6 +151,12 @@ pub fn build(b: *Build) !void {
        });
        b.installArtifact(exe);

+        const exe_check = b.addLibrary(.{
+            .name = "snapshot_creator_check",
+            .root_module = exe.root_module,
+        });
+        check.dependOn(&exe_check.step);
+
        const run_cmd = b.addRunArtifact(exe);
        if (b.args) |args| {
            run_cmd.addArgs(args);
@@ -170,6 +195,12 @@ pub fn build(b: *Build) !void {
        });
        b.installArtifact(exe);

+        const exe_check = b.addLibrary(.{
+            .name = "legacy_test_check",
+            .root_module = exe.root_module,
+        });
+        check.dependOn(&exe_check.step);
+
        const run_cmd = b.addRunArtifact(exe);
        if (b.args) |args| {
            run_cmd.addArgs(args);
--- 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/Runtime.zig");
+const Network = @import("network/Network.zig");
 pub const ArenaPool = @import("ArenaPool.zig");

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

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

 // max message size
--- a/src/browser/HttpClient.zig
+++ b/src/browser/HttpClient.zig
@@ -30,7 +30,7 @@ const Notification = @import("../Notification.zig");
 const CookieJar = @import("webapi/storage/Cookie.zig").Jar;

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

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

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

 // Queue of requests that depend on a robots.txt.
 // Allows us to fetch the robots.txt just once.
@@ -131,7 +131,7 @@ pub const CDPClient = struct {
    blocking_read_end: *const fn (*anyopaque) bool,
 };

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

@@ -695,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 Runtime pool.
+    // Process dirty connections — return them to Network pool.
    while (self.dirty.popFirst()) |node| {
        const conn: *http.Connection = @fieldParentPtr("node", node);
        self.handles.remove(conn) catch |err| {
--- 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 net_http = @import("../network/http.zig");
+const 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) !net_http.Headers {
+fn getHeaders(self: *ScriptManager) !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,28 +25,72 @@ 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, 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);
+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);
+            }
        }
-        if (comptime opts.encode) {
-            return processResolved(allocator, path, opts);
-        }
-        return path;
    }

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

    if (path[0] == '?') {
@@ -63,14 +107,7 @@ pub fn resolve(allocator: Allocator, base: [:0]const u8, path: anytype, comptime
    if (std.mem.startsWith(u8, path, "//")) {
        // network-path reference
        const index = std.mem.indexOfScalar(u8, base, ':') orelse {
-            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);
+            return processResolved(allocator, path, opts);
        };
        const protocol = base[0 .. index + 1];
        const result = try std.mem.joinZ(allocator, "", &.{ protocol, path });
@@ -96,6 +133,7 @@ pub fn resolve(allocator: Allocator, base: [:0]const u8, path: anytype, comptime
    // 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;
@@ -1570,3 +1608,182 @@ 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/actions.zig
+++ b/src/browser/actions.zig
@@ -22,23 +22,10 @@ const DOMNode = @import("webapi/Node.zig");
 const Element = @import("webapi/Element.zig");
 const Event = @import("webapi/Event.zig");
 const MouseEvent = @import("webapi/event/MouseEvent.zig");
-const KeyboardEvent = @import("webapi/event/KeyboardEvent.zig");
 const Page = @import("Page.zig");
 const Session = @import("Session.zig");
 const Selector = @import("webapi/selector/Selector.zig");

-fn dispatchInputAndChangeEvents(el: *Element, page: *Page) !void {
-    const input_evt: *Event = try .initTrusted(comptime .wrap("input"), .{ .bubbles = true }, page);
-    page._event_manager.dispatch(el.asEventTarget(), input_evt) catch |err| {
-        lp.log.err(.app, "dispatch input event failed", .{ .err = err });
-    };
-
-    const change_evt: *Event = try .initTrusted(comptime .wrap("change"), .{ .bubbles = true }, page);
-    page._event_manager.dispatch(el.asEventTarget(), change_evt) catch |err| {
-        lp.log.err(.app, "dispatch change event failed", .{ .err = err });
-    };
-}
-
 pub fn click(node: *DOMNode, page: *Page) !void {
    const el = node.is(Element) orelse return error.InvalidNodeType;

@@ -56,107 +43,9 @@ pub fn click(node: *DOMNode, page: *Page) !void {
    };
 }

-pub fn hover(node: *DOMNode, page: *Page) !void {
-    const el = node.is(Element) orelse return error.InvalidNodeType;
-
-    const mouseover_event: *MouseEvent = try .initTrusted(comptime .wrap("mouseover"), .{
-        .bubbles = true,
-        .cancelable = true,
-        .composed = true,
-    }, page);
-
-    page._event_manager.dispatch(el.asEventTarget(), mouseover_event.asEvent()) catch |err| {
-        lp.log.err(.app, "hover mouseover failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-
-    const mouseenter_event: *MouseEvent = try .initTrusted(comptime .wrap("mouseenter"), .{
-        .composed = true,
-    }, page);
-
-    page._event_manager.dispatch(el.asEventTarget(), mouseenter_event.asEvent()) catch |err| {
-        lp.log.err(.app, "hover mouseenter failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-}
-
-pub fn press(node: ?*DOMNode, key: []const u8, page: *Page) !void {
-    const target = if (node) |n|
-        (n.is(Element) orelse return error.InvalidNodeType).asEventTarget()
-    else
-        page.document.asNode().asEventTarget();
-
-    const keydown_event: *KeyboardEvent = try .initTrusted(comptime .wrap("keydown"), .{
-        .bubbles = true,
-        .cancelable = true,
-        .composed = true,
-        .key = key,
-    }, page);
-
-    page._event_manager.dispatch(target, keydown_event.asEvent()) catch |err| {
-        lp.log.err(.app, "press keydown failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-
-    const keyup_event: *KeyboardEvent = try .initTrusted(comptime .wrap("keyup"), .{
-        .bubbles = true,
-        .cancelable = true,
-        .composed = true,
-        .key = key,
-    }, page);
-
-    page._event_manager.dispatch(target, keyup_event.asEvent()) catch |err| {
-        lp.log.err(.app, "press keyup failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-}
-
-pub fn selectOption(node: *DOMNode, value: []const u8, page: *Page) !void {
-    const el = node.is(Element) orelse return error.InvalidNodeType;
-    const select = el.is(Element.Html.Select) orelse return error.InvalidNodeType;
-
-    select.setValue(value, page) catch |err| {
-        lp.log.err(.app, "select setValue failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-
-    try dispatchInputAndChangeEvents(el, page);
-}
-
-pub fn setChecked(node: *DOMNode, checked: bool, page: *Page) !void {
-    const el = node.is(Element) orelse return error.InvalidNodeType;
-    const input = el.is(Element.Html.Input) orelse return error.InvalidNodeType;
-
-    if (input._input_type != .checkbox and input._input_type != .radio) {
-        return error.InvalidNodeType;
-    }
-
-    input.setChecked(checked, page) catch |err| {
-        lp.log.err(.app, "setChecked failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-
-    // Match browser event order: click fires first, then input and change.
-    const click_event: *MouseEvent = try .initTrusted(comptime .wrap("click"), .{
-        .bubbles = true,
-        .cancelable = true,
-        .composed = true,
-    }, page);
-
-    page._event_manager.dispatch(el.asEventTarget(), click_event.asEvent()) catch |err| {
-        lp.log.err(.app, "dispatch click event failed", .{ .err = err });
-    };
-
-    try dispatchInputAndChangeEvents(el, page);
-}
-
 pub fn fill(node: *DOMNode, text: []const u8, page: *Page) !void {
    const el = node.is(Element) orelse return error.InvalidNodeType;

-    el.focus(page) catch |err| {
-        lp.log.err(.app, "fill focus failed", .{ .err = err });
-    };
-
    if (el.is(Element.Html.Input)) |input| {
        input.setValue(text, page) catch |err| {
            lp.log.err(.app, "fill input failed", .{ .err = err });
@@ -176,7 +65,15 @@ pub fn fill(node: *DOMNode, text: []const u8, page: *Page) !void {
        return error.InvalidNodeType;
    }

-    try dispatchInputAndChangeEvents(el, page);
+    const input_evt: *Event = try .initTrusted(comptime .wrap("input"), .{ .bubbles = true }, page);
+    page._event_manager.dispatch(el.asEventTarget(), input_evt) catch |err| {
+        lp.log.err(.app, "dispatch input event failed", .{ .err = err });
+    };
+
+    const change_evt: *Event = try .initTrusted(comptime .wrap("change"), .{ .bubbles = true }, page);
+    page._event_manager.dispatch(el.asEventTarget(), change_evt) catch |err| {
+        lp.log.err(.app, "dispatch change event failed", .{ .err = err });
+    };
 }

 pub fn scroll(node: ?*DOMNode, x: ?i32, y: ?i32, page: *Page) !void {
--- a/src/browser/markdown.zig
+++ b/src/browser/markdown.zig
@@ -25,9 +25,7 @@ const Element = @import("webapi/Element.zig");
 const Node = @import("webapi/Node.zig");
 const isAllWhitespace = @import("../string.zig").isAllWhitespace;

-pub const Opts = struct {
-    // Options for future customization (e.g., dialect)
-};
+pub const Opts = struct {};

 const State = struct {
    const ListType = enum { ordered, unordered };
@@ -39,7 +37,6 @@ const State = struct {
    list_depth: usize = 0,
    list_stack: [32]ListState = undefined,
    pre_node: ?*Node = null,
-    in_code: bool = false,
    in_table: bool = false,
    table_row_index: usize = 0,
    table_col_count: usize = 0,
@@ -100,27 +97,35 @@ fn getAnchorLabel(el: *Element) ?[]const u8 {
    return el.getAttributeSafe(comptime .wrap("aria-label")) orelse el.getAttributeSafe(comptime .wrap("title"));
 }

-fn hasBlockDescendant(root: *Node) bool {
-    var tw = TreeWalker.FullExcludeSelf.Elements.init(root, .{});
-    while (tw.next()) |el| {
-        if (el.getTag().isBlock()) return true;
-    }
-    return false;
-}
+const ContentInfo = struct {
+    has_visible: bool,
+    has_block: bool,
+};

-fn hasVisibleContent(root: *Node) bool {
+fn analyzeContent(root: *Node) ContentInfo {
+    var result: ContentInfo = .{ .has_visible = false, .has_block = false };
    var tw = TreeWalker.FullExcludeSelf.init(root, .{});
    while (tw.next()) |node| {
-        if (isSignificantText(node)) return true;
-        if (node.is(Element)) |el| {
+        if (isSignificantText(node)) {
+            result.has_visible = true;
+            if (result.has_block) return result;
+        } else if (node.is(Element)) |el| {
            if (!isVisibleElement(el)) {
                tw.skipChildren();
-            } else if (el.getTag() == .img) {
-                return true;
+            } else {
+                const tag = el.getTag();
+                if (tag == .img) {
+                    result.has_visible = true;
+                    if (result.has_block) return result;
+                }
+                if (tag.isBlock()) {
+                    result.has_block = true;
+                    if (result.has_visible) return result;
+                }
            }
        }
    }
-    return false;
+    return result;
 }

 const Context = struct {
@@ -170,9 +175,7 @@ const Context = struct {

        if (!isVisibleElement(el)) return;

-        // --- Opening Tag Logic ---
-
-        // Ensure block elements start on a new line (double newline for paragraphs etc)
+        // Ensure block elements start on a new line
        if (tag.isBlock() and !self.state.in_table) {
            try self.ensureNewline();
            if (shouldAddSpacing(tag)) {
@@ -182,7 +185,6 @@ const Context = struct {
            try self.ensureNewline();
        }

-        // Prefixes
        switch (tag) {
            .h1 => try self.writer.writeAll("# "),
            .h2 => try self.writer.writeAll("## "),
@@ -225,7 +227,6 @@ const Context = struct {
                try self.writer.writeByte('|');
            },
            .td, .th => {
-                // Note: leading pipe handled by previous cell closing or tr opening
                self.state.last_char_was_newline = false;
                try self.writer.writeByte(' ');
            },
@@ -241,7 +242,6 @@ const Context = struct {
            .code => {
                if (self.state.pre_node == null) {
                    try self.writer.writeByte('`');
-                    self.state.in_code = true;
                    self.state.last_char_was_newline = false;
                }
            },
@@ -286,16 +286,15 @@ const Context = struct {
                return;
            },
            .anchor => {
-                const has_content = hasVisibleContent(el.asNode());
+                const info = analyzeContent(el.asNode());
                const label = getAnchorLabel(el);
                const href_raw = el.getAttributeSafe(comptime .wrap("href"));

-                if (!has_content and label == null and href_raw == null) return;
+                if (!info.has_visible and label == null and href_raw == null) return;

-                const has_block = hasBlockDescendant(el.asNode());
                const href = if (href_raw) |h| URL.resolve(self.page.call_arena, self.page.base(), h, .{ .encode = true }) catch h else null;

-                if (has_block) {
+                if (info.has_block) {
                    try self.renderChildren(el.asNode());
                    if (href) |h| {
                        if (!self.state.last_char_was_newline) try self.writer.writeByte('\n');
@@ -307,25 +306,12 @@ const Context = struct {
                    return;
                }

-                if (isStandaloneAnchor(el)) {
+                const standalone = isStandaloneAnchor(el);
+                if (standalone) {
                    if (!self.state.last_char_was_newline) try self.writer.writeByte('\n');
-                    try self.writer.writeByte('[');
-                    if (has_content) {
-                        try self.renderChildren(el.asNode());
-                    } else {
-                        try self.writer.writeAll(label orelse "");
-                    }
-                    try self.writer.writeAll("](");
-                    if (href) |h| {
-                        try self.writer.writeAll(h);
-                    }
-                    try self.writer.writeAll(")\n");
-                    self.state.last_char_was_newline = true;
-                    return;
                }
-
                try self.writer.writeByte('[');
-                if (has_content) {
+                if (info.has_visible) {
                    try self.renderChildren(el.asNode());
                } else {
                    try self.writer.writeAll(label orelse "");
@@ -335,7 +321,12 @@ const Context = struct {
                    try self.writer.writeAll(h);
                }
                try self.writer.writeByte(')');
-                self.state.last_char_was_newline = false;
+                if (standalone) {
+                    try self.writer.writeByte('\n');
+                    self.state.last_char_was_newline = true;
+                } else {
+                    self.state.last_char_was_newline = false;
+                }
                return;
            },
            .input => {
@@ -350,12 +341,8 @@ const Context = struct {
            else => {},
        }

-        // --- Render Children ---
        try self.renderChildren(el.asNode());

-        // --- Closing Tag Logic ---
-
-        // Suffixes
        switch (tag) {
            .pre => {
                if (!self.state.last_char_was_newline) {
@@ -368,7 +355,6 @@ const Context = struct {
            .code => {
                if (self.state.pre_node == null) {
                    try self.writer.writeByte('`');
-                    self.state.in_code = false;
                    self.state.last_char_was_newline = false;
                }
            },
@@ -411,7 +397,6 @@ const Context = struct {
            else => {},
        }

-        // Post-block newlines
        if (tag.isBlock() and !self.state.in_table) {
            try self.ensureNewline();
        }
@@ -454,15 +439,19 @@ const Context = struct {
    }

    fn escape(self: *Context, text: []const u8) !void {
-        for (text) |c| {
+        var start: usize = 0;
+        for (text, 0..) |c, i| {
            switch (c) {
                '\\', '`', '*', '_', '{', '}', '[', ']', '(', ')', '#', '+', '-', '!', '|' => {
+                    if (i > start) try self.writer.writeAll(text[start..i]);
                    try self.writer.writeByte('\\');
                    try self.writer.writeByte(c);
+                    start = i + 1;
                },
-                else => try self.writer.writeByte(c),
+                else => {},
            }
        }
+        if (start < text.len) try self.writer.writeAll(text[start..]);
    }
 };

--- a/src/browser/tests/mcp_actions.html
+++ b/src/browser/tests/mcp_actions.html
@@ -10,20 +10,5 @@
    <div id="scrollbox" style="width: 100px; height: 100px; overflow: scroll;" onscroll="window.scrolled = true;">
        <div style="height: 500px;">Long content</div>
    </div>
-    <div id="hoverTarget" onmouseover="window.hovered = true;">Hover Me</div>
-    <input id="keyTarget" onkeydown="window.keyPressed = event.key;" onkeyup="window.keyReleased = event.key;">
-    <select id="sel2" onchange="window.sel2Changed = this.value">
-        <option value="a">Alpha</option>
-        <option value="b">Beta</option>
-        <option value="c">Gamma</option>
-    </select>
-    <input id="chk" type="checkbox">
-    <input id="rad" type="radio" name="group1">
-    <script>
-        document.getElementById('chk').addEventListener('click', function() { window.chkClicked = true; });
-        document.getElementById('chk').addEventListener('change', function() { window.chkChanged = true; });
-        document.getElementById('rad').addEventListener('click', function() { window.radClicked = true; });
-        document.getElementById('rad').addEventListener('change', function() { window.radChanged = true; });
-    </script>
 </body>
 </html>
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -523,6 +523,31 @@ 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 "";
 }
@@ -1686,6 +1711,8 @@ 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/element/Html.zig
+++ b/src/browser/webapi/element/Html.zig
@@ -391,6 +391,14 @@ 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,
@@ -1231,6 +1239,7 @@ 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,6 +174,14 @@ 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 "";
 }
@@ -218,6 +226,7 @@ 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/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 net_http = @import("../../../network/http.zig");
-pub fn populateHttpHeader(self: *Headers, allocator: Allocator, http_headers: *net_http.Headers) !void {
+const http = @import("../../../network/http.zig");
+pub fn populateHttpHeader(self: *Headers, allocator: Allocator, http_headers: *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 net_http = @import("../../../network/http.zig");
+const 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: net_http.Method,
+_method: 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) !net_http.Method {
+fn parseMethod(method: []const u8, page: *Page) !http.Method {
    if (method.len > "propfind".len) {
        return error.InvalidMethod;
    }

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

-    const method_lookup = std.StaticStringMap(net_http.Method).initComptime(.{
+    const method_lookup = std.StaticStringMap(http.Method).initComptime(.{
        .{ "get", .GET },
        .{ "post", .POST },
        .{ "delete", .DELETE },
--- 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 net_http = @import("../../../network/http.zig");
+const 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: net_http.Method = .GET,
+_method: 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: net_http.Header) !void {
+fn httpHeaderCallback(transfer: *HttpClient.Transfer, header: 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) !net_http.Method {
+fn parseMethod(method: []const u8) !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 net_http = @import("../../network/http.zig");
+const 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 net_http.Header = null,
+        headers: ?[]const 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(net_http.Method, method) orelse return error.InvalidParams;
+        transfer.req.method = std.meta.stringToEnum(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 net_http.Header = null,
+        responseHeaders: ?[]const http.Header = null,
        binaryResponseHeaders: ?[]const u8 = null,
        body: ?[]const u8 = null,
        responsePhrase: ?[]const u8 = null,
--- a/src/crash_handler.zig
+++ b/src/crash_handler.zig
@@ -86,7 +86,7 @@ fn report(reason: []const u8, begin_addr: usize, args: anytype) !void {
    var url_buffer: [4096]u8 = undefined;
    const url = blk: {
        var writer: std.Io.Writer = .fixed(&url_buffer);
-        try writer.print("https://crash.lightpanda.io/c?v={s}&r=", .{lp.build_config.version});
+        try writer.print("https://crash.lightpanda.io/c?v={s}&r=", .{lp.build_config.version_encoded});
        for (reason) |b| {
            switch (b) {
                'A'...'Z', 'a'...'z', '0'...'9', '-', '.', '_' => try writer.writeByte(b),
--- 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/Runtime.zig");
+pub const Network = @import("network/Network.zig");
 pub const Server = @import("Server.zig");
 pub const Config = @import("Config.zig");
 pub const URL = @import("browser/URL.zig");
--- a/src/mcp/tools.zig
+++ b/src/mcp/tools.zig
@@ -179,74 +179,6 @@ pub const tool_list = [_]protocol.Tool{
            \\}
        ),
    },
-    .{
-        .name = "hover",
-        .description = "Hover over an element, triggering mouseover and mouseenter events. Useful for menus, tooltips, and hover states.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "backendNodeId": { "type": "integer", "description": "The backend node ID of the element to hover over." }
-            \\  },
-            \\  "required": ["backendNodeId"]
-            \\}
-        ),
-    },
-    .{
-        .name = "press",
-        .description = "Press a keyboard key, dispatching keydown and keyup events. Use key names like 'Enter', 'Tab', 'Escape', 'ArrowDown', 'Backspace', or single characters like 'a', '1'.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "key": { "type": "string", "description": "The key to press (e.g. 'Enter', 'Tab', 'a')." },
-            \\    "backendNodeId": { "type": "integer", "description": "Optional backend node ID of the element to target. Defaults to the document." }
-            \\  },
-            \\  "required": ["key"]
-            \\}
-        ),
-    },
-    .{
-        .name = "selectOption",
-        .description = "Select an option in a <select> dropdown element by its value. Dispatches input and change events.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "backendNodeId": { "type": "integer", "description": "The backend node ID of the <select> element." },
-            \\    "value": { "type": "string", "description": "The value of the option to select." }
-            \\  },
-            \\  "required": ["backendNodeId", "value"]
-            \\}
-        ),
-    },
-    .{
-        .name = "setChecked",
-        .description = "Check or uncheck a checkbox or radio button. Dispatches input, change, and click events.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "backendNodeId": { "type": "integer", "description": "The backend node ID of the checkbox or radio input element." },
-            \\    "checked": { "type": "boolean", "description": "Whether to check (true) or uncheck (false) the element." }
-            \\  },
-            \\  "required": ["backendNodeId", "checked"]
-            \\}
-        ),
-    },
-    .{
-        .name = "findElement",
-        .description = "Find interactive elements by role and/or accessible name. Returns matching elements with their backend node IDs. Useful for locating specific elements without parsing the full semantic tree.",
-        .inputSchema = protocol.minify(
-            \\{
-            \\  "type": "object",
-            \\  "properties": {
-            \\    "role": { "type": "string", "description": "Optional ARIA role to match (e.g. 'button', 'link', 'textbox', 'checkbox')." },
-            \\    "name": { "type": "string", "description": "Optional accessible name substring to match (case-insensitive)." }
-            \\  }
-            \\}
-        ),
-    },
 };

 pub fn handleList(server: *Server, arena: std.mem.Allocator, req: protocol.Request) !void {
@@ -347,11 +279,6 @@ const ToolAction = enum {
    fill,
    scroll,
    waitForSelector,
-    hover,
-    press,
-    selectOption,
-    setChecked,
-    findElement,
 };

 const tool_map = std.StaticStringMap(ToolAction).initComptime(.{
@@ -369,11 +296,6 @@ const tool_map = std.StaticStringMap(ToolAction).initComptime(.{
    .{ "fill", .fill },
    .{ "scroll", .scroll },
    .{ "waitForSelector", .waitForSelector },
-    .{ "hover", .hover },
-    .{ "press", .press },
-    .{ "selectOption", .selectOption },
-    .{ "setChecked", .setChecked },
-    .{ "findElement", .findElement },
 });

 pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Request) !void {
@@ -408,11 +330,6 @@ pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Reque
        .fill => try handleFill(server, arena, req.id.?, call_params.arguments),
        .scroll => try handleScroll(server, arena, req.id.?, call_params.arguments),
        .waitForSelector => try handleWaitForSelector(server, arena, req.id.?, call_params.arguments),
-        .hover => try handleHover(server, arena, req.id.?, call_params.arguments),
-        .press => try handlePress(server, arena, req.id.?, call_params.arguments),
-        .selectOption => try handleSelectOption(server, arena, req.id.?, call_params.arguments),
-        .setChecked => try handleSetChecked(server, arena, req.id.?, call_params.arguments),
-        .findElement => try handleFindElement(server, arena, req.id.?, call_params.arguments),
    }
 }

@@ -477,9 +394,17 @@ fn handleNodeDetails(server: *Server, arena: std.mem.Allocator, id: std.json.Val
        backendNodeId: CDPNode.Id,
    };
    const args = try parseArgs(Params, arena, arguments, server, id, "nodeDetails");
-    const resolved = try resolveNodeAndPage(server, id, args.backendNodeId);

-    const details = lp.SemanticTree.getNodeDetails(arena, resolved.node, &server.node_registry, resolved.page) catch {
+    _ = server.session.currentPage() orelse {
+        return server.sendError(id, .PageNotLoaded, "Page not loaded");
+    };
+
+    const node = server.node_registry.lookup_by_id.get(args.backendNodeId) orelse {
+        return server.sendError(id, .InvalidParams, "Node not found");
+    };
+
+    const page = server.session.currentPage().?;
+    const details = lp.SemanticTree.getNodeDetails(arena, node.dom, &server.node_registry, page) catch {
        return server.sendError(id, .InternalError, "Failed to get node details");
    };

@@ -579,19 +504,26 @@ fn handleClick(server: *Server, arena: std.mem.Allocator, id: std.json.Value, ar
        backendNodeId: CDPNode.Id,
    };
    const args = try parseArgs(ClickParams, arena, arguments, server, id, "click");
-    const resolved = try resolveNodeAndPage(server, id, args.backendNodeId);

-    lp.actions.click(resolved.node, resolved.page) catch |err| {
+    const page = server.session.currentPage() orelse {
+        return server.sendError(id, .PageNotLoaded, "Page not loaded");
+    };
+
+    const node = server.node_registry.lookup_by_id.get(args.backendNodeId) orelse {
+        return server.sendError(id, .InvalidParams, "Node not found");
+    };
+
+    lp.actions.click(node.dom, page) catch |err| {
        if (err == error.InvalidNodeType) {
            return server.sendError(id, .InvalidParams, "Node is not an HTML element");
        }
        return server.sendError(id, .InternalError, "Failed to click element");
    };

-    const page_title = resolved.page.getTitle() catch null;
+    const page_title = page.getTitle() catch null;
    const result_text = try std.fmt.allocPrint(arena, "Clicked element (backendNodeId: {d}). Page url: {s}, title: {s}", .{
        args.backendNodeId,
-        resolved.page.url,
+        page.url,
        page_title orelse "(none)",
    });
    const content = [_]protocol.TextContent([]const u8){.{ .text = result_text }};
@@ -604,20 +536,27 @@ fn handleFill(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arg
        text: []const u8,
    };
    const args = try parseArgs(FillParams, arena, arguments, server, id, "fill");
-    const resolved = try resolveNodeAndPage(server, id, args.backendNodeId);

-    lp.actions.fill(resolved.node, args.text, resolved.page) catch |err| {
+    const page = server.session.currentPage() orelse {
+        return server.sendError(id, .PageNotLoaded, "Page not loaded");
+    };
+
+    const node = server.node_registry.lookup_by_id.get(args.backendNodeId) orelse {
+        return server.sendError(id, .InvalidParams, "Node not found");
+    };
+
+    lp.actions.fill(node.dom, args.text, page) catch |err| {
        if (err == error.InvalidNodeType) {
            return server.sendError(id, .InvalidParams, "Node is not an input, textarea or select");
        }
        return server.sendError(id, .InternalError, "Failed to fill element");
    };

-    const page_title = resolved.page.getTitle() catch null;
+    const page_title = page.getTitle() catch null;
    const result_text = try std.fmt.allocPrint(arena, "Filled element (backendNodeId: {d}) with \"{s}\". Page url: {s}, title: {s}", .{
        args.backendNodeId,
        args.text,
-        resolved.page.url,
+        page.url,
        page_title orelse "(none)",
    });
    const content = [_]protocol.TextContent([]const u8){.{ .text = result_text }};
@@ -691,189 +630,6 @@ fn handleWaitForSelector(server: *Server, arena: std.mem.Allocator, id: std.json
    return server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
 }

-fn handleHover(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
-    const Params = struct {
-        backendNodeId: CDPNode.Id,
-    };
-    const args = try parseArgs(Params, arena, arguments, server, id, "hover");
-    const resolved = try resolveNodeAndPage(server, id, args.backendNodeId);
-
-    lp.actions.hover(resolved.node, resolved.page) catch |err| {
-        if (err == error.InvalidNodeType) {
-            return server.sendError(id, .InvalidParams, "Node is not an HTML element");
-        }
-        return server.sendError(id, .InternalError, "Failed to hover element");
-    };
-
-    const page_title = resolved.page.getTitle() catch null;
-    const result_text = try std.fmt.allocPrint(arena, "Hovered element (backendNodeId: {d}). Page url: {s}, title: {s}", .{
-        args.backendNodeId,
-        resolved.page.url,
-        page_title orelse "(none)",
-    });
-    const content = [_]protocol.TextContent([]const u8){.{ .text = result_text }};
-    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
-}
-
-fn handlePress(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
-    const Params = struct {
-        key: []const u8,
-        backendNodeId: ?CDPNode.Id = null,
-    };
-    const args = try parseArgs(Params, arena, arguments, server, id, "press");
-
-    const page = server.session.currentPage() orelse {
-        return server.sendError(id, .PageNotLoaded, "Page not loaded");
-    };
-
-    var target_node: ?*DOMNode = null;
-    if (args.backendNodeId) |node_id| {
-        const node = server.node_registry.lookup_by_id.get(node_id) orelse {
-            return server.sendError(id, .InvalidParams, "Node not found");
-        };
-        target_node = node.dom;
-    }
-
-    lp.actions.press(target_node, args.key, page) catch |err| {
-        if (err == error.InvalidNodeType) {
-            return server.sendError(id, .InvalidParams, "Node is not an HTML element");
-        }
-        return server.sendError(id, .InternalError, "Failed to press key");
-    };
-
-    const page_title = page.getTitle() catch null;
-    const result_text = try std.fmt.allocPrint(arena, "Pressed key '{s}'. Page url: {s}, title: {s}", .{
-        args.key,
-        page.url,
-        page_title orelse "(none)",
-    });
-    const content = [_]protocol.TextContent([]const u8){.{ .text = result_text }};
-    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
-}
-
-fn handleSelectOption(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
-    const Params = struct {
-        backendNodeId: CDPNode.Id,
-        value: []const u8,
-    };
-    const args = try parseArgs(Params, arena, arguments, server, id, "selectOption");
-    const resolved = try resolveNodeAndPage(server, id, args.backendNodeId);
-
-    lp.actions.selectOption(resolved.node, args.value, resolved.page) catch |err| {
-        if (err == error.InvalidNodeType) {
-            return server.sendError(id, .InvalidParams, "Node is not a <select> element");
-        }
-        return server.sendError(id, .InternalError, "Failed to select option");
-    };
-
-    const page_title = resolved.page.getTitle() catch null;
-    const result_text = try std.fmt.allocPrint(arena, "Selected option '{s}' (backendNodeId: {d}). Page url: {s}, title: {s}", .{
-        args.value,
-        args.backendNodeId,
-        resolved.page.url,
-        page_title orelse "(none)",
-    });
-    const content = [_]protocol.TextContent([]const u8){.{ .text = result_text }};
-    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
-}
-
-fn handleSetChecked(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
-    const Params = struct {
-        backendNodeId: CDPNode.Id,
-        checked: bool,
-    };
-    const args = try parseArgs(Params, arena, arguments, server, id, "setChecked");
-    const resolved = try resolveNodeAndPage(server, id, args.backendNodeId);
-
-    lp.actions.setChecked(resolved.node, args.checked, resolved.page) catch |err| {
-        if (err == error.InvalidNodeType) {
-            return server.sendError(id, .InvalidParams, "Node is not a checkbox or radio input");
-        }
-        return server.sendError(id, .InternalError, "Failed to set checked state");
-    };
-
-    const state_str = if (args.checked) "checked" else "unchecked";
-    const page_title = resolved.page.getTitle() catch null;
-    const result_text = try std.fmt.allocPrint(arena, "Set element (backendNodeId: {d}) to {s}. Page url: {s}, title: {s}", .{
-        args.backendNodeId,
-        state_str,
-        resolved.page.url,
-        page_title orelse "(none)",
-    });
-    const content = [_]protocol.TextContent([]const u8){.{ .text = result_text }};
-    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
-}
-
-fn handleFindElement(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
-    const Params = struct {
-        role: ?[]const u8 = null,
-        name: ?[]const u8 = null,
-    };
-    const args = try parseArgsOrDefault(Params, arena, arguments, server, id);
-
-    if (args.role == null and args.name == null) {
-        return server.sendError(id, .InvalidParams, "At least one of 'role' or 'name' must be provided");
-    }
-
-    const page = server.session.currentPage() orelse {
-        return server.sendError(id, .PageNotLoaded, "Page not loaded");
-    };
-
-    const elements = lp.interactive.collectInteractiveElements(page.document.asNode(), arena, page) catch |err| {
-        log.err(.mcp, "elements collection failed", .{ .err = err });
-        return server.sendError(id, .InternalError, "Failed to collect interactive elements");
-    };
-
-    var matches: std.ArrayList(lp.interactive.InteractiveElement) = .empty;
-    for (elements) |el| {
-        if (args.role) |role| {
-            const el_role = el.role orelse continue;
-            if (!std.ascii.eqlIgnoreCase(el_role, role)) continue;
-        }
-        if (args.name) |name| {
-            const el_name = el.name orelse continue;
-            if (!containsIgnoreCase(el_name, name)) continue;
-        }
-        try matches.append(arena, el);
-    }
-
-    const matched = try matches.toOwnedSlice(arena);
-    lp.interactive.registerNodes(matched, &server.node_registry) catch |err| {
-        log.err(.mcp, "node registration failed", .{ .err = err });
-        return server.sendError(id, .InternalError, "Failed to register element nodes");
-    };
-
-    var aw: std.Io.Writer.Allocating = .init(arena);
-    try std.json.Stringify.value(matched, .{}, &aw.writer);
-
-    const content = [_]protocol.TextContent([]const u8){.{ .text = aw.written() }};
-    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
-}
-
-fn containsIgnoreCase(haystack: []const u8, needle: []const u8) bool {
-    if (needle.len > haystack.len) return false;
-    if (needle.len == 0) return true;
-    const end = haystack.len - needle.len + 1;
-    for (0..end) |i| {
-        if (std.ascii.eqlIgnoreCase(haystack[i..][0..needle.len], needle)) return true;
-    }
-    return false;
-}
-
-const NodeAndPage = struct { node: *DOMNode, page: *lp.Page };
-
-fn resolveNodeAndPage(server: *Server, id: std.json.Value, node_id: CDPNode.Id) !NodeAndPage {
-    const page = server.session.currentPage() orelse {
-        try server.sendError(id, .PageNotLoaded, "Page not loaded");
-        return error.PageNotLoaded;
-    };
-    const node = server.node_registry.lookup_by_id.get(node_id) orelse {
-        try server.sendError(id, .InvalidParams, "Node not found");
-        return error.InvalidParams;
-    };
-    return .{ .node = node.dom, .page = page };
-}
-
 fn ensurePage(server: *Server, id: std.json.Value, url: ?[:0]const u8) !*lp.Page {
    if (url) |u| {
        try performGoto(server, u, id);
@@ -971,7 +727,7 @@ test "MCP - evaluate error reporting" {
    } }, out.written());
 }

-test "MCP - Actions: click, fill, scroll, hover, press, selectOption, setChecked" {
+test "MCP - Actions: click, fill, scroll" {
    defer testing.reset();
    const aa = testing.arena_allocator;

@@ -1032,67 +788,7 @@ test "MCP - Actions: click, fill, scroll, hover, press, selectOption, setChecked
        out.clearRetainingCapacity();
    }

-    {
-        // Test Hover
-        const el = page.document.getElementById("hoverTarget", page).?.asNode();
-        const el_id = (try server.node_registry.register(el)).id;
-        var id_buf: [12]u8 = undefined;
-        const id_str = std.fmt.bufPrint(&id_buf, "{d}", .{el_id}) catch unreachable;
-        const msg = try std.mem.concat(aa, u8, &.{ "{\"jsonrpc\":\"2.0\",\"id\":5,\"method\":\"tools/call\",\"params\":{\"name\":\"hover\",\"arguments\":{\"backendNodeId\":", id_str, "}}}" });
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "Hovered element") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Test Press
-        const el = page.document.getElementById("keyTarget", page).?.asNode();
-        const el_id = (try server.node_registry.register(el)).id;
-        var id_buf: [12]u8 = undefined;
-        const id_str = std.fmt.bufPrint(&id_buf, "{d}", .{el_id}) catch unreachable;
-        const msg = try std.mem.concat(aa, u8, &.{ "{\"jsonrpc\":\"2.0\",\"id\":6,\"method\":\"tools/call\",\"params\":{\"name\":\"press\",\"arguments\":{\"key\":\"Enter\",\"backendNodeId\":", id_str, "}}}" });
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "Pressed key") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Test SelectOption
-        const el = page.document.getElementById("sel2", page).?.asNode();
-        const el_id = (try server.node_registry.register(el)).id;
-        var id_buf: [12]u8 = undefined;
-        const id_str = std.fmt.bufPrint(&id_buf, "{d}", .{el_id}) catch unreachable;
-        const msg = try std.mem.concat(aa, u8, &.{ "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"tools/call\",\"params\":{\"name\":\"selectOption\",\"arguments\":{\"backendNodeId\":", id_str, ",\"value\":\"b\"}}}" });
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "Selected option") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Test SetChecked (checkbox)
-        const el = page.document.getElementById("chk", page).?.asNode();
-        const el_id = (try server.node_registry.register(el)).id;
-        var id_buf: [12]u8 = undefined;
-        const id_str = std.fmt.bufPrint(&id_buf, "{d}", .{el_id}) catch unreachable;
-        const msg = try std.mem.concat(aa, u8, &.{ "{\"jsonrpc\":\"2.0\",\"id\":8,\"method\":\"tools/call\",\"params\":{\"name\":\"setChecked\",\"arguments\":{\"backendNodeId\":", id_str, ",\"checked\":true}}}" });
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "checked") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Test SetChecked (radio)
-        const el = page.document.getElementById("rad", page).?.asNode();
-        const el_id = (try server.node_registry.register(el)).id;
-        var id_buf: [12]u8 = undefined;
-        const id_str = std.fmt.bufPrint(&id_buf, "{d}", .{el_id}) catch unreachable;
-        const msg = try std.mem.concat(aa, u8, &.{ "{\"jsonrpc\":\"2.0\",\"id\":9,\"method\":\"tools/call\",\"params\":{\"name\":\"setChecked\",\"arguments\":{\"backendNodeId\":", id_str, ",\"checked\":true}}}" });
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "checked") != null);
-        out.clearRetainingCapacity();
-    }
-
-    // Evaluate JS assertions for all actions
+    // Evaluate assertions
    var ls: js.Local.Scope = undefined;
    page.js.localScope(&ls);
    defer ls.deinit();
@@ -1104,66 +800,12 @@ test "MCP - Actions: click, fill, scroll, hover, press, selectOption, setChecked
    const result = try ls.local.exec(
        \\ window.clicked === true && window.inputVal === 'hello' &&
        \\ window.changed === true && window.selChanged === 'opt2' &&
-        \\ window.scrolled === true &&
-        \\ window.hovered === true &&
-        \\ window.keyPressed === 'Enter' && window.keyReleased === 'Enter' &&
-        \\ window.sel2Changed === 'b' &&
-        \\ window.chkClicked === true && window.chkChanged === true &&
-        \\ window.radClicked === true && window.radChanged === true
+        \\ window.scrolled === true
    , null);

    try testing.expect(result.isTrue());
 }

-test "MCP - findElement" {
-    defer testing.reset();
-    const aa = testing.arena_allocator;
-
-    var out: std.io.Writer.Allocating = .init(aa);
-    const server = try testLoadPage("http://localhost:9582/src/browser/tests/mcp_actions.html", &out.writer);
-    defer server.deinit();
-
-    {
-        // Find by role
-        const msg =
-            \\{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"findElement","arguments":{"role":"button"}}}
-        ;
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "Click Me") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Find by name (case-insensitive substring)
-        const msg =
-            \\{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"findElement","arguments":{"name":"click"}}}
-        ;
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "Click Me") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Find with no matches
-        const msg =
-            \\{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"findElement","arguments":{"role":"slider"}}}
-        ;
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "[]") != null);
-        out.clearRetainingCapacity();
-    }
-
-    {
-        // Error: no params provided
-        const msg =
-            \\{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"findElement","arguments":{}}}
-        ;
-        try router.handleMessage(server, aa, msg);
-        try testing.expect(std.mem.indexOf(u8, out.written(), "error") != null);
-        out.clearRetainingCapacity();
-    }
-}
-
 test "MCP - waitForSelector: existing element" {
    defer testing.reset();
    var out: std.io.Writer.Allocating = .init(testing.arena_allocator);
--- a/src/network/Network.zig
+++ b/src/network/Network.zig
@@ -26,11 +26,11 @@ const lp = @import("lightpanda");
 const Config = @import("../Config.zig");
 const libcurl = @import("../sys/libcurl.zig");

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

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

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

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

-connections: []net_http.Connection,
+connections: []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, Runtime is used sparingly, and we only create it on demand.
-// When Runtime becomes truly shared, it should become a regular field.
+// Currently, Network is used sparingly, and we only create it on demand.
+// When Network 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) !Runtime {
+pub fn init(allocator: Allocator, config: *const Config) !Network {
    globalInit(allocator);
    errdefer globalDeinit();

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

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

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

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

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

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

 pub fn bind(
-    self: *Runtime,
+    self: *Network,
    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: *Runtime, ctx: *anyopaque, callback: *const fn (*anyopaque) void) void {
+pub fn onTick(self: *Network, 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: *Runtime, ctx: *anyopaque, callback: *const fn (*anyopaque)
    self.wakeupPoll();
 }

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

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

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

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

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

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

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

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

    while (self.submission_queue.popFirst()) |node| {
-        const conn: *net_http.Connection = @fieldParentPtr("node", node);
+        const conn: *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: *Runtime) void {
    }
 }

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

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

-fn preparePollFds(self: *Runtime, multi: *libcurl.CurlM) void {
+fn preparePollFds(self: *Network, 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: *Runtime, multi: *libcurl.CurlM) void {
    };
 }

-fn getCurlTimeout(self: *Runtime) i32 {
+fn getCurlTimeout(self: *Network) 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: *Runtime, multi: *libcurl.CurlM) void {
+fn processCompletions(self: *Network, 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: *Runtime, multi: *libcurl.CurlM) void {
        var ptr: *anyopaque = undefined;
        libcurl.curl_easy_getinfo(easy, .private, &ptr) catch
            lp.assert(false, "curl getinfo private", .{});
-        const conn: *net_http.Connection = @ptrCast(@alignCast(ptr));
+        const conn: *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: *Runtime) ?*net_http.Connection {
+pub fn getConnection(self: *Network) ?*http.Connection {
    self.conn_mutex.lock();
    defer self.conn_mutex.unlock();

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

-pub fn releaseConnection(self: *Runtime, conn: *net_http.Connection) void {
+pub fn releaseConnection(self: *Network, conn: *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: *Runtime, conn: *net_http.Connection) void {
    self.available.append(&conn.node);
 }

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

 // Wraps lines @ 64 columns. A PEM is basically a base64 encoded DER (which is
--- 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 Runtime = @import("../network/Runtime.zig");
+const Network = @import("../network/Network.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,
-runtime: *Runtime,
+network: *Network,
 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,
-        .runtime = &app.network,
+        .network = &app.network,
        .writer = std.Io.Writer.Allocating.init(app.allocator),
    };

-    self.runtime.onTick(@ptrCast(self), flushCallback);
+    self.network.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.runtime.getConnection() orelse {
+    const conn = self.network.getConnection() orelse {
        return;
    };
-    errdefer self.runtime.releaseConnection(conn);
+    errdefer self.network.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.runtime.releaseConnection(conn);
+        self.network.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.runtime.submitRequest(conn);
+    self.network.submitRequest(conn);
 }

 fn writeEvent(self: *LightPanda, event: telemetry.Event) !bool {
Author	SHA1	Message	Date
Karl Seguin	fec02850d4	Merge pull request #2068 from lightpanda-io/refactor/markdown-anchor-rendering Some checks are pending e2e-test / zig build release (push) Waiting to run Details e2e-test / demo-scripts (push) Blocked by required conditions Details e2e-test / wba-demo-scripts (push) Blocked by required conditions Details e2e-test / wba-test (push) Blocked by required conditions Details e2e-test / cdp-and-hyperfine-bench (push) Blocked by required conditions Details e2e-test / perf-fmt (push) Blocked by required conditions Details e2e-test / browser fetch (push) Blocked by required conditions Details zig-test / zig fmt (push) Waiting to run Details zig-test / zig test using v8 in debug mode (push) Waiting to run Details zig-test / zig test (push) Waiting to run Details zig-test / perf-fmt (push) Blocked by required conditions Details markdown: simplify and optimize anchor rendering	2026-04-02 17:06:26 +08:00
Adrià Arrufat	71ac2e8c7f	markdown: simplify and optimize anchor rendering	2026-04-02 09:11:26 +02:00
Karl Seguin	38fa9602fa	Merge pull request #2067 from lightpanda-io/percent-encode-version Some checks failed e2e-test / zig build release (push) Has been cancelled Details e2e-test / demo-scripts (push) Has been cancelled Details e2e-test / wba-demo-scripts (push) Has been cancelled Details e2e-test / wba-test (push) Has been cancelled Details e2e-test / cdp-and-hyperfine-bench (push) Has been cancelled Details e2e-test / perf-fmt (push) Has been cancelled Details e2e-test / browser fetch (push) Has been cancelled Details zig-test / zig fmt (push) Has been cancelled Details zig-test / zig test using v8 in debug mode (push) Has been cancelled Details zig-test / zig test (push) Has been cancelled Details zig-test / perf-fmt (push) Has been cancelled Details percent encode version query string for crash report	2026-04-02 07:50:31 +08:00
Pierre Tachoire	9661204c8d	percent encode version query string for crash report	2026-04-01 22:15:56 +02:00
Karl Seguin	6800e53b0e	Merge pull request #2014 from lightpanda-io/build-check Some checks failed e2e-test / zig build release (push) Has been cancelled Details e2e-test / demo-scripts (push) Has been cancelled Details e2e-test / wba-demo-scripts (push) Has been cancelled Details e2e-test / wba-test (push) Has been cancelled Details e2e-test / cdp-and-hyperfine-bench (push) Has been cancelled Details e2e-test / perf-fmt (push) Has been cancelled Details e2e-test / browser fetch (push) Has been cancelled Details zig-test / zig fmt (push) Has been cancelled Details zig-test / zig test using v8 in debug mode (push) Has been cancelled Details zig-test / zig test (push) Has been cancelled Details zig-test / perf-fmt (push) Has been cancelled Details build: add check step to verify compilation	2026-04-01 21:05:04 +08:00
Nikolay Govorov	e79da3a4ad	Merge pull request #2064 from lightpanda-io/network_naming Improve network naming consistency	2026-04-01 13:10:12 +01:00
Karl Seguin	145792c4f5	Merge pull request #2061 from lightpanda-io/ariaAtomic Add Element.ariaAtomic and Element.ariaLive properties	2026-04-01 20:06:15 +08:00
Karl Seguin	0bb3e3827d	Merge pull request #2060 from lightpanda-io/HTMLAnchorElement.rel Add HTMLAnchorElement.rel property	2026-04-01 20:04:43 +08:00
Karl Seguin	6e6e6e6fad	Merge pull request #2057 from lightpanda-io/element-title Add HTMLElement.title property	2026-04-01 19:36:12 +08:00
Karl Seguin	9d13a7ccdb	Merge pull request #2065 from lightpanda-io/browser/resolve-scheme-in-path Browser/resolve scheme in path	2026-04-01 19:30:40 +08:00
Karl Seguin	7fcaa500d8	Fix typo in variable name protect against overflow if path stats with ':' Minor tweaks to https://github.com/lightpanda-io/browser/pull/2046	2026-04-01 19:20:55 +08:00
Karl Seguin	0604056f76	Improve network naming consistency 1. Runtime.zig -> Network.zig (especially since most places imported it as `const Network = @import("Runtime.zig")` 2. const net_http = @import(...) -> const http = @import(...)	2026-04-01 18:46:03 +08:00
Pierre Tachoire	5965d37c79	Add HTMLAnchorElement.rel property Reflects the `rel` HTML attribute. The `relList` DOMTokenList was already implemented but the string `rel` accessor was missing.	2026-04-01 11:15:10 +02:00
Pierre Tachoire	e430051fff	Add Element.ariaAtomic and Element.ariaLive properties ARIAMixin attribute reflection on Element, per the ARIA spec.	2026-04-01 11:13:52 +02:00
Pierre Tachoire	ca8361f5c1	Merge pull request #2059 from lightpanda-io/integration-e2e-report Some checks failed e2e-test / zig build release (push) Has been cancelled Details e2e-test / demo-scripts (push) Has been cancelled Details e2e-test / wba-demo-scripts (push) Has been cancelled Details e2e-test / wba-test (push) Has been cancelled Details e2e-test / cdp-and-hyperfine-bench (push) Has been cancelled Details e2e-test / perf-fmt (push) Has been cancelled Details e2e-test / browser fetch (push) Has been cancelled Details zig-test / zig fmt (push) Has been cancelled Details zig-test / zig test using v8 in debug mode (push) Has been cancelled Details zig-test / zig test (push) Has been cancelled Details zig-test / perf-fmt (push) Has been cancelled Details ci: send e2e integration results to slack	2026-04-01 10:41:16 +02:00
Pierre Tachoire	bc4afcd82f	Merge pull request #2058 from lightpanda-io/wpt-diff Wpt diff	2026-04-01 10:31:12 +02:00
Pierre Tachoire	1c1bd81daa	ci: send e2e integration results to slack	2026-04-01 10:29:56 +02:00
Pierre Tachoire	ea87fc2c50	ci: publish ci regression list into slack	2026-04-01 10:18:06 +02:00
Pierre Tachoire	e412dfed2f	Add HTMLElement.title property Reflects the `title` HTML attribute as a getter/setter on HTMLElement.	2026-04-01 09:15:34 +02:00
dinisimys2018	2d87f5bf47	fix(browser-url): handle specific file scheme and change error InvalidURL to TypeError	2026-03-31 18:42:03 +03:00
dinisimys2018	0a222ff397	fix(browser-url): add more combinations base+path handle	2026-03-31 16:54:06 +03:00
dinisimys2018	9a0cefad26	fix(browser-url): url resolve scheme in path	2026-03-30 18:58:19 +03:00
Adrià Arrufat	3aeba97fc9	build: add check step to verify compilation	2026-03-27 14:25:17 +09:00