Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

215 KB
Raw Blame
use crate::automation::{
    AutomationEvent, BrowserDownloadProgressEvent, BrowserDownloadWillBeginEvent, DevToolsFrameId,
    DevToolsNetworkResourceType, DevToolsRealmId, DevToolsRemoteHandleId, DevToolsTargetInfo,
    DomSetChildNodesEvent, LogEntryEvent, NavigationFrameEvent, NavigationFrameEventKind,
    NavigationLifecycleEvent, PageFileChooserOpenedEvent, PageJavaScriptDialogOpeningEvent,
    PageLifecycleEvent, RuntimeConsoleEvent, RuntimeExecutionContextEvent,
    RuntimeExecutionContextsClearedEvent, SameDocumentNavigationEvent, ScriptExceptionEvent,
    TargetAttachmentEvent, TargetDetachmentEvent, TargetLifecycleEvent, UserPromptClosedEvent,
};
use moli_core::{
    RendererRuntimeInspectorAsyncCompletion,
    page::{
        RendererAgentAttachmentId, RendererDocumentToken, RendererLifecycleEpoch,
        RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage, WebSocketFrameDirection,
        WebSocketFrameOpcode,
    },
};
use moli_page_types::{
    DevToolsSessionKey, FrontendCommandId, InspectorIssueSnapshot, RendererCallId,
};
use serde_json::{Value, json};
use tokio::sync::mpsc::UnboundedSender;

use super::{
    CdpConnection, CommandOwnerScope, DevToolsDocumentLifecycleWaitKey,
    state::{BrowserContext, DocumentNavigationToken},
};

mod delivery_route;
use delivery_route::ProtocolDeliveryRoute;

pub type BackgroundEventSender = UnboundedSender<BackgroundProtocolEvent>;

#[derive(Debug, Clone, PartialEq)]
pub struct RuntimeInspectorResponseReady {
    frontend_command_id: FrontendCommandId,
    session_key: DevToolsSessionKey,
    owner: Option<CommandOwnerScope>,
    expected_renderer_call_id: Option<RendererCallId>,
    response: Result<RendererRuntimeInspectorAsyncCompletion, String>,
}

impl RuntimeInspectorResponseReady {
    pub fn new(
        command_id: u64,
        session_id: Option<&str>,
        response: Result<RendererRuntimeInspectorAsyncCompletion, String>,
    ) -> Self {
        Self {
            frontend_command_id: FrontendCommandId::new(command_id),
            session_key: DevToolsSessionKey::from_wire_session_id(session_id),
            owner: None,
            expected_renderer_call_id: None,
            response,
        }
    }

    pub(crate) fn for_owner(
        command_id: u64,
        owner: &CommandOwnerScope,
        response: Result<RendererRuntimeInspectorAsyncCompletion, String>,
    ) -> Self {
        Self {
            frontend_command_id: FrontendCommandId::new(command_id),
            session_key: DevToolsSessionKey::from_wire_session_id(owner.session_id()),
            owner: Some(owner.clone()),
            expected_renderer_call_id: None,
            response,
        }
    }

    pub fn command_id(&self) -> u64 {
        self.frontend_command_id.get()
    }

    pub fn session_id(&self) -> Option<&str> {
        self.session_key.wire_session_id()
    }

    pub(crate) fn owner(&self) -> Option<&CommandOwnerScope> {
        self.owner.as_ref()
    }

    pub(crate) fn bind_owner(&mut self, owner: &CommandOwnerScope) {
        assert_eq!(
            self.session_id(),
            owner.session_id(),
            "runtime Inspector response owner must preserve its wire session"
        );
        if let Some(current) = self.owner.as_ref() {
            assert_eq!(
                current, owner,
                "runtime Inspector response owner cannot change"
            );
        } else {
            self.owner = Some(owner.clone());
        }
    }

    pub fn error(&self) -> Option<&str> {
        self.response.as_ref().err().map(String::as_str)
    }

    pub(crate) fn renderer_call_id(&self) -> Option<RendererCallId> {
        self.response
            .as_ref()
            .ok()
            .map(|completion| RendererCallId::new(completion.call_id))
    }

    #[cfg(test)]
    pub(crate) fn new_correlated(
        command_id: u64,
        session_id: Option<&str>,
        renderer_call_id: RendererCallId,
        response: Result<RendererRuntimeInspectorAsyncCompletion, String>,
    ) -> Self {
        let mut ready = Self::new(command_id, session_id, response);
        ready.bind_renderer_call_id(renderer_call_id);
        ready
    }

    pub(crate) fn bind_renderer_call_id(&mut self, renderer_call_id: RendererCallId) {
        assert!(
            self.expected_renderer_call_id
                .replace(renderer_call_id)
                .is_none(),
            "runtime Inspector response cannot change renderer correlation"
        );
    }

    pub(crate) fn has_bound_renderer_call_id(&self) -> bool {
        self.expected_renderer_call_id.is_some()
    }

    pub(crate) fn replace_with_error(&mut self, message: impl Into<String>) {
        self.response = Err(message.into());
    }

    pub(crate) fn renderer_agent_attachment_id(&self) -> Option<RendererAgentAttachmentId> {
        self.response
            .as_ref()
            .ok()
            .and_then(RendererRuntimeInspectorAsyncCompletion::renderer_agent_attachment_id)
    }

    pub fn renderer_output_predecessor(&self) -> Option<moli_core::RendererOutputFence> {
        self.response
            .as_ref()
            .ok()
            .and_then(RendererRuntimeInspectorAsyncCompletion::renderer_output_predecessor)
    }

    pub(crate) fn into_renderer_command_output(
        self,
    ) -> (
        u64,
        RendererRuntimeCommandOutput,
        Option<moli_core::RendererOutputFence>,
    ) {
        let command_id = self.frontend_command_id.get();
        let expected_renderer_call_id = self.expected_renderer_call_id;
        let renderer_output_predecessor = self.renderer_output_predecessor();
        let (attachment_id, mut output) = match self.response {
            Ok(completion)
                if expected_renderer_call_id
                    .is_some_and(|call_id| call_id.get() == completion.call_id)
                    && completion
                        .output
                        .protocol_response(completion.call_id)
                        .is_some() =>
            {
                let attachment_id = completion.renderer_agent_attachment_id();
                let mut output = completion.output;
                let rewritten = rewrite_runtime_command_output_response_id(
                    &mut output,
                    completion.call_id,
                    command_id,
                );
                debug_assert!(rewritten);
                (attachment_id, output)
            }
            Ok(completion)
                if expected_renderer_call_id
                    .is_some_and(|call_id| call_id.get() == completion.call_id) =>
            {
                (
                    completion.renderer_agent_attachment_id(),
                    runtime_command_output_from_response_payload(
                        command_id,
                        BackgroundCommandResponsePayload::internal_error(
                            "RuntimeInspectorResponseMissingProtocolResponse".to_owned(),
                        ),
                    ),
                )
            }
            Ok(completion) => {
                let message =
                    runtime_command_output_response_message(&completion.output, completion.call_id)
                        .cloned()
                        .unwrap_or(Value::Null);
                let payload = runtime_inspector_mismatched_completion_payload(
                    command_id,
                    completion.call_id,
                    &message,
                );
                (
                    completion.renderer_agent_attachment_id(),
                    runtime_command_output_from_response_payload(command_id, payload),
                )
            }
            Err(message) => (
                None,
                runtime_command_output_from_response_payload(
                    command_id,
                    BackgroundCommandResponsePayload::internal_error(message),
                ),
            ),
        };
        if let Some(attachment_id) = attachment_id {
            output.bind_renderer_agent_attachment(attachment_id);
        }
        (command_id, output, renderer_output_predecessor)
    }

    pub fn into_protocol_message_for_typed_runtime_route(self) -> Value {
        let command_id = self.frontend_command_id.get();
        command_response_payload_protocol_message(command_id, self.into_command_response_payload())
    }

    pub(crate) fn into_command_response_payload(self) -> BackgroundCommandResponsePayload {
        match self.response {
            Ok(completion)
                if self
                    .expected_renderer_call_id
                    .is_some_and(|call_id| call_id.get() == completion.call_id) =>
            {
                completion
                    .output
                    .into_protocol_response(completion.call_id)
                    .map(BackgroundCommandResponsePayload::from_owned_runtime_inspector_message)
                    .unwrap_or_else(|| {
                        BackgroundCommandResponsePayload::internal_error(
                            "RuntimeInspectorResponseMissingProtocolResponse".to_owned(),
                        )
                    })
            }
            Ok(completion) => {
                let message =
                    runtime_command_output_response_message(&completion.output, completion.call_id)
                        .cloned()
                        .unwrap_or(Value::Null);
                runtime_inspector_mismatched_completion_payload(
                    self.frontend_command_id.get(),
                    completion.call_id,
                    &message,
                )
            }
            Err(message) => BackgroundCommandResponsePayload::internal_error(message),
        }
    }
}

fn rewrite_runtime_command_output_response_id(
    output: &mut RendererRuntimeCommandOutput,
    renderer_call_id: i32,
    frontend_command_id: u64,
) -> bool {
    let (renderer_agent_attachment_id, v8_state_update, mut messages) =
        std::mem::take(output).into_parts();
    let mut rewritten = false;
    for runtime_message in &mut messages {
        let RendererRuntimeInspectorMessage::Protocol(message) = runtime_message else {
            continue;
        };
        if message
            .renderer_call_id()
            .is_some_and(|call_id| call_id.get() == renderer_call_id)
        {
            message.value_mut()["id"] = json!(frontend_command_id);
            rewritten = true;
            break;
        }
    }
    *output = RendererRuntimeCommandOutput::from_parts(
        renderer_agent_attachment_id,
        v8_state_update,
        messages,
    );
    rewritten
}

fn runtime_command_output_response_message(
    output: &RendererRuntimeCommandOutput,
    call_id: i32,
) -> Option<&Value> {
    output.protocol_response(call_id)
}

fn runtime_command_output_from_response_payload(
    command_id: u64,
    payload: BackgroundCommandResponsePayload,
) -> RendererRuntimeCommandOutput {
    RendererRuntimeCommandOutput::from_inspector_message(RendererRuntimeInspectorMessage::protocol(
        command_response_payload_protocol_message(command_id, payload),
    ))
}

fn runtime_inspector_mismatched_completion_payload(
    expected_command_id: u64,
    actual_call_id: i32,
    message: &Value,
) -> BackgroundCommandResponsePayload {
    let payload = BackgroundCommandResponsePayload::from_runtime_inspector_message(message);
    if actual_call_id < 0 && matches!(payload, BackgroundCommandResponsePayload::Error { .. }) {
        return payload;
    }
    BackgroundCommandResponsePayload::internal_error(format!(
        "RuntimeInspectorResponseIdMismatch(expected={}, got={})",
        expected_command_id, actual_call_id
    ))
}

fn command_response_payload_protocol_message(
    command_id: u64,
    payload: BackgroundCommandResponsePayload,
) -> Value {
    match payload {
        BackgroundCommandResponsePayload::Success { result } => {
            build_command_success_response(Some(command_id), result, None)
        }
        BackgroundCommandResponsePayload::Error {
            code,
            message,
            data,
        } => {
            let mut error = json!({ "code": code, "message": message });
            if let Some(data) = data {
                error["data"] = data;
            }
            json!({
                "id": command_id,
                "error": error,
            })
        }
    }
}

pub type RuntimeInspectorAsyncCompletionReceiver =
    tokio::sync::oneshot::Receiver<RendererRuntimeInspectorAsyncCompletion>;
pub type RuntimeInspectorResponseReadySender = UnboundedSender<RuntimeInspectorResponseReady>;

/// One concrete protocol payload plus the exact route that authorizes its
/// eventual delivery.
///
/// The payload is frozen when the producer creates the event. The route is a
/// separate capability: scheduler residence and navigation gating move this
/// whole value, so neither a replacement Document nor a reused subscription
/// can inherit an older payload. This mirrors Chromium's separation between a
/// concrete Inspector notification and the DevTools session queue that owns
/// its delivery.
#[derive(Debug, Clone, PartialEq)]
pub struct ProtocolDeliveryEnvelope {
    payload: BackgroundProtocolEventPayload,
    route: ProtocolDeliveryRoute,
}

/// Existing protocol producers use this domain name pervasively. It now names
/// the delivery envelope, not a payload enum; route metadata can therefore no
/// longer be represented as a recursive event variant.
pub type BackgroundProtocolEvent = ProtocolDeliveryEnvelope;

macro_rules! define_background_protocol_event_payloads {
    ($( $variant:ident => $constructor:ident($payload:ty $(,)?) ),+ $(,)?) => {
        #[derive(Debug, Clone, PartialEq)]
        enum BackgroundProtocolEventPayload {
            $(
                $variant($payload),
            )+
        }

        impl ProtocolDeliveryEnvelope {
            $(
                fn $constructor(payload: $payload) -> Self {
                    Self::from_payload(BackgroundProtocolEventPayload::$variant(payload))
                }
            )+
        }
    };
}

define_background_protocol_event_payloads!(
    Protocol => wrap_protocol(BackgroundProtocolMessageEvent),
    CommandResponse => wrap_command_response_event(Box<BackgroundCommandResponseEvent>),
    NetworkRequestWillBeSentExtraInfo => wrap_network_request_will_be_sent_extra_info(
        Box<BackgroundNetworkRequestWillBeSentExtraInfoEvent>
    ),
    NetworkResponseReceivedExtraInfo => wrap_network_response_received_extra_info(
        Box<BackgroundNetworkResponseReceivedExtraInfoEvent>
    ),
    NetworkWebSocketCreated => wrap_network_websocket_created(Box<BackgroundNetworkWebSocketCreatedEvent>),
    NetworkWebSocketWillSendHandshakeRequest => wrap_network_websocket_will_send_handshake_request(
        Box<BackgroundNetworkWebSocketWillSendHandshakeRequestEvent>,
    ),
    NetworkWebSocketHandshakeResponseReceived => wrap_network_websocket_handshake_response_received(
        Box<BackgroundNetworkWebSocketHandshakeResponseReceivedEvent>,
    ),
    NetworkWebSocketFrame => wrap_network_websocket_frame(Box<BackgroundNetworkWebSocketFrameEvent>),
    ConsoleMessageAdded => wrap_console_message_added(Box<BackgroundConsoleMessageAddedEvent>),
    LogEntryAdded => wrap_log_entry_added(Box<BackgroundLogEntryAddedEvent>),
    RuntimeConsoleApiCalled => wrap_runtime_console_api_called(Box<BackgroundRuntimeConsoleApiCalledEvent>),
    RuntimeExceptionThrown => wrap_runtime_exception_thrown(Box<BackgroundRuntimeExceptionThrownEvent>),
    RuntimeBindingCalled => wrap_runtime_binding_called(Box<BackgroundRuntimeBindingCalledEvent>),
    RuntimeExecutionContextCreated => wrap_runtime_execution_context_created(Box<BackgroundRuntimeExecutionContextEvent>),
    RuntimeExecutionContextDestroyed => wrap_runtime_execution_context_destroyed(Box<BackgroundRuntimeExecutionContextEvent>),
    RuntimeExecutionContextsCleared => wrap_runtime_execution_contexts_cleared(Box<BackgroundRuntimeExecutionContextsClearedEvent>),
    DomSetChildNodes => wrap_dom_set_child_nodes(Box<BackgroundDomSetChildNodesEvent>),
    PageNavigationFrame => wrap_page_navigation_frame_event(Box<BackgroundPageNavigationFrameEvent>),
    PageDocumentOpened => wrap_page_document_opened_event(Box<BackgroundPageDocumentOpenedEvent>),
    PageDomContentLoaded => wrap_page_dom_content_loaded(Box<BackgroundNavigationLifecycleEvent>),
    PageLoad => wrap_page_load_event(Box<BackgroundNavigationLifecycleEvent>),
    PageLifecycle => wrap_page_lifecycle_event(Box<BackgroundPageLifecycleEvent>),
    PageSameDocumentNavigation => wrap_page_same_document_navigation_event(Box<BackgroundSameDocumentNavigationEvent>),
    PageFrameAttached => wrap_page_frame_attached_event(Box<BackgroundPageFrameAttachedEvent>),
    PageFrameDetached => wrap_page_frame_detached_event(Box<BackgroundPageFrameDetachedEvent>),
    PageFileChooserOpened => wrap_page_file_chooser_opened_event(Box<BackgroundPageFileChooserOpenedEvent>),
    BrowserDownloadWillBegin => wrap_browser_download_will_begin_event(Box<BackgroundBrowserDownloadWillBeginEvent>),
    BrowserDownloadProgress => wrap_browser_download_progress_event(Box<BackgroundBrowserDownloadProgressEvent>),
    PageJavaScriptDialogOpening => wrap_page_javascript_dialog_opening_event(Box<BackgroundPageJavaScriptDialogOpeningEvent>),
    PageJavaScriptDialogClosed => wrap_page_javascript_dialog_closed_event(Box<BackgroundPageJavaScriptDialogClosedEvent>),
    PageScreencastFrame => wrap_page_screencast_frame_event(Box<BackgroundPageScreencastFrameEvent>),
    PageScreencastVisibilityChanged => wrap_page_screencast_visibility_changed_event(Box<BackgroundPageScreencastVisibilityChangedEvent>),
    InspectorTargetCrashed => wrap_inspector_target_crashed_event(Box<BackgroundInspectorTargetCrashedEvent>),
    InspectorTargetReloadedAfterCrash => wrap_inspector_target_reloaded_after_crash_event(Box<BackgroundInspectorTargetReloadedAfterCrashEvent>),
    InspectorDetached => wrap_inspector_detached_event(Box<BackgroundInspectorDetachedEvent>),
    ServiceWorkerRegistrationUpdated => wrap_service_worker_registration_updated_event(Box<BackgroundServiceWorkerRegistrationUpdatedEvent>),
    ServiceWorkerVersionUpdated => wrap_service_worker_version_updated_event(Box<BackgroundServiceWorkerVersionUpdatedEvent>),
    ServiceWorkerErrorReported => wrap_service_worker_error_reported_event(Box<BackgroundServiceWorkerErrorReportedEvent>),
    TargetInfoChanged => wrap_target_info_changed_event(Box<BackgroundTargetInfoChangedEvent>),
    TargetCreated => wrap_target_created_event(Box<BackgroundTargetCreatedEvent>),
    TargetAttached => wrap_target_attached_event(Box<BackgroundTargetAttachedEvent>),
    TargetDetached => wrap_target_detached_event(Box<BackgroundTargetDetachedEvent>),
    TargetDestroyed => wrap_target_destroyed_event(Box<BackgroundTargetDestroyedEvent>),
    TargetCrashed => wrap_target_crashed_event(Box<BackgroundTargetCrashedEvent>),
    TargetReceivedMessageFromTarget => wrap_target_received_message_from_target_event(Box<BackgroundTargetReceivedMessageFromTargetEvent>),
    AutomationOnly => wrap_automation_only_event(Box<AutomationEvent>),
    RuntimeInspectorResponseReady => wrap_runtime_inspector_response_ready_event(Box<RuntimeInspectorResponseReady>),
);

impl BackgroundProtocolEventPayload {
    fn protocol_session_id(&self) -> Option<&str> {
        match self {
            Self::Protocol(event) => event.message.get("sessionId").and_then(Value::as_str),
            Self::CommandResponse(event) => event.session_id.as_deref(),
            Self::NetworkRequestWillBeSentExtraInfo(event) => event.session_id.as_deref(),
            Self::NetworkResponseReceivedExtraInfo(event) => event.session_id.as_deref(),
            Self::NetworkWebSocketCreated(event) => event.session_id.as_deref(),
            Self::NetworkWebSocketWillSendHandshakeRequest(event) => event.session_id.as_deref(),
            Self::NetworkWebSocketHandshakeResponseReceived(event) => event.session_id.as_deref(),
            Self::NetworkWebSocketFrame(event) => event.session_id.as_deref(),
            Self::ConsoleMessageAdded(event) => event.session_id.as_deref(),
            Self::LogEntryAdded(event) => event.session_id.as_deref(),
            Self::RuntimeConsoleApiCalled(event) => event.session_id.as_deref(),
            Self::RuntimeExceptionThrown(event) => event.session_id.as_deref(),
            Self::RuntimeBindingCalled(event) => event.session_id.as_deref(),
            Self::RuntimeExecutionContextCreated(event)
            | Self::RuntimeExecutionContextDestroyed(event) => event.session_id.as_deref(),
            Self::RuntimeExecutionContextsCleared(event) => event.session_id.as_deref(),
            Self::DomSetChildNodes(event) => event.session_id.as_deref(),
            Self::PageNavigationFrame(event) => event.session_id.as_deref(),
            Self::PageDocumentOpened(event) => event.session_id.as_deref(),
            Self::PageDomContentLoaded(event) | Self::PageLoad(event) => {
                event.session_id.as_deref()
            }
            Self::PageLifecycle(event) => event.session_id.as_deref(),
            Self::PageSameDocumentNavigation(event) => event.session_id.as_deref(),
            Self::PageFrameAttached(event) => event.session_id.as_deref(),
            Self::PageFrameDetached(event) => event.session_id.as_deref(),
            Self::PageFileChooserOpened(event) => event.session_id.as_deref(),
            Self::BrowserDownloadWillBegin(event) => event.session_id.as_deref(),
            Self::BrowserDownloadProgress(event) => event.session_id.as_deref(),
            Self::PageJavaScriptDialogOpening(event) => event.session_id.as_deref(),
            Self::PageJavaScriptDialogClosed(event) => event.session_id.as_deref(),
            Self::PageScreencastFrame(event) => event.session_id.as_deref(),
            Self::PageScreencastVisibilityChanged(event) => event.session_id.as_deref(),
            Self::InspectorTargetCrashed(event) => event.session_id.as_deref(),
            Self::InspectorTargetReloadedAfterCrash(event) => event.session_id.as_deref(),
            Self::InspectorDetached(event) => event.session_id.as_deref(),
            Self::ServiceWorkerRegistrationUpdated(event) => event.session_id.as_deref(),
            Self::ServiceWorkerVersionUpdated(event) => event.session_id.as_deref(),
            Self::ServiceWorkerErrorReported(event) => event.session_id.as_deref(),
            Self::TargetInfoChanged(event) => event.session_id.as_deref(),
            Self::TargetCreated(event) => event.session_id.as_deref(),
            Self::TargetAttached(event) => event
                .event
                .parent_session_id
                .as_ref()
                .map(crate::automation::DevToolsSessionId::as_str),
            Self::TargetDetached(event) => event
                .event
                .parent_session_id
                .as_ref()
                .map(crate::automation::DevToolsSessionId::as_str),
            Self::TargetDestroyed(event) => event.session_id.as_deref(),
            Self::TargetCrashed(event) => event.session_id.as_deref(),
            Self::TargetReceivedMessageFromTarget(_) | Self::AutomationOnly(_) => None,
            Self::RuntimeInspectorResponseReady(response) => response.session_id(),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum BackgroundCommandResponsePayload {
    Success {
        result: Value,
    },
    Error {
        code: i32,
        message: String,
        data: Option<Value>,
    },
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) enum BackgroundCommandResponsePayloadRef<'a> {
    Success {
        result: &'a Value,
    },
    Error {
        code: i32,
        message: &'a str,
        data: Option<&'a Value>,
    },
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundProtocolMessageEvent {
    message: Value,
    automation_event: Option<Box<AutomationEvent>>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNetworkRequestWillBeSentExtraInfoEvent {
    session_id: Option<String>,
    request_id: String,
    headers: serde_json::Map<String, Value>,
    cookie_access_report: Value,
    associated_cookies: Vec<Value>,
    request_time: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNetworkResponseReceivedExtraInfoEvent {
    session_id: Option<String>,
    request_id: String,
    headers: serde_json::Map<String, Value>,
    status_code: u16,
    cookie_reports: Vec<Value>,
    blocked_cookies: Vec<Value>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNetworkWebSocketCreatedEvent {
    session_id: Option<String>,
    request_id: String,
    url: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNetworkWebSocketWillSendHandshakeRequestEvent {
    session_id: Option<String>,
    request_id: String,
    timestamp: f64,
    headers: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNetworkWebSocketHandshakeResponseReceivedEvent {
    session_id: Option<String>,
    request_id: String,
    timestamp: f64,
    status: u16,
    status_text: String,
    headers: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNetworkWebSocketFrameEvent {
    session_id: Option<String>,
    request_id: String,
    timestamp: f64,
    direction: WebSocketFrameDirection,
    opcode: WebSocketFrameOpcode,
    payload_length: usize,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundCommandResponseEvent {
    command_id: Option<u64>,
    session_id: Option<String>,
    response: BackgroundCommandResponse,
}

#[derive(Debug, Clone, PartialEq)]
enum BackgroundCommandResponse {
    Success {
        result: Value,
    },
    Error {
        code: i32,
        message: String,
        data: Option<Value>,
    },
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundConsoleMessageAddedEvent {
    session_id: Option<String>,
    source: String,
    level: String,
    text: String,
    url: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundLogEntryAddedEvent {
    session_id: Option<String>,
    source: String,
    level: String,
    text: String,
    url: String,
    timestamp: f64,
    network_request_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundRuntimeConsoleApiCalledEvent {
    session_id: Option<String>,
    event: RuntimeConsoleEvent,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundRuntimeExceptionThrownEvent {
    session_id: Option<String>,
    event: ScriptExceptionEvent,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundRuntimeBindingCalledEvent {
    session_id: Option<String>,
    name: String,
    payload: String,
    execution_context_id: i64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundRuntimeExecutionContextEvent {
    session_id: Option<String>,
    event: RuntimeExecutionContextEvent,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundRuntimeExecutionContextsClearedEvent {
    session_id: Option<String>,
    event: RuntimeExecutionContextsClearedEvent,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundDomSetChildNodesEvent {
    session_id: Option<String>,
    parent_node_id: u32,
    nodes: Vec<Value>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageNavigationFrameEvent {
    session_id: Option<String>,
    event: NavigationFrameEvent,
    unreachable_url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageDocumentOpenedEvent {
    session_id: Option<String>,
    frame_id: String,
    parent_frame_id: Option<String>,
    loader_id: String,
    url: String,
    frame_name: Option<String>,
    security_origin: String,
    secure_context_type: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundNavigationLifecycleEvent {
    session_id: Option<String>,
    event: NavigationLifecycleEvent,
    renderer_document: Option<RendererDocumentToken>,
    renderer_epoch: Option<RendererLifecycleEpoch>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundPageLifecycleEvent {
    session_id: Option<String>,
    event: PageLifecycleEvent,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundSameDocumentNavigationEvent {
    session_id: Option<String>,
    event: SameDocumentNavigationEvent,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageFrameAttachedEvent {
    session_id: Option<String>,
    frame_id: String,
    parent_frame_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageFrameDetachedEvent {
    session_id: Option<String>,
    frame_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageFileChooserOpenedEvent {
    session_id: Option<String>,
    frame_id: String,
    mode: String,
    backend_node_id: u32,
    element_shared_id: Option<DevToolsRemoteHandleId>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundBrowserDownloadWillBeginEvent {
    session_id: Option<String>,
    frame_id: String,
    guid: String,
    url: String,
    suggested_filename: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundBrowserDownloadProgressEvent {
    session_id: Option<String>,
    guid: String,
    state: String,
    received_bytes: u64,
    total_bytes: u64,
    file_path: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageJavaScriptDialogOpeningEvent {
    session_id: Option<String>,
    frame_id: Option<String>,
    url: String,
    message: String,
    dialog_type: String,
    has_browser_handler: bool,
    default_prompt: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageJavaScriptDialogClosedEvent {
    session_id: Option<String>,
    target_id: Option<String>,
    frame_id: String,
    prompt_type: String,
    accepted: bool,
    user_text: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct PageScreencastFrameMetadata {
    pub offset_top: f64,
    pub page_scale_factor: f64,
    pub device_width: f64,
    pub device_height: f64,
    pub scroll_offset_x: f64,
    pub scroll_offset_y: f64,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundPageScreencastFrameEvent {
    session_id: Option<String>,
    data: String,
    metadata: PageScreencastFrameMetadata,
    generation: i32,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundPageScreencastVisibilityChangedEvent {
    session_id: Option<String>,
    visible: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundInspectorTargetCrashedEvent {
    session_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundInspectorTargetReloadedAfterCrashEvent {
    session_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundInspectorDetachedEvent {
    session_id: Option<String>,
    reason: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct BackgroundServiceWorkerRegistration {
    pub(crate) registration_id: String,
    pub(crate) scope_url: String,
    pub(crate) is_deleted: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct BackgroundServiceWorkerVersion {
    pub(crate) version_id: String,
    pub(crate) registration_id: String,
    pub(crate) script_url: String,
    pub(crate) running_status: String,
    pub(crate) status: String,
    pub(crate) controlled_clients: Vec<String>,
    pub(crate) target_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct BackgroundServiceWorkerErrorMessage {
    pub(crate) error_message: String,
    pub(crate) registration_id: String,
    pub(crate) version_id: String,
    pub(crate) source_url: String,
    pub(crate) line_number: u32,
    pub(crate) column_number: u32,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundServiceWorkerRegistrationUpdatedEvent {
    session_id: Option<String>,
    registrations: Vec<BackgroundServiceWorkerRegistration>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundServiceWorkerVersionUpdatedEvent {
    session_id: Option<String>,
    versions: Vec<BackgroundServiceWorkerVersion>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundServiceWorkerErrorReportedEvent {
    session_id: Option<String>,
    error_message: BackgroundServiceWorkerErrorMessage,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundTargetInfoChangedEvent {
    session_id: Option<String>,
    target_info: DevToolsTargetInfo,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundTargetCreatedEvent {
    session_id: Option<String>,
    event: TargetLifecycleEvent,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundTargetAttachedEvent {
    event: TargetAttachmentEvent,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundTargetDetachedEvent {
    event: TargetDetachmentEvent,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundTargetDestroyedEvent {
    session_id: Option<String>,
    event: TargetLifecycleEvent,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackgroundTargetCrashedEvent {
    session_id: Option<String>,
    target_id: String,
    status: String,
    error_code: i32,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BackgroundTargetReceivedMessageFromTargetEvent {
    target_session_id: String,
    nested_event: Box<BackgroundProtocolEvent>,
}

impl ProtocolDeliveryEnvelope {
    fn from_payload(payload: BackgroundProtocolEventPayload) -> Self {
        let route = ProtocolDeliveryRoute::for_wire_session(payload.protocol_session_id());
        Self { payload, route }
    }

    /// Returns the wire session frozen by construction or concrete fan-out.
    /// `None` means the root session; it never asks the current target state to
    /// infer a destination later.
    #[doc(hidden)]
    pub fn protocol_session_id(&self) -> Option<&str> {
        self.route.wire_session_id()
    }

    pub(crate) fn navigation_gate_target_id(&self) -> Option<&str> {
        if let Some(target_id) = self.route.navigation_gate_target_id() {
            return Some(target_id);
        }
        let BackgroundProtocolEventPayload::Protocol(event) = &self.payload else {
            return None;
        };
        match event.automation_event.as_deref()? {
            AutomationEvent::NetworkBeforeRequestSent(event)
            | AutomationEvent::NetworkResponseStarted(event)
            | AutomationEvent::NetworkResponseCompleted(event)
            | AutomationEvent::NetworkFetchError(event)
            | AutomationEvent::NetworkAuthRequired(event)
            | AutomationEvent::RequestPaused(event) => Some(event.target_id.as_str()),
            AutomationEvent::TargetCreated(event) | AutomationEvent::TargetDestroyed(event) => {
                Some(event.target_id.as_str())
            }
            AutomationEvent::TargetAttached(event) => Some(event.target_id.as_str()),
            AutomationEvent::TargetDetached(event) => Some(event.target_id.as_str()),
            AutomationEvent::NavigationFrame(event) => Some(event.target_id.as_str()),
            AutomationEvent::NavigationStarted(event)
            | AutomationEvent::DomContentLoaded(event)
            | AutomationEvent::Load(event) => Some(event.target_id.as_str()),
            AutomationEvent::PageLifecycle(event) => Some(event.target_id.as_str()),
            AutomationEvent::SameDocumentNavigation(event) => Some(event.target_id.as_str()),
            AutomationEvent::UserPromptClosed(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::LogEntryAdded(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::RuntimeConsoleApiCalled(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::RuntimeExecutionContextCreated(event)
            | AutomationEvent::RuntimeExecutionContextDestroyed(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::RuntimeExecutionContextsCleared(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::ScriptMessage(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::ScriptException(event) => {
                event.target_id.as_ref().map(|target_id| target_id.as_str())
            }
            AutomationEvent::PageJavaScriptDialogOpening(_)
            | AutomationEvent::PageFileChooserOpened(_)
            | AutomationEvent::BrowserDownloadWillBegin(_)
            | AutomationEvent::BrowserDownloadProgress(_)
            | AutomationEvent::DomSetChildNodes(_) => None,
        }
    }

    pub fn route_is_current(&self, conn: &CdpConnection) -> bool {
        self.route.is_current(conn)
    }

    /// Adds the exact Page attachment and root Document that authorize a
    /// child-frame event. The capability lives beside the payload rather than
    /// recursively wrapping it as another event kind.
    pub(crate) fn bind_to_root_document_route(
        mut self,
        conn: &CdpConnection,
        root_document: moli_core::RendererDocumentLifecycleIdentity,
    ) -> Option<Self> {
        let binding = conn.target_root_document_protocol_attachment_identity_for_session(
            self.protocol_session_id(),
            root_document,
        )?;
        self.route.bind_root_document(binding);
        Some(self)
    }

    fn bind_to_page_subscription_route(
        mut self,
        session_id: Option<&str>,
        generation: u64,
    ) -> Self {
        self.route.bind_page_subscription(session_id, generation);
        self
    }

    fn bind_to_browser_download_subscription_route(
        mut self,
        session_id: Option<&str>,
        generation: u64,
    ) -> Self {
        self.route
            .bind_browser_download_subscription(session_id, generation);
        self
    }

    pub fn immediate(message: Value) -> Self {
        Self::wrap_protocol(BackgroundProtocolMessageEvent {
            message,
            automation_event: None,
        })
    }

    pub fn immediate_automation_event(message: Value, automation_event: AutomationEvent) -> Self {
        Self::wrap_protocol(BackgroundProtocolMessageEvent {
            message,
            automation_event: Some(Box::new(automation_event)),
        })
    }

    pub(crate) fn audits_issue_added(
        session_id: Option<&str>,
        issue: &InspectorIssueSnapshot,
        frame_id: &str,
        loader_id: &str,
    ) -> Self {
        Self::immediate(build_event(
            "Audits.issueAdded",
            json!({
                "issue": crate::domains::audits_output_state::inspector_issue_protocol_value(
                    issue,
                    frame_id,
                    loader_id,
                ),
            }),
            session_id,
        ))
    }

    pub(crate) fn page_download_will_begin(
        session_id: Option<&str>,
        subscription_generation: u64,
        frame_id: &str,
        guid: &str,
        url: &str,
        suggested_filename: &str,
    ) -> Self {
        Self::wrap_protocol(BackgroundProtocolMessageEvent {
            message: build_event(
                "Page.downloadWillBegin",
                json!({
                    "frameId": frame_id,
                    "guid": guid,
                    "url": url,
                    "suggestedFilename": suggested_filename,
                }),
                session_id,
            ),
            automation_event: None,
        })
        .bind_to_page_subscription_route(session_id, subscription_generation)
    }

    pub(crate) fn page_download_progress(
        session_id: Option<&str>,
        subscription_generation: u64,
        guid: &str,
        state: &str,
        received_bytes: u64,
        total_bytes: u64,
    ) -> Self {
        Self::wrap_protocol(BackgroundProtocolMessageEvent {
            message: build_event(
                "Page.downloadProgress",
                json!({
                    "guid": guid,
                    "state": state,
                    "receivedBytes": received_bytes,
                    "totalBytes": total_bytes,
                }),
                session_id,
            ),
            automation_event: None,
        })
        .bind_to_page_subscription_route(session_id, subscription_generation)
    }

    pub(crate) fn automation_only(automation_event: AutomationEvent) -> Self {
        Self::wrap_automation_only_event(Box::new(automation_event))
    }

    pub fn runtime_inspector_response_ready(response: RuntimeInspectorResponseReady) -> Self {
        Self::wrap_runtime_inspector_response_ready_event(Box::new(response))
    }

    pub fn command_response(
        command_id: Option<u64>,
        session_id: Option<&str>,
        response: BackgroundCommandResponsePayload,
    ) -> Self {
        match response {
            BackgroundCommandResponsePayload::Success { result } => {
                Self::command_success(command_id, session_id, result)
            }
            BackgroundCommandResponsePayload::Error {
                code,
                message,
                data,
            } => Self::command_error(command_id, session_id, code, message, data),
        }
    }

    pub fn command_success(
        command_id: Option<u64>,
        session_id: Option<&str>,
        result: Value,
    ) -> Self {
        Self::wrap_command_response_event(Box::new(BackgroundCommandResponseEvent {
            command_id,
            session_id: session_id.map(str::to_owned),
            response: BackgroundCommandResponse::Success { result },
        }))
    }

    pub fn command_error(
        command_id: Option<u64>,
        session_id: Option<&str>,
        code: i32,
        message: String,
        data: Option<Value>,
    ) -> Self {
        Self::wrap_command_response_event(Box::new(BackgroundCommandResponseEvent {
            command_id,
            session_id: session_id.map(str::to_owned),
            response: BackgroundCommandResponse::Error {
                code,
                message,
                data,
            },
        }))
    }

    pub(crate) fn command_response_payload_ref(
        &self,
    ) -> Option<(
        Option<u64>,
        Option<&str>,
        BackgroundCommandResponsePayloadRef<'_>,
    )> {
        match &self.payload {
            BackgroundProtocolEventPayload::CommandResponse(event) => Some((
                event.command_id,
                event.session_id.as_deref(),
                event.response.payload_ref(),
            )),
            _ => None,
        }
    }

    pub fn into_command_response_payload(
        self,
    ) -> Result<
        (
            Option<u64>,
            Option<String>,
            BackgroundCommandResponsePayload,
        ),
        Self,
    > {
        let Self { payload, route } = self;
        match payload {
            BackgroundProtocolEventPayload::CommandResponse(event) => Ok((
                event.command_id,
                event.session_id,
                event.response.into_payload(),
            )),
            payload => Err(Self { payload, route }),
        }
    }

    pub(crate) fn network_request_will_be_sent_extra_info(
        session_id: Option<&str>,
        request_id: &str,
        headers: serde_json::Map<String, Value>,
        cookie_access_report: Value,
        associated_cookies: Vec<Value>,
        request_time: f64,
    ) -> Self {
        Self::wrap_network_request_will_be_sent_extra_info(Box::new(
            BackgroundNetworkRequestWillBeSentExtraInfoEvent {
                session_id: session_id.map(str::to_owned),
                request_id: request_id.to_owned(),
                headers,
                cookie_access_report,
                associated_cookies,
                request_time,
            },
        ))
    }

    pub(crate) fn network_response_received_extra_info(
        session_id: Option<&str>,
        request_id: &str,
        headers: serde_json::Map<String, Value>,
        status_code: u16,
        cookie_reports: Vec<Value>,
        blocked_cookies: Vec<Value>,
    ) -> Self {
        Self::wrap_network_response_received_extra_info(Box::new(
            BackgroundNetworkResponseReceivedExtraInfoEvent {
                session_id: session_id.map(str::to_owned),
                request_id: request_id.to_owned(),
                headers,
                status_code,
                cookie_reports,
                blocked_cookies,
            },
        ))
    }

    pub(crate) fn network_websocket_created(
        session_id: Option<&str>,
        request_id: &str,
        url: &str,
    ) -> Self {
        Self::wrap_network_websocket_created(Box::new(BackgroundNetworkWebSocketCreatedEvent {
            session_id: session_id.map(str::to_owned),
            request_id: request_id.to_owned(),
            url: url.to_owned(),
        }))
    }

    pub(crate) fn network_websocket_will_send_handshake_request(
        session_id: Option<&str>,
        request_id: &str,
        timestamp: f64,
        headers: serde_json::Map<String, Value>,
    ) -> Self {
        Self::wrap_network_websocket_will_send_handshake_request(Box::new(
            BackgroundNetworkWebSocketWillSendHandshakeRequestEvent {
                session_id: session_id.map(str::to_owned),
                request_id: request_id.to_owned(),
                timestamp,
                headers,
            },
        ))
    }

    pub(crate) fn network_websocket_handshake_response_received(
        session_id: Option<&str>,
        request_id: &str,
        timestamp: f64,
        status: u16,
        status_text: &str,
        headers: serde_json::Map<String, Value>,
    ) -> Self {
        Self::wrap_network_websocket_handshake_response_received(Box::new(
            BackgroundNetworkWebSocketHandshakeResponseReceivedEvent {
                session_id: session_id.map(str::to_owned),
                request_id: request_id.to_owned(),
                timestamp,
                status,
                status_text: status_text.to_owned(),
                headers,
            },
        ))
    }

    pub(crate) fn network_websocket_frame(
        session_id: Option<&str>,
        request_id: &str,
        timestamp: f64,
        direction: WebSocketFrameDirection,
        opcode: WebSocketFrameOpcode,
        payload_length: usize,
    ) -> Self {
        Self::wrap_network_websocket_frame(Box::new(BackgroundNetworkWebSocketFrameEvent {
            session_id: session_id.map(str::to_owned),
            request_id: request_id.to_owned(),
            timestamp,
            direction,
            opcode,
            payload_length,
        }))
    }

    pub(crate) fn console_message_added(
        session_id: Option<&str>,
        source: &str,
        level: &str,
        text: &str,
        url: &str,
    ) -> Self {
        Self::wrap_console_message_added(Box::new(BackgroundConsoleMessageAddedEvent {
            session_id: session_id.map(str::to_owned),
            source: source.to_owned(),
            level: level.to_owned(),
            text: text.to_owned(),
            url: url.to_owned(),
        }))
    }

    pub(crate) fn log_entry_added(
        session_id: Option<&str>,
        source: &str,
        level: &str,
        text: &str,
        url: &str,
        timestamp: f64,
        network_request_id: Option<&str>,
    ) -> Self {
        Self::wrap_log_entry_added(Box::new(BackgroundLogEntryAddedEvent {
            session_id: session_id.map(str::to_owned),
            source: source.to_owned(),
            level: level.to_owned(),
            text: text.to_owned(),
            url: url.to_owned(),
            timestamp,
            network_request_id: network_request_id.map(str::to_owned),
        }))
    }

    pub(crate) fn runtime_console_api_called(
        session_id: Option<&str>,
        event: RuntimeConsoleEvent,
    ) -> Self {
        Self::wrap_runtime_console_api_called(Box::new(BackgroundRuntimeConsoleApiCalledEvent {
            session_id: session_id.map(str::to_owned),
            event,
        }))
    }

    pub(crate) fn runtime_exception_thrown(
        session_id: Option<&str>,
        event: ScriptExceptionEvent,
    ) -> Self {
        Self::wrap_runtime_exception_thrown(Box::new(BackgroundRuntimeExceptionThrownEvent {
            session_id: session_id.map(str::to_owned),
            event,
        }))
    }

    pub(crate) fn runtime_binding_called(
        session_id: Option<&str>,
        name: impl Into<String>,
        payload: impl Into<String>,
        execution_context_id: i64,
    ) -> Self {
        Self::wrap_runtime_binding_called(Box::new(BackgroundRuntimeBindingCalledEvent {
            session_id: session_id.map(str::to_owned),
            name: name.into(),
            payload: payload.into(),
            execution_context_id,
        }))
    }

    pub(crate) fn runtime_execution_context_created(
        session_id: Option<&str>,
        event: RuntimeExecutionContextEvent,
    ) -> Self {
        Self::wrap_runtime_execution_context_created(Box::new(
            BackgroundRuntimeExecutionContextEvent {
                session_id: session_id.map(str::to_owned),
                event,
            },
        ))
    }

    pub(crate) fn runtime_execution_context_destroyed(
        session_id: Option<&str>,
        event: RuntimeExecutionContextEvent,
    ) -> Self {
        Self::wrap_runtime_execution_context_destroyed(Box::new(
            BackgroundRuntimeExecutionContextEvent {
                session_id: session_id.map(str::to_owned),
                event,
            },
        ))
    }

    pub(crate) fn runtime_execution_contexts_cleared(
        session_id: Option<&str>,
        event: RuntimeExecutionContextsClearedEvent,
    ) -> Self {
        Self::wrap_runtime_execution_contexts_cleared(Box::new(
            BackgroundRuntimeExecutionContextsClearedEvent {
                session_id: session_id.map(str::to_owned),
                event,
            },
        ))
    }

    pub(crate) fn dom_set_child_nodes(
        session_id: Option<&str>,
        parent_node_id: u32,
        nodes: Vec<Value>,
    ) -> Self {
        Self::wrap_dom_set_child_nodes(Box::new(BackgroundDomSetChildNodesEvent {
            session_id: session_id.map(str::to_owned),
            parent_node_id,
            nodes,
        }))
    }

    pub(crate) fn dom_attribute_modified(
        session_id: Option<&str>,
        node_id: u32,
        name: &str,
        value: &str,
    ) -> Self {
        Self::immediate(build_event(
            "DOM.attributeModified",
            json!({
                "nodeId": node_id,
                "name": name,
                "value": value,
            }),
            session_id,
        ))
    }

    pub(crate) fn dom_attribute_removed(
        session_id: Option<&str>,
        node_id: u32,
        name: &str,
    ) -> Self {
        Self::immediate(build_event(
            "DOM.attributeRemoved",
            json!({
                "nodeId": node_id,
                "name": name,
            }),
            session_id,
        ))
    }

    pub(crate) fn dom_character_data_modified(
        session_id: Option<&str>,
        node_id: u32,
        character_data: &str,
    ) -> Self {
        Self::immediate(build_event(
            "DOM.characterDataModified",
            json!({
                "nodeId": node_id,
                "characterData": character_data,
            }),
            session_id,
        ))
    }

    pub(crate) fn dom_child_node_count_updated(
        session_id: Option<&str>,
        node_id: u32,
        child_node_count: usize,
    ) -> Self {
        Self::immediate(build_event(
            "DOM.childNodeCountUpdated",
            json!({
                "nodeId": node_id,
                "childNodeCount": child_node_count,
            }),
            session_id,
        ))
    }

    pub(crate) fn dom_child_node_inserted(
        session_id: Option<&str>,
        parent_node_id: u32,
        previous_node_id: u32,
        node: Value,
    ) -> Self {
        Self::immediate(build_event(
            "DOM.childNodeInserted",
            json!({
                "parentNodeId": parent_node_id,
                "previousNodeId": previous_node_id,
                "node": node,
            }),
            session_id,
        ))
    }

    pub(crate) fn dom_child_node_removed(
        session_id: Option<&str>,
        parent_node_id: u32,
        node_id: u32,
    ) -> Self {
        Self::immediate(build_event(
            "DOM.childNodeRemoved",
            json!({
                "parentNodeId": parent_node_id,
                "nodeId": node_id,
            }),
            session_id,
        ))
    }

    pub(crate) fn page_navigation_frame(
        session_id: Option<&str>,
        event: NavigationFrameEvent,
    ) -> Self {
        Self::wrap_page_navigation_frame_event(Box::new(BackgroundPageNavigationFrameEvent {
            session_id: session_id.map(str::to_owned),
            event,
            unreachable_url: None,
        }))
    }

    pub(crate) fn page_navigation_frame_with_unreachable_url(
        session_id: Option<&str>,
        event: NavigationFrameEvent,
        unreachable_url: impl Into<String>,
    ) -> Self {
        Self::wrap_page_navigation_frame_event(Box::new(BackgroundPageNavigationFrameEvent {
            session_id: session_id.map(str::to_owned),
            event,
            unreachable_url: Some(unreachable_url.into()),
        }))
    }

    #[allow(clippy::too_many_arguments)]
    pub(crate) fn page_document_opened(
        session_id: Option<&str>,
        frame_id: impl Into<String>,
        parent_frame_id: Option<String>,
        loader_id: impl Into<String>,
        url: impl Into<String>,
        frame_name: Option<String>,
        security_origin: impl Into<String>,
        secure_context_type: impl Into<String>,
    ) -> Self {
        Self::wrap_page_document_opened_event(Box::new(BackgroundPageDocumentOpenedEvent {
            session_id: session_id.map(str::to_owned),
            frame_id: frame_id.into(),
            parent_frame_id,
            loader_id: loader_id.into(),
            url: url.into(),
            frame_name,
            security_origin: security_origin.into(),
            secure_context_type: secure_context_type.into(),
        }))
    }

    pub(crate) fn page_dom_content_loaded(
        session_id: Option<&str>,
        event: NavigationLifecycleEvent,
    ) -> Self {
        Self::wrap_page_dom_content_loaded(Box::new(BackgroundNavigationLifecycleEvent {
            session_id: session_id.map(str::to_owned),
            event,
            renderer_document: None,
            renderer_epoch: None,
        }))
    }

    pub(crate) fn page_load_for_renderer_document(
        session_id: Option<&str>,
        event: NavigationLifecycleEvent,
        renderer_document: RendererDocumentToken,
        renderer_epoch: RendererLifecycleEpoch,
    ) -> Self {
        Self::wrap_page_load_event(Box::new(BackgroundNavigationLifecycleEvent {
            session_id: session_id.map(str::to_owned),
            event,
            renderer_document: Some(renderer_document),
            renderer_epoch: Some(renderer_epoch),
        }))
    }

    pub(crate) fn page_lifecycle(session_id: Option<&str>, event: PageLifecycleEvent) -> Self {
        Self::wrap_page_lifecycle_event(Box::new(BackgroundPageLifecycleEvent {
            session_id: session_id.map(str::to_owned),
            event,
        }))
    }

    pub(crate) fn page_same_document_navigation(
        session_id: Option<&str>,
        event: SameDocumentNavigationEvent,
    ) -> Self {
        Self::wrap_page_same_document_navigation_event(Box::new(
            BackgroundSameDocumentNavigationEvent {
                session_id: session_id.map(str::to_owned),
                event,
            },
        ))
    }

    pub(crate) fn page_frame_attached(
        session_id: Option<&str>,
        frame_id: impl Into<String>,
        parent_frame_id: impl Into<String>,
    ) -> Self {
        Self::wrap_page_frame_attached_event(Box::new(BackgroundPageFrameAttachedEvent {
            session_id: session_id.map(str::to_owned),
            frame_id: frame_id.into(),
            parent_frame_id: parent_frame_id.into(),
        }))
    }

    pub(crate) fn page_frame_detached(
        session_id: Option<&str>,
        frame_id: impl Into<String>,
    ) -> Self {
        Self::wrap_page_frame_detached_event(Box::new(BackgroundPageFrameDetachedEvent {
            session_id: session_id.map(str::to_owned),
            frame_id: frame_id.into(),
        }))
    }

    pub(crate) fn page_file_chooser_opened(
        session_id: Option<&str>,
        frame_id: &str,
        mode: &str,
        backend_node_id: u32,
        element_shared_id: Option<DevToolsRemoteHandleId>,
    ) -> Self {
        Self::wrap_page_file_chooser_opened_event(Box::new(BackgroundPageFileChooserOpenedEvent {
            session_id: session_id.map(str::to_owned),
            frame_id: frame_id.to_owned(),
            mode: mode.to_owned(),
            backend_node_id,
            element_shared_id,
        }))
    }

    pub(crate) fn browser_download_will_begin(
        session_id: Option<&str>,
        subscription_generation: Option<u64>,
        frame_id: &str,
        guid: &str,
        url: &str,
        suggested_filename: &str,
    ) -> Self {
        let event = Self::wrap_browser_download_will_begin_event(Box::new(
            BackgroundBrowserDownloadWillBeginEvent {
                session_id: session_id.map(str::to_owned),
                frame_id: frame_id.to_owned(),
                guid: guid.to_owned(),
                url: url.to_owned(),
                suggested_filename: suggested_filename.to_owned(),
            },
        ));
        if let Some(generation) = subscription_generation {
            event.bind_to_browser_download_subscription_route(session_id, generation)
        } else {
            event
        }
    }

    pub(crate) fn browser_download_progress(
        session_id: Option<&str>,
        subscription_generation: Option<u64>,
        guid: &str,
        state: &str,
        received_bytes: u64,
        total_bytes: u64,
        file_path: Option<&str>,
    ) -> Self {
        let event = Self::wrap_browser_download_progress_event(Box::new(
            BackgroundBrowserDownloadProgressEvent {
                session_id: session_id.map(str::to_owned),
                guid: guid.to_owned(),
                state: state.to_owned(),
                received_bytes,
                total_bytes,
                file_path: file_path.map(str::to_owned),
            },
        ));
        if let Some(generation) = subscription_generation {
            event.bind_to_browser_download_subscription_route(session_id, generation)
        } else {
            event
        }
    }

    pub(crate) fn automation_download_will_begin(
        frame_id: &str,
        guid: &str,
        url: &str,
        suggested_filename: &str,
    ) -> Self {
        Self::automation_only(AutomationEvent::BrowserDownloadWillBegin(
            BrowserDownloadWillBeginEvent {
                frame_id: DevToolsFrameId::from(frame_id),
                guid: guid.to_owned(),
                url: url.to_owned(),
                suggested_filename: suggested_filename.to_owned(),
            },
        ))
    }

    pub(crate) fn automation_download_progress(
        guid: &str,
        state: &str,
        received_bytes: u64,
        total_bytes: u64,
        file_path: Option<&str>,
    ) -> Self {
        Self::automation_only(AutomationEvent::BrowserDownloadProgress(
            BrowserDownloadProgressEvent {
                guid: guid.to_owned(),
                state: state.to_owned(),
                received_bytes,
                total_bytes,
                file_path: file_path.map(str::to_owned),
            },
        ))
    }

    pub(crate) fn page_javascript_dialog_opening(
        session_id: Option<&str>,
        event: PageJavaScriptDialogOpeningEvent,
    ) -> Self {
        Self::wrap_page_javascript_dialog_opening_event(Box::new(
            BackgroundPageJavaScriptDialogOpeningEvent {
                session_id: session_id.map(str::to_owned),
                frame_id: event.frame_id.as_ref().map(|id| id.as_str().to_owned()),
                url: event.url,
                message: event.message,
                dialog_type: event.dialog_type,
                has_browser_handler: event.has_browser_handler,
                default_prompt: event.default_prompt,
            },
        ))
    }

    pub(crate) fn page_javascript_dialog_closed(
        session_id: Option<&str>,
        event: UserPromptClosedEvent,
    ) -> Self {
        Self::wrap_page_javascript_dialog_closed_event(Box::new(
            BackgroundPageJavaScriptDialogClosedEvent {
                session_id: session_id.map(str::to_owned),
                target_id: event.target_id.as_ref().map(|id| id.as_str().to_owned()),
                frame_id: event.frame_id.as_str().to_owned(),
                prompt_type: event.prompt_type,
                accepted: event.accepted,
                user_text: event.user_text,
            },
        ))
    }

    pub(crate) fn page_screencast_visibility_changed(
        session_id: Option<&str>,
        visible: bool,
    ) -> Self {
        Self::wrap_page_screencast_visibility_changed_event(Box::new(
            BackgroundPageScreencastVisibilityChangedEvent {
                session_id: session_id.map(str::to_owned),
                visible,
            },
        ))
    }

    pub(crate) fn page_screencast_frame(
        session_id: Option<&str>,
        data: String,
        metadata: PageScreencastFrameMetadata,
        generation: i32,
    ) -> Self {
        Self::wrap_page_screencast_frame_event(Box::new(BackgroundPageScreencastFrameEvent {
            session_id: session_id.map(str::to_owned),
            data,
            metadata,
            generation,
        }))
    }

    pub(crate) fn page_window_open(
        session_id: Option<&str>,
        url: &str,
        window_name: &str,
        window_features: &[String],
        user_gesture: bool,
    ) -> Self {
        Self::immediate(build_event(
            "Page.windowOpen",
            json!({
                "url": url,
                "windowName": window_name,
                "windowFeatures": window_features,
                "userGesture": user_gesture,
            }),
            session_id,
        ))
    }

    pub(crate) fn inspector_target_crashed(session_id: Option<&str>) -> Self {
        Self::wrap_inspector_target_crashed_event(Box::new(BackgroundInspectorTargetCrashedEvent {
            session_id: session_id.map(str::to_owned),
        }))
    }

    pub(crate) fn inspector_target_reloaded_after_crash(session_id: Option<&str>) -> Self {
        Self::wrap_inspector_target_reloaded_after_crash_event(Box::new(
            BackgroundInspectorTargetReloadedAfterCrashEvent {
                session_id: session_id.map(str::to_owned),
            },
        ))
    }

    pub(crate) fn inspector_detached(session_id: Option<&str>, reason: impl Into<String>) -> Self {
        Self::wrap_inspector_detached_event(Box::new(BackgroundInspectorDetachedEvent {
            session_id: session_id.map(str::to_owned),
            reason: reason.into(),
        }))
    }

    pub(crate) fn service_worker_registration_updated(
        session_id: Option<&str>,
        registrations: Vec<BackgroundServiceWorkerRegistration>,
    ) -> Self {
        Self::wrap_service_worker_registration_updated_event(Box::new(
            BackgroundServiceWorkerRegistrationUpdatedEvent {
                session_id: session_id.map(str::to_owned),
                registrations,
            },
        ))
    }

    pub(crate) fn service_worker_version_updated(
        session_id: Option<&str>,
        versions: Vec<BackgroundServiceWorkerVersion>,
    ) -> Self {
        Self::wrap_service_worker_version_updated_event(Box::new(
            BackgroundServiceWorkerVersionUpdatedEvent {
                session_id: session_id.map(str::to_owned),
                versions,
            },
        ))
    }

    pub(crate) fn service_worker_error_reported(
        session_id: Option<&str>,
        error_message: BackgroundServiceWorkerErrorMessage,
    ) -> Self {
        Self::wrap_service_worker_error_reported_event(Box::new(
            BackgroundServiceWorkerErrorReportedEvent {
                session_id: session_id.map(str::to_owned),
                error_message,
            },
        ))
    }

    pub(crate) fn target_info_changed(
        session_id: Option<&str>,
        target_info: DevToolsTargetInfo,
    ) -> Self {
        Self::wrap_target_info_changed_event(Box::new(BackgroundTargetInfoChangedEvent {
            session_id: session_id.map(str::to_owned),
            target_info,
        }))
    }

    pub(crate) fn target_created(session_id: Option<&str>, event: TargetLifecycleEvent) -> Self {
        Self::wrap_target_created_event(Box::new(BackgroundTargetCreatedEvent {
            session_id: session_id.map(str::to_owned),
            event,
        }))
    }

    pub(crate) fn target_attached(event: TargetAttachmentEvent) -> Self {
        Self::wrap_target_attached_event(Box::new(BackgroundTargetAttachedEvent { event }))
    }

    pub(crate) fn target_detached(event: TargetDetachmentEvent) -> Self {
        Self::wrap_target_detached_event(Box::new(BackgroundTargetDetachedEvent { event }))
    }

    pub(crate) fn target_destroyed(session_id: Option<&str>, event: TargetLifecycleEvent) -> Self {
        Self::wrap_target_destroyed_event(Box::new(BackgroundTargetDestroyedEvent {
            session_id: session_id.map(str::to_owned),
            event,
        }))
    }

    pub(crate) fn target_crashed(
        session_id: Option<&str>,
        target_id: impl Into<String>,
        status: impl Into<String>,
        error_code: i32,
    ) -> Self {
        Self::wrap_target_crashed_event(Box::new(BackgroundTargetCrashedEvent {
            session_id: session_id.map(str::to_owned),
            target_id: target_id.into(),
            status: status.into(),
            error_code,
        }))
    }

    pub(crate) fn target_received_message_from_target(
        target_session_id: impl Into<String>,
        nested_event: BackgroundProtocolEvent,
    ) -> Self {
        Self::wrap_target_received_message_from_target_event(Box::new(
            BackgroundTargetReceivedMessageFromTargetEvent {
                target_session_id: target_session_id.into(),
                nested_event: Box::new(nested_event),
            },
        ))
    }

    pub(crate) fn ensure_protocol_session_id(&mut self, session_id: Option<&str>) {
        let Some(session_id) = session_id else {
            return;
        };
        match &mut self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => {
                if event.message.get("sessionId").is_none() {
                    event.message["sessionId"] = json!(session_id);
                }
            }
            BackgroundProtocolEventPayload::CommandResponse(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::ConsoleMessageAdded(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::LogEntryAdded(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::RuntimeExceptionThrown(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::RuntimeBindingCalled(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(event)
            | BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::DomSetChildNodes(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageNavigationFrame(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageDocumentOpened(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageDomContentLoaded(event)
            | BackgroundProtocolEventPayload::PageLoad(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageLifecycle(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageSameDocumentNavigation(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageFrameAttached(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageFrameDetached(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageFileChooserOpened(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::BrowserDownloadProgress(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageScreencastFrame(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::InspectorTargetCrashed(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::InspectorDetached(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::ServiceWorkerErrorReported(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::TargetInfoChanged(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::TargetCreated(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::TargetAttached(event) => {
                if event.event.parent_session_id.is_none() {
                    event.event.parent_session_id = Some(session_id.into());
                }
            }
            BackgroundProtocolEventPayload::TargetDetached(event) => {
                if event.event.parent_session_id.is_none() {
                    event.event.parent_session_id = Some(session_id.into());
                }
            }
            BackgroundProtocolEventPayload::TargetDestroyed(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::TargetCrashed(event) => {
                if event.session_id.is_none() {
                    event.session_id = Some(session_id.to_owned());
                }
            }
            BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(_) => {}
            BackgroundProtocolEventPayload::AutomationOnly(_)
            | BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => {}
        }
        self.route.ensure_wire_session_id(session_id);
    }

    pub fn should_wait_for_background_navigation_completion(&self) -> bool {
        self.is_non_document_network_event() && !self.is_fetch_interception_control_path_event()
    }

    pub fn is_non_document_network_event(&self) -> bool {
        let Some(resource_type) = self.network_resource_type() else {
            return false;
        };
        resource_type != DevToolsNetworkResourceType::Document
    }

    /// Returns whether this event is an already-produced CDP Network-domain
    /// observation.
    ///
    /// Main-document load scheduling may delay Page-side effects produced by
    /// a timer, but it must not delay network facts that Chromium exposes as
    /// soon as they occur. This classification uses the typed protocol method
    /// rather than a renderer wake source, because one renderer publication
    /// can contain both kinds of output.
    pub fn is_network_protocol_observation(&self) -> bool {
        self.protocol_method()
            .is_some_and(|method| method.starts_with("Network."))
    }

    pub fn is_document_network_response_started(&self) -> bool {
        let Some(message) = self.protocol_message() else {
            return false;
        };
        message.get("method").and_then(Value::as_str) == Some("Network.responseReceived")
            && self.network_resource_type() == Some(DevToolsNetworkResourceType::Document)
    }

    pub fn trace_network_summary(
        &self,
    ) -> Option<(&str, Option<&str>, Option<&str>, Option<&str>)> {
        match &self.payload {
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(event) => {
                return Some((
                    "Network.requestWillBeSentExtraInfo",
                    None,
                    Some(event.request_id.as_str()),
                    None,
                ));
            }
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(event) => {
                return Some((
                    "Network.responseReceivedExtraInfo",
                    None,
                    Some(event.request_id.as_str()),
                    None,
                ));
            }
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(event) => {
                return Some((
                    "Network.webSocketCreated",
                    Some("WebSocket"),
                    Some(event.request_id.as_str()),
                    Some(event.url.as_str()),
                ));
            }
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(event) => {
                return Some((
                    "Network.webSocketWillSendHandshakeRequest",
                    Some("WebSocket"),
                    Some(event.request_id.as_str()),
                    None,
                ));
            }
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(event) => {
                return Some((
                    "Network.webSocketHandshakeResponseReceived",
                    Some("WebSocket"),
                    Some(event.request_id.as_str()),
                    None,
                ));
            }
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(event) => {
                return Some((
                    network_websocket_frame_protocol_method(event.direction),
                    Some("WebSocket"),
                    Some(event.request_id.as_str()),
                    None,
                ));
            }
            _ => {}
        }
        let message = self.protocol_message()?;
        let method = message.get("method")?.as_str()?;
        if !method.starts_with("Network.") && !method.starts_with("Fetch.") {
            return None;
        }
        let params = message.get("params")?;
        let request_id = params
            .get("requestId")
            .or_else(|| params.get("networkId"))
            .and_then(Value::as_str);
        let url = params
            .pointer("/request/url")
            .or_else(|| params.pointer("/response/url"))
            .or_else(|| params.get("documentURL"))
            .and_then(Value::as_str);
        Some((
            method,
            self.network_resource_type()
                .map(DevToolsNetworkResourceType::as_cdp_type),
            request_id,
            url,
        ))
    }

    fn is_fetch_interception_control_path_event(&self) -> bool {
        match self.protocol_method() {
            Some("Fetch.requestPaused" | "Fetch.authRequired") => true,
            Some(method) if method.starts_with("Network.") => self.has_blocked_intercepts(),
            _ => false,
        }
    }

    fn has_blocked_intercepts(&self) -> bool {
        self.automation_event_has_blocked_intercepts()
            || self.protocol_message_has_blocked_intercepts()
    }

    fn automation_event_has_blocked_intercepts(&self) -> bool {
        let BackgroundProtocolEventPayload::Protocol(event) = &self.payload else {
            return false;
        };
        match event.automation_event.as_deref() {
            Some(
                AutomationEvent::NetworkBeforeRequestSent(event)
                | AutomationEvent::NetworkResponseStarted(event)
                | AutomationEvent::NetworkResponseCompleted(event)
                | AutomationEvent::NetworkFetchError(event)
                | AutomationEvent::NetworkAuthRequired(event)
                | AutomationEvent::RequestPaused(event),
            ) => !event.blocked_intercepts.is_empty(),
            _ => false,
        }
    }

    fn protocol_message_has_blocked_intercepts(&self) -> bool {
        self.protocol_message()
            .and_then(|message| message.get("params"))
            .and_then(|params| params.get("__moliBlockedInterceptors"))
            .and_then(Value::as_array)
            .is_some_and(|blocked_intercepts| !blocked_intercepts.is_empty())
    }

    fn network_resource_type(&self) -> Option<DevToolsNetworkResourceType> {
        if let Some(resource_type) = self.automation_event_network_resource_type() {
            return Some(resource_type);
        }
        self.protocol_message_network_resource_type()
    }

    fn automation_event_network_resource_type(&self) -> Option<DevToolsNetworkResourceType> {
        let BackgroundProtocolEventPayload::Protocol(event) = &self.payload else {
            return None;
        };
        match event.automation_event.as_deref()? {
            AutomationEvent::NetworkBeforeRequestSent(event)
            | AutomationEvent::NetworkResponseStarted(event)
            | AutomationEvent::NetworkResponseCompleted(event)
            | AutomationEvent::NetworkFetchError(event)
            | AutomationEvent::NetworkAuthRequired(event)
            | AutomationEvent::RequestPaused(event) => event.resource_type,
            _ => None,
        }
    }

    fn protocol_message_network_resource_type(&self) -> Option<DevToolsNetworkResourceType> {
        let message = self.protocol_message()?;
        let method = message.get("method")?.as_str()?;
        let params = message.get("params")?;
        match method {
            "Network.requestWillBeSent" | "Network.responseReceived" | "Network.loadingFailed" => {
                params
                    .get("type")?
                    .as_str()
                    .and_then(DevToolsNetworkResourceType::from_cdp_type)
            }
            "Network.webSocketFrameError" | "Network.webSocketClosed" => {
                Some(DevToolsNetworkResourceType::WebSocket)
            }
            "Fetch.requestPaused" | "Fetch.authRequired" => params
                .get("resourceType")?
                .as_str()
                .and_then(DevToolsNetworkResourceType::from_cdp_type),
            _ => None,
        }
    }

    pub fn into_protocol_message(self) -> Value {
        match self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => {
                strip_moli_private_protocol_fields(event.message)
            }
            BackgroundProtocolEventPayload::CommandResponse(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::ConsoleMessageAdded(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::LogEntryAdded(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::RuntimeExceptionThrown(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::RuntimeBindingCalled(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(event) => {
                (*event).into_context_created_protocol_message()
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(event) => {
                (*event).into_context_destroyed_protocol_message()
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::DomSetChildNodes(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageNavigationFrame(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageDocumentOpened(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageDomContentLoaded(event) => {
                (*event).into_dom_content_loaded_protocol_message()
            }
            BackgroundProtocolEventPayload::PageLoad(event) => {
                (*event).into_load_protocol_message()
            }
            BackgroundProtocolEventPayload::PageLifecycle(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageSameDocumentNavigation(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageFrameAttached(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageFrameDetached(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageFileChooserOpened(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::BrowserDownloadProgress(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageScreencastFrame(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::InspectorTargetCrashed(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::InspectorDetached(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::ServiceWorkerErrorReported(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetInfoChanged(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetCreated(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetAttached(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetDetached(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetDestroyed(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetCrashed(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(event) => {
                (*event).into_protocol_message()
            }
            BackgroundProtocolEventPayload::AutomationOnly(_) => json!({
                "error": {
                    "code": -32000,
                    "message": "InternalAutomationOnlyEventNotRouted",
                },
            }),
            BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => json!({
                "error": {
                    "code": -32000,
                    "message": "InternalRuntimeInspectorResponseReadyNotRouted",
                },
            }),
        }
    }

    pub fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        match self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => (
                event.message,
                event
                    .automation_event
                    .map(|automation_event| *automation_event),
            ),
            BackgroundProtocolEventPayload::CommandResponse(event) => {
                ((*event).into_protocol_message(), None)
            }
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::ConsoleMessageAdded(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::LogEntryAdded(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::RuntimeExceptionThrown(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::RuntimeBindingCalled(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(event) => {
                (*event).into_context_created_parts()
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(event) => {
                (*event).into_context_destroyed_parts()
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::DomSetChildNodes(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageNavigationFrame(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageDocumentOpened(event) => {
                ((*event).into_protocol_message(), None)
            }
            BackgroundProtocolEventPayload::PageDomContentLoaded(event) => {
                (*event).into_dom_content_loaded_parts()
            }
            BackgroundProtocolEventPayload::PageLoad(event) => (*event).into_load_parts(),
            BackgroundProtocolEventPayload::PageLifecycle(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageSameDocumentNavigation(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::PageFrameAttached(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageFrameDetached(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageFileChooserOpened(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::BrowserDownloadProgress(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::PageScreencastFrame(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::InspectorTargetCrashed(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::InspectorDetached(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::ServiceWorkerErrorReported(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::TargetInfoChanged(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::TargetCreated(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::TargetAttached(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::TargetDetached(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::TargetDestroyed(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::TargetCrashed(event) => (*event).into_parts(),
            BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(event) => {
                (*event).into_parts()
            }
            BackgroundProtocolEventPayload::AutomationOnly(event) => (
                json!({
                    "method": "Moli.automationOnly",
                    "params": {},
                }),
                Some(*event),
            ),
            BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => (
                json!({
                    "error": {
                        "code": -32000,
                        "message": "InternalRuntimeInspectorResponseReadyNotRouted",
                    },
                }),
                None,
            ),
        }
    }

    pub fn take_runtime_inspector_response_ready(
        self,
    ) -> Result<RuntimeInspectorResponseReady, Self> {
        let Self { payload, route } = self;
        match payload {
            BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(response) => {
                Ok(*response)
            }
            payload => Err(Self { payload, route }),
        }
    }

    #[cfg(test)]
    pub(crate) fn as_runtime_inspector_response_ready(
        &self,
    ) -> Option<&RuntimeInspectorResponseReady> {
        match &self.payload {
            BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(response) => {
                Some(response)
            }
            _ => None,
        }
    }

    #[cfg(test)]
    pub(crate) fn is_target_detached(&self) -> bool {
        matches!(
            &self.payload,
            BackgroundProtocolEventPayload::TargetDetached(_)
        )
    }

    pub fn protocol_message(&self) -> Option<&Value> {
        match &self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => Some(&event.message),
            BackgroundProtocolEventPayload::CommandResponse(_) => None,
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(_) => None,
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(_) => None,
            BackgroundProtocolEventPayload::ConsoleMessageAdded(_) => None,
            BackgroundProtocolEventPayload::LogEntryAdded(_) => None,
            BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(_) => None,
            BackgroundProtocolEventPayload::RuntimeExceptionThrown(_) => None,
            BackgroundProtocolEventPayload::RuntimeBindingCalled(_) => None,
            BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(_) => None,
            BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(_) => None,
            BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(_) => None,
            BackgroundProtocolEventPayload::DomSetChildNodes(_) => None,
            BackgroundProtocolEventPayload::PageNavigationFrame(_) => None,
            BackgroundProtocolEventPayload::PageDocumentOpened(_) => None,
            BackgroundProtocolEventPayload::PageDomContentLoaded(_) => None,
            BackgroundProtocolEventPayload::PageLoad(_) => None,
            BackgroundProtocolEventPayload::PageLifecycle(_) => None,
            BackgroundProtocolEventPayload::PageSameDocumentNavigation(_) => None,
            BackgroundProtocolEventPayload::PageFrameAttached(_) => None,
            BackgroundProtocolEventPayload::PageFrameDetached(_) => None,
            BackgroundProtocolEventPayload::PageFileChooserOpened(_) => None,
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(_) => None,
            BackgroundProtocolEventPayload::BrowserDownloadProgress(_) => None,
            BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(_) => None,
            BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(_) => None,
            BackgroundProtocolEventPayload::PageScreencastFrame(_) => None,
            BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(_) => None,
            BackgroundProtocolEventPayload::InspectorTargetCrashed(_) => None,
            BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(_) => None,
            BackgroundProtocolEventPayload::InspectorDetached(_) => None,
            BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(_) => None,
            BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(_) => None,
            BackgroundProtocolEventPayload::ServiceWorkerErrorReported(_) => None,
            BackgroundProtocolEventPayload::TargetInfoChanged(_) => None,
            BackgroundProtocolEventPayload::TargetCreated(_) => None,
            BackgroundProtocolEventPayload::TargetAttached(_) => None,
            BackgroundProtocolEventPayload::TargetDetached(_) => None,
            BackgroundProtocolEventPayload::TargetDestroyed(_) => None,
            BackgroundProtocolEventPayload::TargetCrashed(_) => None,
            BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(_) => None,
            BackgroundProtocolEventPayload::AutomationOnly(_) => None,
            BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => None,
        }
    }

    pub fn protocol_method(&self) -> Option<&str> {
        match &self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => {
                event.message.get("method").and_then(Value::as_str)
            }
            BackgroundProtocolEventPayload::CommandResponse(_) => None,
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(_) => {
                Some("Network.requestWillBeSentExtraInfo")
            }
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(_) => {
                Some("Network.responseReceivedExtraInfo")
            }
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(_) => {
                Some("Network.webSocketCreated")
            }
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(_) => {
                Some("Network.webSocketWillSendHandshakeRequest")
            }
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(_) => {
                Some("Network.webSocketHandshakeResponseReceived")
            }
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(event) => {
                Some(network_websocket_frame_protocol_method(event.direction))
            }
            BackgroundProtocolEventPayload::ConsoleMessageAdded(_) => Some("Console.messageAdded"),
            BackgroundProtocolEventPayload::LogEntryAdded(_) => Some("Log.entryAdded"),
            BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(_) => {
                Some("Runtime.consoleAPICalled")
            }
            BackgroundProtocolEventPayload::RuntimeExceptionThrown(_) => {
                Some("Runtime.exceptionThrown")
            }
            BackgroundProtocolEventPayload::RuntimeBindingCalled(_) => {
                Some("Runtime.bindingCalled")
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(_) => {
                Some("Runtime.executionContextCreated")
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(_) => {
                Some("Runtime.executionContextDestroyed")
            }
            BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(_) => {
                Some("Runtime.executionContextsCleared")
            }
            BackgroundProtocolEventPayload::DomSetChildNodes(_) => Some("DOM.setChildNodes"),
            BackgroundProtocolEventPayload::PageNavigationFrame(event) => {
                Some(navigation_frame_protocol_method(event.event.kind))
            }
            BackgroundProtocolEventPayload::PageDocumentOpened(_) => Some("Page.documentOpened"),
            BackgroundProtocolEventPayload::PageDomContentLoaded(_) => {
                Some("Page.domContentEventFired")
            }
            BackgroundProtocolEventPayload::PageLoad(_) => Some("Page.loadEventFired"),
            BackgroundProtocolEventPayload::PageLifecycle(_) => Some("Page.lifecycleEvent"),
            BackgroundProtocolEventPayload::PageSameDocumentNavigation(_) => {
                Some("Page.navigatedWithinDocument")
            }
            BackgroundProtocolEventPayload::PageFrameAttached(_) => Some("Page.frameAttached"),
            BackgroundProtocolEventPayload::PageFrameDetached(_) => Some("Page.frameDetached"),
            BackgroundProtocolEventPayload::PageFileChooserOpened(_) => {
                Some("Page.fileChooserOpened")
            }
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(_) => {
                Some("Browser.downloadWillBegin")
            }
            BackgroundProtocolEventPayload::BrowserDownloadProgress(_) => {
                Some("Browser.downloadProgress")
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(_) => {
                Some("Page.javascriptDialogOpening")
            }
            BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(_) => {
                Some("Page.javascriptDialogClosed")
            }
            BackgroundProtocolEventPayload::PageScreencastFrame(_) => Some("Page.screencastFrame"),
            BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(_) => {
                Some("Page.screencastVisibilityChanged")
            }
            BackgroundProtocolEventPayload::InspectorTargetCrashed(_) => {
                Some("Inspector.targetCrashed")
            }
            BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(_) => {
                Some("Inspector.targetReloadedAfterCrash")
            }
            BackgroundProtocolEventPayload::InspectorDetached(_) => Some("Inspector.detached"),
            BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(_) => {
                Some("ServiceWorker.workerRegistrationUpdated")
            }
            BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(_) => {
                Some("ServiceWorker.workerVersionUpdated")
            }
            BackgroundProtocolEventPayload::ServiceWorkerErrorReported(_) => {
                Some("ServiceWorker.workerErrorReported")
            }
            BackgroundProtocolEventPayload::TargetInfoChanged(_) => {
                Some("Target.targetInfoChanged")
            }
            BackgroundProtocolEventPayload::TargetCreated(_) => Some("Target.targetCreated"),
            BackgroundProtocolEventPayload::TargetAttached(_) => Some("Target.attachedToTarget"),
            BackgroundProtocolEventPayload::TargetDetached(_) => Some("Target.detachedFromTarget"),
            BackgroundProtocolEventPayload::TargetDestroyed(_) => Some("Target.targetDestroyed"),
            BackgroundProtocolEventPayload::TargetCrashed(_) => Some("Target.targetCrashed"),
            BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(_) => {
                Some("Target.receivedMessageFromTarget")
            }
            BackgroundProtocolEventPayload::AutomationOnly(_)
            | BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => None,
        }
    }

    pub fn matches_document_load_wait_key(&self, key: &DevToolsDocumentLifecycleWaitKey) -> bool {
        let BackgroundProtocolEventPayload::PageLoad(event) = &self.payload else {
            return false;
        };
        event.renderer_document == Some(key.renderer_document)
            && event.renderer_epoch == Some(key.renderer_epoch)
            && event.event.frame_id.as_str() == key.frame_id
            && event
                .event
                .loader_id
                .as_ref()
                .map(|loader_id| loader_id.as_str())
                == Some(key.loader_id.as_str())
    }

    pub fn download_will_begin_frame_id(&self) -> Option<&str> {
        match &self.payload {
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(event) => {
                Some(event.frame_id.as_str())
            }
            BackgroundProtocolEventPayload::Protocol(event) => {
                match event.automation_event.as_deref() {
                    Some(AutomationEvent::BrowserDownloadWillBegin(event)) => {
                        Some(event.frame_id.as_str())
                    }
                    _ => None,
                }
            }
            BackgroundProtocolEventPayload::AutomationOnly(event) => match event.as_ref() {
                AutomationEvent::BrowserDownloadWillBegin(event) => Some(event.frame_id.as_str()),
                _ => None,
            },
            _ => None,
        }
    }

    pub fn protocol_message_id(&self) -> Option<u64> {
        match &self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => {
                event.message.get("id").and_then(Value::as_u64)
            }
            BackgroundProtocolEventPayload::CommandResponse(event) => event.command_id,
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(_)
            | BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(_)
            | BackgroundProtocolEventPayload::NetworkWebSocketCreated(_)
            | BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(_)
            | BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(_)
            | BackgroundProtocolEventPayload::NetworkWebSocketFrame(_)
            | BackgroundProtocolEventPayload::ConsoleMessageAdded(_)
            | BackgroundProtocolEventPayload::LogEntryAdded(_)
            | BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(_)
            | BackgroundProtocolEventPayload::RuntimeExceptionThrown(_)
            | BackgroundProtocolEventPayload::RuntimeBindingCalled(_)
            | BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(_)
            | BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(_)
            | BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(_)
            | BackgroundProtocolEventPayload::DomSetChildNodes(_)
            | BackgroundProtocolEventPayload::PageNavigationFrame(_)
            | BackgroundProtocolEventPayload::PageDocumentOpened(_)
            | BackgroundProtocolEventPayload::PageDomContentLoaded(_)
            | BackgroundProtocolEventPayload::PageLoad(_)
            | BackgroundProtocolEventPayload::PageLifecycle(_)
            | BackgroundProtocolEventPayload::PageSameDocumentNavigation(_)
            | BackgroundProtocolEventPayload::PageFrameAttached(_)
            | BackgroundProtocolEventPayload::PageFrameDetached(_)
            | BackgroundProtocolEventPayload::PageFileChooserOpened(_)
            | BackgroundProtocolEventPayload::BrowserDownloadWillBegin(_)
            | BackgroundProtocolEventPayload::BrowserDownloadProgress(_)
            | BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(_)
            | BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(_)
            | BackgroundProtocolEventPayload::PageScreencastFrame(_)
            | BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(_)
            | BackgroundProtocolEventPayload::InspectorTargetCrashed(_)
            | BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(_)
            | BackgroundProtocolEventPayload::InspectorDetached(_)
            | BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(_)
            | BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(_)
            | BackgroundProtocolEventPayload::ServiceWorkerErrorReported(_)
            | BackgroundProtocolEventPayload::TargetInfoChanged(_)
            | BackgroundProtocolEventPayload::TargetCreated(_)
            | BackgroundProtocolEventPayload::TargetAttached(_)
            | BackgroundProtocolEventPayload::TargetDetached(_)
            | BackgroundProtocolEventPayload::TargetDestroyed(_)
            | BackgroundProtocolEventPayload::TargetCrashed(_)
            | BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(_) => None,
            BackgroundProtocolEventPayload::AutomationOnly(_)
            | BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => None,
        }
    }

    pub fn has_protocol_wire_message(&self) -> bool {
        matches!(
            &self.payload,
            BackgroundProtocolEventPayload::Protocol(_)
                | BackgroundProtocolEventPayload::CommandResponse(_)
                | BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(_)
                | BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(_)
                | BackgroundProtocolEventPayload::NetworkWebSocketCreated(_)
                | BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(_)
                | BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(_)
                | BackgroundProtocolEventPayload::NetworkWebSocketFrame(_)
                | BackgroundProtocolEventPayload::ConsoleMessageAdded(_)
                | BackgroundProtocolEventPayload::LogEntryAdded(_)
                | BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(_)
                | BackgroundProtocolEventPayload::RuntimeExceptionThrown(_)
                | BackgroundProtocolEventPayload::RuntimeBindingCalled(_)
                | BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(_)
                | BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(_)
                | BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(_)
                | BackgroundProtocolEventPayload::DomSetChildNodes(_)
                | BackgroundProtocolEventPayload::PageNavigationFrame(_)
                | BackgroundProtocolEventPayload::PageDocumentOpened(_)
                | BackgroundProtocolEventPayload::PageDomContentLoaded(_)
                | BackgroundProtocolEventPayload::PageLoad(_)
                | BackgroundProtocolEventPayload::PageLifecycle(_)
                | BackgroundProtocolEventPayload::PageSameDocumentNavigation(_)
                | BackgroundProtocolEventPayload::PageFrameAttached(_)
                | BackgroundProtocolEventPayload::PageFrameDetached(_)
                | BackgroundProtocolEventPayload::PageFileChooserOpened(_)
                | BackgroundProtocolEventPayload::BrowserDownloadWillBegin(_)
                | BackgroundProtocolEventPayload::BrowserDownloadProgress(_)
                | BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(_)
                | BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(_)
                | BackgroundProtocolEventPayload::PageScreencastFrame(_)
                | BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(_)
                | BackgroundProtocolEventPayload::InspectorTargetCrashed(_)
                | BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(_)
                | BackgroundProtocolEventPayload::InspectorDetached(_)
                | BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(_)
                | BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(_)
                | BackgroundProtocolEventPayload::ServiceWorkerErrorReported(_)
                | BackgroundProtocolEventPayload::TargetInfoChanged(_)
                | BackgroundProtocolEventPayload::TargetCreated(_)
                | BackgroundProtocolEventPayload::TargetAttached(_)
                | BackgroundProtocolEventPayload::TargetDetached(_)
                | BackgroundProtocolEventPayload::TargetDestroyed(_)
                | BackgroundProtocolEventPayload::TargetCrashed(_)
                | BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(_)
        )
    }

    pub(crate) fn matches_console_message_added(
        &self,
        source: &str,
        level: &str,
        text: &str,
    ) -> bool {
        match &self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => {
                event.message["method"] == json!("Console.messageAdded")
                    && event.message["params"]["message"]["source"] == json!(source)
                    && event.message["params"]["message"]["level"] == json!(level)
                    && event.message["params"]["message"]["text"] == json!(text)
            }
            BackgroundProtocolEventPayload::ConsoleMessageAdded(event) => {
                event.source == source && event.level == level && event.text == text
            }
            _ => false,
        }
    }

    pub(crate) fn protocol_params_mut(&mut self) -> Option<&mut Value> {
        match &mut self.payload {
            BackgroundProtocolEventPayload::Protocol(event) => event.message.get_mut("params"),
            BackgroundProtocolEventPayload::CommandResponse(_) => None,
            BackgroundProtocolEventPayload::NetworkRequestWillBeSentExtraInfo(_) => None,
            BackgroundProtocolEventPayload::NetworkResponseReceivedExtraInfo(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketCreated(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketWillSendHandshakeRequest(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketHandshakeResponseReceived(_) => None,
            BackgroundProtocolEventPayload::NetworkWebSocketFrame(_) => None,
            BackgroundProtocolEventPayload::ConsoleMessageAdded(_) => None,
            BackgroundProtocolEventPayload::LogEntryAdded(_) => None,
            BackgroundProtocolEventPayload::RuntimeConsoleApiCalled(_) => None,
            BackgroundProtocolEventPayload::RuntimeExceptionThrown(_) => None,
            BackgroundProtocolEventPayload::RuntimeBindingCalled(_) => None,
            BackgroundProtocolEventPayload::RuntimeExecutionContextCreated(_) => None,
            BackgroundProtocolEventPayload::RuntimeExecutionContextDestroyed(_) => None,
            BackgroundProtocolEventPayload::RuntimeExecutionContextsCleared(_) => None,
            BackgroundProtocolEventPayload::DomSetChildNodes(_) => None,
            BackgroundProtocolEventPayload::PageNavigationFrame(_) => None,
            BackgroundProtocolEventPayload::PageDocumentOpened(_) => None,
            BackgroundProtocolEventPayload::PageDomContentLoaded(_) => None,
            BackgroundProtocolEventPayload::PageLoad(_) => None,
            BackgroundProtocolEventPayload::PageLifecycle(_) => None,
            BackgroundProtocolEventPayload::PageSameDocumentNavigation(_) => None,
            BackgroundProtocolEventPayload::PageFrameAttached(_) => None,
            BackgroundProtocolEventPayload::PageFrameDetached(_) => None,
            BackgroundProtocolEventPayload::PageFileChooserOpened(_) => None,
            BackgroundProtocolEventPayload::BrowserDownloadWillBegin(_) => None,
            BackgroundProtocolEventPayload::BrowserDownloadProgress(_) => None,
            BackgroundProtocolEventPayload::PageJavaScriptDialogOpening(_) => None,
            BackgroundProtocolEventPayload::PageJavaScriptDialogClosed(_) => None,
            BackgroundProtocolEventPayload::PageScreencastFrame(_) => None,
            BackgroundProtocolEventPayload::PageScreencastVisibilityChanged(_) => None,
            BackgroundProtocolEventPayload::InspectorTargetCrashed(_) => None,
            BackgroundProtocolEventPayload::InspectorTargetReloadedAfterCrash(_) => None,
            BackgroundProtocolEventPayload::InspectorDetached(_) => None,
            BackgroundProtocolEventPayload::ServiceWorkerRegistrationUpdated(_) => None,
            BackgroundProtocolEventPayload::ServiceWorkerVersionUpdated(_) => None,
            BackgroundProtocolEventPayload::ServiceWorkerErrorReported(_) => None,
            BackgroundProtocolEventPayload::TargetInfoChanged(_) => None,
            BackgroundProtocolEventPayload::TargetCreated(_) => None,
            BackgroundProtocolEventPayload::TargetAttached(_) => None,
            BackgroundProtocolEventPayload::TargetDetached(_) => None,
            BackgroundProtocolEventPayload::TargetDestroyed(_) => None,
            BackgroundProtocolEventPayload::TargetCrashed(_) => None,
            BackgroundProtocolEventPayload::TargetReceivedMessageFromTarget(_) => None,
            BackgroundProtocolEventPayload::AutomationOnly(_) => None,
            BackgroundProtocolEventPayload::RuntimeInspectorResponseReady(_) => None,
        }
    }
}

impl BackgroundCommandResponseEvent {
    fn into_protocol_message(self) -> Value {
        let mut message = match self.response {
            BackgroundCommandResponse::Success { result } => {
                return build_command_success_response(self.command_id, result, self.session_id);
            }
            BackgroundCommandResponse::Error {
                code,
                message,
                data,
            } => {
                let mut error = json!({ "code": code, "message": message });
                if let Some(data) = data {
                    error["data"] = data;
                }
                json!({ "id": self.command_id, "error": error })
            }
        };
        if let Some(session_id) = self.session_id {
            message["sessionId"] = json!(session_id);
        }
        message
    }
}

pub(crate) fn build_command_success_response(
    command_id: Option<u64>,
    result: Value,
    session_id: Option<String>,
) -> Value {
    let mut message = serde_json::Map::new();
    message.insert(
        "id".to_owned(),
        command_id.map(Value::from).unwrap_or(Value::Null),
    );
    message.insert("result".to_owned(), result);
    if let Some(session_id) = session_id {
        message.insert("sessionId".to_owned(), Value::String(session_id));
    }
    Value::Object(message)
}

impl BackgroundCommandResponsePayload {
    pub(crate) fn from_runtime_inspector_message(message: &Value) -> Self {
        if let Some(result) = message.get("result") {
            return Self::Success {
                result: result.clone(),
            };
        }
        if let Some(error) = message.get("error") {
            let code = error
                .get("code")
                .and_then(Value::as_i64)
                .and_then(|code| i32::try_from(code).ok())
                .unwrap_or(-32000);
            let message = error
                .get("message")
                .and_then(Value::as_str)
                .unwrap_or("Runtime inspector command failed")
                .to_owned();
            let data = error.get("data").cloned();
            return Self::Error {
                code,
                message,
                data,
            };
        }
        Self::internal_error("MissingDevToolsCommandResult")
    }

    pub(crate) fn from_owned_runtime_inspector_message(mut message: Value) -> Self {
        let Some(message) = message.as_object_mut() else {
            return Self::internal_error("MissingDevToolsCommandResult");
        };
        if let Some(result) = message.remove("result") {
            return Self::Success { result };
        }
        if let Some(error) = message.remove("error") {
            let Value::Object(mut error) = error else {
                return Self::Error {
                    code: -32000,
                    message: "Runtime inspector command failed".to_owned(),
                    data: None,
                };
            };
            let code = error
                .remove("code")
                .and_then(|code| code.as_i64())
                .and_then(|code| i32::try_from(code).ok())
                .unwrap_or(-32000);
            let message = error
                .remove("message")
                .and_then(|message| message.as_str().map(str::to_owned))
                .unwrap_or_else(|| "Runtime inspector command failed".to_owned());
            let data = error.remove("data");
            return Self::Error {
                code,
                message,
                data,
            };
        }
        Self::internal_error("MissingDevToolsCommandResult")
    }

    fn internal_error(message: impl Into<String>) -> Self {
        Self::Error {
            code: -32000,
            message: message.into(),
            data: None,
        }
    }
}

impl BackgroundCommandResponse {
    fn payload_ref(&self) -> BackgroundCommandResponsePayloadRef<'_> {
        match self {
            Self::Success { result } => BackgroundCommandResponsePayloadRef::Success { result },
            Self::Error {
                code,
                message,
                data,
            } => BackgroundCommandResponsePayloadRef::Error {
                code: *code,
                message,
                data: data.as_ref(),
            },
        }
    }

    fn into_payload(self) -> BackgroundCommandResponsePayload {
        match self {
            Self::Success { result } => BackgroundCommandResponsePayload::Success { result },
            Self::Error {
                code,
                message,
                data,
            } => BackgroundCommandResponsePayload::Error {
                code,
                message,
                data,
            },
        }
    }
}

impl BackgroundNetworkRequestWillBeSentExtraInfoEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Network.requestWillBeSentExtraInfo",
            json!({
                "requestId": self.request_id,
                "associatedCookies": self.associated_cookies,
                "headers": self.headers,
                "connectTiming": { "requestTime": self.request_time },
                "cookieAccessReport": self.cookie_access_report,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundNetworkResponseReceivedExtraInfoEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Network.responseReceivedExtraInfo",
            json!({
                "requestId": self.request_id,
                "blockedCookies": self.blocked_cookies,
                "headers": self.headers,
                "resourceIPAddressSpace": "Unknown",
                "statusCode": self.status_code,
                "cookieReports": self.cookie_reports,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundNetworkWebSocketCreatedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Network.webSocketCreated",
            json!({
                "requestId": self.request_id,
                "url": self.url,
                "initiator": { "type": "script" },
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundNetworkWebSocketWillSendHandshakeRequestEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Network.webSocketWillSendHandshakeRequest",
            json!({
                "requestId": self.request_id,
                "timestamp": self.timestamp,
                "wallTime": self.timestamp,
                "request": {
                    "headers": self.headers,
                },
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundNetworkWebSocketHandshakeResponseReceivedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Network.webSocketHandshakeResponseReceived",
            json!({
                "requestId": self.request_id,
                "timestamp": self.timestamp,
                "response": {
                    "status": self.status,
                    "statusText": self.status_text,
                    "headers": self.headers,
                },
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundNetworkWebSocketFrameEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            network_websocket_frame_protocol_method(self.direction),
            json!({
                "requestId": self.request_id,
                "timestamp": self.timestamp,
                "response": {
                    "opcode": websocket_frame_opcode_number(self.opcode),
                    "mask": false,
                    "payloadData": "",
                    "payloadLength": self.payload_length,
                },
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

fn network_websocket_frame_protocol_method(direction: WebSocketFrameDirection) -> &'static str {
    match direction {
        WebSocketFrameDirection::Sent => "Network.webSocketFrameSent",
        WebSocketFrameDirection::Received => "Network.webSocketFrameReceived",
    }
}

fn websocket_frame_opcode_number(opcode: WebSocketFrameOpcode) -> u8 {
    match opcode {
        WebSocketFrameOpcode::Text => 1,
        WebSocketFrameOpcode::Binary => 2,
    }
}

impl BackgroundRuntimeBindingCalledEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Runtime.bindingCalled",
            json!({
                "name": self.name,
                "payload": self.payload,
                "executionContextId": self.execution_context_id,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundRuntimeExecutionContextEvent {
    fn into_context_created_protocol_message(self) -> Value {
        build_event(
            "Runtime.executionContextCreated",
            runtime_context_created_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_context_created_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_context_created_protocol_message();
        (
            message,
            Some(AutomationEvent::RuntimeExecutionContextCreated(self.event)),
        )
    }

    fn into_context_destroyed_protocol_message(self) -> Value {
        build_event(
            "Runtime.executionContextDestroyed",
            runtime_context_destroyed_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_context_destroyed_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_context_destroyed_protocol_message();
        (
            message,
            Some(AutomationEvent::RuntimeExecutionContextDestroyed(
                self.event,
            )),
        )
    }
}

impl BackgroundRuntimeExecutionContextsClearedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Runtime.executionContextsCleared",
            runtime_contexts_cleared_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (
            message,
            Some(AutomationEvent::RuntimeExecutionContextsCleared(self.event)),
        )
    }
}

fn runtime_context_created_protocol_params(event: RuntimeExecutionContextEvent) -> Value {
    let mut aux_data = serde_json::Map::new();
    aux_data.insert(
        "isDefault".to_owned(),
        json!(event.is_default.unwrap_or(false)),
    );
    aux_data.insert(
        "type".to_owned(),
        json!(event.context_type.unwrap_or_else(|| "default".to_owned())),
    );
    if let Some(frame_id) = event.frame_id.as_ref() {
        aux_data.insert("frameId".to_owned(), json!(frame_id.as_str()));
    }
    if let Some(grant_universal_access) = event.grant_universal_access {
        aux_data.insert(
            "grantUniversalAccess".to_owned(),
            json!(grant_universal_access),
        );
    }
    json!({
        "context": {
            "id": event.context_id.unwrap_or_default(),
            "origin": event.origin.unwrap_or_default(),
            "name": event.name.unwrap_or_default(),
            "uniqueId": event.realm_id.as_ref().map(DevToolsRealmId::as_str).unwrap_or_default(),
            "auxData": Value::Object(aux_data),
        }
    })
}

fn runtime_context_destroyed_protocol_params(event: RuntimeExecutionContextEvent) -> Value {
    json!({
        "executionContextId": event.context_id.unwrap_or_default(),
        "executionContextUniqueId": event.realm_id.as_ref().map(DevToolsRealmId::as_str).unwrap_or_default(),
    })
}

fn runtime_contexts_cleared_protocol_params(_event: RuntimeExecutionContextsClearedEvent) -> Value {
    json!({})
}

impl BackgroundDomSetChildNodesEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "DOM.setChildNodes",
            json!({
                "parentId": self.parent_node_id,
                "nodes": self.nodes,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        let event = DomSetChildNodesEvent {
            parent_node_id: self.parent_node_id,
            nodes: self.nodes,
        };
        (message, Some(AutomationEvent::DomSetChildNodes(event)))
    }
}

impl BackgroundPageNavigationFrameEvent {
    fn into_protocol_message(self) -> Value {
        let Self {
            session_id,
            event,
            unreachable_url,
        } = self;
        build_event(
            navigation_frame_protocol_method(event.kind),
            navigation_frame_protocol_params(event, unreachable_url.as_deref()),
            session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::NavigationFrame(self.event)))
    }
}

impl BackgroundNavigationLifecycleEvent {
    fn into_dom_content_loaded_protocol_message(self) -> Value {
        build_event(
            "Page.domContentEventFired",
            navigation_lifecycle_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_dom_content_loaded_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_dom_content_loaded_protocol_message();
        (message, Some(AutomationEvent::DomContentLoaded(self.event)))
    }

    fn into_load_protocol_message(self) -> Value {
        build_event(
            "Page.loadEventFired",
            navigation_lifecycle_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_load_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_load_protocol_message();
        (message, Some(AutomationEvent::Load(self.event)))
    }
}

impl BackgroundPageLifecycleEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.lifecycleEvent",
            json!({
                "frameId": self.event.frame_id.as_str(),
                "loaderId": self.event.loader_id.as_str(),
                "name": self.event.name,
                "timestamp": self.event.timestamp,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::PageLifecycle(self.event)))
    }
}

impl BackgroundSameDocumentNavigationEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.navigatedWithinDocument",
            json!({
                "frameId": self.event.frame_id.as_str(),
                "url": self.event.url.as_str(),
                "navigationType": self.event.navigation_type.as_str(),
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (
            message,
            Some(AutomationEvent::SameDocumentNavigation(self.event)),
        )
    }
}

impl BackgroundPageFrameAttachedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.frameAttached",
            json!({
                "frameId": self.frame_id,
                "parentFrameId": self.parent_frame_id,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundPageDocumentOpenedEvent {
    fn into_protocol_message(self) -> Value {
        let mut frame = json!({
            "id": self.frame_id,
            "loaderId": self.loader_id,
            "url": self.url,
            "domainAndRegistry": "",
            "securityOrigin": self.security_origin,
            "mimeType": "text/html",
            "adFrameStatus": { "adFrameType": "none" },
            "secureContextType": self.secure_context_type,
            "crossOriginIsolatedContextType": "NotIsolated",
            "gatedAPIFeatures": [],
        });
        if let Some(frame_name) = self.frame_name {
            frame["name"] = json!(frame_name);
        }
        if let Some(parent_frame_id) = self.parent_frame_id {
            frame["parentId"] = json!(parent_frame_id);
        }
        build_event(
            "Page.documentOpened",
            json!({ "frame": frame }),
            self.session_id.as_deref(),
        )
    }
}

impl BackgroundPageFrameDetachedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.frameDetached",
            json!({
                "frameId": self.frame_id,
                "reason": "remove",
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

fn navigation_frame_protocol_method(kind: NavigationFrameEventKind) -> &'static str {
    match kind {
        NavigationFrameEventKind::Scheduled => "Page.frameScheduledNavigation",
        NavigationFrameEventKind::Requested => "Page.frameRequestedNavigation",
        NavigationFrameEventKind::StartedNavigating => "Page.frameStartedNavigating",
        NavigationFrameEventKind::StartedLoading => "Page.frameStartedLoading",
        NavigationFrameEventKind::ClearedScheduled => "Page.frameClearedScheduledNavigation",
        NavigationFrameEventKind::Navigated => "Page.frameNavigated",
        NavigationFrameEventKind::DocumentUpdated => "DOM.documentUpdated",
        NavigationFrameEventKind::StoppedLoading => "Page.frameStoppedLoading",
    }
}

fn navigation_frame_protocol_params(
    event: NavigationFrameEvent,
    unreachable_url: Option<&str>,
) -> Value {
    match event.kind {
        NavigationFrameEventKind::Scheduled => json!({
            "frameId": event.frame_id.as_str(),
            "delay": 0,
            "reason": "scriptInitiated",
            "url": event.url,
        }),
        NavigationFrameEventKind::Requested => json!({
            "frameId": event.frame_id.as_str(),
            "reason": "scriptInitiated",
            "url": event.url,
            "disposition": "currentTab",
        }),
        NavigationFrameEventKind::StartedNavigating => json!({
            "frameId": event.frame_id.as_str(),
            "url": event.url,
            "loaderId": event.loader_id.as_ref().map(|id| id.as_str()).unwrap_or(""),
            "navigationType": "differentDocument",
        }),
        NavigationFrameEventKind::StartedLoading => {
            json!({ "frameId": event.frame_id.as_str() })
        }
        NavigationFrameEventKind::ClearedScheduled => {
            json!({ "frameId": event.frame_id.as_str() })
        }
        NavigationFrameEventKind::Navigated => {
            let mut frame = json!({
                "id": event.frame_id.as_str(),
                "loaderId": event.loader_id.as_ref().map(|id| id.as_str()).unwrap_or(""),
                "url": event.url,
                "domainAndRegistry": "",
                "securityOrigin": event.security_origin.unwrap_or_default(),
                "mimeType": "text/html",
                "adFrameStatus": { "adFrameType": "none" },
                "secureContextType": event.secure_context_type.unwrap_or_default(),
                "crossOriginIsolatedContextType": "NotIsolated",
                "gatedAPIFeatures": [],
            });
            if let Some(parent_frame_id) = event.parent_frame_id {
                frame["parentId"] = json!(parent_frame_id.as_str());
            }
            if let Some(frame_name) = event.frame_name {
                frame["name"] = json!(frame_name);
            }
            if let Some(unreachable_url) = unreachable_url {
                frame["unreachableUrl"] = json!(unreachable_url);
            }
            json!({
                "type": "Navigation",
                "frame": frame,
            })
        }
        NavigationFrameEventKind::DocumentUpdated => json!({}),
        NavigationFrameEventKind::StoppedLoading => {
            json!({ "frameId": event.frame_id.as_str() })
        }
    }
}

fn navigation_lifecycle_protocol_params(event: NavigationLifecycleEvent) -> Value {
    json!({ "timestamp": event.timestamp })
}

impl BackgroundPageFileChooserOpenedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.fileChooserOpened",
            json!({
                "frameId": self.frame_id,
                "mode": self.mode,
                "backendNodeId": self.backend_node_id,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        let event = PageFileChooserOpenedEvent {
            frame_id: DevToolsFrameId::from(self.frame_id.as_str()),
            mode: self.mode,
            backend_node_id: self.backend_node_id,
            element_shared_id: self.element_shared_id,
        };
        (message, Some(AutomationEvent::PageFileChooserOpened(event)))
    }
}

impl BackgroundBrowserDownloadWillBeginEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Browser.downloadWillBegin",
            json!({
                "frameId": self.frame_id,
                "guid": self.guid,
                "url": self.url,
                "suggestedFilename": self.suggested_filename,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundBrowserDownloadProgressEvent {
    fn into_protocol_message(self) -> Value {
        let mut params = json!({
            "guid": self.guid,
            "state": self.state,
            "receivedBytes": self.received_bytes,
            "totalBytes": self.total_bytes,
        });
        if let Some(file_path) = self.file_path {
            params["filePath"] = json!(file_path);
        }
        build_event(
            "Browser.downloadProgress",
            params,
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundPageJavaScriptDialogOpeningEvent {
    fn into_protocol_message(self) -> Value {
        let mut params = json!({
            "url": self.url,
            "message": self.message,
            "type": self.dialog_type,
            "hasBrowserHandler": self.has_browser_handler,
            "defaultPrompt": self.default_prompt,
        });
        if let Some(frame_id) = self.frame_id {
            params["frameId"] = json!(frame_id);
        }
        build_event(
            "Page.javascriptDialogOpening",
            params,
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        let event = PageJavaScriptDialogOpeningEvent {
            frame_id: self.frame_id.as_deref().map(DevToolsFrameId::from),
            url: self.url,
            message: self.message,
            dialog_type: self.dialog_type,
            has_browser_handler: self.has_browser_handler,
            default_prompt: self.default_prompt,
        };
        (
            message,
            Some(AutomationEvent::PageJavaScriptDialogOpening(event)),
        )
    }
}

impl BackgroundPageJavaScriptDialogClosedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.javascriptDialogClosed",
            json!({
                "frameId": self.frame_id,
                "result": self.accepted,
                "userInput": self.user_text,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        let event = UserPromptClosedEvent {
            target_id: self.target_id.as_deref().map(Into::into),
            frame_id: self.frame_id.as_str().into(),
            prompt_type: self.prompt_type,
            accepted: self.accepted,
            user_text: self.user_text,
        };
        (message, Some(AutomationEvent::UserPromptClosed(event)))
    }
}

impl BackgroundPageScreencastVisibilityChangedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.screencastVisibilityChanged",
            json!({
                "visible": self.visible,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundPageScreencastFrameEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Page.screencastFrame",
            json!({
                "data": self.data,
                "metadata": {
                    "offsetTop": self.metadata.offset_top,
                    "pageScaleFactor": self.metadata.page_scale_factor,
                    "deviceWidth": self.metadata.device_width,
                    "deviceHeight": self.metadata.device_height,
                    "scrollOffsetX": self.metadata.scroll_offset_x,
                    "scrollOffsetY": self.metadata.scroll_offset_y,
                    "timestamp": self.metadata.timestamp,
                },
                "sessionId": self.generation,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundInspectorTargetCrashedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Inspector.targetCrashed",
            json!({}),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundInspectorTargetReloadedAfterCrashEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Inspector.targetReloadedAfterCrash",
            json!({}),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundInspectorDetachedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Inspector.detached",
            json!({
                "reason": self.reason,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundServiceWorkerRegistrationUpdatedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "ServiceWorker.workerRegistrationUpdated",
            json!({
                "registrations": self
                    .registrations
                    .into_iter()
                    .map(BackgroundServiceWorkerRegistration::into_protocol_value)
                    .collect::<Vec<_>>(),
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundServiceWorkerVersionUpdatedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "ServiceWorker.workerVersionUpdated",
            json!({
                "versions": self
                    .versions
                    .into_iter()
                    .map(BackgroundServiceWorkerVersion::into_protocol_value)
                    .collect::<Vec<_>>(),
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundServiceWorkerErrorReportedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "ServiceWorker.workerErrorReported",
            json!({
                "errorMessage": self.error_message.into_protocol_value(),
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundServiceWorkerRegistration {
    fn into_protocol_value(self) -> Value {
        json!({
            "registrationId": self.registration_id,
            "scopeURL": self.scope_url,
            "isDeleted": self.is_deleted,
        })
    }
}

impl BackgroundServiceWorkerVersion {
    fn into_protocol_value(self) -> Value {
        json!({
            "versionId": self.version_id,
            "registrationId": self.registration_id,
            "scriptURL": self.script_url,
            "runningStatus": self.running_status,
            "status": self.status,
            "controlledClients": self.controlled_clients,
            "targetId": self.target_id,
        })
    }
}

impl BackgroundServiceWorkerErrorMessage {
    fn into_protocol_value(self) -> Value {
        json!({
            "errorMessage": self.error_message,
            "registrationId": self.registration_id,
            "versionId": self.version_id,
            "sourceURL": self.source_url,
            "lineNumber": self.line_number,
            "columnNumber": self.column_number,
        })
    }
}

impl BackgroundTargetInfoChangedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Target.targetInfoChanged",
            json!({
                "targetInfo": self.target_info.into_cdp_value(),
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundTargetCreatedEvent {
    fn into_protocol_message(self) -> Value {
        let Self { session_id, event } = self;
        let target_info = event.target_info.unwrap_or_else(|| DevToolsTargetInfo {
            target_id: Some(event.target_id),
            kind: event.kind,
            title: String::new(),
            url: event.url,
            attached: false,
            opener_id: None,
            opener_frame_id: None,
            can_access_opener: false,
            browser_context_id: event.browser_context_id,
            moli_popup_id: None,
        });
        build_event(
            "Target.targetCreated",
            json!({ "targetInfo": target_info.into_cdp_value() }),
            session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::TargetCreated(self.event)))
    }
}

impl BackgroundTargetAttachedEvent {
    fn into_protocol_message(self) -> Value {
        let event = self.event;
        let parent_session_id = event.parent_session_id;
        build_event(
            "Target.attachedToTarget",
            json!({
                "sessionId": event.session_id.as_str(),
                "targetInfo": event.target_info.into_cdp_value(),
                "waitingForDebugger": event.waiting_for_debugger,
            }),
            parent_session_id.as_ref().map(|id| id.as_str()),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::TargetAttached(self.event)))
    }
}

impl BackgroundTargetDetachedEvent {
    fn into_protocol_message(self) -> Value {
        let event = self.event;
        let params = json!({
            "targetId": event.target_id.as_str(),
            "sessionId": event.session_id.as_str(),
        });
        build_event(
            "Target.detachedFromTarget",
            params,
            event.parent_session_id.as_ref().map(|id| id.as_str()),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::TargetDetached(self.event)))
    }
}

impl BackgroundTargetDestroyedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Target.targetDestroyed",
            json!({
                "targetId": self.event.target_id.as_str(),
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::TargetDestroyed(self.event)))
    }
}

impl BackgroundTargetCrashedEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Target.targetCrashed",
            json!({
                "targetId": self.target_id,
                "status": self.status,
                "errorCode": self.error_code,
            }),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundTargetReceivedMessageFromTargetEvent {
    fn into_protocol_message(self) -> Value {
        let nested_message = self.nested_event.into_protocol_message();
        build_event(
            "Target.receivedMessageFromTarget",
            json!({
                "message": nested_message.to_string(),
                "sessionId": self.target_session_id,
            }),
            None,
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        (self.into_protocol_message(), None)
    }
}

impl BackgroundConsoleMessageAddedEvent {
    fn into_protocol_message(self) -> Value {
        build_console_message_added_protocol_message(
            self.session_id.as_deref(),
            &self.source,
            &self.level,
            &self.text,
            &self.url,
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        let event = RuntimeConsoleEvent {
            target_id: None,
            console_type: self.level,
            text: self.text.clone(),
            args: vec![json!({
                "type": "string",
                "value": self.text,
            })],
            stack: None,
            stack_trace: None,
            execution_context_id: None,
            timestamp: None,
        };
        (
            message,
            Some(AutomationEvent::RuntimeConsoleApiCalled(event)),
        )
    }
}

impl BackgroundLogEntryAddedEvent {
    fn into_protocol_message(self) -> Value {
        build_log_entry_added_protocol_message(
            self.session_id.as_deref(),
            &self.source,
            &self.level,
            &self.text,
            &self.url,
            self.timestamp,
            self.network_request_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        let event = LogEntryEvent {
            target_id: None,
            source: self.source,
            level: self.level,
            text: self.text,
            url: Some(self.url),
            timestamp: Some(self.timestamp),
            network_request_id: self.network_request_id,
            args: Vec::new(),
        };
        (message, Some(AutomationEvent::LogEntryAdded(event)))
    }
}

impl BackgroundRuntimeConsoleApiCalledEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Runtime.consoleAPICalled",
            runtime_console_api_called_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (
            message,
            Some(AutomationEvent::RuntimeConsoleApiCalled(self.event)),
        )
    }
}

impl BackgroundRuntimeExceptionThrownEvent {
    fn into_protocol_message(self) -> Value {
        build_event(
            "Runtime.exceptionThrown",
            runtime_exception_thrown_protocol_params(self.event),
            self.session_id.as_deref(),
        )
    }

    fn into_parts(self) -> (Value, Option<AutomationEvent>) {
        let message = self.clone().into_protocol_message();
        (message, Some(AutomationEvent::ScriptException(self.event)))
    }
}

fn runtime_console_api_called_protocol_params(event: RuntimeConsoleEvent) -> Value {
    let mut params = json!({
        "type": event.console_type,
        "args": event.args,
        "executionContextId": event.execution_context_id.unwrap_or_default(),
        "timestamp": event.timestamp.unwrap_or_default(),
    });
    if let Some(stack_trace) = event.stack_trace
        && let Some(params) = params.as_object_mut()
    {
        params.insert("stackTrace".to_owned(), stack_trace.into_cdp_value());
    }
    params
}

fn runtime_exception_thrown_protocol_params(event: ScriptExceptionEvent) -> Value {
    let exception = *event.exception;
    let exception_id = exception
        .exception_id
        .or_else(|| event.exception_index.map(|index| (index + 1) as u64))
        .unwrap_or_default();
    let script_id = exception.script_id.clone().unwrap_or_default();
    let line_number = exception.line_number.unwrap_or_default();
    let column_number = exception.column_number.unwrap_or_default();
    let exception_text = exception.text.clone();
    let stack_trace = exception.stack_trace.clone();
    let mut details = json!({
        "exceptionId": exception_id,
        "text": exception_text,
        "lineNumber": line_number,
        "columnNumber": column_number,
        "scriptId": script_id,
        "url": event.url.unwrap_or_default(),
        "executionContextId": event.execution_context_id.unwrap_or_default(),
        "exception": runtime_exception_remote_object(exception),
    });
    if let Some(stack_trace) = stack_trace
        && let Some(details) = details.as_object_mut()
    {
        details.insert("stackTrace".to_owned(), stack_trace.into_cdp_value());
    }
    json!({
        "timestamp": event.timestamp.unwrap_or_default(),
        "exceptionDetails": details,
    })
}

fn runtime_exception_remote_object(exception: crate::automation::DevToolsScriptException) -> Value {
    exception
        .value
        .map(crate::cdp_projection::remote_object_from_devtools)
        .unwrap_or_else(|| {
            json!({
                "type": "object",
                "subtype": "error",
                "className": "Error",
                "description": exception.text,
            })
        })
}

fn build_console_message_added_protocol_message(
    session_id: Option<&str>,
    source: &str,
    level: &str,
    text: &str,
    url: &str,
) -> Value {
    build_event(
        "Console.messageAdded",
        json!({
            "message": {
                "source": source,
                "level": level,
                "text": text,
                "url": url,
                "line": 0,
                "column": 0,
            }
        }),
        session_id,
    )
}

fn build_log_entry_added_protocol_message(
    session_id: Option<&str>,
    source: &str,
    level: &str,
    text: &str,
    url: &str,
    timestamp: f64,
    network_request_id: Option<&str>,
) -> Value {
    let mut entry = json!({
        "source": source,
        "level": level,
        "text": text,
        "timestamp": timestamp,
        "url": url,
    });
    if let Some(network_request_id) = network_request_id {
        entry["networkRequestId"] = json!(network_request_id);
    }
    build_event(
        "Log.entryAdded",
        json!({
            "entry": entry,
        }),
        session_id,
    )
}

fn strip_moli_private_protocol_fields(mut message: Value) -> Value {
    let preserve_blocked_intercepts =
        message.get("method").and_then(Value::as_str) == Some("Fetch.requestPaused");
    if let Some(params) = message.get_mut("params").and_then(Value::as_object_mut) {
        if !preserve_blocked_intercepts {
            params.remove("__moliBlockedInterceptors");
        }
        params.remove("__moliFetchRequestId");
    }
    message
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct NavigationBackgroundEvent {
    token: DocumentNavigationToken,
    event: BackgroundProtocolEvent,
}

impl NavigationBackgroundEvent {
    #[cfg(test)]
    pub(crate) fn protocol_message(token: DocumentNavigationToken, message: Value) -> Self {
        Self {
            token,
            event: BackgroundProtocolEvent::immediate(message),
        }
    }

    pub(crate) fn background_event(
        token: DocumentNavigationToken,
        event: BackgroundProtocolEvent,
    ) -> Self {
        Self { token, event }
    }

    pub(crate) fn into_background_protocol_event_if_current<'a>(
        self,
        browser_contexts: impl IntoIterator<Item = &'a BrowserContext>,
    ) -> Option<BackgroundProtocolEvent> {
        let is_current = browser_contexts.into_iter().any(|browser_context| {
            browser_context.accepts_pending_document_navigation_event(&self.token)
        });
        if !is_current {
            return None;
        }
        Some(self.event)
    }

    #[cfg(test)]
    pub(crate) fn into_protocol_message_if_current<'a>(
        self,
        browser_contexts: impl IntoIterator<Item = &'a BrowserContext>,
    ) -> Option<Value> {
        self.into_background_protocol_event_if_current(browser_contexts)
            .map(BackgroundProtocolEvent::into_protocol_message)
    }
}

pub fn build_event(method: &str, params: Value, session_id: Option<&str>) -> Value {
    let mut v = json!({ "method": method, "params": params });
    if let Some(sid) = session_id {
        v["sessionId"] = json!(sid);
    }
    v
}

#[cfg(test)]
mod tests {
    use crate::automation::{
        AutomationEvent, DevToolsBrowserContextId, DevToolsFrameId, DevToolsLoaderId,
        DevToolsNetworkResourceType, DevToolsSessionId, DevToolsTargetId, DevToolsTargetInfo,
        DevToolsTargetKind, NavigationFrameEvent, NavigationFrameEventKind,
        NavigationLifecycleEvent, RuntimeExecutionContextEvent,
        RuntimeExecutionContextsClearedEvent, TargetAttachmentEvent, TargetDetachmentEvent,
        TargetLifecycleEvent, UserPromptClosedEvent,
    };
    use serde_json::{Value, json};

    use super::{
        BackgroundCommandResponsePayload, BackgroundProtocolEvent,
        BackgroundServiceWorkerErrorMessage, BackgroundServiceWorkerRegistration,
        BackgroundServiceWorkerVersion, NavigationBackgroundEvent, PageScreencastFrameMetadata,
        RuntimeInspectorResponseReady, build_event,
    };
    use crate::conn::{BrowserContext, CdpConnection, DevToolsDocumentLifecycleWaitKey};
    use moli_core::{
        PageId, RendererRuntimeInspectorAsyncCompletion,
        page::{
            RendererAgentAttachmentId, RendererDocumentLifecycleMilestone, RendererDocumentToken,
            RendererLifecycleEpoch, RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage,
            WebSocketFrameDirection, WebSocketFrameOpcode,
        },
    };
    use moli_page_types::RendererCallId;

    #[test]
    fn owned_runtime_response_moves_large_result_without_reallocating_its_strings() {
        let message = json!({
            "id": 17,
            "result": {
                "result": {
                    "type": "object",
                    "value": ["x".repeat(1024 * 1024)]
                }
            }
        });
        let original = message
            .pointer("/result/result/value/0")
            .and_then(Value::as_str)
            .expect("large Runtime result string");
        let original_ptr = original.as_ptr();

        let payload =
            BackgroundCommandResponsePayload::from_owned_runtime_inspector_message(message);
        let event = BackgroundProtocolEvent::command_response(Some(17), None, payload);
        let (_, _, payload) = event
            .into_command_response_payload()
            .expect("typed command response");
        let BackgroundCommandResponsePayload::Success { result } = payload else {
            panic!("owned Runtime result should remain successful");
        };
        let moved = result
            .pointer("/result/value/0")
            .and_then(Value::as_str)
            .expect("moved Runtime result string");

        assert_eq!(moved.as_ptr(), original_ptr);
        assert_eq!(moved.len(), 1024 * 1024);
    }

    #[test]
    fn page_download_envelope_rejects_disabled_and_reenabled_subscription() {
        let mut conn = CdpConnection::new();
        conn.install_default_browser_target();
        assert!(conn.set_page_domain_enabled_for_session_owner(None, true));
        let first_generation = conn
            .page_domain_subscription_generation_for_session_owner(None)
            .expect("Page.enable should create a subscription generation");
        let event = BackgroundProtocolEvent::page_download_progress(
            None,
            first_generation,
            "GUID-download",
            "inProgress",
            1,
            2,
        );
        assert!(event.route_is_current(&conn));

        assert!(conn.disable_page_domain_for_session_owner(None));
        assert!(!event.route_is_current(&conn));
        conn.with_target_devtools_session_state_for_session_mut(None, |state| {
            state.page_session_state = Default::default();
        })
        .expect("default target session state");

        assert!(conn.set_page_domain_enabled_for_session_owner(None, true));
        assert!(
            !event.route_is_current(&conn),
            "re-enabling Page must not resume an old observer after default state was collapsed"
        );
        let second_generation = conn
            .page_domain_subscription_generation_for_session_owner(None)
            .expect("re-enabled Page domain should expose a generation");
        assert_ne!(second_generation, first_generation);
        let current_event = BackgroundProtocolEvent::page_download_progress(
            None,
            second_generation,
            "GUID-current",
            "completed",
            2,
            2,
        );
        assert!(current_event.route_is_current(&conn));
    }

    #[test]
    fn browser_download_route_guard_rejects_detached_and_reenabled_subscription() {
        let mut conn = CdpConnection::new();
        conn.download_behavior
            .set_browser_events_enabled_for_session(Some("SID-browser"), true);
        let first_generation = conn.download_behavior.browser_event_observers()[0].1;
        let event = BackgroundProtocolEvent::browser_download_progress(
            Some("SID-browser"),
            Some(first_generation),
            "GUID-download",
            "inProgress",
            1,
            2,
            None,
        );
        assert!(event.route_is_current(&conn));

        conn.download_behavior
            .set_browser_events_enabled_for_session(Some("SID-browser"), false);
        assert!(!event.route_is_current(&conn));

        conn.download_behavior
            .set_browser_events_enabled_for_session(Some("SID-browser"), true);
        let second_generation = conn.download_behavior.browser_event_observers()[0].1;
        assert_ne!(second_generation, first_generation);
        assert!(
            !event.route_is_current(&conn),
            "re-enabling Browser download events must not revive an old async completion"
        );
        let current_event = BackgroundProtocolEvent::browser_download_progress(
            Some("SID-browser"),
            Some(second_generation),
            "GUID-current",
            "completed",
            2,
            2,
            Some("/tmp/GUID-current"),
        );
        assert!(current_event.route_is_current(&conn));
    }

    #[test]
    fn renderer_page_load_matches_wait_key_by_document_and_epoch() {
        let page_id = PageId::new_for_testing(902);
        let document = RendererDocumentToken::new_for_testing(page_id, 3);
        let event = NavigationLifecycleEvent {
            target_id: DevToolsTargetId::from("FRAME"),
            frame_id: DevToolsFrameId::from("FRAME"),
            navigation_id: None,
            loader_id: Some(DevToolsLoaderId::from("LOADER")),
            url: String::new(),
            timestamp: 1.0,
        };
        let output = BackgroundProtocolEvent::page_load_for_renderer_document(
            None,
            event,
            document,
            RendererLifecycleEpoch(4),
        );
        let matching = DevToolsDocumentLifecycleWaitKey {
            registration_id: crate::conn::state::RendererDocumentLifecycleWaiterId::new_for_test(1),
            renderer_document: document,
            renderer_epoch: RendererLifecycleEpoch(4),
            milestone: RendererDocumentLifecycleMilestone::Load,
            frame_id: "FRAME".to_owned(),
            loader_id: "LOADER".to_owned(),
        };
        let restarted_epoch = DevToolsDocumentLifecycleWaitKey {
            renderer_epoch: RendererLifecycleEpoch(5),
            ..matching.clone()
        };

        assert!(output.matches_document_load_wait_key(&matching));
        assert!(!output.matches_document_load_wait_key(&restarted_epoch));
    }

    #[test]
    fn navigation_background_event_materializes_only_for_current_token() {
        let mut browser_context = BrowserContext::new("CTX-nav".to_owned());
        browser_context.set_active_target_id("TID-nav");
        browser_context.attach_active_session("SID-nav");
        let token = browser_context
            .start_document_navigation_for_active_target("LOADER-1".to_owned())
            .expect("active target should produce navigation token");
        let message = build_event(
            "Page.frameStartedLoading",
            json!({ "frameId": "TID-nav" }),
            Some("SID-nav"),
        );

        let event = NavigationBackgroundEvent::protocol_message(token, message.clone());

        assert_eq!(
            event.into_protocol_message_if_current(std::iter::once(&browser_context)),
            Some(message)
        );
    }

    #[test]
    fn navigation_background_event_preserves_typed_sidecar_for_current_token() {
        let mut browser_context = BrowserContext::new("CTX-nav".to_owned());
        browser_context.set_active_target_id("TID-nav");
        browser_context.attach_active_session("SID-nav");
        let token = browser_context
            .start_document_navigation_for_active_target("LOADER-1".to_owned())
            .expect("active target should produce navigation token");
        let message = build_event(
            "Page.frameStartedNavigating",
            json!({
                "frameId": "TID-nav",
                "loaderId": "LOADER-1",
                "url": "https://example.test/",
                "navigationType": "differentDocument"
            }),
            Some("SID-nav"),
        );
        let automation_event = AutomationEvent::NavigationFrame(NavigationFrameEvent {
            target_id: DevToolsTargetId::from("TID-nav"),
            frame_id: DevToolsFrameId::from("TID-nav"),
            parent_frame_id: None,
            loader_id: Some(DevToolsLoaderId::from("LOADER-1")),
            url: "https://example.test/".to_owned(),
            kind: NavigationFrameEventKind::StartedNavigating,
            frame_name: None,
            security_origin: None,
            secure_context_type: None,
        });

        let event = NavigationBackgroundEvent::background_event(
            token,
            BackgroundProtocolEvent::immediate_automation_event(
                message.clone(),
                automation_event.clone(),
            ),
        );
        let background_event = event
            .into_background_protocol_event_if_current(std::iter::once(&browser_context))
            .expect("current navigation event should materialize");
        let (actual_message, actual_automation_event) = background_event.into_parts();

        assert_eq!(actual_message, message);
        assert_eq!(actual_automation_event, Some(automation_event));
    }

    #[test]
    fn runtime_inspector_negative_call_id_preserves_error_payload() {
        let response = RuntimeInspectorResponseReady::new_correlated(
            42,
            None,
            RendererCallId::new(-1),
            Ok(
                RendererRuntimeInspectorAsyncCompletion::from_protocol_message(
                    -1,
                    json!({
                        "id": -1,
                        "error": {
                            "code": -32001,
                            "message": "renderer rejected command",
                            "data": { "reason": "negative call id" }
                        }
                    }),
                ),
            ),
        );

        let payload = response.clone().into_command_response_payload();
        let BackgroundCommandResponsePayload::Error {
            code,
            message,
            data,
        } = payload
        else {
            panic!("negative call id error completion should stay an error payload");
        };
        assert_eq!(code, -32001);
        assert_eq!(message, "renderer rejected command");
        assert_eq!(data, Some(json!({ "reason": "negative call id" })));

        let message = response.into_protocol_message_for_typed_runtime_route();
        assert_eq!(message["id"], json!(42));
        assert_eq!(message["error"]["code"], json!(-32001));
        assert_eq!(
            message["error"]["message"],
            json!("renderer rejected command")
        );
        assert_eq!(
            message["error"]["data"],
            json!({ "reason": "negative call id" })
        );
    }

    #[test]
    fn runtime_inspector_generated_error_output_preserves_renderer_attachment() {
        let attachment_id = RendererAgentAttachmentId::allocate();
        let mut output = RendererRuntimeCommandOutput::from_inspector_message(
            RendererRuntimeInspectorMessage::protocol(json!({
                "method": "Runtime.consoleAPICalled",
                "params": {},
            })),
        );
        output.bind_renderer_agent_attachment(attachment_id);
        let response = RuntimeInspectorResponseReady::new_correlated(
            42,
            None,
            RendererCallId::new(42),
            Ok(RendererRuntimeInspectorAsyncCompletion::from_command_output(42, output)),
        );

        let (command_id, output, renderer_output_predecessor) =
            response.into_renderer_command_output();

        assert_eq!(command_id, 42);
        assert_eq!(renderer_output_predecessor, None);
        assert_eq!(output.renderer_agent_attachment_id(), Some(attachment_id));
        assert_eq!(
            output
                .protocol_response(42)
                .expect("generated error output should contain the frontend response")["error"]["message"],
            json!("RuntimeInspectorResponseMissingProtocolResponse")
        );
    }

    #[test]
    fn runtime_inspector_response_restores_large_frontend_command_id() {
        let frontend_command_id = i32::MAX as u64 + 73;
        let response = RuntimeInspectorResponseReady::new_correlated(
            frontend_command_id,
            Some("SID-large-id"),
            RendererCallId::new(11),
            Ok(
                RendererRuntimeInspectorAsyncCompletion::from_protocol_message(
                    11,
                    json!({
                        "id": 11,
                        "result": { "result": { "type": "number", "value": 42 } }
                    }),
                ),
            ),
        );

        let message = response.into_protocol_message_for_typed_runtime_route();

        assert_eq!(message["id"], json!(frontend_command_id));
        assert_eq!(message["result"]["result"]["value"], json!(42));
    }

    #[test]
    fn runtime_binding_call_stays_typed_until_wire_projection() {
        let mut event =
            BackgroundProtocolEvent::runtime_binding_called(None, "bindingName", "payload", 42);

        assert!(event.protocol_message().is_none());
        assert!(event.has_protocol_wire_message());

        event.ensure_protocol_session_id(Some("SID-runtime"));
        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Runtime.bindingCalled"));
        assert_eq!(message["sessionId"], json!("SID-runtime"));
        assert_eq!(message["params"]["name"], json!("bindingName"));
        assert_eq!(message["params"]["payload"], json!("payload"));
        assert_eq!(message["params"]["executionContextId"], json!(42));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn page_frame_attached_stays_typed_until_wire_projection() {
        let mut event =
            BackgroundProtocolEvent::page_frame_attached(None, "CHILD-FRAME", "PARENT-FRAME");

        assert!(event.protocol_message().is_none());
        assert_eq!(event.protocol_method(), Some("Page.frameAttached"));
        assert!(event.has_protocol_wire_message());

        event.ensure_protocol_session_id(Some("SID-page"));
        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Page.frameAttached"));
        assert_eq!(message["sessionId"], json!("SID-page"));
        assert_eq!(message["params"]["frameId"], json!("CHILD-FRAME"));
        assert_eq!(message["params"]["parentFrameId"], json!("PARENT-FRAME"));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn page_frame_detached_stays_typed_until_wire_projection() {
        let mut event = BackgroundProtocolEvent::page_frame_detached(None, "CHILD-FRAME");

        assert!(event.protocol_message().is_none());
        assert_eq!(event.protocol_method(), Some("Page.frameDetached"));
        assert!(event.has_protocol_wire_message());

        event.ensure_protocol_session_id(Some("SID-page"));
        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Page.frameDetached"));
        assert_eq!(message["sessionId"], json!("SID-page"));
        assert_eq!(message["params"]["frameId"], json!("CHILD-FRAME"));
        assert_eq!(message["params"]["reason"], json!("remove"));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn javascript_dialog_closed_stays_typed_until_wire_projection() {
        let event = BackgroundProtocolEvent::page_javascript_dialog_closed(
            Some("SID-dialog"),
            UserPromptClosedEvent {
                target_id: Some(DevToolsTargetId::from("TID-dialog")),
                frame_id: DevToolsFrameId::from("FRAME-dialog"),
                prompt_type: "prompt".to_owned(),
                accepted: true,
                user_text: "typed response".to_owned(),
            },
        );

        assert!(event.protocol_message().is_none());
        assert!(event.has_protocol_wire_message());

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Page.javascriptDialogClosed"));
        assert_eq!(message["sessionId"], json!("SID-dialog"));
        assert_eq!(message["params"]["frameId"], json!("FRAME-dialog"));
        assert_eq!(message["params"]["result"], json!(true));
        assert_eq!(message["params"]["userInput"], json!("typed response"));
        assert_eq!(
            automation_event,
            Some(AutomationEvent::UserPromptClosed(UserPromptClosedEvent {
                target_id: Some(DevToolsTargetId::from("TID-dialog")),
                frame_id: DevToolsFrameId::from("FRAME-dialog"),
                prompt_type: "prompt".to_owned(),
                accepted: true,
                user_text: "typed response".to_owned(),
            }))
        );
    }

    #[test]
    fn screencast_visibility_stays_typed_until_wire_projection() {
        let event =
            BackgroundProtocolEvent::page_screencast_visibility_changed(Some("SID-page"), true);

        assert!(event.protocol_message().is_none());
        assert!(event.has_protocol_wire_message());

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Page.screencastVisibilityChanged"));
        assert_eq!(message["sessionId"], json!("SID-page"));
        assert_eq!(message["params"]["visible"], json!(true));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn screencast_frame_stays_typed_until_wire_projection() {
        let event = BackgroundProtocolEvent::page_screencast_frame(
            Some("SID-page"),
            "encoded-frame".to_owned(),
            PageScreencastFrameMetadata {
                offset_top: 0.0,
                page_scale_factor: 1.0,
                device_width: 800.0,
                device_height: 600.0,
                scroll_offset_x: 0.0,
                scroll_offset_y: 0.0,
                timestamp: 1234.5,
            },
            7,
        );

        assert!(event.protocol_message().is_none());
        assert_eq!(event.protocol_method(), Some("Page.screencastFrame"));
        assert!(event.has_protocol_wire_message());

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Page.screencastFrame"));
        assert_eq!(message["sessionId"], json!("SID-page"));
        assert_eq!(message["params"]["data"], json!("encoded-frame"));
        assert_eq!(message["params"]["sessionId"], json!(7));
        assert_eq!(message["params"]["metadata"]["deviceWidth"], json!(800.0));
        assert_eq!(message["params"]["metadata"]["timestamp"], json!(1234.5));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn inspector_events_stay_typed_until_wire_projection() {
        let events = vec![
            BackgroundProtocolEvent::inspector_target_crashed(Some("SID-crashed")),
            BackgroundProtocolEvent::inspector_target_reloaded_after_crash(Some("SID-reloaded")),
            BackgroundProtocolEvent::inspector_detached(Some("SID-detached"), "Target detached"),
        ];

        for event in &events {
            assert!(event.protocol_message().is_none());
            assert!(event.has_protocol_wire_message());
        }

        let parts = events
            .into_iter()
            .map(BackgroundProtocolEvent::into_parts)
            .collect::<Vec<_>>();

        assert_eq!(parts[0].0["method"], json!("Inspector.targetCrashed"));
        assert_eq!(parts[0].0["sessionId"], json!("SID-crashed"));
        assert_eq!(parts[0].0["params"], json!({}));
        assert_eq!(parts[0].1, None);

        assert_eq!(
            parts[1].0["method"],
            json!("Inspector.targetReloadedAfterCrash")
        );
        assert_eq!(parts[1].0["sessionId"], json!("SID-reloaded"));
        assert_eq!(parts[1].0["params"], json!({}));
        assert_eq!(parts[1].1, None);

        assert_eq!(parts[2].0["method"], json!("Inspector.detached"));
        assert_eq!(parts[2].0["sessionId"], json!("SID-detached"));
        assert_eq!(parts[2].0["params"]["reason"], json!("Target detached"));
        assert_eq!(parts[2].1, None);
    }

    #[test]
    fn service_worker_events_stay_typed_until_wire_projection() {
        let events = vec![
            BackgroundProtocolEvent::service_worker_registration_updated(
                Some("SID-service-worker"),
                vec![BackgroundServiceWorkerRegistration {
                    registration_id: "41".to_owned(),
                    scope_url: "https://example.test/app/".to_owned(),
                    is_deleted: false,
                }],
            ),
            BackgroundProtocolEvent::service_worker_version_updated(
                Some("SID-service-worker"),
                vec![BackgroundServiceWorkerVersion {
                    version_id: "7".to_owned(),
                    registration_id: "41".to_owned(),
                    script_url: "https://example.test/service-worker.js".to_owned(),
                    running_status: "running".to_owned(),
                    status: "activated".to_owned(),
                    controlled_clients: vec!["TID-page".to_owned()],
                    target_id: "TID-service-worker".to_owned(),
                }],
            ),
            BackgroundProtocolEvent::service_worker_error_reported(
                Some("SID-service-worker"),
                BackgroundServiceWorkerErrorMessage {
                    error_message: "boom".to_owned(),
                    registration_id: "41".to_owned(),
                    version_id: "7".to_owned(),
                    source_url: "https://example.test/service-worker.js".to_owned(),
                    line_number: 12,
                    column_number: 34,
                },
            ),
        ];

        for event in &events {
            assert!(event.protocol_message().is_none());
            assert!(event.has_protocol_wire_message());
        }

        let parts = events
            .into_iter()
            .map(BackgroundProtocolEvent::into_parts)
            .collect::<Vec<_>>();

        assert_eq!(
            parts[0].0["method"],
            json!("ServiceWorker.workerRegistrationUpdated")
        );
        assert_eq!(parts[0].0["sessionId"], json!("SID-service-worker"));
        assert_eq!(
            parts[0].0["params"]["registrations"][0],
            json!({
                "registrationId": "41",
                "scopeURL": "https://example.test/app/",
                "isDeleted": false
            })
        );
        assert_eq!(parts[0].1, None);

        assert_eq!(
            parts[1].0["method"],
            json!("ServiceWorker.workerVersionUpdated")
        );
        assert_eq!(parts[1].0["sessionId"], json!("SID-service-worker"));
        assert_eq!(
            parts[1].0["params"]["versions"][0],
            json!({
                "versionId": "7",
                "registrationId": "41",
                "scriptURL": "https://example.test/service-worker.js",
                "runningStatus": "running",
                "status": "activated",
                "controlledClients": ["TID-page"],
                "targetId": "TID-service-worker"
            })
        );
        assert_eq!(parts[1].1, None);

        assert_eq!(
            parts[2].0["method"],
            json!("ServiceWorker.workerErrorReported")
        );
        assert_eq!(parts[2].0["sessionId"], json!("SID-service-worker"));
        assert_eq!(
            parts[2].0["params"]["errorMessage"],
            json!({
                "errorMessage": "boom",
                "registrationId": "41",
                "versionId": "7",
                "sourceURL": "https://example.test/service-worker.js",
                "lineNumber": 12,
                "columnNumber": 34
            })
        );
        assert_eq!(parts[2].1, None);
    }

    #[test]
    fn target_info_changed_stays_typed_until_wire_projection() {
        let event = BackgroundProtocolEvent::target_info_changed(
            None,
            DevToolsTargetInfo {
                target_id: Some(DevToolsTargetId::from("TID-target-info")),
                kind: DevToolsTargetKind::Page,
                title: "Target title".to_owned(),
                url: "https://example.test/target".to_owned(),
                attached: true,
                opener_id: Some(DevToolsTargetId::from("TID-opener")),
                opener_frame_id: Some(DevToolsFrameId::from("FRAME-opener")),
                can_access_opener: true,
                browser_context_id: Some(DevToolsBrowserContextId::from("BID-target-info")),
                moli_popup_id: None,
            },
        );

        assert!(event.protocol_message().is_none());
        assert!(event.has_protocol_wire_message());

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Target.targetInfoChanged"));
        assert!(message.get("sessionId").is_none());
        assert_eq!(
            message["params"]["targetInfo"],
            json!({
                "targetId": "TID-target-info",
                "type": "page",
                "title": "Target title",
                "url": "https://example.test/target",
                "attached": true,
                "canAccessOpener": true,
                "openerId": "TID-opener",
                "openerFrameId": "FRAME-opener",
                "browserContextId": "BID-target-info"
            })
        );
        assert_eq!(automation_event, None);
    }

    #[test]
    fn target_lifecycle_events_stay_typed_until_wire_projection() {
        let target_info = DevToolsTargetInfo {
            target_id: Some(DevToolsTargetId::from("TID-created")),
            kind: DevToolsTargetKind::Page,
            title: String::new(),
            url: "https://example.test/created".to_owned(),
            attached: false,
            opener_id: None,
            opener_frame_id: None,
            can_access_opener: false,
            browser_context_id: Some(DevToolsBrowserContextId::from("BID-created")),
            moli_popup_id: None,
        };
        let mut attached = BackgroundProtocolEvent::target_attached(TargetAttachmentEvent {
            target_id: DevToolsTargetId::from("TID-attached"),
            session_id: DevToolsSessionId::from("SID-child"),
            parent_session_id: None,
            target_info: DevToolsTargetInfo {
                target_id: Some(DevToolsTargetId::from("TID-attached")),
                kind: DevToolsTargetKind::Page,
                title: String::new(),
                url: "about:blank".to_owned(),
                attached: true,
                opener_id: None,
                opener_frame_id: None,
                can_access_opener: false,
                browser_context_id: None,
                moli_popup_id: None,
            },
            waiting_for_debugger: true,
        });
        attached.ensure_protocol_session_id(Some("SID-parent"));
        let events = vec![
            BackgroundProtocolEvent::target_created(
                None,
                TargetLifecycleEvent {
                    target_id: DevToolsTargetId::from("TID-created"),
                    browser_context_id: Some(DevToolsBrowserContextId::from("BID-created")),
                    kind: DevToolsTargetKind::Page,
                    url: "https://example.test/created".to_owned(),
                    target_info: Some(target_info),
                },
            ),
            attached,
            BackgroundProtocolEvent::target_detached(TargetDetachmentEvent {
                target_id: DevToolsTargetId::from("TID-detached"),
                session_id: DevToolsSessionId::from("SID-detached"),
                parent_session_id: Some(DevToolsSessionId::from("SID-parent")),
                reason: Some("Render process gone.".to_owned()),
            }),
        ];

        for event in &events {
            assert!(event.protocol_message().is_none());
            assert!(event.has_protocol_wire_message());
        }

        let parts = events
            .into_iter()
            .map(BackgroundProtocolEvent::into_parts)
            .collect::<Vec<_>>();

        assert_eq!(parts[0].0["method"], json!("Target.targetCreated"));
        assert!(parts[0].0.get("sessionId").is_none());
        assert_eq!(
            parts[0].0["params"]["targetInfo"]["targetId"],
            json!("TID-created")
        );
        let Some(AutomationEvent::TargetCreated(event)) = &parts[0].1 else {
            panic!("expected TargetCreated automation sidecar");
        };
        assert_eq!(event.target_id.as_str(), "TID-created");

        assert_eq!(parts[1].0["method"], json!("Target.attachedToTarget"));
        assert_eq!(parts[1].0["sessionId"], json!("SID-parent"));
        assert_eq!(parts[1].0["params"]["sessionId"], json!("SID-child"));
        assert_eq!(parts[1].0["params"]["waitingForDebugger"], json!(true));
        let Some(AutomationEvent::TargetAttached(event)) = &parts[1].1 else {
            panic!("expected TargetAttached automation sidecar");
        };
        assert_eq!(event.target_id.as_str(), "TID-attached");
        assert_eq!(
            event.parent_session_id.as_ref().map(|id| id.as_str()),
            Some("SID-parent")
        );

        assert_eq!(parts[2].0["method"], json!("Target.detachedFromTarget"));
        assert_eq!(parts[2].0["sessionId"], json!("SID-parent"));
        assert_eq!(parts[2].0["params"]["targetId"], json!("TID-detached"));
        assert!(parts[2].0["params"].get("reason").is_none());
        let Some(AutomationEvent::TargetDetached(event)) = &parts[2].1 else {
            panic!("expected TargetDetached automation sidecar");
        };
        assert_eq!(event.target_id.as_str(), "TID-detached");
        assert_eq!(event.reason.as_deref(), Some("Render process gone."));
    }

    #[test]
    fn target_destroyed_stays_typed_until_wire_projection() {
        let event = BackgroundProtocolEvent::target_destroyed(
            None,
            TargetLifecycleEvent {
                target_id: DevToolsTargetId::from("TID-destroyed"),
                browser_context_id: Some(DevToolsBrowserContextId::from("BID-destroyed")),
                kind: DevToolsTargetKind::Page,
                url: "https://example.test/destroyed".to_owned(),
                target_info: None,
            },
        );

        assert!(event.protocol_message().is_none());
        assert!(event.has_protocol_wire_message());

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Target.targetDestroyed"));
        assert!(message.get("sessionId").is_none());
        assert_eq!(message["params"]["targetId"], json!("TID-destroyed"));
        let Some(AutomationEvent::TargetDestroyed(event)) = automation_event else {
            panic!("expected TargetDestroyed automation sidecar");
        };
        assert_eq!(event.target_id.as_str(), "TID-destroyed");
        assert_eq!(
            event.browser_context_id.as_ref().map(|id| id.as_str()),
            Some("BID-destroyed")
        );
    }

    #[test]
    fn target_destroyed_preserves_owner_session_until_wire_projection() {
        let event = BackgroundProtocolEvent::target_destroyed(
            Some("SID-owner"),
            TargetLifecycleEvent {
                target_id: DevToolsTargetId::from("TID-destroyed"),
                browser_context_id: None,
                kind: DevToolsTargetKind::Page,
                url: "about:blank".to_owned(),
                target_info: None,
            },
        );

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Target.targetDestroyed"));
        assert_eq!(message["sessionId"], json!("SID-owner"));
        assert_eq!(message["params"]["targetId"], json!("TID-destroyed"));
        let Some(AutomationEvent::TargetDestroyed(event)) = automation_event else {
            panic!("expected TargetDestroyed automation sidecar");
        };
        assert_eq!(event.target_id.as_str(), "TID-destroyed");
    }

    #[test]
    fn target_crashed_stays_typed_until_wire_projection() {
        let event = BackgroundProtocolEvent::target_crashed(None, "TID-crashed", "crashed", 1);

        assert!(event.protocol_message().is_none());
        assert_eq!(event.protocol_method(), Some("Target.targetCrashed"));
        assert!(event.has_protocol_wire_message());

        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Target.targetCrashed"));
        assert!(message.get("sessionId").is_none());
        assert_eq!(message["params"]["targetId"], json!("TID-crashed"));
        assert_eq!(message["params"]["status"], json!("crashed"));
        assert_eq!(message["params"]["errorCode"], json!(1));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn target_received_message_stays_typed_until_wire_projection() {
        let nested_event =
            BackgroundProtocolEvent::command_success(Some(77), None, json!({ "ok": true }));
        let mut event =
            BackgroundProtocolEvent::target_received_message_from_target("SID-child", nested_event);

        assert!(event.protocol_message().is_none());
        assert!(event.has_protocol_wire_message());

        event.ensure_protocol_session_id(Some("SID-parent"));
        let (message, automation_event) = event.into_parts();

        assert_eq!(message["method"], json!("Target.receivedMessageFromTarget"));
        assert!(
            message.get("sessionId").is_none(),
            "legacy Target.receivedMessageFromTarget is routed through params.sessionId"
        );
        assert_eq!(message["params"]["sessionId"], json!("SID-child"));
        let nested: Value = serde_json::from_str(
            message["params"]["message"]
                .as_str()
                .expect("nested target message should be a string"),
        )
        .expect("nested target message should be valid json");
        assert_eq!(nested["id"], json!(77));
        assert_eq!(nested["result"], json!({ "ok": true }));
        assert_eq!(automation_event, None);
    }

    #[test]
    fn console_and_log_background_events_do_not_rewrap_cdp_params_as_sidecars() {
        let console = BackgroundProtocolEvent::console_message_added(
            Some("SID-console"),
            "javascript",
            "log",
            "hello",
            "",
        );
        let (console_message, console_event) = console.into_parts();
        assert_eq!(console_message["method"], json!("Console.messageAdded"));
        assert_eq!(console_message["sessionId"], json!("SID-console"));
        assert_eq!(console_message["params"]["message"]["text"], json!("hello"));
        let Some(AutomationEvent::RuntimeConsoleApiCalled(console_event)) = console_event else {
            panic!("Console.messageAdded should expose a RuntimeConsoleApiCalled sidecar");
        };
        assert_eq!(console_event.text, "hello");

        let log = BackgroundProtocolEvent::log_entry_added(
            Some("SID-log"),
            "javascript",
            "error",
            "boom",
            "",
            1.25,
            None,
        );
        let (log_message, log_event) = log.into_parts();
        assert_eq!(log_message["method"], json!("Log.entryAdded"));
        assert_eq!(log_message["sessionId"], json!("SID-log"));
        assert_eq!(log_message["params"]["entry"]["text"], json!("boom"));
        let Some(AutomationEvent::LogEntryAdded(log_event)) = log_event else {
            panic!("Log.entryAdded should expose a LogEntryAdded sidecar");
        };
        assert_eq!(log_event.text, "boom");
    }

    #[test]
    fn network_extra_info_events_stay_typed_until_wire_projection() {
        let request = BackgroundProtocolEvent::network_request_will_be_sent_extra_info(
            Some("SID-network"),
            "REQ-extra",
            serde_json::Map::from_iter([("Cookie".to_owned(), json!("sid=1"))]),
            json!({ "includedCookies": [], "excludedCookies": [] }),
            Vec::new(),
            12.5,
        );
        assert!(request.protocol_message().is_none());
        assert_eq!(
            request.protocol_method(),
            Some("Network.requestWillBeSentExtraInfo")
        );
        assert!(request.has_protocol_wire_message());
        let (message, automation_event) = request.into_parts();
        assert_eq!(
            message["method"],
            json!("Network.requestWillBeSentExtraInfo")
        );
        assert_eq!(message["sessionId"], json!("SID-network"));
        assert_eq!(message["params"]["requestId"], json!("REQ-extra"));
        assert_eq!(message["params"]["headers"]["Cookie"], json!("sid=1"));
        assert_eq!(message["params"]["associatedCookies"], json!([]));
        assert_eq!(
            message["params"]["connectTiming"]["requestTime"],
            json!(12.5)
        );
        assert!(automation_event.is_none());

        let response = BackgroundProtocolEvent::network_response_received_extra_info(
            Some("SID-network"),
            "REQ-extra",
            serde_json::Map::from_iter([("set-cookie".to_owned(), json!("sid=2"))]),
            302,
            vec![json!({ "status": "Include" })],
            Vec::new(),
        );
        assert!(response.protocol_message().is_none());
        assert_eq!(
            response.protocol_method(),
            Some("Network.responseReceivedExtraInfo")
        );
        let (message, automation_event) = response.into_parts();
        assert_eq!(
            message["method"],
            json!("Network.responseReceivedExtraInfo")
        );
        assert_eq!(message["sessionId"], json!("SID-network"));
        assert_eq!(message["params"]["requestId"], json!("REQ-extra"));
        assert_eq!(message["params"]["statusCode"], json!(302));
        assert_eq!(message["params"]["headers"]["set-cookie"], json!("sid=2"));
        assert_eq!(message["params"]["blockedCookies"], json!([]));
        assert_eq!(
            message["params"]["resourceIPAddressSpace"],
            json!("Unknown")
        );
        assert_eq!(
            message["params"]["cookieReports"],
            json!([{ "status": "Include" }])
        );
        assert!(automation_event.is_none());
    }

    #[test]
    fn network_websocket_events_stay_typed_until_wire_projection() {
        let events = vec![
            (
                BackgroundProtocolEvent::network_websocket_created(
                    Some("SID-ws"),
                    "REQ-ws",
                    "ws://example.test/socket",
                ),
                "Network.webSocketCreated",
            ),
            (
                BackgroundProtocolEvent::network_websocket_will_send_handshake_request(
                    Some("SID-ws"),
                    "REQ-ws",
                    11.5,
                    serde_json::Map::from_iter([(
                        "origin".to_owned(),
                        json!("https://example.test"),
                    )]),
                ),
                "Network.webSocketWillSendHandshakeRequest",
            ),
            (
                BackgroundProtocolEvent::network_websocket_handshake_response_received(
                    Some("SID-ws"),
                    "REQ-ws",
                    12.5,
                    101,
                    "Switching Protocols",
                    serde_json::Map::from_iter([("upgrade".to_owned(), json!("websocket"))]),
                ),
                "Network.webSocketHandshakeResponseReceived",
            ),
            (
                BackgroundProtocolEvent::network_websocket_frame(
                    Some("SID-ws"),
                    "REQ-ws",
                    13.5,
                    WebSocketFrameDirection::Received,
                    WebSocketFrameOpcode::Text,
                    5,
                ),
                "Network.webSocketFrameReceived",
            ),
        ];

        for (event, method) in events {
            assert!(
                event.protocol_message().is_none(),
                "WebSocket events must stay typed until wire projection"
            );
            assert_eq!(event.protocol_method(), Some(method));
            assert!(event.has_protocol_wire_message());
            let (message, automation_event) = event.into_parts();
            assert_eq!(message["method"], json!(method));
            assert_eq!(message["sessionId"], json!("SID-ws"));
            assert_eq!(message["params"]["requestId"], json!("REQ-ws"));
            assert!(automation_event.is_none());
        }
    }

    #[test]
    fn runtime_context_events_expose_method_without_raw_protocol_message() {
        let context_event = RuntimeExecutionContextEvent {
            target_id: None,
            context_id: Some(7),
            realm_id: None,
            frame_id: Some(DevToolsFrameId::from("FRAME-runtime")),
            origin: Some("https://example.test".to_owned()),
            name: Some(String::new()),
            is_default: Some(true),
            context_type: Some("default".to_owned()),
            grant_universal_access: None,
        };
        let events = vec![
            (
                BackgroundProtocolEvent::runtime_execution_contexts_cleared(
                    Some("SID-runtime"),
                    RuntimeExecutionContextsClearedEvent { target_id: None },
                ),
                "Runtime.executionContextsCleared",
            ),
            (
                BackgroundProtocolEvent::runtime_execution_context_created(
                    Some("SID-runtime"),
                    context_event.clone(),
                ),
                "Runtime.executionContextCreated",
            ),
            (
                BackgroundProtocolEvent::runtime_execution_context_destroyed(
                    Some("SID-runtime"),
                    context_event,
                ),
                "Runtime.executionContextDestroyed",
            ),
        ];

        for (event, method) in events {
            assert!(
                event.protocol_message().is_none(),
                "typed runtime context events must not expose raw protocol message state"
            );
            assert_eq!(event.protocol_method(), Some(method));
            assert!(event.has_protocol_wire_message());

            let (message, automation_event) = event.into_parts();
            assert_eq!(message["method"], json!(method));
            assert_eq!(message["sessionId"], json!("SID-runtime"));
            assert!(automation_event.is_some());
        }
    }

    #[test]
    fn page_activity_events_stay_typed_until_wire_projection() {
        let events = vec![
            BackgroundProtocolEvent::page_file_chooser_opened(
                Some("SID-page"),
                "FRAME-file",
                "selectMultiple",
                17,
                None,
            ),
            BackgroundProtocolEvent::browser_download_will_begin(
                Some("SID-page"),
                None,
                "FRAME-download",
                "GUID-download",
                "https://example.test/download",
                "download.txt",
            ),
            BackgroundProtocolEvent::browser_download_progress(
                Some("SID-page"),
                None,
                "GUID-download",
                "completed",
                123,
                123,
                Some("/tmp/download.txt"),
            ),
            BackgroundProtocolEvent::page_javascript_dialog_opening(
                Some("SID-page"),
                crate::automation::PageJavaScriptDialogOpeningEvent {
                    frame_id: Some(DevToolsFrameId::from("FRAME-dialog")),
                    url: "https://example.test/dialog".to_owned(),
                    message: "confirm?".to_owned(),
                    dialog_type: "confirm".to_owned(),
                    has_browser_handler: true,
                    default_prompt: String::new(),
                },
            ),
        ];

        for event in &events {
            assert!(
                event.protocol_message().is_none(),
                "activity event should stay typed until wire projection: {event:?}"
            );
            assert!(event.has_protocol_wire_message());
        }

        let parts = events
            .into_iter()
            .map(BackgroundProtocolEvent::into_parts)
            .collect::<Vec<_>>();
        let methods = parts
            .iter()
            .map(|(message, _)| message["method"].as_str().unwrap())
            .collect::<Vec<_>>();
        assert_eq!(
            methods,
            vec![
                "Page.fileChooserOpened",
                "Browser.downloadWillBegin",
                "Browser.downloadProgress",
                "Page.javascriptDialogOpening",
            ]
        );
        assert!(matches!(
            parts[0].1.as_ref(),
            Some(AutomationEvent::PageFileChooserOpened(_))
        ));
        assert_eq!(parts[1].1, None);
        assert_eq!(parts[2].1, None);
        assert!(matches!(
            parts[3].1.as_ref(),
            Some(AutomationEvent::PageJavaScriptDialogOpening(_))
        ));
        assert_eq!(parts[0].0["sessionId"], json!("SID-page"));
        assert_eq!(parts[0].0["params"]["backendNodeId"], json!(17));
        assert_eq!(
            parts[1].0["params"]["suggestedFilename"],
            json!("download.txt")
        );
        assert_eq!(parts[2].0["params"]["filePath"], json!("/tmp/download.txt"));
        assert_eq!(parts[3].0["params"]["frameId"], json!("FRAME-dialog"));
    }

    #[test]
    fn background_event_waits_for_navigation_completion_only_for_non_document_network() {
        use crate::automation::{DevToolsRequestId, NetworkRequestEvent};

        let network_event = |resource_type: Option<DevToolsNetworkResourceType>| {
            AutomationEvent::NetworkResponseStarted(NetworkRequestEvent {
                target_id: DevToolsTargetId::from("TID-nav"),
                frame_id: Some(DevToolsFrameId::from("TID-nav")),
                request_id: DevToolsRequestId::from("REQ-nav"),
                loader_id: Some(DevToolsLoaderId::from("LOADER-nav")),
                url: "https://example.test/resource".to_owned(),
                document_url: None,
                method: None,
                request_headers: Vec::new(),
                request_body: None,
                request_initiator_type: None,
                bidi_request_initiator_type: None,
                redirect_response: None,
                redirect_has_extra_info: false,
                request_cookie_report: None,
                resource_type,
                timestamp: Some(1.0),
                wall_time: None,
                status: Some(200),
                status_text: None,
                response_headers: Vec::new(),
                response_mime_type: None,
                response_protocol: None,
                has_extra_info: false,
                encoded_data_length: Some(0),
                from_cache: false,
                fetch_request_id: None,
                error_text: None,
                loading_failed_canceled: false,
                blocked_intercepts: Vec::new(),
                network_id: None,
                auth_challenge: None,
            })
        };

        let document = BackgroundProtocolEvent::immediate_automation_event(
            json!({"method": "Network.responseReceived"}),
            network_event(Some(DevToolsNetworkResourceType::Document)),
        );
        let script = BackgroundProtocolEvent::immediate_automation_event(
            json!({"method": "Network.responseReceived"}),
            network_event(Some(DevToolsNetworkResourceType::Script)),
        );
        let lifecycle = BackgroundProtocolEvent::immediate_automation_event(
            json!({"method": "Page.frameStartedLoading"}),
            AutomationEvent::NavigationFrame(NavigationFrameEvent {
                target_id: DevToolsTargetId::from("TID-nav"),
                frame_id: DevToolsFrameId::from("TID-nav"),
                parent_frame_id: None,
                loader_id: Some(DevToolsLoaderId::from("LOADER-nav")),
                url: "https://example.test/".to_owned(),
                kind: NavigationFrameEventKind::StartedLoading,
                frame_name: None,
                security_origin: None,
                secure_context_type: None,
            }),
        );
        let protocol_document = BackgroundProtocolEvent::immediate(json!({
            "method": "Network.responseReceived",
            "params": {
                "requestId": "REQ-protocol-document",
                "type": "Document"
            }
        }));
        let protocol_script = BackgroundProtocolEvent::immediate(json!({
            "method": "Network.responseReceived",
            "params": {
                "requestId": "REQ-protocol-script",
                "type": "Script"
            }
        }));
        let blocked_protocol_script = BackgroundProtocolEvent::immediate(json!({
            "method": "Network.requestWillBeSent",
            "params": {
                "requestId": "REQ-protocol-script-blocked",
                "type": "Script",
                "__moliBlockedInterceptors": ["intercept-script"]
            }
        }));
        let fetch_request_paused = BackgroundProtocolEvent::immediate(json!({
            "method": "Fetch.requestPaused",
            "params": {
                "requestId": "INT-script",
                "resourceType": "Script"
            }
        }));
        let fetch_auth_required = BackgroundProtocolEvent::immediate(json!({
            "method": "Fetch.authRequired",
            "params": {
                "requestId": "INT-auth",
                "resourceType": "Script"
            }
        }));
        let protocol_without_type = BackgroundProtocolEvent::immediate(json!({
            "method": "Network.responseReceived",
            "params": {
                "requestId": "REQ-protocol-unknown"
            }
        }));

        assert!(!document.should_wait_for_background_navigation_completion());
        assert!(script.should_wait_for_background_navigation_completion());
        assert!(!lifecycle.should_wait_for_background_navigation_completion());
        assert!(!protocol_document.should_wait_for_background_navigation_completion());
        assert!(protocol_script.should_wait_for_background_navigation_completion());
        assert!(!blocked_protocol_script.should_wait_for_background_navigation_completion());
        assert!(!fetch_request_paused.should_wait_for_background_navigation_completion());
        assert!(!fetch_auth_required.should_wait_for_background_navigation_completion());
        assert!(!protocol_without_type.should_wait_for_background_navigation_completion());
    }

    #[test]
    fn navigation_background_event_drops_stale_token() {
        let mut browser_context = BrowserContext::new("CTX-nav".to_owned());
        browser_context.set_active_target_id("TID-nav");
        let stale = browser_context
            .start_document_navigation_for_active_target("LOADER-1".to_owned())
            .expect("active target should produce stale token");
        let current = browser_context
            .start_document_navigation_for_active_target("LOADER-2".to_owned())
            .expect("active target should produce current token");
        let message = build_event(
            "Page.frameStoppedLoading",
            json!({ "frameId": "TID-nav" }),
            None,
        );

        let stale_event = NavigationBackgroundEvent::protocol_message(stale, message.clone());
        let current_event = NavigationBackgroundEvent::protocol_message(current, message.clone());

        assert_eq!(
            stale_event.into_protocol_message_if_current(std::iter::once(&browser_context)),
            None
        );
        assert_eq!(
            current_event.into_protocol_message_if_current(std::iter::once(&browser_context)),
            Some(message)
        );
    }

    #[test]
    fn protocol_message_output_strips_moli_private_fields() {
        let message = BackgroundProtocolEvent::immediate(json!({
            "method": "Fetch.authRequired",
            "params": {
                "requestId": "FETCH-1",
                "__moliBlockedInterceptors": ["intercept-auth"],
                "__moliFetchRequestId": "FETCH-1"
            }
        }))
        .into_protocol_message();

        assert_eq!(message["params"]["requestId"], json!("FETCH-1"));
        assert!(message["params"].get("__moliBlockedInterceptors").is_none());
        assert!(message["params"].get("__moliFetchRequestId").is_none());
    }
}