Add XMLHttpRequest.timeout with curl enforcement

Implement the XHR timeout property end-to-end: the JS-visible
getter/setter stores the value, send() passes it to the HTTP client,
and curl enforces it via CURLOPT_TIMEOUT_MS. On timeout, a `timeout`
event is dispatched instead of `error`, per the XHR spec.

.github/workflows/e2e-integration-test.yml

@@ -62,7 +62,7 @@ jobs:
       - name: run end to end integration tests
         continue-on-error: true
         run: |
-          ./lightpanda serve --http-proxy ${{ secrets.MASSIVE_PROXY_RESIDENTIAL_US }} --log-level error & echo $! > LPD.pid
+          ./lightpanda serve --log-level error & echo $! > LPD.pid
           go run integration/main.go |tee result.log
           kill `cat LPD.pid`
 

build.zig

@@ -46,12 +46,8 @@ pub fn build(b: *Build) !void {
     var stdout = std.fs.File.stdout().writer(&.{});
     try stdout.interface.print("Lightpanda {f}\n", .{version});
 
-    const version_string = b.fmt("{f}", .{version});
-    const version_encoded = std.mem.replaceOwned(u8, b.allocator, version_string, "+", "%2B") catch @panic("OOM");
-
     var opts = b.addOptions();
-    opts.addOption([]const u8, "version", version_string);
+    opts.addOption([]const u8, "version", b.fmt("{f}", .{version}));
-    opts.addOption([]const u8, "version_encoded", version_encoded);
     opts.addOption(?[]const u8, "snapshot_path", snapshot_path);
 
     const enable_tsan = b.option(bool, "tsan", "Enable Thread Sanitizer") orelse false;
@@ -89,15 +85,6 @@ 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(.{
@@ -116,12 +103,6 @@ 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);
@@ -151,12 +132,6 @@ 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);
@@ -195,12 +170,6 @@ 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);

src/App.zig

@@ -26,7 +26,7 @@ const Snapshot = @import("browser/js/Snapshot.zig");
 const Platform = @import("browser/js/Platform.zig");
 const Telemetry = @import("telemetry/telemetry.zig").Telemetry;
 
-const Network = @import("network/Network.zig");
+const Network = @import("network/Runtime.zig");
 pub const ArenaPool = @import("ArenaPool.zig");
 
 const App = @This();
@@ -55,7 +55,7 @@ pub fn init(allocator: Allocator, config: *const Config) !*App {
         .arena_pool = undefined,
     };
 
-    app.network = try Network.init(allocator, app, config);
+    app.network = try Network.init(allocator, config);
     errdefer app.network.deinit();
 
     app.platform = try Platform.init();

src/Config.zig

@@ -34,6 +34,7 @@ pub const RunMode = enum {
     mcp,
 };
 
+pub const MAX_LISTENERS = 16;
 pub const CDP_MAX_HTTP_REQUEST_SIZE = 4096;
 
 // max message size
@@ -156,17 +157,9 @@ pub fn userAgentSuffix(self: *const Config) ?[]const u8 {
     };
 }
 
-pub fn httpCacheDir(self: *const Config) ?[]const u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_cache_dir,
-        else => null,
-    };
-}
-
 pub fn cdpTimeout(self: *const Config) usize {
     return switch (self.mode) {
         .serve => |opts| if (opts.timeout > 604_800) 604_800_000 else @as(usize, opts.timeout) * 1000,
-        .mcp => 10000, // Default timeout for MCP-CDP
         else => unreachable,
     };
 }
@@ -174,7 +167,6 @@ pub fn cdpTimeout(self: *const Config) usize {
 pub fn port(self: *const Config) u16 {
     return switch (self.mode) {
         .serve => |opts| opts.port,
-        .mcp => |opts| opts.cdp_port orelse 0,
         else => unreachable,
     };
 }
@@ -182,7 +174,6 @@ pub fn port(self: *const Config) u16 {
 pub fn advertiseHost(self: *const Config) []const u8 {
     return switch (self.mode) {
         .serve => |opts| opts.advertise_host orelse opts.host,
-        .mcp => "127.0.0.1",
         else => unreachable,
     };
 }
@@ -201,7 +192,6 @@ pub fn webBotAuth(self: *const Config) ?WebBotAuthConfig {
 pub fn maxConnections(self: *const Config) u16 {
     return switch (self.mode) {
         .serve => |opts| opts.cdp_max_connections,
-        .mcp => 16,
         else => unreachable,
     };
 }
@@ -209,7 +199,6 @@ pub fn maxConnections(self: *const Config) u16 {
 pub fn maxPendingConnections(self: *const Config) u31 {
     return switch (self.mode) {
         .serve => |opts| opts.cdp_max_pending_connections,
-        .mcp => 128,
         else => unreachable,
     };
 }
@@ -235,7 +224,6 @@ pub const Serve = struct {
 pub const Mcp = struct {
     common: Common = .{},
     version: mcp.Version = .default,
-    cdp_port: ?u16 = null,
 };
 
 pub const DumpFormat = enum {
@@ -280,7 +268,6 @@ pub const Common = struct {
     log_format: ?log.Format = null,
     log_filter_scopes: ?[]log.Scope = null,
     user_agent_suffix: ?[]const u8 = null,
-    http_cache_dir: ?[]const u8 = null,
 
     web_bot_auth_key_file: ?[]const u8 = null,
     web_bot_auth_keyid: ?[]const u8 = null,
@@ -400,11 +387,6 @@ pub fn printUsageAndExit(self: *const Config, success: bool) void {
         \\
         \\--web-bot-auth-domain
         \\                Your domain e.g. yourdomain.com
-        \\
-        \\--http-cache-dir
-        \\                Path to a directory to use as a Filesystem Cache for network resources.
-        \\                Omitting this will result is no caching.
-        \\                Defaults to no caching.
     ;
 
     //                                                                     MAX_HELP_LEN|
@@ -695,19 +677,6 @@ fn parseMcpArgs(
             continue;
         }
 
-        if (std.mem.eql(u8, "--cdp-port", opt) or std.mem.eql(u8, "--cdp_port", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.mcp, "missing argument value", .{ .arg = opt });
-                return error.InvalidArgument;
-            };
-
-            result.cdp_port = std.fmt.parseInt(u16, str, 10) catch |err| {
-                log.fatal(.mcp, "invalid argument value", .{ .arg = opt, .err = err });
-                return error.InvalidArgument;
-            };
-            continue;
-        }
-
         if (try parseCommonArg(allocator, opt, args, &result.common)) {
             continue;
         }
@@ -1079,14 +1048,5 @@ fn parseCommonArg(
         return true;
     }
 
-    if (std.mem.eql(u8, "--http-cache-dir", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http-cache-dir" });
-            return error.InvalidArgument;
-        };
-        common.http_cache_dir = try allocator.dupe(u8, str);
-        return true;
-    }
-
     return false;
 }

src/Server.zig

@@ -260,14 +260,14 @@ pub const Client = struct {
 
     fn start(self: *Client) void {
         const http = self.http;
-        http.setCdpClient(.{
+        http.cdp_client = .{
             .socket = self.ws.socket,
             .ctx = self,
             .blocking_read_start = Client.blockingReadStart,
             .blocking_read = Client.blockingRead,
             .blocking_read_end = Client.blockingReadStop,
-        });
+        };
-        defer http.setCdpClient(null);
+        defer http.cdp_client = null;
 
         self.httpLoop(http) catch |err| {
             log.err(.app, "CDP client loop", .{ .err = err });
@@ -297,12 +297,13 @@ pub const Client = struct {
         }
 
         var cdp = &self.mode.cdp;
-        const timeout_ms = self.ws.timeout_ms;
+        var last_message = milliTimestamp(.monotonic);
+        var ms_remaining = self.ws.timeout_ms;
 
         while (true) {
-            const result = cdp.pageWait(timeout_ms) catch |wait_err| switch (wait_err) {
+            const result = cdp.pageWait(ms_remaining) catch |wait_err| switch (wait_err) {
                 error.NoPage => {
-                    const status = http.tick(timeout_ms) catch |err| {
+                    const status = http.tick(ms_remaining) catch |err| {
                         log.err(.app, "http tick", .{ .err = err });
                         return;
                     };
@@ -313,6 +314,8 @@ pub const Client = struct {
                     if (self.readSocket() == false) {
                         return;
                     }
+                    last_message = milliTimestamp(.monotonic);
+                    ms_remaining = self.ws.timeout_ms;
                     continue;
                 },
                 else => return wait_err,
@@ -323,10 +326,18 @@ pub const Client = struct {
                     if (self.readSocket() == false) {
                         return;
                     }
+                    last_message = milliTimestamp(.monotonic);
+                    ms_remaining = self.ws.timeout_ms;
                 },
                 .done => {
+                    const now = milliTimestamp(.monotonic);
+                    const elapsed = now - last_message;
+                    if (elapsed >= ms_remaining) {
                         log.info(.app, "CDP timeout", .{});
                         return;
+                    }
+                    ms_remaining -= @intCast(elapsed);
+                    last_message = now;
                 },
             }
         }

src/browser/Mime.zig

@@ -27,9 +27,6 @@ charset: [41]u8 = default_charset,
 charset_len: usize = default_charset_len,
 is_default_charset: bool = true,
 
-type_buf: [127]u8 = @splat(0),
-sub_type_buf: [127]u8 = @splat(0),
-
 /// String "UTF-8" continued by null characters.
 const default_charset = .{ 'U', 'T', 'F', '-', '8' } ++ .{0} ** 36;
 const default_charset_len = 5;
@@ -64,10 +61,7 @@ pub const ContentType = union(ContentTypeEnum) {
     image_webp: void,
     application_json: void,
     unknown: void,
-    other: struct {
+    other: struct { type: []const u8, sub_type: []const u8 },
-        type: []const u8,
-        sub_type: []const u8,
-    },
 };
 
 pub fn contentTypeString(mime: *const Mime) []const u8 {
@@ -118,18 +112,17 @@ fn parseCharset(value: []const u8) error{ CharsetTooBig, Invalid }![]const u8 {
     return value;
 }
 
-pub fn parse(input: []const u8) !Mime {
+pub fn parse(input: []u8) !Mime {
     if (input.len > 255) {
         return error.TooBig;
     }
 
-    var buf: [255]u8 = undefined;
+    // Zig's trim API is broken. The return type is always `[]const u8`,
-    const normalized = std.ascii.lowerString(&buf, std.mem.trim(u8, input, &std.ascii.whitespace));
+    // even if the input type is `[]u8`. @constCast is safe here.
+    var normalized = @constCast(std.mem.trim(u8, input, &std.ascii.whitespace));
     _ = std.ascii.lowerString(normalized, normalized);
 
-    var mime = Mime{ .content_type = undefined };
+    const content_type, const type_len = try parseContentType(normalized);
-
-    const content_type, const type_len = try parseContentType(normalized, &mime.type_buf, &mime.sub_type_buf);
     if (type_len >= normalized.len) {
         return .{ .content_type = content_type };
     }
@@ -170,12 +163,13 @@ pub fn parse(input: []const u8) !Mime {
         }
     }
 
-    mime.params = params;
+    return .{
-    mime.charset = charset;
+        .params = params,
-    mime.charset_len = charset_len;
+        .charset = charset,
-    mime.content_type = content_type;
+        .charset_len = charset_len,
-    mime.is_default_charset = !has_explicit_charset;
+        .content_type = content_type,
-    return mime;
+        .is_default_charset = !has_explicit_charset,
+    };
 }
 
 /// Prescan the first 1024 bytes of an HTML document for a charset declaration.
@@ -401,7 +395,7 @@ pub fn isText(mime: *const Mime) bool {
 }
 
 // we expect value to be lowercase
-fn parseContentType(value: []const u8, type_buf: []u8, sub_type_buf: []u8) !struct { ContentType, usize } {
+fn parseContentType(value: []const u8) !struct { ContentType, usize } {
     const end = std.mem.indexOfScalarPos(u8, value, 0, ';') orelse value.len;
     const type_name = trimRight(value[0..end]);
     const attribute_start = end + 1;
@@ -450,18 +444,10 @@ fn parseContentType(value: []const u8, type_buf: []u8, sub_type_buf: []u8) !stru
         return error.Invalid;
     }
 
-    @memcpy(type_buf[0..main_type.len], main_type);
+    return .{ .{ .other = .{
-    @memcpy(sub_type_buf[0..sub_type.len], sub_type);
+        .type = main_type,
-
+        .sub_type = sub_type,
-    return .{
+    } }, attribute_start };
-        .{
-            .other = .{
-                .type = type_buf[0..main_type.len],
-                .sub_type = sub_type_buf[0..sub_type.len],
-            },
-        },
-        attribute_start,
-    };
 }
 
 const VALID_CODEPOINTS = blk: {
@@ -475,13 +461,6 @@ const VALID_CODEPOINTS = blk: {
     break :blk v;
 };
 
-pub fn typeString(self: *const Mime) []const u8 {
-    return switch (self.content_type) {
-        .other => |o| o.type[0..o.type_len],
-        else => "",
-    };
-}
-
 fn validType(value: []const u8) bool {
     for (value) |b| {
         if (VALID_CODEPOINTS[b] == false) {

src/browser/Page.zig

@@ -351,30 +351,6 @@ pub fn deinit(self: *Page, abort_http: bool) void {
         session.releaseArena(qn.arena);
     }
 
-    {
-        // Release all objects we're referencing
-        {
-            var it = self._blob_urls.valueIterator();
-            while (it.next()) |blob| {
-                blob.*.releaseRef(session);
-            }
-        }
-
-        {
-            var it: ?*std.DoublyLinkedList.Node = self._mutation_observers.first;
-            while (it) |node| : (it = node.next) {
-                const observer: *MutationObserver = @fieldParentPtr("node", node);
-                observer.releaseRef(session);
-            }
-        }
-
-        for (self._intersection_observers.items) |observer| {
-            observer.releaseRef(session);
-        }
-
-        self.window._document._selection.releaseRef(session);
-    }
-
     session.browser.env.destroyContext(self.js);
 
     self._script_manager.shutdown = true;
@@ -438,15 +414,7 @@ pub fn releaseArena(self: *Page, allocator: Allocator) void {
 
 pub fn isSameOrigin(self: *const Page, url: [:0]const u8) !bool {
     const current_origin = self.origin orelse return false;
-
+    return std.mem.startsWith(u8, url, current_origin);
-    // fastpath
-    if (!std.mem.startsWith(u8, url, current_origin)) {
-        return false;
-    }
-
-    // Starting here, at least protocols are equals.
-    // Compare hosts (domain:port) strictly
-    return std.mem.eql(u8, URL.getHost(url), URL.getHost(current_origin));
 }
 
 /// Look up a blob URL in this page's registry.
@@ -886,10 +854,12 @@ fn notifyParentLoadComplete(self: *Page) void {
     parent.iframeCompletedLoading(self.iframe.?);
 }
 
-fn pageHeaderDoneCallback(response: HttpClient.Response) !bool {
+fn pageHeaderDoneCallback(transfer: *HttpClient.Transfer) !bool {
-    var self: *Page = @ptrCast(@alignCast(response.ctx));
+    var self: *Page = @ptrCast(@alignCast(transfer.ctx));
 
-    const response_url = response.url();
+    const header = &transfer.response_header.?;
+
+    const response_url = std.mem.span(header.url);
     if (std.mem.eql(u8, response_url, self.url) == false) {
         // would be different than self.url in the case of a redirect
         self.url = try self.arena.dupeZ(u8, response_url);
@@ -903,8 +873,8 @@ fn pageHeaderDoneCallback(response: HttpClient.Response) !bool {
     if (comptime IS_DEBUG) {
         log.debug(.page, "navigate header", .{
             .url = self.url,
-            .status = response.status(),
+            .status = header.status,
-            .content_type = response.contentType(),
+            .content_type = header.contentType(),
             .type = self._type,
         });
     }
@@ -925,14 +895,14 @@ fn pageHeaderDoneCallback(response: HttpClient.Response) !bool {
     return true;
 }
 
-fn pageDataCallback(response: HttpClient.Response, data: []const u8) !void {
+fn pageDataCallback(transfer: *HttpClient.Transfer, data: []const u8) !void {
-    var self: *Page = @ptrCast(@alignCast(response.ctx));
+    var self: *Page = @ptrCast(@alignCast(transfer.ctx));
 
     if (self._parse_state == .pre) {
         // we lazily do this, because we might need the first chunk of data
         // to sniff the content type
         var mime: Mime = blk: {
-            if (response.contentType()) |ct| {
+            if (transfer.response_header.?.contentType()) |ct| {
                 break :blk try Mime.parse(ct);
             }
             break :blk Mime.sniff(data);
@@ -1368,24 +1338,20 @@ pub fn schedulePerformanceObserverDelivery(self: *Page) !void {
 }
 
 pub fn registerMutationObserver(self: *Page, observer: *MutationObserver) !void {
-    observer.acquireRef();
     self._mutation_observers.append(&observer.node);
 }
 
 pub fn unregisterMutationObserver(self: *Page, observer: *MutationObserver) void {
-    observer.releaseRef(self._session);
     self._mutation_observers.remove(&observer.node);
 }
 
 pub fn registerIntersectionObserver(self: *Page, observer: *IntersectionObserver) !void {
-    observer.acquireRef();
     try self._intersection_observers.append(self.arena, observer);
 }
 
 pub fn unregisterIntersectionObserver(self: *Page, observer: *IntersectionObserver) void {
     for (self._intersection_observers.items, 0..) |obs, i| {
         if (obs == observer) {
-            observer.releaseRef(self._session);
             _ = self._intersection_observers.swapRemove(i);
             return;
         }
@@ -3622,41 +3588,3 @@ test "WebApi: Frames" {
 test "WebApi: Integration" {
     try testing.htmlRunner("integration", .{});
 }
-
-test "Page: isSameOrigin" {
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    var page: Page = undefined;
-
-    page.origin = null;
-    try testing.expectEqual(false, page.isSameOrigin("https://origin.com/"));
-
-    page.origin = try URL.getOrigin(allocator, "https://origin.com/foo/bar") orelse unreachable;
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com/foo/bar")); // exact same
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com/bar/bar")); // path differ
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com/")); // path differ
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com")); // no path
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com/foo?q=1"));
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com/foo#hash"));
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com/foo?q=1#hash"));
-    // FIXME try testing.expectEqual(true, page.isSameOrigin("https://foo:bar@origin.com"));
-    // FIXME try testing.expectEqual(true, page.isSameOrigin("https://origin.com:443/foo"));
-
-    try testing.expectEqual(false, page.isSameOrigin("http://origin.com/")); // another proto
-    try testing.expectEqual(false, page.isSameOrigin("https://origin.com:123/")); // another port
-    try testing.expectEqual(false, page.isSameOrigin("https://sub.origin.com/")); // another subdomain
-    try testing.expectEqual(false, page.isSameOrigin("https://target.com/")); // different domain
-    try testing.expectEqual(false, page.isSameOrigin("https://origin.com.target.com/")); // different domain
-    try testing.expectEqual(false, page.isSameOrigin("https://target.com/@origin.com"));
-
-    page.origin = try URL.getOrigin(allocator, "https://origin.com:8443/foo") orelse unreachable;
-    try testing.expectEqual(true, page.isSameOrigin("https://origin.com:8443/bar"));
-    try testing.expectEqual(false, page.isSameOrigin("https://origin.com/bar")); // missing port
-    try testing.expectEqual(false, page.isSameOrigin("https://origin.com:9999/bar")); // wrong port
-
-    try testing.expectEqual(false, page.isSameOrigin(""));
-    try testing.expectEqual(false, page.isSameOrigin("not-a-url"));
-    try testing.expectEqual(false, page.isSameOrigin("//origin.com/foo"));
-}

src/browser/Runner.zig

@@ -68,6 +68,7 @@ pub fn waitCDP(self: *Runner, opts: WaitOpts) !CDPWaitResult {
 
 fn _wait(self: *Runner, comptime is_cdp: bool, opts: WaitOpts) !CDPWaitResult {
     var timer = try std.time.Timer.start();
+    var ms_remaining = opts.ms;
 
     const tick_opts = TickOpts{
         .ms = 200,
@@ -91,10 +92,11 @@ fn _wait(self: *Runner, comptime is_cdp: bool, opts: WaitOpts) !CDPWaitResult {
             .cdp_socket => if (comptime is_cdp) return .cdp_socket else unreachable,
         };
 
-        const ms_elapsed: u32 = @intCast(timer.read() / std.time.ns_per_ms);
+        const ms_elapsed = timer.lap() / 1_000_000;
-        if (ms_elapsed >= opts.ms) {
+        if (ms_elapsed >= ms_remaining) {
             return .done;
         }
+        ms_remaining -= @intCast(ms_elapsed);
         if (next_ms > 0) {
             std.Thread.sleep(std.time.ns_per_ms * next_ms);
         }
@@ -135,7 +137,7 @@ fn _tick(self: *Runner, comptime is_cdp: bool, opts: TickOpts) !CDPTickResult {
         .pre, .raw, .text, .image => {
             // The main page hasn't started/finished navigating.
             // There's no JS to run, and no reason to run the scheduler.
-            if (http_client.active() == 0 and (comptime is_cdp) == false) {
+            if (http_client.active == 0 and (comptime is_cdp) == false) {
                 // haven't started navigating, I guess.
                 return .done;
             }
@@ -169,8 +171,8 @@ fn _tick(self: *Runner, comptime is_cdp: bool, opts: TickOpts) !CDPTickResult {
             // Each call to this runs scheduled load events.
             try page.dispatchLoad();
 
-            const http_active = http_client.active();
+            const http_active = http_client.active;
-            const total_network_activity = http_active + http_client.intercepted();
+            const total_network_activity = http_active + http_client.intercepted;
             if (page._notified_network_almost_idle.check(total_network_activity <= 2)) {
                 page.notifyNetworkAlmostIdle();
             }
@@ -183,7 +185,7 @@ fn _tick(self: *Runner, comptime is_cdp: bool, opts: TickOpts) !CDPTickResult {
                 // because is_cdp is true, and that can only be
                 // the case when interception isn't possible.
                 if (comptime IS_DEBUG) {
-                    std.debug.assert(http_client.intercepted() == 0);
+                    std.debug.assert(http_client.intercepted == 0);
                 }
 
                 if (browser.hasBackgroundTasks()) {
@@ -235,16 +237,7 @@ fn _tick(self: *Runner, comptime is_cdp: bool, opts: TickOpts) !CDPTickResult {
             page._parse_state = .{ .raw_done = @errorName(err) };
             return err;
         },
-        .raw_done => {
+        .raw_done => return .done,
-            if (comptime is_cdp) {
-                const http_result = try http_client.tick(@intCast(opts.ms));
-                if (http_result == .cdp_socket) {
-                    return .cdp_socket;
-                }
-                return .{ .ok = 0 };
-            }
-            return .done;
-        },
     }
 }
 

src/browser/ScriptManager.zig

@@ -22,7 +22,7 @@ const builtin = @import("builtin");
 
 const log = @import("../log.zig");
 const HttpClient = @import("HttpClient.zig");
-const http = @import("../network/http.zig");
+const net_http = @import("../network/http.zig");
 const String = @import("../string.zig").String;
 
 const js = @import("js/js.zig");
@@ -136,7 +136,7 @@ fn clearList(list: *std.DoublyLinkedList) void {
     }
 }
 
-fn getHeaders(self: *ScriptManager) !http.Headers {
+fn getHeaders(self: *ScriptManager) !net_http.Headers {
     var headers = try self.client.newHeaders();
     try self.page.headersForRequest(&headers);
     return headers;
@@ -273,24 +273,6 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
             // Let the outer errdefer handle releasing the arena if client.request fails
         }
 
-        if (comptime IS_DEBUG) {
-            var ls: js.Local.Scope = undefined;
-            page.js.localScope(&ls);
-            defer ls.deinit();
-
-            log.debug(.http, "script queue", .{
-                .ctx = ctx,
-                .url = remote_url.?,
-                .element = element,
-                .stack = ls.local.stackTrace() catch "???",
-            });
-        }
-
-        {
-            const was_evaluating = self.is_evaluating;
-            self.is_evaluating = true;
-            defer self.is_evaluating = was_evaluating;
-
         try self.client.request(.{
             .url = url,
             .ctx = script,
@@ -308,9 +290,20 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
             .done_callback = Script.doneCallback,
             .error_callback = Script.errorCallback,
         });
-        }
-
         handover = true;
+
+        if (comptime IS_DEBUG) {
+            var ls: js.Local.Scope = undefined;
+            page.js.localScope(&ls);
+            defer ls.deinit();
+
+            log.debug(.http, "script queue", .{
+                .ctx = ctx,
+                .url = remote_url.?,
+                .element = element,
+                .stack = ls.local.stackTrace() catch "???",
+            });
+        }
     }
 
     if (is_blocking == false) {
@@ -701,33 +694,32 @@ pub const Script = struct {
         self.manager.page.releaseArena(self.arena);
     }
 
-    fn startCallback(response: HttpClient.Response) !void {
+    fn startCallback(transfer: *HttpClient.Transfer) !void {
-        log.debug(.http, "script fetch start", .{ .req = response });
+        log.debug(.http, "script fetch start", .{ .req = transfer });
     }
 
-    fn headerCallback(response: HttpClient.Response) !bool {
+    fn headerCallback(transfer: *HttpClient.Transfer) !bool {
-        const self: *Script = @ptrCast(@alignCast(response.ctx));
+        const self: *Script = @ptrCast(@alignCast(transfer.ctx));
-
+        const header = &transfer.response_header.?;
-        self.status = response.status().?;
+        self.status = header.status;
-        if (response.status() != 200) {
+        if (header.status != 200) {
             log.info(.http, "script header", .{
-                .req = response,
+                .req = transfer,
-                .status = response.status(),
+                .status = header.status,
-                .content_type = response.contentType(),
+                .content_type = header.contentType(),
             });
             return false;
         }
 
         if (comptime IS_DEBUG) {
             log.debug(.http, "script header", .{
-                .req = response,
+                .req = transfer,
-                .status = response.status(),
+                .status = header.status,
-                .content_type = response.contentType(),
+                .content_type = header.contentType(),
             });
         }
 
-        switch (response.inner) {
+        {
-            .transfer => |transfer| {
             // temp debug, trying to figure out why the next assert sometimes
             // fails. Is the buffer just corrupt or is headerCallback really
             // being called twice?
@@ -759,28 +751,25 @@ pub const Script = struct {
             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;
-            },
-            else => {},
         }
 
         lp.assert(self.source.remote.capacity == 0, "ScriptManager.Header buffer", .{ .capacity = self.source.remote.capacity });
         var buffer: std.ArrayList(u8) = .empty;
-        if (response.contentLength()) |cl| {
+        if (transfer.getContentLength()) |cl| {
             try buffer.ensureTotalCapacity(self.arena, cl);
         }
         self.source = .{ .remote = buffer };
         return true;
     }
 
-    fn dataCallback(response: HttpClient.Response, data: []const u8) !void {
+    fn dataCallback(transfer: *HttpClient.Transfer, data: []const u8) !void {
-        const self: *Script = @ptrCast(@alignCast(response.ctx));
+        const self: *Script = @ptrCast(@alignCast(transfer.ctx));
-        self._dataCallback(response, data) catch |err| {
+        self._dataCallback(transfer, data) catch |err| {
-            log.err(.http, "SM.dataCallback", .{ .err = err, .transfer = response, .len = data.len });
+            log.err(.http, "SM.dataCallback", .{ .err = err, .transfer = transfer, .len = data.len });
             return err;
         };
     }
-
+    fn _dataCallback(self: *Script, _: *HttpClient.Transfer, data: []const u8) !void {
-    fn _dataCallback(self: *Script, _: HttpClient.Response, data: []const u8) !void {
         try self.source.remote.appendSlice(self.arena, data);
     }
 

src/browser/Session.zig

@@ -501,11 +501,7 @@ pub const FinalizerCallback = struct {
     session: *Session,
     resolved_ptr_id: usize,
     finalizer_ptr_id: usize,
-    release_ref: *const fn (ptr_id: usize, session: *Session) void,
+    _deinit: *const fn (ptr_id: usize, session: *Session) void,
-
-    // Track how many identities (JS worlds) reference this FC.
-    // Only cleanup when all identities have finalized.
-    identity_count: u8 = 0,
 
     // For every FinalizerCallback we'll have 1+ FinalizerCallback.Identity: one
     // for every identity that gets the instance. In most cases, that'l be 1.
@@ -514,9 +510,8 @@ pub const FinalizerCallback = struct {
         fc: *Session.FinalizerCallback,
     };
 
-    // Called during page reset to force cleanup regardless of identity_count.
     fn deinit(self: *FinalizerCallback, session: *Session) void {
-        self.release_ref(self.finalizer_ptr_id, session);
+        self._deinit(self.finalizer_ptr_id, session);
         session.releaseArena(self.arena);
     }
 };

src/browser/URL.zig

@@ -25,73 +25,29 @@ const ResolveOpts = struct {
 };
 
 // path is anytype, so that it can be used with both []const u8 and [:0]const u8
-pub fn resolve(allocator: Allocator, base: [:0]const u8, source_path: anytype, comptime opts: ResolveOpts) ![:0]const u8 {
+pub fn resolve(allocator: Allocator, base: [:0]const u8, path: anytype, comptime opts: ResolveOpts) ![:0]const u8 {
-    const PT = @TypeOf(source_path);
+    const PT = @TypeOf(path);
-
+    if (base.len == 0 or isCompleteHTTPUrl(path)) {
-    var path: [:0]const u8 = if (comptime !isNullTerminated(PT) or opts.always_dupe) try allocator.dupeZ(u8, source_path) else source_path;
+        if (comptime opts.always_dupe or !isNullTerminated(PT)) {
-
+            const duped = try allocator.dupeZ(u8, path);
-    if (base.len == 0) {
+            return processResolved(allocator, duped, opts);
+        }
+        if (comptime opts.encode) {
             return processResolved(allocator, path, opts);
         }
-
+        return path;
-    // Minimum is "x:" and skip relative path (very common case)
-    if (path.len >= 2 and path[0] != '/') {
-        if (std.mem.indexOfScalar(u8, path[0..], ':')) |scheme_path_end| {
-            scheme_check: {
-                const scheme_path = path[0..scheme_path_end];
-                //from "ws" to "https"
-                if (scheme_path_end >= 2 and scheme_path_end <= 5) {
-                    const has_double_slashes: bool = scheme_path_end + 3 <= path.len and path[scheme_path_end + 1] == '/' and path[scheme_path_end + 2] == '/';
-                    const special_schemes = [_][]const u8{ "https", "http", "ws", "wss", "file", "ftp" };
-
-                    for (special_schemes) |special_scheme| {
-                        if (std.ascii.eqlIgnoreCase(scheme_path, special_scheme)) {
-                            const base_scheme_end = std.mem.indexOf(u8, base, "://") orelse 0;
-
-                            if (base_scheme_end > 0 and std.mem.eql(u8, base[0..base_scheme_end], scheme_path) and !has_double_slashes) {
-                                //Skip ":" and exit as relative state
-                                path = path[scheme_path_end + 1 ..];
-                                break :scheme_check;
-                            } else {
-                                var rest_start: usize = scheme_path_end + 1;
-                                //Skip any slashas after "scheme:"
-                                while (rest_start < path.len and (path[rest_start] == '/' or path[rest_start] == '\\')) {
-                                    rest_start += 1;
-                                }
-                                // A special scheme (exclude "file") must contain at least any chars after "://"
-                                if (rest_start == path.len and !std.ascii.eqlIgnoreCase(scheme_path, "file")) {
-                                    return error.TypeError;
-                                }
-                                //File scheme allow empty host
-                                const separator: []const u8 = if (!has_double_slashes and std.ascii.eqlIgnoreCase(scheme_path, "file")) ":///" else "://";
-
-                                path = try std.mem.joinZ(allocator, "", &.{ scheme_path, separator, path[rest_start..] });
-                                return processResolved(allocator, path, opts);
-                            }
-                        }
-                    }
-                }
-                if (scheme_path.len > 0) {
-                    for (scheme_path[1..]) |c| {
-                        if (!std.ascii.isAlphanumeric(c) and c != '+' and c != '-' and c != '.') {
-                            //Exit as relative state
-                            break :scheme_check;
-                        }
-                    }
-                }
-                //path is complete http url
-                return processResolved(allocator, path, opts);
-            }
-        }
     }
 
     if (path.len == 0) {
-        if (opts.always_dupe) {
+        if (comptime opts.always_dupe) {
-            const dupe = try allocator.dupeZ(u8, base);
+            const duped = try allocator.dupeZ(u8, base);
-            return processResolved(allocator, dupe, opts);
+            return processResolved(allocator, duped, opts);
         }
+        if (comptime opts.encode) {
             return processResolved(allocator, base, opts);
         }
+        return base;
+    }
 
     if (path[0] == '?') {
         const base_path_end = std.mem.indexOfAny(u8, base, "?#") orelse base.len;
@@ -107,7 +63,14 @@ pub fn resolve(allocator: Allocator, base: [:0]const u8, source_path: anytype, c
     if (std.mem.startsWith(u8, path, "//")) {
         // network-path reference
         const index = std.mem.indexOfScalar(u8, base, ':') orelse {
+            if (comptime isNullTerminated(PT)) {
+                if (comptime opts.encode) {
                     return processResolved(allocator, path, opts);
+                }
+                return path;
+            }
+            const duped = try allocator.dupeZ(u8, path);
+            return processResolved(allocator, duped, opts);
         };
         const protocol = base[0 .. index + 1];
         const result = try std.mem.joinZ(allocator, "", &.{ protocol, path });
@@ -133,7 +96,6 @@ pub fn resolve(allocator: Allocator, base: [:0]const u8, source_path: anytype, c
     // trailing space so that we always have space to append the null terminator
     // and so that we can compare the next two characters without needing to length check
     var out = try std.mem.join(allocator, "", &.{ normalized_base, "/", path, "  " });
-
     const end = out.len - 2;
 
     const path_marker = path_start + 1;
@@ -509,7 +471,7 @@ fn getUserInfo(raw: [:0]const u8) ?[]const u8 {
     return raw[authority_start .. auth.host_start - 1];
 }
 
-pub fn getHost(raw: []const u8) []const u8 {
+pub fn getHost(raw: [:0]const u8) []const u8 {
     const auth = parseAuthority(raw) orelse return "";
     return auth.getHost(raw);
 }
@@ -1608,182 +1570,3 @@ test "URL: getOrigin" {
         }
     }
 }
-
-test "URL: resolve path scheme" {
-    const Case = struct {
-        base: [:0]const u8,
-        path: [:0]const u8,
-        expected: [:0]const u8,
-        expected_error: bool = false,
-    };
-
-    const cases = [_]Case{
-        //same schemes and path as relative path (one slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:/about",
-            .expected = "https://www.example.com/about",
-        },
-        //same schemes and path as relative path (without slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:about",
-            .expected = "https://www.example.com/about",
-        },
-        //same schemes and path as absolute path (two slashes)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https://about",
-            .expected = "https://about",
-        },
-        //different schemes and path as absolute (without slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "http:about",
-            .expected = "http://about",
-        },
-        //different schemes and path as absolute (with one slash)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "http:/about",
-            .expected = "http://about",
-        },
-        //different schemes and path as absolute (with two slashes)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "http://about",
-            .expected = "http://about",
-        },
-        //same schemes and path as absolute (with more slashes)
-        .{
-            .base = "https://site/",
-            .path = "https://path",
-            .expected = "https://path",
-        },
-        //path scheme is not special and path as absolute (without additional slashes)
-        .{
-            .base = "http://localhost/",
-            .path = "data:test",
-            .expected = "data:test",
-        },
-        //different schemes and path as absolute (pathscheme=ws)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "ws://about",
-            .expected = "ws://about",
-        },
-        //different schemes and path as absolute (path scheme=wss)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "wss://about",
-            .expected = "wss://about",
-        },
-        //different schemes and path as absolute (path scheme=ftp)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "ftp://about",
-            .expected = "ftp://about",
-        },
-        //different schemes and path as absolute (path scheme=file)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file://path/to/file",
-            .expected = "file://path/to/file",
-        },
-        //different schemes and path as absolute (path scheme=file, host is empty)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file:/path/to/file",
-            .expected = "file:///path/to/file",
-        },
-        //different schemes and path as absolute (path scheme=file, host is empty)
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file:/",
-            .expected = "file:///",
-        },
-        //different schemes without :// and normalize "file" scheme, absolute path
-        .{
-            .base = "https://www.example.com/example",
-            .path = "file:path/to/file",
-            .expected = "file:///path/to/file",
-        },
-        //same schemes without :// in path and rest starts with scheme:/, relative path
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:/file:/relative/path/",
-            .expected = "https://www.example.com/file:/relative/path/",
-        },
-        //same schemes without :// in path and rest starts with scheme://, relative path
-        .{
-            .base = "https://www.example.com/example",
-            .path = "https:/http://relative/path/",
-            .expected = "https://www.example.com/http://relative/path/",
-        },
-        //same schemes without :// in path , relative state
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:relative:path",
-            .expected = "http://www.example.com/relative:path",
-        },
-        //repeat different schemes in path
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:http:/relative/path/",
-            .expected = "http://www.example.com/http:/relative/path/",
-        },
-        //repeat different schemes in path
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:https://relative:path",
-            .expected = "http://www.example.com/https://relative:path",
-        },
-        //NOT required :// for blob scheme
-        .{
-            .base = "http://www.example.com/example",
-            .path = "blob:other",
-            .expected = "blob:other",
-        },
-        //NOT required :// for NON-special schemes and can contains "+" or "-" or "." in scheme
-        .{
-            .base = "http://www.example.com/example",
-            .path = "custom+foo:other",
-            .expected = "custom+foo:other",
-        },
-        //NOT required :// for NON-special schemes
-        .{
-            .base = "http://www.example.com/example",
-            .path = "blob:",
-            .expected = "blob:",
-        },
-        //NOT required :// for special scheme equal base scheme
-        .{
-            .base = "http://www.example.com/example",
-            .path = "http:",
-            .expected = "http://www.example.com/example",
-        },
-        //required :// for special scheme, so throw error.InvalidURL
-        .{
-            .base = "http://www.example.com/example",
-            .path = "https:",
-            .expected = "",
-            .expected_error = true,
-        },
-        //incorrect symbols in path scheme
-        .{
-            .base = "https://site",
-            .path = "http?://host/some",
-            .expected = "https://site/http?://host/some",
-        },
-    };
-
-    for (cases) |case| {
-        if (case.expected_error) {
-            const result = resolve(testing.arena_allocator, case.base, case.path, .{});
-            try testing.expectError(error.TypeError, result);
-        } else {
-            const result = try resolve(testing.arena_allocator, case.base, case.path, .{});
-            try testing.expectString(case.expected, result);
-        }
-    }
-}

src/browser/js/Env.zig

@@ -296,7 +296,7 @@ pub fn createContext(self: *Env, page: *Page, params: ContextParams) !*Context {
         // it gets setup automatically as objects are created, but the Window
         // object already exists in v8 (it's the global) so we manually create
         // the mapping here.
-        const tao = try params.identity_arena.create(@import("TaggedOpaque.zig"));
+        const tao = try context_arena.create(@import("TaggedOpaque.zig"));
         tao.* = .{
             .value = @ptrCast(page.window),
             .prototype_chain = (&Window.JsApi.Meta.prototype_chain).ptr,

src/browser/js/Local.zig

@@ -244,10 +244,7 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
                 // The TAO contains the pointer to our Zig instance as
                 // well as any meta data we'll need to use it later.
                 // See the TaggedOpaque struct for more details.
-                // Use identity_arena so TAOs survive context destruction. V8 objects
+                const tao = try context_arena.create(TaggedOpaque);
-                // are stored in identity_map (session-level) and may be referenced
-                // after their creating context is destroyed (e.g., via microtasks).
-                const tao = try ctx.identity_arena.create(TaggedOpaque);
                 tao.* = .{
                     .value = resolved.ptr,
                     .prototype_chain = resolved.prototype_chain.ptr,
@@ -269,6 +266,7 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
             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);
@@ -277,8 +275,7 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
                     // 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.acquire_ref(finalizer_ptr_id);
+                    finalizer_gop.value_ptr.* = try self.createFinalizerCallback(resolved_ptr_id, finalizer_ptr_id, finalizer.deinit);
-                    finalizer_gop.value_ptr.* = try self.createFinalizerCallback(resolved_ptr_id, finalizer_ptr_id, finalizer.release_ref_from_zig);
                 }
                 const fc = finalizer_gop.value_ptr.*;
                 const identity_finalizer = try fc.arena.create(Session.FinalizerCallback.Identity);
@@ -286,9 +283,8 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
                     .fc = fc,
                     .identity = ctx.identity,
                 };
-                fc.identity_count += 1;
 
-                v8.v8__Global__SetWeakFinalizer(gop.value_ptr, identity_finalizer, finalizer.release_ref, v8.kParameter);
+                v8.v8__Global__SetWeakFinalizer(gop.value_ptr, identity_finalizer, finalizer.release, v8.kParameter);
             }
             return js_obj;
         },
@@ -1132,9 +1128,9 @@ const Resolved = 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,
-        acquire_ref: *const fn (ptr_id: usize) void,
+        deinit: *const fn (ptr_id: usize, session: *Session) void,
-        release_ref: *const fn (handle: ?*const v8.WeakCallbackInfo) callconv(.c) void,
+        acquireRef: *const fn (ptr_id: usize) void,
-        release_ref_from_zig: *const fn (ptr_id: usize, session: *Session) void,
+        release: *const fn (handle: ?*const v8.WeakCallbackInfo) callconv(.c) void,
     };
 };
 pub fn resolveValue(value: anytype) Resolved {
@@ -1174,49 +1170,32 @@ fn resolveT(comptime T: type, value: *T) Resolved {
             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 releaseRef(handle: ?*const v8.WeakCallbackInfo) callconv(.c) void {
+                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;
-                    const session = fc.session;
-                    const finalizer_ptr_id = fc.finalizer_ptr_id;
-
-                    // Remove from this identity's map
                     if (identity_finalizer.identity.identity_map.fetchRemove(fc.resolved_ptr_id)) |kv| {
                         var global = kv.value;
                         v8.v8__Global__Reset(&global);
                     }
 
-                    const identity_count = fc.identity_count;
+                    FT.releaseRef(@ptrFromInt(fc.finalizer_ptr_id), fc.session);
-                    if (identity_count == 1) {
-                        // All IsolatedWorlds that reference this object have
-                        // released it. Release the instance ref, remove the
-                        // FinalizerCallback and free it.
-                        FT.releaseRef(@ptrFromInt(finalizer_ptr_id), session);
-                        const removed = session.finalizer_callbacks.remove(finalizer_ptr_id);
-                        if (comptime IS_DEBUG) {
-                            std.debug.assert(removed);
-                        }
-                        session.releaseArena(fc.arena);
-                    } else {
-                        fc.identity_count = identity_count - 1;
-                    }
-                }
-
-                fn releaseRefFromZig(ptr_id: usize, session: *Session) void {
-                    FT.releaseRef(@ptrFromInt(ptr_id), session);
                 }
             };
             break :blk .{
                 .ptr_id = @intFromPtr(finalizer_ptr),
-                .acquire_ref = Wrap.acquireRef,
+                .deinit = Wrap.deinit,
-                .release_ref = Wrap.releaseRef,
+                .acquireRef = Wrap.acquireRef,
-                .release_ref_from_zig = Wrap.releaseRefFromZig,
+                .release = Wrap.release,
             };
         },
     };
@@ -1475,7 +1454,7 @@ fn createFinalizerCallback(
     // The most specific value where finalizers are defined
     // What actually gets acquired / released / deinit
     finalizer_ptr_id: usize,
-    release_ref: *const fn (ptr_id: usize, session: *Session) void,
+    deinit: *const fn (ptr_id: usize, session: *Session) void,
 ) !*Session.FinalizerCallback {
     const session = self.ctx.session;
 
@@ -1486,7 +1465,7 @@ fn createFinalizerCallback(
     fc.* = .{
         .arena = arena,
         .session = session,
-        .release_ref = release_ref,
+        ._deinit = deinit,
         .resolved_ptr_id = resolved_ptr_id,
         .finalizer_ptr_id = finalizer_ptr_id,
     };

src/browser/markdown.zig

@@ -25,7 +25,9 @@ const Element = @import("webapi/Element.zig");
 const Node = @import("webapi/Node.zig");
 const isAllWhitespace = @import("../string.zig").isAllWhitespace;
 
-pub const Opts = struct {};
+pub const Opts = struct {
+    // Options for future customization (e.g., dialect)
+};
 
 const State = struct {
     const ListType = enum { ordered, unordered };
@@ -37,6 +39,7 @@ const State = struct {
     list_depth: usize = 0,
     list_stack: [32]ListState = undefined,
     pre_node: ?*Node = null,
+    in_code: bool = false,
     in_table: bool = false,
     table_row_index: usize = 0,
     table_col_count: usize = 0,
@@ -97,35 +100,27 @@ fn getAnchorLabel(el: *Element) ?[]const u8 {
     return el.getAttributeSafe(comptime .wrap("aria-label")) orelse el.getAttributeSafe(comptime .wrap("title"));
 }
 
-const ContentInfo = struct {
+fn hasBlockDescendant(root: *Node) bool {
-    has_visible: bool,
+    var tw = TreeWalker.FullExcludeSelf.Elements.init(root, .{});
-    has_block: bool,
+    while (tw.next()) |el| {
-};
+        if (el.getTag().isBlock()) return true;
+    }
+    return false;
+}
 
-fn analyzeContent(root: *Node) ContentInfo {
+fn hasVisibleContent(root: *Node) bool {
-    var result: ContentInfo = .{ .has_visible = false, .has_block = false };
     var tw = TreeWalker.FullExcludeSelf.init(root, .{});
     while (tw.next()) |node| {
-        if (isSignificantText(node)) {
+        if (isSignificantText(node)) return true;
-            result.has_visible = true;
+        if (node.is(Element)) |el| {
-            if (result.has_block) return result;
-        } else if (node.is(Element)) |el| {
             if (!isVisibleElement(el)) {
                 tw.skipChildren();
-            } else {
+            } else if (el.getTag() == .img) {
-                const tag = el.getTag();
+                return true;
-                if (tag == .img) {
-                    result.has_visible = true;
-                    if (result.has_block) return result;
-                }
-                if (tag.isBlock()) {
-                    result.has_block = true;
-                    if (result.has_visible) return result;
             }
         }
     }
-    }
+    return false;
-    return result;
 }
 
 const Context = struct {
@@ -175,7 +170,9 @@ const Context = struct {
 
         if (!isVisibleElement(el)) return;
 
-        // Ensure block elements start on a new line
+        // --- Opening Tag Logic ---
+
+        // Ensure block elements start on a new line (double newline for paragraphs etc)
         if (tag.isBlock() and !self.state.in_table) {
             try self.ensureNewline();
             if (shouldAddSpacing(tag)) {
@@ -185,6 +182,7 @@ const Context = struct {
             try self.ensureNewline();
         }
 
+        // Prefixes
         switch (tag) {
             .h1 => try self.writer.writeAll("# "),
             .h2 => try self.writer.writeAll("## "),
@@ -227,6 +225,7 @@ const Context = struct {
                 try self.writer.writeByte('|');
             },
             .td, .th => {
+                // Note: leading pipe handled by previous cell closing or tr opening
                 self.state.last_char_was_newline = false;
                 try self.writer.writeByte(' ');
             },
@@ -242,6 +241,7 @@ const Context = struct {
             .code => {
                 if (self.state.pre_node == null) {
                     try self.writer.writeByte('`');
+                    self.state.in_code = true;
                     self.state.last_char_was_newline = false;
                 }
             },
@@ -286,15 +286,16 @@ const Context = struct {
                 return;
             },
             .anchor => {
-                const info = analyzeContent(el.asNode());
+                const has_content = hasVisibleContent(el.asNode());
                 const label = getAnchorLabel(el);
                 const href_raw = el.getAttributeSafe(comptime .wrap("href"));
 
-                if (!info.has_visible and label == null and href_raw == null) return;
+                if (!has_content and label == null and href_raw == null) return;
 
+                const has_block = hasBlockDescendant(el.asNode());
                 const href = if (href_raw) |h| URL.resolve(self.page.call_arena, self.page.base(), h, .{ .encode = true }) catch h else null;
 
-                if (info.has_block) {
+                if (has_block) {
                     try self.renderChildren(el.asNode());
                     if (href) |h| {
                         if (!self.state.last_char_was_newline) try self.writer.writeByte('\n');
@@ -306,12 +307,25 @@ const Context = struct {
                     return;
                 }
 
-                const standalone = isStandaloneAnchor(el);
+                if (isStandaloneAnchor(el)) {
-                if (standalone) {
                     if (!self.state.last_char_was_newline) try self.writer.writeByte('\n');
-                }
                     try self.writer.writeByte('[');
-                if (info.has_visible) {
+                    if (has_content) {
+                        try self.renderChildren(el.asNode());
+                    } else {
+                        try self.writer.writeAll(label orelse "");
+                    }
+                    try self.writer.writeAll("](");
+                    if (href) |h| {
+                        try self.writer.writeAll(h);
+                    }
+                    try self.writer.writeAll(")\n");
+                    self.state.last_char_was_newline = true;
+                    return;
+                }
+
+                try self.writer.writeByte('[');
+                if (has_content) {
                     try self.renderChildren(el.asNode());
                 } else {
                     try self.writer.writeAll(label orelse "");
@@ -321,12 +335,7 @@ const Context = struct {
                     try self.writer.writeAll(h);
                 }
                 try self.writer.writeByte(')');
-                if (standalone) {
-                    try self.writer.writeByte('\n');
-                    self.state.last_char_was_newline = true;
-                } else {
                 self.state.last_char_was_newline = false;
-                }
                 return;
             },
             .input => {
@@ -341,8 +350,12 @@ const Context = struct {
             else => {},
         }
 
+        // --- Render Children ---
         try self.renderChildren(el.asNode());
 
+        // --- Closing Tag Logic ---
+
+        // Suffixes
         switch (tag) {
             .pre => {
                 if (!self.state.last_char_was_newline) {
@@ -355,6 +368,7 @@ const Context = struct {
             .code => {
                 if (self.state.pre_node == null) {
                     try self.writer.writeByte('`');
+                    self.state.in_code = false;
                     self.state.last_char_was_newline = false;
                 }
             },
@@ -397,6 +411,7 @@ const Context = struct {
             else => {},
         }
 
+        // Post-block newlines
         if (tag.isBlock() and !self.state.in_table) {
             try self.ensureNewline();
         }
@@ -439,19 +454,15 @@ const Context = struct {
     }
 
     fn escape(self: *Context, text: []const u8) !void {
-        var start: usize = 0;
+        for (text) |c| {
-        for (text, 0..) |c, i| {
             switch (c) {
                 '\\', '`', '*', '_', '{', '}', '[', ']', '(', ')', '#', '+', '-', '!', '|' => {
-                    if (i > start) try self.writer.writeAll(text[start..i]);
                     try self.writer.writeByte('\\');
                     try self.writer.writeByte(c);
-                    start = i + 1;
                 },
-                else => {},
+                else => try self.writer.writeByte(c),
             }
         }
-        if (start < text.len) try self.writer.writeAll(text[start..]);
     }
 };
 

src/browser/tests/net/xhr.html

@@ -306,3 +306,27 @@
     URL.revokeObjectURL(blobUrl);
   });
 </script>
+
+<script id=xhr_timeout>
+  // timeout property: default is 0
+  const req = new XMLHttpRequest();
+  testing.expectEqual(0, req.timeout);
+
+  // timeout can be set and read back
+  req.timeout = 5000;
+  testing.expectEqual(5000, req.timeout);
+
+  // request with timeout set succeeds normally when server responds in time
+  testing.async(async (restore) => {
+    const event = await new Promise((resolve) => {
+      req.onload = resolve;
+      req.open('GET', 'http://127.0.0.1:9582/xhr');
+      req.send();
+    });
+
+    restore();
+    testing.expectEqual('load', event.type);
+    testing.expectEqual(200, req.status);
+    testing.expectEqual(5000, req.timeout);
+  });
+</script>

src/browser/tests/node/child_nodes.html

@@ -4,7 +4,7 @@
 <div id=empty></div>
 <div id=one><p id=p10></p></div>
 
-<!--<script id=childNodes>
+<script id=childNodes>
   const div = $('#d1');
   const children = div.childNodes;
   testing.expectEqual(true, children instanceof NodeList);
@@ -65,24 +65,24 @@
   testing.expectEqual([], Array.from(empty.values()));
   testing.expectEqual([], Array.from(empty.entries()));
   testing.expectEqual([], Array.from(empty));
-</script> -->
+</script>
 
 <script id=one>
   const one = $('#one').childNodes;
-  // const p10 = $('#p10');
+  const p10 = $('#p10');
-  // testing.expectEqual(1, one.length);
+  testing.expectEqual(1, one.length);
-  // testing.expectEqual(p10, one[0]);
+  testing.expectEqual(p10, one[0]);
-  // testing.expectEqual([0], Array.from(one.keys()));
+  testing.expectEqual([0], Array.from(one.keys()));
-  // testing.expectEqual([p10], Array.from(one.values()));
+  testing.expectEqual([p10], Array.from(one.values()));
-  // testing.expectEqual([[0, p10]], Array.from(one.entries()));
+  testing.expectEqual([[0, p10]], Array.from(one.entries()));
 
-  // testing.expectEqual([p10], Array.from(one));
+  testing.expectEqual([p10], Array.from(one));
   let foreach = [];
   one.forEach((p) => foreach.push(p));
   testing.expectEqual([p10], foreach);
 </script>
 
-<!-- <script id=contains>
+<script id=contains>
   testing.expectEqual(true, document.contains(document));
   testing.expectEqual(true, $('#d1').contains($('#d1')));
   testing.expectEqual(true, document.contains($('#d1')));
@@ -94,4 +94,3 @@
   testing.expectEqual(false, $('#d1').contains($('#empty')));
   testing.expectEqual(false, $('#d1').contains($('#p10')));
 </script>
- -->

src/browser/webapi/Element.zig

@@ -523,31 +523,6 @@ pub fn setDir(self: *Element, value: []const u8, page: *Page) !void {
     return self.setAttributeSafe(comptime .wrap("dir"), .wrap(value), page);
 }
 
-// ARIAMixin - ARIA attribute reflection
-pub fn getAriaAtomic(self: *const Element) ?[]const u8 {
-    return self.getAttributeSafe(comptime .wrap("aria-atomic"));
-}
-
-pub fn setAriaAtomic(self: *Element, value: ?[]const u8, page: *Page) !void {
-    if (value) |v| {
-        try self.setAttributeSafe(comptime .wrap("aria-atomic"), .wrap(v), page);
-    } else {
-        try self.removeAttribute(comptime .wrap("aria-atomic"), page);
-    }
-}
-
-pub fn getAriaLive(self: *const Element) ?[]const u8 {
-    return self.getAttributeSafe(comptime .wrap("aria-live"));
-}
-
-pub fn setAriaLive(self: *Element, value: ?[]const u8, page: *Page) !void {
-    if (value) |v| {
-        try self.setAttributeSafe(comptime .wrap("aria-live"), .wrap(v), page);
-    } else {
-        try self.removeAttribute(comptime .wrap("aria-live"), page);
-    }
-}
-
 pub fn getClassName(self: *const Element) []const u8 {
     return self.getAttributeSafe(comptime .wrap("class")) orelse "";
 }
@@ -1711,8 +1686,6 @@ pub const JsApi = struct {
     pub const localName = bridge.accessor(Element.getLocalName, null, .{});
     pub const id = bridge.accessor(Element.getId, Element.setId, .{});
     pub const slot = bridge.accessor(Element.getSlot, Element.setSlot, .{});
-    pub const ariaAtomic = bridge.accessor(Element.getAriaAtomic, Element.setAriaAtomic, .{});
-    pub const ariaLive = bridge.accessor(Element.getAriaLive, Element.setAriaLive, .{});
     pub const dir = bridge.accessor(Element.getDir, Element.setDir, .{});
     pub const className = bridge.accessor(Element.getClassName, Element.setClassName, .{});
     pub const classList = bridge.accessor(Element.getClassList, Element.setClassList, .{});

src/browser/webapi/IntersectionObserver.zig

@@ -114,9 +114,7 @@ pub fn init(callback: js.Function.Temp, options: ?ObserverInit, page: *Page) !*I
 pub fn deinit(self: *IntersectionObserver, session: *Session) void {
     self._callback.release();
     for (self._pending_entries.items) |entry| {
-        // These were never handed to v8, they do not have a corresponding
+        entry.deinitIfUnused(session);
-        // FinalizerCallback. We 100% own them.
-        entry.deinit(session);
     }
     session.releaseArena(self._arena);
 }
@@ -137,11 +135,14 @@ pub fn observe(self: *IntersectionObserver, target: *Element, page: *Page) !void
         }
     }
 
-    try self._observing.append(self._arena, target);
+    // Register with page if this is our first observation
-    if (self._observing.items.len == 1) {
+    if (self._observing.items.len == 0) {
+        self._rc._refs += 1;
         try page.registerIntersectionObserver(self);
     }
 
+    try self._observing.append(self._arena, target);
+
     // Don't initialize previous state yet - let checkIntersection do it
     // This ensures we get an entry on first observation
 
@@ -165,7 +166,7 @@ pub fn unobserve(self: *IntersectionObserver, target: *Element, page: *Page) voi
             while (j < self._pending_entries.items.len) {
                 if (self._pending_entries.items[j]._target == target) {
                     const entry = self._pending_entries.swapRemove(j);
-                    entry.deinit(page._session);
+                    entry.deinitIfUnused(page._session);
                 } else {
                     j += 1;
                 }
@@ -175,21 +176,25 @@ pub fn unobserve(self: *IntersectionObserver, target: *Element, page: *Page) voi
     }
 
     if (original_length > 0 and self._observing.items.len == 0) {
-        page.unregisterIntersectionObserver(self);
+        self._rc._refs -= 1;
     }
 }
 
 pub fn disconnect(self: *IntersectionObserver, page: *Page) void {
     for (self._pending_entries.items) |entry| {
-        entry.deinit(page._session);
+        entry.deinitIfUnused(page._session);
     }
     self._pending_entries.clearRetainingCapacity();
     self._previous_states.clearRetainingCapacity();
 
-    if (self._observing.items.len > 0) {
+    const observing_count = self._observing.items.len;
-        page.unregisterIntersectionObserver(self);
-    }
     self._observing.clearRetainingCapacity();
+
+    page.unregisterIntersectionObserver(self);
+
+    if (observing_count > 0) {
+        _ = self.releaseRef(page._session);
+    }
 }
 
 pub fn takeRecords(self: *IntersectionObserver, page: *Page) ![]*IntersectionObserverEntry {
@@ -335,6 +340,13 @@ pub const IntersectionObserverEntry = struct {
         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);
     }

src/browser/webapi/MutationObserver.zig

@@ -87,12 +87,8 @@ 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 {
-    for (self._pending_records.items) |record| {
-        // These were never handed to v8, they do not have a corresponding
-        // FinalizerCallback. We 100% own them.
-        record.deinit(session);
-    }
     self._callback.release();
     session.releaseArena(self._arena);
 }
@@ -167,14 +163,16 @@ 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;
+        try page.registerMutationObserver(self);
+    }
+
     try self._observing.append(arena, .{
         .target = target,
         .options = store_options,
     });
-
-    if (self._observing.items.len == 1) {
-        try page.registerMutationObserver(self);
-    }
 }
 
 pub fn disconnect(self: *MutationObserver, page: *Page) void {
@@ -182,11 +180,13 @@ pub fn disconnect(self: *MutationObserver, page: *Page) void {
         _ = record.releaseRef(page._session);
     }
     self._pending_records.clearRetainingCapacity();
-
+    const observing_count = self._observing.items.len;
-    if (self._observing.items.len > 0) {
-        page.unregisterMutationObserver(self);
-    }
     self._observing.clearRetainingCapacity();
+
+    if (observing_count > 0) {
+        _ = self.releaseRef(page._session);
+    }
+    page.unregisterMutationObserver(self);
 }
 
 pub fn takeRecords(self: *MutationObserver, page: *Page) ![]*MutationRecord {

src/browser/webapi/collections/NodeList.zig

@@ -42,8 +42,8 @@ _rc: lp.RC(u32) = .{},
 
 pub fn deinit(self: *NodeList, session: *Session) void {
     switch (self._data) {
-        .child_nodes => |cn| cn.deinit(session),
         .selector_list => |list| list.deinit(session),
+        .child_nodes => |cn| cn.deinit(session),
         else => {},
     }
 }
@@ -92,12 +92,7 @@ pub fn entries(self: *NodeList, page: *Page) !*EntryIterator {
 
 pub fn forEach(self: *NodeList, cb: js.Function, page: *Page) !void {
     var i: i32 = 0;
-
     var it = try self.values(page);
-
-    // the iterator takes a reference against our list
-    defer self.releaseRef(page._session);
-
     while (true) : (i += 1) {
         const next = try it.next(page);
         if (next.done) {

src/browser/webapi/collections/iterator.zig

@@ -26,8 +26,7 @@ pub fn Entry(comptime Inner: type, comptime field: ?[]const u8) type {
     const R = reflect(Inner, field);
 
     return struct {
-        _inner: Inner,
+        inner: Inner,
-        _rc: lp.RC(u8) = .{},
 
         const Self = @This();
 
@@ -39,31 +38,29 @@ pub fn Entry(comptime Inner: type, comptime field: ?[]const u8) type {
         };
 
         pub fn init(inner: Inner, page: *Page) !*Self {
-            const self = try page._factory.create(Self{ ._inner = inner });
+            return page._factory.create(Self{ .inner = inner });
-
-            if (@hasDecl(Inner, "acquireRef")) {
-                self._inner.acquireRef();
-            }
-            return self;
         }
 
         pub fn deinit(self: *Self, session: *Session) void {
-            if (@hasDecl(Inner, "releaseRef")) {
+            _ = self;
-                self._inner.releaseRef(session);
+            _ = session;
-            }
-            session.factory.destroy(self);
         }
 
         pub fn releaseRef(self: *Self, session: *Session) void {
-            self._rc.release(self, session);
+            // Release the reference to the inner type that we acquired
+            if (@hasDecl(Inner, "releaseRef")) {
+                self.inner.releaseRef(session);
+            }
         }
 
         pub fn acquireRef(self: *Self) void {
-            self._rc.acquire();
+            if (@hasDecl(Inner, "acquireRef")) {
+                self.inner.acquireRef();
+            }
         }
 
         pub fn next(self: *Self, page: *Page) if (R.has_error_return) anyerror!Result else Result {
-            const entry = (if (comptime R.has_error_return) try self._inner.next(page) else self._inner.next(page)) orelse {
+            const entry = (if (comptime R.has_error_return) try self.inner.next(page) else self.inner.next(page)) orelse {
                 return .{ .done = true, .value = null };
             };
 

src/browser/webapi/element/Html.zig

@@ -391,14 +391,6 @@ pub fn setLang(self: *HtmlElement, value: []const u8, page: *Page) !void {
     try self.asElement().setAttributeSafe(comptime .wrap("lang"), .wrap(value), page);
 }
 
-pub fn getTitle(self: *HtmlElement) []const u8 {
-    return self.asElement().getAttributeSafe(comptime .wrap("title")) orelse "";
-}
-
-pub fn setTitle(self: *HtmlElement, value: []const u8, page: *Page) !void {
-    try self.asElement().setAttributeSafe(comptime .wrap("title"), .wrap(value), page);
-}
-
 pub fn getAttributeFunction(
     self: *HtmlElement,
     listener_type: GlobalEventHandler,
@@ -1239,7 +1231,6 @@ pub const JsApi = struct {
     pub const hidden = bridge.accessor(HtmlElement.getHidden, HtmlElement.setHidden, .{});
     pub const lang = bridge.accessor(HtmlElement.getLang, HtmlElement.setLang, .{});
     pub const tabIndex = bridge.accessor(HtmlElement.getTabIndex, HtmlElement.setTabIndex, .{});
-    pub const title = bridge.accessor(HtmlElement.getTitle, HtmlElement.setTitle, .{});
 
     pub const onabort = bridge.accessor(HtmlElement.getOnAbort, HtmlElement.setOnAbort, .{});
     pub const onanimationcancel = bridge.accessor(HtmlElement.getOnAnimationCancel, HtmlElement.setOnAnimationCancel, .{});

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

@@ -174,14 +174,6 @@ pub fn setType(self: *Anchor, value: []const u8, page: *Page) !void {
     try self.asElement().setAttributeSafe(comptime .wrap("type"), .wrap(value), page);
 }
 
-pub fn getRel(self: *Anchor) []const u8 {
-    return self.asConstElement().getAttributeSafe(comptime .wrap("rel")) orelse "";
-}
-
-pub fn setRel(self: *Anchor, value: []const u8, page: *Page) !void {
-    try self.asElement().setAttributeSafe(comptime .wrap("rel"), .wrap(value), page);
-}
-
 pub fn getName(self: *const Anchor) []const u8 {
     return self.asConstElement().getAttributeSafe(comptime .wrap("name")) orelse "";
 }
@@ -226,7 +218,6 @@ pub const JsApi = struct {
     pub const pathname = bridge.accessor(Anchor.getPathname, Anchor.setPathname, .{});
     pub const search = bridge.accessor(Anchor.getSearch, Anchor.setSearch, .{});
     pub const hash = bridge.accessor(Anchor.getHash, Anchor.setHash, .{});
-    pub const rel = bridge.accessor(Anchor.getRel, Anchor.setRel, .{});
     pub const @"type" = bridge.accessor(Anchor.getType, Anchor.setType, .{});
     pub const text = bridge.accessor(Anchor.getText, Anchor.setText, .{});
     pub const relList = bridge.accessor(_getRelList, null, .{ .null_as_undefined = true });

src/browser/webapi/net/Fetch.zig

@@ -127,16 +127,16 @@ fn handleBlobUrl(url: []const u8, resolver: js.PromiseResolver, page: *Page) !js
     return resolver.promise();
 }
 
-fn httpStartCallback(response: HttpClient.Response) !void {
+fn httpStartCallback(transfer: *HttpClient.Transfer) !void {
-    const self: *Fetch = @ptrCast(@alignCast(response.ctx));
+    const self: *Fetch = @ptrCast(@alignCast(transfer.ctx));
     if (comptime IS_DEBUG) {
         log.debug(.http, "request start", .{ .url = self._url, .source = "fetch" });
     }
-    self._response._http_response = response;
+    self._response._transfer = transfer;
 }
 
-fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
+fn httpHeaderDoneCallback(transfer: *HttpClient.Transfer) !bool {
-    const self: *Fetch = @ptrCast(@alignCast(response.ctx));
+    const self: *Fetch = @ptrCast(@alignCast(transfer.ctx));
 
     if (self._signal) |signal| {
         if (signal._aborted) {
@@ -145,24 +145,25 @@ fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
     }
 
     const arena = self._response._arena;
-    if (response.contentLength()) |cl| {
+    if (transfer.getContentLength()) |cl| {
         try self._buf.ensureTotalCapacity(arena, cl);
     }
 
     const res = self._response;
+    const header = transfer.response_header.?;
 
     if (comptime IS_DEBUG) {
         log.debug(.http, "request header", .{
             .source = "fetch",
             .url = self._url,
-            .status = response.status(),
+            .status = header.status,
         });
     }
 
-    res._status = response.status().?;
+    res._status = header.status;
-    res._status_text = std.http.Status.phrase(@enumFromInt(response.status().?)) orelse "";
+    res._status_text = std.http.Status.phrase(@enumFromInt(header.status)) orelse "";
-    res._url = try arena.dupeZ(u8, response.url());
+    res._url = try arena.dupeZ(u8, std.mem.span(header.url));
-    res._is_redirected = response.redirectCount().? > 0;
+    res._is_redirected = header.redirect_count > 0;
 
     // Determine response type based on origin comparison
     const page_origin = URL.getOrigin(arena, self._page.url) catch null;
@@ -182,7 +183,7 @@ fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
         res._type = .basic;
     }
 
-    var it = response.headerIterator();
+    var it = transfer.responseHeaderIterator();
     while (it.next()) |hdr| {
         try res._headers.append(hdr.name, hdr.value, self._page);
     }
@@ -190,8 +191,8 @@ fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
     return true;
 }
 
-fn httpDataCallback(response: HttpClient.Response, data: []const u8) !void {
+fn httpDataCallback(transfer: *HttpClient.Transfer, data: []const u8) !void {
-    const self: *Fetch = @ptrCast(@alignCast(response.ctx));
+    const self: *Fetch = @ptrCast(@alignCast(transfer.ctx));
 
     // Check if aborted
     if (self._signal) |signal| {
@@ -206,7 +207,7 @@ fn httpDataCallback(response: HttpClient.Response, data: []const u8) !void {
 fn httpDoneCallback(ctx: *anyopaque) !void {
     const self: *Fetch = @ptrCast(@alignCast(ctx));
     var response = self._response;
-    response._http_response = null;
+    response._transfer = null;
     response._body = self._buf.items;
 
     log.info(.http, "request complete", .{
@@ -229,7 +230,7 @@ fn httpErrorCallback(ctx: *anyopaque, _: anyerror) void {
     const self: *Fetch = @ptrCast(@alignCast(ctx));
 
     var response = self._response;
-    response._http_response = null;
+    response._transfer = null;
     // the response is only passed on v8 on success, if we're here, it's safe to
     // clear this. (defer since `self is in the response's arena).
 
@@ -255,7 +256,7 @@ fn httpShutdownCallback(ctx: *anyopaque) void {
 
     if (self._owns_response) {
         var response = self._response;
-        response._http_response = null;
+        response._transfer = null;
         response.deinit(self._page._session);
         // Do not access `self` after this point: the Fetch struct was
         // allocated from response._arena which has been released.

src/browser/webapi/net/Headers.zig

@@ -86,8 +86,8 @@ pub fn forEach(self: *Headers, cb_: js.Function, js_this_: ?js.Object) !void {
 }
 
 // TODO: do we really need 2 different header structs??
-const http = @import("../../../network/http.zig");
+const net_http = @import("../../../network/http.zig");
-pub fn populateHttpHeader(self: *Headers, allocator: Allocator, http_headers: *http.Headers) !void {
+pub fn populateHttpHeader(self: *Headers, allocator: Allocator, http_headers: *net_http.Headers) !void {
     for (self._list._entries.items) |entry| {
         const merged = try std.mem.concatWithSentinel(allocator, u8, &.{ entry.name.str(), ": ", entry.value.str() }, 0);
         try http_headers.add(merged);

src/browser/webapi/net/Request.zig

@@ -19,7 +19,7 @@
 const std = @import("std");
 
 const js = @import("../../js/js.zig");
-const http = @import("../../../network/http.zig");
+const net_http = @import("../../../network/http.zig");
 
 const URL = @import("../URL.zig");
 const Page = @import("../../Page.zig");
@@ -31,7 +31,7 @@ const Allocator = std.mem.Allocator;
 const Request = @This();
 
 _url: [:0]const u8,
-_method: http.Method,
+_method: net_http.Method,
 _headers: ?*Headers,
 _body: ?[]const u8,
 _arena: Allocator,
@@ -119,14 +119,14 @@ pub fn init(input: Input, opts_: ?InitOpts, page: *Page) !*Request {
     });
 }
 
-fn parseMethod(method: []const u8, page: *Page) !http.Method {
+fn parseMethod(method: []const u8, page: *Page) !net_http.Method {
     if (method.len > "propfind".len) {
         return error.InvalidMethod;
     }
 
     const lower = std.ascii.lowerString(&page.buf, method);
 
-    const method_lookup = std.StaticStringMap(http.Method).initComptime(.{
+    const method_lookup = std.StaticStringMap(net_http.Method).initComptime(.{
         .{ "get", .GET },
         .{ "post", .POST },
         .{ "delete", .DELETE },

src/browser/webapi/net/Response.zig

@@ -48,7 +48,7 @@ _type: Type,
 _status_text: []const u8,
 _url: [:0]const u8,
 _is_redirected: bool,
-_http_response: ?HttpClient.Response = null,
+_transfer: ?*HttpClient.Transfer = null,
 
 const InitOpts = struct {
     status: u16 = 200,
@@ -81,9 +81,9 @@ pub fn init(body_: ?[]const u8, opts_: ?InitOpts, page: *Page) !*Response {
 }
 
 pub fn deinit(self: *Response, session: *Session) void {
-    if (self._http_response) |resp| {
+    if (self._transfer) |transfer| {
-        resp.abort(error.Abort);
+        transfer.abort(error.Abort);
-        self._http_response = null;
+        self._transfer = null;
     }
     session.releaseArena(self._arena);
 }
@@ -191,7 +191,7 @@ pub fn clone(self: *const Response, page: *Page) !*Response {
         ._type = self._type,
         ._is_redirected = self._is_redirected,
         ._headers = try Headers.init(.{ .obj = self._headers }, page),
-        ._http_response = null,
+        ._transfer = null,
     };
     return cloned;
 }

src/browser/webapi/net/XMLHttpRequest.zig

@@ -22,7 +22,7 @@ const js = @import("../../js/js.zig");
 
 const log = @import("../../../log.zig");
 const HttpClient = @import("../../HttpClient.zig");
-const http = @import("../../../network/http.zig");
+const net_http = @import("../../../network/http.zig");
 
 const URL = @import("../../URL.zig");
 const Mime = @import("../../Mime.zig");
@@ -43,11 +43,11 @@ _rc: lp.RC(u8) = .{},
 _page: *Page,
 _proto: *XMLHttpRequestEventTarget,
 _arena: Allocator,
-_http_response: ?HttpClient.Response = null,
+_transfer: ?*HttpClient.Transfer = null,
 _active_request: bool = false,
 
 _url: [:0]const u8 = "",
-_method: http.Method = .GET,
+_method: net_http.Method = .GET,
 _request_headers: *Headers,
 _request_body: ?[]const u8 = null,
 
@@ -63,6 +63,7 @@ _response_type: ResponseType = .text,
 _ready_state: ReadyState = .unsent,
 _on_ready_state_change: ?js.Function.Temp = null,
 _with_credentials: bool = false,
+_timeout: u32 = 0,
 
 const ReadyState = enum(u8) {
     unsent = 0,
@@ -90,19 +91,19 @@ const ResponseType = enum {
 pub fn init(page: *Page) !*XMLHttpRequest {
     const arena = try page.getArena(.{ .debug = "XMLHttpRequest" });
     errdefer page.releaseArena(arena);
-    const self = try page._factory.xhrEventTarget(arena, XMLHttpRequest{
+    const xhr = try page._factory.xhrEventTarget(arena, XMLHttpRequest{
         ._page = page,
         ._arena = arena,
         ._proto = undefined,
         ._request_headers = try Headers.init(null, page),
     });
-    return self;
+    return xhr;
 }
 
 pub fn deinit(self: *XMLHttpRequest, session: *Session) void {
-    if (self._http_response) |resp| {
+    if (self._transfer) |transfer| {
-        resp.abort(error.Abort);
+        transfer.abort(error.Abort);
-        self._http_response = null;
+        self._transfer = null;
     }
 
     if (self._on_ready_state_change) |func| {
@@ -180,13 +181,21 @@ pub fn setWithCredentials(self: *XMLHttpRequest, value: bool) !void {
     self._with_credentials = value;
 }
 
+pub fn getTimeout(self: *const XMLHttpRequest) u32 {
+    return self._timeout;
+}
+
+pub fn setTimeout(self: *XMLHttpRequest, value: u32) void {
+    self._timeout = value;
+}
+
 // TODO: this takes an optional 3 more parameters
 // TODO: url should be a union, as it can be multiple things
 pub fn open(self: *XMLHttpRequest, method_: []const u8, url: [:0]const u8) !void {
     // Abort any in-progress request
-    if (self._http_response) |transfer| {
+    if (self._transfer) |transfer| {
         transfer.abort(error.Abort);
-        self._http_response = null;
+        self._transfer = null;
     }
 
     // Reset internal state
@@ -243,10 +252,7 @@ pub fn send(self: *XMLHttpRequest, body_: ?[]const u8) !void {
         try page.headersForRequest(&headers);
     }
 
-    self.acquireRef();
+    try http_client.request(.{
-    self._active_request = true;
-
-    http_client.request(.{
         .ctx = self,
         .url = self._url,
         .method = self._method,
@@ -256,6 +262,7 @@ pub fn send(self: *XMLHttpRequest, body_: ?[]const u8) !void {
         .cookie_jar = if (cookie_support) &page._session.cookie_jar else null,
         .cookie_origin = page.url,
         .resource_type = .xhr,
+        .timeout_ms = self._timeout,
         .notification = page._session.notification,
         .start_callback = httpStartCallback,
         .header_callback = httpHeaderDoneCallback,
@@ -263,10 +270,9 @@ pub fn send(self: *XMLHttpRequest, body_: ?[]const u8) !void {
         .done_callback = httpDoneCallback,
         .error_callback = httpErrorCallback,
         .shutdown_callback = httpShutdownCallback,
-    }) catch |err| {
+    });
-        self.releaseSelfRef();
+    self.acquireRef();
-        return err;
+    self._active_request = true;
-    };
 }
 
 fn handleBlobUrl(self: *XMLHttpRequest, page: *Page) !void {
@@ -402,32 +408,34 @@ pub fn getResponseXML(self: *XMLHttpRequest, page: *Page) !?*Node.Document {
     };
 }
 
-fn httpStartCallback(response: HttpClient.Response) !void {
+fn httpStartCallback(transfer: *HttpClient.Transfer) !void {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
     if (comptime IS_DEBUG) {
         log.debug(.http, "request start", .{ .method = self._method, .url = self._url, .source = "xhr" });
     }
-    self._http_response = response;
+    self._transfer = transfer;
 }
 
-fn httpHeaderCallback(response: HttpClient.Response, header: http.Header) !void {
+fn httpHeaderCallback(transfer: *HttpClient.Transfer, header: net_http.Header) !void {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
     const joined = try std.fmt.allocPrint(self._arena, "{s}: {s}", .{ header.name, header.value });
     try self._response_headers.append(self._arena, joined);
 }
 
-fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
+fn httpHeaderDoneCallback(transfer: *HttpClient.Transfer) !bool {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
+
+    const header = &transfer.response_header.?;
 
     if (comptime IS_DEBUG) {
         log.debug(.http, "request header", .{
             .source = "xhr",
             .url = self._url,
-            .status = response.status(),
+            .status = header.status,
         });
     }
 
-    if (response.contentType()) |ct| {
+    if (header.contentType()) |ct| {
         self._response_mime = Mime.parse(ct) catch |e| {
             log.info(.http, "invalid content type", .{
                 .content_Type = ct,
@@ -438,18 +446,18 @@ fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
         };
     }
 
-    var it = response.headerIterator();
+    var it = transfer.responseHeaderIterator();
     while (it.next()) |hdr| {
         const joined = try std.fmt.allocPrint(self._arena, "{s}: {s}", .{ hdr.name, hdr.value });
         try self._response_headers.append(self._arena, joined);
     }
 
-    self._response_status = response.status().?;
+    self._response_status = header.status;
-    if (response.contentLength()) |cl| {
+    if (transfer.getContentLength()) |cl| {
         self._response_len = cl;
         try self._response_data.ensureTotalCapacity(self._arena, cl);
     }
-    self._response_url = try self._arena.dupeZ(u8, response.url());
+    self._response_url = try self._arena.dupeZ(u8, std.mem.span(header.url));
 
     const page = self._page;
 
@@ -464,8 +472,8 @@ fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
     return true;
 }
 
-fn httpDataCallback(response: HttpClient.Response, data: []const u8) !void {
+fn httpDataCallback(transfer: *HttpClient.Transfer, data: []const u8) !void {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
     try self._response_data.appendSlice(self._arena, data);
 
     const page = self._page;
@@ -488,7 +496,7 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
 
     // Not that the request is done, the http/client will free the transfer
     // object. It isn't safe to keep it around.
-    self._http_response = null;
+    self._transfer = null;
 
     const page = self._page;
 
@@ -511,23 +519,22 @@ 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.handleError(err);
-    if (self._http_response != null) {
+    if (self._transfer != null) {
-        self._http_response = null;
+        self._transfer = null;
     }
     self.releaseSelfRef();
 }
 
 fn httpShutdownCallback(ctx: *anyopaque) void {
     const self: *XMLHttpRequest = @ptrCast(@alignCast(ctx));
-    self._http_response = null;
+    self._transfer = null;
-    self.releaseSelfRef();
 }
 
 pub fn abort(self: *XMLHttpRequest) void {
     self.handleError(error.Abort);
-    if (self._http_response) |resp| {
+    if (self._transfer) |transfer| {
-        self._http_response = null;
+        self._transfer = null;
-        resp.abort(error.Abort);
+        transfer.abort(error.Abort);
     }
     self.releaseSelfRef();
 }
@@ -542,6 +549,7 @@ fn handleError(self: *XMLHttpRequest, err: anyerror) void {
 }
 fn _handleError(self: *XMLHttpRequest, err: anyerror) !void {
     const is_abort = err == error.Abort;
+    const is_timeout = err == error.OperationTimedout;
 
     const new_state: ReadyState = if (is_abort) .unsent else .done;
     if (new_state != self._ready_state) {
@@ -550,8 +558,12 @@ fn _handleError(self: *XMLHttpRequest, err: anyerror) !void {
         try self.stateChanged(new_state, page);
         if (is_abort) {
             try self._proto.dispatch(.abort, null, page);
+        } else if (is_timeout) {
+            try self._proto.dispatch(.timeout, null, page);
         }
+        if (!is_timeout) {
             try self._proto.dispatch(.err, null, page);
+        }
         try self._proto.dispatch(.load_end, null, page);
     }
 
@@ -577,7 +589,7 @@ fn stateChanged(self: *XMLHttpRequest, state: ReadyState, page: *Page) !void {
     }
 }
 
-fn parseMethod(method: []const u8) !http.Method {
+fn parseMethod(method: []const u8) !net_http.Method {
     if (std.ascii.eqlIgnoreCase(method, "get")) {
         return .GET;
     }
@@ -613,6 +625,7 @@ pub const JsApi = struct {
     pub const DONE = bridge.property(@intFromEnum(XMLHttpRequest.ReadyState.done), .{ .template = true });
 
     pub const onreadystatechange = bridge.accessor(XMLHttpRequest.getOnReadyStateChange, XMLHttpRequest.setOnReadyStateChange, .{});
+    pub const timeout = bridge.accessor(XMLHttpRequest.getTimeout, XMLHttpRequest.setTimeout, .{});
     pub const withCredentials = bridge.accessor(XMLHttpRequest.getWithCredentials, XMLHttpRequest.setWithCredentials, .{ .dom_exception = true });
     pub const open = bridge.function(XMLHttpRequest.open, .{});
     pub const send = bridge.function(XMLHttpRequest.send, .{ .dom_exception = true });

src/cdp/domains/fetch.zig

@@ -23,7 +23,7 @@ const CDP = @import("../CDP.zig");
 const log = @import("../../log.zig");
 
 const HttpClient = @import("../../browser/HttpClient.zig");
-const http = @import("../../network/http.zig");
+const net_http = @import("../../network/http.zig");
 const Notification = @import("../../Notification.zig");
 
 const network = @import("network.zig");
@@ -224,7 +224,7 @@ fn continueRequest(cmd: *CDP.Command) !void {
         url: ?[]const u8 = null,
         method: ?[]const u8 = null,
         postData: ?[]const u8 = null,
-        headers: ?[]const http.Header = null,
+        headers: ?[]const net_http.Header = null,
         interceptResponse: bool = false,
     })) orelse return error.InvalidParams;
 
@@ -249,7 +249,7 @@ fn continueRequest(cmd: *CDP.Command) !void {
         try transfer.updateURL(try arena.dupeZ(u8, url));
     }
     if (params.method) |method| {
-        transfer.req.method = std.meta.stringToEnum(http.Method, method) orelse return error.InvalidParams;
+        transfer.req.method = std.meta.stringToEnum(net_http.Method, method) orelse return error.InvalidParams;
     }
 
     if (params.headers) |headers| {
@@ -326,7 +326,7 @@ fn fulfillRequest(cmd: *CDP.Command) !void {
     const params = (try cmd.params(struct {
         requestId: []const u8, // "INT-{d}"
         responseCode: u16,
-        responseHeaders: ?[]const http.Header = null,
+        responseHeaders: ?[]const net_http.Header = null,
         binaryResponseHeaders: ?[]const u8 = null,
         body: ?[]const u8 = null,
         responsePhrase: ?[]const u8 = null,

src/cdp/domains/page.zig

@@ -139,8 +139,8 @@ fn setLifecycleEventsEnabled(cmd: *CDP.Command) !void {
         try sendPageLifecycle(bc, "load", now, frame_id, loader_id);
 
         const http_client = page._session.browser.http_client;
-        const http_active = http_client.active();
+        const http_active = http_client.active;
-        const total_network_activity = http_active + http_client.intercepted();
+        const total_network_activity = http_active + http_client.intercepted;
         if (page._notified_network_almost_idle.check(total_network_activity <= 2)) {
             try sendPageLifecycle(bc, "networkAlmostIdle", now, frame_id, loader_id);
         }

src/crash_handler.zig

@@ -86,7 +86,7 @@ fn report(reason: []const u8, begin_addr: usize, args: anytype) !void {
     var url_buffer: [4096]u8 = undefined;
     const url = blk: {
         var writer: std.Io.Writer = .fixed(&url_buffer);
-        try writer.print("https://crash.lightpanda.io/c?v={s}&r=", .{lp.build_config.version_encoded});
+        try writer.print("https://crash.lightpanda.io/c?v={s}&r=", .{lp.build_config.version});
         for (reason) |b| {
             switch (b) {
                 'A'...'Z', 'a'...'z', '0'...'9', '-', '.', '_' => try writer.writeByte(b),

src/lightpanda.zig

@@ -18,7 +18,7 @@
 
 const std = @import("std");
 pub const App = @import("App.zig");
-pub const Network = @import("network/Network.zig");
+pub const Network = @import("network/Runtime.zig");
 pub const Server = @import("Server.zig");
 pub const Config = @import("Config.zig");
 pub const URL = @import("browser/URL.zig");
@@ -259,6 +259,9 @@ pub fn RC(comptime T: type) type {
                 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 {

src/log.zig

@@ -39,7 +39,6 @@ pub const Scope = enum {
     telemetry,
     unknown_prop,
     mcp,
-    cache,
 };
 
 const Opts = struct {

src/main.zig

@@ -144,22 +144,11 @@ fn run(allocator: Allocator, main_arena: Allocator) !void {
 
             app.network.run();
         },
-        .mcp => |opts| {
+        .mcp => {
             log.info(.mcp, "starting server", .{});
 
             log.opts.format = .logfmt;
 
-            var cdp_server: ?*lp.Server = null;
-            if (opts.cdp_port) |port| {
-                const address = std.net.Address.parseIp("127.0.0.1", port) catch |err| {
-                    log.fatal(.mcp, "invalid cdp address", .{ .err = err, .port = port });
-                    return;
-                };
-                cdp_server = try lp.Server.init(app, address);
-                try sighandler.on(lp.Server.shutdown, .{cdp_server.?});
-            }
-            defer if (cdp_server) |s| s.deinit();
-
             var worker_thread = try std.Thread.spawn(.{}, mcpThread, .{ allocator, app });
             defer worker_thread.join();
 

src/mcp/tools.zig

@@ -9,72 +9,57 @@ const protocol = @import("protocol.zig");
 const Server = @import("Server.zig");
 const CDPNode = @import("../cdp/Node.zig");
 
-const goto_schema = protocol.minify(
-    \\{
-    \\  "type": "object",
-    \\  "properties": {
-    \\    "url": { "type": "string", "description": "The URL to navigate to, must be a valid URL." },
-    \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
-    \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." }
-    \\  },
-    \\  "required": ["url"]
-    \\}
-);
-
-const url_params_schema = protocol.minify(
-    \\{
-    \\  "type": "object",
-    \\  "properties": {
-    \\    "url": { "type": "string", "description": "Optional URL to navigate to before processing." },
-    \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
-    \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." }
-    \\  }
-    \\}
-);
-
-const evaluate_schema = protocol.minify(
-    \\{
-    \\  "type": "object",
-    \\  "properties": {
-    \\    "script": { "type": "string" },
-    \\    "url": { "type": "string", "description": "Optional URL to navigate to before evaluating." },
-    \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
-    \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." }
-    \\  },
-    \\  "required": ["script"]
-    \\}
-);
-
 pub const tool_list = [_]protocol.Tool{
     .{
         .name = "goto",
         .description = "Navigate to a specified URL and load the page in memory so it can be reused later for info extraction.",
-        .inputSchema = goto_schema,
+        .inputSchema = protocol.minify(
-    },
+            \\{
-    .{
+            \\  "type": "object",
-        .name = "navigate",
+            \\  "properties": {
-        .description = "Alias for goto. Navigate to a specified URL and load the page in memory.",
+            \\    "url": { "type": "string", "description": "The URL to navigate to, must be a valid URL." }
-        .inputSchema = goto_schema,
+            \\  },
+            \\  "required": ["url"]
+            \\}
+        ),
     },
     .{
         .name = "markdown",
         .description = "Get the page content in markdown format. If a url is provided, it navigates to that url first.",
-        .inputSchema = url_params_schema,
+        .inputSchema = protocol.minify(
+            \\{
+            \\  "type": "object",
+            \\  "properties": {
+            \\    "url": { "type": "string", "description": "Optional URL to navigate to before fetching markdown." }
+            \\  }
+            \\}
+        ),
     },
     .{
         .name = "links",
         .description = "Extract all links in the opened page. If a url is provided, it navigates to that url first.",
-        .inputSchema = url_params_schema,
+        .inputSchema = protocol.minify(
+            \\{
+            \\  "type": "object",
+            \\  "properties": {
+            \\    "url": { "type": "string", "description": "Optional URL to navigate to before extracting links." }
+            \\  }
+            \\}
+        ),
     },
     .{
         .name = "evaluate",
         .description = "Evaluate JavaScript in the current page context. If a url is provided, it navigates to that url first.",
-        .inputSchema = evaluate_schema,
+        .inputSchema = protocol.minify(
-    },
+            \\{
-    .{
+            \\  "type": "object",
-        .name = "eval",
+            \\  "properties": {
-        .description = "Alias for evaluate. Evaluate JavaScript in the current page context.",
+            \\    "script": { "type": "string" },
-        .inputSchema = evaluate_schema,
+            \\    "url": { "type": "string", "description": "Optional URL to navigate to before evaluating." }
+            \\  },
+            \\  "required": ["script"]
+            \\}
+        ),
     },
     .{
         .name = "semantic_tree",
@@ -84,8 +69,6 @@ pub const tool_list = [_]protocol.Tool{
             \\  "type": "object",
             \\  "properties": {
             \\    "url": { "type": "string", "description": "Optional URL to navigate to before fetching the semantic tree." },
-            \\    "timeout": { "type": "integer", "description": "Optional timeout in milliseconds. Defaults to 10000." },
-            \\    "waitUntil": { "type": "string", "enum": ["load", "domcontentloaded", "networkidle", "done"], "description": "Optional wait strategy. Defaults to 'done'." },
             \\    "backendNodeId": { "type": "integer", "description": "Optional backend node ID to get the tree for a specific element instead of the document root." },
             \\    "maxDepth": { "type": "integer", "description": "Optional maximum depth of the tree to return. Useful for exploring high-level structure first." }
             \\  }
@@ -108,17 +91,38 @@ pub const tool_list = [_]protocol.Tool{
     .{
         .name = "interactiveElements",
         .description = "Extract interactive elements from the opened page. If a url is provided, it navigates to that url first.",
-        .inputSchema = url_params_schema,
+        .inputSchema = protocol.minify(
+            \\{
+            \\  "type": "object",
+            \\  "properties": {
+            \\    "url": { "type": "string", "description": "Optional URL to navigate to before extracting interactive elements." }
+            \\  }
+            \\}
+        ),
     },
     .{
         .name = "structuredData",
         .description = "Extract structured data (like JSON-LD, OpenGraph, etc) from the opened page. If a url is provided, it navigates to that url first.",
-        .inputSchema = url_params_schema,
+        .inputSchema = protocol.minify(
+            \\{
+            \\  "type": "object",
+            \\  "properties": {
+            \\    "url": { "type": "string", "description": "Optional URL to navigate to before extracting structured data." }
+            \\  }
+            \\}
+        ),
     },
     .{
         .name = "detectForms",
         .description = "Detect all forms on the page and return their structure including fields, types, and required status. If a url is provided, it navigates to that url first.",
-        .inputSchema = url_params_schema,
+        .inputSchema = protocol.minify(
+            \\{
+            \\  "type": "object",
+            \\  "properties": {
+            \\    "url": { "type": "string", "description": "Optional URL to navigate to before detecting forms." }
+            \\  }
+            \\}
+        ),
     },
     .{
         .name = "click",
@@ -185,21 +189,15 @@ pub fn handleList(server: *Server, arena: std.mem.Allocator, req: protocol.Reque
 
 const GotoParams = struct {
     url: [:0]const u8,
-    timeout: ?u32 = null,
-    waitUntil: ?lp.Config.WaitUntil = null,
 };
 
 const UrlParams = struct {
     url: ?[:0]const u8 = null,
-    timeout: ?u32 = null,
-    waitUntil: ?lp.Config.WaitUntil = null,
 };
 
 const EvaluateParams = struct {
     script: [:0]const u8,
     url: ?[:0]const u8 = null,
-    timeout: ?u32 = null,
-    waitUntil: ?lp.Config.WaitUntil = null,
 };
 
 const ToolStreamingText = struct {
@@ -276,7 +274,6 @@ const ToolAction = enum {
     structuredData,
     detectForms,
     evaluate,
-    eval,
     semantic_tree,
     click,
     fill,
@@ -294,7 +291,6 @@ const tool_map = std.StaticStringMap(ToolAction).initComptime(.{
     .{ "structuredData", .structuredData },
     .{ "detectForms", .detectForms },
     .{ "evaluate", .evaluate },
-    .{ "eval", .eval },
     .{ "semantic_tree", .semantic_tree },
     .{ "click", .click },
     .{ "fill", .fill },
@@ -328,7 +324,7 @@ pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Reque
         .interactiveElements => try handleInteractiveElements(server, arena, req.id.?, call_params.arguments),
         .structuredData => try handleStructuredData(server, arena, req.id.?, call_params.arguments),
         .detectForms => try handleDetectForms(server, arena, req.id.?, call_params.arguments),
-        .eval, .evaluate => try handleEvaluate(server, arena, req.id.?, call_params.arguments),
+        .evaluate => try handleEvaluate(server, arena, req.id.?, call_params.arguments),
         .semantic_tree => try handleSemanticTree(server, arena, req.id.?, call_params.arguments),
         .click => try handleClick(server, arena, req.id.?, call_params.arguments),
         .fill => try handleFill(server, arena, req.id.?, call_params.arguments),
@@ -339,7 +335,7 @@ pub fn handleCall(server: *Server, arena: std.mem.Allocator, req: protocol.Reque
 
 fn handleGoto(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgs(GotoParams, arena, arguments, server, id, "goto");
-    try performGoto(server, args.url, id, args.timeout, args.waitUntil);
+    try performGoto(server, args.url, id);
 
     const content = [_]protocol.TextContent([]const u8){.{ .text = "Navigated successfully." }};
     try server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
@@ -347,7 +343,7 @@ fn handleGoto(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arg
 
 fn handleMarkdown(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     const content = [_]protocol.TextContent(ToolStreamingText){.{
         .text = .{ .page = page, .action = .markdown },
@@ -359,7 +355,7 @@ fn handleMarkdown(server: *Server, arena: std.mem.Allocator, id: std.json.Value,
 
 fn handleLinks(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     const content = [_]protocol.TextContent(ToolStreamingText){.{
         .text = .{ .page = page, .action = .links },
@@ -374,11 +370,9 @@ fn handleSemanticTree(server: *Server, arena: std.mem.Allocator, id: std.json.Va
         url: ?[:0]const u8 = null,
         backendNodeId: ?u32 = null,
         maxDepth: ?u32 = null,
-        timeout: ?u32 = null,
-        waitUntil: ?lp.Config.WaitUntil = null,
     };
     const args = try parseArgsOrDefault(TreeParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     const content = [_]protocol.TextContent(ToolStreamingText){.{
         .text = .{
@@ -423,7 +417,7 @@ fn handleNodeDetails(server: *Server, arena: std.mem.Allocator, id: std.json.Val
 
 fn handleInteractiveElements(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     const elements = lp.interactive.collectInteractiveElements(page.document.asNode(), arena, page) catch |err| {
         log.err(.mcp, "elements collection failed", .{ .err = err });
@@ -444,7 +438,7 @@ fn handleInteractiveElements(server: *Server, arena: std.mem.Allocator, id: std.
 
 fn handleStructuredData(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     const data = lp.structured_data.collectStructuredData(page.document.asNode(), arena, page) catch |err| {
         log.err(.mcp, "struct data collection failed", .{ .err = err });
@@ -459,7 +453,7 @@ fn handleStructuredData(server: *Server, arena: std.mem.Allocator, id: std.json.
 
 fn handleDetectForms(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgsOrDefault(UrlParams, arena, arguments, server, id);
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     const forms_data = lp.forms.collectForms(arena, page.document.asNode(), page) catch |err| {
         log.err(.mcp, "form collection failed", .{ .err = err });
@@ -480,7 +474,7 @@ fn handleDetectForms(server: *Server, arena: std.mem.Allocator, id: std.json.Val
 
 fn handleEvaluate(server: *Server, arena: std.mem.Allocator, id: std.json.Value, arguments: ?std.json.Value) !void {
     const args = try parseArgs(EvaluateParams, arena, arguments, server, id, "evaluate");
-    const page = try ensurePage(server, id, args.url, args.timeout, args.waitUntil);
+    const page = try ensurePage(server, id, args.url);
 
     var ls: js.Local.Scope = undefined;
     page.js.localScope(&ls);
@@ -636,9 +630,9 @@ fn handleWaitForSelector(server: *Server, arena: std.mem.Allocator, id: std.json
     return server.sendResult(id, protocol.CallToolResult([]const u8){ .content = &content });
 }
 
-fn ensurePage(server: *Server, id: std.json.Value, url: ?[:0]const u8, timeout: ?u32, waitUntil: ?lp.Config.WaitUntil) !*lp.Page {
+fn ensurePage(server: *Server, id: std.json.Value, url: ?[:0]const u8) !*lp.Page {
     if (url) |u| {
-        try performGoto(server, u, id, timeout, waitUntil);
+        try performGoto(server, u, id);
     }
     return server.session.currentPage() orelse {
         try server.sendError(id, .PageNotLoaded, "Page not loaded");
@@ -674,7 +668,7 @@ fn parseArgs(comptime T: type, arena: std.mem.Allocator, arguments: ?std.json.Va
     };
 }
 
-fn performGoto(server: *Server, url: [:0]const u8, id: std.json.Value, timeout: ?u32, waitUntil: ?lp.Config.WaitUntil) !void {
+fn performGoto(server: *Server, url: [:0]const u8, id: std.json.Value) !void {
     const session = server.session;
     if (session.page != null) {
         session.removePage();
@@ -695,11 +689,8 @@ fn performGoto(server: *Server, url: [:0]const u8, id: std.json.Value, timeout:
         try server.sendError(id, .InternalError, "Failed to start page runner");
         return error.NavigationFailed;
     };
-    runner.wait(.{
+    runner.wait(.{ .ms = 2000 }) catch {
-        .ms = timeout orelse 10000,
+        try server.sendError(id, .InternalError, "Timeout waiting for page load");
-        .until = waitUntil orelse .done,
-    }) catch {
-        try server.sendError(id, .InternalError, "Error waiting for page load");
         return error.NavigationFailed;
     };
 }

src/network/Runtime.zig

@@ -17,7 +17,6 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
-const log = @import("../log.zig");
 const builtin = @import("builtin");
 const net = std.net;
 const posix = std.posix;
@@ -27,15 +26,11 @@ const lp = @import("lightpanda");
 const Config = @import("../Config.zig");
 const libcurl = @import("../sys/libcurl.zig");
 
-const http = @import("http.zig");
+const net_http = @import("http.zig");
 const RobotStore = @import("Robots.zig").RobotStore;
 const WebBotAuth = @import("WebBotAuth.zig");
 
-const Cache = @import("cache/Cache.zig");
+const Runtime = @This();
-const FsCache = @import("cache/FsCache.zig");
-
-const App = @import("../App.zig");
-const Network = @This();
 
 const Listener = struct {
     socket: posix.socket_t,
@@ -50,14 +45,12 @@ const MAX_TICK_CALLBACKS = 16;
 
 allocator: Allocator,
 
-app: *App,
 config: *const Config,
-ca_blob: ?http.Blob,
+ca_blob: ?net_http.Blob,
 robot_store: RobotStore,
 web_bot_auth: ?WebBotAuth,
-cache: ?Cache,
 
-connections: []http.Connection,
+connections: []net_http.Connection,
 available: std.DoublyLinkedList = .{},
 conn_mutex: std.Thread.Mutex = .{},
 
@@ -70,8 +63,8 @@ wakeup_pipe: [2]posix.fd_t = .{ -1, -1 },
 shutdown: std.atomic.Value(bool) = .init(false),
 
 // Multi is a heavy structure that can consume up to 2MB of RAM.
-// Currently, Network is used sparingly, and we only create it on demand.
+// Currently, Runtime is used sparingly, and we only create it on demand.
-// When Network becomes truly shared, it should become a regular field.
+// When Runtime becomes truly shared, it should become a regular field.
 multi: ?*libcurl.CurlM = null,
 submission_mutex: std.Thread.Mutex = .{},
 submission_queue: std.DoublyLinkedList = .{},
@@ -207,7 +200,7 @@ fn globalDeinit() void {
     libcurl.curl_global_cleanup();
 }
 
-pub fn init(allocator: Allocator, app: *App, config: *const Config) !Network {
+pub fn init(allocator: Allocator, config: *const Config) !Runtime {
     globalInit(allocator);
     errdefer globalDeinit();
 
@@ -220,18 +213,18 @@ pub fn init(allocator: Allocator, app: *App, config: *const Config) !Network {
     @memset(pollfds, .{ .fd = -1, .events = 0, .revents = 0 });
     pollfds[0] = .{ .fd = pipe[0], .events = posix.POLL.IN, .revents = 0 };
 
-    var ca_blob: ?http.Blob = null;
+    var ca_blob: ?net_http.Blob = null;
     if (config.tlsVerifyHost()) {
         ca_blob = try loadCerts(allocator);
     }
 
     const count: usize = config.httpMaxConcurrent();
-    const connections = try allocator.alloc(http.Connection, count);
+    const connections = try allocator.alloc(net_http.Connection, count);
     errdefer allocator.free(connections);
 
     var available: std.DoublyLinkedList = .{};
     for (0..count) |i| {
-        connections[i] = try http.Connection.init(ca_blob, config);
+        connections[i] = try net_http.Connection.init(ca_blob, config);
         available.append(&connections[i].node);
     }
 
@@ -240,22 +233,6 @@ pub fn init(allocator: Allocator, app: *App, config: *const Config) !Network {
     else
         null;
 
-    const cache = if (config.httpCacheDir()) |cache_dir_path|
-        Cache{
-            .kind = .{
-                .fs = FsCache.init(cache_dir_path) catch |e| {
-                    log.err(.cache, "failed to init", .{
-                        .kind = "FsCache",
-                        .path = cache_dir_path,
-                        .err = e,
-                    });
-                    return e;
-                },
-            },
-        }
-    else
-        null;
-
     return .{
         .allocator = allocator,
         .config = config,
@@ -267,14 +244,12 @@ pub fn init(allocator: Allocator, app: *App, config: *const Config) !Network {
         .available = available,
         .connections = connections,
 
-        .app = app,
         .robot_store = RobotStore.init(allocator),
         .web_bot_auth = web_bot_auth,
-        .cache = cache,
     };
 }
 
-pub fn deinit(self: *Network) void {
+pub fn deinit(self: *Runtime) void {
     if (self.multi) |multi| {
         libcurl.curl_multi_cleanup(multi) catch {};
     }
@@ -303,13 +278,11 @@ pub fn deinit(self: *Network) void {
         wba.deinit(self.allocator);
     }
 
-    if (self.cache) |*cache| cache.deinit();
-
     globalDeinit();
 }
 
 pub fn bind(
-    self: *Network,
+    self: *Runtime,
     address: net.Address,
     ctx: *anyopaque,
     on_accept: *const fn (ctx: *anyopaque, socket: posix.socket_t) void,
@@ -340,7 +313,7 @@ pub fn bind(
     };
 }
 
-pub fn onTick(self: *Network, ctx: *anyopaque, callback: *const fn (*anyopaque) void) void {
+pub fn onTick(self: *Runtime, ctx: *anyopaque, callback: *const fn (*anyopaque) void) void {
     self.callbacks_mutex.lock();
     defer self.callbacks_mutex.unlock();
 
@@ -355,7 +328,7 @@ pub fn onTick(self: *Network, ctx: *anyopaque, callback: *const fn (*anyopaque)
     self.wakeupPoll();
 }
 
-pub fn fireTicks(self: *Network) void {
+pub fn fireTicks(self: *Runtime) void {
     self.callbacks_mutex.lock();
     defer self.callbacks_mutex.unlock();
 
@@ -364,7 +337,7 @@ pub fn fireTicks(self: *Network) void {
     }
 }
 
-pub fn run(self: *Network) void {
+pub fn run(self: *Runtime) void {
     var drain_buf: [64]u8 = undefined;
     var running_handles: c_int = 0;
 
@@ -455,18 +428,18 @@ pub fn run(self: *Network) void {
     }
 }
 
-pub fn submitRequest(self: *Network, conn: *http.Connection) void {
+pub fn submitRequest(self: *Runtime, conn: *net_http.Connection) void {
     self.submission_mutex.lock();
     self.submission_queue.append(&conn.node);
     self.submission_mutex.unlock();
     self.wakeupPoll();
 }
 
-fn wakeupPoll(self: *Network) void {
+fn wakeupPoll(self: *Runtime) void {
     _ = posix.write(self.wakeup_pipe[1], &.{1}) catch {};
 }
 
-fn drainQueue(self: *Network) void {
+fn drainQueue(self: *Runtime) void {
     self.submission_mutex.lock();
     defer self.submission_mutex.unlock();
 
@@ -482,7 +455,7 @@ fn drainQueue(self: *Network) void {
     };
 
     while (self.submission_queue.popFirst()) |node| {
-        const conn: *http.Connection = @fieldParentPtr("node", node);
+        const conn: *net_http.Connection = @fieldParentPtr("node", node);
         conn.setPrivate(conn) catch |err| {
             lp.log.err(.app, "curl set private", .{ .err = err });
             self.releaseConnection(conn);
@@ -495,12 +468,12 @@ fn drainQueue(self: *Network) void {
     }
 }
 
-pub fn stop(self: *Network) void {
+pub fn stop(self: *Runtime) void {
     self.shutdown.store(true, .release);
     self.wakeupPoll();
 }
 
-fn acceptConnections(self: *Network) void {
+fn acceptConnections(self: *Runtime) void {
     if (self.shutdown.load(.acquire)) {
         return;
     }
@@ -530,7 +503,7 @@ fn acceptConnections(self: *Network) void {
     }
 }
 
-fn preparePollFds(self: *Network, multi: *libcurl.CurlM) void {
+fn preparePollFds(self: *Runtime, multi: *libcurl.CurlM) void {
     const curl_fds = self.pollfds[PSEUDO_POLLFDS..];
     @memset(curl_fds, .{ .fd = -1, .events = 0, .revents = 0 });
 
@@ -541,14 +514,14 @@ fn preparePollFds(self: *Network, multi: *libcurl.CurlM) void {
     };
 }
 
-fn getCurlTimeout(self: *Network) i32 {
+fn getCurlTimeout(self: *Runtime) i32 {
     const multi = self.multi orelse return -1;
     var timeout_ms: c_long = -1;
     libcurl.curl_multi_timeout(multi, &timeout_ms) catch return -1;
     return @intCast(@min(timeout_ms, std.math.maxInt(i32)));
 }
 
-fn processCompletions(self: *Network, multi: *libcurl.CurlM) void {
+fn processCompletions(self: *Runtime, multi: *libcurl.CurlM) void {
     var msgs_in_queue: c_int = 0;
     while (libcurl.curl_multi_info_read(multi, &msgs_in_queue)) |msg| {
         switch (msg.data) {
@@ -564,7 +537,7 @@ fn processCompletions(self: *Network, multi: *libcurl.CurlM) void {
         var ptr: *anyopaque = undefined;
         libcurl.curl_easy_getinfo(easy, .private, &ptr) catch
             lp.assert(false, "curl getinfo private", .{});
-        const conn: *http.Connection = @ptrCast(@alignCast(ptr));
+        const conn: *net_http.Connection = @ptrCast(@alignCast(ptr));
 
         libcurl.curl_multi_remove_handle(multi, easy) catch {};
         self.releaseConnection(conn);
@@ -583,7 +556,7 @@ comptime {
     }
 }
 
-pub fn getConnection(self: *Network) ?*http.Connection {
+pub fn getConnection(self: *Runtime) ?*net_http.Connection {
     self.conn_mutex.lock();
     defer self.conn_mutex.unlock();
 
@@ -591,7 +564,7 @@ pub fn getConnection(self: *Network) ?*http.Connection {
     return @fieldParentPtr("node", node);
 }
 
-pub fn releaseConnection(self: *Network, conn: *http.Connection) void {
+pub fn releaseConnection(self: *Runtime, conn: *net_http.Connection) void {
     conn.reset(self.config, self.ca_blob) catch |err| {
         lp.assert(false, "couldn't reset curl easy", .{ .err = err });
     };
@@ -602,8 +575,8 @@ pub fn releaseConnection(self: *Network, conn: *http.Connection) void {
     self.available.append(&conn.node);
 }
 
-pub fn newConnection(self: *Network) !http.Connection {
+pub fn newConnection(self: *Runtime) !net_http.Connection {
-    return http.Connection.init(self.ca_blob, self.config);
+    return net_http.Connection.init(self.ca_blob, self.config);
 }
 
 // Wraps lines @ 64 columns. A PEM is basically a base64 encoded DER (which is

src/network/cache/Cache.zig

@@ -1,213 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-const Http = @import("../http.zig");
-const FsCache = @import("FsCache.zig");
-
-/// A browser-wide cache for resources across the network.
-/// This mostly conforms to RFC9111 with regards to caching behavior.
-pub const Cache = @This();
-
-kind: union(enum) {
-    fs: FsCache,
-},
-
-pub fn deinit(self: *Cache) void {
-    return switch (self.kind) {
-        inline else => |*c| c.deinit(),
-    };
-}
-
-pub fn get(self: *Cache, arena: std.mem.Allocator, req: CacheRequest) ?CachedResponse {
-    return switch (self.kind) {
-        inline else => |*c| c.get(arena, req),
-    };
-}
-
-pub fn put(self: *Cache, metadata: CachedMetadata, body: []const u8) !void {
-    return switch (self.kind) {
-        inline else => |*c| c.put(metadata, body),
-    };
-}
-
-pub const CacheControl = struct {
-    max_age: u64,
-
-    pub fn parse(value: []const u8) ?CacheControl {
-        var cc: CacheControl = .{ .max_age = undefined };
-
-        var max_age_set = false;
-        var max_s_age_set = false;
-        var is_public = false;
-
-        var iter = std.mem.splitScalar(u8, value, ',');
-        while (iter.next()) |part| {
-            const directive = std.mem.trim(u8, part, &std.ascii.whitespace);
-            if (std.ascii.eqlIgnoreCase(directive, "no-store")) {
-                return null;
-            } else if (std.ascii.eqlIgnoreCase(directive, "no-cache")) {
-                return null;
-            } else if (std.ascii.eqlIgnoreCase(directive, "public")) {
-                is_public = true;
-            } else if (std.ascii.startsWithIgnoreCase(directive, "max-age=")) {
-                if (!max_s_age_set) {
-                    if (std.fmt.parseInt(u64, directive[8..], 10) catch null) |max_age| {
-                        cc.max_age = max_age;
-                        max_age_set = true;
-                    }
-                }
-            } else if (std.ascii.startsWithIgnoreCase(directive, "s-maxage=")) {
-                if (std.fmt.parseInt(u64, directive[9..], 10) catch null) |max_age| {
-                    cc.max_age = max_age;
-                    max_age_set = true;
-                    max_s_age_set = true;
-                }
-            }
-        }
-
-        if (!max_age_set) return null;
-        if (!is_public) return null;
-        if (cc.max_age == 0) return null;
-
-        return cc;
-    }
-};
-
-pub const CachedMetadata = struct {
-    url: [:0]const u8,
-    content_type: []const u8,
-
-    status: u16,
-    stored_at: i64,
-    age_at_store: u64,
-
-    cache_control: CacheControl,
-    /// Response Headers
-    headers: []const Http.Header,
-
-    /// These are Request Headers used by Vary.
-    vary_headers: []const Http.Header,
-
-    pub fn format(self: CachedMetadata, writer: *std.Io.Writer) !void {
-        try writer.print("url={s} | status={d} | content_type={s} | max_age={d} | vary=[", .{
-            self.url,
-            self.status,
-            self.content_type,
-            self.cache_control.max_age,
-        });
-
-        // Logging all headers gets pretty verbose...
-        // so we just log the Vary ones that matter for caching.
-
-        if (self.vary_headers.len > 0) {
-            for (self.vary_headers, 0..) |hdr, i| {
-                if (i > 0) try writer.print(", ", .{});
-                try writer.print("{s}: {s}", .{ hdr.name, hdr.value });
-            }
-        }
-        try writer.print("]", .{});
-    }
-};
-
-pub const CacheRequest = struct {
-    url: []const u8,
-    timestamp: i64,
-    request_headers: []const Http.Header,
-};
-
-pub const CachedData = union(enum) {
-    buffer: []const u8,
-    file: struct {
-        file: std.fs.File,
-        offset: usize,
-        len: usize,
-    },
-
-    pub fn format(self: CachedData, writer: *std.Io.Writer) !void {
-        switch (self) {
-            .buffer => |buf| try writer.print("buffer({d} bytes)", .{buf.len}),
-            .file => |f| try writer.print("file(offset={d}, len={d} bytes)", .{ f.offset, f.len }),
-        }
-    }
-};
-
-pub const CachedResponse = struct {
-    metadata: CachedMetadata,
-    data: CachedData,
-
-    pub fn format(self: *const CachedResponse, writer: *std.Io.Writer) !void {
-        try writer.print("metadata=(", .{});
-        try self.metadata.format(writer);
-        try writer.print("), data=", .{});
-        try self.data.format(writer);
-    }
-};
-
-pub fn tryCache(
-    arena: std.mem.Allocator,
-    timestamp: i64,
-    url: [:0]const u8,
-    status: u16,
-    content_type: ?[]const u8,
-    cache_control: ?[]const u8,
-    vary: ?[]const u8,
-    age: ?[]const u8,
-    has_set_cookie: bool,
-    has_authorization: bool,
-) !?CachedMetadata {
-    if (status != 200) {
-        log.debug(.cache, "no store", .{ .url = url, .code = status, .reason = "status" });
-        return null;
-    }
-    if (has_set_cookie) {
-        log.debug(.cache, "no store", .{ .url = url, .reason = "has_cookies" });
-        return null;
-    }
-    if (has_authorization) {
-        log.debug(.cache, "no store", .{ .url = url, .reason = "has_authorization" });
-        return null;
-    }
-    if (vary) |v| if (std.mem.eql(u8, v, "*")) {
-        log.debug(.cache, "no store", .{ .url = url, .vary = v, .reason = "vary" });
-        return null;
-    };
-    const cc = blk: {
-        if (cache_control == null) {
-            log.debug(.cache, "no store", .{ .url = url, .reason = "no cache control" });
-            return null;
-        }
-        if (CacheControl.parse(cache_control.?)) |cc| {
-            break :blk cc;
-        }
-        log.debug(.cache, "no store", .{ .url = url, .cache_control = cache_control.?, .reason = "cache control" });
-        return null;
-    };
-
-    return .{
-        .url = try arena.dupeZ(u8, url),
-        .content_type = if (content_type) |ct| try arena.dupe(u8, ct) else "application/octet-stream",
-        .status = status,
-        .stored_at = timestamp,
-        .age_at_store = if (age) |a| std.fmt.parseInt(u64, a, 10) catch 0 else 0,
-        .cache_control = cc,
-        .headers = &.{},
-        .vary_headers = &.{},
-    };
-}

src/network/cache/FsCache.zig

@@ -1,612 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-const Cache = @import("Cache.zig");
-const Http = @import("../http.zig");
-const CacheRequest = Cache.CacheRequest;
-const CachedMetadata = Cache.CachedMetadata;
-const CachedResponse = Cache.CachedResponse;
-
-const CACHE_VERSION: usize = 1;
-const LOCK_STRIPES = 16;
-comptime {
-    std.debug.assert(std.math.isPowerOfTwo(LOCK_STRIPES));
-}
-
-pub const FsCache = @This();
-
-dir: std.fs.Dir,
-locks: [LOCK_STRIPES]std.Thread.Mutex = .{std.Thread.Mutex{}} ** LOCK_STRIPES,
-
-const CacheMetadataJson = struct {
-    version: usize,
-    metadata: CachedMetadata,
-};
-
-fn getLockPtr(self: *FsCache, key: *const [HASHED_KEY_LEN]u8) *std.Thread.Mutex {
-    const lock_idx = std.hash.Wyhash.hash(0, key[0..]) & (LOCK_STRIPES - 1);
-    return &self.locks[lock_idx];
-}
-
-const BODY_LEN_HEADER_LEN = 8;
-const HASHED_KEY_LEN = 64;
-const HASHED_PATH_LEN = HASHED_KEY_LEN + 6;
-const HASHED_TMP_PATH_LEN = HASHED_PATH_LEN + 4;
-
-fn hashKey(key: []const u8) [HASHED_KEY_LEN]u8 {
-    var digest: [std.crypto.hash.sha2.Sha256.digest_length]u8 = undefined;
-    std.crypto.hash.sha2.Sha256.hash(key, &digest, .{});
-    var hex: [HASHED_KEY_LEN]u8 = undefined;
-    _ = std.fmt.bufPrint(&hex, "{s}", .{std.fmt.bytesToHex(&digest, .lower)}) catch unreachable;
-    return hex;
-}
-
-fn cachePath(hashed_key: *const [HASHED_KEY_LEN]u8) [HASHED_PATH_LEN]u8 {
-    var path: [HASHED_PATH_LEN]u8 = undefined;
-    _ = std.fmt.bufPrint(&path, "{s}.cache", .{hashed_key}) catch unreachable;
-    return path;
-}
-
-fn cacheTmpPath(hashed_key: *const [HASHED_KEY_LEN]u8) [HASHED_TMP_PATH_LEN]u8 {
-    var path: [HASHED_TMP_PATH_LEN]u8 = undefined;
-    _ = std.fmt.bufPrint(&path, "{s}.cache.tmp", .{hashed_key}) catch unreachable;
-    return path;
-}
-
-pub fn init(path: []const u8) !FsCache {
-    const cwd = std.fs.cwd();
-
-    cwd.makeDir(path) catch |err| switch (err) {
-        error.PathAlreadyExists => {},
-        else => return err,
-    };
-
-    const dir = try cwd.openDir(path, .{ .iterate = true });
-    return .{ .dir = dir };
-}
-
-pub fn deinit(self: *FsCache) void {
-    self.dir.close();
-}
-
-pub fn get(self: *FsCache, arena: std.mem.Allocator, req: CacheRequest) ?Cache.CachedResponse {
-    const hashed_key = hashKey(req.url);
-    const cache_p = cachePath(&hashed_key);
-
-    const lock = self.getLockPtr(&hashed_key);
-    lock.lock();
-    defer lock.unlock();
-
-    const file = self.dir.openFile(&cache_p, .{ .mode = .read_only }) catch |e| {
-        switch (e) {
-            std.fs.File.OpenError.FileNotFound => {
-                log.debug(.cache, "miss", .{ .url = req.url, .hash = &hashed_key, .reason = "missing" });
-            },
-            else => |err| {
-                log.warn(.cache, "open file err", .{ .url = req.url, .err = err });
-            },
-        }
-        return null;
-    };
-
-    var cleanup = false;
-    defer if (cleanup) {
-        file.close();
-        self.dir.deleteFile(&cache_p) catch |e| {
-            log.err(.cache, "clean fail", .{ .url = req.url, .file = &cache_p, .err = e });
-        };
-    };
-
-    var file_buf: [1024]u8 = undefined;
-    var len_buf: [BODY_LEN_HEADER_LEN]u8 = undefined;
-
-    var file_reader = file.reader(&file_buf);
-    const file_reader_iface = &file_reader.interface;
-
-    file_reader_iface.readSliceAll(&len_buf) catch |e| {
-        log.warn(.cache, "read header", .{ .url = req.url, .err = e });
-        cleanup = true;
-        return null;
-    };
-    const body_len = std.mem.readInt(u64, &len_buf, .little);
-
-    // Now we read metadata.
-    file_reader.seekTo(body_len + BODY_LEN_HEADER_LEN) catch |e| {
-        log.warn(.cache, "seek metadata", .{ .url = req.url, .err = e });
-        cleanup = true;
-        return null;
-    };
-
-    var json_reader = std.json.Reader.init(arena, file_reader_iface);
-    const cache_file: CacheMetadataJson = std.json.parseFromTokenSourceLeaky(
-        CacheMetadataJson,
-        arena,
-        &json_reader,
-        .{ .allocate = .alloc_always },
-    ) catch |e| {
-        // Warn because malformed metadata can be a deeper symptom.
-        log.warn(.cache, "miss", .{ .url = req.url, .err = e, .reason = "malformed metadata" });
-        cleanup = true;
-        return null;
-    };
-
-    if (cache_file.version != CACHE_VERSION) {
-        log.debug(.cache, "miss", .{
-            .url = req.url,
-            .reason = "version mismatch",
-            .expected = CACHE_VERSION,
-            .got = cache_file.version,
-        });
-        cleanup = true;
-        return null;
-    }
-
-    const metadata = cache_file.metadata;
-
-    // Check entry expiration.
-    const now = req.timestamp;
-    const age = (now - metadata.stored_at) + @as(i64, @intCast(metadata.age_at_store));
-    if (age < 0 or @as(u64, @intCast(age)) >= metadata.cache_control.max_age) {
-        log.debug(.cache, "miss", .{ .url = req.url, .reason = "expired" });
-        cleanup = true;
-        return null;
-    }
-
-    // If we have Vary headers, ensure they are present & matching.
-    for (metadata.vary_headers) |vary_hdr| {
-        const name = vary_hdr.name;
-        const value = vary_hdr.value;
-
-        const incoming = for (req.request_headers) |h| {
-            if (std.ascii.eqlIgnoreCase(h.name, name)) break h.value;
-        } else "";
-
-        if (!std.ascii.eqlIgnoreCase(value, incoming)) {
-            log.debug(.cache, "miss", .{
-                .url = req.url,
-                .reason = "vary mismatch",
-                .header = name,
-                .expected = value,
-                .got = incoming,
-            });
-            return null;
-        }
-    }
-
-    // On the case of a hash collision.
-    if (!std.ascii.eqlIgnoreCase(metadata.url, req.url)) {
-        log.warn(.cache, "collision", .{ .url = req.url, .expected = metadata.url, .got = req.url });
-        cleanup = true;
-        return null;
-    }
-
-    log.debug(.cache, "hit", .{ .url = req.url, .hash = &hashed_key });
-
-    return .{
-        .metadata = metadata,
-        .data = .{
-            .file = .{
-                .file = file,
-                .offset = BODY_LEN_HEADER_LEN,
-                .len = body_len,
-            },
-        },
-    };
-}
-
-pub fn put(self: *FsCache, meta: CachedMetadata, body: []const u8) !void {
-    const hashed_key = hashKey(meta.url);
-    const cache_p = cachePath(&hashed_key);
-    const cache_tmp_p = cacheTmpPath(&hashed_key);
-
-    const lock = self.getLockPtr(&hashed_key);
-    lock.lock();
-    defer lock.unlock();
-
-    const file = self.dir.createFile(&cache_tmp_p, .{ .truncate = true }) catch |e| {
-        log.err(.cache, "create file", .{ .url = meta.url, .file = &cache_tmp_p, .err = e });
-        return e;
-    };
-    defer file.close();
-
-    var writer_buf: [1024]u8 = undefined;
-    var file_writer = file.writer(&writer_buf);
-    var file_writer_iface = &file_writer.interface;
-
-    var len_buf: [8]u8 = undefined;
-    std.mem.writeInt(u64, &len_buf, body.len, .little);
-
-    file_writer_iface.writeAll(&len_buf) catch |e| {
-        log.err(.cache, "write body len", .{ .url = meta.url, .err = e });
-        return e;
-    };
-    file_writer_iface.writeAll(body) catch |e| {
-        log.err(.cache, "write body", .{ .url = meta.url, .err = e });
-        return e;
-    };
-    std.json.Stringify.value(
-        CacheMetadataJson{ .version = CACHE_VERSION, .metadata = meta },
-        .{ .whitespace = .minified },
-        file_writer_iface,
-    ) catch |e| {
-        log.err(.cache, "write metadata", .{ .url = meta.url, .err = e });
-        return e;
-    };
-    file_writer_iface.flush() catch |e| {
-        log.err(.cache, "flush", .{ .url = meta.url, .err = e });
-        return e;
-    };
-    self.dir.rename(&cache_tmp_p, &cache_p) catch |e| {
-        log.err(.cache, "rename", .{ .url = meta.url, .from = &cache_tmp_p, .to = &cache_p, .err = e });
-        return e;
-    };
-
-    log.debug(.cache, "put", .{ .url = meta.url, .hash = &hashed_key, .body_len = body.len });
-}
-
-const testing = std.testing;
-
-fn setupCache() !struct { tmp: testing.TmpDir, cache: Cache } {
-    var tmp = testing.tmpDir(.{});
-    errdefer tmp.cleanup();
-
-    const path = try tmp.dir.realpathAlloc(testing.allocator, ".");
-    defer testing.allocator.free(path);
-
-    return .{
-        .tmp = tmp,
-        .cache = Cache{ .kind = .{ .fs = try FsCache.init(path) } },
-    };
-}
-
-test "FsCache: basic put and get" {
-    var setup = try setupCache();
-    defer {
-        setup.cache.deinit();
-        setup.tmp.cleanup();
-    }
-
-    const cache = &setup.cache;
-
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-
-    const now = std.time.timestamp();
-    const meta = CachedMetadata{
-        .url = "https://example.com",
-        .content_type = "text/html",
-        .status = 200,
-        .stored_at = now,
-        .age_at_store = 0,
-        .cache_control = .{ .max_age = 600 },
-        .headers = &.{},
-        .vary_headers = &.{},
-    };
-
-    const body = "hello world";
-    try cache.put(meta, body);
-
-    const result = cache.get(
-        arena.allocator(),
-        .{
-            .url = "https://example.com",
-            .timestamp = now,
-            .request_headers = &.{},
-        },
-    ) orelse return error.CacheMiss;
-    const f = result.data.file;
-    const file = f.file;
-    defer file.close();
-
-    var buf: [64]u8 = undefined;
-    var file_reader = file.reader(&buf);
-    try file_reader.seekTo(f.offset);
-
-    const read_buf = try file_reader.interface.readAlloc(testing.allocator, f.len);
-    defer testing.allocator.free(read_buf);
-    try testing.expectEqualStrings(body, read_buf);
-}
-
-test "FsCache: get expiration" {
-    var setup = try setupCache();
-    defer {
-        setup.cache.deinit();
-        setup.tmp.cleanup();
-    }
-
-    const cache = &setup.cache;
-
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-
-    const now = 5000;
-    const max_age = 1000;
-
-    const meta = CachedMetadata{
-        .url = "https://example.com",
-        .content_type = "text/html",
-        .status = 200,
-        .stored_at = now,
-        .age_at_store = 900,
-        .cache_control = .{ .max_age = max_age },
-        .headers = &.{},
-        .vary_headers = &.{},
-    };
-
-    const body = "hello world";
-    try cache.put(meta, body);
-
-    const result = cache.get(
-        arena.allocator(),
-        .{
-            .url = "https://example.com",
-            .timestamp = now + 50,
-            .request_headers = &.{},
-        },
-    ) orelse return error.CacheMiss;
-    result.data.file.file.close();
-
-    try testing.expectEqual(null, cache.get(
-        arena.allocator(),
-        .{
-            .url = "https://example.com",
-            .timestamp = now + 200,
-            .request_headers = &.{},
-        },
-    ));
-
-    try testing.expectEqual(null, cache.get(
-        arena.allocator(),
-        .{
-            .url = "https://example.com",
-            .timestamp = now,
-            .request_headers = &.{},
-        },
-    ));
-}
-
-test "FsCache: put override" {
-    var setup = try setupCache();
-    defer {
-        setup.cache.deinit();
-        setup.tmp.cleanup();
-    }
-
-    const cache = &setup.cache;
-
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-
-    {
-        const now = 5000;
-        const max_age = 1000;
-
-        const meta = CachedMetadata{
-            .url = "https://example.com",
-            .content_type = "text/html",
-            .status = 200,
-            .stored_at = now,
-            .age_at_store = 900,
-            .cache_control = .{ .max_age = max_age },
-            .headers = &.{},
-            .vary_headers = &.{},
-        };
-
-        const body = "hello world";
-        try cache.put(meta, body);
-
-        const result = cache.get(
-            arena.allocator(),
-            .{
-                .url = "https://example.com",
-                .timestamp = now,
-                .request_headers = &.{},
-            },
-        ) orelse return error.CacheMiss;
-        const f = result.data.file;
-        const file = f.file;
-        defer file.close();
-
-        var buf: [64]u8 = undefined;
-        var file_reader = file.reader(&buf);
-        try file_reader.seekTo(f.offset);
-
-        const read_buf = try file_reader.interface.readAlloc(testing.allocator, f.len);
-        defer testing.allocator.free(read_buf);
-
-        try testing.expectEqualStrings(body, read_buf);
-    }
-
-    {
-        const now = 10000;
-        const max_age = 2000;
-
-        const meta = CachedMetadata{
-            .url = "https://example.com",
-            .content_type = "text/html",
-            .status = 200,
-            .stored_at = now,
-            .age_at_store = 0,
-            .cache_control = .{ .max_age = max_age },
-            .headers = &.{},
-            .vary_headers = &.{},
-        };
-
-        const body = "goodbye world";
-        try cache.put(meta, body);
-
-        const result = cache.get(
-            arena.allocator(),
-            .{
-                .url = "https://example.com",
-                .timestamp = now,
-                .request_headers = &.{},
-            },
-        ) orelse return error.CacheMiss;
-        const f = result.data.file;
-        const file = f.file;
-        defer file.close();
-
-        var buf: [64]u8 = undefined;
-        var file_reader = file.reader(&buf);
-        try file_reader.seekTo(f.offset);
-
-        const read_buf = try file_reader.interface.readAlloc(testing.allocator, f.len);
-        defer testing.allocator.free(read_buf);
-
-        try testing.expectEqualStrings(body, read_buf);
-    }
-}
-
-test "FsCache: garbage file" {
-    var setup = try setupCache();
-    defer {
-        setup.cache.deinit();
-        setup.tmp.cleanup();
-    }
-
-    const hashed_key = hashKey("https://example.com");
-    const cache_p = cachePath(&hashed_key);
-    const file = try setup.cache.kind.fs.dir.createFile(&cache_p, .{});
-    try file.writeAll("this is not a valid cache file !@#$%");
-    file.close();
-
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-
-    try testing.expectEqual(
-        null,
-        setup.cache.get(arena.allocator(), .{
-            .url = "https://example.com",
-            .timestamp = 5000,
-            .request_headers = &.{},
-        }),
-    );
-}
-
-test "FsCache: vary hit and miss" {
-    var setup = try setupCache();
-    defer {
-        setup.cache.deinit();
-        setup.tmp.cleanup();
-    }
-
-    const cache = &setup.cache;
-
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-
-    const now = std.time.timestamp();
-    const meta = CachedMetadata{
-        .url = "https://example.com",
-        .content_type = "text/html",
-        .status = 200,
-        .stored_at = now,
-        .age_at_store = 0,
-        .cache_control = .{ .max_age = 600 },
-        .headers = &.{},
-        .vary_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "gzip" },
-        },
-    };
-
-    try cache.put(meta, "hello world");
-
-    const result = cache.get(arena.allocator(), .{
-        .url = "https://example.com",
-        .timestamp = now,
-        .request_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "gzip" },
-        },
-    }) orelse return error.CacheMiss;
-    result.data.file.file.close();
-
-    try testing.expectEqual(null, cache.get(arena.allocator(), .{
-        .url = "https://example.com",
-        .timestamp = now,
-        .request_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "br" },
-        },
-    }));
-
-    try testing.expectEqual(null, cache.get(arena.allocator(), .{
-        .url = "https://example.com",
-        .timestamp = now,
-        .request_headers = &.{},
-    }));
-
-    const result2 = cache.get(arena.allocator(), .{
-        .url = "https://example.com",
-        .timestamp = now,
-        .request_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "gzip" },
-        },
-    }) orelse return error.CacheMiss;
-    result2.data.file.file.close();
-}
-
-test "FsCache: vary multiple headers" {
-    var setup = try setupCache();
-    defer {
-        setup.cache.deinit();
-        setup.tmp.cleanup();
-    }
-
-    const cache = &setup.cache;
-
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-
-    const now = std.time.timestamp();
-    const meta = CachedMetadata{
-        .url = "https://example.com",
-        .content_type = "text/html",
-        .status = 200,
-        .stored_at = now,
-        .age_at_store = 0,
-        .cache_control = .{ .max_age = 600 },
-        .headers = &.{},
-        .vary_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "gzip" },
-            .{ .name = "Accept-Language", .value = "en" },
-        },
-    };
-
-    try cache.put(meta, "hello world");
-
-    const result = cache.get(arena.allocator(), .{
-        .url = "https://example.com",
-        .timestamp = now,
-        .request_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "gzip" },
-            .{ .name = "Accept-Language", .value = "en" },
-        },
-    }) orelse return error.CacheMiss;
-    result.data.file.file.close();
-
-    try testing.expectEqual(null, cache.get(arena.allocator(), .{
-        .url = "https://example.com",
-        .timestamp = now,
-        .request_headers = &.{
-            .{ .name = "Accept-Encoding", .value = "gzip" },
-            .{ .name = "Accept-Language", .value = "fr" },
-        },
-    }));
-}

src/network/http.zig

@@ -79,7 +79,7 @@ pub const Headers = struct {
         self.headers = updated_headers;
     }
 
-    pub fn parseHeader(header_str: []const u8) ?Header {
+    fn parseHeader(header_str: []const u8) ?Header {
         const colon_pos = std.mem.indexOfScalar(u8, header_str, ':') orelse return null;
 
         const name = std.mem.trim(u8, header_str[0..colon_pos], " \t");
@@ -88,9 +88,22 @@ pub const Headers = struct {
         return .{ .name = name, .value = value };
     }
 
-    pub fn iterator(self: Headers) HeaderIterator {
+    pub fn iterator(self: *Headers) Iterator {
-        return .{ .curl_slist = .{ .header = self.headers } };
+        return .{
+            .header = self.headers,
+        };
     }
+
+    const Iterator = struct {
+        header: [*c]libcurl.CurlSList,
+
+        pub fn next(self: *Iterator) ?Header {
+            const h = self.header orelse return null;
+
+            self.header = h.*.next;
+            return parseHeader(std.mem.span(@as([*:0]const u8, @ptrCast(h.*.data))));
+        }
+    };
 };
 
 // In normal cases, the header iterator comes from the curl linked list.
@@ -99,7 +112,6 @@ pub const Headers = struct {
 // This union, is an iterator that exposes the same API for either case.
 pub const HeaderIterator = union(enum) {
     curl: CurlHeaderIterator,
-    curl_slist: CurlSListIterator,
     list: ListHeaderIterator,
 
     pub fn next(self: *HeaderIterator) ?Header {
@@ -108,19 +120,6 @@ pub const HeaderIterator = union(enum) {
         }
     }
 
-    pub fn collect(self: *HeaderIterator, allocator: std.mem.Allocator) !std.ArrayList(Header) {
-        var list: std.ArrayList(Header) = .empty;
-
-        while (self.next()) |hdr| {
-            try list.append(allocator, .{
-                .name = try allocator.dupe(u8, hdr.name),
-                .value = try allocator.dupe(u8, hdr.value),
-            });
-        }
-
-        return list;
-    }
-
     const CurlHeaderIterator = struct {
         conn: *const Connection,
         prev: ?*libcurl.CurlHeader = null,
@@ -137,16 +136,6 @@ pub const HeaderIterator = union(enum) {
         }
     };
 
-    const CurlSListIterator = struct {
-        header: [*c]libcurl.CurlSList,
-
-        pub fn next(self: *CurlSListIterator) ?Header {
-            const h = self.header orelse return null;
-            self.header = h.*.next;
-            return Headers.parseHeader(std.mem.span(@as([*:0]const u8, @ptrCast(h.*.data))));
-        }
-    };
-
     const ListHeaderIterator = struct {
         index: usize = 0,
         list: []const Header,
@@ -245,6 +234,10 @@ pub const Connection = struct {
         try libcurl.curl_easy_setopt(self._easy, .url, url.ptr);
     }
 
+    pub fn setTimeout(self: *const Connection, timeout_ms: u32) !void {
+        try libcurl.curl_easy_setopt(self._easy, .timeout_ms, timeout_ms);
+    }
+
     // a libcurl request has 2 methods. The first is the method that
     // controls how libcurl behaves. This specifically influences how redirects
     // are handled. For example, if you do a POST and get a 301, libcurl will

src/network/layer/CacheLayer.zig

@@ -1,240 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const http = @import("../http.zig");
-const Transfer = @import("../../browser/HttpClient.zig").Transfer;
-const Context = @import("../../browser/HttpClient.zig").Context;
-const Request = @import("../../browser/HttpClient.zig").Request;
-const Response = @import("../../browser/HttpClient.zig").Response;
-const Layer = @import("../../browser/HttpClient.zig").Layer;
-
-const Cache = @import("../cache/Cache.zig");
-const CachedMetadata = @import("../cache/Cache.zig").CachedMetadata;
-const CachedResponse = @import("../cache/Cache.zig").CachedResponse;
-const Forward = @import("Forward.zig");
-
-const CacheLayer = @This();
-
-next: Layer = undefined,
-
-pub fn layer(self: *CacheLayer) Layer {
-    return .{
-        .ptr = self,
-        .vtable = &.{
-            .request = request,
-        },
-    };
-}
-
-fn request(ptr: *anyopaque, ctx: Context, req: Request) anyerror!void {
-    const self: *CacheLayer = @ptrCast(@alignCast(ptr));
-    const network = ctx.network;
-
-    if (network.cache == null or req.method != .GET) {
-        return self.next.request(ctx, req);
-    }
-
-    const arena = try network.app.arena_pool.acquire(.{ .debug = "CacheLayer" });
-    errdefer network.app.arena_pool.release(arena);
-
-    var iter = req.headers.iterator();
-    const req_header_list = try iter.collect(arena);
-
-    if (network.cache.?.get(arena, .{
-        .url = req.url,
-        .timestamp = std.time.timestamp(),
-        .request_headers = req_header_list.items,
-    })) |cached| {
-        defer req.headers.deinit();
-        defer network.app.arena_pool.release(arena);
-        return serveFromCache(req, &cached);
-    }
-
-    const cache_ctx = try arena.create(CacheContext);
-    cache_ctx.* = .{
-        .arena = arena,
-        .context = ctx,
-        .forward = Forward.fromRequest(req),
-        .req_url = req.url,
-        .req_headers = req.headers,
-    };
-
-    const wrapped = cache_ctx.forward.wrapRequest(
-        req,
-        cache_ctx,
-        "forward",
-        .{
-            .start = CacheContext.startCallback,
-            .header = CacheContext.headerCallback,
-            .done = CacheContext.doneCallback,
-            .shutdown = CacheContext.shutdownCallback,
-            .err = CacheContext.errorCallback,
-        },
-    );
-
-    return self.next.request(ctx, wrapped);
-}
-
-fn serveFromCache(req: Request, cached: *const CachedResponse) !void {
-    const response = Response.fromCached(req.ctx, cached);
-    defer switch (cached.data) {
-        .buffer => |_| {},
-        .file => |f| f.file.close(),
-    };
-
-    if (req.start_callback) |cb| {
-        try cb(response);
-    }
-
-    const proceed = try req.header_callback(response);
-    if (!proceed) {
-        req.error_callback(req.ctx, error.Abort);
-        return;
-    }
-
-    switch (cached.data) {
-        .buffer => |data| {
-            if (data.len > 0) {
-                try req.data_callback(response, data);
-            }
-        },
-        .file => |f| {
-            const file = f.file;
-            var buf: [1024]u8 = undefined;
-            var file_reader = file.reader(&buf);
-            try file_reader.seekTo(f.offset);
-            const reader = &file_reader.interface;
-            var read_buf: [1024]u8 = undefined;
-            var remaining = f.len;
-            while (remaining > 0) {
-                const read_len = @min(read_buf.len, remaining);
-                const n = try reader.readSliceShort(read_buf[0..read_len]);
-                if (n == 0) break;
-                remaining -= n;
-                try req.data_callback(response, read_buf[0..n]);
-            }
-        },
-    }
-
-    try req.done_callback(req.ctx);
-}
-
-const CacheContext = struct {
-    arena: std.mem.Allocator,
-    context: Context,
-    transfer: ?*Transfer = null,
-    forward: Forward,
-    req_url: [:0]const u8,
-    req_headers: http.Headers,
-    pending_metadata: ?*CachedMetadata = null,
-
-    fn startCallback(response: Response) anyerror!void {
-        const self: *CacheContext = @ptrCast(@alignCast(response.ctx));
-        self.transfer = response.inner.transfer;
-        return self.forward.forwardStart(response);
-    }
-
-    fn headerCallback(response: Response) anyerror!bool {
-        const self: *CacheContext = @ptrCast(@alignCast(response.ctx));
-        const allocator = self.arena;
-
-        const transfer = response.inner.transfer;
-        var rh = &transfer.response_header.?;
-
-        const conn = transfer._conn.?;
-
-        const vary = if (conn.getResponseHeader("vary", 0)) |h| h.value else null;
-
-        const maybe_cm = try Cache.tryCache(
-            allocator,
-            std.time.timestamp(),
-            transfer.url,
-            rh.status,
-            rh.contentType(),
-            if (conn.getResponseHeader("cache-control", 0)) |h| h.value else null,
-            vary,
-            if (conn.getResponseHeader("age", 0)) |h| h.value else null,
-            conn.getResponseHeader("set-cookie", 0) != null,
-            conn.getResponseHeader("authorization", 0) != null,
-        );
-
-        if (maybe_cm) |cm| {
-            var iter = transfer.responseHeaderIterator();
-            var header_list = try iter.collect(allocator);
-            const end_of_response = header_list.items.len;
-
-            if (vary) |vary_str| {
-                var req_it = self.req_headers.iterator();
-                while (req_it.next()) |hdr| {
-                    var vary_iter = std.mem.splitScalar(u8, vary_str, ',');
-                    while (vary_iter.next()) |part| {
-                        const name = std.mem.trim(u8, part, &std.ascii.whitespace);
-                        if (std.ascii.eqlIgnoreCase(hdr.name, name)) {
-                            try header_list.append(allocator, .{
-                                .name = try allocator.dupe(u8, hdr.name),
-                                .value = try allocator.dupe(u8, hdr.value),
-                            });
-                        }
-                    }
-                }
-
-                const metadata = try allocator.create(CachedMetadata);
-                metadata.* = cm;
-                metadata.headers = header_list.items[0..end_of_response];
-                metadata.vary_headers = header_list.items[end_of_response..];
-                self.pending_metadata = metadata;
-            }
-        }
-
-        return self.forward.forwardHeader(response);
-    }
-
-    fn doneCallback(ctx: *anyopaque) anyerror!void {
-        const self: *CacheContext = @ptrCast(@alignCast(ctx));
-        defer self.context.network.app.arena_pool.release(self.arena);
-
-        const transfer = self.transfer orelse @panic("Start Callback didn't set CacheLayer.transfer");
-
-        if (self.pending_metadata) |metadata| {
-            const cache = &self.context.network.cache.?;
-
-            log.debug(.browser, "http cache", .{ .key = self.req_url, .metadata = metadata });
-            cache.put(metadata.*, transfer._stream_buffer.items) catch |err| {
-                log.warn(.http, "cache put failed", .{ .err = err });
-            };
-            log.debug(.browser, "http.cache.put", .{ .url = self.req_url });
-        }
-
-        return self.forward.forwardDone();
-    }
-
-    fn shutdownCallback(ctx: *anyopaque) void {
-        const self: *CacheContext = @ptrCast(@alignCast(ctx));
-        defer self.context.network.app.arena_pool.release(self.arena);
-        self.forward.forwardShutdown();
-    }
-
-    fn errorCallback(ctx: *anyopaque, e: anyerror) void {
-        const self: *CacheContext = @ptrCast(@alignCast(ctx));
-        defer self.context.network.app.arena_pool.release(self.arena);
-        self.forward.forwardErr(e);
-    }
-};

src/network/layer/Forward.zig

@@ -1,135 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const Request = @import("../../browser/HttpClient.zig").Request;
-const Response = @import("../../browser/HttpClient.zig").Response;
-
-const Forward = @This();
-
-ctx: *anyopaque,
-start: ?Request.StartCallback,
-header: Request.HeaderCallback,
-data: Request.DataCallback,
-done: Request.DoneCallback,
-err: Request.ErrorCallback,
-shutdown: ?Request.ShutdownCallback,
-
-pub fn fromRequest(req: Request) Forward {
-    return .{
-        .ctx = req.ctx,
-        .start = req.start_callback,
-        .header = req.header_callback,
-        .data = req.data_callback,
-        .done = req.done_callback,
-        .err = req.error_callback,
-        .shutdown = req.shutdown_callback,
-    };
-}
-
-pub const Overrides = struct {
-    start: ?Request.StartCallback = null,
-    header: ?Request.HeaderCallback = null,
-    data: ?Request.DataCallback = null,
-    done: ?Request.DoneCallback = null,
-    err: ?Request.ErrorCallback = null,
-    shutdown: ?Request.ShutdownCallback = null,
-};
-
-pub fn wrapRequest(
-    self: *Forward,
-    req: Request,
-    new_ctx: anytype,
-    comptime field: []const u8,
-    overrides: Overrides,
-) Request {
-    const T = @TypeOf(new_ctx.*);
-    const PassthroughT = makePassthrough(T, field);
-    var wrapped = req;
-    wrapped.ctx = new_ctx;
-    wrapped.start_callback = overrides.start orelse if (self.start != null) PassthroughT.start else null;
-    wrapped.header_callback = overrides.header orelse PassthroughT.header;
-    wrapped.data_callback = overrides.data orelse PassthroughT.data;
-    wrapped.done_callback = overrides.done orelse PassthroughT.done;
-    wrapped.error_callback = overrides.err orelse PassthroughT.err;
-    wrapped.shutdown_callback = overrides.shutdown orelse if (self.shutdown != null) PassthroughT.shutdown else null;
-    return wrapped;
-}
-
-fn makePassthrough(comptime T: type, comptime field: []const u8) type {
-    return struct {
-        pub fn start(response: Response) anyerror!void {
-            const self: *T = @ptrCast(@alignCast(response.ctx));
-            return @field(self, field).forwardStart(response);
-        }
-
-        pub fn header(response: Response) anyerror!bool {
-            const self: *T = @ptrCast(@alignCast(response.ctx));
-            return @field(self, field).forwardHeader(response);
-        }
-
-        pub fn data(response: Response, chunk: []const u8) anyerror!void {
-            const self: *T = @ptrCast(@alignCast(response.ctx));
-            return @field(self, field).forwardData(response, chunk);
-        }
-
-        pub fn done(ctx_ptr: *anyopaque) anyerror!void {
-            const self: *T = @ptrCast(@alignCast(ctx_ptr));
-            return @field(self, field).forwardDone();
-        }
-
-        pub fn err(ctx_ptr: *anyopaque, e: anyerror) void {
-            const self: *T = @ptrCast(@alignCast(ctx_ptr));
-            @field(self, field).forwardErr(e);
-        }
-
-        pub fn shutdown(ctx_ptr: *anyopaque) void {
-            const self: *T = @ptrCast(@alignCast(ctx_ptr));
-            @field(self, field).forwardShutdown();
-        }
-    };
-}
-
-pub fn forwardStart(self: Forward, response: Response) anyerror!void {
-    var fwd = response;
-    fwd.ctx = self.ctx;
-    if (self.start) |cb| try cb(fwd);
-}
-
-pub fn forwardHeader(self: Forward, response: Response) anyerror!bool {
-    var fwd = response;
-    fwd.ctx = self.ctx;
-    return self.header(fwd);
-}
-
-pub fn forwardData(self: Forward, response: Response, chunk: []const u8) anyerror!void {
-    var fwd = response;
-    fwd.ctx = self.ctx;
-    return self.data(fwd, chunk);
-}
-
-pub fn forwardDone(self: Forward) anyerror!void {
-    return self.done(self.ctx);
-}
-
-pub fn forwardErr(self: Forward, e: anyerror) void {
-    self.err(self.ctx, e);
-}
-
-pub fn forwardShutdown(self: Forward) void {
-    if (self.shutdown) |cb| cb(self.ctx);
-}

src/network/layer/RobotsLayer.zig

@@ -1,255 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const URL = @import("../../browser/URL.zig");
-const Robots = @import("../Robots.zig");
-const Context = @import("../../browser/HttpClient.zig").Context;
-const Request = @import("../../browser/HttpClient.zig").Request;
-const Response = @import("../../browser/HttpClient.zig").Response;
-const Layer = @import("../../browser/HttpClient.zig").Layer;
-const Forward = @import("Forward.zig");
-
-const RobotsLayer = @This();
-
-next: Layer = undefined,
-obey_robots: bool,
-allocator: std.mem.Allocator,
-pending: std.StringHashMapUnmanaged(std.ArrayListUnmanaged(Request)) = .empty,
-
-pub fn layer(self: *RobotsLayer) Layer {
-    return .{
-        .ptr = self,
-        .vtable = &.{
-            .request = request,
-        },
-    };
-}
-
-pub fn deinit(self: *RobotsLayer, allocator: std.mem.Allocator) void {
-    var it = self.pending.iterator();
-    while (it.next()) |entry| {
-        entry.value_ptr.deinit(allocator);
-    }
-    self.pending.deinit(allocator);
-}
-
-fn request(ptr: *anyopaque, ctx: Context, req: Request) anyerror!void {
-    const self: *RobotsLayer = @ptrCast(@alignCast(ptr));
-
-    if (!self.obey_robots) {
-        return self.next.request(ctx, req);
-    }
-
-    const robots_url = try URL.getRobotsUrl(self.allocator, req.url);
-    errdefer self.allocator.free(robots_url);
-
-    if (ctx.network.robot_store.get(robots_url)) |robot_entry| {
-        defer self.allocator.free(robots_url);
-        switch (robot_entry) {
-            .present => |robots| {
-                const path = URL.getPathname(req.url);
-                if (!robots.isAllowed(path)) {
-                    log.warn(.http, "blocked by robots", .{ .url = req.url });
-                    req.error_callback(req.ctx, error.RobotsBlocked);
-                    return;
-                }
-            },
-            .absent => {},
-        }
-        return self.next.request(ctx, req);
-    }
-
-    return self.fetchRobotsThenRequest(ctx, robots_url, req);
-}
-
-fn fetchRobotsThenRequest(self: *RobotsLayer, ctx: Context, robots_url: [:0]const u8, req: Request) !void {
-    const entry = try self.pending.getOrPut(self.allocator, robots_url);
-
-    if (!entry.found_existing) {
-        errdefer self.allocator.free(robots_url);
-        entry.value_ptr.* = .empty;
-
-        const robots_ctx = try self.allocator.create(RobotsContext);
-        errdefer self.allocator.destroy(robots_ctx);
-        robots_ctx.* = .{
-            .layer = self,
-            .ctx = ctx,
-            .robots_url = robots_url,
-            .buffer = .empty,
-        };
-
-        const headers = try ctx.newHeaders();
-        log.debug(.browser, "fetching robots.txt", .{ .robots_url = robots_url });
-
-        try self.next.request(ctx, .{
-            .ctx = robots_ctx,
-            .url = robots_url,
-            .method = .GET,
-            .headers = headers,
-            .blocking = false,
-            .frame_id = req.frame_id,
-            .cookie_jar = req.cookie_jar,
-            .cookie_origin = req.cookie_origin,
-            .notification = req.notification,
-            .resource_type = .fetch,
-            .header_callback = RobotsContext.headerCallback,
-            .data_callback = RobotsContext.dataCallback,
-            .done_callback = RobotsContext.doneCallback,
-            .error_callback = RobotsContext.errorCallback,
-            .shutdown_callback = RobotsContext.shutdownCallback,
-        });
-    } else {
-        self.allocator.free(robots_url);
-    }
-
-    try entry.value_ptr.append(self.allocator, req);
-}
-
-fn flushPending(self: *RobotsLayer, ctx: Context, robots_url: [:0]const u8, allowed: bool) void {
-    var queued = self.pending.fetchRemove(robots_url) orelse
-        @panic("RobotsLayer.flushPending: missing queue");
-    defer queued.value.deinit(self.allocator);
-
-    for (queued.value.items) |queued_req| {
-        if (!allowed) {
-            log.warn(.http, "blocked by robots", .{ .url = queued_req.url });
-            defer queued_req.headers.deinit();
-            queued_req.error_callback(queued_req.ctx, error.RobotsBlocked);
-        } else {
-            self.next.request(ctx, queued_req) catch |e| {
-                defer queued_req.headers.deinit();
-                queued_req.error_callback(queued_req.ctx, e);
-            };
-        }
-    }
-}
-
-fn flushPendingShutdown(self: *RobotsLayer, robots_url: [:0]const u8) void {
-    var queued = self.pending.fetchRemove(robots_url) orelse
-        @panic("RobotsLayer.flushPendingShutdown: missing queue");
-    defer queued.value.deinit(self.allocator);
-
-    for (queued.value.items) |queued_req| {
-        defer queued_req.headers.deinit();
-        if (queued_req.shutdown_callback) |cb| cb(queued_req.ctx);
-    }
-}
-
-const RobotsContext = struct {
-    layer: *RobotsLayer,
-    ctx: Context,
-    robots_url: [:0]const u8,
-    buffer: std.ArrayListUnmanaged(u8),
-    status: u16 = 0,
-
-    fn deinit(self: *RobotsContext) void {
-        self.buffer.deinit(self.layer.allocator);
-        self.layer.allocator.destroy(self);
-    }
-
-    fn headerCallback(response: Response) anyerror!bool {
-        const self: *RobotsContext = @ptrCast(@alignCast(response.ctx));
-        switch (response.inner) {
-            .transfer => |t| {
-                if (t.response_header) |hdr| {
-                    log.debug(.browser, "robots status", .{ .status = hdr.status, .robots_url = self.robots_url });
-                    self.status = hdr.status;
-                }
-                if (t.getContentLength()) |cl| {
-                    try self.buffer.ensureTotalCapacity(self.layer.allocator, cl);
-                }
-            },
-            .cached => {},
-        }
-        return true;
-    }
-
-    fn dataCallback(response: Response, data: []const u8) anyerror!void {
-        const self: *RobotsContext = @ptrCast(@alignCast(response.ctx));
-        try self.buffer.appendSlice(self.layer.allocator, data);
-    }
-
-    fn doneCallback(ctx_ptr: *anyopaque) anyerror!void {
-        const self: *RobotsContext = @ptrCast(@alignCast(ctx_ptr));
-        const l = self.layer;
-        const ctx = self.ctx;
-        const robots_url = self.robots_url;
-        defer l.allocator.free(robots_url);
-        defer self.deinit();
-
-        var allowed = true;
-        const network = ctx.network;
-
-        switch (self.status) {
-            200 => {
-                if (self.buffer.items.len > 0) {
-                    const robots: ?Robots = network.robot_store.robotsFromBytes(
-                        network.config.http_headers.user_agent,
-                        self.buffer.items,
-                    ) catch blk: {
-                        log.warn(.browser, "failed to parse robots", .{ .robots_url = robots_url });
-                        try network.robot_store.putAbsent(robots_url);
-                        break :blk null;
-                    };
-                    if (robots) |r| {
-                        try network.robot_store.put(robots_url, r);
-                        const path = URL.getPathname(self.layer.pending.get(robots_url).?.items[0].url);
-                        allowed = r.isAllowed(path);
-                    }
-                }
-            },
-            404 => {
-                log.debug(.http, "robots not found", .{ .url = robots_url });
-                try network.robot_store.putAbsent(robots_url);
-            },
-            else => {
-                log.debug(.http, "unexpected status on robots", .{
-                    .url = robots_url,
-                    .status = self.status,
-                });
-                try network.robot_store.putAbsent(robots_url);
-            },
-        }
-
-        l.flushPending(ctx, robots_url, allowed);
-    }
-
-    fn errorCallback(ctx_ptr: *anyopaque, err: anyerror) void {
-        const self: *RobotsContext = @ptrCast(@alignCast(ctx_ptr));
-        const l = self.layer;
-        const ctx = self.ctx;
-        const robots_url = self.robots_url;
-        defer l.allocator.free(robots_url);
-        defer self.deinit();
-        log.warn(.http, "robots fetch failed", .{ .err = err });
-        l.flushPending(ctx, robots_url, true);
-    }
-
-    fn shutdownCallback(ctx_ptr: *anyopaque) void {
-        const self: *RobotsContext = @ptrCast(@alignCast(ctx_ptr));
-        const l = self.layer;
-        const robots_url = self.robots_url;
-        defer l.allocator.free(robots_url);
-        defer self.deinit();
-        log.debug(.http, "robots fetch shutdown", .{});
-        l.flushPendingShutdown(robots_url);
-    }
-};

src/network/layer/WebBotAuthLayer.zig

@@ -1,54 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const log = @import("../../log.zig");
-
-const URL = @import("../../browser/URL.zig");
-const WebBotAuth = @import("../WebBotAuth.zig");
-const Context = @import("../../browser/HttpClient.zig").Context;
-const Request = @import("../../browser/HttpClient.zig").Request;
-const Layer = @import("../../browser/HttpClient.zig").Layer;
-
-const WebBotAuthLayer = @This();
-
-next: Layer = undefined,
-
-pub fn layer(self: *WebBotAuthLayer) Layer {
-    return .{
-        .ptr = self,
-        .vtable = &.{ .request = request },
-    };
-}
-
-pub fn deinit(_: *WebBotAuthLayer, _: std.mem.Allocator) void {}
-
-fn request(ptr: *anyopaque, ctx: Context, req: Request) anyerror!void {
-    const self: *WebBotAuthLayer = @ptrCast(@alignCast(ptr));
-    var our_req = req;
-
-    if (ctx.network.web_bot_auth) |*wba| {
-        const arena = try ctx.network.app.arena_pool.acquire(.{ .debug = "WebBotAuthLayer" });
-        defer ctx.network.app.arena_pool.release(arena);
-
-        const authority = URL.getHost(req.url);
-        try wba.signRequest(arena, &our_req.headers, authority);
-    }
-
-    return self.next.request(ctx, our_req);
-}

src/telemetry/lightpanda.zig

@@ -8,7 +8,7 @@ const log = @import("../log.zig");
 const App = @import("../App.zig");
 const Config = @import("../Config.zig");
 const telemetry = @import("telemetry.zig");
-const Network = @import("../network/Network.zig");
+const Runtime = @import("../network/Runtime.zig");
 
 const URL = "https://telemetry.lightpanda.io";
 const BUFFER_SIZE = 1024;
@@ -17,7 +17,7 @@ const MAX_BODY_SIZE = 500 * 1024; // 500KB server limit
 const LightPanda = @This();
 
 allocator: Allocator,
-network: *Network,
+runtime: *Runtime,
 writer: std.Io.Writer.Allocating,
 
 /// Protects concurrent producers in send().
@@ -36,11 +36,11 @@ pub fn init(self: *LightPanda, app: *App, iid: ?[36]u8, run_mode: Config.RunMode
         .iid = iid,
         .run_mode = run_mode,
         .allocator = app.allocator,
-        .network = &app.network,
+        .runtime = &app.network,
         .writer = std.Io.Writer.Allocating.init(app.allocator),
     };
 
-    self.network.onTick(@ptrCast(self), flushCallback);
+    self.runtime.onTick(@ptrCast(self), flushCallback);
 }
 
 pub fn deinit(self: *LightPanda) void {
@@ -70,17 +70,17 @@ fn flushCallback(ctx: *anyopaque) void {
 }
 
 fn postEvent(self: *LightPanda) !void {
-    const conn = self.network.getConnection() orelse {
+    const conn = self.runtime.getConnection() orelse {
         return;
     };
-    errdefer self.network.releaseConnection(conn);
+    errdefer self.runtime.releaseConnection(conn);
 
     const h = self.head.load(.monotonic);
     const t = self.tail.load(.acquire);
     const dropped = self.dropped.swap(0, .monotonic);
 
     if (h == t and dropped == 0) {
-        self.network.releaseConnection(conn);
+        self.runtime.releaseConnection(conn);
         return;
     }
     errdefer _ = self.dropped.fetchAdd(dropped, .monotonic);
@@ -104,7 +104,7 @@ fn postEvent(self: *LightPanda) !void {
     try conn.setBody(self.writer.written());
 
     self.head.store(h + sent, .release);
-    self.network.submitRequest(conn);
+    self.runtime.submitRequest(conn);
 }
 
 fn writeEvent(self: *LightPanda, event: telemetry.Event) !bool {