From f3e1204fa1eef0cdc46d1d220a96bd7a67ad1f0b Mon Sep 17 00:00:00 2001
From: Karl Seguin <k@openmymind.io>
Date: Mon, 9 Mar 2026 13:44:17 +0800
Subject: [PATCH 1/8] Throw exception, as expected, on empty input to
 DOMParser.parseFromString

https://github.com/lightpanda-io/browser/issues/1738
---
 src/browser/tests/domparser.html | 14 +++++++++++---
 src/browser/webapi/DOMParser.zig |  9 +++++----
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/browser/tests/domparser.html b/src/browser/tests/domparser.html
index 70fd6ff9..24d34e89 100644
--- a/src/browser/tests/domparser.html
+++ b/src/browser/tests/domparser.html
@@ -4,9 +4,17 @@
 
 <script id=basic>
 {
-  const parser = new DOMParser();
-  testing.expectEqual('object', typeof parser);
-  testing.expectEqual('function', typeof parser.parseFromString);
+  {
+    const parser = new DOMParser();
+    testing.expectEqual('object', typeof parser);
+    testing.expectEqual('function', typeof parser.parseFromString);
+  }
+
+  {
+    // Empty XML is a parse error (no root element)
+    const parser = new DOMParser();
+    testing.expectError('Error', () => parser.parseFromString('', 'text/xml'));
+  }
 }
 </script>
 
diff --git a/src/browser/webapi/DOMParser.zig b/src/browser/webapi/DOMParser.zig
index e2a0a438..9e27e9c7 100644
--- a/src/browser/webapi/DOMParser.zig
+++ b/src/browser/webapi/DOMParser.zig
@@ -90,15 +90,16 @@ pub fn parseFromString(
                 return pe.err;
             }
 
-            // If first node is a `ProcessingInstruction`, skip it.
             const first_child = doc_node.firstChild() orelse {
-                // Parsing should fail if there aren't any nodes.
-                unreachable;
+                // Empty XML or no root element - this is a parse error.
+                // TODO: Return a document with a <parsererror> element per spec.
+                return error.JsException;
             };
 
+            // If first node is a `ProcessingInstruction`, skip it.
             if (first_child.getNodeType() == 7) {
                 // We're sure that firstChild exist, this cannot fail.
-                _ = doc_node.removeChild(first_child, page) catch unreachable;
+                _ = try doc_node.removeChild(first_child, page);
             }
 
             return doc.asDocument();

From 5568340b9a7948e7990cdfd7c58a1b7f311ca1c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A0=20Arrufat?= <adria.arrufat@gmail.com>
Date: Mon, 9 Mar 2026 18:48:38 +0900
Subject: [PATCH 2/8] build: add code formatting check

---
 build.zig     | 11 +++++++++++
 build.zig.zon |  1 -
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/build.zig b/build.zig
index 7e3a2817..d4eabcea 100644
--- a/build.zig
+++ b/build.zig
@@ -52,6 +52,17 @@ pub fn build(b: *Build) !void {
         mod.addImport("lightpanda", mod); // allow circular "lightpanda" import
         mod.addImport("build_config", opts.createModule());
 
+        // Format check
+        const fmt_step = b.step("fmt", "Check code formatting");
+        const fmt = b.addFmt(.{
+            .paths = &.{ "src", "build.zig", "build.zig.zon" },
+            .check = true,
+        });
+        fmt_step.dependOn(&fmt.step);
+
+        // Set default behavior
+        b.default_step.dependOn(fmt_step);
+
         try linkV8(b, mod, enable_asan, enable_tsan, prebuilt_v8_path);
         try linkCurl(b, mod);
         try linkHtml5Ever(b, mod);
diff --git a/build.zig.zon b/build.zig.zon
index b7525c77..eb3812a8 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -7,7 +7,6 @@
         .v8 = .{
             .url = "https://github.com/lightpanda-io/zig-v8-fork/archive/refs/tags/v0.3.1.tar.gz",
             .hash = "v8-0.0.0-xddH64J7BAC81mkf6G9RbEJxS-W3TIRl5iFnShwbqCqy",
-
         },
         //.v8 = .{ .path = "../zig-v8-fork" },
         .brotli = .{

From 183643547b6e35106abf8501b058add754933a79 Mon Sep 17 00:00:00 2001
From: Karl Seguin <k@openmymind.io>
Date: Mon, 9 Mar 2026 18:06:22 +0800
Subject: [PATCH 3/8] document.applets should always return an empty collection

Add a new .empty mode to HTMLCollection.

Fixes WPT /shadow-dom/leaktests/html-collection.html
---
 src/browser/tests/legacy/html/document.html       | 3 ++-
 src/browser/webapi/HTMLDocument.zig               | 5 ++---
 src/browser/webapi/collections.zig                | 5 +++--
 src/browser/webapi/collections/HTMLCollection.zig | 8 ++++++++
 4 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/browser/tests/legacy/html/document.html b/src/browser/tests/legacy/html/document.html
index 7abb0b03..01e5d76a 100644
--- a/src/browser/tests/legacy/html/document.html
+++ b/src/browser/tests/legacy/html/document.html
@@ -6,6 +6,7 @@
 </html>
 
 <script src="../testing.js"></script>
+<applet></applet>
 
 <script id=document>
   testing.expectEqual('HTMLDocument', document.__proto__.constructor.name);
@@ -23,7 +24,7 @@
   testing.expectEqual(2, document.scripts.length);
   testing.expectEqual(0, document.forms.length);
   testing.expectEqual(1, document.links.length);
-  testing.expectEqual(0, document.applets.length);
+  testing.expectEqual(0, document.applets.length); // deprecated, always returns 0
   testing.expectEqual(0, document.anchors.length);
   testing.expectEqual(7, document.all.length);
   testing.expectEqual('document', document.currentScript.id);
diff --git a/src/browser/webapi/HTMLDocument.zig b/src/browser/webapi/HTMLDocument.zig
index 15ba610b..76c3be40 100644
--- a/src/browser/webapi/HTMLDocument.zig
+++ b/src/browser/webapi/HTMLDocument.zig
@@ -167,9 +167,8 @@ pub fn getEmbeds(self: *HTMLDocument, page: *Page) !collections.NodeLive(.tag) {
     return collections.NodeLive(.tag).init(self.asNode(), .embed, page);
 }
 
-const applet_string = String.init(undefined, "applet", .{}) catch unreachable;
-pub fn getApplets(self: *HTMLDocument, page: *Page) !collections.NodeLive(.tag_name) {
-    return collections.NodeLive(.tag_name).init(self.asNode(), applet_string, page);
+pub fn getApplets(_: *const HTMLDocument) collections.HTMLCollection {
+    return .{ ._data = .empty };
 }
 
 pub fn getCurrentScript(self: *const HTMLDocument) ?*Element.Html.Script {
diff --git a/src/browser/webapi/collections.zig b/src/browser/webapi/collections.zig
index 13cd911f..4a5a5384 100644
--- a/src/browser/webapi/collections.zig
+++ b/src/browser/webapi/collections.zig
@@ -20,14 +20,15 @@ pub const NodeLive = @import("collections/node_live.zig").NodeLive;
 pub const ChildNodes = @import("collections/ChildNodes.zig");
 pub const DOMTokenList = @import("collections/DOMTokenList.zig");
 pub const RadioNodeList = @import("collections/RadioNodeList.zig");
+pub const HTMLCollection = @import("collections/HTMLCollection.zig");
 pub const HTMLAllCollection = @import("collections/HTMLAllCollection.zig");
 pub const HTMLOptionsCollection = @import("collections/HTMLOptionsCollection.zig");
 pub const HTMLFormControlsCollection = @import("collections/HTMLFormControlsCollection.zig");
 
 pub fn registerTypes() []const type {
     return &.{
-        @import("collections/HTMLCollection.zig"),
-        @import("collections/HTMLCollection.zig").Iterator,
+        HTMLCollection,
+        HTMLCollection.Iterator,
         @import("collections/NodeList.zig"),
         @import("collections/NodeList.zig").KeyIterator,
         @import("collections/NodeList.zig").ValueIterator,
diff --git a/src/browser/webapi/collections/HTMLCollection.zig b/src/browser/webapi/collections/HTMLCollection.zig
index 0172541b..fc73ec6d 100644
--- a/src/browser/webapi/collections/HTMLCollection.zig
+++ b/src/browser/webapi/collections/HTMLCollection.zig
@@ -36,6 +36,7 @@ const Mode = enum {
     links,
     anchors,
     form,
+    empty,
 };
 
 const HTMLCollection = @This();
@@ -52,22 +53,26 @@ _data: union(Mode) {
     links: NodeLive(.links),
     anchors: NodeLive(.anchors),
     form: NodeLive(.form),
+    empty: void,
 },
 
 pub fn length(self: *HTMLCollection, page: *const Page) u32 {
     return switch (self._data) {
+        .empty => 0,
         inline else => |*impl| impl.length(page),
     };
 }
 
 pub fn getAtIndex(self: *HTMLCollection, index: usize, page: *const Page) ?*Element {
     return switch (self._data) {
+        .empty => null,
         inline else => |*impl| impl.getAtIndex(index, page),
     };
 }
 
 pub fn getByName(self: *HTMLCollection, name: []const u8, page: *Page) ?*Element {
     return switch (self._data) {
+        .empty => null,
         inline else => |*impl| impl.getByName(name, page),
     };
 }
@@ -87,6 +92,7 @@ pub fn iterator(self: *HTMLCollection, page: *Page) !*Iterator {
             .links => |*impl| .{ .links = impl._tw.clone() },
             .anchors => |*impl| .{ .anchors = impl._tw.clone() },
             .form => |*impl| .{ .form = impl._tw.clone() },
+            .empty => .empty,
         },
     }, page);
 }
@@ -106,6 +112,7 @@ pub const Iterator = GenericIterator(struct {
         links: TreeWalker.FullExcludeSelf,
         anchors: TreeWalker.FullExcludeSelf,
         form: TreeWalker.FullExcludeSelf,
+        empty: void,
     },
 
     pub fn next(self: *@This(), _: *Page) ?*Element {
@@ -121,6 +128,7 @@ pub const Iterator = GenericIterator(struct {
             .links => |*impl| impl.nextTw(&self.tw.links),
             .anchors => |*impl| impl.nextTw(&self.tw.anchors),
             .form => |*impl| impl.nextTw(&self.tw.form),
+            .empty => return null,
         };
     }
 }, null);

From 8672232ee2d932eae72b747803e9c2ca9fafb7af Mon Sep 17 00:00:00 2001
From: Pierre Tachoire <pierre@lightpanda.io>
Date: Mon, 9 Mar 2026 16:57:41 +0100
Subject: [PATCH 4/8] cdp: add dummy page.captureScreenshot

---
 src/cdp/domains/page.zig       |  71 +++++++++++++++++++++++++++++++++
 src/cdp/domains/screenshot.png | Bin 0 -> 13945 bytes
 2 files changed, 71 insertions(+)
 create mode 100644 src/cdp/domains/screenshot.png

diff --git a/src/cdp/domains/page.zig b/src/cdp/domains/page.zig
index e029b6a6..d4b7b301 100644
--- a/src/cdp/domains/page.zig
+++ b/src/cdp/domains/page.zig
@@ -19,6 +19,8 @@
 const std = @import("std");
 const lp = @import("lightpanda");
 
+const screenshot_png = @embedFile("screenshot.png");
+
 const id = @import("../id.zig");
 const log = @import("../../log.zig");
 const js = @import("../../browser/js/js.zig");
@@ -39,6 +41,7 @@ pub fn processMessage(cmd: anytype) !void {
         navigate,
         stopLoading,
         close,
+        captureScreenshot,
     }, cmd.input.action) orelse return error.UnknownMethod;
 
     switch (action) {
@@ -50,6 +53,7 @@ pub fn processMessage(cmd: anytype) !void {
         .navigate => return navigate(cmd),
         .stopLoading => return cmd.sendResult(null, .{}),
         .close => return close(cmd),
+        .captureScreenshot => return captureScreenshot(cmd),
     }
 }
 
@@ -514,6 +518,57 @@ const LifecycleEvent = struct {
     timestamp: u64,
 };
 
+const Viewport = struct {
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+    scale: f64,
+};
+
+fn base64Encode(comptime input: []const u8) [std.base64.standard.Encoder.calcSize(input.len)]u8 {
+    const encoder = std.base64.standard.Encoder;
+    var buf: [encoder.calcSize(input.len)]u8 = undefined;
+    _ = encoder.encode(&buf, input);
+    return buf;
+}
+
+fn captureScreenshot(cmd: anytype) !void {
+    const Params = struct {
+        format: ?[]const u8 = "png",
+        quality: ?u8 = null,
+        clip: ?Viewport = null,
+        fromSurface: ?bool = false,
+        captureBeyondViewport: ?bool = false,
+        optimizeForSpeed: ?bool = false,
+    };
+    const params = try cmd.params(Params) orelse Params{};
+
+    const format = params.format orelse "png";
+
+    if (!std.mem.eql(u8, format, "png")) {
+        log.warn(.not_implemented, "Page.captureScreenshot params", .{ .format = format });
+        return cmd.sendError(-32000, "unsupported screenshot format.", .{});
+    }
+    if (params.quality != null) {
+        log.warn(.not_implemented, "Page.captureScreenshot params", .{ .quality = params.quality });
+    }
+    if (params.clip != null) {
+        log.warn(.not_implemented, "Page.captureScreenshot params", .{ .clip = params.clip });
+    }
+    if (params.fromSurface orelse false or params.captureBeyondViewport orelse false or params.optimizeForSpeed orelse false) {
+        log.warn(.not_implemented, "Page.captureScreenshot params", .{
+            .fromSurface = params.fromSurface,
+            .captureBeyondViewport = params.captureBeyondViewport,
+            .optimizeForSpeed = params.optimizeForSpeed,
+        });
+    }
+
+    return cmd.sendResult(.{
+        .data = base64Encode(screenshot_png),
+    }, .{});
+}
+
 const testing = @import("../testing.zig");
 test "cdp.page: getFrameTree" {
     var ctx = testing.context();
@@ -547,3 +602,19 @@ test "cdp.page: getFrameTree" {
         }, .{ .id = 11 });
     }
 }
+
+test "cdp.page: captureScreenshot" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+    {
+        try ctx.processMessage(.{ .id = 10, .method = "Page.captureScreenshot", .params = .{ .format = "jpg" } });
+        try ctx.expectSentError(-32000, "unsupported screenshot format.", .{ .id = 10 });
+    }
+
+    {
+        try ctx.processMessage(.{ .id = 11, .method = "Page.captureScreenshot" });
+        try ctx.expectSentResult(.{
+            .data = base64Encode(screenshot_png),
+        }, .{ .id = 11 });
+    }
+}
diff --git a/src/cdp/domains/screenshot.png b/src/cdp/domains/screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..12fbde5ddf2767307d5cbe5ed3533c6b5bafc7b7
GIT binary patch
literal 13945
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

literal 0
HcmV?d00001


From 37c34351ee403767d61c84ac14307f3da0a801ee Mon Sep 17 00:00:00 2001
From: Pierre Tachoire <pierre@lightpanda.io>
Date: Mon, 9 Mar 2026 19:23:36 +0100
Subject: [PATCH 5/8] http: handle auth challenge for non-proxy auth

---
 src/Net.zig         | 4 ++++
 src/http/Client.zig | 6 +++++-
 src/sys/libcurl.zig | 2 ++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/Net.zig b/src/Net.zig
index bd723be6..c45707e4 100644
--- a/src/Net.zig
+++ b/src/Net.zig
@@ -377,6 +377,10 @@ pub const Connection = struct {
         try libcurl.curl_easy_setopt(self.easy, .proxy_user_pwd, creds.ptr);
     }
 
+    pub fn setCredentials(self: *const Connection, creds: [:0]const u8) !void {
+        try libcurl.curl_easy_setopt(self.easy, .user_pwd, creds.ptr);
+    }
+
     pub fn setCallbacks(
         self: *const Connection,
         comptime header_cb: libcurl.CurlHeaderFunction,
diff --git a/src/http/Client.zig b/src/http/Client.zig
index 326635f4..5701de27 100644
--- a/src/http/Client.zig
+++ b/src/http/Client.zig
@@ -718,7 +718,11 @@ fn makeRequest(self: *Client, conn: *Net.Connection, transfer: *Transfer) anyerr
 
         // add credentials
         if (req.credentials) |creds| {
-            try conn.setProxyCredentials(creds);
+            if (transfer._auth_challenge != null and transfer._auth_challenge.?.source == .proxy) {
+                try conn.setProxyCredentials(creds);
+            } else {
+                try conn.setCredentials(creds);
+            }
         }
     }
 
diff --git a/src/sys/libcurl.zig b/src/sys/libcurl.zig
index ca718ebb..759cba25 100644
--- a/src/sys/libcurl.zig
+++ b/src/sys/libcurl.zig
@@ -148,6 +148,7 @@ pub const CurlOption = enum(c.CURLoption) {
     cookie = c.CURLOPT_COOKIE,
     private = c.CURLOPT_PRIVATE,
     proxy_user_pwd = c.CURLOPT_PROXYUSERPWD,
+    user_pwd = c.CURLOPT_USERPWD,
     header_data = c.CURLOPT_HEADERDATA,
     header_function = c.CURLOPT_HEADERFUNCTION,
     write_data = c.CURLOPT_WRITEDATA,
@@ -512,6 +513,7 @@ pub fn curl_easy_setopt(easy: *Curl, comptime option: CurlOption, value: anytype
         .accept_encoding,
         .custom_request,
         .cookie,
+        .user_pwd,
         .proxy_user_pwd,
         .copy_post_fields,
         => blk: {

From a417c73bf79a6ebd9b1a08c62ae3938715295e3a Mon Sep 17 00:00:00 2001
From: egrs <egrs@users.noreply.github.com>
Date: Mon, 9 Mar 2026 19:11:09 +0100
Subject: [PATCH 6/8] add LP.getInteractiveElements CDP command
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Returns a structured list of all interactive elements on a page:
buttons, links, inputs, ARIA widgets, contenteditable regions, and
elements with event listeners. Includes accessible names, roles,
listener types, and key attributes.

Event listener introspection (both addEventListener and inline
handlers) is unique to LP — no other browser exposes this to
automation code.
---
 src/browser/interactive.zig | 481 ++++++++++++++++++++++++++++++++++++
 src/cdp/domains/lp.zig      |  49 ++++
 src/lightpanda.zig          |   1 +
 3 files changed, 531 insertions(+)
 create mode 100644 src/browser/interactive.zig

diff --git a/src/browser/interactive.zig b/src/browser/interactive.zig
new file mode 100644
index 00000000..cf623f6c
--- /dev/null
+++ b/src/browser/interactive.zig
@@ -0,0 +1,481 @@
+// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const Page = @import("Page.zig");
+const TreeWalker = @import("webapi/TreeWalker.zig");
+const Element = @import("webapi/Element.zig");
+const Node = @import("webapi/Node.zig");
+const EventTarget = @import("webapi/EventTarget.zig");
+
+const Allocator = std.mem.Allocator;
+
+pub const InteractivityType = enum {
+    native,
+    aria,
+    contenteditable,
+    listener,
+    focusable,
+};
+
+pub const InteractiveElement = struct {
+    node: *Node,
+    tag_name: []const u8,
+    role: ?[]const u8,
+    name: ?[]const u8,
+    interactivity_type: InteractivityType,
+    listener_types: []const []const u8,
+    disabled: bool,
+    tab_index: i32,
+    id: ?[]const u8,
+    class: ?[]const u8,
+    href: ?[]const u8,
+    input_type: ?[]const u8,
+    value: ?[]const u8,
+    element_name: ?[]const u8,
+    placeholder: ?[]const u8,
+
+    pub fn jsonStringify(self: *const InteractiveElement, jw: anytype) !void {
+        try jw.beginObject();
+
+        try jw.objectField("tagName");
+        try jw.write(self.tag_name);
+
+        try jw.objectField("role");
+        try jw.write(self.role);
+
+        try jw.objectField("name");
+        try jw.write(self.name);
+
+        try jw.objectField("type");
+        try jw.write(@tagName(self.interactivity_type));
+
+        if (self.listener_types.len > 0) {
+            try jw.objectField("listeners");
+            try jw.beginArray();
+            for (self.listener_types) |lt| {
+                try jw.write(lt);
+            }
+            try jw.endArray();
+        }
+
+        if (self.disabled) {
+            try jw.objectField("disabled");
+            try jw.write(true);
+        }
+
+        try jw.objectField("tabIndex");
+        try jw.write(self.tab_index);
+
+        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.href) |v| {
+            try jw.objectField("href");
+            try jw.write(v);
+        }
+
+        if (self.input_type) |v| {
+            try jw.objectField("inputType");
+            try jw.write(v);
+        }
+
+        if (self.value) |v| {
+            try jw.objectField("value");
+            try jw.write(v);
+        }
+
+        if (self.element_name) |v| {
+            try jw.objectField("elementName");
+            try jw.write(v);
+        }
+
+        if (self.placeholder) |v| {
+            try jw.objectField("placeholder");
+            try jw.write(v);
+        }
+
+        try jw.endObject();
+    }
+};
+
+/// Collect all interactive elements under `root`.
+pub fn collectInteractiveElements(
+    root: *Node,
+    page: *Page,
+    arena: Allocator,
+) ![]InteractiveElement {
+    // Pre-build a map of event_target pointer → event type names,
+    // so classify and getListenerTypes are both O(1) per element.
+    const listener_targets = try buildListenerTargetMap(page, arena);
+
+    var results: std.ArrayList(InteractiveElement) = .empty;
+
+    var tw = TreeWalker.FullExcludeSelf.init(root, .{});
+    while (tw.next()) |node| {
+        const el = node.is(Element) orelse continue;
+        const html_el = el.is(Element.Html) orelse continue;
+
+        // Skip non-visual elements that are never user-interactive.
+        switch (el.getTag()) {
+            .script, .style, .link, .meta, .head, .noscript, .template => continue,
+            else => {},
+        }
+
+        const itype = classifyInteractivity(el, html_el, listener_targets) orelse continue;
+
+        const listener_types = getListenerTypes(
+            el.asEventTarget(),
+            listener_targets,
+        );
+
+        try results.append(arena, .{
+            .node = node,
+            .tag_name = el.getTagNameLower(),
+            .role = getRole(el),
+            .name = getAccessibleName(el),
+            .interactivity_type = itype,
+            .listener_types = listener_types,
+            .disabled = isDisabled(el),
+            .tab_index = html_el.getTabIndex(),
+            .id = el.getAttributeSafe(comptime .wrap("id")),
+            .class = el.getAttributeSafe(comptime .wrap("class")),
+            .href = el.getAttributeSafe(comptime .wrap("href")),
+            .input_type = getInputType(el),
+            .value = getInputValue(el),
+            .element_name = el.getAttributeSafe(comptime .wrap("name")),
+            .placeholder = el.getAttributeSafe(comptime .wrap("placeholder")),
+        });
+    }
+
+    return results.items;
+}
+
+const ListenerTargetMap = std.AutoHashMapUnmanaged(usize, std.ArrayList([]const u8));
+
+/// Pre-build a map from event_target pointer → list of event type names.
+/// This lets both classifyInteractivity (O(1) "has any?") and
+/// getListenerTypes (O(1) "which ones?") avoid re-iterating per element.
+fn buildListenerTargetMap(page: *Page, arena: Allocator) !ListenerTargetMap {
+    var map = ListenerTargetMap{};
+
+    // addEventListener registrations
+    var it = page._event_manager.lookup.iterator();
+    while (it.next()) |entry| {
+        const list = entry.value_ptr.*;
+        if (list.first != null) {
+            const gop = try map.getOrPut(arena, entry.key_ptr.event_target);
+            if (!gop.found_existing) gop.value_ptr.* = .empty;
+            try gop.value_ptr.append(arena, entry.key_ptr.type_string.str());
+        }
+    }
+
+    // Inline handlers (onclick, onmousedown, etc.)
+    var attr_it = page._event_target_attr_listeners.iterator();
+    while (attr_it.next()) |entry| {
+        const gop = try map.getOrPut(arena, @intFromPtr(entry.key_ptr.target));
+        if (!gop.found_existing) gop.value_ptr.* = .empty;
+        // Strip "on" prefix to get the event type name.
+        try gop.value_ptr.append(arena, @tagName(entry.key_ptr.handler)[2..]);
+    }
+
+    return map;
+}
+
+fn classifyInteractivity(
+    el: *Element,
+    html_el: *Element.Html,
+    listener_targets: ListenerTargetMap,
+) ?InteractivityType {
+    // 1. Native interactive by tag
+    switch (el.getTag()) {
+        .button, .summary, .details, .select, .textarea => return .native,
+        .anchor, .area => {
+            if (el.getAttributeSafe(comptime .wrap("href")) != null) return .native;
+        },
+        .input => {
+            if (el.is(Element.Html.Input)) |input| {
+                if (input._input_type != .hidden) return .native;
+            }
+        },
+        else => {},
+    }
+
+    // 2. ARIA interactive role
+    if (el.getAttributeSafe(comptime .wrap("role"))) |role| {
+        if (isInteractiveRole(role)) return .aria;
+    }
+
+    // 3. contenteditable (15 bytes, exceeds SSO limit for comptime)
+    if (el.getAttributeSafe(.wrap("contenteditable"))) |ce| {
+        if (ce.len == 0 or std.ascii.eqlIgnoreCase(ce, "true")) return .contenteditable;
+    }
+
+    // 4. Event listeners (addEventListener or inline handlers)
+    const et_ptr = @intFromPtr(html_el.asEventTarget());
+    if (listener_targets.get(et_ptr) != null) return .listener;
+
+    // 5. Explicitly focusable via tabindex.
+    // Only count elements with an EXPLICIT tabindex attribute,
+    // since getTabIndex() returns 0 for all interactive tags by default
+    // (including anchors without href and hidden inputs).
+    if (el.getAttributeSafe(comptime .wrap("tabindex"))) |_| {
+        if (html_el.getTabIndex() >= 0) return .focusable;
+    }
+
+    return null;
+}
+
+fn isInteractiveRole(role: []const u8) bool {
+    const interactive_roles = [_][]const u8{
+        "button",           "link",          "tab",        "menuitem",
+        "menuitemcheckbox", "menuitemradio", "switch",     "checkbox",
+        "radio",            "slider",        "spinbutton", "searchbox",
+        "combobox",         "option",        "treeitem",
+    };
+    for (interactive_roles) |r| {
+        if (std.ascii.eqlIgnoreCase(role, r)) return true;
+    }
+    return false;
+}
+
+fn getRole(el: *Element) ?[]const u8 {
+    // Explicit role attribute takes precedence
+    if (el.getAttributeSafe(comptime .wrap("role"))) |role| return role;
+
+    // Implicit role from tag
+    return switch (el.getTag()) {
+        .button, .summary => "button",
+        .anchor, .area => if (el.getAttributeSafe(comptime .wrap("href")) != null) "link" else null,
+        .input => blk: {
+            if (el.is(Element.Html.Input)) |input| {
+                break :blk switch (input._input_type) {
+                    .text, .tel, .url, .email => "textbox",
+                    .checkbox => "checkbox",
+                    .radio => "radio",
+                    .button, .submit, .reset, .image => "button",
+                    .range => "slider",
+                    .number => "spinbutton",
+                    .search => "searchbox",
+                    else => null,
+                };
+            }
+            break :blk null;
+        },
+        .select => "combobox",
+        .textarea => "textbox",
+        .details => "group",
+        else => null,
+    };
+}
+
+fn getAccessibleName(el: *Element) ?[]const u8 {
+    // aria-label
+    if (el.getAttributeSafe(comptime .wrap("aria-label"))) |v| {
+        if (v.len > 0) return v;
+    }
+
+    // alt (for img, input[type=image])
+    if (el.getAttributeSafe(comptime .wrap("alt"))) |v| {
+        if (v.len > 0) return v;
+    }
+
+    // title
+    if (el.getAttributeSafe(comptime .wrap("title"))) |v| {
+        if (v.len > 0) return v;
+    }
+
+    // placeholder
+    if (el.getAttributeSafe(comptime .wrap("placeholder"))) |v| {
+        if (v.len > 0) return v;
+    }
+
+    // value (for buttons)
+    if (el.getTag() == .input) {
+        if (el.getAttributeSafe(comptime .wrap("value"))) |v| {
+            if (v.len > 0) return v;
+        }
+    }
+
+    // Text content (first non-empty text node, trimmed)
+    return getTextContent(el.asNode());
+}
+
+fn getTextContent(node: *Node) ?[]const u8 {
+    var tw = TreeWalker.FullExcludeSelf.init(node, .{});
+    while (tw.next()) |child| {
+        // Skip text inside script/style elements.
+        if (child.is(Element)) |el| {
+            switch (el.getTag()) {
+                .script, .style => {
+                    tw.skipChildren();
+                    continue;
+                },
+                else => {},
+            }
+        }
+        if (child.is(Node.CData)) |cdata| {
+            if (cdata.is(Node.CData.Text)) |text| {
+                const content = std.mem.trim(u8, text.getWholeText(), &std.ascii.whitespace);
+                if (content.len > 0) return content;
+            }
+        }
+    }
+    return null;
+}
+
+fn isDisabled(el: *Element) bool {
+    return el.getAttributeSafe(comptime .wrap("disabled")) != null;
+}
+
+fn getInputType(el: *Element) ?[]const u8 {
+    if (el.is(Element.Html.Input)) |input| {
+        return input._input_type.toString();
+    }
+    return null;
+}
+
+fn getInputValue(el: *Element) ?[]const u8 {
+    if (el.is(Element.Html.Input)) |input| {
+        return input.getValue();
+    }
+    return null;
+}
+
+/// Get all event listener types registered on this target.
+fn getListenerTypes(target: *EventTarget, listener_targets: ListenerTargetMap) []const []const u8 {
+    if (listener_targets.get(@intFromPtr(target))) |types| return types.items;
+    return &.{};
+}
+
+const testing = @import("../testing.zig");
+
+fn testInteractive(html: []const u8) ![]InteractiveElement {
+    const page = try testing.test_session.createPage();
+    defer testing.test_session.removePage();
+
+    const doc = page.window._document;
+    const div = try doc.createElement("div", null, page);
+    try page.parseHtmlAsChildren(div.asNode(), html);
+
+    return collectInteractiveElements(div.asNode(), page, page.call_arena);
+}
+
+test "browser.interactive: button" {
+    const elements = try testInteractive("<button>Click me</button>");
+    try testing.expectEqual(1, elements.len);
+    try testing.expectEqual("button", elements[0].tag_name);
+    try testing.expectEqual("button", elements[0].role.?);
+    try testing.expectEqual("Click me", elements[0].name.?);
+    try testing.expectEqual(InteractivityType.native, elements[0].interactivity_type);
+}
+
+test "browser.interactive: anchor with href" {
+    const elements = try testInteractive("<a href=\"/page\">Link</a>");
+    try testing.expectEqual(1, elements.len);
+    try testing.expectEqual("a", elements[0].tag_name);
+    try testing.expectEqual("link", elements[0].role.?);
+    try testing.expectEqual("Link", elements[0].name.?);
+}
+
+test "browser.interactive: anchor without href" {
+    const elements = try testInteractive("<a>Not a link</a>");
+    try testing.expectEqual(0, elements.len);
+}
+
+test "browser.interactive: input types" {
+    const elements = try testInteractive(
+        \\<input type="text" placeholder="Search">
+        \\<input type="hidden" name="csrf">
+    );
+    try testing.expectEqual(1, elements.len);
+    try testing.expectEqual("input", elements[0].tag_name);
+    try testing.expectEqual("text", elements[0].input_type.?);
+    try testing.expectEqual("Search", elements[0].placeholder.?);
+}
+
+test "browser.interactive: select and textarea" {
+    const elements = try testInteractive(
+        \\<select name="color"><option>Red</option></select>
+        \\<textarea name="msg"></textarea>
+    );
+    try testing.expectEqual(2, elements.len);
+    try testing.expectEqual("select", elements[0].tag_name);
+    try testing.expectEqual("textarea", elements[1].tag_name);
+}
+
+test "browser.interactive: aria role" {
+    const elements = try testInteractive("<div role=\"button\">Custom</div>");
+    try testing.expectEqual(1, elements.len);
+    try testing.expectEqual("div", elements[0].tag_name);
+    try testing.expectEqual("button", elements[0].role.?);
+    try testing.expectEqual(InteractivityType.aria, elements[0].interactivity_type);
+}
+
+test "browser.interactive: contenteditable" {
+    const elements = try testInteractive("<div contenteditable=\"true\">Edit me</div>");
+    try testing.expectEqual(1, elements.len);
+    try testing.expectEqual(InteractivityType.contenteditable, elements[0].interactivity_type);
+}
+
+test "browser.interactive: tabindex" {
+    const elements = try testInteractive("<div tabindex=\"0\">Focusable</div>");
+    try testing.expectEqual(1, elements.len);
+    try testing.expectEqual(InteractivityType.focusable, elements[0].interactivity_type);
+    try testing.expectEqual(@as(i32, 0), elements[0].tab_index);
+}
+
+test "browser.interactive: disabled" {
+    const elements = try testInteractive("<button disabled>Off</button>");
+    try testing.expectEqual(1, elements.len);
+    try testing.expect(elements[0].disabled);
+}
+
+test "browser.interactive: non-interactive div" {
+    const elements = try testInteractive("<div>Just text</div>");
+    try testing.expectEqual(0, elements.len);
+}
+
+test "browser.interactive: details and summary" {
+    const elements = try testInteractive("<details><summary>More</summary><p>Content</p></details>");
+    try testing.expectEqual(2, elements.len);
+    try testing.expectEqual("details", elements[0].tag_name);
+    try testing.expectEqual("summary", elements[1].tag_name);
+}
+
+test "browser.interactive: mixed elements" {
+    const elements = try testInteractive(
+        \\<div>
+        \\  <a href="/home">Home</a>
+        \\  <p>Some text</p>
+        \\  <button id="btn1">Submit</button>
+        \\  <input type="email" placeholder="Email">
+        \\  <div>Not interactive</div>
+        \\  <div role="tab">Tab</div>
+        \\</div>
+    );
+    try testing.expectEqual(4, elements.len);
+}
diff --git a/src/cdp/domains/lp.zig b/src/cdp/domains/lp.zig
index 5503c356..d5f5cff3 100644
--- a/src/cdp/domains/lp.zig
+++ b/src/cdp/domains/lp.zig
@@ -19,15 +19,18 @@
 const std = @import("std");
 const lp = @import("lightpanda");
 const markdown = lp.markdown;
+const interactive = lp.interactive;
 const Node = @import("../Node.zig");
 
 pub fn processMessage(cmd: anytype) !void {
     const action = std.meta.stringToEnum(enum {
         getMarkdown,
+        getInteractiveElements,
     }, cmd.input.action) orelse return error.UnknownMethod;
 
     switch (action) {
         .getMarkdown => return getMarkdown(cmd),
+        .getInteractiveElements => return getInteractiveElements(cmd),
     }
 }
 
@@ -54,6 +57,35 @@ fn getMarkdown(cmd: anytype) !void {
     }, .{});
 }
 
+fn getInteractiveElements(cmd: anytype) !void {
+    const Params = struct {
+        nodeId: ?Node.Id = null,
+    };
+    const params = (try cmd.params(Params)) orelse Params{};
+
+    const bc = cmd.browser_context orelse return error.NoBrowserContext;
+    const page = bc.session.currentPage() orelse return error.PageNotLoaded;
+
+    const root = if (params.nodeId) |nodeId|
+        (bc.node_registry.lookup_by_id.get(nodeId) orelse return error.InvalidNodeId).dom
+    else
+        page.document.asNode();
+
+    const elements = try interactive.collectInteractiveElements(root, page, cmd.arena);
+
+    // Register nodes so nodeIds are valid for subsequent CDP calls.
+    var node_ids: std.ArrayList(Node.Id) = try .initCapacity(cmd.arena, elements.len);
+    for (elements) |el| {
+        const registered = try bc.node_registry.register(el.node);
+        node_ids.appendAssumeCapacity(registered.id);
+    }
+
+    return cmd.sendResult(.{
+        .elements = elements,
+        .nodeIds = node_ids.items,
+    }, .{});
+}
+
 const testing = @import("../testing.zig");
 test "cdp.lp: getMarkdown" {
     var ctx = testing.context();
@@ -70,3 +102,20 @@ test "cdp.lp: getMarkdown" {
     const result = ctx.client.?.sent.items[0].object.get("result").?.object;
     try testing.expect(result.get("markdown") != null);
 }
+
+test "cdp.lp: getInteractiveElements" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    const bc = try ctx.loadBrowserContext(.{});
+    _ = try bc.session.createPage();
+
+    try ctx.processMessage(.{
+        .id = 1,
+        .method = "LP.getInteractiveElements",
+    });
+
+    const result = ctx.client.?.sent.items[0].object.get("result").?.object;
+    try testing.expect(result.get("elements") != null);
+    try testing.expect(result.get("nodeIds") != null);
+}
diff --git a/src/lightpanda.zig b/src/lightpanda.zig
index 26bc23f0..34deb146 100644
--- a/src/lightpanda.zig
+++ b/src/lightpanda.zig
@@ -30,6 +30,7 @@ pub const log = @import("log.zig");
 pub const js = @import("browser/js/js.zig");
 pub const dump = @import("browser/dump.zig");
 pub const markdown = @import("browser/markdown.zig");
+pub const interactive = @import("browser/interactive.zig");
 pub const mcp = @import("mcp.zig");
 pub const build_config = @import("build_config");
 pub const crash_handler = @import("crash_handler.zig");

From dc3958356d9f3da6d887e3216d5db256bc28bd9a Mon Sep 17 00:00:00 2001
From: egrs <egrs@users.noreply.github.com>
Date: Tue, 10 Mar 2026 08:13:01 +0100
Subject: [PATCH 7/8] address review feedback

- TreeWalker.Full instead of FullExcludeSelf so querying a specific
  nodeId evaluates the root element itself
- resolve href to absolute URL via URL.resolve
- isDisabled checks ancestor <fieldset disabled> with legend exemption
- parameter order: allocator before *Page per convention
---
 src/browser/interactive.zig | 55 +++++++++++++++++++++++++++++++++----
 src/cdp/domains/lp.zig      |  2 +-
 2 files changed, 51 insertions(+), 6 deletions(-)

diff --git a/src/browser/interactive.zig b/src/browser/interactive.zig
index cf623f6c..b0428a6c 100644
--- a/src/browser/interactive.zig
+++ b/src/browser/interactive.zig
@@ -19,6 +19,7 @@
 const std = @import("std");
 
 const Page = @import("Page.zig");
+const URL = @import("URL.zig");
 const TreeWalker = @import("webapi/TreeWalker.zig");
 const Element = @import("webapi/Element.zig");
 const Node = @import("webapi/Node.zig");
@@ -125,8 +126,8 @@ pub const InteractiveElement = struct {
 /// Collect all interactive elements under `root`.
 pub fn collectInteractiveElements(
     root: *Node,
-    page: *Page,
     arena: Allocator,
+    page: *Page,
 ) ![]InteractiveElement {
     // Pre-build a map of event_target pointer → event type names,
     // so classify and getListenerTypes are both O(1) per element.
@@ -134,7 +135,7 @@ pub fn collectInteractiveElements(
 
     var results: std.ArrayList(InteractiveElement) = .empty;
 
-    var tw = TreeWalker.FullExcludeSelf.init(root, .{});
+    var tw = TreeWalker.Full.init(root, .{});
     while (tw.next()) |node| {
         const el = node.is(Element) orelse continue;
         const html_el = el.is(Element.Html) orelse continue;
@@ -163,7 +164,10 @@ pub fn collectInteractiveElements(
             .tab_index = html_el.getTabIndex(),
             .id = el.getAttributeSafe(comptime .wrap("id")),
             .class = el.getAttributeSafe(comptime .wrap("class")),
-            .href = el.getAttributeSafe(comptime .wrap("href")),
+            .href = if (el.getAttributeSafe(comptime .wrap("href"))) |href|
+                URL.resolve(arena, page.base(), href, .{ .encode = true }) catch href
+            else
+                null,
             .input_type = getInputType(el),
             .value = getInputValue(el),
             .element_name = el.getAttributeSafe(comptime .wrap("name")),
@@ -348,7 +352,34 @@ fn getTextContent(node: *Node) ?[]const u8 {
 }
 
 fn isDisabled(el: *Element) bool {
-    return el.getAttributeSafe(comptime .wrap("disabled")) != null;
+    if (el.getAttributeSafe(comptime .wrap("disabled")) != null) return true;
+    return isDisabledByFieldset(el);
+}
+
+/// Check if an element is disabled by an ancestor <fieldset disabled>.
+/// Per spec, elements inside the first <legend> child of a disabled fieldset
+/// are NOT disabled by that fieldset.
+fn isDisabledByFieldset(el: *Element) bool {
+    const element_node = el.asNode();
+    var current: ?*Node = element_node._parent;
+    while (current) |node| {
+        current = node._parent;
+        const ancestor = node.is(Element) orelse continue;
+
+        if (ancestor.getTag() == .fieldset and ancestor.getAttributeSafe(comptime .wrap("disabled")) != null) {
+            // Check if element is inside the first <legend> child of this fieldset
+            var child = ancestor.firstElementChild();
+            while (child) |c| {
+                if (c.getTag() == .legend) {
+                    if (c.asNode().contains(element_node)) return false;
+                    break;
+                }
+                child = c.nextElementSibling();
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
 fn getInputType(el: *Element) ?[]const u8 {
@@ -381,7 +412,7 @@ fn testInteractive(html: []const u8) ![]InteractiveElement {
     const div = try doc.createElement("div", null, page);
     try page.parseHtmlAsChildren(div.asNode(), html);
 
-    return collectInteractiveElements(div.asNode(), page, page.call_arena);
+    return collectInteractiveElements(div.asNode(), page.call_arena, page);
 }
 
 test "browser.interactive: button" {
@@ -454,6 +485,20 @@ test "browser.interactive: disabled" {
     try testing.expect(elements[0].disabled);
 }
 
+test "browser.interactive: disabled by fieldset" {
+    const elements = try testInteractive(
+        \\<fieldset disabled>
+        \\  <button>Disabled</button>
+        \\  <legend><button>In legend</button></legend>
+        \\</fieldset>
+    );
+    try testing.expectEqual(2, elements.len);
+    // Button outside legend is disabled by fieldset
+    try testing.expect(elements[0].disabled);
+    // Button inside first legend is NOT disabled
+    try testing.expect(!elements[1].disabled);
+}
+
 test "browser.interactive: non-interactive div" {
     const elements = try testInteractive("<div>Just text</div>");
     try testing.expectEqual(0, elements.len);
diff --git a/src/cdp/domains/lp.zig b/src/cdp/domains/lp.zig
index d5f5cff3..8263322b 100644
--- a/src/cdp/domains/lp.zig
+++ b/src/cdp/domains/lp.zig
@@ -71,7 +71,7 @@ fn getInteractiveElements(cmd: anytype) !void {
     else
         page.document.asNode();
 
-    const elements = try interactive.collectInteractiveElements(root, page, cmd.arena);
+    const elements = try interactive.collectInteractiveElements(root, cmd.arena, page);
 
     // Register nodes so nodeIds are valid for subsequent CDP calls.
     var node_ids: std.ArrayList(Node.Id) = try .initCapacity(cmd.arena, elements.len);

From d669d5c15346c4e986b270ed0711267896b7269d Mon Sep 17 00:00:00 2001
From: Pierre Tachoire <pierre@lightpanda.io>
Date: Mon, 9 Mar 2026 16:40:57 +0100
Subject: [PATCH 8/8] cdp: add a dummy Page.getLayoutMetrics

---
 src/cdp/domains/page.zig | 112 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)

diff --git a/src/cdp/domains/page.zig b/src/cdp/domains/page.zig
index d4b7b301..70f349a9 100644
--- a/src/cdp/domains/page.zig
+++ b/src/cdp/domains/page.zig
@@ -42,6 +42,7 @@ pub fn processMessage(cmd: anytype) !void {
         stopLoading,
         close,
         captureScreenshot,
+        getLayoutMetrics,
     }, cmd.input.action) orelse return error.UnknownMethod;
 
     switch (action) {
@@ -54,6 +55,7 @@ pub fn processMessage(cmd: anytype) !void {
         .stopLoading => return cmd.sendResult(null, .{}),
         .close => return close(cmd),
         .captureScreenshot => return captureScreenshot(cmd),
+        .getLayoutMetrics => return getLayoutMetrics(cmd),
     }
 }
 
@@ -569,6 +571,58 @@ fn captureScreenshot(cmd: anytype) !void {
     }, .{});
 }
 
+fn getLayoutMetrics(cmd: anytype) !void {
+    const width = 1920;
+    const height = 1080;
+
+    return cmd.sendResult(.{
+        .layoutViewport = .{
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+        },
+        .visualViewport = .{
+            .offsetX = 0,
+            .offsetY = 0,
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+            .scale = 1,
+            .zoom = 1,
+        },
+        .contentSize = .{
+            .x = 0,
+            .y = 0,
+            .width = width,
+            .height = height,
+        },
+        .cssLayoutViewport = .{
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+        },
+        .cssVisualViewport = .{
+            .offsetX = 0,
+            .offsetY = 0,
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+            .scale = 1,
+            .zoom = 1,
+        },
+        .cssContentSize = .{
+            .x = 0,
+            .y = 0,
+            .width = width,
+            .height = height,
+        },
+    }, .{});
+}
+
 const testing = @import("../testing.zig");
 test "cdp.page: getFrameTree" {
     var ctx = testing.context();
@@ -618,3 +672,61 @@ test "cdp.page: captureScreenshot" {
         }, .{ .id = 11 });
     }
 }
+
+test "cdp.page: getLayoutMetrics" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    _ = try ctx.loadBrowserContext(.{ .id = "BID-9", .url = "hi.html", .target_id = "FID-000000000X".* });
+
+    const width = 1920;
+    const height = 1080;
+
+    try ctx.processMessage(.{ .id = 12, .method = "Page.getLayoutMetrics" });
+    try ctx.expectSentResult(.{
+        .layoutViewport = .{
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+        },
+        .visualViewport = .{
+            .offsetX = 0,
+            .offsetY = 0,
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+            .scale = 1,
+            .zoom = 1,
+        },
+        .contentSize = .{
+            .x = 0,
+            .y = 0,
+            .width = width,
+            .height = height,
+        },
+        .cssLayoutViewport = .{
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+        },
+        .cssVisualViewport = .{
+            .offsetX = 0,
+            .offsetY = 0,
+            .pageX = 0,
+            .pageY = 0,
+            .clientWidth = width,
+            .clientHeight = height,
+            .scale = 1,
+            .zoom = 1,
+        },
+        .cssContentSize = .{
+            .x = 0,
+            .y = 0,
+            .width = width,
+            .height = height,
+        },
+    }, .{ .id = 12 });
+}