Add CDP Node Registry

This expands on the existing CDP node work used in  DOM.search. It introduces
a node registry to track all nodes returned to the client and give lookups to
get a node from a Id or a *parser.node.

Eventually, the goal is to have the Registry emit the DOM.setChildNodes event
whenever necessary, as well as support many of the missing DOM actions.

Added tests to existing search handlers. Reworked search a little bit to avoid
some unnecessary allocations and to hook it into the registry.

The generated Node is currently incomplete. The parentId is missing, the
children are missing. Also, we still need to associate the v8 ObjectId to the
node.

Finally, I moved all action handlers into a nested "domain" folder.

src/cdp/domains/browser.zig

@@ -0,0 +1,117 @@
+// Copyright (C) 2023-2024  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");
+
+// TODO: hard coded data
+const PROTOCOL_VERSION = "1.3";
+const PRODUCT = "Chrome/124.0.6367.29";
+const REVISION = "@9e6ded5ac1ff5e38d930ae52bd9aec09bd1a68e4";
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+const JS_VERSION = "12.4.254.8";
+const DEV_TOOLS_WINDOW_ID = 1923710101;
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        getVersion,
+        setDownloadBehavior,
+        getWindowForTarget,
+        setWindowBounds,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .getVersion => return getVersion(cmd),
+        .setDownloadBehavior => return setDownloadBehavior(cmd),
+        .getWindowForTarget => return getWindowForTarget(cmd),
+        .setWindowBounds => return setWindowBounds(cmd),
+    }
+}
+
+fn getVersion(cmd: anytype) !void {
+    // TODO: pre-serialize?
+    return cmd.sendResult(.{
+        .protocolVersion = PROTOCOL_VERSION,
+        .product = PRODUCT,
+        .revision = REVISION,
+        .userAgent = USER_AGENT,
+        .jsVersion = JS_VERSION,
+    }, .{ .include_session_id = false });
+}
+
+// TODO: noop method
+fn setDownloadBehavior(cmd: anytype) !void {
+    // const params = (try cmd.params(struct {
+    //     behavior: []const u8,
+    //     browserContextId: ?[]const u8 = null,
+    //     downloadPath: ?[]const u8 = null,
+    //     eventsEnabled: ?bool = null,
+    // })) orelse return error.InvalidParams;
+
+    return cmd.sendResult(null, .{ .include_session_id = false });
+}
+
+fn getWindowForTarget(cmd: anytype) !void {
+    // const params = (try cmd.params(struct {
+    //     targetId: ?[]const u8 = null,
+    // })) orelse return error.InvalidParams;
+
+    return cmd.sendResult(.{ .windowId = DEV_TOOLS_WINDOW_ID, .bounds = .{
+        .windowState = "normal",
+    } }, .{});
+}
+
+// TODO: noop method
+fn setWindowBounds(cmd: anytype) !void {
+    return cmd.sendResult(null, .{});
+}
+
+const testing = @import("../testing.zig");
+test "cdp.browser: getVersion" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    try ctx.processMessage(.{
+        .id = 32,
+        .method = "Browser.getVersion",
+    });
+
+    try ctx.expectSentCount(1);
+    try ctx.expectSentResult(.{
+        .protocolVersion = PROTOCOL_VERSION,
+        .product = PRODUCT,
+        .revision = REVISION,
+        .userAgent = USER_AGENT,
+        .jsVersion = JS_VERSION,
+    }, .{ .id = 32, .index = 0, .session_id = null });
+}
+
+test "cdp.browser: getWindowForTarget" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    try ctx.processMessage(.{
+        .id = 33,
+        .method = "Browser.getWindowForTarget",
+    });
+
+    try ctx.expectSentCount(1);
+    try ctx.expectSentResult(.{
+        .windowId = DEV_TOOLS_WINDOW_ID,
+        .bounds = .{ .windowState = "normal" },
+    }, .{ .id = 33, .index = 0, .session_id = null });
+}

src/cdp/domains/css.zig

@@ -0,0 +1,29 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/dom.zig

@@ -0,0 +1,184 @@
+// Copyright (C) 2023-2024  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 parser = @import("netsurf");
+const Node = @import("../Node.zig");
+const css = @import("../../dom/css.zig");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+        getDocument,
+        performSearch,
+        getSearchResults,
+        discardSearchResults,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+        .getDocument => return getDocument(cmd),
+        .performSearch => return performSearch(cmd),
+        .getSearchResults => return getSearchResults(cmd),
+        .discardSearchResults => return discardSearchResults(cmd),
+    }
+}
+
+// https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDocument
+fn getDocument(cmd: anytype) !void {
+    // const params = (try cmd.params(struct {
+    //     depth: ?u32 = null,
+    //     pierce: ?bool = null,
+    // })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const page = bc.session.currentPage() orelse return error.PageNotLoaded;
+    const doc = page.doc orelse return error.DocumentNotLoaded;
+
+    const node = try bc.node_registry.register(parser.documentToNode(doc));
+    return cmd.sendResult(.{
+        .root = node,
+    }, .{});
+}
+
+// https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-performSearch
+fn performSearch(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        query: []const u8,
+        includeUserAgentShadowDOM: ?bool = null,
+    })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const page = bc.session.currentPage() orelse return error.PageNotLoaded;
+    const doc = page.doc orelse return error.DocumentNotLoaded;
+
+    const allocator = cmd.cdp.allocator;
+    var list = try css.querySelectorAll(allocator, parser.documentToNode(doc), params.query);
+    defer list.deinit(allocator);
+
+    const search = try bc.node_search_list.create(list.nodes.items);
+
+    return cmd.sendResult(.{
+        .searchId = search.name,
+        .resultCount = @as(u32, @intCast(search.node_ids.len)),
+    }, .{});
+}
+
+// https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-discardSearchResults
+fn discardSearchResults(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        searchId: []const u8,
+    })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+
+    bc.node_search_list.remove(params.searchId);
+    return cmd.sendResult(null, .{});
+}
+
+// https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getSearchResults
+fn getSearchResults(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        searchId: []const u8,
+        fromIndex: u32,
+        toIndex: u32,
+    })) orelse return error.InvalidParams;
+
+    if (params.fromIndex >= params.toIndex) {
+        return error.BadIndices;
+    }
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+
+    const search = bc.node_search_list.get(params.searchId) orelse {
+        return error.SearchResultNotFound;
+    };
+
+    const node_ids = search.node_ids;
+
+    if (params.fromIndex >= node_ids.len) return error.BadFromIndex;
+    if (params.toIndex > node_ids.len) return error.BadToIndex;
+
+    return cmd.sendResult(.{ .nodeIds = node_ids[params.fromIndex..params.toIndex] }, .{});
+}
+
+const testing = @import("../testing.zig");
+test "cdp.dom: getSearchResults unknown search id" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    try testing.expectError(error.BrowserContextNotLoaded, ctx.processMessage(.{
+        .id = 8,
+        .method = "DOM.getSearchResults",
+        .params = .{ .searchId = "Nope", .fromIndex = 0, .toIndex = 10 },
+    }));
+}
+
+test "cdp.dom: search flow" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    _ = try ctx.loadBrowserContext(.{ .id = "BID-A", .html = "<p>1</p> <p>2</p>" });
+
+    try ctx.processMessage(.{
+        .id = 12,
+        .method = "DOM.performSearch",
+        .params = .{ .query = "p" },
+    });
+    try ctx.expectSentResult(.{ .searchId = "0", .resultCount = 2 }, .{ .id = 12 });
+
+    {
+        // getSearchResults
+        try ctx.processMessage(.{
+            .id = 13,
+            .method = "DOM.getSearchResults",
+            .params = .{ .searchId = "0", .fromIndex = 0, .toIndex = 2 },
+        });
+        try ctx.expectSentResult(.{ .nodeIds = &.{ 0, 1 } }, .{ .id = 13 });
+
+        // different fromIndex
+        try ctx.processMessage(.{
+            .id = 14,
+            .method = "DOM.getSearchResults",
+            .params = .{ .searchId = "0", .fromIndex = 1, .toIndex = 2 },
+        });
+        try ctx.expectSentResult(.{ .nodeIds = &.{1} }, .{ .id = 14 });
+
+        // different toIndex
+        try ctx.processMessage(.{
+            .id = 15,
+            .method = "DOM.getSearchResults",
+            .params = .{ .searchId = "0", .fromIndex = 0, .toIndex = 1 },
+        });
+        try ctx.expectSentResult(.{ .nodeIds = &.{0} }, .{ .id = 15 });
+    }
+
+    try ctx.processMessage(.{
+        .id = 16,
+        .method = "DOM.discardSearchResults",
+        .params = .{ .searchId = "0" },
+    });
+    try ctx.expectSentResult(null, .{ .id = 16 });
+
+    // make sure the delete actually did something
+    try testing.expectError(error.SearchResultNotFound, ctx.processMessage(.{
+        .id = 17,
+        .method = "DOM.getSearchResults",
+        .params = .{ .searchId = "0", .fromIndex = 0, .toIndex = 1 },
+    }));
+}

src/cdp/domains/emulation.zig

@@ -0,0 +1,67 @@
+// Copyright (C) 2023-2024  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 Runtime = @import("runtime.zig");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        setEmulatedMedia,
+        setFocusEmulationEnabled,
+        setDeviceMetricsOverride,
+        setTouchEmulationEnabled,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .setEmulatedMedia => return setEmulatedMedia(cmd),
+        .setFocusEmulationEnabled => return setFocusEmulationEnabled(cmd),
+        .setDeviceMetricsOverride => return setDeviceMetricsOverride(cmd),
+        .setTouchEmulationEnabled => return setTouchEmulationEnabled(cmd),
+    }
+}
+
+// TODO: noop method
+fn setEmulatedMedia(cmd: anytype) !void {
+    // const input = (try const incoming.params(struct {
+    //     media: ?[]const u8 = null,
+    //     features: ?[]struct{
+    //         name: []const u8,
+    //         value: [] const u8
+    //     } = null,
+    // })) orelse return error.InvalidParams;
+
+    return cmd.sendResult(null, .{});
+}
+
+// TODO: noop method
+fn setFocusEmulationEnabled(cmd: anytype) !void {
+    // const input = (try const incoming.params(struct {
+    //     enabled: bool,
+    // })) orelse return error.InvalidParams;
+    return cmd.sendResult(null, .{});
+}
+
+// TODO: noop method
+fn setDeviceMetricsOverride(cmd: anytype) !void {
+    return cmd.sendResult(null, .{});
+}
+
+// TODO: noop method
+fn setTouchEmulationEnabled(cmd: anytype) !void {
+    return cmd.sendResult(null, .{});
+}

src/cdp/domains/fetch.zig

@@ -0,0 +1,29 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        disable,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .disable => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/inspector.zig

@@ -0,0 +1,29 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/log.zig

@@ -0,0 +1,29 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/network.zig

@@ -0,0 +1,31 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+        setCacheDisabled,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+        .setCacheDisabled => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/page.zig

@@ -0,0 +1,298 @@
+// Copyright (C) 2023-2024  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 runtime = @import("runtime.zig");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+        getFrameTree,
+        setLifecycleEventsEnabled,
+        addScriptToEvaluateOnNewDocument,
+        createIsolatedWorld,
+        navigate,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+        .getFrameTree => return getFrameTree(cmd),
+        .setLifecycleEventsEnabled => return setLifecycleEventsEnabled(cmd),
+        .addScriptToEvaluateOnNewDocument => return addScriptToEvaluateOnNewDocument(cmd),
+        .createIsolatedWorld => return createIsolatedWorld(cmd),
+        .navigate => return navigate(cmd),
+    }
+}
+
+const Frame = struct {
+    id: []const u8,
+    loaderId: []const u8,
+    url: []const u8,
+    domainAndRegistry: []const u8 = "",
+    securityOrigin: []const u8,
+    mimeType: []const u8 = "text/html",
+    adFrameStatus: struct {
+        adFrameType: []const u8 = "none",
+    } = .{},
+    secureContextType: []const u8,
+    crossOriginIsolatedContextType: []const u8 = "NotIsolated",
+    gatedAPIFeatures: [][]const u8 = &[0][]const u8{},
+};
+
+fn getFrameTree(cmd: anytype) !void {
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const target_id = bc.target_id orelse return error.TargetNotLoaded;
+
+    return cmd.sendResult(.{
+        .frameTree = .{
+            .frame = Frame{
+                .url = bc.url,
+                .id = target_id,
+                .loaderId = bc.loader_id,
+                .securityOrigin = bc.security_origin,
+                .secureContextType = bc.secure_context_type,
+            },
+        },
+    }, .{});
+}
+
+fn setLifecycleEventsEnabled(cmd: anytype) !void {
+    // const params = (try cmd.params(struct {
+    //     enabled: bool,
+    // })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    bc.page_life_cycle_events = true;
+    return cmd.sendResult(null, .{});
+}
+
+// TODO: hard coded method
+fn addScriptToEvaluateOnNewDocument(cmd: anytype) !void {
+    // const params = (try cmd.params(struct {
+    //     source: []const u8,
+    //     worldName: ?[]const u8 = null,
+    //     includeCommandLineAPI: bool = false,
+    //     runImmediately: bool = false,
+    // })) orelse return error.InvalidParams;
+
+    return cmd.sendResult(.{
+        .identifier = "1",
+    }, .{});
+}
+
+// TODO: hard coded method
+fn createIsolatedWorld(cmd: anytype) !void {
+    _ = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+
+    const session_id = cmd.input.session_id orelse return error.SessionIdRequired;
+
+    const params = (try cmd.params(struct {
+        frameId: []const u8,
+        worldName: []const u8,
+        grantUniveralAccess: bool,
+    })) orelse return error.InvalidParams;
+
+    // noop executionContextCreated event
+    try cmd.sendEvent("Runtime.executionContextCreated", .{
+        .context = runtime.ExecutionContextCreated{
+            .id = 0,
+            .origin = "",
+            .name = params.worldName,
+            // TODO: hard coded ID
+            .uniqueId = "7102379147004877974.3265385113993241162",
+            .auxData = .{
+                .isDefault = false,
+                .type = "isolated",
+                .frameId = params.frameId,
+            },
+        },
+    }, .{ .session_id = session_id });
+
+    return cmd.sendResult(.{
+        .executionContextId = 0,
+    }, .{});
+}
+
+fn navigate(cmd: anytype) !void {
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+
+    // didn't create?
+    const target_id = bc.target_id orelse return error.TargetIdNotLoaded;
+
+    // didn't attach?
+    const session_id = bc.session_id orelse return error.SessionIdNotLoaded;
+
+    // if we have a target_id we have to have a page;
+    std.debug.assert(bc.session.page != null);
+
+    const params = (try cmd.params(struct {
+        url: []const u8,
+        referrer: ?[]const u8 = null,
+        transitionType: ?[]const u8 = null, // TODO: enum
+        frameId: ?[]const u8 = null,
+        referrerPolicy: ?[]const u8 = null, // TODO: enum
+    })) orelse return error.InvalidParams;
+
+    // change state
+    bc.reset();
+    bc.url = params.url;
+
+    // TODO: hard coded ID
+    bc.loader_id = "AF8667A203C5392DBE9AC290044AA4C2";
+
+    const LifecycleEvent = struct {
+        frameId: []const u8,
+        loaderId: ?[]const u8,
+        name: []const u8,
+        timestamp: f32,
+    };
+
+    var life_event = LifecycleEvent{
+        .frameId = target_id,
+        .loaderId = bc.loader_id,
+        .name = "init",
+        .timestamp = 343721.796037,
+    };
+
+    // frameStartedLoading event
+    // TODO: event partially hard coded
+    try cmd.sendEvent("Page.frameStartedLoading", .{
+        .frameId = target_id,
+    }, .{ .session_id = session_id });
+
+    if (bc.page_life_cycle_events) {
+        try cmd.sendEvent("Page.lifecycleEvent", life_event, .{ .session_id = session_id });
+    }
+
+    // output
+    try cmd.sendResult(.{
+        .frameId = target_id,
+        .loaderId = bc.loader_id,
+    }, .{});
+
+    // TODO: at this point do we need async the following actions to be async?
+
+    // Send Runtime.executionContextsCleared event
+    // TODO: noop event, we have no env context at this point, is it necesarry?
+    try cmd.sendEvent("Runtime.executionContextsCleared", null, .{ .session_id = session_id });
+
+    const aux_data = try std.fmt.allocPrint(
+        cmd.arena,
+        // NOTE: we assume this is the default web page
+        "{{\"isDefault\":true,\"type\":\"default\",\"frameId\":\"{s}\"}}",
+        .{target_id},
+    );
+
+    var page = bc.session.currentPage().?;
+    try page.navigate(params.url, aux_data);
+
+    // Events
+
+    // lifecycle init event
+    // TODO: partially hard coded
+    if (bc.page_life_cycle_events) {
+        life_event.name = "init";
+        life_event.timestamp = 343721.796037;
+        try cmd.sendEvent("Page.lifecycleEvent", life_event, .{ .session_id = session_id });
+    }
+
+    try cmd.sendEvent("DOM.documentUpdated", null, .{ .session_id = session_id });
+
+    // frameNavigated event
+    try cmd.sendEvent("Page.frameNavigated", .{
+        .type = "Navigation",
+        .frame = Frame{
+            .id = target_id,
+            .url = bc.url,
+            .securityOrigin = bc.security_origin,
+            .secureContextType = bc.secure_context_type,
+            .loaderId = bc.loader_id,
+        },
+    }, .{ .session_id = session_id });
+
+    // domContentEventFired event
+    // TODO: partially hard coded
+    try cmd.sendEvent(
+        "Page.domContentEventFired",
+        .{ .timestamp = 343721.803338 },
+        .{ .session_id = session_id },
+    );
+
+    // lifecycle DOMContentLoaded event
+    // TODO: partially hard coded
+    if (bc.page_life_cycle_events) {
+        life_event.name = "DOMContentLoaded";
+        life_event.timestamp = 343721.803338;
+        try cmd.sendEvent("Page.lifecycleEvent", life_event, .{ .session_id = session_id });
+    }
+
+    // loadEventFired event
+    // TODO: partially hard coded
+    try cmd.sendEvent(
+        "Page.loadEventFired",
+        .{ .timestamp = 343721.824655 },
+        .{ .session_id = session_id },
+    );
+
+    // lifecycle DOMContentLoaded event
+    // TODO: partially hard coded
+    if (bc.page_life_cycle_events) {
+        life_event.name = "load";
+        life_event.timestamp = 343721.824655;
+        try cmd.sendEvent("Page.lifecycleEvent", life_event, .{ .session_id = session_id });
+    }
+
+    // frameStoppedLoading
+    return cmd.sendEvent("Page.frameStoppedLoading", .{
+        .frameId = target_id,
+    }, .{ .session_id = session_id });
+}
+
+const testing = @import("../testing.zig");
+test "cdp.page: getFrameTree" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    {
+        try testing.expectError(error.BrowserContextNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Page.getFrameTree", .params = .{ .targetId = "X" } }));
+        try ctx.expectSentError(-31998, "BrowserContextNotLoaded", .{ .id = 10 });
+    }
+
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9", .target_id = "TID-3" });
+    {
+        try ctx.processMessage(.{ .id = 11, .method = "Page.getFrameTree" });
+        try ctx.expectSentResult(.{
+            .frameTree = .{
+                .frame = .{
+                    .id = "TID-3",
+                    .loaderId = bc.loader_id,
+                    .url = bc.url,
+                    .domainAndRegistry = "",
+                    .securityOrigin = bc.security_origin,
+                    .mimeType = "text/html",
+                    .adFrameStatus = .{
+                        .adFrameType = "none",
+                    },
+                    .secureContextType = bc.secure_context_type,
+                    .crossOriginIsolatedContextType = "NotIsolated",
+                    .gatedAPIFeatures = [_][]const u8{},
+                },
+            },
+        }, .{ .id = 11 });
+    }
+}

src/cdp/domains/performance.zig

@@ -0,0 +1,29 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/runtime.zig

@@ -0,0 +1,107 @@
+// Copyright (C) 2023-2024  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 builtin = @import("builtin");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+        runIfWaitingForDebugger,
+        evaluate,
+        addBinding,
+        callFunctionOn,
+        releaseObject,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .runIfWaitingForDebugger => return cmd.sendResult(null, .{}),
+        else => return sendInspector(cmd, action),
+    }
+}
+
+fn sendInspector(cmd: anytype, action: anytype) !void {
+    // save script in file at debug mode
+    if (builtin.mode == .Debug) {
+        try logInspector(cmd, action);
+    }
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+
+    // the result to return is handled directly by the inspector.
+    bc.session.callInspector(cmd.input.json);
+
+    // force running micro tasks after send input to the inspector.
+    cmd.cdp.browser.runMicrotasks();
+}
+
+pub const ExecutionContextCreated = struct {
+    id: u64,
+    origin: []const u8,
+    name: []const u8,
+    uniqueId: []const u8,
+    auxData: ?AuxData = null,
+
+    pub const AuxData = struct {
+        isDefault: bool = true,
+        type: []const u8 = "default",
+        frameId: []const u8,
+    };
+};
+
+fn logInspector(cmd: anytype, action: anytype) !void {
+    const script = switch (action) {
+        .evaluate => blk: {
+            const params = (try cmd.params(struct {
+                expression: []const u8,
+                // contextId: ?u8 = null,
+                // returnByValue: ?bool = null,
+                // awaitPromise: ?bool = null,
+                // userGesture: ?bool = null,
+            })) orelse return error.InvalidParams;
+
+            break :blk params.expression;
+        },
+        .callFunctionOn => blk: {
+            const params = (try cmd.params(struct {
+                functionDeclaration: []const u8,
+                // objectId: ?[]const u8 = null,
+                // executionContextId: ?u8 = null,
+                // arguments: ?[]struct {
+                //     value: ?[]const u8 = null,
+                //     objectId: ?[]const u8 = null,
+                // } = null,
+                // returnByValue: ?bool = null,
+                // awaitPromise: ?bool = null,
+                // userGesture: ?bool = null,
+            })) orelse return error.InvalidParams;
+
+            break :blk params.functionDeclaration;
+        },
+        else => return,
+    };
+    const id = cmd.input.id orelse return error.RequiredId;
+    const name = try std.fmt.allocPrint(cmd.arena, "id_{d}.js", .{id});
+
+    var dir = try std.fs.cwd().makeOpenPath(".zig-cache/tmp", .{});
+    defer dir.close();
+
+    const f = try dir.createFile(name, .{});
+    defer f.close();
+    try f.writeAll(script);
+}

src/cdp/domains/security.zig

@@ -0,0 +1,29 @@
+// Copyright (C) 2023-2024  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");
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        enable,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .enable => return cmd.sendResult(null, .{}),
+    }
+}

src/cdp/domains/target.zig

@@ -0,0 +1,680 @@
+// Copyright (C) 2023-2024  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 log = std.log.scoped(.cdp);
+
+// TODO: hard coded IDs
+const LOADER_ID = "LOADERID42AA389647D702B4D805F49A";
+
+pub fn processMessage(cmd: anytype) !void {
+    const action = std.meta.stringToEnum(enum {
+        attachToTarget,
+        closeTarget,
+        createBrowserContext,
+        createTarget,
+        detachFromTarget,
+        disposeBrowserContext,
+        getBrowserContexts,
+        getTargetInfo,
+        sendMessageToTarget,
+        setAutoAttach,
+        setDiscoverTargets,
+    }, cmd.input.action) orelse return error.UnknownMethod;
+
+    switch (action) {
+        .attachToTarget => return attachToTarget(cmd),
+        .closeTarget => return closeTarget(cmd),
+        .createBrowserContext => return createBrowserContext(cmd),
+        .createTarget => return createTarget(cmd),
+        .detachFromTarget => return detachFromTarget(cmd),
+        .disposeBrowserContext => return disposeBrowserContext(cmd),
+        .getBrowserContexts => return getBrowserContexts(cmd),
+        .getTargetInfo => return getTargetInfo(cmd),
+        .sendMessageToTarget => return sendMessageToTarget(cmd),
+        .setAutoAttach => return setAutoAttach(cmd),
+        .setDiscoverTargets => return setDiscoverTargets(cmd),
+    }
+}
+
+fn getBrowserContexts(cmd: anytype) !void {
+    var browser_context_ids: []const []const u8 = undefined;
+    if (cmd.browser_context) |bc| {
+        browser_context_ids = &.{bc.id};
+    } else {
+        browser_context_ids = &.{};
+    }
+
+    return cmd.sendResult(.{
+        .browserContextIds = browser_context_ids,
+    }, .{ .include_session_id = false });
+}
+
+fn createBrowserContext(cmd: anytype) !void {
+    const bc = cmd.createBrowserContext() catch |err| switch (err) {
+        error.AlreadyExists => return cmd.sendError(-32000, "Cannot have more than one browser context at a time"),
+        else => return err,
+    };
+
+    return cmd.sendResult(.{
+        .browserContextId = bc.id,
+    }, .{});
+}
+
+fn disposeBrowserContext(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        browserContextId: []const u8,
+    })) orelse return error.InvalidParams;
+
+    if (cmd.cdp.disposeBrowserContext(params.browserContextId) == false) {
+        return cmd.sendError(-32602, "No browser context with the given id found");
+    }
+    try cmd.sendResult(null, .{});
+}
+
+fn createTarget(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        // url: []const u8,
+        // width: ?u64 = null,
+        // height: ?u64 = null,
+        browserContextId: ?[]const u8 = null,
+        // enableBeginFrameControl: bool = false,
+        // newWindow: bool = false,
+        // background: bool = false,
+        // forTab: ?bool = null,
+    })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse cmd.createBrowserContext() catch |err| switch (err) {
+        error.AlreadyExists => unreachable,
+        else => return err,
+    };
+
+    if (bc.target_id != null) {
+        return error.TargetAlreadyLoaded;
+    }
+    if (params.browserContextId) |param_browser_context_id| {
+        if (std.mem.eql(u8, param_browser_context_id, bc.id) == false) {
+            return error.UnknownBrowserContextId;
+        }
+    }
+
+    // if target_id is null, we should never have a page
+    std.debug.assert(bc.session.page == null);
+
+    // if target_id is null, we should never have a session_id
+    std.debug.assert(bc.session_id == null);
+
+    const target_id = cmd.cdp.target_id_gen.next();
+
+    // start the js env
+    const aux_data = try std.fmt.allocPrint(
+        cmd.arena,
+        // NOTE: we assume this is the default web page
+        "{{\"isDefault\":true,\"type\":\"default\",\"frameId\":\"{s}\"}}",
+        .{target_id},
+    );
+    _ = try bc.session.createPage(aux_data);
+
+    // change CDP state
+    bc.url = "about:blank";
+    bc.security_origin = "://";
+    bc.secure_context_type = "InsecureScheme";
+    bc.loader_id = LOADER_ID;
+
+    // send targetCreated event
+    // TODO: should this only be sent when Target.setDiscoverTargets
+    // has been enabled?
+    try cmd.sendEvent("Target.targetCreated", .{
+        .targetInfo = TargetInfo{
+            .url = bc.url,
+            .targetId = target_id,
+            .title = "about:blank",
+            .browserContextId = bc.id,
+            .attached = false,
+        },
+    }, .{});
+
+    // attach to the target only if auto attach is set.
+    if (cmd.cdp.target_auto_attach) {
+        try doAttachtoTarget(cmd, target_id);
+    }
+
+    bc.target_id = target_id;
+
+    try cmd.sendResult(.{
+        .targetId = target_id,
+    }, .{});
+}
+
+fn attachToTarget(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        targetId: []const u8,
+        flatten: bool = true,
+    })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const target_id = bc.target_id orelse return error.TargetNotLoaded;
+    if (std.mem.eql(u8, target_id, params.targetId) == false) {
+        return error.UnknownTargetId;
+    }
+
+    if (bc.session_id != null) {
+        return error.SessionAlreadyLoaded;
+    }
+
+    try doAttachtoTarget(cmd, target_id);
+
+    return cmd.sendResult(
+        .{ .sessionId = bc.session_id },
+        .{ .include_session_id = false },
+    );
+}
+
+fn closeTarget(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        targetId: []const u8,
+    })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    const target_id = bc.target_id orelse return error.TargetNotLoaded;
+    if (std.mem.eql(u8, target_id, params.targetId) == false) {
+        return error.UnknownTargetId;
+    }
+
+    // can't be null if we have a target_id
+    std.debug.assert(bc.session.page != null);
+
+    try cmd.sendResult(.{ .success = true }, .{ .include_session_id = false });
+
+    // could be null, created but never attached
+    if (bc.session_id) |session_id| {
+        // Inspector.detached event
+        try cmd.sendEvent("Inspector.detached", .{
+            .reason = "Render process gone.",
+        }, .{ .session_id = session_id });
+
+        // detachedFromTarget event
+        try cmd.sendEvent("Target.detachedFromTarget", .{
+            .targetId = target_id,
+            .sessionId = session_id,
+            .reason = "Render process gone.",
+        }, .{});
+
+        bc.session_id = null;
+    }
+
+    bc.session.removePage();
+    bc.target_id = null;
+}
+
+fn getTargetInfo(cmd: anytype) !void {
+    const Params = struct {
+        targetId: ?[]const u8 = null,
+    };
+    const params = (try cmd.params(Params)) orelse Params{};
+
+    if (params.targetId) |param_target_id| {
+        const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+        const target_id = bc.target_id orelse return error.TargetNotLoaded;
+        if (std.mem.eql(u8, target_id, param_target_id) == false) {
+            return error.UnknownTargetId;
+        }
+
+        return cmd.sendResult(.{
+            .targetInfo = TargetInfo{
+                .targetId = target_id,
+                .type = "page",
+                .title = "",
+                .url = "",
+                .attached = true,
+                .canAccessOpener = false,
+            },
+        }, .{ .include_session_id = false });
+    }
+
+    return cmd.sendResult(.{
+        .targetInfo = TargetInfo{
+            .targetId = "TID-STARTUP-B",
+            .type = "browser",
+            .title = "",
+            .url = "",
+            .attached = true,
+            .canAccessOpener = false,
+        },
+    }, .{ .include_session_id = false });
+}
+
+fn sendMessageToTarget(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        message: []const u8,
+        sessionId: []const u8,
+    })) orelse return error.InvalidParams;
+
+    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
+    if (bc.target_id == null) {
+        return error.TargetNotLoaded;
+    }
+
+    std.debug.assert(bc.session_id != null);
+    if (std.mem.eql(u8, bc.session_id.?, params.sessionId) == false) {
+        // Is this right? Is the params.sessionId meant to be the active
+        // sessionId? What else could it be? We have no other session_id.
+        return error.UnknownSessionId;
+    }
+
+    const Capture = struct {
+        allocator: std.mem.Allocator,
+        buf: std.ArrayListUnmanaged(u8),
+
+        pub fn sendJSON(self: *@This(), message: anytype) !void {
+            return std.json.stringify(message, .{
+                .emit_null_optional_fields = false,
+            }, self.buf.writer(self.allocator));
+        }
+    };
+
+    var capture = Capture{
+        .buf = .{},
+        .allocator = cmd.arena,
+    };
+
+    cmd.cdp.dispatch(cmd.arena, &capture, params.message) catch |err| {
+        log.err("send message {d} ({s}): {any}", .{ cmd.input.id orelse -1, params.message, err });
+        return err;
+    };
+
+    try cmd.sendEvent("Target.receivedMessageFromTarget", .{
+        .message = capture.buf.items,
+        .sessionId = params.sessionId,
+    }, .{});
+}
+
+fn detachFromTarget(cmd: anytype) !void {
+    // TODO check if sessionId/targetId match.
+    // const params = (try cmd.params(struct {
+    //     sessionId: ?[]const u8,
+    //     targetId: ?[]const u8,
+    // })) orelse return error.InvalidParams;
+
+    if (cmd.browser_context) |bc| {
+        bc.session_id = null;
+        // TODO should we send a Target.detachedFromTarget event?
+    }
+
+    return cmd.sendResult(null, .{});
+}
+
+// TODO: noop method
+fn setDiscoverTargets(cmd: anytype) !void {
+    return cmd.sendResult(null, .{});
+}
+
+fn setAutoAttach(cmd: anytype) !void {
+    const params = (try cmd.params(struct {
+        autoAttach: bool,
+        waitForDebuggerOnStart: bool,
+        flatten: bool = true,
+        // filter: ?[]TargetFilter = null,
+    })) orelse return error.InvalidParams;
+
+    // set a flag to send Target.attachedToTarget events
+    cmd.cdp.target_auto_attach = params.autoAttach;
+
+    try cmd.sendResult(null, .{});
+
+    if (cmd.cdp.target_auto_attach == false) {
+        // detach from all currently attached targets.
+        if (cmd.browser_context) |bc| {
+            bc.session_id = null;
+            // TODO should we send a Target.detachedFromTarget event?
+        }
+        return;
+    }
+
+    // autoAttach is set to true, we must attach to all existing targets.
+    if (cmd.browser_context) |bc| {
+        if (bc.target_id == null) {
+            // hasn't attached  yet
+            const target_id = cmd.cdp.target_id_gen.next();
+            try doAttachtoTarget(cmd, target_id);
+            bc.target_id = target_id;
+        }
+        // should we send something here?
+        return;
+    }
+
+    // This is a hack. Puppeteer, and probably others, expect the Browser to
+    // automatically started creating targets. Things like an empty tab, or
+    // a blank page. And they block until this happens. So we send an event
+    // telling them that they've been attached to our Broswer. Hopefully, the
+    // first thing they'll do is create a real BrowserContext and progress from
+    // there.
+    // This hack requires the main cdp dispatch handler to special case
+    // messages from this "STARTUP" session.
+    try cmd.sendEvent("Target.attachedToTarget", AttachToTarget{
+        .sessionId = "STARTUP",
+        .targetInfo = TargetInfo{
+            .type = "page",
+            .targetId = "TID-STARTUP-P",
+            .title = "New Private Tab",
+            .url = "chrome://newtab/",
+            .browserContextId = "BID-STARTUP",
+        },
+    }, .{});
+}
+
+fn doAttachtoTarget(cmd: anytype, target_id: []const u8) !void {
+    const bc = cmd.browser_context.?;
+    std.debug.assert(bc.session_id == null);
+    const session_id = cmd.cdp.session_id_gen.next();
+
+    try cmd.sendEvent("Target.attachedToTarget", AttachToTarget{
+        .sessionId = session_id,
+        .targetInfo = TargetInfo{
+            .targetId = target_id,
+            .title = "about:blank",
+            .url = "chrome://newtab/",
+            .browserContextId = bc.id,
+        },
+    }, .{});
+
+    bc.session_id = session_id;
+}
+
+const AttachToTarget = struct {
+    sessionId: []const u8,
+    targetInfo: TargetInfo,
+    waitingForDebugger: bool = false,
+};
+
+const TargetInfo = struct {
+    url: []const u8,
+    title: []const u8,
+    targetId: []const u8,
+    attached: bool = true,
+    type: []const u8 = "page",
+    canAccessOpener: bool = false,
+    browserContextId: ?[]const u8 = null,
+};
+
+const testing = @import("../testing.zig");
+test "cdp.target: getBrowserContexts" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    // {
+    //     // no browser context
+    //     try ctx.processMessage(.{.id = 4, .method = "Target.getBrowserContexts"});
+
+    //     try ctx.expectSentResult(.{
+    //         .browserContextIds = &.{},
+    //     }, .{ .id = 4, .session_id = null });
+    // }
+
+    {
+        // with a browser context
+        _ = try ctx.loadBrowserContext(.{ .id = "BID-X" });
+        try ctx.processMessage(.{ .id = 5, .method = "Target.getBrowserContexts" });
+
+        try ctx.expectSentResult(.{
+            .browserContextIds = &.{"BID-X"},
+        }, .{ .id = 5, .session_id = null });
+    }
+}
+
+test "cdp.target: createBrowserContext" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    {
+        try ctx.processMessage(.{ .id = 4, .method = "Target.createBrowserContext" });
+        try ctx.expectSentResult(.{
+            .browserContextId = ctx.cdp().browser_context.?.id,
+        }, .{ .id = 4, .session_id = null });
+    }
+
+    {
+        // we already have one now
+        try ctx.processMessage(.{ .id = 5, .method = "Target.createBrowserContext" });
+        try ctx.expectSentError(-32000, "Cannot have more than one browser context at a time", .{ .id = 5 });
+    }
+}
+
+test "cdp.target: disposeBrowserContext" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    {
+        try testing.expectError(error.InvalidParams, ctx.processMessage(.{ .id = 7, .method = "Target.disposeBrowserContext" }));
+        try ctx.expectSentError(-31998, "InvalidParams", .{ .id = 7 });
+    }
+
+    {
+        try ctx.processMessage(.{
+            .id = 8,
+            .method = "Target.disposeBrowserContext",
+            .params = .{ .browserContextId = "BID-10" },
+        });
+        try ctx.expectSentError(-32602, "No browser context with the given id found", .{ .id = 8 });
+    }
+
+    {
+        _ = try ctx.loadBrowserContext(.{ .id = "BID-20" });
+        try ctx.processMessage(.{
+            .id = 9,
+            .method = "Target.disposeBrowserContext",
+            .params = .{ .browserContextId = "BID-20" },
+        });
+        try ctx.expectSentResult(null, .{ .id = 9 });
+        try testing.expectEqual(null, ctx.cdp().browser_context);
+    }
+}
+
+test "cdp.target: createTarget" {
+    {
+        var ctx = testing.context();
+        defer ctx.deinit();
+        try ctx.processMessage(.{ .id = 10, .method = "Target.createTarget", .params = .{ .url = "about/blank" } });
+
+        // should create a browser context
+        const bc = ctx.cdp().browser_context.?;
+        try ctx.expectSentEvent("Target.targetCreated", .{ .targetInfo = .{ .url = "about:blank", .title = "about:blank", .attached = false, .type = "page", .canAccessOpener = false, .browserContextId = bc.id, .targetId = bc.target_id.? } }, .{});
+    }
+
+    {
+        var ctx = testing.context();
+        defer ctx.deinit();
+        // active auto attach to get the Target.attachedToTarget event.
+        try ctx.processMessage(.{ .id = 9, .method = "Target.setAutoAttach", .params = .{ .autoAttach = true, .waitForDebuggerOnStart = false } });
+        try ctx.processMessage(.{ .id = 10, .method = "Target.createTarget", .params = .{ .url = "about/blank" } });
+
+        // should create a browser context
+        const bc = ctx.cdp().browser_context.?;
+        try ctx.expectSentEvent("Target.targetCreated", .{ .targetInfo = .{ .url = "about:blank", .title = "about:blank", .attached = false, .type = "page", .canAccessOpener = false, .browserContextId = bc.id, .targetId = bc.target_id.? } }, .{});
+        try ctx.expectSentEvent("Target.attachedToTarget", .{ .sessionId = bc.session_id.?, .targetInfo = .{ .url = "chrome://newtab/", .title = "about:blank", .attached = true, .type = "page", .canAccessOpener = false, .browserContextId = bc.id, .targetId = bc.target_id.? } }, .{});
+    }
+
+    var ctx = testing.context();
+    defer ctx.deinit();
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9" });
+    {
+        try testing.expectError(error.UnknownBrowserContextId, ctx.processMessage(.{ .id = 10, .method = "Target.createTarget", .params = .{ .browserContextId = "BID-8" } }));
+        try ctx.expectSentError(-31998, "UnknownBrowserContextId", .{ .id = 10 });
+    }
+
+    {
+        try ctx.processMessage(.{ .id = 10, .method = "Target.createTarget", .params = .{ .browserContextId = "BID-9" } });
+        try testing.expectEqual(true, bc.target_id != null);
+        try testing.expectEqual(
+            \\{"isDefault":true,"type":"default","frameId":"TID-1"}
+        , bc.session.page.?.aux_data);
+
+        try ctx.expectSentResult(.{ .targetId = bc.target_id.? }, .{ .id = 10 });
+        try ctx.expectSentEvent("Target.targetCreated", .{ .targetInfo = .{ .url = "about:blank", .title = "about:blank", .attached = false, .type = "page", .canAccessOpener = false, .browserContextId = "BID-9", .targetId = bc.target_id.? } }, .{});
+    }
+}
+
+test "cdp.target: closeTarget" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    {
+        try testing.expectError(error.BrowserContextNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Target.closeTarget", .params = .{ .targetId = "X" } }));
+        try ctx.expectSentError(-31998, "BrowserContextNotLoaded", .{ .id = 10 });
+    }
+
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9" });
+    {
+        try testing.expectError(error.TargetNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Target.closeTarget", .params = .{ .targetId = "TID-8" } }));
+        try ctx.expectSentError(-31998, "TargetNotLoaded", .{ .id = 10 });
+    }
+
+    // pretend we createdTarget first
+    _ = try bc.session.createPage(null);
+    bc.target_id = "TID-A";
+    {
+        try testing.expectError(error.UnknownTargetId, ctx.processMessage(.{ .id = 10, .method = "Target.closeTarget", .params = .{ .targetId = "TID-8" } }));
+        try ctx.expectSentError(-31998, "UnknownTargetId", .{ .id = 10 });
+    }
+
+    {
+        try ctx.processMessage(.{ .id = 11, .method = "Target.closeTarget", .params = .{ .targetId = "TID-A" } });
+        try ctx.expectSentResult(.{ .success = true }, .{ .id = 11 });
+        try testing.expectEqual(null, bc.session.page);
+        try testing.expectEqual(null, bc.target_id);
+    }
+}
+
+test "cdp.target: attachToTarget" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    {
+        try testing.expectError(error.BrowserContextNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Target.attachToTarget", .params = .{ .targetId = "X" } }));
+        try ctx.expectSentError(-31998, "BrowserContextNotLoaded", .{ .id = 10 });
+    }
+
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9" });
+    {
+        try testing.expectError(error.TargetNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Target.attachToTarget", .params = .{ .targetId = "TID-8" } }));
+        try ctx.expectSentError(-31998, "TargetNotLoaded", .{ .id = 10 });
+    }
+
+    // pretend we createdTarget first
+    _ = try bc.session.createPage(null);
+    bc.target_id = "TID-B";
+    {
+        try testing.expectError(error.UnknownTargetId, ctx.processMessage(.{ .id = 10, .method = "Target.attachToTarget", .params = .{ .targetId = "TID-8" } }));
+        try ctx.expectSentError(-31998, "UnknownTargetId", .{ .id = 10 });
+    }
+
+    {
+        try ctx.processMessage(.{ .id = 11, .method = "Target.attachToTarget", .params = .{ .targetId = "TID-B" } });
+        const session_id = bc.session_id.?;
+        try ctx.expectSentResult(.{ .sessionId = session_id }, .{ .id = 11 });
+        try ctx.expectSentEvent("Target.attachedToTarget", .{ .sessionId = session_id, .targetInfo = .{ .url = "chrome://newtab/", .title = "about:blank", .attached = true, .type = "page", .canAccessOpener = false, .browserContextId = "BID-9", .targetId = bc.target_id.? } }, .{});
+    }
+}
+
+test "cdp.target: getTargetInfo" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+
+    {
+        try ctx.processMessage(.{ .id = 9, .method = "Target.getTargetInfo" });
+        try ctx.expectSentResult(.{
+            .targetInfo = .{
+                .type = "browser",
+                .title = "",
+                .url = "",
+                .attached = true,
+                .canAccessOpener = false,
+            },
+        }, .{ .id = 9 });
+    }
+
+    {
+        try testing.expectError(error.BrowserContextNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Target.getTargetInfo", .params = .{ .targetId = "X" } }));
+        try ctx.expectSentError(-31998, "BrowserContextNotLoaded", .{ .id = 10 });
+    }
+
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9" });
+    {
+        try testing.expectError(error.TargetNotLoaded, ctx.processMessage(.{ .id = 10, .method = "Target.getTargetInfo", .params = .{ .targetId = "TID-8" } }));
+        try ctx.expectSentError(-31998, "TargetNotLoaded", .{ .id = 10 });
+    }
+
+    // pretend we createdTarget first
+    _ = try bc.session.createPage(null);
+    bc.target_id = "TID-A";
+    {
+        try testing.expectError(error.UnknownTargetId, ctx.processMessage(.{ .id = 10, .method = "Target.getTargetInfo", .params = .{ .targetId = "TID-8" } }));
+        try ctx.expectSentError(-31998, "UnknownTargetId", .{ .id = 10 });
+    }
+
+    {
+        try ctx.processMessage(.{ .id = 11, .method = "Target.getTargetInfo", .params = .{ .targetId = "TID-A" } });
+        try ctx.expectSentResult(.{
+            .targetInfo = .{
+                .targetId = "TID-A",
+                .type = "page",
+                .title = "",
+                .url = "",
+                .attached = true,
+                .canAccessOpener = false,
+            },
+        }, .{ .id = 11 });
+    }
+}
+
+test "cdp.target: issue#474: attach to just created target" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9" });
+    {
+        try ctx.processMessage(.{ .id = 10, .method = "Target.createTarget", .params = .{ .browserContextId = "BID-9" } });
+        try testing.expectEqual(true, bc.target_id != null);
+        try ctx.expectSentResult(.{ .targetId = bc.target_id.? }, .{ .id = 10 });
+
+        try ctx.processMessage(.{ .id = 11, .method = "Target.attachToTarget", .params = .{ .targetId = bc.target_id.? } });
+        const session_id = bc.session_id.?;
+        try ctx.expectSentResult(.{ .sessionId = session_id }, .{ .id = 11 });
+    }
+}
+
+test "cdp.target: detachFromTarget" {
+    var ctx = testing.context();
+    defer ctx.deinit();
+    const bc = try ctx.loadBrowserContext(.{ .id = "BID-9" });
+    {
+        try ctx.processMessage(.{ .id = 10, .method = "Target.createTarget", .params = .{ .browserContextId = "BID-9" } });
+        try testing.expectEqual(true, bc.target_id != null);
+        try ctx.expectSentResult(.{ .targetId = bc.target_id.? }, .{ .id = 10 });
+
+        try ctx.processMessage(.{ .id = 11, .method = "Target.attachToTarget", .params = .{ .targetId = bc.target_id.? } });
+        try ctx.expectSentResult(.{ .sessionId = bc.session_id.? }, .{ .id = 11 });
+
+        try ctx.processMessage(.{ .id = 12, .method = "Target.detachFromTarget", .params = .{ .targetId = bc.target_id.? } });
+        try testing.expectEqual(null, bc.session_id);
+        try ctx.expectSentResult(null, .{ .id = 12 });
+
+        try ctx.processMessage(.{ .id = 13, .method = "Target.attachToTarget", .params = .{ .targetId = bc.target_id.? } });
+        try ctx.expectSentResult(.{ .sessionId = bc.session_id.? }, .{ .id = 13 });
+    }
+}