add Network.requestServedFromCache CDP Event

src/Notification.zig

@@ -83,6 +83,7 @@ const EventListeners = struct {
     http_request_intercept: List = .{},
     http_request_done: List = .{},
     http_request_auth_required: List = .{},
+    http_request_served_from_cache: List = .{},
     http_response_data: List = .{},
     http_response_header_done: List = .{},
     javascript_dialog_opening: List = .{},
@@ -103,6 +104,7 @@ const Events = union(enum) {
     http_request_intercept: *const RequestIntercept,
     http_request_auth_required: *const RequestAuthRequired,
     http_request_done: *const RequestDone,
+    http_request_served_from_cache: *const RequestServedFromCache,
     http_response_data: *const ResponseData,
     http_response_header_done: *const ResponseHeaderDone,
     javascript_dialog_opening: *const JavascriptDialogOpening,
@@ -198,6 +200,10 @@ pub const RequestFail = struct {
     err: anyerror,
 };
 
+pub const RequestServedFromCache = struct {
+    request: *Request,
+};
+
 pub const JavascriptDialogOpening = struct {
     url: [:0]const u8,
     message: []const u8,

src/cdp/CDP.zig

@@ -576,6 +576,7 @@ pub const BrowserContext = struct {
         try self.notification.register(.http_request_fail, self, onHttpRequestFail);
         try self.notification.register(.http_request_start, self, onHttpRequestStart);
         try self.notification.register(.http_request_done, self, onHttpRequestDone);
+        try self.notification.register(.http_request_served_from_cache, self, onHttpRequestServedFromCache);
         try self.notification.register(.http_response_data, self, onHttpResponseData);
         try self.notification.register(.http_response_header_done, self, onHttpResponseHeadersDone);
     }
@@ -584,6 +585,7 @@ pub const BrowserContext = struct {
         self.notification.unregister(.http_request_fail, self);
         self.notification.unregister(.http_request_start, self);
         self.notification.unregister(.http_request_done, self);
+        self.notification.unregister(.http_request_served_from_cache, self);
         self.notification.unregister(.http_response_data, self);
         self.notification.unregister(.http_response_header_done, self);
     }
@@ -734,6 +736,11 @@ pub const BrowserContext = struct {
         try @import("domains/fetch.zig").requestAuthRequired(self, data);
     }
 
+    pub fn onHttpRequestServedFromCache(ctx: *anyopaque, msg: *const Notification.RequestServedFromCache) !void {
+        const self: *BrowserContext = @ptrCast(@alignCast(ctx));
+        return @import("domains/network.zig").httpServedFromCache(self, msg);
+    }
+
     fn resetNotificationArena(self: *BrowserContext) void {
         defer _ = self.cdp.notification_arena.reset(.{ .retain_with_limit = 1024 * 64 });
     }

src/cdp/domains/network.zig

@@ -328,6 +328,15 @@ pub fn httpRequestDone(bc: *CDP.BrowserContext, msg: *const Notification.Request
     }, .{ .session_id = session_id });
 }
 
+pub fn httpServedFromCache(bc: *CDP.BrowserContext, msg: *const Notification.RequestServedFromCache) !void {
+    const session_id = bc.session_id orelse return;
+    const req = msg.request;
+
+    try bc.cdp.sendEvent("Network.requestServedFromCache", .{
+        .requestId = &id.toRequestId(req),
+    }, .{ .session_id = session_id });
+}
+
 pub const RequestWriter = struct {
     request: *Request,
 

src/network/layer/InterceptionLayer.zig

@@ -109,6 +109,13 @@ pub const InterceptContext = struct {
     fn startCallback(response: Response) anyerror!void {
         const self: *InterceptContext = @ptrCast(@alignCast(response.ctx));
         log.debug(.http, "intercept start", .{ .url = self.request.params.url });
+
+        if (response.inner == .cached) {
+            self.request.params.notification.dispatch(.http_request_served_from_cache, &.{
+                .request = &self.request,
+            });
+        }
+
         return self.forward.forwardStart(response);
     }