Add HTMLAnchorElement.rel property

Reflects the `rel` HTML attribute. The `relList` DOMTokenList was
already implemented but the string `rel` accessor was missing.

.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"

.github/workflows/e2e-test.yml

@@ -100,18 +100,15 @@ jobs:
           ./proxy/proxy & echo $! > PROXY.id
           ./lightpanda serve --http-proxy 'http://127.0.0.1:3000' & echo $! > LPD.pid
           go run runner/main.go
+          URL=https://demo-browser.lightpanda.io/campfire-commerce/ node puppeteer/proxy_auth.js
           kill `cat LPD.pid` `cat PROXY.id`
 
-      - name: run request interception through proxy
+      - name: run request interception through proxy and playwright
         run: |
           export PROXY_USERNAME=username PROXY_PASSWORD=password
           ./proxy/proxy & echo $! > PROXY.id
           ./lightpanda serve & echo $! > LPD.pid
           BASE_URL=https://demo-browser.lightpanda.io/ node playwright/proxy_auth.js
-          kill `cat LPD.pid`
-
-          ./lightpanda serve --http-proxy 'http://127.0.0.1:3000' & echo $! > LPD.pid
-          URL=https://demo-browser.lightpanda.io/campfire-commerce/ node puppeteer/proxy_auth.js
           kill `cat LPD.pid` `cat PROXY.id`
 
   # e2e tests w/ web-bot-auth configuration on.
@@ -164,14 +161,18 @@ jobs:
             --http-proxy 'http://127.0.0.1:3000' \
             & echo $! > LPD.pid
           go run runner/main.go
+          URL=https://demo-browser.lightpanda.io/campfire-commerce/ node puppeteer/proxy_auth.js
           kill `cat LPD.pid` `cat PROXY.id`
 
-      - name: run request interception through proxy
+      - name: run request interception through proxy and playwright
         run: |
           export PROXY_USERNAME=username PROXY_PASSWORD=password
           ./proxy/proxy & echo $! > PROXY.id
-          ./lightpanda serve & echo $! > LPD.pid
-          URL=https://demo-browser.lightpanda.io/campfire-commerce/ node puppeteer/proxy_auth.js
+          ./lightpanda serve \
+            --web-bot-auth-key-file private_key.pem \
+            --web-bot-auth-keyid ${{ vars.WBA_KEY_ID }} \
+            --web-bot-auth-domain ${{ vars.WBA_DOMAIN }} \
+            & echo $! > LPD.pid
           BASE_URL=https://demo-browser.lightpanda.io/ node playwright/proxy_auth.js
           kill `cat LPD.pid` `cat PROXY.id`
 

.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"

README.md

@@ -36,8 +36,8 @@ Lightpanda is the open-source browser made for headless usage:
 
 Fast web automation for AI agents, LLM training, scraping and testing:
 
-- Ultra-low memory footprint (9x less than Chrome)
-- Exceptionally fast execution (11x faster than Chrome)
+- Ultra-low memory footprint (16x less than Chrome)
+- Exceptionally fast execution (9x faster than Chrome)
 - Instant startup
 
 [^1]: **Playwright support disclaimer:**

SECURITY.md

@@ -0,0 +1,11 @@
+# Reporting security issues
+
+## Supported Versions
+
+Security fixes are applied to the latest `main` branch.
+
+## Reporting a Vulnerability
+
+Please **DO NOT** file a public issue, instead send your report privately to security@lightpanda.io.
+
+Security reports are greatly appreciated and we will publicly thank you for it, although we keep your name confidential if you request it.

src/Config.zig

@@ -249,7 +249,9 @@ pub const Fetch = struct {
     with_frames: bool = false,
     strip: dump.Opts.Strip = .{},
     wait_ms: u32 = 5000,
-    wait_until: WaitUntil = .done,
+    wait_until: ?WaitUntil = null,
+    wait_script: ?[:0]const u8 = null,
+    wait_selector: ?[:0]const u8 = null,
 };
 
 pub const Common = struct {
@@ -413,12 +415,24 @@ pub fn printUsageAndExit(self: *const Config, success: bool) void {
         \\
         \\--with-frames   Includes the contents of iframes. Defaults to false.
         \\
-        \\--wait-ms       Wait time in milliseconds.
+        \\--wait-ms       Wait time in milliseconds. Supersedes all other --wait
+        \\                parameters.
         \\                Defaults to 5000.
         \\
-        \\--wait-until    Wait until the specified event.
-        \\                Supported events: load, domcontentloaded, networkidle, done.
-        \\                Defaults to 'done'.
+        \\--wait-until    Wait until the specified event. Checked before the other
+        \\                --wait- options. Supported events: load, domcontentloaded,
+        \\                networkidle, done.
+        \\                Defaults to 'done'. If --wait-selector, --wait-script or
+        \\                --wait-script-file are specified, defaults to none.
+        \\
+        \\--wait-selector Wait for an element matching the CSS selector to appear.
+        \\                Checked after --wait-until condition is met.
+        \\
+        \\--wait-script   Wait for a JavaScript expression to return truthy.
+        \\                Checked after --wait-until condition is met.
+        \\
+        \\--wait-script-file
+        \\                Like --wait-script, but reads the script from a file.
         \\
     ++ common_options ++
         \\
@@ -685,7 +699,9 @@ fn parseFetchArgs(
     var common: Common = .{};
     var strip: dump.Opts.Strip = .{};
     var wait_ms: u32 = 5000;
-    var wait_until: WaitUntil = .done;
+    var wait_until: ?WaitUntil = null;
+    var wait_script: ?[:0]const u8 = null;
+    var wait_selector: ?[:0]const u8 = null;
 
     while (args.next()) |opt| {
         if (std.mem.eql(u8, "--wait-ms", opt) or std.mem.eql(u8, "--wait_ms", opt)) {
@@ -712,6 +728,36 @@ fn parseFetchArgs(
             continue;
         }
 
+        if (std.mem.eql(u8, "--wait-selector", opt) or std.mem.eql(u8, "--wait_selector", opt)) {
+            const str = args.next() orelse {
+                log.fatal(.app, "missing argument value", .{ .arg = opt });
+                return error.InvalidArgument;
+            };
+            wait_selector = try allocator.dupeZ(u8, str);
+            continue;
+        }
+
+        if (std.mem.eql(u8, "--wait-script", opt) or std.mem.eql(u8, "--wait_script", opt)) {
+            const str = args.next() orelse {
+                log.fatal(.app, "missing argument value", .{ .arg = opt });
+                return error.InvalidArgument;
+            };
+            wait_script = try allocator.dupeZ(u8, str);
+            continue;
+        }
+
+        if (std.mem.eql(u8, "--wait-script-file", opt) or std.mem.eql(u8, "--wait_script_file", opt)) {
+            const path = args.next() orelse {
+                log.fatal(.app, "missing argument value", .{ .arg = opt });
+                return error.InvalidArgument;
+            };
+            wait_script = std.fs.cwd().readFileAllocOptions(allocator, path, 1024 * 1024, null, .of(u8), 0) catch |err| {
+                log.fatal(.app, "failed to read file", .{ .arg = opt, .path = path, .err = err });
+                return error.InvalidArgument;
+            };
+            continue;
+        }
+
         if (std.mem.eql(u8, "--dump", opt)) {
             var peek_args = args.*;
             if (peek_args.next()) |next_arg| {
@@ -802,6 +848,8 @@ fn parseFetchArgs(
         .with_frames = with_frames,
         .wait_ms = wait_ms,
         .wait_until = wait_until,
+        .wait_selector = wait_selector,
+        .wait_script = wait_script,
     };
 }
 

src/Notification.zig

@@ -74,6 +74,8 @@ const EventListeners = struct {
     page_network_idle: List = .{},
     page_network_almost_idle: List = .{},
     page_frame_created: List = .{},
+    page_dom_content_loaded: List = .{},
+    page_loaded: List = .{},
     http_request_fail: List = .{},
     http_request_start: List = .{},
     http_request_intercept: List = .{},
@@ -91,6 +93,8 @@ const Events = union(enum) {
     page_network_idle: *const PageNetworkIdle,
     page_network_almost_idle: *const PageNetworkAlmostIdle,
     page_frame_created: *const PageFrameCreated,
+    page_dom_content_loaded: *const PageDOMContentLoaded,
+    page_loaded: *const PageLoaded,
     http_request_fail: *const RequestFail,
     http_request_start: *const RequestStart,
     http_request_intercept: *const RequestIntercept,
@@ -137,6 +141,18 @@ pub const PageFrameCreated = struct {
     timestamp: u64,
 };
 
+pub const PageDOMContentLoaded = struct {
+    req_id: u32,
+    frame_id: u32,
+    timestamp: u64,
+};
+
+pub const PageLoaded = struct {
+    req_id: u32,
+    frame_id: u32,
+    timestamp: u64,
+};
+
 pub const RequestStart = struct {
     transfer: *Transfer,
 };

src/SemanticTree.zig

@@ -95,9 +95,11 @@ const NodeData = struct {
     name: ?[]const u8,
     value: ?[]const u8,
     options: ?[]OptionData = null,
+    checked: ?bool = null,
     xpath: []const u8,
-    is_interactive: bool,
-    node_name: []const u8,
+    interactive: bool,
+    disabled: bool,
+    tag_name: []const u8,
 };
 
 const WalkContext = struct {
@@ -148,16 +150,21 @@ fn walk(
     const role = try axn.getRole();
 
     var is_interactive = false;
+    var is_disabled = false;
     var value: ?[]const u8 = null;
     var options: ?[]OptionData = null;
-    var node_name: []const u8 = "text";
+    var checked: ?bool = null;
+    var tag_name: []const u8 = "text";
 
     if (node.is(Element)) |el| {
-        node_name = el.getTagNameLower();
+        tag_name = el.getTagNameLower();
 
         if (el.is(Element.Html.Input)) |input| {
             value = input.getValue();
-            if (el.getAttributeSafe(comptime lp.String.wrap("list"))) |list_id| {
+            if (input._input_type == .checkbox or input._input_type == .radio) {
+                checked = input.getChecked();
+            }
+            if (el.getAttributeSafe(comptime .wrap("list"))) |list_id| {
                 options = try extractDataListOptions(list_id, self.page, self.arena);
             }
         } else if (el.is(Element.Html.TextArea)) |textarea| {
@@ -172,8 +179,10 @@ fn walk(
                 is_interactive = true;
             }
         }
+
+        is_disabled = el.isDisabled();
     } else if (node._type == .document or node._type == .document_fragment) {
-        node_name = "root";
+        tag_name = "root";
     }
 
     const initial_xpath_len = ctx.xpath_buffer.items.len;
@@ -234,9 +243,11 @@ fn walk(
         .name = name,
         .value = value,
         .options = options,
+        .checked = checked,
         .xpath = xpath,
-        .is_interactive = is_interactive,
-        .node_name = node_name,
+        .interactive = is_interactive,
+        .disabled = is_disabled,
+        .tag_name = tag_name,
     };
 
     if (should_visit) {
@@ -335,7 +346,7 @@ const JsonVisitor = struct {
         try self.jw.write(data.id);
 
         try self.jw.objectField("nodeName");
-        try self.jw.write(data.node_name);
+        try self.jw.write(data.tag_name);
 
         try self.jw.objectField("xpath");
         try self.jw.write(data.xpath);
@@ -345,7 +356,12 @@ const JsonVisitor = struct {
             try self.jw.write(1);
 
             try self.jw.objectField("isInteractive");
-            try self.jw.write(data.is_interactive);
+            try self.jw.write(data.interactive);
+
+            if (data.disabled) {
+                try self.jw.objectField("isDisabled");
+                try self.jw.write(true);
+            }
 
             try self.jw.objectField("role");
             try self.jw.write(data.role);
@@ -373,6 +389,11 @@ const JsonVisitor = struct {
                 try self.jw.endObject();
             }
 
+            if (data.checked) |checked| {
+                try self.jw.objectField("checked");
+                try self.jw.write(checked);
+            }
+
             if (data.options) |options| {
                 try self.jw.objectField("options");
                 try self.jw.beginArray();
@@ -459,6 +480,9 @@ const TextVisitor = struct {
         const is_text_only = std.mem.eql(u8, data.role, "StaticText") or std.mem.eql(u8, data.role, "none") or std.mem.eql(u8, data.role, "generic");
 
         try self.writer.print("{d}", .{data.id});
+        if (data.interactive) {
+            try self.writer.writeAll(if (data.disabled) " [i:disabled]" else " [i]");
+        }
         if (!is_text_only) {
             try self.writer.print(" {s}", .{data.role});
         }
@@ -472,6 +496,14 @@ const TextVisitor = struct {
             }
         }
 
+        if (data.checked) |c| {
+            if (c) {
+                try self.writer.writeAll(" [checked]");
+            } else {
+                try self.writer.writeAll(" [unchecked]");
+            }
+        }
+
         if (data.options) |options| {
             try self.writer.writeAll(" options=[");
             for (options, 0..) |opt, i| {
@@ -509,13 +541,189 @@ const TextVisitor = struct {
     }
 };
 
+pub const NodeDetails = struct {
+    backendNodeId: CDPNode.Id,
+    tag_name: []const u8,
+    role: []const u8,
+    name: ?[]const u8,
+    interactive: bool,
+    disabled: bool,
+    value: ?[]const u8 = null,
+    input_type: ?[]const u8 = null,
+    placeholder: ?[]const u8 = null,
+    href: ?[]const u8 = null,
+    id: ?[]const u8 = null,
+    class: ?[]const u8 = null,
+    checked: ?bool = null,
+    options: ?[]OptionData = null,
+
+    pub fn jsonStringify(self: *const NodeDetails, jw: anytype) !void {
+        try jw.beginObject();
+
+        try jw.objectField("backendNodeId");
+        try jw.write(self.backendNodeId);
+
+        try jw.objectField("tagName");
+        try jw.write(self.tag_name);
+
+        try jw.objectField("role");
+        try jw.write(self.role);
+
+        if (self.name) |n| {
+            try jw.objectField("name");
+            try jw.write(n);
+        }
+
+        try jw.objectField("isInteractive");
+        try jw.write(self.interactive);
+
+        if (self.disabled) {
+            try jw.objectField("isDisabled");
+            try jw.write(true);
+        }
+
+        if (self.value) |v| {
+            try jw.objectField("value");
+            try jw.write(v);
+        }
+
+        if (self.input_type) |v| {
+            try jw.objectField("inputType");
+            try jw.write(v);
+        }
+
+        if (self.placeholder) |v| {
+            try jw.objectField("placeholder");
+            try jw.write(v);
+        }
+
+        if (self.href) |v| {
+            try jw.objectField("href");
+            try jw.write(v);
+        }
+
+        if (self.id) |v| {
+            try jw.objectField("id");
+            try jw.write(v);
+        }
+
+        if (self.class) |v| {
+            try jw.objectField("class");
+            try jw.write(v);
+        }
+
+        if (self.checked) |c| {
+            try jw.objectField("checked");
+            try jw.write(c);
+        }
+
+        if (self.options) |opts| {
+            try jw.objectField("options");
+            try jw.beginArray();
+            for (opts) |opt| {
+                try jw.beginObject();
+                try jw.objectField("value");
+                try jw.write(opt.value);
+                try jw.objectField("text");
+                try jw.write(opt.text);
+                if (opt.selected) {
+                    try jw.objectField("selected");
+                    try jw.write(true);
+                }
+                try jw.endObject();
+            }
+            try jw.endArray();
+        }
+
+        try jw.endObject();
+    }
+};
+
+pub fn getNodeDetails(
+    arena: std.mem.Allocator,
+    node: *Node,
+    registry: *CDPNode.Registry,
+    page: *Page,
+) !NodeDetails {
+    const cdp_node = try registry.register(node);
+    const axn = AXNode.fromNode(node);
+    const role = try axn.getRole();
+    const name = try axn.getName(page, arena);
+
+    var is_interactive = false;
+    var is_disabled = false;
+    var tag_name: []const u8 = "text";
+    var value: ?[]const u8 = null;
+    var input_type: ?[]const u8 = null;
+    var placeholder: ?[]const u8 = null;
+    var href: ?[]const u8 = null;
+    var id_attr: ?[]const u8 = null;
+    var class_attr: ?[]const u8 = null;
+    var checked: ?bool = null;
+    var options: ?[]OptionData = null;
+
+    if (node.is(Element)) |el| {
+        tag_name = el.getTagNameLower();
+        is_disabled = el.isDisabled();
+        id_attr = el.getAttributeSafe(comptime .wrap("id"));
+        class_attr = el.getAttributeSafe(comptime .wrap("class"));
+        placeholder = el.getAttributeSafe(comptime .wrap("placeholder"));
+
+        if (el.getAttributeSafe(comptime .wrap("href"))) |h| {
+            const URL = lp.URL;
+            href = URL.resolve(arena, page.base(), h, .{ .encode = true }) catch h;
+        }
+
+        if (el.is(Element.Html.Input)) |input| {
+            value = input.getValue();
+            input_type = input._input_type.toString();
+            if (input._input_type == .checkbox or input._input_type == .radio) {
+                checked = input.getChecked();
+            }
+            if (el.getAttributeSafe(comptime .wrap("list"))) |list_id| {
+                options = try extractDataListOptions(list_id, page, arena);
+            }
+        } else if (el.is(Element.Html.TextArea)) |textarea| {
+            value = textarea.getValue();
+        } else if (el.is(Element.Html.Select)) |select| {
+            value = select.getValue(page);
+            options = try extractSelectOptions(el.asNode(), page, arena);
+        }
+
+        if (el.is(Element.Html)) |html_el| {
+            const listener_targets = try interactive.buildListenerTargetMap(page, arena);
+            var pointer_events_cache: Element.PointerEventsCache = .empty;
+            if (interactive.classifyInteractivity(page, el, html_el, listener_targets, &pointer_events_cache) != null) {
+                is_interactive = true;
+            }
+        }
+    }
+
+    return .{
+        .backendNodeId = cdp_node.id,
+        .tag_name = tag_name,
+        .role = role,
+        .name = name,
+        .interactive = is_interactive,
+        .disabled = is_disabled,
+        .value = value,
+        .input_type = input_type,
+        .placeholder = placeholder,
+        .href = href,
+        .id = id_attr,
+        .class = class_attr,
+        .checked = checked,
+        .options = options,
+    };
+}
+
 const testing = @import("testing.zig");
 
 test "SemanticTree backendDOMNodeId" {
     var registry: CDPNode.Registry = .init(testing.allocator);
     defer registry.deinit();
 
-    var page = try testing.pageTest("cdp/registry1.html");
+    var page = try testing.pageTest("cdp/registry1.html", .{});
     defer testing.reset();
     defer page._session.removePage();
 
@@ -539,7 +747,7 @@ test "SemanticTree max_depth" {
     var registry: CDPNode.Registry = .init(testing.allocator);
     defer registry.deinit();
 
-    var page = try testing.pageTest("cdp/registry1.html");
+    var page = try testing.pageTest("cdp/registry1.html", .{});
     defer testing.reset();
     defer page._session.removePage();
 

src/browser/EventManager.zig

@@ -205,7 +205,7 @@ pub fn dispatch(self: *EventManager, target: *EventTarget, event: *Event) Dispat
 
 pub fn dispatchOpts(self: *EventManager, target: *EventTarget, event: *Event, comptime opts: DispatchOpts) DispatchError!void {
     event.acquireRef();
-    defer event.deinit(false, self.page._session);
+    defer _ = event.releaseRef(self.page._session);
 
     if (comptime IS_DEBUG) {
         log.debug(.event, "eventManager.dispatch", .{ .type = event._type_string.str(), .bubbles = event._bubbles });
@@ -240,7 +240,7 @@ pub fn dispatchDirect(self: *EventManager, target: *EventTarget, event: *Event,
     defer window._current_event = prev_event;
 
     event.acquireRef();
-    defer event.deinit(false, page._session);
+    defer _ = event.releaseRef(page._session);
 
     if (comptime IS_DEBUG) {
         log.debug(.event, "dispatchDirect", .{ .type = event._type_string, .context = opts.context });

src/browser/Factory.zig

@@ -239,7 +239,7 @@ fn eventInit(arena: Allocator, typ: String, value: anytype) !Event {
     const time_stamp = (raw_timestamp / 2) * 2;
 
     return .{
-        ._rc = 0,
+        ._rc = .{},
         ._arena = arena,
         ._type = unionInit(Event.Type, value),
         ._type_string = typ,
@@ -255,6 +255,7 @@ pub fn blob(_: *const Factory, arena: Allocator, child: anytype) !*@TypeOf(child
 
     const blob_ptr = chain.get(0);
     blob_ptr.* = .{
+        ._rc = .{},
         ._arena = arena,
         ._type = unionInit(Blob.Type, chain.get(1)),
         ._slice = "",
@@ -271,7 +272,7 @@ pub fn abstractRange(_: *const Factory, arena: Allocator, child: anytype, page:
     const doc = page.document.asNode();
     const abstract_range = chain.get(0);
     abstract_range.* = AbstractRange{
-        ._rc = 0,
+        ._rc = .{},
         ._arena = arena,
         ._page_id = page.id,
         ._type = unionInit(AbstractRange.Type, chain.get(1)),

src/browser/HttpClient.zig

@@ -1261,15 +1261,21 @@ pub const Transfer = struct {
 
     fn detectAuthChallenge(transfer: *Transfer, conn: *const http.Connection) void {
         const status = conn.getResponseCode() catch return;
-        if (status != 401 and status != 407) {
+        const connect_status = conn.getConnectCode() catch return;
+
+        if (status != 401 and status != 407 and connect_status != 401 and connect_status != 407) {
             transfer._auth_challenge = null;
             return;
         }
 
         if (conn.getResponseHeader("WWW-Authenticate", 0)) |hdr| {
             transfer._auth_challenge = http.AuthChallenge.parse(status, .server, hdr.value) catch null;
+        } else if (conn.getConnectHeader("WWW-Authenticate", 0)) |hdr| {
+            transfer._auth_challenge = http.AuthChallenge.parse(status, .server, hdr.value) catch null;
         } else if (conn.getResponseHeader("Proxy-Authenticate", 0)) |hdr| {
             transfer._auth_challenge = http.AuthChallenge.parse(status, .proxy, hdr.value) catch null;
+        } else if (conn.getConnectHeader("Proxy-Authenticate", 0)) |hdr| {
+            transfer._auth_challenge = http.AuthChallenge.parse(status, .proxy, hdr.value) catch null;
         } else {
             transfer._auth_challenge = .{ .status = status, .source = null, .scheme = null, .realm = null };
         }
@@ -1342,15 +1348,15 @@ pub const Transfer = struct {
             }
         }
 
+        transfer.req.notification.dispatch(.http_response_header_done, &.{
+            .transfer = transfer,
+        });
+
         const proceed = transfer.req.header_callback(transfer) catch |err| {
             log.err(.http, "header_callback", .{ .err = err, .req = transfer });
             return err;
         };
 
-        transfer.req.notification.dispatch(.http_response_header_done, &.{
-            .transfer = transfer,
-        });
-
         return proceed and transfer.aborted == false;
     }
 

src/browser/Page.zig

@@ -487,7 +487,6 @@ pub fn navigate(self: *Page, request_url: [:0]const u8, opts: NavigateOpts) !voi
                 return error.InjectBlankFailed;
             };
         }
-        self.documentIsComplete();
 
         session.notification.dispatch(.page_navigate, &.{
             .frame_id = self._frame_id,
@@ -519,6 +518,8 @@ pub fn navigate(self: *Page, request_url: [:0]const u8, opts: NavigateOpts) !voi
 
         // force next request id manually b/c we won't create a real req.
         _ = session.browser.http_client.incrReqId();
+
+        self.documentIsComplete();
         return;
     }
 
@@ -738,6 +739,12 @@ pub fn _documentIsLoaded(self: *Page) !void {
         self.document.asEventTarget(),
         event,
     );
+
+    self._session.notification.dispatch(.page_dom_content_loaded, &.{
+        .frame_id = self._frame_id,
+        .req_id = self._req_id,
+        .timestamp = timestamp(.monotonic),
+    });
 }
 
 pub fn scriptsCompletedLoading(self: *Page) void {
@@ -796,19 +803,6 @@ pub fn documentIsComplete(self: *Page) void {
     self._documentIsComplete() catch |err| {
         log.err(.page, "document is complete", .{ .err = err, .type = self._type, .url = self.url });
     };
-
-    if (self._navigated_options) |no| {
-        // _navigated_options will be null in special short-circuit cases, like
-        // "navigating" to about:blank, in which case this notification has
-        // already been sent
-        self._session.notification.dispatch(.page_navigated, &.{
-            .frame_id = self._frame_id,
-            .req_id = self._req_id,
-            .opts = no,
-            .url = self.url,
-            .timestamp = timestamp(.monotonic),
-        });
-    }
 }
 
 fn _documentIsComplete(self: *Page) !void {
@@ -827,6 +821,12 @@ fn _documentIsComplete(self: *Page) !void {
         try self._event_manager.dispatchDirect(window_target, event, self.window._on_load, .{ .inject_target = false, .context = "page load" });
     }
 
+    self._session.notification.dispatch(.page_loaded, &.{
+        .frame_id = self._frame_id,
+        .req_id = self._req_id,
+        .timestamp = timestamp(.monotonic),
+    });
+
     if (self._event_manager.hasDirectListeners(window_target, "pageshow", self.window._on_pageshow)) {
         const pageshow_event = (try PageTransitionEvent.initTrusted(comptime .wrap("pageshow"), .{}, self)).asEvent();
         try self._event_manager.dispatchDirect(window_target, pageshow_event, self.window._on_pageshow, .{ .context = "page show" });
@@ -879,6 +879,19 @@ fn pageHeaderDoneCallback(transfer: *HttpClient.Transfer) !bool {
         });
     }
 
+    if (self._navigated_options) |no| {
+        // _navigated_options will be null in special short-circuit cases, like
+        // "navigating" to about:blank, in which case this notification has
+        // already been sent
+        self._session.notification.dispatch(.page_navigated, &.{
+            .frame_id = self._frame_id,
+            .req_id = self._req_id,
+            .opts = no,
+            .url = self.url,
+            .timestamp = timestamp(.monotonic),
+        });
+    }
+
     return true;
 }
 
@@ -3392,7 +3405,7 @@ pub fn handleClick(self: *Page, target: *Node) !void {
 pub fn triggerKeyboard(self: *Page, keyboard_event: *KeyboardEvent) !void {
     const event = keyboard_event.asEvent();
     const element = self.window._document._active_element orelse {
-        keyboard_event.deinit(false, self._session);
+        _ = event.releaseRef(self._session);
         return;
     };
 
@@ -3488,7 +3501,7 @@ pub fn submitForm(self: *Page, submitter_: ?*Element, form_: ?*Element.Html.Form
 
         // so submit_event is still valid when we check _prevent_default
         submit_event.acquireRef();
-        defer submit_event.deinit(false, self._session);
+        defer _ = submit_event.releaseRef(self._session);
 
         try self._event_manager.dispatch(form_element.asEventTarget(), submit_event);
         // If the submit event was prevented, don't submit the form

src/browser/Runner.zig

@@ -22,10 +22,14 @@ const builtin = @import("builtin");
 
 const log = @import("../log.zig");
 
+const js = @import("js/js.zig");
 const Page = @import("Page.zig");
 const Session = @import("Session.zig");
 const HttpClient = @import("HttpClient.zig");
 
+const Node = @import("webapi/Node.zig");
+const Selector = @import("webapi/selector/Selector.zig");
+
 const IS_DEBUG = builtin.mode == .Debug;
 
 const Runner = @This();
@@ -236,3 +240,111 @@ fn _tick(self: *Runner, comptime is_cdp: bool, opts: TickOpts) !CDPTickResult {
         .raw_done => return .done,
     }
 }
+
+pub fn waitForSelector(self: *Runner, selector: [:0]const u8, timeout_ms: u32) !*Node.Element {
+    const arena = try self.session.getArena(.{ .debug = "Runner.waitForSelector" });
+    defer self.session.releaseArena(arena);
+
+    var timer = try std.time.Timer.start();
+    const parsed_selector = try Selector.parseLeaky(arena, selector);
+
+    while (true) {
+        // self.page can change between ticks
+        const page = self.page;
+        if (try parsed_selector.query(page.document.asNode(), page)) |el| {
+            return el;
+        }
+
+        const elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
+        if (elapsed >= timeout_ms) {
+            return error.Timeout;
+        }
+        switch (try self.tick(.{ .ms = timeout_ms - elapsed })) {
+            .done => return error.Timeout,
+            .ok => |recommended_sleep_ms| {
+                if (recommended_sleep_ms > 0) {
+                    std.Thread.sleep(std.time.ns_per_ms * recommended_sleep_ms);
+                }
+            },
+        }
+    }
+}
+
+pub fn waitForScript(runner: *Runner, script: [:0]const u8, timeout_ms: u32) !void {
+    var timer = try std.time.Timer.start();
+
+    while (true) {
+        const page = runner.page;
+
+        // Execute the script and check if it returns truthy
+        var ls: js.Local.Scope = undefined;
+        page.js.localScope(&ls);
+        defer ls.deinit();
+
+        var try_catch: js.TryCatch = undefined;
+        try_catch.init(&ls.local);
+        defer try_catch.deinit();
+
+        const value = ls.local.exec(script, "wait_script") catch |err| {
+            const caught = try_catch.caughtOrError(page.call_arena, err);
+            log.err(.app, "wait script error", .{ .err = caught });
+            return error.ScriptError;
+        };
+
+        if (value.toBool()) {
+            return;
+        }
+
+        const elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
+        if (elapsed >= timeout_ms) {
+            return error.Timeout;
+        }
+        switch (try runner.tick(.{ .ms = timeout_ms - elapsed })) {
+            .done => return error.Timeout,
+            .ok => |recommended_sleep_ms| {
+                if (recommended_sleep_ms > 0) {
+                    std.Thread.sleep(std.time.ns_per_ms * recommended_sleep_ms);
+                }
+            },
+        }
+    }
+}
+
+const testing = @import("../testing.zig");
+test "Runner: no page" {
+    try testing.expectError(error.NoPage, Runner.init(testing.test_session, .{}));
+}
+
+test "Runner: waitForSelector timeout" {
+    const page = try testing.pageTest("runner/runner1.html", .{});
+    defer page._session.removePage();
+
+    var runner = try page._session.runner(.{});
+    try testing.expectError(error.Timeout, runner.waitForSelector("#nope", 10));
+}
+
+test "Runner: waitForSelector" {
+    defer testing.reset();
+    const page = try testing.pageTest("runner/runner1.html", .{});
+    defer page._session.removePage();
+
+    var runner = try page._session.runner(.{});
+    const el = try runner.waitForSelector("#sel1", 10);
+    try testing.expectEqual("selector-1-content", try el.asNode().getTextContentAlloc(testing.arena_allocator));
+}
+
+test "Runner: waitForScript timeout" {
+    const page = try testing.pageTest("runner/runner1.html", .{});
+    defer page._session.removePage();
+
+    var runner = try page._session.runner(.{});
+    try testing.expectError(error.Timeout, runner.waitForScript("document.querySelector('#nope')", 10));
+}
+
+test "Runner: waitForScript" {
+    const page = try testing.pageTest("runner/runner1.html", .{});
+    defer page._session.removePage();
+
+    var runner = try page._session.runner(.{});
+    try runner.waitForScript("document.querySelector('#sel1')", 10);
+}

src/browser/Session.zig

@@ -71,6 +71,18 @@ origins: std.StringHashMapUnmanaged(*js.Origin) = .empty,
 // ensuring object identity works across same-origin frames.
 identity: js.Identity = .{},
 
+// Shared finalizer callbacks across all Identities. Keyed by Zig instance ptr.
+// This ensures objects are only freed when ALL v8 wrappers are gone.
+finalizer_callbacks: std.AutoHashMapUnmanaged(usize, *FinalizerCallback) = .empty,
+
+// Tracked global v8 objects that need to be released on cleanup.
+// Lives at Session level so objects can outlive individual Identities.
+globals: std.ArrayList(v8.Global) = .empty,
+
+// Temporary v8 globals that can be released early. Key is global.data_ptr.
+// Lives at Session level so objects holding Temps can outlive individual Identities.
+temps: std.AutoHashMapUnmanaged(usize, v8.Global) = .empty,
+
 // Shared resources for all pages in this session.
 // These live for the duration of the page tree (root + frames).
 arena_pool: *ArenaPool,
@@ -224,6 +236,30 @@ pub fn releaseOrigin(self: *Session, origin: *js.Origin) void {
 /// Reset page_arena and factory for a clean slate.
 /// Called when root page is removed.
 fn resetPageResources(self: *Session) void {
+    // Force cleanup all remaining finalized objects
+    {
+        var it = self.finalizer_callbacks.valueIterator();
+        while (it.next()) |fc| {
+            fc.*.deinit(self);
+        }
+        self.finalizer_callbacks = .empty;
+    }
+
+    {
+        for (self.globals.items) |*global| {
+            v8.v8__Global__Reset(global);
+        }
+        self.globals = .empty;
+    }
+
+    {
+        var it = self.temps.valueIterator();
+        while (it.next()) |global| {
+            v8.v8__Global__Reset(global);
+        }
+        self.temps = .empty;
+    }
+
     self.identity.deinit();
     self.identity = .{};
 
@@ -457,35 +493,25 @@ pub fn nextPageId(self: *Session) u32 {
     return id;
 }
 
-// A type that has a finalizer can have its finalizer called one of two ways.
-// The first is from V8 via the WeakCallback we give to weakRef. But that isn't
-// guaranteed to fire, so we track this in finalizer_callbacks and call them on
-// page reset.
+// Every finalizable instance of Zig gets 1 FinalizerCallback registered in the
+// session. This is to ensure that, if v8 doesn't finalize the value, we can
+// release on page reset.
 pub const FinalizerCallback = struct {
     arena: Allocator,
     session: *Session,
-    ptr: *anyopaque,
-    global: v8.Global,
-    identity: *js.Identity,
-    zig_finalizer: *const fn (ptr: *anyopaque, session: *Session) void,
+    resolved_ptr_id: usize,
+    finalizer_ptr_id: usize,
+    _deinit: *const fn (ptr_id: usize, session: *Session) void,
 
-    pub fn deinit(self: *FinalizerCallback) void {
-        self.zig_finalizer(self.ptr, self.session);
-        self.session.releaseArena(self.arena);
-    }
-
-    /// Release this item from the identity tracking maps (called after finalizer runs from V8)
-    pub fn releaseIdentity(self: *FinalizerCallback) void {
-        const session = self.session;
-        const id = @intFromPtr(self.ptr);
-
-        if (self.identity.identity_map.fetchRemove(id)) |kv| {
-            var global = kv.value;
-            v8.v8__Global__Reset(&global);
-        }
-
-        _ = self.identity.finalizer_callbacks.remove(id);
+    // For every FinalizerCallback we'll have 1+ FinalizerCallback.Identity: one
+    // for every identity that gets the instance. In most cases, that'l be 1.
+    pub const Identity = struct {
+        identity: *js.Identity,
+        fc: *Session.FinalizerCallback,
+    };
 
+    fn deinit(self: *FinalizerCallback, session: *Session) void {
+        self._deinit(self.finalizer_ptr_id, session);
         session.releaseArena(self.arena);
     }
 };

src/browser/StyleManager.zig

@@ -114,7 +114,7 @@ fn addRawRule(self: *StyleManager, selector_text: []const u8, block_text: []cons
 
     if (!props.isRelevant()) return;
 
-    const selectors = SelectorParser.parseList(self.arena, selector_text, self.page) catch return;
+    const selectors = SelectorParser.parseList(self.arena, selector_text) catch return;
     for (selectors) |selector| {
         const rightmost = if (selector.segments.len > 0) selector.segments[selector.segments.len - 1].compound else selector.first;
         const bucket_key = getBucketKey(rightmost) orelse continue;
@@ -484,7 +484,7 @@ fn addRule(self: *StyleManager, style_rule: *CSSStyleRule) !void {
     }
 
     // Parse the selector list
-    const selectors = SelectorParser.parseList(self.arena, selector_text, self.page) catch return;
+    const selectors = SelectorParser.parseList(self.arena, selector_text) catch return;
     if (selectors.len == 0) {
         return;
     }

src/browser/actions.zig

@@ -110,28 +110,10 @@ pub fn waitForSelector(selector: [:0]const u8, timeout_ms: u32, session: *Sessio
     var runner = try session.runner(.{});
     try runner.wait(.{ .ms = timeout_ms, .until = .load });
 
-    while (true) {
-        const page = runner.page;
-        const element = Selector.querySelector(page.document.asNode(), selector, page) catch {
-            return error.InvalidSelector;
-        };
+    const elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
+    const remaining = timeout_ms -| elapsed;
+    if (remaining == 0) return error.Timeout;
 
-        if (element) |el| {
-            return el.asNode();
-        }
-
-        const elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
-        if (elapsed >= timeout_ms) {
-            return error.Timeout;
-        }
-        switch (try runner.tick(.{ .ms = timeout_ms - elapsed })) {
-            .done => return error.Timeout,
-            .ok => |recommended_sleep_ms| {
-                if (recommended_sleep_ms > 0) {
-                    // guanrateed to be <= 20ms
-                    std.Thread.sleep(std.time.ns_per_ms * recommended_sleep_ms);
-                }
-            },
-        }
-    }
+    const el = try runner.waitForSelector(selector, remaining);
+    return el.asNode();
 }

src/browser/js/Context.zig

@@ -21,6 +21,7 @@ const lp = @import("lightpanda");
 const log = @import("../../log.zig");
 
 const js = @import("js.zig");
+const bridge = @import("bridge.zig");
 const Env = @import("Env.zig");
 const Origin = @import("Origin.zig");
 const Scheduler = @import("Scheduler.zig");
@@ -213,48 +214,11 @@ pub fn setOrigin(self: *Context, key: ?[]const u8) !void {
 }
 
 pub fn trackGlobal(self: *Context, global: v8.Global) !void {
-    return self.identity.globals.append(self.identity_arena, global);
+    return self.session.globals.append(self.session.page_arena, global);
 }
 
 pub fn trackTemp(self: *Context, global: v8.Global) !void {
-    return self.identity.temps.put(self.identity_arena, global.data_ptr, global);
-}
-
-pub fn weakRef(self: *Context, obj: anytype) void {
-    const resolved = js.Local.resolveValue(obj);
-    const fc = self.identity.finalizer_callbacks.get(@intFromPtr(resolved.ptr)) orelse {
-        if (comptime IS_DEBUG) {
-            // should not be possible
-            std.debug.assert(false);
-        }
-        return;
-    };
-    v8.v8__Global__SetWeakFinalizer(&fc.global, fc, resolved.finalizer_from_v8, v8.kParameter);
-}
-
-pub fn safeWeakRef(self: *Context, obj: anytype) void {
-    const resolved = js.Local.resolveValue(obj);
-    const fc = self.identity.finalizer_callbacks.get(@intFromPtr(resolved.ptr)) orelse {
-        if (comptime IS_DEBUG) {
-            // should not be possible
-            std.debug.assert(false);
-        }
-        return;
-    };
-    v8.v8__Global__ClearWeak(&fc.global);
-    v8.v8__Global__SetWeakFinalizer(&fc.global, fc, resolved.finalizer_from_v8, v8.kParameter);
-}
-
-pub fn strongRef(self: *Context, obj: anytype) void {
-    const resolved = js.Local.resolveValue(obj);
-    const fc = self.identity.finalizer_callbacks.get(@intFromPtr(resolved.ptr)) orelse {
-        if (comptime IS_DEBUG) {
-            // should not be possible
-            std.debug.assert(false);
-        }
-        return;
-    };
-    v8.v8__Global__ClearWeak(&fc.global);
+    return self.session.temps.put(self.session.page_arena, global.data_ptr, global);
 }
 
 pub const IdentityResult = struct {
@@ -270,35 +234,6 @@ pub fn addIdentity(self: *Context, ptr: usize) !IdentityResult {
     };
 }
 
-pub fn releaseTemp(self: *Context, global: v8.Global) void {
-    if (self.identity.temps.fetchRemove(global.data_ptr)) |kv| {
-        var g = kv.value;
-        v8.v8__Global__Reset(&g);
-    }
-}
-
-pub fn createFinalizerCallback(
-    self: *Context,
-    global: v8.Global,
-    ptr: *anyopaque,
-    zig_finalizer: *const fn (ptr: *anyopaque, session: *Session) void,
-) !*Session.FinalizerCallback {
-    const session = self.session;
-    const arena = try session.getArena(.{ .debug = "FinalizerCallback" });
-    errdefer session.releaseArena(arena);
-    const fc = try arena.create(Session.FinalizerCallback);
-    fc.* = .{
-        .arena = arena,
-        .session = session,
-        .ptr = ptr,
-        .global = global,
-        .zig_finalizer = zig_finalizer,
-        // Store identity pointer for cleanup when V8 GCs the object
-        .identity = self.identity,
-    };
-    return fc;
-}
-
 // Any operation on the context have to be made from a local.
 pub fn localScope(self: *Context, ls: *js.Local.Scope) void {
     const isolate = self.isolate;

src/browser/js/Function.zig

@@ -213,7 +213,7 @@ fn _persist(self: *const Function, comptime is_global: bool) !(if (is_global) Gl
         return .{ .handle = global, .temps = {} };
     }
     try ctx.trackTemp(global);
-    return .{ .handle = global, .temps = &ctx.identity.temps };
+    return .{ .handle = global, .temps = &ctx.session.temps };
 }
 
 pub fn tempWithThis(self: *const Function, value: anytype) !Temp {

src/browser/js/Identity.zig

@@ -38,38 +38,9 @@ const Identity = @This();
 // Maps Zig instance pointers to their v8::Global(Object) wrappers.
 identity_map: std.AutoHashMapUnmanaged(usize, v8.Global) = .empty,
 
-// Tracked global v8 objects that need to be released on cleanup.
-globals: std.ArrayList(v8.Global) = .empty,
-
-// Temporary v8 globals that can be released early. Key is global.data_ptr.
-temps: std.AutoHashMapUnmanaged(usize, v8.Global) = .empty,
-
-// Finalizer callbacks for weak references. Key is @intFromPtr of the Zig instance.
-finalizer_callbacks: std.AutoHashMapUnmanaged(usize, *Session.FinalizerCallback) = .empty,
-
 pub fn deinit(self: *Identity) void {
-    {
-        var it = self.finalizer_callbacks.valueIterator();
-        while (it.next()) |finalizer| {
-            finalizer.*.deinit();
-        }
-    }
-
-    {
-        var it = self.identity_map.valueIterator();
-        while (it.next()) |global| {
-            v8.v8__Global__Reset(global);
-        }
-    }
-
-    for (self.globals.items) |*global| {
+    var it = self.identity_map.valueIterator();
+    while (it.next()) |global| {
         v8.v8__Global__Reset(global);
     }
-
-    {
-        var it = self.temps.valueIterator();
-        while (it.next()) |global| {
-            v8.v8__Global__Reset(global);
-        }
-    }
 }

src/browser/js/Local.zig

@@ -17,10 +17,11 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
-const Session = @import("../Session.zig");
 const log = @import("../../log.zig");
 const string = @import("../../string.zig");
 
+const Session = @import("../Session.zig");
+
 const js = @import("js.zig");
 const bridge = @import("bridge.zig");
 const Caller = @import("Caller.zig");
@@ -213,7 +214,8 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
         .pointer => |ptr| {
             const resolved = resolveValue(value);
 
-            const gop = try ctx.addIdentity(@intFromPtr(resolved.ptr));
+            const resolved_ptr_id = @intFromPtr(resolved.ptr);
+            const gop = try ctx.addIdentity(resolved_ptr_id);
             if (gop.found_existing) {
                 // we've seen this instance before, return the same object
                 return (js.Object.Global{ .handle = gop.value_ptr.* }).local(self);
@@ -262,31 +264,27 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
             // dont' use js_obj.persist(), because we don't want to track this in
             // context.global_objects, we want to track it in context.identity_map.
             v8.v8__Global__New(isolate.handle, js_obj.handle, gop.value_ptr);
-            if (@hasDecl(JsApi.Meta, "finalizer")) {
-                // It would be great if resolved knew the resolved type, but I
-                // can't figure out how to make that work, since it depends on
-                // the [runtime] `value`.
-                // We need the resolved finalizer, which we have in resolved.
-                //
-                // The above if statement would be more clear as:
-                //    if (resolved.finalizer_from_v8) |finalizer| {
-                // But that's a runtime check.
-                // Instead, we check if the base has finalizer. The assumption
-                // here is that if a resolve type has a finalizer, then the base
-                // should have a finalizer too.
-                const fc = try ctx.createFinalizerCallback(gop.value_ptr.*, resolved.ptr, resolved.finalizer_from_zig.?);
-                {
-                    errdefer fc.deinit();
-                    try ctx.identity.finalizer_callbacks.put(ctx.identity_arena, @intFromPtr(resolved.ptr), fc);
-                }
+            if (resolved.finalizer) |finalizer| {
+                const finalizer_ptr_id = finalizer.ptr_id;
+                finalizer.acquireRef(finalizer_ptr_id);
 
-                conditionallyReference(value);
-                if (@hasDecl(JsApi.Meta, "weak")) {
-                    if (comptime IS_DEBUG) {
-                        std.debug.assert(JsApi.Meta.weak == true);
-                    }
-                    v8.v8__Global__SetWeakFinalizer(gop.value_ptr, fc, resolved.finalizer_from_v8, v8.kParameter);
+                const session = ctx.session;
+                const finalizer_gop = try session.finalizer_callbacks.getOrPut(session.page_arena, finalizer_ptr_id);
+                if (finalizer_gop.found_existing == false) {
+                    // This is the first context (and very likely only one) to
+                    // see this Zig instance. We need to create the FinalizerCallback
+                    // so that we can cleanup on page reset if v8 doesn't finalize.
+                    errdefer _ = session.finalizer_callbacks.remove(finalizer_ptr_id);
+                    finalizer_gop.value_ptr.* = try self.createFinalizerCallback(resolved_ptr_id, finalizer_ptr_id, finalizer.deinit);
                 }
+                const fc = finalizer_gop.value_ptr.*;
+                const identity_finalizer = try fc.arena.create(Session.FinalizerCallback.Identity);
+                identity_finalizer.* = .{
+                    .fc = fc,
+                    .identity = ctx.identity,
+                };
+
+                v8.v8__Global__SetWeakFinalizer(gop.value_ptr, identity_finalizer, finalizer.release, v8.kParameter);
             }
             return js_obj;
         },
@@ -1121,12 +1119,19 @@ fn jsUnsignedIntToZig(comptime T: type, max: comptime_int, maybe: u32) !T {
 // This function recursively walks the _type union field (if there is one) to
 // get the most specific class_id possible.
 const Resolved = struct {
-    weak: bool,
     ptr: *anyopaque,
     class_id: u16,
     prototype_chain: []const @import("TaggedOpaque.zig").PrototypeChainEntry,
-    finalizer_from_v8: ?*const fn (handle: ?*const v8.WeakCallbackInfo) callconv(.c) void = null,
-    finalizer_from_zig: ?*const fn (ptr: *anyopaque, session: *Session) void = null,
+    finalizer: ?Finalizer,
+
+    const Finalizer = struct {
+        // Resolved.ptr is the most specific value in a chain (e.g. IFrame, not EventTarget, Node,  ...)
+        // Finalizer.ptr_id is the most specific value in a chain that defines an acquireRef
+        ptr_id: usize,
+        deinit: *const fn (ptr_id: usize, session: *Session) void,
+        acquireRef: *const fn (ptr_id: usize) void,
+        release: *const fn (handle: ?*const v8.WeakCallbackInfo) callconv(.c) void,
+    };
 };
 pub fn resolveValue(value: anytype) Resolved {
     const T = bridge.Struct(@TypeOf(value));
@@ -1153,27 +1158,85 @@ pub fn resolveValue(value: anytype) Resolved {
     unreachable;
 }
 
-fn resolveT(comptime T: type, value: *anyopaque) Resolved {
+fn resolveT(comptime T: type, value: *T) Resolved {
     const Meta = T.JsApi.Meta;
     return .{
         .ptr = value,
         .class_id = Meta.class_id,
         .prototype_chain = &Meta.prototype_chain,
-        .weak = if (@hasDecl(Meta, "weak")) Meta.weak else false,
-        .finalizer_from_v8 = if (@hasDecl(Meta, "finalizer")) Meta.finalizer.from_v8 else null,
-        .finalizer_from_zig = if (@hasDecl(Meta, "finalizer")) Meta.finalizer.from_zig else null,
+        .finalizer = blk: {
+            const FT = (comptime findFinalizerType(T)) orelse break :blk null;
+            const getFinalizerPtr = comptime finalizerPtrGetter(T, FT);
+            const finalizer_ptr = getFinalizerPtr(value);
+
+            const Wrap = struct {
+                fn deinit(ptr_id: usize, session: *Session) void {
+                    FT.deinit(@ptrFromInt(ptr_id), session);
+                }
+
+                fn acquireRef(ptr_id: usize) void {
+                    FT.acquireRef(@ptrFromInt(ptr_id));
+                }
+
+                fn release(handle: ?*const v8.WeakCallbackInfo) callconv(.c) void {
+                    const ptr = v8.v8__WeakCallbackInfo__GetParameter(handle.?).?;
+                    const identity_finalizer: *Session.FinalizerCallback.Identity = @ptrCast(@alignCast(ptr));
+
+                    const fc = identity_finalizer.fc;
+                    if (identity_finalizer.identity.identity_map.fetchRemove(fc.resolved_ptr_id)) |kv| {
+                        var global = kv.value;
+                        v8.v8__Global__Reset(&global);
+                    }
+
+                    FT.releaseRef(@ptrFromInt(fc.finalizer_ptr_id), fc.session);
+                }
+            };
+            break :blk .{
+                .ptr_id = @intFromPtr(finalizer_ptr),
+                .deinit = Wrap.deinit,
+                .acquireRef = Wrap.acquireRef,
+                .release = Wrap.release,
+            };
+        },
     };
 }
 
-fn conditionallyReference(value: anytype) void {
-    const T = bridge.Struct(@TypeOf(value));
-    if (@hasDecl(T, "acquireRef")) {
-        value.acquireRef();
-        return;
+// Start at the "resolved" type (the most specific) and work our way up the
+// prototype chain looking for the type that defines acquireRef
+fn findFinalizerType(comptime T: type) ?type {
+    const S = bridge.Struct(T);
+    if (@hasDecl(S, "acquireRef")) {
+        return S;
     }
-    if (@hasField(T, "_proto")) {
-        conditionallyReference(value._proto);
+    if (@hasField(S, "_proto")) {
+        const ProtoPtr = std.meta.fieldInfo(S, ._proto).type;
+        const ProtoChild = @typeInfo(ProtoPtr).pointer.child;
+        return findFinalizerType(ProtoChild);
     }
+    return null;
+}
+
+// Generate a function that follows the _proto pointer chain to get to the finalizer type
+fn finalizerPtrGetter(comptime T: type, comptime FT: type) *const fn (*T) *FT {
+    const S = bridge.Struct(T);
+    if (S == FT) {
+        return struct {
+            fn get(v: *T) *FT {
+                return v;
+            }
+        }.get;
+    }
+    if (@hasField(S, "_proto")) {
+        const ProtoPtr = std.meta.fieldInfo(S, ._proto).type;
+        const ProtoChild = @typeInfo(ProtoPtr).pointer.child;
+        const childGetter = comptime finalizerPtrGetter(ProtoChild, FT);
+        return struct {
+            fn get(v: *T) *FT {
+                return childGetter(v._proto);
+            }
+        }.get;
+    }
+    @compileError("Cannot find path from " ++ @typeName(T) ++ " to " ++ @typeName(FT));
 }
 
 pub fn stackTrace(self: *const Local) !?[]const u8 {
@@ -1381,6 +1444,34 @@ pub fn debugContextId(self: *const Local) i32 {
     return v8.v8__Context__DebugContextId(self.handle);
 }
 
+fn createFinalizerCallback(
+    self: *const Local,
+
+    // Key in identity map
+    // The most specific value (KeyboardEvent, not Event)
+    resolved_ptr_id: usize,
+
+    // The most specific value where finalizers are defined
+    // What actually gets acquired / released / deinit
+    finalizer_ptr_id: usize,
+    deinit: *const fn (ptr_id: usize, session: *Session) void,
+) !*Session.FinalizerCallback {
+    const session = self.ctx.session;
+
+    const arena = try session.getArena(.{ .debug = "FinalizerCallback" });
+    errdefer session.releaseArena(arena);
+
+    const fc = try arena.create(Session.FinalizerCallback);
+    fc.* = .{
+        .arena = arena,
+        .session = session,
+        ._deinit = deinit,
+        .resolved_ptr_id = resolved_ptr_id,
+        .finalizer_ptr_id = finalizer_ptr_id,
+    };
+    return fc;
+}
+
 // Encapsulates a Local and a HandleScope. When we're going from V8->Zig
 // we easily get both a Local and a HandleScope via Caller.init.
 // But when we're going from Zig -> V8, things are more complicated.

src/browser/js/Promise.zig

@@ -67,7 +67,7 @@ fn _persist(self: *const Promise, comptime is_global: bool) !(if (is_global) Glo
         return .{ .handle = global, .temps = {} };
     }
     try ctx.trackTemp(global);
-    return .{ .handle = global, .temps = &ctx.identity.temps };
+    return .{ .handle = global, .temps = &ctx.session.temps };
 }
 
 pub const Temp = G(.temp);

src/browser/js/Value.zig

@@ -245,15 +245,37 @@ pub fn toJson(self: Value, allocator: Allocator) ![]u8 {
     return js.String.toSliceWithAlloc(.{ .local = local, .handle = str_handle }, allocator);
 }
 
-// Currently does not support host objects (Blob, File, etc.) or transferables
-// which require delegate callbacks to be implemented.
+// Throws a DataCloneError for host objects (Blob, File, etc.) that cannot be serialized.
+// Does not support transferables which require additional delegate callbacks.
 pub fn structuredClone(self: Value) !Value {
     const local = self.local;
     const v8_context = local.handle;
     const v8_isolate = local.isolate.handle;
 
+    const SerializerDelegate = struct {
+        // Called when V8 encounters a host object it doesn't know how to serialize.
+        // Returns false to indicate the object cannot be cloned, and throws a DataCloneError.
+        // V8 asserts has_exception() after this returns false, so we must throw here.
+        fn writeHostObject(_: ?*anyopaque, isolate: ?*v8.Isolate, _: ?*const v8.Object) callconv(.c) v8.MaybeBool {
+            const iso = isolate orelse return .{ .has_value = true, .value = false };
+            const message = v8.v8__String__NewFromUtf8(iso, "The object cannot be cloned.", v8.kNormal, -1);
+            const error_value = v8.v8__Exception__Error(message) orelse return .{ .has_value = true, .value = false };
+            _ = v8.v8__Isolate__ThrowException(iso, error_value);
+            return .{ .has_value = true, .value = false };
+        }
+
+        // Called by V8 to report serialization errors. The exception should already be thrown.
+        fn throwDataCloneError(_: ?*anyopaque, _: ?*const v8.String) callconv(.c) void {}
+    };
+
     const size, const data = blk: {
-        const serializer = v8.v8__ValueSerializer__New(v8_isolate, null) orelse return error.JsException;
+        const serializer = v8.v8__ValueSerializer__New(v8_isolate, &.{
+            .data = null,
+            .get_shared_array_buffer_id = null,
+            .write_host_object = SerializerDelegate.writeHostObject,
+            .throw_data_clone_error = SerializerDelegate.throwDataCloneError,
+        }) orelse return error.JsException;
+
         defer v8.v8__ValueSerializer__DELETE(serializer);
 
         var write_result: v8.MaybeBool = undefined;
@@ -303,7 +325,7 @@ fn _persist(self: *const Value, comptime is_global: bool) !(if (is_global) Globa
         return .{ .handle = global, .temps = {} };
     }
     try ctx.trackTemp(global);
-    return .{ .handle = global, .temps = &ctx.identity.temps };
+    return .{ .handle = global, .temps = &ctx.session.temps };
 }
 
 pub fn toZig(self: Value, comptime T: type) !T {

src/browser/js/bridge.zig

@@ -101,33 +101,6 @@ pub fn Builder(comptime T: type) type {
             }
             return entries;
         }
-
-        pub fn finalizer(comptime func: *const fn (self: *T, shutdown: bool, session: *Session) void) Finalizer {
-            return .{
-                .from_zig = struct {
-                    fn wrap(ptr: *anyopaque, session: *Session) void {
-                        func(@ptrCast(@alignCast(ptr)), true, session);
-                    }
-                }.wrap,
-
-                .from_v8 = struct {
-                    fn wrap(handle: ?*const v8.WeakCallbackInfo) callconv(.c) void {
-                        const ptr = v8.v8__WeakCallbackInfo__GetParameter(handle.?).?;
-                        const fc: *Session.FinalizerCallback = @ptrCast(@alignCast(ptr));
-
-                        const value_ptr = fc.ptr;
-                        if (fc.identity.finalizer_callbacks.contains(@intFromPtr(value_ptr))) {
-                            func(@ptrCast(@alignCast(value_ptr)), false, fc.session);
-                            fc.releaseIdentity();
-                        } else {
-                            // A bit weird, but v8 _requires_ that we release it
-                            // If we don't. We'll 100% crash.
-                            v8.v8__Global__Reset(&fc.global);
-                        }
-                    }
-                }.wrap,
-            };
-        }
     };
 }
 
@@ -411,17 +384,6 @@ pub const Property = struct {
     }
 };
 
-const Finalizer = struct {
-    // The finalizer wrapper when called from Zig. This is only called on
-    // Origin.deinit
-    from_zig: *const fn (ctx: *anyopaque, session: *Session) void,
-
-    // The finalizer wrapper when called from V8. This may never be called
-    // (hence why we fallback to calling in Origin.deinit). If it is called,
-    // it is only ever called after we SetWeak on the Global.
-    from_v8: *const fn (?*const v8.WeakCallbackInfo) callconv(.c) void,
-};
-
 pub fn unknownWindowPropertyCallback(c_name: ?*const v8.Name, handle: ?*const v8.PropertyCallbackInfo) callconv(.c) u8 {
     const v8_isolate = v8.v8__PropertyCallbackInfo__GetIsolate(handle).?;
     var caller: Caller = undefined;

src/browser/tests/document/dir_lang.html

@@ -0,0 +1,41 @@
+<html lang="en" dir="ltr">
+<head>
+  <script src="../testing.js"></script>
+</head>
+<body>
+  <script id="test-document-dir-lang">
+    // HTMLElement.dir and HTMLElement.lang
+    testing.expectEqual('ltr', document.documentElement.dir);
+    testing.expectEqual('en', document.documentElement.lang);
+
+    // Document.dir and Document.lang delegate to documentElement
+    testing.expectEqual('ltr', document.dir);
+    testing.expectEqual('en', document.lang);
+
+    // Setting via document updates the documentElement attribute
+    document.dir = 'rtl';
+    testing.expectEqual('rtl', document.documentElement.dir);
+    testing.expectEqual('rtl', document.documentElement.getAttribute('dir'));
+
+    document.lang = 'fr';
+    testing.expectEqual('fr', document.documentElement.lang);
+    testing.expectEqual('fr', document.documentElement.getAttribute('lang'));
+
+    // Setting via element is reflected in document
+    document.documentElement.dir = 'ltr';
+    testing.expectEqual('ltr', document.dir);
+
+    document.documentElement.lang = 'de';
+    testing.expectEqual('de', document.lang);
+
+    // div elements also have dir and lang
+    const div = document.createElement('div');
+    testing.expectEqual('', div.dir);
+    testing.expectEqual('', div.lang);
+    div.dir = 'rtl';
+    div.lang = 'ar';
+    testing.expectEqual('rtl', div.dir);
+    testing.expectEqual('ar', div.lang);
+  </script>
+</body>
+</html>

src/browser/tests/net/url_search_params.html

@@ -20,8 +20,8 @@
 
 <script id=urlSearchParams>
   const inputs = [
-   // @ZIGDOM [["over", "9000!!"], ["abc", 123], ["key1", ""], ["key2", ""]],
-   {over: "9000!!", abc: 123, key1: "", key2: ""},
+    [["over", "9000!!"], ["abc", "123"], ["key1", ""], ["key2", ""]],
+    {over: "9000!!", abc: 123, key1: "", key2: ""},
     "over=9000!!&abc=123&key1&key2=",
     "?over=9000!!&abc=123&key1&key2=",
   ]
@@ -367,3 +367,49 @@
     testing.expectEqual(['3'], ups.getAll('b'));
   }
 </script>
+
+<script id=arrayOfArrays>
+{
+  const usp = new URLSearchParams([["a", "1"], ["b", "2"], ["a", "3"]]);
+  testing.expectEqual(3, usp.size);
+  testing.expectEqual('1', usp.get('a'));
+  testing.expectEqual(['1', '3'], usp.getAll('a'));
+  testing.expectEqual('2', usp.get('b'));
+  testing.expectEqual('a=1&b=2&a=3', usp.toString());
+}
+</script>
+
+<script id=arrayOfArraysEmpty>
+{
+  const usp = new URLSearchParams([]);
+  testing.expectEqual(0, usp.size);
+  testing.expectEqual('', usp.toString());
+}
+</script>
+
+<script id=arrayOfArraysDuplicateKeys>
+{
+  const usp = new URLSearchParams([["key", "first"], ["key", "second"], ["key", "third"]]);
+  testing.expectEqual(3, usp.size);
+  testing.expectEqual('first', usp.get('key'));
+  testing.expectEqual(['first', 'second', 'third'], usp.getAll('key'));
+}
+</script>
+
+<script id=arrayOfArraysSpecialChars>
+{
+  const usp = new URLSearchParams([["q", "hello world"], ["url", "https://example.com/?a=1&b=2"]]);
+  testing.expectEqual(2, usp.size);
+  testing.expectEqual('hello world', usp.get('q'));
+  testing.expectEqual('https://example.com/?a=1&b=2', usp.get('url'));
+}
+</script>
+
+<script id=arrayOfArraysNumericValues>
+{
+  const usp = new URLSearchParams([["count", 42], ["pi", 3.14]]);
+  testing.expectEqual(2, usp.size);
+  testing.expectEqual('42', usp.get('count'));
+  testing.expectEqual('3.14', usp.get('pi'));
+}
+</script>

src/browser/tests/runner/runner1.html

@@ -0,0 +1,4 @@
+<!DOCTYPE html>
+<meta charset="UTF-8">
+<div id=sel0>selector-0-content</div>
+<div id=sel1>selector-1-content</div>

src/browser/tests/window/window.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <script src="../testing.js"></script>
+<body></body>
 
 <script id=window>
   testing.expectEqual(window, globalThis);
@@ -260,6 +261,28 @@
     }
     testing.expectEqual(true, threw);
   }
+
+  // Host objects (DOM elements) cannot be cloned - should throw, not crash
+  {
+    let threw = false;
+    try {
+      structuredClone(document.body);
+    } catch (err) {
+      threw = true;
+    }
+    testing.expectEqual(true, threw);
+  }
+
+  // Objects containing host objects cannot be cloned - should throw, not crash
+  {
+    let threw = false;
+    try {
+      structuredClone({ element: document.body });
+    } catch (err) {
+      threw = true;
+    }
+    testing.expectEqual(true, threw);
+  }
 </script>
 
 <script id=cached_getter_wrong_this>

src/browser/webapi/AbstractRange.zig

@@ -17,6 +17,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
+
 const js = @import("../js/js.zig");
 
 const Session = @import("../Session.zig");
@@ -31,7 +33,7 @@ const AbstractRange = @This();
 
 pub const _prototype_root = true;
 
-_rc: u8,
+_rc: lp.RC(u8) = .{},
 _type: Type,
 _page_id: u32,
 _arena: Allocator,
@@ -44,24 +46,18 @@ _start_container: *Node,
 _range_link: std.DoublyLinkedList.Node = .{},
 
 pub fn acquireRef(self: *AbstractRange) void {
-    self._rc += 1;
+    self._rc.acquire();
 }
 
-pub fn deinit(self: *AbstractRange, shutdown: bool, session: *Session) void {
-    _ = shutdown;
-    const rc = self._rc;
-    if (comptime IS_DEBUG) {
-        std.debug.assert(rc != 0);
+pub fn deinit(self: *AbstractRange, session: *Session) void {
+    if (session.findPageById(self._page_id)) |page| {
+        page._live_ranges.remove(&self._range_link);
     }
+    session.releaseArena(self._arena);
+}
 
-    if (rc == 1) {
-        if (session.findPageById(self._page_id)) |page| {
-            page._live_ranges.remove(&self._range_link);
-        }
-        session.releaseArena(self._arena);
-        return;
-    }
-    self._rc = rc - 1;
+pub fn releaseRef(self: *AbstractRange, session: *Session) void {
+    self._rc.release(self, session);
 }
 
 pub const Type = union(enum) {
@@ -338,8 +334,6 @@ pub const JsApi = struct {
         pub const name = "AbstractRange";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(AbstractRange.deinit);
     };
 
     pub const startContainer = bridge.accessor(AbstractRange.getStartContainer, null, .{});

src/browser/webapi/Blob.zig

@@ -17,7 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
-const Writer = std.Io.Writer;
+const lp = @import("lightpanda");
 
 const js = @import("../js/js.zig");
 const Page = @import("../Page.zig");
@@ -25,6 +25,7 @@ const Session = @import("../Session.zig");
 
 const Mime = @import("../Mime.zig");
 
+const Writer = std.Io.Writer;
 const Allocator = std.mem.Allocator;
 
 /// https://w3c.github.io/FileAPI/#blob-section
@@ -34,6 +35,7 @@ const Blob = @This();
 pub const _prototype_root = true;
 
 _type: Type,
+_rc: lp.RC(u32),
 
 _arena: Allocator,
 
@@ -120,6 +122,7 @@ pub fn initWithMimeValidation(
 
     const self = try arena.create(Blob);
     self.* = .{
+        ._rc = .{},
         ._arena = arena,
         ._type = .generic,
         ._slice = data,
@@ -128,11 +131,18 @@ pub fn initWithMimeValidation(
     return self;
 }
 
-pub fn deinit(self: *Blob, shutdown: bool, session: *Session) void {
-    _ = shutdown;
+pub fn deinit(self: *Blob, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *Blob, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *Blob) void {
+    self._rc.acquire();
+}
+
 const largest_vector = @max(std.simd.suggestVectorLength(u8) orelse 1, 8);
 /// Array of possible vector sizes for the current arch in decrementing order.
 /// We may move this to some file for SIMD helpers in the future.
@@ -325,8 +335,6 @@ pub const JsApi = struct {
         pub const name = "Blob";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(Blob.deinit);
     };
 
     pub const constructor = bridge.constructor(Blob.init, .{});

src/browser/webapi/Document.zig

@@ -61,7 +61,7 @@ _fonts: ?*FontFaceSet = null,
 _write_insertion_point: ?*Node = null,
 _script_created_parser: ?Parser.Streaming = null,
 _adopted_style_sheets: ?js.Object.Global = null,
-_selection: Selection = .init,
+_selection: Selection = .{ ._rc = .init(1) },
 
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#throw-on-dynamic-markup-insertion-counter
 // Incremented during custom element reactions when parsing. When > 0,

src/browser/webapi/Event.zig

@@ -17,6 +17,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
+
 const js = @import("../js/js.zig");
 
 const Page = @import("../Page.zig");
@@ -55,7 +57,7 @@ _is_trusted: bool = false,
 // - 0: no reference, always a transient state going to either 1 or about to be deinit'd
 // - 1: either zig or v8 have a reference
 // - 2: both zig and v8 have a reference
-_rc: u8 = 0,
+_rc: lp.RC(u8) = .{},
 
 pub const EventPhase = enum(u8) {
     none = 0,
@@ -139,25 +141,16 @@ pub fn initEvent(
 }
 
 pub fn acquireRef(self: *Event) void {
-    self._rc += 1;
+    self._rc.acquire();
 }
 
-pub fn deinit(self: *Event, shutdown: bool, session: *Session) void {
-    if (shutdown) {
-        session.releaseArena(self._arena);
-        return;
-    }
+/// Force cleanup on Session shutdown.
+pub fn deinit(self: *Event, session: *Session) void {
+    session.releaseArena(self._arena);
+}
 
-    const rc = self._rc;
-    if (comptime IS_DEBUG) {
-        std.debug.assert(rc != 0);
-    }
-
-    if (rc == 1) {
-        session.releaseArena(self._arena);
-    } else {
-        self._rc = rc - 1;
-    }
+pub fn releaseRef(self: *Event, session: *Session) void {
+    self._rc.release(self, session);
 }
 
 pub fn as(self: *Event, comptime T: type) *T {
@@ -440,8 +433,6 @@ pub const JsApi = struct {
 
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(Event.deinit);
         pub const enumerable = false;
     };
 

src/browser/webapi/EventTarget.zig

@@ -60,7 +60,7 @@ pub fn dispatchEvent(self: *EventTarget, event: *Event, page: *Page) !bool {
     event._is_trusted = false;
 
     event.acquireRef();
-    defer event.deinit(false, page._session);
+    defer _ = event.releaseRef(page._session);
     try page._event_manager.dispatch(self, event);
     return !event._cancelable or !event._prevent_default;
 }

src/browser/webapi/File.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 
 const js = @import("../js/js.zig");
 const Page = @import("../Page.zig");
@@ -26,7 +27,6 @@ const Blob = @import("Blob.zig");
 
 const File = @This();
 
-/// `File` inherits `Blob`.
 _proto: *Blob,
 
 // TODO: Implement File API.
@@ -36,10 +36,6 @@ pub fn init(page: *Page) !*File {
     return page._factory.blob(arena, File{ ._proto = undefined });
 }
 
-pub fn deinit(self: *File, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub const JsApi = struct {
     pub const bridge = js.Bridge(File);
 
@@ -47,8 +43,6 @@ pub const JsApi = struct {
         pub const name = "File";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(File.deinit);
     };
 
     pub const constructor = bridge.constructor(File.init, .{});

src/browser/webapi/FileReader.zig

@@ -17,6 +17,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
+
 const js = @import("../js/js.zig");
 
 const Page = @import("../Page.zig");
@@ -31,6 +33,7 @@ const Allocator = std.mem.Allocator;
 /// https://developer.mozilla.org/en-US/docs/Web/API/FileReader
 const FileReader = @This();
 
+_rc: lp.RC(u8) = .{},
 _page: *Page,
 _proto: *EventTarget,
 _arena: Allocator,
@@ -70,7 +73,7 @@ pub fn init(page: *Page) !*FileReader {
     });
 }
 
-pub fn deinit(self: *FileReader, _: bool, session: *Session) void {
+pub fn deinit(self: *FileReader, session: *Session) void {
     if (self._on_abort) |func| func.release();
     if (self._on_error) |func| func.release();
     if (self._on_load) |func| func.release();
@@ -81,6 +84,14 @@ pub fn deinit(self: *FileReader, _: bool, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *FileReader, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *FileReader) void {
+    self._rc.acquire();
+}
+
 fn asEventTarget(self: *FileReader) *EventTarget {
     return self._proto;
 }
@@ -309,8 +320,6 @@ pub const JsApi = struct {
         pub const name = "FileReader";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(FileReader.deinit);
     };
 
     pub const constructor = bridge.constructor(FileReader.init, .{});

src/browser/webapi/HTMLDocument.zig

@@ -182,6 +182,30 @@ pub fn setLocation(self: *HTMLDocument, url: [:0]const u8, page: *Page) !void {
     return page.scheduleNavigation(url, .{ .reason = .script, .kind = .{ .push = null } }, .{ .script = self._proto._page });
 }
 
+pub fn getDir(self: *HTMLDocument) []const u8 {
+    const el = self._proto.getDocumentElement() orelse return "";
+    const html = el.is(Element.Html) orelse return "";
+    return html.getDir();
+}
+
+pub fn setDir(self: *HTMLDocument, value: []const u8, page: *Page) !void {
+    const el = self._proto.getDocumentElement() orelse return;
+    const html = el.is(Element.Html) orelse return;
+    try html.setDir(value, page);
+}
+
+pub fn getLang(self: *HTMLDocument) []const u8 {
+    const el = self._proto.getDocumentElement() orelse return "";
+    const html = el.is(Element.Html) orelse return "";
+    return html.getLang();
+}
+
+pub fn setLang(self: *HTMLDocument, value: []const u8, page: *Page) !void {
+    const el = self._proto.getDocumentElement() orelse return;
+    const html = el.is(Element.Html) orelse return;
+    try html.setLang(value, page);
+}
+
 pub fn getAll(self: *HTMLDocument, page: *Page) !*collections.HTMLAllCollection {
     return page._factory.create(collections.HTMLAllCollection.init(self.asNode(), page));
 }
@@ -250,8 +274,10 @@ pub const JsApi = struct {
         });
     }
 
+    pub const dir = bridge.accessor(HTMLDocument.getDir, HTMLDocument.setDir, .{});
     pub const head = bridge.accessor(HTMLDocument.getHead, null, .{});
     pub const body = bridge.accessor(HTMLDocument.getBody, null, .{});
+    pub const lang = bridge.accessor(HTMLDocument.getLang, HTMLDocument.setLang, .{});
     pub const title = bridge.accessor(HTMLDocument.getTitle, HTMLDocument.setTitle, .{});
     pub const images = bridge.accessor(HTMLDocument.getImages, null, .{});
     pub const scripts = bridge.accessor(HTMLDocument.getScripts, null, .{});

src/browser/webapi/IntersectionObserver.zig

@@ -16,6 +16,8 @@
 // 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 js = @import("../js/js.zig");
 const log = @import("../../log.zig");
 
@@ -39,6 +41,7 @@ pub fn registerTypes() []const type {
 
 const IntersectionObserver = @This();
 
+_rc: lp.RC(u8) = .{},
 _arena: Allocator,
 _callback: js.Function.Temp,
 _observing: std.ArrayList(*Element) = .{},
@@ -108,15 +111,22 @@ pub fn init(callback: js.Function.Temp, options: ?ObserverInit, page: *Page) !*I
     return self;
 }
 
-pub fn deinit(self: *IntersectionObserver, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *IntersectionObserver, session: *Session) void {
     self._callback.release();
-    if ((comptime IS_DEBUG) and !shutdown) {
-        std.debug.assert(self._observing.items.len == 0);
+    for (self._pending_entries.items) |entry| {
+        entry.deinitIfUnused(session);
     }
-
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *IntersectionObserver, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *IntersectionObserver) void {
+    self._rc.acquire();
+}
+
 pub fn observe(self: *IntersectionObserver, target: *Element, page: *Page) !void {
     // Check if already observing this target
     for (self._observing.items) |elem| {
@@ -127,7 +137,7 @@ pub fn observe(self: *IntersectionObserver, target: *Element, page: *Page) !void
 
     // Register with page if this is our first observation
     if (self._observing.items.len == 0) {
-        page.js.strongRef(self);
+        self._rc._refs += 1;
         try page.registerIntersectionObserver(self);
     }
 
@@ -144,17 +154,19 @@ pub fn observe(self: *IntersectionObserver, target: *Element, page: *Page) !void
 }
 
 pub fn unobserve(self: *IntersectionObserver, target: *Element, page: *Page) void {
+    const original_length = self._observing.items.len;
     for (self._observing.items, 0..) |elem, i| {
         if (elem == target) {
             _ = self._observing.swapRemove(i);
             _ = self._previous_states.remove(target);
 
-            // Remove any pending entries for this target
+            // Remove any pending entries for this target.
+            // Entries will be cleaned up by V8 GC via the finalizer.
             var j: usize = 0;
             while (j < self._pending_entries.items.len) {
                 if (self._pending_entries.items[j]._target == target) {
                     const entry = self._pending_entries.swapRemove(j);
-                    entry.deinit(false, page._session);
+                    entry.deinitIfUnused(page._session);
                 } else {
                     j += 1;
                 }
@@ -163,21 +175,26 @@ pub fn unobserve(self: *IntersectionObserver, target: *Element, page: *Page) voi
         }
     }
 
-    if (self._observing.items.len == 0) {
-        page.js.safeWeakRef(self);
+    if (original_length > 0 and self._observing.items.len == 0) {
+        self._rc._refs -= 1;
     }
 }
 
 pub fn disconnect(self: *IntersectionObserver, page: *Page) void {
-    page.unregisterIntersectionObserver(self);
-    self._observing.clearRetainingCapacity();
-    self._previous_states.clearRetainingCapacity();
-
     for (self._pending_entries.items) |entry| {
-        entry.deinit(false, page._session);
+        entry.deinitIfUnused(page._session);
     }
     self._pending_entries.clearRetainingCapacity();
-    page.js.safeWeakRef(self);
+    self._previous_states.clearRetainingCapacity();
+
+    const observing_count = self._observing.items.len;
+    self._observing.clearRetainingCapacity();
+
+    page.unregisterIntersectionObserver(self);
+
+    if (observing_count > 0) {
+        _ = self.releaseRef(page._session);
+    }
 }
 
 pub fn takeRecords(self: *IntersectionObserver, page: *Page) ![]*IntersectionObserverEntry {
@@ -268,7 +285,6 @@ fn checkIntersection(self: *IntersectionObserver, target: *Element, page: *Page)
             ._bounding_client_rect = try page._factory.create(data.bounding_client_rect),
             ._intersection_ratio = data.intersection_ratio,
         };
-
         try self._pending_entries.append(self._arena, entry);
     }
 
@@ -310,6 +326,7 @@ pub fn deliverEntries(self: *IntersectionObserver, page: *Page) !void {
 }
 
 pub const IntersectionObserverEntry = struct {
+    _rc: lp.RC(u8) = .{},
     _arena: Allocator,
     _time: f64,
     _target: *Element,
@@ -319,10 +336,25 @@ pub const IntersectionObserverEntry = struct {
     _intersection_ratio: f64,
     _is_intersecting: bool,
 
-    pub fn deinit(self: *IntersectionObserverEntry, _: bool, session: *Session) void {
+    pub fn deinit(self: *IntersectionObserverEntry, session: *Session) void {
         session.releaseArena(self._arena);
     }
 
+    fn deinitIfUnused(self: *IntersectionObserverEntry, session: *Session) void {
+        if (self._rc._refs == 0) {
+            // hasn't been handed to JS yet.
+            self.deinit(session);
+        }
+    }
+
+    pub fn releaseRef(self: *IntersectionObserverEntry, session: *Session) void {
+        self._rc.release(self, session);
+    }
+
+    pub fn acquireRef(self: *IntersectionObserverEntry) void {
+        self._rc.acquire();
+    }
+
     pub fn getTarget(self: *const IntersectionObserverEntry) *Element {
         return self._target;
     }
@@ -358,8 +390,6 @@ pub const IntersectionObserverEntry = struct {
             pub const name = "IntersectionObserverEntry";
             pub const prototype_chain = bridge.prototypeChain();
             pub var class_id: bridge.ClassId = undefined;
-            pub const weak = true;
-            pub const finalizer = bridge.finalizer(IntersectionObserverEntry.deinit);
         };
 
         pub const target = bridge.accessor(IntersectionObserverEntry.getTarget, null, .{});
@@ -379,8 +409,6 @@ pub const JsApi = struct {
         pub const name = "IntersectionObserver";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(IntersectionObserver.deinit);
     };
 
     pub const constructor = bridge.constructor(init, .{});

src/browser/webapi/MutationObserver.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const String = @import("../../string.zig").String;
 
 const js = @import("../js/js.zig");
@@ -39,6 +40,7 @@ pub fn registerTypes() []const type {
 
 const MutationObserver = @This();
 
+_rc: lp.RC(u8) = .{},
 _arena: Allocator,
 _callback: js.Function.Temp,
 _observing: std.ArrayList(Observing) = .{},
@@ -85,15 +87,20 @@ pub fn init(callback: js.Function.Temp, page: *Page) !*MutationObserver {
     return self;
 }
 
-pub fn deinit(self: *MutationObserver, shutdown: bool, session: *Session) void {
+/// Force cleanup on Session shutdown.
+pub fn deinit(self: *MutationObserver, session: *Session) void {
     self._callback.release();
-    if ((comptime IS_DEBUG) and !shutdown) {
-        std.debug.assert(self._observing.items.len == 0);
-    }
-
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *MutationObserver, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *MutationObserver) void {
+    self._rc.acquire();
+}
+
 pub fn observe(self: *MutationObserver, target: *Node, options: ObserveOptions, page: *Page) !void {
     const arena = self._arena;
 
@@ -158,7 +165,7 @@ pub fn observe(self: *MutationObserver, target: *Node, options: ObserveOptions,
 
     // Register with page if this is our first observation
     if (self._observing.items.len == 0) {
-        page.js.strongRef(self);
+        self._rc._refs += 1;
         try page.registerMutationObserver(self);
     }
 
@@ -169,13 +176,17 @@ pub fn observe(self: *MutationObserver, target: *Node, options: ObserveOptions,
 }
 
 pub fn disconnect(self: *MutationObserver, page: *Page) void {
-    page.unregisterMutationObserver(self);
-    self._observing.clearRetainingCapacity();
     for (self._pending_records.items) |record| {
-        record.deinit(false, page._session);
+        _ = record.releaseRef(page._session);
     }
     self._pending_records.clearRetainingCapacity();
-    page.js.safeWeakRef(self);
+    const observing_count = self._observing.items.len;
+    self._observing.clearRetainingCapacity();
+
+    if (observing_count > 0) {
+        _ = self.releaseRef(page._session);
+    }
+    page.unregisterMutationObserver(self);
 }
 
 pub fn takeRecords(self: *MutationObserver, page: *Page) ![]*MutationRecord {
@@ -348,6 +359,7 @@ pub fn deliverRecords(self: *MutationObserver, page: *Page) !void {
 }
 
 pub const MutationRecord = struct {
+    _rc: lp.RC(u8) = .{},
     _type: Type,
     _target: *Node,
     _arena: Allocator,
@@ -364,10 +376,18 @@ pub const MutationRecord = struct {
         characterData,
     };
 
-    pub fn deinit(self: *MutationRecord, _: bool, session: *Session) void {
+    pub fn deinit(self: *MutationRecord, session: *Session) void {
         session.releaseArena(self._arena);
     }
 
+    pub fn releaseRef(self: *MutationRecord, session: *Session) void {
+        self._rc.release(self, session);
+    }
+
+    pub fn acquireRef(self: *MutationRecord) void {
+        self._rc.acquire();
+    }
+
     pub fn getType(self: *const MutationRecord) []const u8 {
         return switch (self._type) {
             .attributes => "attributes",
@@ -418,8 +438,6 @@ pub const MutationRecord = struct {
             pub const name = "MutationRecord";
             pub const prototype_chain = bridge.prototypeChain();
             pub var class_id: bridge.ClassId = undefined;
-            pub const weak = true;
-            pub const finalizer = bridge.finalizer(MutationRecord.deinit);
         };
 
         pub const @"type" = bridge.accessor(MutationRecord.getType, null, .{});
@@ -441,8 +459,6 @@ pub const JsApi = struct {
         pub const name = "MutationObserver";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(MutationObserver.deinit);
     };
 
     pub const constructor = bridge.constructor(MutationObserver.init, .{});

src/browser/webapi/Permissions.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../js/js.zig");
 const Page = @import("../Page.zig");
 const Session = @import("../Session.zig");
@@ -50,14 +51,23 @@ pub fn query(_: *const Permissions, qd: QueryDescriptor, page: *Page) !js.Promis
 }
 
 const PermissionStatus = struct {
+    _rc: lp.RC(u8) = .{},
     _arena: Allocator,
     _name: []const u8,
     _state: []const u8,
 
-    pub fn deinit(self: *PermissionStatus, _: bool, session: *Session) void {
+    pub fn deinit(self: *PermissionStatus, session: *Session) void {
         session.releaseArena(self._arena);
     }
 
+    pub fn releaseRef(self: *PermissionStatus, session: *Session) void {
+        self._rc.release(self, session);
+    }
+
+    pub fn acquireRef(self: *PermissionStatus) void {
+        self._rc.acquire();
+    }
+
     fn getName(self: *const PermissionStatus) []const u8 {
         return self._name;
     }
@@ -72,8 +82,6 @@ const PermissionStatus = struct {
             pub const name = "PermissionStatus";
             pub const prototype_chain = bridge.prototypeChain();
             pub var class_id: bridge.ClassId = undefined;
-            pub const weak = true;
-            pub const finalizer = bridge.finalizer(PermissionStatus.deinit);
         };
         pub const name = bridge.accessor(getName, null, .{});
         pub const state = bridge.accessor(getState, null, .{});

src/browser/webapi/Range.zig

@@ -38,10 +38,6 @@ pub fn init(page: *Page) !*Range {
     return page._factory.abstractRange(arena, Range{ ._proto = undefined }, page);
 }
 
-pub fn deinit(self: *Range, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asAbstractRange(self: *Range) *AbstractRange {
     return self._proto;
 }
@@ -697,8 +693,6 @@ pub const JsApi = struct {
         pub const name = "Range";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(Range.deinit);
     };
 
     // Constants for compareBoundaryPoints

src/browser/webapi/Selection.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 
 const js = @import("../js/js.zig");
 const Page = @import("../Page.zig");
@@ -32,18 +33,27 @@ const Selection = @This();
 
 pub const SelectionDirection = enum { backward, forward, none };
 
+_rc: lp.RC(u8) = .{},
 _range: ?*Range = null,
 _direction: SelectionDirection = .none,
 
 pub const init: Selection = .{};
 
-pub fn deinit(self: *Selection, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *Selection, session: *Session) void {
     if (self._range) |r| {
-        r.deinit(shutdown, session);
+        r.asAbstractRange().releaseRef(session);
         self._range = null;
     }
 }
 
+pub fn releaseRef(self: *Selection, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *Selection) void {
+    self._rc.acquire();
+}
+
 fn dispatchSelectionChangeEvent(page: *Page) !void {
     const event = try Event.init("selectionchange", .{}, page);
     try page._event_manager.dispatch(page.document.asEventTarget(), event);
@@ -693,7 +703,7 @@ pub fn toString(self: *const Selection, page: *Page) ![]const u8 {
 
 fn setRange(self: *Selection, new_range: ?*Range, page: *Page) void {
     if (self._range) |existing| {
-        existing.deinit(false, page._session);
+        _ = existing.asAbstractRange().releaseRef(page._session);
     }
     if (new_range) |nr| {
         nr.asAbstractRange().acquireRef();
@@ -708,7 +718,6 @@ pub const JsApi = struct {
         pub const name = "Selection";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const finalizer = bridge.finalizer(Selection.deinit);
     };
 
     pub const anchorNode = bridge.accessor(Selection.getAnchorNode, null, .{});

src/browser/webapi/URL.zig

@@ -256,8 +256,7 @@ pub fn createObjectURL(blob: *Blob, page: *Page) ![]const u8 {
         .{ page.origin orelse "null", uuid_buf },
     );
     try page._blob_urls.put(page.arena, blob_url, blob);
-    // prevent GC from cleaning up the blob while it's in the registry
-    page.js.strongRef(blob);
+    blob.acquireRef();
     return blob_url;
 }
 
@@ -267,9 +266,8 @@ pub fn revokeObjectURL(url: []const u8, page: *Page) void {
         return;
     }
 
-    // Remove from registry and release strong ref (no-op if not found)
     if (page._blob_urls.fetchRemove(url)) |entry| {
-        page.js.weakRef(entry.value);
+        entry.value.releaseRef(page._session);
     }
 }
 

src/browser/webapi/animation/Animation.zig

@@ -17,6 +17,7 @@
 // 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 js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
@@ -33,6 +34,7 @@ const PlayState = enum {
     finished,
 };
 
+_rc: lp.RC(u32) = .{},
 _page: *Page,
 _arena: Allocator,
 
@@ -62,10 +64,18 @@ pub fn init(page: *Page) !*Animation {
     return self;
 }
 
-pub fn deinit(self: *Animation, _: bool, session: *Session) void {
+pub fn deinit(self: *Animation, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *Animation, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *Animation) void {
+    self._rc.acquire();
+}
+
 pub fn play(self: *Animation, page: *Page) !void {
     if (self._playState == .running) {
         return;
@@ -75,7 +85,7 @@ pub fn play(self: *Animation, page: *Page) !void {
     self._playState = .running;
 
     // Schedule the transition from .running => .finished in 10ms.
-    page.js.strongRef(self);
+    self.acquireRef();
     try page.js.scheduler.add(
         self,
         Animation.update,
@@ -201,7 +211,7 @@ fn update(ctx: *anyopaque) !?u32 {
     }
 
     // No future change scheduled, set the object weak for garbage collection.
-    self._page.js.weakRef(self);
+    self.releaseRef(self._page._session);
     return null;
 }
 
@@ -220,8 +230,6 @@ pub const JsApi = struct {
         pub const name = "Animation";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(Animation.deinit);
     };
 
     pub const play = bridge.function(Animation.play, .{});

src/browser/webapi/collections/NodeList.zig

@@ -17,6 +17,7 @@
 // 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 js = @import("../../js/js.zig");
@@ -37,15 +38,9 @@ _data: union(enum) {
     radio_node_list: *RadioNodeList,
     name: NodeLive(.name),
 },
-_rc: usize = 0,
-
-pub fn deinit(self: *NodeList, _: bool, session: *Session) void {
-    const rc = self._rc;
-    if (rc > 1) {
-        self._rc = rc - 1;
-        return;
-    }
+_rc: lp.RC(u32) = .{},
 
+pub fn deinit(self: *NodeList, session: *Session) void {
     switch (self._data) {
         .selector_list => |list| list.deinit(session),
         .child_nodes => |cn| cn.deinit(session),
@@ -53,8 +48,12 @@ pub fn deinit(self: *NodeList, _: bool, session: *Session) void {
     }
 }
 
+pub fn releaseRef(self: *NodeList, session: *Session) void {
+    self._rc.release(self, session);
+}
+
 pub fn acquireRef(self: *NodeList) void {
-    self._rc += 1;
+    self._rc.acquire();
 }
 
 pub fn length(self: *NodeList, page: *Page) !u32 {
@@ -119,8 +118,12 @@ const Iterator = struct {
 
     const Entry = struct { u32, *Node };
 
-    pub fn deinit(self: *Iterator, shutdown: bool, session: *Session) void {
-        self.list.deinit(shutdown, session);
+    pub fn deinit(self: *Iterator, session: *Session) void {
+        self.list.deinit(session);
+    }
+
+    pub fn releaseRef(self: *Iterator, session: *Session) void {
+        self.list.releaseRef(session);
     }
 
     pub fn acquireRef(self: *Iterator) void {
@@ -143,8 +146,6 @@ pub const JsApi = struct {
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
         pub const enumerable = false;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(NodeList.deinit);
     };
 
     pub const length = bridge.accessor(NodeList.length, null, .{});

src/browser/webapi/collections/iterator.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
 const Session = @import("../../Session.zig");
@@ -40,9 +41,15 @@ pub fn Entry(comptime Inner: type, comptime field: ?[]const u8) type {
             return page._factory.create(Self{ .inner = inner });
         }
 
-        pub fn deinit(self: *Self, shutdown: bool, session: *Session) void {
-            if (@hasDecl(Inner, "deinit")) {
-                self.inner.deinit(shutdown, session);
+        pub fn deinit(self: *Self, session: *Session) void {
+            _ = self;
+            _ = session;
+        }
+
+        pub fn releaseRef(self: *Self, session: *Session) void {
+            // Release the reference to the inner type that we acquired
+            if (@hasDecl(Inner, "releaseRef")) {
+                self.inner.releaseRef(session);
             }
         }
 
@@ -73,8 +80,6 @@ pub fn Entry(comptime Inner: type, comptime field: ?[]const u8) type {
             pub const Meta = struct {
                 pub const prototype_chain = bridge.prototypeChain();
                 pub var class_id: bridge.ClassId = undefined;
-                pub const weak = true;
-                pub const finalizer = bridge.finalizer(Self.deinit);
             };
 
             pub const next = bridge.function(Self.next, .{ .null_as_undefined = true });

src/browser/webapi/css/FontFace.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
 const Session = @import("../../Session.zig");
@@ -25,6 +26,7 @@ const Allocator = std.mem.Allocator;
 
 const FontFace = @This();
 
+_rc: lp.RC(u8) = .{},
 _arena: Allocator,
 _family: []const u8,
 
@@ -42,10 +44,18 @@ pub fn init(family: []const u8, source: []const u8, page: *Page) !*FontFace {
     return self;
 }
 
-pub fn deinit(self: *FontFace, _: bool, session: *Session) void {
+pub fn deinit(self: *FontFace, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *FontFace, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *FontFace) void {
+    self._rc.acquire();
+}
+
 pub fn getFamily(self: *const FontFace) []const u8 {
     return self._family;
 }
@@ -67,8 +77,6 @@ pub const JsApi = struct {
         pub const name = "FontFace";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(FontFace.deinit);
     };
 
     pub const constructor = bridge.constructor(FontFace.init, .{});

src/browser/webapi/css/FontFaceSet.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
 const Session = @import("../../Session.zig");
@@ -28,6 +29,7 @@ const Allocator = std.mem.Allocator;
 
 const FontFaceSet = @This();
 
+_rc: lp.RC(u8) = .{},
 _proto: *EventTarget,
 _arena: Allocator,
 
@@ -41,10 +43,18 @@ pub fn init(page: *Page) !*FontFaceSet {
     });
 }
 
-pub fn deinit(self: *FontFaceSet, _: bool, session: *Session) void {
+pub fn deinit(self: *FontFaceSet, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *FontFaceSet, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *FontFaceSet) void {
+    self._rc.acquire();
+}
+
 pub fn asEventTarget(self: *FontFaceSet) *EventTarget {
     return self._proto;
 }
@@ -95,8 +105,6 @@ pub const JsApi = struct {
         pub const name = "FontFaceSet";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(FontFaceSet.deinit);
     };
 
     pub const size = bridge.property(0, .{ .template = false, .readonly = true });

src/browser/webapi/element/Attribute.zig

@@ -26,6 +26,8 @@ const GenericIterator = @import("../collections/iterator.zig").Entry;
 const Page = @import("../../Page.zig");
 const String = @import("../../../string.zig").String;
 
+const Allocator = std.mem.Allocator;
+
 const IS_DEBUG = @import("builtin").mode == .Debug;
 
 pub fn registerTypes() []const type {
@@ -419,7 +421,7 @@ pub fn validateAttributeName(name: String) !void {
     }
 }
 
-pub fn normalizeNameForLookup(name: String, page: *Page) !String {
+fn normalizeNameForLookup(name: String, page: *Page) !String {
     if (!needsLowerCasing(name.str())) {
         return name;
     }
@@ -431,6 +433,14 @@ pub fn normalizeNameForLookup(name: String, page: *Page) !String {
     return .wrap(normalized);
 }
 
+pub fn normalizeNameForLookupAlloc(allocator: Allocator, name: String) !String {
+    if (!needsLowerCasing(name.str())) {
+        return name.dupe(allocator);
+    }
+    const normalized = try std.ascii.allocLowerString(allocator, name.str());
+    return .wrap(normalized);
+}
+
 fn needsLowerCasing(name: []const u8) bool {
     var remaining = name;
     if (comptime std.simd.suggestVectorLength(u8)) |vector_len| {

src/browser/webapi/element/Html.zig

@@ -375,6 +375,22 @@ pub fn setTabIndex(self: *HtmlElement, value: i32, page: *Page) !void {
     try self.asElement().setAttributeSafe(comptime .wrap("tabindex"), .wrap(str), page);
 }
 
+pub fn getDir(self: *HtmlElement) []const u8 {
+    return self.asElement().getAttributeSafe(comptime .wrap("dir")) orelse "";
+}
+
+pub fn setDir(self: *HtmlElement, value: []const u8, page: *Page) !void {
+    try self.asElement().setAttributeSafe(comptime .wrap("dir"), .wrap(value), page);
+}
+
+pub fn getLang(self: *HtmlElement) []const u8 {
+    return self.asElement().getAttributeSafe(comptime .wrap("lang")) orelse "";
+}
+
+pub fn setLang(self: *HtmlElement, value: []const u8, page: *Page) !void {
+    try self.asElement().setAttributeSafe(comptime .wrap("lang"), .wrap(value), page);
+}
+
 pub fn getAttributeFunction(
     self: *HtmlElement,
     listener_type: GlobalEventHandler,
@@ -1211,7 +1227,9 @@ pub const JsApi = struct {
     pub const insertAdjacentHTML = bridge.function(HtmlElement.insertAdjacentHTML, .{ .dom_exception = true });
     pub const click = bridge.function(HtmlElement.click, .{});
 
+    pub const dir = bridge.accessor(HtmlElement.getDir, HtmlElement.setDir, .{});
     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 onabort = bridge.accessor(HtmlElement.getOnAbort, HtmlElement.setOnAbort, .{});

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 });

src/browser/webapi/encoding/TextDecoder.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../../js/js.zig");
 
 const Page = @import("../../Page.zig");
@@ -25,6 +26,7 @@ const Allocator = std.mem.Allocator;
 
 const TextDecoder = @This();
 
+_rc: lp.RC(u8) = .{},
 _fatal: bool,
 _arena: Allocator,
 _ignore_bom: bool,
@@ -60,10 +62,18 @@ pub fn init(label_: ?[]const u8, opts_: ?InitOpts, page: *Page) !*TextDecoder {
     return self;
 }
 
-pub fn deinit(self: *TextDecoder, _: bool, session: *Session) void {
+pub fn deinit(self: *TextDecoder, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *TextDecoder, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *TextDecoder) void {
+    self._rc.acquire();
+}
+
 pub fn getIgnoreBOM(self: *const TextDecoder) bool {
     return self._ignore_bom;
 }
@@ -109,8 +119,6 @@ pub const JsApi = struct {
         pub const name = "TextDecoder";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(TextDecoder.deinit);
     };
 
     pub const constructor = bridge.constructor(TextDecoder.init, .{});

src/browser/webapi/event/CompositionEvent.zig

@@ -53,10 +53,6 @@ pub fn init(typ: []const u8, opts_: ?Options, page: *Page) !*CompositionEvent {
     return event;
 }
 
-pub fn deinit(self: *CompositionEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *CompositionEvent) *Event {
     return self._proto;
 }
@@ -72,8 +68,6 @@ pub const JsApi = struct {
         pub const name = "CompositionEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(CompositionEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(CompositionEvent.init, .{});

src/browser/webapi/event/CustomEvent.zig

@@ -73,11 +73,19 @@ pub fn initCustomEvent(
     self._detail = detail_;
 }
 
-pub fn deinit(self: *CustomEvent, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *CustomEvent, session: *Session) void {
     if (self._detail) |d| {
         d.release();
     }
-    self._proto.deinit(shutdown, session);
+    self._proto.deinit(session);
+}
+
+pub fn acquireRef(self: *CustomEvent) void {
+    self._proto.acquireRef();
+}
+
+pub fn releaseRef(self: *CustomEvent, session: *Session) void {
+    self._proto._rc.release(self, session);
 }
 
 pub fn asEvent(self: *CustomEvent) *Event {
@@ -95,8 +103,6 @@ pub const JsApi = struct {
         pub const name = "CustomEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(CustomEvent.deinit);
         pub const enumerable = false;
     };
 

src/browser/webapi/event/ErrorEvent.zig

@@ -80,11 +80,19 @@ fn initWithTrusted(arena: Allocator, typ: String, opts_: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *ErrorEvent, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *ErrorEvent, session: *Session) void {
     if (self._error) |e| {
         e.release();
     }
-    self._proto.deinit(shutdown, session);
+    self._proto.deinit(session);
+}
+
+pub fn acquireRef(self: *ErrorEvent) void {
+    self._proto.acquireRef();
+}
+
+pub fn releaseRef(self: *ErrorEvent, session: *Session) void {
+    self._proto._rc.release(self, session);
 }
 
 pub fn asEvent(self: *ErrorEvent) *Event {

src/browser/webapi/event/FocusEvent.zig

@@ -70,10 +70,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *FocusEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *FocusEvent) *Event {
     return self._proto.asEvent();
 }
@@ -89,8 +85,6 @@ pub const JsApi = struct {
         pub const name = "FocusEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(FocusEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(FocusEvent.init, .{});

src/browser/webapi/event/FormDataEvent.zig

@@ -66,10 +66,6 @@ fn initWithTrusted(arena: Allocator, typ: String, maybe_options: ?Options, trust
     return event;
 }
 
-pub fn deinit(self: *FormDataEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *FormDataEvent) *Event {
     return self._proto;
 }
@@ -85,8 +81,6 @@ pub const JsApi = struct {
         pub const name = "FormDataEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(FormDataEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(FormDataEvent.init, .{});

src/browser/webapi/event/InputEvent.zig

@@ -83,10 +83,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *InputEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *InputEvent) *Event {
     return self._proto.asEvent();
 }
@@ -110,8 +106,6 @@ pub const JsApi = struct {
         pub const name = "InputEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(InputEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(InputEvent.init, .{});

src/browser/webapi/event/KeyboardEvent.zig

@@ -229,10 +229,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *KeyboardEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *KeyboardEvent) *Event {
     return self._proto.asEvent();
 }
@@ -296,8 +292,6 @@ pub const JsApi = struct {
         pub const name = "KeyboardEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(KeyboardEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(KeyboardEvent.init, .{});

src/browser/webapi/event/MessageEvent.zig

@@ -73,11 +73,19 @@ fn initWithTrusted(arena: Allocator, typ: String, opts_: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *MessageEvent, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *MessageEvent, session: *Session) void {
     if (self._data) |d| {
         d.release();
     }
-    self._proto.deinit(shutdown, session);
+    self._proto.deinit(session);
+}
+
+pub fn acquireRef(self: *MessageEvent) void {
+    self._proto.acquireRef();
+}
+
+pub fn releaseRef(self: *MessageEvent, session: *Session) void {
+    self._proto._rc.release(self, session);
 }
 
 pub fn asEvent(self: *MessageEvent) *Event {
@@ -103,8 +111,6 @@ pub const JsApi = struct {
         pub const name = "MessageEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(MessageEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(MessageEvent.init, .{});

src/browser/webapi/event/MouseEvent.zig

@@ -121,10 +121,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *MouseEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *MouseEvent) *Event {
     return self._proto.asEvent();
 }
@@ -203,8 +199,6 @@ pub const JsApi = struct {
         pub const name = "MouseEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(MouseEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(MouseEvent.init, .{});

src/browser/webapi/event/NavigationCurrentEntryChangeEvent.zig

@@ -83,10 +83,6 @@ fn initWithTrusted(
     return event;
 }
 
-pub fn deinit(self: *NavigationCurrentEntryChangeEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *NavigationCurrentEntryChangeEvent) *Event {
     return self._proto;
 }
@@ -106,8 +102,6 @@ pub const JsApi = struct {
         pub const name = "NavigationCurrentEntryChangeEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(NavigationCurrentEntryChangeEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(NavigationCurrentEntryChangeEvent.init, .{});

src/browser/webapi/event/PageTransitionEvent.zig

@@ -66,10 +66,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *PageTransitionEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *PageTransitionEvent) *Event {
     return self._proto;
 }
@@ -85,8 +81,6 @@ pub const JsApi = struct {
         pub const name = "PageTransitionEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(PageTransitionEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(PageTransitionEvent.init, .{});

src/browser/webapi/event/PointerEvent.zig

@@ -128,10 +128,6 @@ pub fn init(typ: []const u8, _opts: ?Options, page: *Page) !*PointerEvent {
     return event;
 }
 
-pub fn deinit(self: *PointerEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *PointerEvent) *Event {
     return self._proto.asEvent();
 }
@@ -191,8 +187,6 @@ pub const JsApi = struct {
         pub const name = "PointerEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(PointerEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(PointerEvent.init, .{});

src/browser/webapi/event/PopStateEvent.zig

@@ -67,10 +67,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *PopStateEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *PopStateEvent) *Event {
     return self._proto;
 }
@@ -92,8 +88,6 @@ pub const JsApi = struct {
         pub const name = "PopStateEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(PopStateEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(PopStateEvent.init, .{});

src/browser/webapi/event/ProgressEvent.zig

@@ -68,10 +68,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *ProgressEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *ProgressEvent) *Event {
     return self._proto;
 }
@@ -96,8 +92,6 @@ pub const JsApi = struct {
         pub const name = "ProgressEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(ProgressEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(ProgressEvent.init, .{});

src/browser/webapi/event/PromiseRejectionEvent.zig

@@ -56,14 +56,22 @@ pub fn init(typ: []const u8, opts_: ?Options, page: *Page) !*PromiseRejectionEve
     return event;
 }
 
-pub fn deinit(self: *PromiseRejectionEvent, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *PromiseRejectionEvent, session: *Session) void {
     if (self._reason) |r| {
         r.release();
     }
     if (self._promise) |p| {
         p.release();
     }
-    self._proto.deinit(shutdown, session);
+    self._proto.deinit(session);
+}
+
+pub fn acquireRef(self: *PromiseRejectionEvent) void {
+    self._proto.acquireRef();
+}
+
+pub fn releaseRef(self: *PromiseRejectionEvent, session: *Session) void {
+    self._proto._rc.release(self, session);
 }
 
 pub fn asEvent(self: *PromiseRejectionEvent) *Event {
@@ -85,8 +93,6 @@ pub const JsApi = struct {
         pub const name = "PromiseRejectionEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(PromiseRejectionEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(PromiseRejectionEvent.init, .{});

src/browser/webapi/event/SubmitEvent.zig

@@ -67,10 +67,6 @@ fn initWithTrusted(arena: Allocator, typ: String, _opts: ?Options, trusted: bool
     return event;
 }
 
-pub fn deinit(self: *SubmitEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *SubmitEvent) *Event {
     return self._proto;
 }
@@ -86,8 +82,6 @@ pub const JsApi = struct {
         pub const name = "SubmitEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(SubmitEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(SubmitEvent.init, .{});

src/browser/webapi/event/TextEvent.zig

@@ -59,10 +59,6 @@ pub fn init(typ: []const u8, _opts: ?Options, page: *Page) !*TextEvent {
     return event;
 }
 
-pub fn deinit(self: *TextEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *TextEvent) *Event {
     return self._proto.asEvent();
 }
@@ -101,8 +97,6 @@ pub const JsApi = struct {
         pub const name = "TextEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(TextEvent.deinit);
     };
 
     // No constructor - TextEvent is created via document.createEvent('TextEvent')

src/browser/webapi/event/UIEvent.zig

@@ -71,10 +71,6 @@ pub fn init(typ: []const u8, _opts: ?Options, page: *Page) !*UIEvent {
     return event;
 }
 
-pub fn deinit(self: *UIEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn as(self: *UIEvent, comptime T: type) *T {
     return self.is(T).?;
 }
@@ -122,8 +118,6 @@ pub const JsApi = struct {
         pub const name = "UIEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(UIEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(UIEvent.init, .{});

src/browser/webapi/event/WheelEvent.zig

@@ -87,10 +87,6 @@ pub fn init(typ: []const u8, _opts: ?Options, page: *Page) !*WheelEvent {
     return event;
 }
 
-pub fn deinit(self: *WheelEvent, shutdown: bool, session: *Session) void {
-    self._proto.deinit(shutdown, session);
-}
-
 pub fn asEvent(self: *WheelEvent) *Event {
     return self._proto.asEvent();
 }
@@ -118,8 +114,6 @@ pub const JsApi = struct {
         pub const name = "WheelEvent";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(WheelEvent.deinit);
     };
 
     pub const constructor = bridge.constructor(WheelEvent.init, .{});

src/browser/webapi/net/Fetch.zig

@@ -62,7 +62,7 @@ pub fn init(input: Input, options: ?InitOpts, page: *Page) !js.Promise {
     }
 
     const response = try Response.init(null, .{ .status = 0 }, page);
-    errdefer response.deinit(true, page._session);
+    errdefer response.deinit(page._session);
 
     const fetch = try response._arena.create(Fetch);
     fetch.* = .{
@@ -226,7 +226,7 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
     return ls.toLocal(self._resolver).resolve("fetch done", js_val);
 }
 
-fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
+fn httpErrorCallback(ctx: *anyopaque, _: anyerror) void {
     const self: *Fetch = @ptrCast(@alignCast(ctx));
 
     var response = self._response;
@@ -235,7 +235,7 @@ fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
     // clear this. (defer since `self is in the response's arena).
 
     defer if (self._owns_response) {
-        response.deinit(err == error.Abort, self._page._session);
+        response.deinit(self._page._session);
         self._owns_response = false;
     };
 
@@ -257,7 +257,7 @@ fn httpShutdownCallback(ctx: *anyopaque) void {
     if (self._owns_response) {
         var response = self._response;
         response._transfer = null;
-        response.deinit(true, self._page._session);
+        response.deinit(self._page._session);
         // Do not access `self` after this point: the Fetch struct was
         // allocated from response._arena which has been released.
     }

src/browser/webapi/net/Response.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../../js/js.zig");
 const HttpClient = @import("../../HttpClient.zig");
 
@@ -38,6 +39,7 @@ pub const Type = enum {
     opaqueredirect,
 };
 
+_rc: lp.RC(u8) = .{},
 _status: u16,
 _arena: Allocator,
 _headers: *Headers,
@@ -78,18 +80,22 @@ pub fn init(body_: ?[]const u8, opts_: ?InitOpts, page: *Page) !*Response {
     return self;
 }
 
-pub fn deinit(self: *Response, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *Response, session: *Session) void {
     if (self._transfer) |transfer| {
-        if (shutdown) {
-            transfer.terminate();
-        } else {
-            transfer.abort(error.Abort);
-        }
+        transfer.abort(error.Abort);
         self._transfer = null;
     }
     session.releaseArena(self._arena);
 }
 
+pub fn releaseRef(self: *Response, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *Response) void {
+    self._rc.acquire();
+}
+
 pub fn getStatus(self: *const Response) u16 {
     return self._status;
 }
@@ -197,8 +203,6 @@ pub const JsApi = struct {
         pub const name = "Response";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(Response.deinit);
     };
 
     pub const constructor = bridge.constructor(Response.init, .{});

src/browser/webapi/net/URLSearchParams.zig

@@ -46,6 +46,10 @@ pub fn init(opts_: ?InitOpts, page: *Page) !*URLSearchParams {
             .query_string => |qs| break :blk try paramsFromString(arena, qs, &page.buf),
             .form_data => |fd| break :blk try KeyValueList.copy(arena, fd._list),
             .value => |js_val| {
+                // Order matters here; Array is also an Object.
+                if (js_val.isArray()) {
+                    break :blk try paramsFromArray(arena, js_val.toArray());
+                }
                 if (js_val.isObject()) {
                     break :blk try KeyValueList.fromJsObject(arena, js_val.toObject(), null, page);
                 }
@@ -134,6 +138,37 @@ pub fn sort(self: *URLSearchParams) void {
     }.cmp);
 }
 
+fn paramsFromArray(allocator: Allocator, array: js.Array) !KeyValueList {
+    const array_len = array.len();
+    if (array_len == 0) {
+        return .empty;
+    }
+
+    var params = KeyValueList.init();
+    try params.ensureTotalCapacity(allocator, array_len);
+    // TODO: Release `params` on error.
+
+    var i: u32 = 0;
+    while (i < array_len) : (i += 1) {
+        const item = try array.get(i);
+        if (!item.isArray()) return error.InvalidArgument;
+
+        const as_array = item.toArray();
+        // Need 2 items for KV.
+        if (as_array.len() != 2) return error.InvalidArgument;
+
+        const name_val = try as_array.get(0);
+        const value_val = try as_array.get(1);
+
+        params._entries.appendAssumeCapacity(.{
+            .name = try name_val.toSSOWithAlloc(allocator),
+            .value = try value_val.toSSOWithAlloc(allocator),
+        });
+    }
+
+    return params;
+}
+
 fn paramsFromString(allocator: Allocator, input_: []const u8, buf: []u8) !KeyValueList {
     if (input_.len == 0) {
         return .empty;

src/browser/webapi/net/XMLHttpRequest.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
 const js = @import("../../js/js.zig");
 
 const log = @import("../../../log.zig");
@@ -38,10 +39,12 @@ const Allocator = std.mem.Allocator;
 const IS_DEBUG = @import("builtin").mode == .Debug;
 
 const XMLHttpRequest = @This();
+_rc: lp.RC(u8) = .{},
 _page: *Page,
 _proto: *XMLHttpRequestEventTarget,
 _arena: Allocator,
 _transfer: ?*HttpClient.Transfer = null,
+_active_request: bool = false,
 
 _url: [:0]const u8 = "",
 _method: net_http.Method = .GET,
@@ -87,21 +90,18 @@ const ResponseType = enum {
 pub fn init(page: *Page) !*XMLHttpRequest {
     const arena = try page.getArena(.{ .debug = "XMLHttpRequest" });
     errdefer page.releaseArena(arena);
-    return page._factory.xhrEventTarget(arena, XMLHttpRequest{
+    const xhr = try page._factory.xhrEventTarget(arena, XMLHttpRequest{
         ._page = page,
         ._arena = arena,
         ._proto = undefined,
         ._request_headers = try Headers.init(null, page),
     });
+    return xhr;
 }
 
-pub fn deinit(self: *XMLHttpRequest, shutdown: bool, session: *Session) void {
+pub fn deinit(self: *XMLHttpRequest, session: *Session) void {
     if (self._transfer) |transfer| {
-        if (shutdown) {
-            transfer.terminate();
-        } else {
-            transfer.abort(error.Abort);
-        }
+        transfer.abort(error.Abort);
         self._transfer = null;
     }
 
@@ -137,6 +137,22 @@ pub fn deinit(self: *XMLHttpRequest, shutdown: bool, session: *Session) void {
     session.releaseArena(self._arena);
 }
 
+fn releaseSelfRef(self: *XMLHttpRequest) void {
+    if (self._active_request == false) {
+        return;
+    }
+    self.releaseRef(self._page._session);
+    self._active_request = false;
+}
+
+pub fn releaseRef(self: *XMLHttpRequest, session: *Session) void {
+    self._rc.release(self, session);
+}
+
+pub fn acquireRef(self: *XMLHttpRequest) void {
+    self._rc.acquire();
+}
+
 fn asEventTarget(self: *XMLHttpRequest) *EventTarget {
     return self._proto._proto;
 }
@@ -245,8 +261,8 @@ pub fn send(self: *XMLHttpRequest, body_: ?[]const u8) !void {
         .error_callback = httpErrorCallback,
         .shutdown_callback = httpShutdownCallback,
     });
-
-    page.js.strongRef(self);
+    self.acquireRef();
+    self._active_request = true;
 }
 
 fn handleBlobUrl(self: *XMLHttpRequest, page: *Page) !void {
@@ -486,15 +502,17 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
         .loaded = loaded,
     }, page);
 
-    page.js.weakRef(self);
+    self.releaseSelfRef();
 }
 
 fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
     const self: *XMLHttpRequest = @ptrCast(@alignCast(ctx));
     // http client will close it after an error, it isn't safe to keep around
-    self._transfer = null;
     self.handleError(err);
-    self._page.js.weakRef(self);
+    if (self._transfer != null) {
+        self._transfer = null;
+    }
+    self.releaseSelfRef();
 }
 
 fn httpShutdownCallback(ctx: *anyopaque) void {
@@ -505,10 +523,10 @@ fn httpShutdownCallback(ctx: *anyopaque) void {
 pub fn abort(self: *XMLHttpRequest) void {
     self.handleError(error.Abort);
     if (self._transfer) |transfer| {
-        transfer.abort(error.Abort);
         self._transfer = null;
+        transfer.abort(error.Abort);
     }
-    self._page.js.weakRef(self);
+    self.releaseSelfRef();
 }
 
 fn handleError(self: *XMLHttpRequest, err: anyerror) void {
@@ -582,8 +600,6 @@ pub const JsApi = struct {
         pub const name = "XMLHttpRequest";
         pub const prototype_chain = bridge.prototypeChain();
         pub var class_id: bridge.ClassId = undefined;
-        pub const weak = true;
-        pub const finalizer = bridge.finalizer(XMLHttpRequest.deinit);
     };
 
     pub const constructor = bridge.constructor(XMLHttpRequest.init, .{});

src/browser/webapi/selector/Parser.zig

@@ -74,7 +74,7 @@ fn preprocessInput(arena: Allocator, input: []const u8) ![]const u8 {
     return result.items;
 }
 
-pub fn parseList(arena: Allocator, input: []const u8, page: *Page) ParseError![]const Selector.Selector {
+pub fn parseList(arena: Allocator, input: []const u8) ParseError![]const Selector.Selector {
     // Preprocess input to normalize line endings
     const preprocessed = try preprocessInput(arena, input);
 
@@ -140,7 +140,7 @@ pub fn parseList(arena: Allocator, input: []const u8, page: *Page) ParseError![]
         const selector_input = std.mem.trimRight(u8, trimmed[0..comma_pos], &std.ascii.whitespace);
 
         if (selector_input.len > 0) {
-            const selector = try parse(arena, selector_input, page);
+            const selector = try parse(arena, selector_input);
             try selectors.append(arena, selector);
         }
 
@@ -155,7 +155,7 @@ pub fn parseList(arena: Allocator, input: []const u8, page: *Page) ParseError![]
     return selectors.items;
 }
 
-pub fn parse(arena: Allocator, input: []const u8, page: *Page) ParseError!Selector.Selector {
+pub fn parse(arena: Allocator, input: []const u8) ParseError!Selector.Selector {
     var parser = Parser{ .input = input };
     var segments: std.ArrayList(Segment) = .empty;
     var current_compound: std.ArrayList(Part) = .empty;
@@ -164,7 +164,7 @@ pub fn parse(arena: Allocator, input: []const u8, page: *Page) ParseError!Select
     while (parser.skipSpaces()) {
         if (parser.peek() == 0) break;
 
-        const part = try parser.parsePart(arena, page);
+        const part = try parser.parsePart(arena);
         try current_compound.append(arena, part);
 
         // Check what comes after this part
@@ -238,7 +238,7 @@ pub fn parse(arena: Allocator, input: []const u8, page: *Page) ParseError!Select
         while (parser.skipSpaces()) {
             if (parser.peek() == 0) break;
 
-            const part = try parser.parsePart(arena, page);
+            const part = try parser.parsePart(arena);
             try current_compound.append(arena, part);
 
             // Check what comes after this part
@@ -289,7 +289,7 @@ pub fn parse(arena: Allocator, input: []const u8, page: *Page) ParseError!Select
     };
 }
 
-fn parsePart(self: *Parser, arena: Allocator, page: *Page) !Part {
+fn parsePart(self: *Parser, arena: Allocator) !Part {
     return switch (self.peek()) {
         '#' => .{ .id = try self.id(arena) },
         '.' => .{ .class = try self.class(arena) },
@@ -297,16 +297,17 @@ fn parsePart(self: *Parser, arena: Allocator, page: *Page) !Part {
             self.input = self.input[1..];
             break :blk .universal;
         },
-        '[' => .{ .attribute = try self.attribute(arena, page) },
-        ':' => .{ .pseudo_class = try self.pseudoClass(arena, page) },
+        '[' => .{ .attribute = try self.attribute(arena) },
+        ':' => .{ .pseudo_class = try self.pseudoClass(arena) },
         'a'...'z', 'A'...'Z', '_', '\\', 0x80...0xFF => blk: {
             // Use parseIdentifier for full escape support
             const tag_name = try self.parseIdentifier(arena, error.InvalidTagSelector);
             if (tag_name.len > 256) {
                 return error.InvalidTagSelector;
             }
+            var buf: [256]u8 = undefined;
             // Try to match as a known tag enum for optimization
-            const lower = std.ascii.lowerString(&page.buf, tag_name);
+            const lower = std.ascii.lowerString(&buf, tag_name);
             if (Node.Element.Tag.parseForMatch(lower)) |known_tag| {
                 break :blk .{ .tag = known_tag };
             }
@@ -373,7 +374,7 @@ fn consumeUntilCommaOrParen(self: *Parser) []const u8 {
     return result;
 }
 
-fn pseudoClass(self: *Parser, arena: Allocator, page: *Page) !Selector.PseudoClass {
+fn pseudoClass(self: *Parser, arena: Allocator) !Selector.PseudoClass {
     if (comptime IS_DEBUG) {
         // Should have been verified by caller
         std.debug.assert(self.peek() == ':');
@@ -445,7 +446,7 @@ fn pseudoClass(self: *Parser, arena: Allocator, page: *Page) !Selector.PseudoCla
                 if (self.peek() == 0) return error.InvalidPseudoClass;
 
                 // Parse a full selector (with potential combinators and compounds)
-                const selector = try parse(arena, self.consumeUntilCommaOrParen(), page);
+                const selector = try parse(arena, self.consumeUntilCommaOrParen());
                 try selectors.append(arena, selector);
 
                 _ = self.skipSpaces();
@@ -472,7 +473,7 @@ fn pseudoClass(self: *Parser, arena: Allocator, page: *Page) !Selector.PseudoCla
                 if (self.peek() == ')') break;
                 if (self.peek() == 0) return error.InvalidPseudoClass;
 
-                const selector = try parse(arena, self.consumeUntilCommaOrParen(), page);
+                const selector = try parse(arena, self.consumeUntilCommaOrParen());
                 try selectors.append(arena, selector);
 
                 _ = self.skipSpaces();
@@ -499,7 +500,7 @@ fn pseudoClass(self: *Parser, arena: Allocator, page: *Page) !Selector.PseudoCla
                 if (self.peek() == ')') break;
                 if (self.peek() == 0) return error.InvalidPseudoClass;
 
-                const selector = try parse(arena, self.consumeUntilCommaOrParen(), page);
+                const selector = try parse(arena, self.consumeUntilCommaOrParen());
                 try selectors.append(arena, selector);
 
                 _ = self.skipSpaces();
@@ -526,7 +527,7 @@ fn pseudoClass(self: *Parser, arena: Allocator, page: *Page) !Selector.PseudoCla
                 if (self.peek() == ')') break;
                 if (self.peek() == 0) return error.InvalidPseudoClass;
 
-                const selector = try parse(arena, self.consumeUntilCommaOrParen(), page);
+                const selector = try parse(arena, self.consumeUntilCommaOrParen());
                 try selectors.append(arena, selector);
 
                 _ = self.skipSpaces();
@@ -898,7 +899,7 @@ fn tag(self: *Parser) ![]const u8 {
     return input[0..i];
 }
 
-fn attribute(self: *Parser, arena: Allocator, page: *Page) !Selector.Attribute {
+fn attribute(self: *Parser, arena: Allocator) !Selector.Attribute {
     if (comptime IS_DEBUG) {
         // should have been verified by caller
         std.debug.assert(self.peek() == '[');
@@ -910,8 +911,7 @@ fn attribute(self: *Parser, arena: Allocator, page: *Page) !Selector.Attribute {
     const attr_name = try self.attributeName();
 
     // Normalize the name to lowercase for fast matching (consistent with Attribute.normalizeNameForLookup)
-    const normalized = try Attribute.normalizeNameForLookup(.wrap(attr_name), page);
-    const name = try normalized.dupe(arena);
+    const name = try Attribute.normalizeNameForLookupAlloc(arena, .wrap(attr_name));
     var case_insensitive = false;
     _ = self.skipSpaces();
 

src/browser/webapi/selector/Selector.zig

@@ -20,41 +20,24 @@ const std = @import("std");
 
 const String = @import("../../../string.zig").String;
 
-const Parser = @import("Parser.zig");
 const Node = @import("../Node.zig");
 const Page = @import("../../Page.zig");
+
+const Parser = @import("Parser.zig");
 pub const List = @import("List.zig");
 
-pub fn querySelector(root: *Node, input: []const u8, page: *Page) !?*Node.Element {
+const Allocator = std.mem.Allocator;
+
+pub fn parseLeaky(arena: Allocator, input: []const u8) !Parsed {
     if (input.len == 0) {
         return error.SyntaxError;
     }
+    return .{ .selectors = try Parser.parseList(arena, input) };
+}
 
-    const arena = page.call_arena;
-    const selectors = try Parser.parseList(arena, input, page);
-
-    for (selectors) |selector| {
-        // Fast path: single compound with only an ID selector
-        if (selector.segments.len == 0 and selector.first.parts.len == 1) {
-            const first = selector.first.parts[0];
-            if (first == .id) {
-                const el = page.getElementByIdFromNode(root, first.id) orelse continue;
-                // Check if the element is within the root subtree
-                const node = el.asNode();
-                if (node != root and root.contains(node)) {
-                    return el;
-                }
-                continue;
-            }
-        }
-
-        if (List.initOne(root, selector, page)) |node| {
-            if (node.is(Node.Element)) |el| {
-                return el;
-            }
-        }
-    }
-    return null;
+pub fn querySelector(root: *Node, input: []const u8, page: *Page) !?*Node.Element {
+    const parsed = try parseLeaky(page.call_arena, input);
+    return parsed.query(root, page);
 }
 
 pub fn querySelectorAll(root: *Node, input: []const u8, page: *Page) !*List {
@@ -67,7 +50,7 @@ pub fn querySelectorAll(root: *Node, input: []const u8, page: *Page) !*List {
 
     var nodes: std.AutoArrayHashMapUnmanaged(*Node, void) = .empty;
 
-    const selectors = try Parser.parseList(arena, input, page);
+    const selectors = try Parser.parseList(arena, input);
     for (selectors) |selector| {
         try List.collect(arena, root, selector, &nodes, page);
     }
@@ -86,7 +69,7 @@ pub fn matches(el: *Node.Element, input: []const u8, page: *Page) !bool {
     }
 
     const arena = page.call_arena;
-    const selectors = try Parser.parseList(arena, input, page);
+    const selectors = try Parser.parseList(arena, input);
 
     for (selectors) |selector| {
         if (List.matches(el.asNode(), selector, el.asNode(), page)) {
@@ -104,7 +87,7 @@ pub fn matchesWithScope(el: *Node.Element, input: []const u8, scope: *Node.Eleme
     }
 
     const arena = page.call_arena;
-    const selectors = try Parser.parseList(arena, input, page);
+    const selectors = try Parser.parseList(arena, input);
 
     for (selectors) |selector| {
         if (List.matches(el.asNode(), selector, scope.asNode(), page)) {
@@ -292,3 +275,32 @@ pub const Selector = struct {
         }
     }
 };
+
+pub const Parsed = struct {
+    selectors: []const Selector,
+
+    pub fn query(self: Parsed, root: *Node, page: *Page) !?*Node.Element {
+        for (self.selectors) |selector| {
+            // Fast path: single compound with only an ID selector
+            if (selector.segments.len == 0 and selector.first.parts.len == 1) {
+                const first = selector.first.parts[0];
+                if (first == .id) {
+                    const el = page.getElementByIdFromNode(root, first.id) orelse continue;
+                    // Check if the element is within the root subtree
+                    const node = el.asNode();
+                    if (node != root and root.contains(node)) {
+                        return el;
+                    }
+                    continue;
+                }
+            }
+
+            if (List.initOne(root, selector, page)) |node| {
+                if (node.is(Node.Element)) |el| {
+                    return el;
+                }
+            }
+        }
+        return null;
+    }
+};

src/cdp/AXNode.zig

@@ -1179,7 +1179,7 @@ test "AXNode: writer" {
     var registry = Node.Registry.init(testing.allocator);
     defer registry.deinit();
 
-    var page = try testing.pageTest("cdp/dom3.html");
+    var page = try testing.pageTest("cdp/dom3.html", .{});
     defer page._session.removePage();
     var doc = page.window._document;
 

src/cdp/Node.zig

@@ -343,7 +343,7 @@ test "cdp Node: Registry register" {
     try testing.expectEqual(0, registry.lookup_by_id.count());
     try testing.expectEqual(0, registry.lookup_by_node.count());
 
-    var page = try testing.pageTest("cdp/registry1.html");
+    var page = try testing.pageTest("cdp/registry1.html", .{});
     defer page._session.removePage();
     var doc = page.window._document;
 
@@ -400,7 +400,7 @@ test "cdp Node: search list" {
     }
 
     {
-        var page = try testing.pageTest("cdp/registry2.html");
+        var page = try testing.pageTest("cdp/registry2.html", .{});
         defer page._session.removePage();
         var doc = page.window._document;
 
@@ -440,7 +440,7 @@ test "cdp Node: Writer" {
     var registry = Registry.init(testing.allocator);
     defer registry.deinit();
 
-    var page = try testing.pageTest("cdp/registry3.html");
+    var page = try testing.pageTest("cdp/registry3.html", .{});
     defer page._session.removePage();
     var doc = page.window._document;
 

src/cdp/domains/accessibility.zig

@@ -18,8 +18,9 @@
 
 const std = @import("std");
 const id = @import("../id.zig");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         disable,
@@ -32,15 +33,15 @@ pub fn processMessage(cmd: anytype) !void {
         .getFullAXTree => return getFullAXTree(cmd),
     }
 }
-fn enable(cmd: anytype) !void {
+fn enable(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn disable(cmd: anytype) !void {
+fn disable(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn getFullAXTree(cmd: anytype) !void {
+fn getFullAXTree(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         depth: ?i32 = null,
         frameId: ?[]const u8 = null,

src/cdp/domains/browser.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
 // TODO: hard coded data
 const PROTOCOL_VERSION = "1.3";
@@ -35,7 +36,7 @@ const PRODUCT = "Chrome/124.0.6367.29";
 const JS_VERSION = "12.4.254.8";
 const DEV_TOOLS_WINDOW_ID = 1923710101;
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         getVersion,
         setPermission,
@@ -57,7 +58,7 @@ pub fn processMessage(cmd: anytype) !void {
     }
 }
 
-fn getVersion(cmd: anytype) !void {
+fn getVersion(cmd: *CDP.Command) !void {
     // TODO: pre-serialize?
     return cmd.sendResult(.{
         .protocolVersion = PROTOCOL_VERSION,
@@ -69,7 +70,7 @@ fn getVersion(cmd: anytype) !void {
 }
 
 // TODO: noop method
-fn setDownloadBehavior(cmd: anytype) !void {
+fn setDownloadBehavior(cmd: *CDP.Command) !void {
     // const params = (try cmd.params(struct {
     //     behavior: []const u8,
     //     browserContextId: ?[]const u8 = null,
@@ -80,7 +81,7 @@ fn setDownloadBehavior(cmd: anytype) !void {
     return cmd.sendResult(null, .{ .include_session_id = false });
 }
 
-fn getWindowForTarget(cmd: anytype) !void {
+fn getWindowForTarget(cmd: *CDP.Command) !void {
     // const params = (try cmd.params(struct {
     //     targetId: ?[]const u8 = null,
     // })) orelse return error.InvalidParams;
@@ -91,22 +92,22 @@ fn getWindowForTarget(cmd: anytype) !void {
 }
 
 // TODO: noop method
-fn setWindowBounds(cmd: anytype) !void {
+fn setWindowBounds(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
 // TODO: noop method
-fn grantPermissions(cmd: anytype) !void {
+fn grantPermissions(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
 // TODO: noop method
-fn setPermission(cmd: anytype) !void {
+fn setPermission(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
 // TODO: noop method
-fn resetPermissions(cmd: anytype) !void {
+fn resetPermissions(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 

src/cdp/domains/css.zig

@@ -17,8 +17,9 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
     }, cmd.input.action) orelse return error.UnknownMethod;

src/cdp/domains/dom.zig

@@ -18,17 +18,18 @@
 
 const std = @import("std");
 const id = @import("../id.zig");
-const log = @import("../../log.zig");
+const CDP = @import("../CDP.zig");
 const Node = @import("../Node.zig");
+
+const log = @import("../../log.zig");
+const dump = @import("../../browser/dump.zig");
+const js = @import("../../browser/js/js.zig");
 const DOMNode = @import("../../browser/webapi/Node.zig");
 const Selector = @import("../../browser/webapi/selector/Selector.zig");
 
-const dump = @import("../../browser/dump.zig");
-const js = @import("../../browser/js/js.zig");
-
 const Allocator = std.mem.Allocator;
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         getDocument,
@@ -69,7 +70,7 @@ pub fn processMessage(cmd: anytype) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDocument
-fn getDocument(cmd: anytype) !void {
+fn getDocument(cmd: *CDP.Command) !void {
     const Params = struct {
         // CDP documentation implies that 0 isn't valid, but it _does_ work in Chrome
         depth: i32 = 3,
@@ -89,7 +90,7 @@ fn getDocument(cmd: anytype) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-performSearch
-fn performSearch(cmd: anytype) !void {
+fn performSearch(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         query: []const u8,
         includeUserAgentShadowDOM: ?bool = null,
@@ -116,7 +117,7 @@ fn performSearch(cmd: anytype) !void {
 // hierarchy of each nodes.
 // We dispatch event in the reverse order: from the top level to the direct parents.
 // We should dispatch a node only if it has never been sent.
-fn dispatchSetChildNodes(cmd: anytype, dom_nodes: []const *DOMNode) !void {
+fn dispatchSetChildNodes(cmd: *CDP.Command, dom_nodes: []const *DOMNode) !void {
     const arena = cmd.arena;
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const session_id = bc.session_id orelse return error.SessionIdNotLoaded;
@@ -172,7 +173,7 @@ fn dispatchSetChildNodes(cmd: anytype, dom_nodes: []const *DOMNode) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-discardSearchResults
-fn discardSearchResults(cmd: anytype) !void {
+fn discardSearchResults(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         searchId: []const u8,
     })) orelse return error.InvalidParams;
@@ -184,7 +185,7 @@ fn discardSearchResults(cmd: anytype) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getSearchResults
-fn getSearchResults(cmd: anytype) !void {
+fn getSearchResults(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         searchId: []const u8,
         fromIndex: u32,
@@ -209,7 +210,7 @@ fn getSearchResults(cmd: anytype) !void {
     return cmd.sendResult(.{ .nodeIds = node_ids[params.fromIndex..params.toIndex] }, .{});
 }
 
-fn querySelector(cmd: anytype) !void {
+fn querySelector(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: Node.Id,
         selector: []const u8,
@@ -235,7 +236,7 @@ fn querySelector(cmd: anytype) !void {
     }, .{});
 }
 
-fn querySelectorAll(cmd: anytype) !void {
+fn querySelectorAll(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: Node.Id,
         selector: []const u8,
@@ -266,7 +267,7 @@ fn querySelectorAll(cmd: anytype) !void {
     }, .{});
 }
 
-fn resolveNode(cmd: anytype) !void {
+fn resolveNode(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: ?Node.Id = null,
         backendNodeId: ?u32 = null,
@@ -327,7 +328,7 @@ fn resolveNode(cmd: anytype) !void {
     } }, .{});
 }
 
-fn describeNode(cmd: anytype) !void {
+fn describeNode(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: ?Node.Id = null,
         backendNodeId: ?Node.Id = null,
@@ -374,7 +375,7 @@ fn rectToQuad(rect: DOMNode.Element.DOMRect) Quad {
     };
 }
 
-fn scrollIntoViewIfNeeded(cmd: anytype) !void {
+fn scrollIntoViewIfNeeded(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: ?Node.Id = null,
         backendNodeId: ?u32 = null,
@@ -397,7 +398,7 @@ fn scrollIntoViewIfNeeded(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn getNode(arena: Allocator, bc: anytype, node_id: ?Node.Id, backend_node_id: ?Node.Id, object_id: ?[]const u8) !*Node {
+fn getNode(arena: Allocator, bc: *CDP.BrowserContext, node_id: ?Node.Id, backend_node_id: ?Node.Id, object_id: ?[]const u8) !*Node {
     const input_node_id = node_id orelse backend_node_id;
     if (input_node_id) |input_node_id_| {
         return bc.node_registry.lookup_by_id.get(input_node_id_) orelse return error.NodeNotFound;
@@ -417,7 +418,7 @@ fn getNode(arena: Allocator, bc: anytype, node_id: ?Node.Id, backend_node_id: ?N
 
 // https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getContentQuads
 // Related to: https://drafts.csswg.org/cssom-view/#the-geometryutils-interface
-fn getContentQuads(cmd: anytype) !void {
+fn getContentQuads(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: ?Node.Id = null,
         backendNodeId: ?Node.Id = null,
@@ -443,7 +444,7 @@ fn getContentQuads(cmd: anytype) !void {
     return cmd.sendResult(.{ .quads = &.{quad} }, .{});
 }
 
-fn getBoxModel(cmd: anytype) !void {
+fn getBoxModel(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: ?Node.Id = null,
         backendNodeId: ?u32 = null,
@@ -472,7 +473,7 @@ fn getBoxModel(cmd: anytype) !void {
     } }, .{});
 }
 
-fn requestChildNodes(cmd: anytype) !void {
+fn requestChildNodes(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: Node.Id,
         depth: i32 = 1,
@@ -496,7 +497,7 @@ fn requestChildNodes(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn getFrameOwner(cmd: anytype) !void {
+fn getFrameOwner(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         frameId: []const u8,
     })) orelse return error.InvalidParams;
@@ -512,7 +513,7 @@ fn getFrameOwner(cmd: anytype) !void {
     return cmd.sendResult(.{ .nodeId = node.id, .backendNodeId = node.id }, .{});
 }
 
-fn getOuterHTML(cmd: anytype) !void {
+fn getOuterHTML(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         nodeId: ?Node.Id = null,
         backendNodeId: ?Node.Id = null,
@@ -534,7 +535,7 @@ fn getOuterHTML(cmd: anytype) !void {
     return cmd.sendResult(.{ .outerHTML = aw.written() }, .{});
 }
 
-fn requestNode(cmd: anytype) !void {
+fn requestNode(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         objectId: []const u8,
     })) orelse return error.InvalidParams;

src/cdp/domains/emulation.zig

@@ -17,9 +17,10 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 const log = @import("../../log.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         setEmulatedMedia,
         setFocusEmulationEnabled,
@@ -38,7 +39,7 @@ pub fn processMessage(cmd: anytype) !void {
 }
 
 // TODO: noop method
-fn setEmulatedMedia(cmd: anytype) !void {
+fn setEmulatedMedia(cmd: *CDP.Command) !void {
     // const input = (try const incoming.params(struct {
     //     media: ?[]const u8 = null,
     //     features: ?[]struct{
@@ -51,7 +52,7 @@ fn setEmulatedMedia(cmd: anytype) !void {
 }
 
 // TODO: noop method
-fn setFocusEmulationEnabled(cmd: anytype) !void {
+fn setFocusEmulationEnabled(cmd: *CDP.Command) !void {
     // const input = (try const incoming.params(struct {
     //     enabled: bool,
     // })) orelse return error.InvalidParams;
@@ -59,16 +60,16 @@ fn setFocusEmulationEnabled(cmd: anytype) !void {
 }
 
 // TODO: noop method
-fn setDeviceMetricsOverride(cmd: anytype) !void {
+fn setDeviceMetricsOverride(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
 // TODO: noop method
-fn setTouchEmulationEnabled(cmd: anytype) !void {
+fn setTouchEmulationEnabled(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn setUserAgentOverride(cmd: anytype) !void {
+fn setUserAgentOverride(cmd: *CDP.Command) !void {
     log.info(.app, "setUserAgentOverride ignored", .{});
     return cmd.sendResult(null, .{});
 }

src/cdp/domains/fetch.zig

@@ -17,17 +17,19 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
-const Allocator = std.mem.Allocator;
 
 const id = @import("../id.zig");
+const CDP = @import("../CDP.zig");
 const log = @import("../../log.zig");
-const network = @import("network.zig");
 
 const HttpClient = @import("../../browser/HttpClient.zig");
 const net_http = @import("../../network/http.zig");
 const Notification = @import("../../Notification.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+const network = @import("network.zig");
+const Allocator = std.mem.Allocator;
+
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         disable,
         enable,
@@ -135,13 +137,13 @@ const ErrorReason = enum {
     BlockedByResponse,
 };
 
-fn disable(cmd: anytype) !void {
+fn disable(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     bc.fetchDisable();
     return cmd.sendResult(null, .{});
 }
 
-fn enable(cmd: anytype) !void {
+fn enable(cmd: *CDP.Command) !void {
     const params = (try cmd.params(EnableParam)) orelse EnableParam{};
     if (!arePatternsSupported(params.patterns)) {
         log.warn(.not_implemented, "Fetch.enable", .{ .params = "pattern" });
@@ -180,7 +182,7 @@ fn arePatternsSupported(patterns: []RequestPattern) bool {
     return true;
 }
 
-pub fn requestIntercept(bc: anytype, intercept: *const Notification.RequestIntercept) !void {
+pub fn requestIntercept(bc: *CDP.BrowserContext, intercept: *const Notification.RequestIntercept) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;
@@ -215,7 +217,7 @@ pub fn requestIntercept(bc: anytype, intercept: *const Notification.RequestInter
     intercept.wait_for_interception.* = true;
 }
 
-fn continueRequest(cmd: anytype) !void {
+fn continueRequest(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(struct {
         requestId: []const u8, // INT-{d}"
@@ -275,7 +277,7 @@ const AuthChallengeResponse = enum {
     ProvideCredentials,
 };
 
-fn continueWithAuth(cmd: anytype) !void {
+fn continueWithAuth(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(struct {
         requestId: []const u8, // "INT-{d}"
@@ -318,7 +320,7 @@ fn continueWithAuth(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn fulfillRequest(cmd: anytype) !void {
+fn fulfillRequest(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
 
     const params = (try cmd.params(struct {
@@ -360,7 +362,7 @@ fn fulfillRequest(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn failRequest(cmd: anytype) !void {
+fn failRequest(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(struct {
         requestId: []const u8, // "INT-{d}"
@@ -382,7 +384,7 @@ fn failRequest(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-pub fn requestAuthRequired(bc: anytype, intercept: *const Notification.RequestAuthRequired) !void {
+pub fn requestAuthRequired(bc: *CDP.BrowserContext, intercept: *const Notification.RequestAuthRequired) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;

src/cdp/domains/input.zig

@@ -17,8 +17,9 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         dispatchKeyEvent,
         dispatchMouseEvent,
@@ -33,7 +34,7 @@ pub fn processMessage(cmd: anytype) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchKeyEvent
-fn dispatchKeyEvent(cmd: anytype) !void {
+fn dispatchKeyEvent(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         type: Type,
         key: []const u8 = "",
@@ -74,7 +75,7 @@ fn dispatchKeyEvent(cmd: anytype) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchMouseEvent
-fn dispatchMouseEvent(cmd: anytype) !void {
+fn dispatchMouseEvent(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         x: f64,
         y: f64,
@@ -104,7 +105,7 @@ fn dispatchMouseEvent(cmd: anytype) !void {
 }
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-insertText
-fn insertText(cmd: anytype) !void {
+fn insertText(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         text: []const u8, // The text to insert
     })) orelse return error.InvalidParams;

src/cdp/domains/inspector.zig

@@ -17,8 +17,9 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         disable,

src/cdp/domains/log.zig

@@ -17,8 +17,9 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         disable,

src/cdp/domains/lp.zig

@@ -18,18 +18,23 @@
 
 const std = @import("std");
 const lp = @import("lightpanda");
+
+const CDP = @import("../CDP.zig");
+
+const Node = @import("../Node.zig");
+const DOMNode = @import("../../browser/webapi/Node.zig");
+
 const markdown = lp.markdown;
 const SemanticTree = lp.SemanticTree;
 const interactive = lp.interactive;
 const structured_data = lp.structured_data;
-const Node = @import("../Node.zig");
-const DOMNode = @import("../../browser/webapi/Node.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         getMarkdown,
         getSemanticTree,
         getInteractiveElements,
+        getNodeDetails,
         getStructuredData,
         detectForms,
         clickNode,
@@ -42,6 +47,7 @@ pub fn processMessage(cmd: anytype) !void {
         .getMarkdown => return getMarkdown(cmd),
         .getSemanticTree => return getSemanticTree(cmd),
         .getInteractiveElements => return getInteractiveElements(cmd),
+        .getNodeDetails => return getNodeDetails(cmd),
         .getStructuredData => return getStructuredData(cmd),
         .detectForms => return detectForms(cmd),
         .clickNode => return clickNode(cmd),
@@ -141,6 +147,24 @@ fn getInteractiveElements(cmd: anytype) !void {
     }, .{});
 }
 
+fn getNodeDetails(cmd: anytype) !void {
+    const Params = struct {
+        backendNodeId: Node.Id,
+    };
+    const params = (try cmd.params(Params)) orelse return error.InvalidParam;
+
+    const bc = cmd.browser_context orelse return error.NoBrowserContext;
+    const page = bc.session.currentPage() orelse return error.PageNotLoaded;
+
+    const node = (bc.node_registry.lookup_by_id.get(params.backendNodeId) orelse return error.InvalidNodeId).dom;
+
+    const details = SemanticTree.getNodeDetails(cmd.arena, node, &bc.node_registry, page) catch return error.InternalError;
+
+    return cmd.sendResult(.{
+        .nodeDetails = details,
+    }, .{});
+}
+
 fn getStructuredData(cmd: anytype) !void {
     const bc = cmd.browser_context orelse return error.NoBrowserContext;
     const page = bc.session.currentPage() orelse return error.PageNotLoaded;

src/cdp/domains/network.zig

@@ -18,18 +18,21 @@
 
 const std = @import("std");
 const lp = @import("lightpanda");
-const Allocator = std.mem.Allocator;
+
 const log = @import("../../log.zig");
 
-const CdpStorage = @import("storage.zig");
-
 const id = @import("../id.zig");
+const CDP = @import("../CDP.zig");
+
 const URL = @import("../../browser/URL.zig");
 const Transfer = @import("../../browser/HttpClient.zig").Transfer;
 const Notification = @import("../../Notification.zig");
 const Mime = @import("../../browser/Mime.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+const CdpStorage = @import("storage.zig");
+const Allocator = std.mem.Allocator;
+
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         disable,
@@ -59,19 +62,19 @@ pub fn processMessage(cmd: anytype) !void {
     }
 }
 
-fn enable(cmd: anytype) !void {
+fn enable(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     try bc.networkEnable();
     return cmd.sendResult(null, .{});
 }
 
-fn disable(cmd: anytype) !void {
+fn disable(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     bc.networkDisable();
     return cmd.sendResult(null, .{});
 }
 
-fn setExtraHTTPHeaders(cmd: anytype) !void {
+fn setExtraHTTPHeaders(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         headers: std.json.ArrayHashMap([]const u8),
     })) orelse return error.InvalidParams;
@@ -110,7 +113,7 @@ fn cookieMatches(cookie: *const Cookie, name: []const u8, domain: ?[]const u8, p
     return true;
 }
 
-fn deleteCookies(cmd: anytype) !void {
+fn deleteCookies(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         name: []const u8,
         url: ?[:0]const u8 = null,
@@ -144,14 +147,14 @@ fn deleteCookies(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn clearBrowserCookies(cmd: anytype) !void {
+fn clearBrowserCookies(cmd: *CDP.Command) !void {
     if (try cmd.params(struct {}) != null) return error.InvalidParams;
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     bc.session.cookie_jar.clearRetainingCapacity();
     return cmd.sendResult(null, .{});
 }
 
-fn setCookie(cmd: anytype) !void {
+fn setCookie(cmd: *CDP.Command) !void {
     const params = (try cmd.params(
         CdpStorage.CdpCookie,
     )) orelse return error.InvalidParams;
@@ -162,7 +165,7 @@ fn setCookie(cmd: anytype) !void {
     try cmd.sendResult(.{ .success = true }, .{});
 }
 
-fn setCookies(cmd: anytype) !void {
+fn setCookies(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         cookies: []const CdpStorage.CdpCookie,
     })) orelse return error.InvalidParams;
@@ -178,7 +181,7 @@ fn setCookies(cmd: anytype) !void {
 const GetCookiesParam = struct {
     urls: ?[]const [:0]const u8 = null,
 };
-fn getCookies(cmd: anytype) !void {
+fn getCookies(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(GetCookiesParam)) orelse GetCookiesParam{};
 
@@ -201,7 +204,7 @@ fn getCookies(cmd: anytype) !void {
     try cmd.sendResult(.{ .cookies = writer }, .{});
 }
 
-fn getResponseBody(cmd: anytype) !void {
+fn getResponseBody(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         requestId: []const u8, // "REQ-{d}"
     })) orelse return error.InvalidParams;
@@ -227,7 +230,7 @@ fn getResponseBody(cmd: anytype) !void {
     }, .{});
 }
 
-pub fn httpRequestFail(bc: anytype, msg: *const Notification.RequestFail) !void {
+pub fn httpRequestFail(bc: *CDP.BrowserContext, msg: *const Notification.RequestFail) !void {
     // It's possible that the request failed because we aborted when the client
     // sent Target.closeTarget. In that case, bc.session_id will be cleared
     // already, and we can skip sending these messages to the client.
@@ -247,7 +250,7 @@ pub fn httpRequestFail(bc: anytype, msg: *const Notification.RequestFail) !void
     }, .{ .session_id = session_id });
 }
 
-pub fn httpRequestStart(bc: anytype, msg: *const Notification.RequestStart) !void {
+pub fn httpRequestStart(bc: *CDP.BrowserContext, msg: *const Notification.RequestStart) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;
@@ -276,7 +279,7 @@ pub fn httpRequestStart(bc: anytype, msg: *const Notification.RequestStart) !voi
     }, .{ .session_id = session_id });
 }
 
-pub fn httpResponseHeaderDone(arena: Allocator, bc: anytype, msg: *const Notification.ResponseHeaderDone) !void {
+pub fn httpResponseHeaderDone(arena: Allocator, bc: *CDP.BrowserContext, msg: *const Notification.ResponseHeaderDone) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;
@@ -293,7 +296,7 @@ pub fn httpResponseHeaderDone(arena: Allocator, bc: anytype, msg: *const Notific
     }, .{ .session_id = session_id });
 }
 
-pub fn httpRequestDone(bc: anytype, msg: *const Notification.RequestDone) !void {
+pub fn httpRequestDone(bc: *CDP.BrowserContext, msg: *const Notification.RequestDone) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;

src/cdp/domains/page.zig

@@ -1,4 +1,5 @@
 // Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -22,6 +23,8 @@ const lp = @import("lightpanda");
 const screenshot_png = @embedFile("screenshot.png");
 
 const id = @import("../id.zig");
+const CDP = @import("../CDP.zig");
+
 const log = @import("../../log.zig");
 const js = @import("../../browser/js/js.zig");
 const URL = @import("../../browser/URL.zig");
@@ -31,7 +34,7 @@ const Notification = @import("../../Notification.zig");
 
 const Allocator = std.mem.Allocator;
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         getFrameTree,
@@ -78,7 +81,7 @@ const Frame = struct {
     gatedAPIFeatures: [][]const u8 = &[0][]const u8{},
 };
 
-fn getFrameTree(cmd: anytype) !void {
+fn getFrameTree(cmd: *CDP.Command) !void {
     // Stagehand parses the response and error if we don't return a
     // correct one for this call when browser context or target id are missing.
     const startup = .{
@@ -108,7 +111,7 @@ fn getFrameTree(cmd: anytype) !void {
     }, .{});
 }
 
-fn setLifecycleEventsEnabled(cmd: anytype) !void {
+fn setLifecycleEventsEnabled(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         enabled: bool,
     })) orelse return error.InvalidParams;
@@ -149,7 +152,7 @@ fn setLifecycleEventsEnabled(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn addScriptToEvaluateOnNewDocument(cmd: anytype) !void {
+fn addScriptToEvaluateOnNewDocument(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         source: []const u8,
         worldName: ?[]const u8 = null,
@@ -179,7 +182,7 @@ fn addScriptToEvaluateOnNewDocument(cmd: anytype) !void {
     }, .{});
 }
 
-fn removeScriptToEvaluateOnNewDocument(cmd: anytype) !void {
+fn removeScriptToEvaluateOnNewDocument(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         identifier: []const u8,
     })) orelse return error.InvalidParams;
@@ -198,7 +201,7 @@ fn removeScriptToEvaluateOnNewDocument(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn close(cmd: anytype) !void {
+fn close(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
 
     const target_id = bc.target_id orelse return error.TargetNotLoaded;
@@ -235,7 +238,7 @@ fn close(cmd: anytype) !void {
     bc.target_id = null;
 }
 
-fn createIsolatedWorld(cmd: anytype) !void {
+fn createIsolatedWorld(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         frameId: []const u8,
         worldName: []const u8,
@@ -255,7 +258,7 @@ fn createIsolatedWorld(cmd: anytype) !void {
     return cmd.sendResult(.{ .executionContextId = js_context.id }, .{});
 }
 
-fn navigate(cmd: anytype) !void {
+fn navigate(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         url: [:0]const u8,
         // referrer: ?[]const u8 = null,
@@ -289,7 +292,7 @@ fn navigate(cmd: anytype) !void {
     });
 }
 
-fn doReload(cmd: anytype) !void {
+fn doReload(cmd: *CDP.Command) !void {
     const params = try cmd.params(struct {
         ignoreCache: ?bool = null,
         scriptToEvaluateOnLoad: ?[]const u8 = null,
@@ -319,7 +322,7 @@ fn doReload(cmd: anytype) !void {
     });
 }
 
-pub fn pageNavigate(bc: anytype, event: *const Notification.PageNavigate) !void {
+pub fn pageNavigate(bc: *CDP.BrowserContext, event: *const Notification.PageNavigate) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;
@@ -371,7 +374,7 @@ pub fn pageNavigate(bc: anytype, event: *const Notification.PageNavigate) !void
     }, .{ .session_id = session_id });
 }
 
-pub fn pageRemove(bc: anytype) !void {
+pub fn pageRemove(bc: *CDP.BrowserContext) !void {
     // Clear all remote object mappings to prevent stale objectIds from being used
     // after the context is destroy
     bc.inspector_session.inspector.resetContextGroup();
@@ -382,7 +385,7 @@ pub fn pageRemove(bc: anytype) !void {
     }
 }
 
-pub fn pageCreated(bc: anytype, page: *Page) !void {
+pub fn pageCreated(bc: *CDP.BrowserContext, page: *Page) !void {
     _ = bc.cdp.page_arena.reset(.{ .retain_with_limit = 1024 * 512 });
 
     for (bc.isolated_worlds.items) |isolated_world| {
@@ -394,7 +397,7 @@ pub fn pageCreated(bc: anytype, page: *Page) !void {
     bc.captured_responses = .empty;
 }
 
-pub fn pageFrameCreated(bc: anytype, event: *const Notification.PageFrameCreated) !void {
+pub fn pageFrameCreated(bc: *CDP.BrowserContext, event: *const Notification.PageFrameCreated) !void {
     const session_id = bc.session_id orelse return;
 
     const cdp = bc.cdp;
@@ -415,12 +418,11 @@ pub fn pageFrameCreated(bc: anytype, event: *const Notification.PageFrameCreated
     }
 }
 
-pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.PageNavigated) !void {
+pub fn pageNavigated(arena: Allocator, bc: *CDP.BrowserContext, event: *const Notification.PageNavigated) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;
 
-    const timestamp = event.timestamp;
     const frame_id = &id.toFrameId(event.frame_id);
     const loader_id = &id.toLoaderId(event.req_id);
 
@@ -472,9 +474,9 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
     const page = bc.session.currentPage() orelse return error.PageNotLoaded;
 
     // When we actually recreated the context we should have the inspector send
-    // this event, see: resetContextGroup Sending this event will tell the
-    // client that the context ids they had are invalid and the context shouls
-    // be dropped The client will expect us to send new contextCreated events,
+    // this event, see: resetContextGroup. Sending this event will tell the
+    // client that the context ids they had are invalid and the context should
+    // be dropped. The client will expect us to send new contextCreated events,
     // such that the client has new id's for the active contexts.
     // Only send executionContextsCleared for main frame navigations. For child
     // frames (iframes), clearing all contexts would destroy the main frame's
@@ -484,6 +486,18 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
         try cdp.sendEvent("Runtime.executionContextsCleared", null, .{ .session_id = session_id });
     }
 
+    // frameNavigated event
+    try cdp.sendEvent("Page.frameNavigated", .{
+        .type = "Navigation",
+        .frame = Frame{
+            .id = frame_id,
+            .url = event.url,
+            .loaderId = loader_id,
+            .securityOrigin = bc.security_origin,
+            .secureContextType = bc.secure_context_type,
+        },
+    }, .{ .session_id = session_id });
+
     {
         const aux_data = try std.fmt.allocPrint(arena, "{{\"isDefault\":true,\"type\":\"default\",\"frameId\":\"{s}\",\"loaderId\":\"{s}\"}}", .{ frame_id, loader_id });
 
@@ -554,18 +568,22 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
     // chromedp client expects to receive the events is this order.
     // see https://github.com/chromedp/chromedp/issues/1558
     try cdp.sendEvent("DOM.documentUpdated", null, .{ .session_id = session_id });
+}
+
+pub fn pageDOMContentLoaded(bc: anytype, event: *const Notification.PageDOMContentLoaded) !void {
+    const session_id = bc.session_id orelse return;
+    const timestamp = event.timestamp;
+    var cdp = bc.cdp;
 
-    // domContentEventFired event
-    // TODO: partially hard coded
     try cdp.sendEvent(
         "Page.domContentEventFired",
         .{ .timestamp = timestamp },
         .{ .session_id = session_id },
     );
 
-    // lifecycle DOMContentLoaded event
-    // TODO: partially hard coded
     if (bc.page_life_cycle_events) {
+        const frame_id = &id.toFrameId(event.frame_id);
+        const loader_id = &id.toLoaderId(event.req_id);
         try cdp.sendEvent("Page.lifecycleEvent", LifecycleEvent{
             .timestamp = timestamp,
             .name = "DOMContentLoaded",
@@ -573,16 +591,23 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
             .loaderId = loader_id,
         }, .{ .session_id = session_id });
     }
+}
+
+pub fn pageLoaded(bc: anytype, event: *const Notification.PageLoaded) !void {
+    const session_id = bc.session_id orelse return;
+    const timestamp = event.timestamp;
+    var cdp = bc.cdp;
+
+    const frame_id = &id.toFrameId(event.frame_id);
 
-    // loadEventFired event
     try cdp.sendEvent(
         "Page.loadEventFired",
         .{ .timestamp = timestamp },
         .{ .session_id = session_id },
     );
 
-    // lifecycle DOMContentLoaded event
     if (bc.page_life_cycle_events) {
+        const loader_id = &id.toLoaderId(event.req_id);
         try cdp.sendEvent("Page.lifecycleEvent", LifecycleEvent{
             .timestamp = timestamp,
             .name = "load",
@@ -591,21 +616,20 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
         }, .{ .session_id = session_id });
     }
 
-    // frameStoppedLoading
     return cdp.sendEvent("Page.frameStoppedLoading", .{
         .frameId = frame_id,
     }, .{ .session_id = session_id });
 }
 
-pub fn pageNetworkIdle(bc: anytype, event: *const Notification.PageNetworkIdle) !void {
+pub fn pageNetworkIdle(bc: *CDP.BrowserContext, event: *const Notification.PageNetworkIdle) !void {
     return sendPageLifecycle(bc, "networkIdle", event.timestamp, &id.toFrameId(event.frame_id), &id.toLoaderId(event.req_id));
 }
 
-pub fn pageNetworkAlmostIdle(bc: anytype, event: *const Notification.PageNetworkAlmostIdle) !void {
+pub fn pageNetworkAlmostIdle(bc: *CDP.BrowserContext, event: *const Notification.PageNetworkAlmostIdle) !void {
     return sendPageLifecycle(bc, "networkAlmostIdle", event.timestamp, &id.toFrameId(event.frame_id), &id.toLoaderId(event.req_id));
 }
 
-fn sendPageLifecycle(bc: anytype, name: []const u8, timestamp: u64, frame_id: []const u8, loader_id: []const u8) !void {
+fn sendPageLifecycle(bc: *CDP.BrowserContext, name: []const u8, timestamp: u64, frame_id: []const u8, loader_id: []const u8) !void {
     // detachTarget could be called, in which case, we still have a page doing
     // things, but no session.
     const session_id = bc.session_id orelse return;
@@ -640,7 +664,7 @@ fn base64Encode(comptime input: []const u8) [std.base64.standard.Encoder.calcSiz
     return buf;
 }
 
-fn captureScreenshot(cmd: anytype) !void {
+fn captureScreenshot(cmd: *CDP.Command) !void {
     const Params = struct {
         format: ?[]const u8 = "png",
         quality: ?u8 = null,
@@ -676,7 +700,7 @@ fn captureScreenshot(cmd: anytype) !void {
     }, .{});
 }
 
-fn getLayoutMetrics(cmd: anytype) !void {
+fn getLayoutMetrics(cmd: *CDP.Command) !void {
     const width = 1920;
     const height = 1080;
 

src/cdp/domains/performance.zig

@@ -17,8 +17,9 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         disable,

src/cdp/domains/runtime.zig

@@ -19,7 +19,9 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub fn processMessage(cmd: anytype) !void {
+const CDP = @import("../CDP.zig");
+
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         runIfWaitingForDebugger,
@@ -36,7 +38,7 @@ pub fn processMessage(cmd: anytype) !void {
     }
 }
 
-fn sendInspector(cmd: anytype, action: anytype) !void {
+fn sendInspector(cmd: *CDP.Command, action: anytype) !void {
     // save script in file at debug mode
     if (builtin.mode == .Debug) {
         try logInspector(cmd, action);
@@ -48,7 +50,7 @@ fn sendInspector(cmd: anytype, action: anytype) !void {
     bc.callInspector(cmd.input.json);
 }
 
-fn logInspector(cmd: anytype, action: anytype) !void {
+fn logInspector(cmd: *CDP.Command, action: anytype) !void {
     const script = switch (action) {
         .evaluate => blk: {
             const params = (try cmd.params(struct {

src/cdp/domains/security.zig

@@ -17,8 +17,9 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const CDP = @import("../CDP.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         enable,
         disable,
@@ -32,7 +33,7 @@ pub fn processMessage(cmd: anytype) !void {
     }
 }
 
-fn setIgnoreCertificateErrors(cmd: anytype) !void {
+fn setIgnoreCertificateErrors(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         ignore: bool,
     })) orelse return error.InvalidParams;

src/cdp/domains/storage.zig

@@ -18,13 +18,16 @@
 
 const std = @import("std");
 
+const CDP = @import("../CDP.zig");
+
 const log = @import("../../log.zig");
 const URL = @import("../../browser/URL.zig");
 const Cookie = @import("../../browser/webapi/storage/storage.zig").Cookie;
+
 const CookieJar = Cookie.Jar;
 pub const PreparedUri = Cookie.PreparedUri;
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         clearCookies,
         setCookies,
@@ -40,7 +43,7 @@ pub fn processMessage(cmd: anytype) !void {
 
 const BrowserContextParam = struct { browserContextId: ?[]const u8 = null };
 
-fn clearCookies(cmd: anytype) !void {
+fn clearCookies(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(BrowserContextParam)) orelse BrowserContextParam{};
 
@@ -55,7 +58,7 @@ fn clearCookies(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn getCookies(cmd: anytype) !void {
+fn getCookies(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(BrowserContextParam)) orelse BrowserContextParam{};
 
@@ -69,7 +72,7 @@ fn getCookies(cmd: anytype) !void {
     try cmd.sendResult(.{ .cookies = writer }, .{});
 }
 
-fn setCookies(cmd: anytype) !void {
+fn setCookies(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const params = (try cmd.params(struct {
         cookies: []const CdpCookie,

src/cdp/domains/target.zig

@@ -20,11 +20,13 @@ const std = @import("std");
 const lp = @import("lightpanda");
 
 const id = @import("../id.zig");
+const CDP = @import("../CDP.zig");
+
 const log = @import("../../log.zig");
 const URL = @import("../../browser/URL.zig");
 const js = @import("../../browser/js/js.zig");
 
-pub fn processMessage(cmd: anytype) !void {
+pub fn processMessage(cmd: *CDP.Command) !void {
     const action = std.meta.stringToEnum(enum {
         getTargets,
         attachToTarget,
@@ -60,7 +62,7 @@ pub fn processMessage(cmd: anytype) !void {
     }
 }
 
-fn getTargets(cmd: anytype) !void {
+fn getTargets(cmd: *CDP.Command) !void {
     // If no context available, return an empty array.
     const bc = cmd.browser_context orelse {
         return cmd.sendResult(.{
@@ -86,7 +88,7 @@ fn getTargets(cmd: anytype) !void {
     }, .{ .include_session_id = false });
 }
 
-fn getBrowserContexts(cmd: anytype) !void {
+fn getBrowserContexts(cmd: *CDP.Command) !void {
     var browser_context_ids: []const []const u8 = undefined;
     if (cmd.browser_context) |bc| {
         browser_context_ids = &.{bc.id};
@@ -99,7 +101,7 @@ fn getBrowserContexts(cmd: anytype) !void {
     }, .{ .include_session_id = false });
 }
 
-fn createBrowserContext(cmd: anytype) !void {
+fn createBrowserContext(cmd: *CDP.Command) !void {
     const params = try cmd.params(struct {
         disposeOnDetach: bool = false,
         proxyServer: ?[:0]const u8 = null,
@@ -130,7 +132,7 @@ fn createBrowserContext(cmd: anytype) !void {
     }, .{});
 }
 
-fn disposeBrowserContext(cmd: anytype) !void {
+fn disposeBrowserContext(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         browserContextId: []const u8,
     })) orelse return error.InvalidParams;
@@ -141,7 +143,7 @@ fn disposeBrowserContext(cmd: anytype) !void {
     try cmd.sendResult(null, .{});
 }
 
-fn createTarget(cmd: anytype) !void {
+fn createTarget(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         url: [:0]const u8 = "about:blank",
         // width: ?u64 = null,
@@ -230,7 +232,7 @@ fn createTarget(cmd: anytype) !void {
     }, .{});
 }
 
-fn attachToTarget(cmd: anytype) !void {
+fn attachToTarget(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         targetId: []const u8,
         flatten: bool = true,
@@ -247,7 +249,7 @@ fn attachToTarget(cmd: anytype) !void {
     return cmd.sendResult(.{ .sessionId = bc.session_id }, .{});
 }
 
-fn attachToBrowserTarget(cmd: anytype) !void {
+fn attachToBrowserTarget(cmd: *CDP.Command) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
 
     const session_id = bc.session_id orelse cmd.cdp.session_id_gen.next();
@@ -269,7 +271,7 @@ fn attachToBrowserTarget(cmd: anytype) !void {
     return cmd.sendResult(.{ .sessionId = bc.session_id }, .{});
 }
 
-fn closeTarget(cmd: anytype) !void {
+fn closeTarget(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         targetId: []const u8,
     })) orelse return error.InvalidParams;
@@ -310,7 +312,7 @@ fn closeTarget(cmd: anytype) !void {
     bc.target_id = null;
 }
 
-fn getTargetInfo(cmd: anytype) !void {
+fn getTargetInfo(cmd: *CDP.Command) !void {
     const Params = struct {
         targetId: ?[]const u8 = null,
     };
@@ -347,7 +349,7 @@ fn getTargetInfo(cmd: anytype) !void {
     }, .{ .include_session_id = false });
 }
 
-fn sendMessageToTarget(cmd: anytype) !void {
+fn sendMessageToTarget(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         message: []const u8,
         sessionId: []const u8,
@@ -365,32 +367,19 @@ fn sendMessageToTarget(cmd: anytype) !void {
         return error.UnknownSessionId;
     }
 
-    const Capture = struct {
-        aw: std.Io.Writer.Allocating,
-
-        pub fn sendJSON(self: *@This(), message: anytype) !void {
-            return std.json.Stringify.value(message, .{
-                .emit_null_optional_fields = false,
-            }, &self.aw.writer);
-        }
-    };
-
-    var capture = Capture{
-        .aw = .init(cmd.arena),
-    };
-
-    cmd.cdp.dispatch(cmd.arena, &capture, params.message) catch |err| {
+    var aw = std.Io.Writer.Allocating.init(cmd.arena);
+    cmd.cdp.dispatch(cmd.arena, .{ .capture = &aw.writer }, params.message) catch |err| {
         log.err(.cdp, "internal dispatch error", .{ .err = err, .id = cmd.input.id, .message = params.message });
         return err;
     };
 
     try cmd.sendEvent("Target.receivedMessageFromTarget", .{
-        .message = capture.aw.written(),
+        .message = aw.written(),
         .sessionId = params.sessionId,
     }, .{});
 }
 
-fn detachFromTarget(cmd: anytype) !void {
+fn detachFromTarget(cmd: *CDP.Command) !void {
     if (cmd.browser_context) |bc| {
         if (bc.session_id) |session_id| {
             try cmd.sendEvent("Target.detachedFromTarget", .{
@@ -404,11 +393,11 @@ fn detachFromTarget(cmd: anytype) !void {
 }
 
 // TODO: noop method
-fn setDiscoverTargets(cmd: anytype) !void {
+fn setDiscoverTargets(cmd: *CDP.Command) !void {
     return cmd.sendResult(null, .{});
 }
 
-fn setAutoAttach(cmd: anytype) !void {
+fn setAutoAttach(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         autoAttach: bool,
         waitForDebuggerOnStart: bool,
@@ -468,7 +457,7 @@ fn setAutoAttach(cmd: anytype) !void {
     try cmd.sendResult(null, .{});
 }
 
-fn doAttachtoTarget(cmd: anytype, target_id: []const u8) !void {
+fn doAttachtoTarget(cmd: *CDP.Command, target_id: []const u8) !void {
     const bc = cmd.browser_context.?;
     const session_id = bc.session_id orelse cmd.cdp.session_id_gen.next();
 

src/cdp/testing.zig

@@ -64,7 +64,7 @@ const TestContext = struct {
         session_id: ?[]const u8 = null,
         url: ?[:0]const u8 = null,
     };
-    pub fn loadBrowserContext(self: *TestContext, opts: BrowserContextOpts) !*CDP.BrowserContext(CDP) {
+    pub fn loadBrowserContext(self: *TestContext, opts: BrowserContextOpts) !*CDP.BrowserContext {
         var c = self.cdp();
         if (c.browser_context) |bc| {
             _ = c.disposeBrowserContext(bc.id);

src/lightpanda.zig

@@ -48,7 +48,9 @@ const IS_DEBUG = @import("builtin").mode == .Debug;
 
 pub const FetchOpts = struct {
     wait_ms: u32 = 5000,
-    wait_until: Config.WaitUntil = .load,
+    wait_until: ?Config.WaitUntil = null,
+    wait_script: ?[:0]const u8 = null,
+    wait_selector: ?[:0]const u8 = null,
     dump: dump.Opts,
     dump_mode: ?Config.DumpFormat = null,
     writer: ?*std.Io.Writer = null,
@@ -111,7 +113,31 @@ pub fn fetch(app: *App, url: [:0]const u8, opts: FetchOpts) !void {
         .kind = .{ .push = null },
     });
     var runner = try session.runner(.{});
-    try runner.wait(.{ .ms = opts.wait_ms, .until = opts.wait_until });
+
+    var timer = try std.time.Timer.start();
+
+    if (opts.wait_until) |wu| {
+        try runner.wait(.{ .ms = opts.wait_ms, .until = wu });
+    } else if (opts.wait_selector == null and opts.wait_script == null) {
+        // We default to .done if both wait_selector and wait_script are null
+        // This allows the caller to ONLY --wait-selector or ONLY --wait-script
+        // or combine --wait-until WITH --wait-selector/script
+        try runner.wait(.{ .ms = opts.wait_ms, .until = .done });
+    }
+
+    if (opts.wait_selector) |selector| {
+        const elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
+        const remaining = opts.wait_ms -| elapsed;
+        if (remaining == 0) return error.Timeout;
+        _ = try runner.waitForSelector(selector, remaining);
+    }
+
+    if (opts.wait_script) |script| {
+        const elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
+        const remaining = opts.wait_ms -| elapsed;
+        if (remaining == 0) return error.Timeout;
+        try runner.waitForScript(script, remaining);
+    }
 
     const writer = opts.writer orelse return;
     if (opts.dump_mode) |mode| {
@@ -209,6 +235,41 @@ noinline fn assertionFailure(comptime ctx: []const u8, args: anytype) noreturn {
     @import("crash_handler.zig").crash(ctx, args, @returnAddress());
 }
 
+// Reference counting helper
+pub fn RC(comptime T: type) type {
+    return struct {
+        _refs: T = 0,
+
+        pub fn init(refs: T) @This() {
+            return .{ ._refs = refs };
+        }
+
+        pub fn acquire(self: *@This()) void {
+            self._refs += 1;
+        }
+
+        pub fn release(self: *@This(), value: anytype, session: *Session) void {
+            if (comptime IS_DEBUG) {
+                std.debug.assert(self._refs > 0);
+            }
+
+            const refs = self._refs - 1;
+            self._refs = refs;
+            if (refs > 0) {
+                return;
+            }
+            value.deinit(session);
+            if (session.finalizer_callbacks.fetchRemove(@intFromPtr(value))) |kv| {
+                session.releaseArena(kv.value.arena);
+            }
+        }
+
+        pub fn format(self: @This(), writer: *std.Io.Writer) !void {
+            return writer.print("{d}", .{self._refs});
+        }
+    };
+}
+
 test {
     std.testing.refAllDecls(@This());
 }

src/main.zig

@@ -123,6 +123,8 @@ fn run(allocator: Allocator, main_arena: Allocator) !void {
             var fetch_opts = lp.FetchOpts{
                 .wait_ms = opts.wait_ms,
                 .wait_until = opts.wait_until,
+                .wait_script = opts.wait_script,
+                .wait_selector = opts.wait_selector,
                 .dump_mode = opts.dump_mode,
                 .dump = .{
                     .strip = opts.strip,

src/mcp/tools.zig

@@ -75,6 +75,19 @@ pub const tool_list = [_]protocol.Tool{
             \\}
         ),
     },
+    .{
+        .name = "nodeDetails",
+        .description = "Get detailed information about a specific node by its backend node ID. Returns tag, role, name, interactivity, disabled state, value, input type, placeholder, href, checked state, and select options.",
+        .inputSchema = protocol.minify(
+            \\{
+            \\  "type": "object",
+            \\  "properties": {
+            \\    "backendNodeId": { "type": "integer", "description": "The backend node ID of the element to inspect." }
+            \\  },
+            \\  "required": ["backendNodeId"]
+            \\}
+        ),
+    },
     .{
         .name = "interactiveElements",
         .description = "Extract interactive elements from the opened page. If a url is provided, it navigates to that url first.",
@@ -256,6 +269,7 @@ const ToolAction = enum {
     navigate,
     markdown,
     links,
+    nodeDetails,
     interactiveElements,
     structuredData,
     detectForms,
@@ -272,6 +286,7 @@ const tool_map = std.StaticStringMap(ToolAction).initComptime(.{
     .{ "navigate", .navigate },
     .{ "markdown", .markdown },
     .{ "links", .links },
+    .{ "nodeDetails", .nodeDetails },
     .{ "interactiveElements", .interactiveElements },
     .{ "structuredData", .structuredData },
     .{ "detectForms", .detectForms },
@@ -305,6 +320,7 @@ pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Reque
         .goto, .navigate => try handleGoto(server, arena, req.id.?, call_params.arguments),
         .markdown => try handleMarkdown(server, arena, req.id.?, call_params.arguments),
         .links => try handleLinks(server, arena, req.id.?, call_params.arguments),
+        .nodeDetails => try handleNodeDetails(server, arena, req.id.?, call_params.arguments),
         .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),
@@ -373,6 +389,32 @@ fn handleSemanticTree(server: *Server, arena: std.mem.Allocator, id: std.json.Va
     };
 }
 
+fn handleNodeDetails(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, "nodeDetails");
+
+    _ = 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");
+    };
+
+    var aw: std.Io.Writer.Allocating = .init(arena);
+    try std.json.Stringify.value(&details, .{}, &aw.writer);
+
+    const content = [_]protocol.TextContent([]const u8){.{ .text = aw.written() }};
+    try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
+}
+
 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);

src/network/http.zig

@@ -389,6 +389,15 @@ pub const Connection = struct {
         return url;
     }
 
+    pub fn getConnectCode(self: *const Connection) !u16 {
+        var status: c_long = undefined;
+        try libcurl.curl_easy_getinfo(self._easy, .connect_code, &status);
+        if (status < 0 or status > std.math.maxInt(u16)) {
+            return 0;
+        }
+        return @intCast(status);
+    }
+
     pub fn getResponseCode(self: *const Connection) !u16 {
         var status: c_long = undefined;
         try libcurl.curl_easy_getinfo(self._easy, .response_code, &status);
@@ -404,6 +413,24 @@ pub const Connection = struct {
         return @intCast(count);
     }
 
+    pub fn getConnectHeader(self: *const Connection, name: [:0]const u8, index: usize) ?HeaderValue {
+        var hdr: ?*libcurl.CurlHeader = null;
+        libcurl.curl_easy_header(self._easy, name, index, .connect, -1, &hdr) catch |err| {
+            // ErrorHeader includes OutOfMemory — rare but real errors from curl internals.
+            // Logged and returned as null since callers don't expect errors.
+            log.err(.http, "get response header", .{
+                .name = name,
+                .err = err,
+            });
+            return null;
+        };
+        const h = hdr orelse return null;
+        return .{
+            .amount = h.amount,
+            .value = std.mem.span(h.value),
+        };
+    }
+
     pub fn getResponseHeader(self: *const Connection, name: [:0]const u8, index: usize) ?HeaderValue {
         var hdr: ?*libcurl.CurlHeader = null;
         libcurl.curl_easy_header(self._easy, name, index, .header, -1, &hdr) catch |err| {