build: add check step to verify compilation

.github/workflows/e2e-test.yml

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

.github/workflows/nightly.yml

@@ -7,7 +7,7 @@ env:
   AWS_REGION: ${{ vars.NIGHTLY_BUILD_AWS_REGION }}
 
   RELEASE: ${{ github.ref_type == 'tag' && github.ref_name || 'nightly' }}
-  VERSION_FLAG: ${{ github.ref_type == 'tag' && format('-Dversion={0}', github.ref_name) || '-Dversion=nightly' }}
+  VERSION_FLAG: ${{ github.ref_type == 'tag' && format('-Dversion_string={0}', github.ref_name) || format('-Dpre_version={0}', 'nightly') }}
 
 on:
   push:

README.md

@@ -36,8 +36,8 @@ Lightpanda is the open-source browser made for headless usage:
 
 Fast web automation for AI agents, LLM training, scraping and testing:
 
-- Ultra-low memory footprint (16x less than Chrome)
-- Exceptionally fast execution (9x faster than Chrome)
+- Ultra-low memory footprint (9x less than Chrome)
+- Exceptionally fast execution (11x faster than Chrome)
 - Instant startup
 
 [^1]: **Playwright support disclaimer:**
@@ -170,7 +170,6 @@ You may still encounter errors or crashes. Please open an issue with specifics i
 
 Here are the key features we have implemented:
 
-- [ ] CORS [#2015](https://github.com/lightpanda-io/browser/issues/2015)
 - [x] HTTP loader ([Libcurl](https://curl.se/libcurl/))
 - [x] HTML parser ([html5ever](https://github.com/servo/html5ever))
 - [x] DOM tree

SECURITY.md

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

build.zig

@@ -85,6 +85,15 @@ pub fn build(b: *Build) !void {
         break :blk mod;
     };
 
+    // Check compilation
+    const check = b.step("check", "Check if lightpanda compiles");
+
+    const check_lib = b.addLibrary(.{
+        .name = "lightpanda_check",
+        .root_module = lightpanda_module,
+    });
+    check.dependOn(&check_lib.step);
+
     {
         // browser
         const exe = b.addExecutable(.{
@@ -103,6 +112,12 @@ pub fn build(b: *Build) !void {
         });
         b.installArtifact(exe);
 
+        const exe_check = b.addLibrary(.{
+            .name = "lightpanda_exe_check",
+            .root_module = exe.root_module,
+        });
+        check.dependOn(&exe_check.step);
+
         const run_cmd = b.addRunArtifact(exe);
         if (b.args) |args| {
             run_cmd.addArgs(args);
@@ -132,6 +147,12 @@ pub fn build(b: *Build) !void {
         });
         b.installArtifact(exe);
 
+        const exe_check = b.addLibrary(.{
+            .name = "snapshot_creator_check",
+            .root_module = exe.root_module,
+        });
+        check.dependOn(&exe_check.step);
+
         const run_cmd = b.addRunArtifact(exe);
         if (b.args) |args| {
             run_cmd.addArgs(args);
@@ -170,6 +191,12 @@ pub fn build(b: *Build) !void {
         });
         b.installArtifact(exe);
 
+        const exe_check = b.addLibrary(.{
+            .name = "legacy_test_check",
+            .root_module = exe.root_module,
+        });
+        check.dependOn(&exe_check.step);
+
         const run_cmd = b.addRunArtifact(exe);
         if (b.args) |args| {
             run_cmd.addArgs(args);
@@ -719,45 +746,39 @@ fn buildCurl(
     return lib;
 }
 
-/// Resolves the semantic version of the build.
-///
-/// The base version is read from `build.zig.zon`. This can be overridden
-/// using the `-Dversion` command-line flag:
-/// - If the flag contains a full semantic version (e.g., `1.2.3`), it replaces
-///   the base version entirely.
-/// - If the flag contains a simple string (e.g., `nightly`), it replaces only
-///   the pre-release tag of the base version (e.g., `1.0.0-dev` -> `1.0.0-nightly`).
-///
-/// For versions that have a pre-release tag and no explicit build metadata,
-/// this function automatically enriches the version with the git commit count
-/// and short hash (e.g., `1.0.0-dev.5243+dbe45229`).
+/// Returns `MAJOR.MINOR.PATCH-dev` when `git describe` fails.
 fn resolveVersion(b: *std.Build) std.SemanticVersion {
-    const opt_version = b.option([]const u8, "version", "Override the version of this build");
+    const version_string = b.option([]const u8, "version_string", "Override the version of this build");
+    if (version_string) |semver_string| {
+        return std.SemanticVersion.parse(semver_string) catch |err| {
+            std.debug.panic("Expected -Dversion-string={s} to be a semantic version: {}", .{ semver_string, err });
+        };
+    }
 
-    const version = if (opt_version) |v|
-        std.SemanticVersion.parse(v) catch blk: {
-            var fallback = lightpanda_version;
-            fallback.pre = v;
-            break :blk fallback;
+    const pre_version = b.option([]const u8, "pre_version", "Override the pre version of this build");
+    const pre = blk: {
+        if (pre_version) |pre| {
+            break :blk pre;
         }
-    else
-        lightpanda_version;
 
-    // Only enrich versions that have a pre-release field and no explicit build metadata.
-    if (version.pre == null or version.build != null) return version;
+        break :blk lightpanda_version.pre;
+    };
+
+    // If it's a stable release (no pre or build metadata in build.zig.zon), use it as is
+    if (pre == null and lightpanda_version.build == null) return lightpanda_version;
 
     // For dev/nightly versions, calculate the commit count and hash
-    const git_hash_raw = runGit(b, &.{ "rev-parse", "--short", "HEAD" }) catch return version;
+    const git_hash_raw = runGit(b, &.{ "rev-parse", "--short", "HEAD" }) catch return lightpanda_version;
     const commit_hash = std.mem.trim(u8, git_hash_raw, " \n\r");
 
-    const git_count_raw = runGit(b, &.{ "rev-list", "--count", "HEAD" }) catch return version;
+    const git_count_raw = runGit(b, &.{ "rev-list", "--count", "HEAD" }) catch return lightpanda_version;
     const commit_count = std.mem.trim(u8, git_count_raw, " \n\r");
 
     return .{
-        .major = version.major,
-        .minor = version.minor,
-        .patch = version.patch,
-        .pre = b.fmt("{s}.{s}", .{ version.pre.?, commit_count }),
+        .major = lightpanda_version.major,
+        .minor = lightpanda_version.minor,
+        .patch = lightpanda_version.patch,
+        .pre = b.fmt("{s}.{s}", .{ pre.?, commit_count }),
         .build = commit_hash,
     };
 }

src/ArenaPool.zig

@@ -18,7 +18,6 @@
 
 const std = @import("std");
 const builtin = @import("builtin");
-const log = @import("log.zig");
 
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
@@ -63,7 +62,7 @@ pub fn deinit(self: *ArenaPool) void {
         var it = self._leak_track.iterator();
         while (it.next()) |kv| {
             if (kv.value_ptr.* != 0) {
-                log.err(.bug, "ArenaPool leak", .{ .name = kv.key_ptr.*, .count = kv.value_ptr.* });
+                std.debug.print("ArenaPool leak detected: '{s}' count={d}\n", .{ kv.key_ptr.*, kv.value_ptr.* });
                 has_leaks = true;
             }
         }
@@ -130,11 +129,11 @@ pub fn release(self: *ArenaPool, allocator: Allocator) void {
         if (self._leak_track.getPtr(entry.debug)) |count| {
             count.* -= 1;
             if (count.* < 0) {
-                log.err(.bug, "ArenaPool double-free", .{ .name = entry.debug });
+                std.debug.print("ArenaPool double-free detected: '{s}'\n", .{entry.debug});
                 @panic("ArenaPool: double-free detected");
             }
         } else {
-            log.err(.bug, "ArenaPool release unknown", .{ .name = entry.debug });
+            std.debug.print("ArenaPool release of untracked arena: '{s}'\n", .{entry.debug});
             @panic("ArenaPool: release of untracked arena");
         }
     }

src/Config.zig

@@ -24,7 +24,6 @@ const log = @import("log.zig");
 const dump = @import("browser/dump.zig");
 
 const WebBotAuthConfig = @import("network/WebBotAuth.zig").Config;
-const mcp = @import("mcp.zig");
 
 pub const RunMode = enum {
     help,
@@ -223,7 +222,6 @@ pub const Serve = struct {
 
 pub const Mcp = struct {
     common: Common = .{},
-    version: mcp.Version = .default,
 };
 
 pub const DumpFormat = enum {
@@ -455,12 +453,6 @@ pub fn printUsageAndExit(self: *const Config, success: bool) void {
         \\Starts an MCP (Model Context Protocol) server over stdio
         \\Example: {s} mcp
         \\
-        \\Options:
-        \\--version
-        \\                Override the reported MCP version.
-        \\                Valid: 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25.
-        \\                Defaults to "2024-11-05".
-        \\
     ++ common_options ++
         \\
         \\version command
@@ -648,22 +640,10 @@ fn parseMcpArgs(
     allocator: Allocator,
     args: *std.process.ArgIterator,
 ) !Mcp {
-    var result: Mcp = .{};
+    var mcp: Mcp = .{};
 
     while (args.next()) |opt| {
-        if (std.mem.eql(u8, "--version", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.mcp, "missing argument value", .{ .arg = opt });
-                return error.InvalidArgument;
-            };
-            result.version = std.meta.stringToEnum(mcp.Version, str) orelse {
-                log.fatal(.mcp, "invalid protocol version", .{ .value = str });
-                return error.InvalidArgument;
-            };
-            continue;
-        }
-
-        if (try parseCommonArg(allocator, opt, args, &result.common)) {
+        if (try parseCommonArg(allocator, opt, args, &mcp.common)) {
             continue;
         }
 
@@ -671,7 +651,7 @@ fn parseMcpArgs(
         return error.UnkownOption;
     }
 
-    return result;
+    return mcp;
 }
 
 fn parseFetchArgs(

src/Notification.zig

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

src/SemanticTree.zig

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

src/Server.zig

@@ -22,6 +22,7 @@ const net = std.net;
 const posix = std.posix;
 
 const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
 
 const log = @import("log.zig");
 const App = @import("App.zig");

src/browser/Browser.zig

@@ -19,13 +19,17 @@
 const std = @import("std");
 
 const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
 
 const js = @import("js/js.zig");
+const log = @import("../log.zig");
 const App = @import("../App.zig");
 const HttpClient = @import("HttpClient.zig");
 
 const ArenaPool = App.ArenaPool;
 
+const IS_DEBUG = @import("builtin").mode == .Debug;
+
 const Session = @import("Session.zig");
 const Notification = @import("../Notification.zig");
 

src/browser/EventManager.zig

@@ -205,7 +205,7 @@ pub fn dispatch(self: *EventManager, target: *EventTarget, event: *Event) Dispat
 
 pub fn dispatchOpts(self: *EventManager, target: *EventTarget, event: *Event, comptime opts: DispatchOpts) DispatchError!void {
     event.acquireRef();
-    defer _ = event.releaseRef(self.page._session);
+    defer event.deinit(false, self.page._session);
 
     if (comptime IS_DEBUG) {
         log.debug(.event, "eventManager.dispatch", .{ .type = event._type_string.str(), .bubbles = event._bubbles });
@@ -240,7 +240,7 @@ pub fn dispatchDirect(self: *EventManager, target: *EventTarget, event: *Event,
     defer window._current_event = prev_event;
 
     event.acquireRef();
-    defer _ = event.releaseRef(page._session);
+    defer event.deinit(false, page._session);
 
     if (comptime IS_DEBUG) {
         log.debug(.event, "dispatchDirect", .{ .type = event._type_string, .context = opts.context });
@@ -425,7 +425,7 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts
         ls.deinit();
     }
 
-    const activation_state = try ActivationState.create(event, target, page);
+    const activation_state = ActivationState.create(event, target, page);
 
     // Defer runs even on early return - ensures event phase is reset
     // and default actions execute (unless prevented)
@@ -820,7 +820,7 @@ const ActivationState = struct {
 
     const Input = Element.Html.Input;
 
-    fn create(event: *const Event, target: *Node, page: *Page) !?ActivationState {
+    fn create(event: *const Event, target: *Node, page: *Page) ?ActivationState {
         if (event._type_string.eql(comptime .wrap("click")) == false) {
             return null;
         }

src/browser/Factory.zig

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

src/browser/Page.zig

@@ -27,6 +27,7 @@ const IS_DEBUG = builtin.mode == .Debug;
 
 const log = @import("../log.zig");
 
+const App = @import("../App.zig");
 const String = @import("../string.zig").String;
 
 const Mime = @import("Mime.zig");
@@ -42,6 +43,7 @@ const URL = @import("URL.zig");
 const Blob = @import("webapi/Blob.zig");
 const Node = @import("webapi/Node.zig");
 const Event = @import("webapi/Event.zig");
+const EventTarget = @import("webapi/EventTarget.zig");
 const CData = @import("webapi/CData.zig");
 const Element = @import("webapi/Element.zig");
 const HtmlElement = @import("webapi/element/Html.zig");
@@ -57,6 +59,7 @@ const AbstractRange = @import("webapi/AbstractRange.zig");
 const MutationObserver = @import("webapi/MutationObserver.zig");
 const IntersectionObserver = @import("webapi/IntersectionObserver.zig");
 const CustomElementDefinition = @import("webapi/CustomElementDefinition.zig");
+const storage = @import("webapi/storage/storage.zig");
 const PageTransitionEvent = @import("webapi/event/PageTransitionEvent.zig");
 const SubmitEvent = @import("webapi/event/SubmitEvent.zig");
 const NavigationKind = @import("webapi/navigation/root.zig").NavigationKind;
@@ -64,6 +67,7 @@ const KeyboardEvent = @import("webapi/event/KeyboardEvent.zig");
 const MouseEvent = @import("webapi/event/MouseEvent.zig");
 
 const HttpClient = @import("HttpClient.zig");
+const ArenaPool = App.ArenaPool;
 
 const timestamp = @import("../datetime.zig").timestamp;
 const milliTimestamp = @import("../datetime.zig").milliTimestamp;
@@ -381,9 +385,12 @@ pub fn getTitle(self: *Page) !?[]const u8 {
     return null;
 }
 
-// Add common headers for a request:
+// Add comon headers for a request:
+// * cookies
 // * referer
-pub fn headersForRequest(self: *Page, headers: *HttpClient.Headers) !void {
+pub fn headersForRequest(self: *Page, temp: Allocator, url: [:0]const u8, headers: *HttpClient.Headers) !void {
+    try self.requestCookie(.{}).headersForRequest(temp, url, headers);
+
     // Build the referer
     const referer = blk: {
         if (self.referer_header == null) {
@@ -487,6 +494,7 @@ pub fn navigate(self: *Page, request_url: [:0]const u8, opts: NavigateOpts) !voi
                 return error.InjectBlankFailed;
             };
         }
+        self.documentIsComplete();
 
         session.notification.dispatch(.page_navigate, &.{
             .frame_id = self._frame_id,
@@ -518,8 +526,6 @@ pub fn navigate(self: *Page, request_url: [:0]const u8, opts: NavigateOpts) !voi
 
         // force next request id manually b/c we won't create a real req.
         _ = session.browser.http_client.incrReqId();
-
-        self.documentIsComplete();
         return;
     }
 
@@ -539,6 +545,8 @@ pub fn navigate(self: *Page, request_url: [:0]const u8, opts: NavigateOpts) !voi
     if (opts.header) |hdr| {
         try headers.add(hdr);
     }
+    try self.requestCookie(.{ .is_navigation = true }).headersForRequest(self.arena, self.url, &headers);
+
     // We dispatch page_navigate event before sending the request.
     // It ensures the event page_navigated is not dispatched before this one.
     session.notification.dispatch(.page_navigate, &.{
@@ -565,7 +573,6 @@ pub fn navigate(self: *Page, request_url: [:0]const u8, opts: NavigateOpts) !voi
         .headers = headers,
         .body = opts.body,
         .cookie_jar = &session.cookie_jar,
-        .cookie_origin = self.url,
         .resource_type = .document,
         .notification = self._session.notification,
         .header_callback = pageHeaderDoneCallback,
@@ -739,12 +746,6 @@ pub fn _documentIsLoaded(self: *Page) !void {
         self.document.asEventTarget(),
         event,
     );
-
-    self._session.notification.dispatch(.page_dom_content_loaded, &.{
-        .frame_id = self._frame_id,
-        .req_id = self._req_id,
-        .timestamp = timestamp(.monotonic),
-    });
 }
 
 pub fn scriptsCompletedLoading(self: *Page) void {
@@ -803,6 +804,19 @@ pub fn documentIsComplete(self: *Page) void {
     self._documentIsComplete() catch |err| {
         log.err(.page, "document is complete", .{ .err = err, .type = self._type, .url = self.url });
     };
+
+    if (self._navigated_options) |no| {
+        // _navigated_options will be null in special short-circuit cases, like
+        // "navigating" to about:blank, in which case this notification has
+        // already been sent
+        self._session.notification.dispatch(.page_navigated, &.{
+            .frame_id = self._frame_id,
+            .req_id = self._req_id,
+            .opts = no,
+            .url = self.url,
+            .timestamp = timestamp(.monotonic),
+        });
+    }
 }
 
 fn _documentIsComplete(self: *Page) !void {
@@ -821,12 +835,6 @@ fn _documentIsComplete(self: *Page) !void {
         try self._event_manager.dispatchDirect(window_target, event, self.window._on_load, .{ .inject_target = false, .context = "page load" });
     }
 
-    self._session.notification.dispatch(.page_loaded, &.{
-        .frame_id = self._frame_id,
-        .req_id = self._req_id,
-        .timestamp = timestamp(.monotonic),
-    });
-
     if (self._event_manager.hasDirectListeners(window_target, "pageshow", self.window._on_pageshow)) {
         const pageshow_event = (try PageTransitionEvent.initTrusted(comptime .wrap("pageshow"), .{}, self)).asEvent();
         try self._event_manager.dispatchDirect(window_target, pageshow_event, self.window._on_pageshow, .{ .context = "page show" });
@@ -879,19 +887,6 @@ fn pageHeaderDoneCallback(transfer: *HttpClient.Transfer) !bool {
         });
     }
 
-    if (self._navigated_options) |no| {
-        // _navigated_options will be null in special short-circuit cases, like
-        // "navigating" to about:blank, in which case this notification has
-        // already been sent
-        self._session.notification.dispatch(.page_navigated, &.{
-            .frame_id = self._frame_id,
-            .req_id = self._req_id,
-            .opts = no,
-            .url = self.url,
-            .timestamp = timestamp(.monotonic),
-        });
-    }
-
     return true;
 }
 
@@ -1041,7 +1036,6 @@ fn pageDoneCallback(ctx: *anyopaque) !void {
             });
 
             parser.parse(html);
-            self._parse_state = .complete;
             self.documentIsComplete();
         },
         else => unreachable,
@@ -3405,7 +3399,7 @@ pub fn handleClick(self: *Page, target: *Node) !void {
 pub fn triggerKeyboard(self: *Page, keyboard_event: *KeyboardEvent) !void {
     const event = keyboard_event.asEvent();
     const element = self.window._document._active_element orelse {
-        _ = event.releaseRef(self._session);
+        keyboard_event.deinit(false, self._session);
         return;
     };
 
@@ -3501,7 +3495,7 @@ pub fn submitForm(self: *Page, submitter_: ?*Element, form_: ?*Element.Html.Form
 
         // so submit_event is still valid when we check _prevent_default
         submit_event.acquireRef();
-        defer _ = submit_event.releaseRef(self._session);
+        defer submit_event.deinit(false, self._session);
 
         try self._event_manager.dispatch(form_element.asEventTarget(), submit_event);
         // If the submit event was prevented, don't submit the form
@@ -3560,6 +3554,19 @@ pub fn insertText(self: *Page, v: []const u8) !void {
     }
 }
 
+const RequestCookieOpts = struct {
+    is_http: bool = true,
+    is_navigation: bool = false,
+};
+pub fn requestCookie(self: *const Page, opts: RequestCookieOpts) HttpClient.RequestCookie {
+    return .{
+        .jar = &self._session.cookie_jar,
+        .origin = self.url,
+        .is_http = opts.is_http,
+        .is_navigation = opts.is_navigation,
+    };
+}
+
 fn asUint(comptime string: anytype) std.meta.Int(
     .unsigned,
     @bitSizeOf(@TypeOf(string.*)) - 8, // (- 8) to exclude sentinel 0

src/browser/Runner.zig

@@ -21,9 +21,12 @@ const lp = @import("lightpanda");
 const builtin = @import("builtin");
 
 const log = @import("../log.zig");
+const App = @import("../App.zig");
 
 const Page = @import("Page.zig");
 const Session = @import("Session.zig");
+const Browser = @import("Browser.zig");
+const Factory = @import("Factory.zig");
 const HttpClient = @import("HttpClient.zig");
 
 const IS_DEBUG = builtin.mode == .Debug;

src/browser/ScriptManager.zig

@@ -28,10 +28,12 @@ const String = @import("../string.zig").String;
 const js = @import("js/js.zig");
 const URL = @import("URL.zig");
 const Page = @import("Page.zig");
+const Browser = @import("Browser.zig");
 
 const Element = @import("webapi/Element.zig");
 
 const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
 
 const IS_DEBUG = builtin.mode == .Debug;
 
@@ -136,9 +138,9 @@ fn clearList(list: *std.DoublyLinkedList) void {
     }
 }
 
-fn getHeaders(self: *ScriptManager) !net_http.Headers {
+fn getHeaders(self: *ScriptManager, arena: Allocator, url: [:0]const u8) !net_http.Headers {
     var headers = try self.client.newHeaders();
-    try self.page.headersForRequest(&headers);
+    try self.page.headersForRequest(arena, url, &headers);
     return headers;
 }
 
@@ -278,10 +280,9 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
             .ctx = script,
             .method = .GET,
             .frame_id = page._frame_id,
-            .headers = try self.getHeaders(),
+            .headers = try self.getHeaders(arena, url),
             .blocking = is_blocking,
             .cookie_jar = &page._session.cookie_jar,
-            .cookie_origin = page.url,
             .resource_type = .script,
             .notification = page._session.notification,
             .start_callback = if (log.enabled(.http, .debug)) Script.startCallback else null,
@@ -404,9 +405,8 @@ pub fn preloadImport(self: *ScriptManager, url: [:0]const u8, referrer: []const
         .ctx = script,
         .method = .GET,
         .frame_id = page._frame_id,
-        .headers = try self.getHeaders(),
+        .headers = try self.getHeaders(arena, url),
         .cookie_jar = &page._session.cookie_jar,
-        .cookie_origin = page.url,
         .resource_type = .script,
         .notification = page._session.notification,
         .start_callback = if (log.enabled(.http, .debug)) Script.startCallback else null,
@@ -508,11 +508,10 @@ pub fn getAsyncImport(self: *ScriptManager, url: [:0]const u8, cb: ImportAsync.C
         .url = url,
         .method = .GET,
         .frame_id = page._frame_id,
-        .headers = try self.getHeaders(),
+        .headers = try self.getHeaders(arena, url),
         .ctx = script,
         .resource_type = .script,
         .cookie_jar = &page._session.cookie_jar,
-        .cookie_origin = page.url,
         .notification = page._session.notification,
         .start_callback = if (log.enabled(.http, .debug)) Script.startCallback else null,
         .header_callback = Script.headerCallback,
@@ -655,6 +654,7 @@ pub const Script = struct {
     debug_transfer_aborted: bool = false,
     debug_transfer_bytes_received: usize = 0,
     debug_transfer_notified_fail: bool = false,
+    debug_transfer_redirecting: bool = false,
     debug_transfer_intercept_state: u8 = 0,
     debug_transfer_auth_challenge: bool = false,
     debug_transfer_easy_id: usize = 0,
@@ -730,6 +730,7 @@ pub const Script = struct {
                 .a3 = self.debug_transfer_aborted,
                 .a4 = self.debug_transfer_bytes_received,
                 .a5 = self.debug_transfer_notified_fail,
+                .a6 = self.debug_transfer_redirecting,
                 .a7 = self.debug_transfer_intercept_state,
                 .a8 = self.debug_transfer_auth_challenge,
                 .a9 = self.debug_transfer_easy_id,
@@ -738,9 +739,10 @@ pub const Script = struct {
                 .b3 = transfer.aborted,
                 .b4 = transfer.bytes_received,
                 .b5 = transfer._notified_fail,
+                .b6 = transfer._redirecting,
                 .b7 = @intFromEnum(transfer._intercept_state),
                 .b8 = transfer._auth_challenge != null,
-                .b9 = if (transfer._conn) |c| @intFromPtr(c._easy) else 0,
+                .b9 = if (transfer._conn) |c| @intFromPtr(c.easy) else 0,
             });
             self.header_callback_called = true;
             self.debug_transfer_id = transfer.id;
@@ -748,9 +750,10 @@ pub const Script = struct {
             self.debug_transfer_aborted = transfer.aborted;
             self.debug_transfer_bytes_received = transfer.bytes_received;
             self.debug_transfer_notified_fail = transfer._notified_fail;
+            self.debug_transfer_redirecting = transfer._redirecting;
             self.debug_transfer_intercept_state = @intFromEnum(transfer._intercept_state);
             self.debug_transfer_auth_challenge = transfer._auth_challenge != null;
-            self.debug_transfer_easy_id = if (transfer._conn) |c| @intFromPtr(c._easy) else 0;
+            self.debug_transfer_easy_id = if (transfer._conn) |c| @intFromPtr(c.easy) else 0;
         }
 
         lp.assert(self.source.remote.capacity == 0, "ScriptManager.Header buffer", .{ .capacity = self.source.remote.capacity });

src/browser/Session.zig

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

src/browser/js/Caller.zig

@@ -128,7 +128,7 @@ fn _constructor(self: *Caller, func: anytype, info: FunctionCallbackInfo) !void
     const new_this_handle = info.getThis();
     var this = js.Object{ .local = local, .handle = new_this_handle };
     if (@typeInfo(ReturnType) == .error_union) {
-        const non_error_res = try res;
+        const non_error_res = res catch |err| return err;
         this = try local.mapZigInstanceToJs(new_this_handle, non_error_res);
     } else {
         this = try local.mapZigInstanceToJs(new_this_handle, res);

src/browser/js/Context.zig

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

src/browser/js/Env.zig

@@ -26,6 +26,7 @@ const App = @import("../../App.zig");
 const log = @import("../../log.zig");
 
 const bridge = @import("bridge.zig");
+const Origin = @import("Origin.zig");
 const Context = @import("Context.zig");
 const Isolate = @import("Isolate.zig");
 const Platform = @import("Platform.zig");
@@ -33,6 +34,7 @@ const Snapshot = @import("Snapshot.zig");
 const Inspector = @import("Inspector.zig");
 
 const Page = @import("../Page.zig");
+const Session = @import("../Session.zig");
 const Window = @import("../webapi/Window.zig");
 
 const JsApis = bridge.JsApis;

src/browser/js/Function.zig

@@ -21,6 +21,7 @@ const js = @import("js.zig");
 const v8 = js.v8;
 
 const log = @import("../../log.zig");
+const Session = @import("../Session.zig");
 
 const Function = @This();
 
@@ -213,7 +214,7 @@ fn _persist(self: *const Function, comptime is_global: bool) !(if (is_global) Gl
         return .{ .handle = global, .temps = {} };
     }
     try ctx.trackTemp(global);
-    return .{ .handle = global, .temps = &ctx.session.temps };
+    return .{ .handle = global, .temps = &ctx.identity.temps };
 }
 
 pub fn tempWithThis(self: *const Function, value: anytype) !Temp {

src/browser/js/Identity.zig

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

src/browser/js/Local.zig

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

src/browser/js/Promise.zig

@@ -20,6 +20,8 @@ const std = @import("std");
 const js = @import("js.zig");
 const v8 = js.v8;
 
+const Session = @import("../Session.zig");
+
 const Promise = @This();
 
 local: *const js.Local,
@@ -67,7 +69,7 @@ fn _persist(self: *const Promise, comptime is_global: bool) !(if (is_global) Glo
         return .{ .handle = global, .temps = {} };
     }
     try ctx.trackTemp(global);
-    return .{ .handle = global, .temps = &ctx.session.temps };
+    return .{ .handle = global, .temps = &ctx.identity.temps };
 }
 
 pub const Temp = G(.temp);

src/browser/js/Snapshot.zig

@@ -25,6 +25,7 @@ const IS_DEBUG = @import("builtin").mode == .Debug;
 
 const v8 = js.v8;
 const JsApis = bridge.JsApis;
+const Allocator = std.mem.Allocator;
 
 const Snapshot = @This();
 

src/browser/js/Value.zig

@@ -25,6 +25,7 @@ const v8 = js.v8;
 const IS_DEBUG = @import("builtin").mode == .Debug;
 
 const Allocator = std.mem.Allocator;
+const Session = @import("../Session.zig");
 
 const Value = @This();
 
@@ -303,7 +304,7 @@ fn _persist(self: *const Value, comptime is_global: bool) !(if (is_global) Globa
         return .{ .handle = global, .temps = {} };
     }
     try ctx.trackTemp(global);
-    return .{ .handle = global, .temps = &ctx.session.temps };
+    return .{ .handle = global, .temps = &ctx.identity.temps };
 }
 
 pub fn toZig(self: Value, comptime T: type) !T {

src/browser/js/bridge.zig

@@ -18,12 +18,15 @@
 
 const std = @import("std");
 const js = @import("js.zig");
+const lp = @import("lightpanda");
+const log = @import("../../log.zig");
 const Page = @import("../Page.zig");
 const Session = @import("../Session.zig");
 
 const v8 = js.v8;
 
 const Caller = @import("Caller.zig");
+const Context = @import("Context.zig");
 
 const IS_DEBUG = @import("builtin").mode == .Debug;
 
@@ -101,19 +104,34 @@ pub fn Builder(comptime T: type) type {
             }
             return entries;
         }
-    };
-}
 
-fn releaseRef(comptime T: type, ptr_id: usize, session: *Session) void {
-    if (@hasDecl(T, "releaseRef")) {
-        T.releaseRef(@ptrFromInt(ptr_id), session);
-        return;
-    }
-    if (@hasField(T, "_proto")) {
-        releaseRef(Struct(std.meta.fieldInfo(T, ._proto).type), ptr_id, session);
-        return;
-    }
-    @compileError(@typeName(T) ++ " marked with finalizer without an acquireRef in its prototype chain");
+        pub fn finalizer(comptime func: *const fn (self: *T, shutdown: bool, session: *Session) void) Finalizer {
+            return .{
+                .from_zig = struct {
+                    fn wrap(ptr: *anyopaque, session: *Session) void {
+                        func(@ptrCast(@alignCast(ptr)), true, session);
+                    }
+                }.wrap,
+
+                .from_v8 = struct {
+                    fn wrap(handle: ?*const v8.WeakCallbackInfo) callconv(.c) void {
+                        const ptr = v8.v8__WeakCallbackInfo__GetParameter(handle.?).?;
+                        const fc: *Session.FinalizerCallback = @ptrCast(@alignCast(ptr));
+
+                        const value_ptr = fc.ptr;
+                        if (fc.identity.finalizer_callbacks.contains(@intFromPtr(value_ptr))) {
+                            func(@ptrCast(@alignCast(value_ptr)), false, fc.session);
+                            fc.releaseIdentity();
+                        } else {
+                            // A bit weird, but v8 _requires_ that we release it
+                            // If we don't. We'll 100% crash.
+                            v8.v8__Global__Reset(&fc.global);
+                        }
+                    }
+                }.wrap,
+            };
+        }
+    };
 }
 
 pub const Constructor = struct {
@@ -396,6 +414,17 @@ pub const Property = struct {
     }
 };
 
+const Finalizer = struct {
+    // The finalizer wrapper when called from Zig. This is only called on
+    // Origin.deinit
+    from_zig: *const fn (ctx: *anyopaque, session: *Session) void,
+
+    // The finalizer wrapper when called from V8. This may never be called
+    // (hence why we fallback to calling in Origin.deinit). If it is called,
+    // it is only ever called after we SetWeak on the Global.
+    from_v8: *const fn (?*const v8.WeakCallbackInfo) callconv(.c) void,
+};
+
 pub fn unknownWindowPropertyCallback(c_name: ?*const v8.Name, handle: ?*const v8.PropertyCallbackInfo) callconv(.c) u8 {
     const v8_isolate = v8.v8__PropertyCallbackInfo__GetIsolate(handle).?;
     var caller: Caller = undefined;

src/browser/markdown.zig

@@ -21,6 +21,7 @@ const std = @import("std");
 const Page = @import("Page.zig");
 const URL = @import("URL.zig");
 const TreeWalker = @import("webapi/TreeWalker.zig");
+const CData = @import("webapi/CData.zig");
 const Element = @import("webapi/Element.zig");
 const Node = @import("webapi/Node.zig");
 const isAllWhitespace = @import("../string.zig").isAllWhitespace;

src/browser/tests/canvas/canvas_rendering_context_2d.html

@@ -148,13 +148,3 @@
 
 }
 </script>
-
-<script id=identity>
-{
-  const element = document.createElement('canvas');
-  const ctx = element.getContext('2d');
-
-  testing.expectTrue(ctx === element.getContext('2d'));
-  testing.expectEqual(null, element.getContext('webgl'));
-}
-</script>

src/browser/tests/canvas/webgl_rendering_context.html

@@ -85,13 +85,3 @@
   loseContext.restoreContext();
 }
 </script>
-
-<script id=identity>
-{
-  const element = document.createElement('canvas');
-  const ctx = element.getContext('webgl');
-
-  testing.expectTrue(ctx === element.getContext('webgl'));
-  testing.expectEqual(null, element.getContext('2d'));
-}
-</script>

src/browser/tests/navigator/navigator.html

@@ -15,9 +15,8 @@
   testing.expectEqual(true, validPlatforms.includes(navigator.platform));
   testing.expectEqual('en-US', navigator.language);
   testing.expectEqual(true, Array.isArray(navigator.languages));
-  testing.expectEqual(2, navigator.languages.length);
+  testing.expectEqual(1, navigator.languages.length);
   testing.expectEqual('en-US', navigator.languages[0]);
-  testing.expectEqual('en', navigator.languages[1]);
   testing.expectEqual(true, navigator.onLine);
   testing.expectEqual(true, navigator.cookieEnabled);
   testing.expectEqual(true, navigator.hardwareConcurrency > 0);

src/browser/webapi/AbstractRange.zig

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

src/browser/webapi/Blob.zig

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

src/browser/webapi/CustomElementRegistry.zig

@@ -24,6 +24,7 @@ const Page = @import("../Page.zig");
 
 const Node = @import("Node.zig");
 const Element = @import("Element.zig");
+const DOMException = @import("DOMException.zig");
 const Custom = @import("element/html/Custom.zig");
 const CustomElementDefinition = @import("CustomElementDefinition.zig");
 

src/browser/webapi/DOMException.zig

@@ -59,7 +59,6 @@ pub fn fromError(err: anyerror) ?DOMException {
         error.TimeoutError => .{ ._code = .timeout_error },
         error.InvalidNodeType => .{ ._code = .invalid_node_type_error },
         error.DataClone => .{ ._code = .data_clone_error },
-        error.InvalidAccessError => .{ ._code = .invalid_access_error },
         else => null,
     };
 }

src/browser/webapi/Document.zig

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

src/browser/webapi/Event.zig

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

src/browser/webapi/EventTarget.zig

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

src/browser/webapi/File.zig

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

src/browser/webapi/FileReader.zig

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

src/browser/webapi/HTMLDocument.zig

@@ -18,6 +18,7 @@
 
 const std = @import("std");
 const js = @import("../js/js.zig");
+const String = @import("../../string.zig").String;
 
 const Page = @import("../Page.zig");
 const Node = @import("Node.zig");

src/browser/webapi/ImageData.zig

@@ -19,8 +19,10 @@
 const std = @import("std");
 
 const String = @import("../../string.zig").String;
+const log = @import("../../log.zig");
 
 const js = @import("../js/js.zig");
+const color = @import("../color.zig");
 const Page = @import("../Page.zig");
 
 /// https://developer.mozilla.org/en-US/docs/Web/API/ImageData/ImageData

src/browser/webapi/IntersectionObserver.zig

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

src/browser/webapi/MutationObserver.zig

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

src/browser/webapi/Navigator.zig

@@ -40,8 +40,8 @@ pub fn getUserAgent(_: *const Navigator, page: *Page) []const u8 {
     return page._session.browser.app.config.http_headers.user_agent;
 }
 
-pub fn getLanguages(_: *const Navigator) [2][]const u8 {
-    return .{ "en-US", "en" };
+pub fn getLanguages(_: *const Navigator) [1][]const u8 {
+    return .{"en-US"};
 }
 
 pub fn getPlatform(_: *const Navigator) []const u8 {

src/browser/webapi/Permissions.zig

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

src/browser/webapi/Range.zig

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

src/browser/webapi/Selection.zig

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

src/browser/webapi/URL.zig

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

src/browser/webapi/VisualViewport.zig

@@ -19,6 +19,7 @@
 const js = @import("../js/js.zig");
 const Page = @import("../Page.zig");
 const EventTarget = @import("EventTarget.zig");
+const Window = @import("Window.zig");
 
 const VisualViewport = @This();
 

src/browser/webapi/animation/Animation.zig

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

src/browser/webapi/cdata/Text.zig

@@ -16,6 +16,7 @@
 // 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 String = @import("../../../string.zig").String;
 const js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
 const CData = @import("../CData.zig");

src/browser/webapi/collections/NodeList.zig

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

src/browser/webapi/collections/iterator.zig

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

src/browser/webapi/crypto/HMAC.zig

@@ -20,6 +20,7 @@
 
 const std = @import("std");
 const lp = @import("lightpanda");
+const log = @import("../../../log.zig");
 const crypto = @import("../../../sys/libcrypto.zig");
 
 const Page = @import("../../Page.zig");

src/browser/webapi/crypto/X25519.zig

@@ -20,10 +20,12 @@
 
 const std = @import("std");
 const lp = @import("lightpanda");
+const log = @import("../../../log.zig");
 const crypto = @import("../../../sys/libcrypto.zig");
 
 const Page = @import("../../Page.zig");
 const js = @import("../../js/js.zig");
+const Algorithm = @import("algorithm.zig").Algorithm;
 
 const CryptoKey = @import("../CryptoKey.zig");
 

src/browser/webapi/css/FontFace.zig

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

src/browser/webapi/css/FontFaceSet.zig

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

src/browser/webapi/element/Html.zig

@@ -22,6 +22,7 @@ const reflect = @import("../../reflect.zig");
 const log = @import("../../../log.zig");
 
 const global_event_handlers = @import("../global_event_handlers.zig");
+const GlobalEventHandlersLookup = global_event_handlers.Lookup;
 const GlobalEventHandler = global_event_handlers.Handler;
 
 const Page = @import("../../Page.zig");

src/browser/webapi/element/html/Canvas.zig

@@ -29,9 +29,6 @@ const OffscreenCanvas = @import("../../canvas/OffscreenCanvas.zig");
 
 const Canvas = @This();
 _proto: *HtmlElement,
-_cached: ?DrawingContext = null,
-
-const ContextType = enum { none, @"2d", webgl };
 
 pub fn asElement(self: *Canvas) *Element {
     return self._proto._proto;
@@ -71,28 +68,17 @@ const DrawingContext = union(enum) {
 };
 
 pub fn getContext(self: *Canvas, context_type: []const u8, page: *Page) !?DrawingContext {
-    if (self._cached) |cached| {
-        const matches = switch (cached) {
-            .@"2d" => std.mem.eql(u8, context_type, "2d"),
-            .webgl => std.mem.eql(u8, context_type, "webgl") or std.mem.eql(u8, context_type, "experimental-webgl"),
-        };
-        return if (matches) cached else null;
+    if (std.mem.eql(u8, context_type, "2d")) {
+        const ctx = try page._factory.create(CanvasRenderingContext2D{ ._canvas = self });
+        return .{ .@"2d" = ctx };
     }
 
-    const drawing_context: DrawingContext = blk: {
-        if (std.mem.eql(u8, context_type, "2d")) {
-            const ctx = try page._factory.create(CanvasRenderingContext2D{ ._canvas = self });
-            break :blk .{ .@"2d" = ctx };
-        }
+    if (std.mem.eql(u8, context_type, "webgl") or std.mem.eql(u8, context_type, "experimental-webgl")) {
+        const ctx = try page._factory.create(WebGLRenderingContext{});
+        return .{ .webgl = ctx };
+    }
 
-        if (std.mem.eql(u8, context_type, "webgl") or std.mem.eql(u8, context_type, "experimental-webgl")) {
-            const ctx = try page._factory.create(WebGLRenderingContext{});
-            break :blk .{ .webgl = ctx };
-        }
-        return null;
-    };
-    self._cached = drawing_context;
-    return drawing_context;
+    return null;
 }
 
 /// Transfers control of the canvas to an OffscreenCanvas.

src/browser/webapi/element/html/IFrame.zig

@@ -16,6 +16,7 @@
 // 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 log = @import("../../../../log.zig");
 const js = @import("../../../js/js.zig");
 const Page = @import("../../../Page.zig");
 const Window = @import("../../Window.zig");

src/browser/webapi/element/html/Image.zig

@@ -5,6 +5,10 @@ const URL = @import("../../../URL.zig");
 const Node = @import("../../Node.zig");
 const Element = @import("../../Element.zig");
 const HtmlElement = @import("../Html.zig");
+const Event = @import("../../Event.zig");
+const log = @import("../../../../log.zig");
+
+const IS_DEBUG = @import("builtin").mode == .Debug;
 
 const Image = @This();
 _proto: *HtmlElement,

src/browser/webapi/element/html/Script.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 const std = @import("std");
 
+const log = @import("../../../../log.zig");
 const js = @import("../../../js/js.zig");
 const Page = @import("../../../Page.zig");
 

src/browser/webapi/encoding/TextDecoder.zig

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

src/browser/webapi/event/CompositionEvent.zig

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

src/browser/webapi/event/CustomEvent.zig

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

src/browser/webapi/event/ErrorEvent.zig

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

src/browser/webapi/event/FocusEvent.zig

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

src/browser/webapi/event/FormDataEvent.zig

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

src/browser/webapi/event/InputEvent.zig

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

src/browser/webapi/event/KeyboardEvent.zig

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

src/browser/webapi/event/MessageEvent.zig

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

src/browser/webapi/event/MouseEvent.zig

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

src/browser/webapi/event/NavigationCurrentEntryChangeEvent.zig

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

src/browser/webapi/event/PageTransitionEvent.zig

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

src/browser/webapi/event/PointerEvent.zig

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

src/browser/webapi/event/PopStateEvent.zig

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

src/browser/webapi/event/ProgressEvent.zig

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

src/browser/webapi/event/PromiseRejectionEvent.zig

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

src/browser/webapi/event/SubmitEvent.zig

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

src/browser/webapi/event/TextEvent.zig

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

src/browser/webapi/event/UIEvent.zig

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

src/browser/webapi/event/WheelEvent.zig

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

src/browser/webapi/navigation/Navigation.zig

@@ -27,6 +27,8 @@ const Page = @import("../../Page.zig");
 const Event = @import("../Event.zig");
 const EventTarget = @import("../EventTarget.zig");
 
+const IS_DEBUG = @import("builtin").mode == .Debug;
+
 // https://developer.mozilla.org/en-US/docs/Web/API/Navigation
 const Navigation = @This();
 

src/browser/webapi/navigation/NavigationHistoryEntry.zig

@@ -18,6 +18,7 @@
 
 const std = @import("std");
 const URL = @import("../URL.zig");
+const EventTarget = @import("../EventTarget.zig");
 const NavigationState = @import("root.zig").NavigationState;
 const Page = @import("../../Page.zig");
 const js = @import("../../js/js.zig");

src/browser/webapi/net/Fetch.zig

@@ -62,7 +62,7 @@ pub fn init(input: Input, options: ?InitOpts, page: *Page) !js.Promise {
     }
 
     const response = try Response.init(null, .{ .status = 0 }, page);
-    errdefer response.deinit(page._session);
+    errdefer response.deinit(true, page._session);
 
     const fetch = try response._arena.create(Fetch);
     fetch.* = .{
@@ -80,7 +80,7 @@ pub fn init(input: Input, options: ?InitOpts, page: *Page) !js.Promise {
     if (request._headers) |h| {
         try h.populateHttpHeader(page.call_arena, &headers);
     }
-    try page.headersForRequest(&headers);
+    try page.headersForRequest(page.arena, request._url, &headers);
 
     if (comptime IS_DEBUG) {
         log.debug(.http, "fetch", .{ .url = request._url });
@@ -95,7 +95,6 @@ pub fn init(input: Input, options: ?InitOpts, page: *Page) !js.Promise {
         .headers = headers,
         .resource_type = .fetch,
         .cookie_jar = &page._session.cookie_jar,
-        .cookie_origin = page.url,
         .notification = page._session.notification,
         .start_callback = httpStartCallback,
         .header_callback = httpHeaderDoneCallback,
@@ -226,7 +225,7 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
     return ls.toLocal(self._resolver).resolve("fetch done", js_val);
 }
 
-fn httpErrorCallback(ctx: *anyopaque, _: anyerror) void {
+fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
     const self: *Fetch = @ptrCast(@alignCast(ctx));
 
     var response = self._response;
@@ -235,7 +234,7 @@ fn httpErrorCallback(ctx: *anyopaque, _: anyerror) void {
     // clear this. (defer since `self is in the response's arena).
 
     defer if (self._owns_response) {
-        response.deinit(self._page._session);
+        response.deinit(err == error.Abort, self._page._session);
         self._owns_response = false;
     };
 
@@ -257,7 +256,7 @@ fn httpShutdownCallback(ctx: *anyopaque) void {
     if (self._owns_response) {
         var response = self._response;
         response._transfer = null;
-        response.deinit(self._page._session);
+        response.deinit(true, self._page._session);
         // Do not access `self` after this point: the Fetch struct was
         // allocated from response._arena which has been released.
     }

src/browser/webapi/net/FormData.zig

@@ -22,6 +22,7 @@ const log = @import("../../../log.zig");
 
 const js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
+const Node = @import("../Node.zig");
 const Form = @import("../element/html/Form.zig");
 const Element = @import("../Element.zig");
 const KeyValueList = @import("../KeyValueList.zig");

src/browser/webapi/net/Response.zig

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

src/browser/webapi/net/XMLHttpRequest.zig

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

src/cdp/CDP.zig

@@ -25,6 +25,7 @@ const json = std.json;
 const Incrementing = @import("id.zig").Incrementing;
 
 const log = @import("../log.zig");
+const App = @import("../App.zig");
 const Notification = @import("../Notification.zig");
 
 const Client = @import("../Server.zig").Client;
@@ -34,6 +35,7 @@ const Browser = @import("../browser/Browser.zig");
 const Session = @import("../browser/Session.zig");
 const Page = @import("../browser/Page.zig");
 const Mime = @import("../browser/Mime.zig");
+const HttpClient = @import("../browser/HttpClient.zig");
 
 const InterceptState = @import("domains/fetch.zig").InterceptState;
 
@@ -363,11 +365,6 @@ pub fn BrowserContext(comptime CDP_T: type) type {
         inspector_session: *js.Inspector.Session,
         isolated_worlds: std.ArrayList(*IsolatedWorld),
 
-        // Scripts registered via Page.addScriptToEvaluateOnNewDocument.
-        // Evaluated in each new document after navigation completes.
-        scripts_on_new_document: std.ArrayList(ScriptOnNewDocument) = .empty,
-        next_script_id: u32 = 1,
-
         http_proxy_changed: bool = false,
 
         // Extra headers to add to all requests.
@@ -432,8 +429,6 @@ pub fn BrowserContext(comptime CDP_T: type) type {
             try notification.register(.page_navigate, self, onPageNavigate);
             try notification.register(.page_navigated, self, onPageNavigated);
             try notification.register(.page_frame_created, self, onPageFrameCreated);
-            try notification.register(.page_dom_content_loaded, self, onPageDOMContentLoaded);
-            try notification.register(.page_loaded, self, onPageLoaded);
         }
 
         pub fn deinit(self: *Self) void {
@@ -475,8 +470,8 @@ pub fn BrowserContext(comptime CDP_T: type) type {
             if (self.http_proxy_changed) {
                 // has to be called after browser.closeSession, since it won't
                 // work if there are active connections.
-                browser.http_client.changeProxy(null) catch |err| {
-                    log.warn(.http, "changeProxy", .{ .err = err });
+                browser.http_client.restoreOriginalProxy() catch |err| {
+                    log.warn(.http, "restoreOriginalProxy", .{ .err = err });
                 };
             }
             self.intercept_state.deinit();
@@ -609,16 +604,6 @@ pub fn BrowserContext(comptime CDP_T: type) type {
             return @import("domains/page.zig").pageFrameCreated(self, msg);
         }
 
-        pub fn onPageDOMContentLoaded(ctx: *anyopaque, msg: *const Notification.PageDOMContentLoaded) !void {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            return @import("domains/page.zig").pageDOMContentLoaded(self, msg);
-        }
-
-        pub fn onPageLoaded(ctx: *anyopaque, msg: *const Notification.PageLoaded) !void {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            return @import("domains/page.zig").pageLoaded(self, msg);
-        }
-
         pub fn onPageNetworkIdle(ctx: *anyopaque, msg: *const Notification.PageNetworkIdle) !void {
             const self: *Self = @ptrCast(@alignCast(ctx));
             return @import("domains/page.zig").pageNetworkIdle(self, msg);
@@ -779,11 +764,6 @@ pub fn BrowserContext(comptime CDP_T: type) type {
 /// Clients create this to be able to create variables and run code without interfering with the
 /// normal namespace and values of the webpage. Similar to the main context we need to pretend to recreate it after
 /// a executionContextsCleared event which happens when navigating to a new page. A client can have a command be executed
-const ScriptOnNewDocument = struct {
-    identifier: u32,
-    source: []const u8,
-};
-
 /// in the isolated world by using its Context ID or the worldName.
 /// grantUniveralAccess Indecated whether the isolated world can reference objects like the DOM or other JS Objects.
 /// An isolated world has it's own instance of globals like Window.

src/cdp/domains/lp.zig

@@ -18,6 +18,7 @@
 
 const std = @import("std");
 const lp = @import("lightpanda");
+const log = @import("../../log.zig");
 const markdown = lp.markdown;
 const SemanticTree = lp.SemanticTree;
 const interactive = lp.interactive;
@@ -30,7 +31,6 @@ pub fn processMessage(cmd: anytype) !void {
         getMarkdown,
         getSemanticTree,
         getInteractiveElements,
-        getNodeDetails,
         getStructuredData,
         detectForms,
         clickNode,
@@ -43,7 +43,6 @@ pub fn processMessage(cmd: anytype) !void {
         .getMarkdown => return getMarkdown(cmd),
         .getSemanticTree => return getSemanticTree(cmd),
         .getInteractiveElements => return getInteractiveElements(cmd),
-        .getNodeDetails => return getNodeDetails(cmd),
         .getStructuredData => return getStructuredData(cmd),
         .detectForms => return detectForms(cmd),
         .clickNode => return clickNode(cmd),
@@ -143,24 +142,6 @@ fn getInteractiveElements(cmd: anytype) !void {
     }, .{});
 }
 
-fn getNodeDetails(cmd: anytype) !void {
-    const Params = struct {
-        backendNodeId: Node.Id,
-    };
-    const params = (try cmd.params(Params)) orelse return error.InvalidParam;
-
-    const bc = cmd.browser_context orelse return error.NoBrowserContext;
-    const page = bc.session.currentPage() orelse return error.PageNotLoaded;
-
-    const node = (bc.node_registry.lookup_by_id.get(params.backendNodeId) orelse return error.InvalidNodeId).dom;
-
-    const details = SemanticTree.getNodeDetails(cmd.arena, node, &bc.node_registry, page) catch return error.InternalError;
-
-    return cmd.sendResult(.{
-        .nodeDetails = details,
-    }, .{});
-}
-
 fn getStructuredData(cmd: anytype) !void {
     const bc = cmd.browser_context orelse return error.NoBrowserContext;
     const page = bc.session.currentPage() orelse return error.PageNotLoaded;

src/cdp/domains/network.zig

@@ -351,10 +351,6 @@ pub const TransferAsRequestWriter = struct {
                 try jws.objectField(hdr.name);
                 try jws.write(hdr.value);
             }
-            if (try transfer.getCookieString()) |cookies| {
-                try jws.objectField("Cookie");
-                try jws.write(cookies[0 .. cookies.len - 1]);
-            }
             try jws.endObject();
         }
         try jws.endObject();

src/cdp/domains/page.zig

@@ -37,7 +37,6 @@ pub fn processMessage(cmd: anytype) !void {
         getFrameTree,
         setLifecycleEventsEnabled,
         addScriptToEvaluateOnNewDocument,
-        removeScriptToEvaluateOnNewDocument,
         createIsolatedWorld,
         navigate,
         reload,
@@ -52,7 +51,6 @@ pub fn processMessage(cmd: anytype) !void {
         .getFrameTree => return getFrameTree(cmd),
         .setLifecycleEventsEnabled => return setLifecycleEventsEnabled(cmd),
         .addScriptToEvaluateOnNewDocument => return addScriptToEvaluateOnNewDocument(cmd),
-        .removeScriptToEvaluateOnNewDocument => return removeScriptToEvaluateOnNewDocument(cmd),
         .createIsolatedWorld => return createIsolatedWorld(cmd),
         .navigate => return navigate(cmd),
         .reload => return doReload(cmd),
@@ -149,55 +147,22 @@ fn setLifecycleEventsEnabled(cmd: anytype) !void {
     return cmd.sendResult(null, .{});
 }
 
+// TODO: hard coded method
+// With the command we receive a script we need to store and run for each new document.
+// Note that the worldName refers to the name given to the isolated world.
 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;
+    // const params = (try cmd.params(struct {
+    //     source: []const u8,
+    //     worldName: ?[]const u8 = null,
+    //     includeCommandLineAPI: bool = false,
+    //     runImmediately: bool = false,
+    // })) orelse return error.InvalidParams;
 
-    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
-
-    if (params.runImmediately) {
-        log.warn(.not_implemented, "addScriptOnNewDocument", .{ .param = "runImmediately" });
-    }
-
-    const script_id = bc.next_script_id;
-    bc.next_script_id += 1;
-
-    const source_dupe = try bc.arena.dupe(u8, params.source);
-    try bc.scripts_on_new_document.append(bc.arena, .{
-        .identifier = script_id,
-        .source = source_dupe,
-    });
-
-    var id_buf: [16]u8 = undefined;
-    const id_str = std.fmt.bufPrint(&id_buf, "{d}", .{script_id}) catch "1";
     return cmd.sendResult(.{
-        .identifier = id_str,
+        .identifier = "1",
     }, .{});
 }
 
-fn removeScriptToEvaluateOnNewDocument(cmd: anytype) !void {
-    const params = (try cmd.params(struct {
-        identifier: []const u8,
-    })) orelse return error.InvalidParams;
-
-    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
-
-    const target_id = std.fmt.parseInt(u32, params.identifier, 10) catch
-        return cmd.sendResult(null, .{});
-
-    for (bc.scripts_on_new_document.items, 0..) |script, i| {
-        if (script.identifier == target_id) {
-            _ = bc.scripts_on_new_document.orderedRemove(i);
-            break;
-        }
-    }
-    return cmd.sendResult(null, .{});
-}
-
 fn close(cmd: anytype) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
 
@@ -420,6 +385,7 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
     // things, but no session.
     const session_id = bc.session_id orelse return;
 
+    const timestamp = event.timestamp;
     const frame_id = &id.toFrameId(event.frame_id);
     const loader_id = &id.toLoaderId(event.req_id);
 
@@ -471,9 +437,9 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
     const page = bc.session.currentPage() orelse return error.PageNotLoaded;
 
     // When we actually recreated the context we should have the inspector send
-    // this event, see: resetContextGroup. Sending this event will tell the
-    // client that the context ids they had are invalid and the context should
-    // be dropped. The client will expect us to send new contextCreated events,
+    // this event, see: resetContextGroup Sending this event will tell the
+    // client that the context ids they had are invalid and the context shouls
+    // be dropped The client will expect us to send new contextCreated events,
     // such that the client has new id's for the active contexts.
     // Only send executionContextsCleared for main frame navigations. For child
     // frames (iframes), clearing all contexts would destroy the main frame's
@@ -483,18 +449,6 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
         try cdp.sendEvent("Runtime.executionContextsCleared", null, .{ .session_id = session_id });
     }
 
-    // frameNavigated event
-    try cdp.sendEvent("Page.frameNavigated", .{
-        .type = "Navigation",
-        .frame = Frame{
-            .id = frame_id,
-            .url = event.url,
-            .loaderId = loader_id,
-            .securityOrigin = bc.security_origin,
-            .secureContextType = bc.secure_context_type,
-        },
-    }, .{ .session_id = session_id });
-
     {
         const aux_data = try std.fmt.allocPrint(arena, "{{\"isDefault\":true,\"type\":\"default\",\"frameId\":\"{s}\",\"loaderId\":\"{s}\"}}", .{ frame_id, loader_id });
 
@@ -528,27 +482,6 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
         );
     }
 
-    // Evaluate scripts registered via Page.addScriptToEvaluateOnNewDocument.
-    // Must run after the execution context is created but before the client
-    // receives frameNavigated/loadEventFired so polyfills are available for
-    // subsequent CDP commands.
-    if (bc.scripts_on_new_document.items.len > 0) {
-        var ls: js.Local.Scope = undefined;
-        page.js.localScope(&ls);
-        defer ls.deinit();
-
-        for (bc.scripts_on_new_document.items) |script| {
-            var try_catch: lp.js.TryCatch = undefined;
-            try_catch.init(&ls.local);
-            defer try_catch.deinit();
-
-            ls.local.eval(script.source, null) catch |err| {
-                const caught = try_catch.caughtOrError(arena, err);
-                log.warn(.cdp, "script on new doc", .{ .caught = caught });
-            };
-        }
-    }
-
     // frameNavigated event
     try cdp.sendEvent("Page.frameNavigated", .{
         .type = "Navigation",
@@ -565,22 +498,18 @@ pub fn pageNavigated(arena: Allocator, bc: anytype, event: *const Notification.P
     // chromedp client expects to receive the events is this order.
     // see https://github.com/chromedp/chromedp/issues/1558
     try cdp.sendEvent("DOM.documentUpdated", null, .{ .session_id = session_id });
-}
-
-pub fn pageDOMContentLoaded(bc: anytype, event: *const Notification.PageDOMContentLoaded) !void {
-    const session_id = bc.session_id orelse return;
-    const timestamp = event.timestamp;
-    var cdp = bc.cdp;
 
+    // domContentEventFired event
+    // TODO: partially hard coded
     try cdp.sendEvent(
         "Page.domContentEventFired",
         .{ .timestamp = timestamp },
         .{ .session_id = session_id },
     );
 
+    // lifecycle DOMContentLoaded event
+    // TODO: partially hard coded
     if (bc.page_life_cycle_events) {
-        const frame_id = &id.toFrameId(event.frame_id);
-        const loader_id = &id.toLoaderId(event.req_id);
         try cdp.sendEvent("Page.lifecycleEvent", LifecycleEvent{
             .timestamp = timestamp,
             .name = "DOMContentLoaded",
@@ -588,23 +517,16 @@ pub fn pageDOMContentLoaded(bc: anytype, event: *const Notification.PageDOMConte
             .loaderId = loader_id,
         }, .{ .session_id = session_id });
     }
-}
-
-pub fn pageLoaded(bc: anytype, event: *const Notification.PageLoaded) !void {
-    const session_id = bc.session_id orelse return;
-    const timestamp = event.timestamp;
-    var cdp = bc.cdp;
-
-    const frame_id = &id.toFrameId(event.frame_id);
 
+    // loadEventFired event
     try cdp.sendEvent(
         "Page.loadEventFired",
         .{ .timestamp = timestamp },
         .{ .session_id = session_id },
     );
 
+    // lifecycle DOMContentLoaded event
     if (bc.page_life_cycle_events) {
-        const loader_id = &id.toLoaderId(event.req_id);
         try cdp.sendEvent("Page.lifecycleEvent", LifecycleEvent{
             .timestamp = timestamp,
             .name = "load",
@@ -613,6 +535,7 @@ pub fn pageLoaded(bc: anytype, event: *const Notification.PageLoaded) !void {
         }, .{ .session_id = session_id });
     }
 
+    // frameStoppedLoading
     return cdp.sendEvent("Page.frameStoppedLoading", .{
         .frameId = frame_id,
     }, .{ .session_id = session_id });
@@ -917,55 +840,3 @@ test "cdp.page: reload" {
         try ctx.processMessage(.{ .id = 32, .method = "Page.reload", .params = .{ .ignoreCache = true } });
     }
 }
-
-test "cdp.page: addScriptToEvaluateOnNewDocument" {
-    var ctx = try testing.context();
-    defer ctx.deinit();
-
-    var bc = try ctx.loadBrowserContext(.{ .id = "BID-9", .url = "hi.html", .target_id = "FID-000000000X".* });
-
-    {
-        // Register a script — should return unique identifier "1"
-        try ctx.processMessage(.{ .id = 20, .method = "Page.addScriptToEvaluateOnNewDocument", .params = .{ .source = "window.__test = 1" } });
-        try ctx.expectSentResult(.{
-            .identifier = "1",
-        }, .{ .id = 20 });
-    }
-
-    {
-        // Register another script — should return identifier "2"
-        try ctx.processMessage(.{ .id = 21, .method = "Page.addScriptToEvaluateOnNewDocument", .params = .{ .source = "window.__test2 = 2" } });
-        try ctx.expectSentResult(.{
-            .identifier = "2",
-        }, .{ .id = 21 });
-    }
-
-    {
-        // Remove the first script — should succeed
-        try ctx.processMessage(.{ .id = 22, .method = "Page.removeScriptToEvaluateOnNewDocument", .params = .{ .identifier = "1" } });
-        try ctx.expectSentResult(null, .{ .id = 22 });
-    }
-
-    {
-        // Remove a non-existent identifier — should succeed silently
-        try ctx.processMessage(.{ .id = 23, .method = "Page.removeScriptToEvaluateOnNewDocument", .params = .{ .identifier = "999" } });
-        try ctx.expectSentResult(null, .{ .id = 23 });
-    }
-
-    {
-        try ctx.processMessage(.{ .id = 34, .method = "Page.reload" });
-        // wait for this event, which is sent after we've run the registered scripts
-        try ctx.expectSentEvent("Page.frameNavigated", .{
-            .frame = .{ .loaderId = "LID-0000000002" },
-        }, .{});
-
-        const page = bc.session.currentPage() orelse unreachable;
-
-        var ls: js.Local.Scope = undefined;
-        page.js.localScope(&ls);
-        defer ls.deinit();
-
-        const test_val = try ls.local.exec("window.__test2", null);
-        try testing.expectEqual(2, try test_val.toI32());
-    }
-}

src/cdp/domains/target.zig

@@ -24,6 +24,9 @@ const log = @import("../../log.zig");
 const URL = @import("../../browser/URL.zig");
 const js = @import("../../browser/js/js.zig");
 
+// TODO: hard coded IDs
+const LOADER_ID = "LOADERID42AA389647D702B4D805F49A";
+
 pub fn processMessage(cmd: anytype) !void {
     const action = std.meta.stringToEnum(enum {
         getTargets,

src/cdp/id.zig

@@ -17,6 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const IS_DEBUG = @import("builtin").mode == .Debug;
 
 pub fn toPageId(comptime id_type: enum { frame_id, loader_id }, input: []const u8) !u32 {
     const err = switch (comptime id_type) {

src/cdp/testing.zig

@@ -19,6 +19,10 @@
 const std = @import("std");
 const json = std.json;
 const posix = std.posix;
+const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
+
+const Testing = @This();
 
 const CDP = @import("CDP.zig");
 const Server = @import("../Server.zig");
@@ -168,26 +172,13 @@ const TestContext = struct {
         index: ?usize = null,
     };
     pub fn expectSent(self: *TestContext, expected: anytype, opts: SentOpts) !void {
-        const expected_json = blk: {
-            // Zig makes this hard. When sendJSON is called, we're sending an anytype.
-            // We can't record that in an ArrayList(???), so we serialize it to JSON.
-            // Now, ideally, we could just take our expected structure, serialize it to
-            // json and check if the two are equal.
-            // Except serializing to JSON isn't deterministic.
-            // So we serialize the JSON then we deserialize to json.Value. And then we can
-            // compare our anytype expectation with the json.Value that we captured
-
-            const serialized = try json.Stringify.valueAlloc(base.arena_allocator, expected, .{
-                .whitespace = .indent_2,
-                .emit_null_optional_fields = false,
-            });
-
-            break :blk try std.json.parseFromSliceLeaky(json.Value, base.arena_allocator, serialized, .{});
-        };
-
+        const serialized = try json.Stringify.valueAlloc(base.arena_allocator, expected, .{
+            .whitespace = .indent_2,
+            .emit_null_optional_fields = false,
+        });
         for (0..5) |_| {
             for (self.received.items, 0..) |received, i| {
-                if (try base.isEqualJson(expected_json, received) == false) {
+                if (try compareExpectedToSent(serialized, received) == false) {
                     continue;
                 }
 
@@ -200,15 +191,6 @@ const TestContext = struct {
                 }
                 return;
             }
-
-            if (self.cdp_) |*cdp__| {
-                if (cdp__.browser_context) |*bc| {
-                    if (bc.session.page != null) {
-                        var runner = try bc.session.runner(.{});
-                        _ = try runner.tick(.{ .ms = 1000 });
-                    }
-                }
-            }
             std.Thread.sleep(5 * std.time.ns_per_ms);
             try self.read();
         }
@@ -321,3 +303,17 @@ pub fn context() !TestContext {
         .socket = pair[0],
     };
 }
+
+// Zig makes this hard. When sendJSON is called, we're sending an anytype.
+// We can't record that in an ArrayList(???), so we serialize it to JSON.
+// Now, ideally, we could just take our expected structure, serialize it to
+// json and check if the two are equal.
+// Except serializing to JSON isn't deterministic.
+// So we serialize the JSON then we deserialize to json.Value. And then we can
+// compare our anytype expectation with the json.Value that we captured
+
+fn compareExpectedToSent(expected: []const u8, actual: json.Value) !bool {
+    const expected_value = try std.json.parseFromSlice(json.Value, std.testing.allocator, expected, .{});
+    defer expected_value.deinit();
+    return base.isEqualJson(expected_value.value, actual);
+}

src/lightpanda.zig

@@ -209,41 +209,6 @@ noinline fn assertionFailure(comptime ctx: []const u8, args: anytype) noreturn {
     @import("crash_handler.zig").crash(ctx, args, @returnAddress());
 }
 
-// Reference counting helper
-pub fn RC(comptime T: type) type {
-    return struct {
-        _refs: T = 0,
-
-        pub fn init(refs: T) @This() {
-            return .{ ._refs = refs };
-        }
-
-        pub fn acquire(self: *@This()) void {
-            self._refs += 1;
-        }
-
-        pub fn release(self: *@This(), value: anytype, session: *Session) void {
-            if (comptime IS_DEBUG) {
-                std.debug.assert(self._refs > 0);
-            }
-
-            const refs = self._refs - 1;
-            self._refs = refs;
-            if (refs > 0) {
-                return;
-            }
-            value.deinit(session);
-            if (session.finalizer_callbacks.fetchRemove(@intFromPtr(value))) |kv| {
-                session.releaseArena(kv.value.arena);
-            }
-        }
-
-        pub fn format(self: @This(), writer: *std.Io.Writer) !void {
-            return writer.print("{d}", .{self._refs});
-        }
-    };
-}
-
 test {
     std.testing.refAllDecls(@This());
 }

src/log.zig

@@ -49,6 +49,9 @@ const Opts = struct {
 
 pub var opts = Opts{};
 
+// synchronizes writes to the output
+var out_lock: Thread.Mutex = .{};
+
 // synchronizes access to last_log
 var last_log_lock: Thread.Mutex = .{};
 

src/mcp.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
 
 pub const protocol = @import("mcp/protocol.zig");
-pub const Version = protocol.Version;
 pub const router = @import("mcp/router.zig");
 pub const Server = @import("mcp/Server.zig");