Skip to content

armgit / moli

Public Imported from GitHub
0

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

80.6 KB
Raw Blame
pub(crate) mod native;

use moli_core::page::{
    CompletedPageCommand, PendingPageCommand, RendererDomDebuggerDomBreakpointResolution,
    RendererDomDebuggerEventListener, RendererDomDebuggerEventListenerBreakpoint,
    RendererDomDebuggerEventListenersResolution, RendererDomDebuggerXhrBreakpoint,
};
use serde::Deserialize;
use serde_json::{Map, Value, json};

use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};
use crate::domains::actions::DomDebuggerAction;
use crate::domains::command_output::CommandOutputPlan;

pub(crate) struct PendingDomDebuggerCommandDispatch {
    command_id: Option<u64>,
    owner_scope: CommandOwnerScope,
    pending: PendingPageCommand,
    operation: CompletedDomDebuggerOperation,
}

pub(crate) struct CompletedDomDebuggerCommandDispatch {
    command_id: Option<u64>,
    owner_scope: CommandOwnerScope,
    completed: Result<CompletedPageCommand, String>,
    operation: CompletedDomDebuggerOperation,
}

#[derive(Clone)]
enum CompletedDomDebuggerOperation {
    GetEventListeners,
    ConfigureEventListenerBreakpoint {
        breakpoint: RendererDomDebuggerEventListenerBreakpoint,
        enabled: bool,
    },
    ConfigureXhrBreakpoint {
        breakpoint: RendererDomDebuggerXhrBreakpoint,
        enabled: bool,
    },
    ConfigureDomBreakpoint,
}

pub(crate) enum DomDebuggerCommandTaskStep {
    Pending(PendingDomDebuggerCommandDispatch),
    Complete(CommandOutputPlan),
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct GetEventListenersParams {
    object_id: String,
    #[serde(default = "default_depth")]
    depth: i32,
    #[serde(default)]
    pierce: bool,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct EventListenerBreakpointParams {
    event_name: String,
    #[serde(default)]
    target_name: Option<String>,
}

#[derive(Deserialize)]
struct XhrBreakpointParams {
    url: String,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DomBreakpointParams {
    node_id: u32,
    r#type: String,
}

fn default_depth() -> i32 {
    1
}

impl PendingDomDebuggerCommandDispatch {
    pub(crate) async fn wait(self) -> CompletedDomDebuggerCommandDispatch {
        CompletedDomDebuggerCommandDispatch {
            command_id: self.command_id,
            owner_scope: self.owner_scope,
            completed: self.pending.wait().await.map_err(|error| error.to_string()),
            operation: self.operation,
        }
    }
}

impl CompletedDomDebuggerCommandDispatch {
    pub(crate) fn command_id(&self) -> Option<u64> {
        self.command_id
    }

    pub(crate) fn session_id(&self) -> Option<&str> {
        self.owner_scope.session_id()
    }
}

pub(crate) fn try_start_dom_debugger_command_dispatch(
    conn: &mut CdpConnection,
    cmd: &Cmd<'_>,
) -> DomDebuggerCommandTaskStep {
    let action = match cmd.parse_action::<DomDebuggerAction>() {
        Some(action) => action,
        None => {
            return DomDebuggerCommandTaskStep::Complete(CommandOutputPlan::error(
                -32601,
                "UnknownMethod",
            ));
        }
    };
    if let Err(message) = conn.ensure_document_accessible_for_session_owner(cmd.session_id) {
        return DomDebuggerCommandTaskStep::Complete(CommandOutputPlan::error(-32000, message));
    }
    let renderer_inspector_session_id =
        conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
    let pending_and_operation = match action {
        DomDebuggerAction::GetEventListeners => {
            let params = match cmd.get_params::<GetEventListenersParams>() {
                Ok(Some(params)) => params,
                _ => return invalid_parameters(),
            };
            conn.loaded_page_mut_for_protocol_access(cmd.session_id)
                .and_then(|page| {
                    page.start_dom_debugger_get_event_listeners(
                        renderer_inspector_session_id,
                        params.object_id,
                        params.depth,
                        params.pierce,
                    )
                    .map(|pending| (pending, CompletedDomDebuggerOperation::GetEventListeners))
                    .map_err(|error| error.to_string())
                })
        }
        DomDebuggerAction::SetEventListenerBreakpoint
        | DomDebuggerAction::RemoveEventListenerBreakpoint => {
            let params = match cmd.get_params::<EventListenerBreakpointParams>() {
                Ok(Some(params)) => params,
                _ => return invalid_parameters(),
            };
            if params.event_name.is_empty() {
                return DomDebuggerCommandTaskStep::Complete(CommandOutputPlan::error(
                    -32000,
                    "Event name is empty",
                ));
            }
            let breakpoint = RendererDomDebuggerEventListenerBreakpoint::new(
                params.event_name,
                params.target_name,
            );
            let enabled = action == DomDebuggerAction::SetEventListenerBreakpoint;
            conn.loaded_page_mut_for_protocol_access(cmd.session_id)
                .and_then(|page| {
                    page.start_dom_debugger_configure_event_listener_breakpoint(
                        renderer_inspector_session_id,
                        breakpoint.clone(),
                        enabled,
                    )
                    .map(|pending| {
                        (
                            pending,
                            CompletedDomDebuggerOperation::ConfigureEventListenerBreakpoint {
                                breakpoint,
                                enabled,
                            },
                        )
                    })
                    .map_err(|error| error.to_string())
                })
        }
        DomDebuggerAction::SetXHRBreakpoint | DomDebuggerAction::RemoveXHRBreakpoint => {
            let params = match cmd.get_params::<XhrBreakpointParams>() {
                Ok(Some(params)) => params,
                _ => return invalid_parameters(),
            };
            let breakpoint = RendererDomDebuggerXhrBreakpoint::new(params.url);
            let enabled = action == DomDebuggerAction::SetXHRBreakpoint;
            conn.loaded_page_mut_for_protocol_access(cmd.session_id)
                .and_then(|page| {
                    page.start_dom_debugger_configure_xhr_breakpoint(
                        renderer_inspector_session_id,
                        breakpoint.clone(),
                        enabled,
                    )
                    .map(|pending| {
                        (
                            pending,
                            CompletedDomDebuggerOperation::ConfigureXhrBreakpoint {
                                breakpoint,
                                enabled,
                            },
                        )
                    })
                    .map_err(|error| error.to_string())
                })
        }
        DomDebuggerAction::SetDOMBreakpoint | DomDebuggerAction::RemoveDOMBreakpoint => {
            let params = match cmd.get_params::<DomBreakpointParams>() {
                Ok(Some(params)) => params,
                _ => return invalid_parameters(),
            };
            let enabled = action == DomDebuggerAction::SetDOMBreakpoint;
            conn.loaded_page_mut_for_protocol_access(cmd.session_id)
                .and_then(|page| {
                    page.start_dom_debugger_configure_dom_breakpoint(
                        renderer_inspector_session_id,
                        params.node_id,
                        params.r#type,
                        enabled,
                    )
                    .map(|pending| {
                        (
                            pending,
                            CompletedDomDebuggerOperation::ConfigureDomBreakpoint,
                        )
                    })
                    .map_err(|error| error.to_string())
                })
        }
    };
    match pending_and_operation {
        Ok((pending, operation)) => {
            DomDebuggerCommandTaskStep::Pending(PendingDomDebuggerCommandDispatch {
                command_id: cmd.id,
                owner_scope: CommandOwnerScope::capture(conn, cmd.session_id),
                pending,
                operation,
            })
        }
        Err(message) => {
            DomDebuggerCommandTaskStep::Complete(CommandOutputPlan::error(-32000, message))
        }
    }
}

fn invalid_parameters() -> DomDebuggerCommandTaskStep {
    DomDebuggerCommandTaskStep::Complete(CommandOutputPlan::error(-32602, "Invalid parameters"))
}

pub(crate) fn complete_pending_dom_debugger_command(
    conn: &mut CdpConnection,
    completed: CompletedDomDebuggerCommandDispatch,
) -> CommandOutputPlan {
    let session_id = completed.owner_scope.session_id().map(str::to_owned);
    match completed.operation {
        CompletedDomDebuggerOperation::GetEventListeners => {
            let resolution = completed.completed.and_then(|completion| {
                conn.loaded_page_mut_for_protocol_access_for_owner(&completed.owner_scope)
                    .and_then(|page| {
                        page.finish_dom_debugger_get_event_listeners(completion)
                            .map_err(|error| error.to_string())
                    })
            });
            match resolution {
                Ok(RendererDomDebuggerEventListenersResolution::Found(listeners)) => {
                    CommandOutputPlan::result(json!({
                        "listeners": listeners.into_iter().map(listener_payload).collect::<Vec<_>>()
                    }))
                }
                Ok(RendererDomDebuggerEventListenersResolution::InvalidRemoteObjectId(message))
                | Err(message) => CommandOutputPlan::error(-32000, message),
            }
        }
        CompletedDomDebuggerOperation::ConfigureEventListenerBreakpoint {
            breakpoint,
            enabled,
        } => {
            let completion = completed.completed.and_then(|completion| {
                conn.loaded_page_mut_for_protocol_access_for_owner(&completed.owner_scope)
                    .and_then(|page| {
                        page.finish_unit_runtime_page_command(
                            completion,
                            "DOMDebugger event listener breakpoint",
                        )
                        .map_err(|error| error.to_string())
                    })
            });
            if let Err(message) = completion {
                return CommandOutputPlan::error(-32000, message);
            }
            let recorded = conn.with_target_devtools_session_state_for_session_mut(
                session_id.as_deref(),
                |state| {
                    if enabled {
                        state
                            .dom_debugger_event_listener_breakpoints
                            .insert(breakpoint);
                    } else {
                        state
                            .dom_debugger_event_listener_breakpoints
                            .remove(&breakpoint);
                    }
                },
            );
            if recorded.is_none() {
                return CommandOutputPlan::error(-32000, "NoSuchTarget");
            }
            CommandOutputPlan::result(json!({}))
        }
        CompletedDomDebuggerOperation::ConfigureXhrBreakpoint {
            breakpoint,
            enabled,
        } => {
            let completion = completed.completed.and_then(|completion| {
                conn.loaded_page_mut_for_protocol_access_for_owner(&completed.owner_scope)
                    .and_then(|page| {
                        page.finish_unit_runtime_page_command(
                            completion,
                            "DOMDebugger XHR breakpoint",
                        )
                        .map_err(|error| error.to_string())
                    })
            });
            if let Err(message) = completion {
                return CommandOutputPlan::error(-32000, message);
            }
            let recorded = conn.with_target_devtools_session_state_for_session_mut(
                session_id.as_deref(),
                |state| {
                    if enabled {
                        state.dom_debugger_xhr_breakpoints.insert(breakpoint);
                    } else {
                        state.dom_debugger_xhr_breakpoints.remove(&breakpoint);
                    }
                },
            );
            if recorded.is_none() {
                return CommandOutputPlan::error(-32000, "NoSuchTarget");
            }
            CommandOutputPlan::result(json!({}))
        }
        CompletedDomDebuggerOperation::ConfigureDomBreakpoint => {
            let resolution = completed.completed.and_then(|completion| {
                conn.loaded_page_mut_for_protocol_access_for_owner(&completed.owner_scope)
                    .and_then(|page| {
                        page.finish_dom_debugger_configure_dom_breakpoint(completion)
                            .map_err(|error| error.to_string())
                    })
            });
            match resolution {
                Ok(RendererDomDebuggerDomBreakpointResolution::Configured) => {
                    CommandOutputPlan::result(json!({}))
                }
                Ok(RendererDomDebuggerDomBreakpointResolution::NodeNotFound) => {
                    CommandOutputPlan::error(-32000, "Could not find node with given id")
                }
                Ok(RendererDomDebuggerDomBreakpointResolution::UnknownType(breakpoint_type)) => {
                    CommandOutputPlan::error(
                        -32000,
                        format!("Unknown DOM breakpoint type: {breakpoint_type}"),
                    )
                }
                Err(message) => CommandOutputPlan::error(-32000, message),
            }
        }
    }
}

fn listener_payload(listener: RendererDomDebuggerEventListener) -> Value {
    let mut payload = Map::from_iter([
        ("type".to_owned(), Value::String(listener.event_type)),
        ("useCapture".to_owned(), Value::Bool(listener.use_capture)),
        ("passive".to_owned(), Value::Bool(listener.passive)),
        ("once".to_owned(), Value::Bool(listener.once)),
        ("scriptId".to_owned(), Value::String(listener.script_id)),
        ("lineNumber".to_owned(), json!(listener.line_number)),
        ("columnNumber".to_owned(), json!(listener.column_number)),
    ]);
    if let Some(handler) = listener.handler {
        payload.insert("handler".to_owned(), handler);
    }
    if let Some(original_handler) = listener.original_handler {
        payload.insert("originalHandler".to_owned(), original_handler);
    }
    if let Some(backend_node_id) = listener.backend_node_id {
        payload.insert("backendNodeId".to_owned(), json!(backend_node_id));
    }
    Value::Object(payload)
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;
    use std::time::Duration;

    use serde_json::{Value, json};

    use crate::{
        conn::{BrowserContext, CdpCommandTaskStep},
        testing::TestContext,
    };

    // Full-workspace CI runs these renderer-owner tests alongside CPU-heavy
    // suites. Keep the guard diagnostic, but allow the same scheduling
    // headroom as the test scheduler's external-input waits.
    const DOM_DEBUGGER_COMMAND_TIMEOUT: Duration = Duration::from_secs(30);

    async fn command(ctx: &mut TestContext, message: Value, command_id: u64) -> Value {
        tokio::time::timeout(DOM_DEBUGGER_COMMAND_TIMEOUT, ctx.process_async(message))
            .await
            .unwrap_or_else(|_| {
                panic!("timed out processing DOMDebugger test command {command_id}")
            });
        ctx.take_response_by_id(command_id)
    }

    async fn run_pausing_evaluate_with_observed_resumes(
        ctx: &mut TestContext,
        evaluate: Value,
        resumes: Vec<Value>,
    ) {
        let evaluate_id = evaluate["id"]
            .as_u64()
            .expect("Runtime.evaluate test command must have a numeric id");
        // Keep the pending Runtime.evaluate receiver alive while the test
        // scheduler observes the real renderer publication. Dispatching the
        // interruptible resume before that publication is racy: the interrupt
        // channel can overtake the evaluate request and resume an idle
        // inspector, leaving the later pause without a matching command.
        let evaluate_step = ctx.conn.start_command_dispatch(&evaluate.to_string());
        let CdpCommandTaskStep::Pending(evaluate_pending) = evaluate_step else {
            panic!("a pausing Runtime.evaluate must remain pending until Debugger.resume");
        };
        let mut messages = Vec::new();

        for resume in resumes {
            let resume_id = resume["id"]
                .as_u64()
                .expect("Debugger.resume test command must have a numeric id");
            let resume_session_id = resume.get("sessionId").cloned();
            let paused = ctx
                .wait_for_scheduler_message("pause preceding Debugger.resume", |message| {
                    message["method"] == json!("Debugger.paused")
                        && match &resume_session_id {
                            Some(session_id) => message.get("sessionId") == Some(session_id),
                            None => message.get("sessionId").is_none(),
                        }
                })
                .await;
            messages.push(paused);

            let response_start = ctx.sent.len();
            let resume_step = ctx.conn.start_command_dispatch(&resume.to_string());
            let (mut resume_messages, scheduler_events) = tokio::time::timeout(
                DOM_DEBUGGER_COMMAND_TIMEOUT,
                ctx.complete_command_task_step_for_test(resume_step),
            )
            .await
            .expect("Debugger.resume should complete after its matching pause");
            assert!(scheduler_events.is_empty(), "{scheduler_events:?}");
            if !resume_messages
                .iter()
                .any(|message| message["id"] == json!(resume_id))
            {
                ctx.wait_for_test_command_response(resume_id, response_start)
                    .await;
                resume_messages.push(ctx.take_response_by_id(resume_id));
            }
            messages.append(&mut resume_messages);
        }

        let evaluate_completed =
            tokio::time::timeout(DOM_DEBUGGER_COMMAND_TIMEOUT, evaluate_pending.wait())
                .await
                .expect("Debugger.resume should release the paused Runtime.evaluate");
        let evaluate_step = ctx
            .conn
            .complete_pending_command_dispatch(evaluate_completed)
            .await;
        let (mut evaluate_messages, scheduler_events) = tokio::time::timeout(
            DOM_DEBUGGER_COMMAND_TIMEOUT,
            ctx.complete_command_task_step_for_test(evaluate_step),
        )
        .await
        .expect("resumed Runtime.evaluate should complete");
        assert!(scheduler_events.is_empty(), "{scheduler_events:?}");
        if !evaluate_messages
            .iter()
            .any(|message| message["id"] == json!(evaluate_id))
        {
            if !ctx
                .sent
                .iter()
                .any(|message| message["id"] == json!(evaluate_id))
            {
                let response_start = ctx.sent.len();
                ctx.wait_for_test_command_response(evaluate_id, response_start)
                    .await;
            }
            evaluate_messages.push(ctx.take_response_by_id(evaluate_id));
        }
        messages.append(&mut evaluate_messages);
        ctx.sent.extend(messages);
    }

    async fn load_document(ctx: &mut TestContext, html: &str) {
        let mut browser_context = BrowserContext::new("BID-1".into());
        browser_context.set_active_target_id("TID-1".to_owned());
        browser_context.set_target_url("data:text/html,dom-debugger-test".to_owned());
        browser_context.attach_active_session("SID-1".to_owned());
        ctx.conn
            .install_browser_context_fixture_for_test(browser_context);
        ctx.install_navigation_fixture_for_session_owner(
            &format!("data:text/html,{html}"),
            Some("SID-1"),
        )
        .await;
    }

    async fn evaluate_object(
        ctx: &mut TestContext,
        id: u64,
        expression: &str,
        object_group: Option<&str>,
    ) -> String {
        let mut params = json!({ "expression": expression });
        if let Some(object_group) = object_group {
            params["objectGroup"] = json!(object_group);
        }
        ctx.process_async(json!({
            "id": id,
            "method": "Runtime.evaluate",
            "sessionId": "SID-1",
            "params": params
        }))
        .await;
        let response = ctx.take_response_by_id(id);
        response["result"]["result"]["objectId"]
            .as_str()
            .unwrap_or_else(|| panic!("Runtime.evaluate should return an object: {response:?}"))
            .to_owned()
    }

    async fn dom_node_id(ctx: &mut TestContext, id: u64, selector: &str) -> u32 {
        let document = command(
            ctx,
            json!({
                "id": id,
                "method": "DOM.getDocument",
                "sessionId": "SID-1",
                "params": { "depth": 1 }
            }),
            id,
        )
        .await;
        let root_node_id = document["result"]["root"]["nodeId"]
            .as_u64()
            .expect("DOM.getDocument root node id") as u32;
        let query_id = id + 1;
        let query = command(
            ctx,
            json!({
                "id": query_id,
                "method": "DOM.querySelector",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "selector": selector }
            }),
            query_id,
        )
        .await;
        query["result"]["nodeId"]
            .as_u64()
            .unwrap_or_else(|| panic!("DOM.querySelector should find {selector}: {query:?}"))
            as u32
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn dom_breakpoints_validate_nodes_pause_before_mutations_and_remove_cleanly() {
        let mut ctx = TestContext::new();
        load_document(
            &mut ctx,
            "<!doctype html><main id=root><section id=middle><span>old</span></section></main>",
        )
        .await;

        let enable = command(
            &mut ctx,
            json!({
                "id": 80,
                "method": "Debugger.enable",
                "sessionId": "SID-1"
            }),
            80,
        )
        .await;
        assert!(enable.get("error").is_none(), "{enable:?}");
        let root_node_id = dom_node_id(&mut ctx, 81, "#root").await;

        let missing_precedes_type = command(
            &mut ctx,
            json!({
                "id": 83,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": 999999, "type": "bogus" }
            }),
            83,
        )
        .await;
        assert_eq!(
            missing_precedes_type["error"]["message"],
            json!("Could not find node with given id")
        );

        let invalid_type = command(
            &mut ctx,
            json!({
                "id": 84,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "bogus" }
            }),
            84,
        )
        .await;
        assert_eq!(
            invalid_type["error"]["message"],
            json!("Unknown DOM breakpoint type: bogus")
        );

        let set = command(
            &mut ctx,
            json!({
                "id": 85,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "subtree-modified" }
            }),
            85,
        )
        .await;
        assert_eq!(set["result"], json!({}), "{set:?}");

        let output_start = ctx.sent.len();
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 86,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "middle.appendChild(document.createElement('b')); true",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 87,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let mut saw_target_path = false;
        let paused = ctx
            .wait_for_scheduler_message("DOM mutation breakpoint pause", |message| {
                if message["method"] == json!("DOM.setChildNodes")
                    && message["sessionId"] == json!("SID-1")
                {
                    saw_target_path = true;
                    return false;
                }
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("DOM")
            })
            .await;
        assert!(
            saw_target_path,
            "unbound mutation target path must precede Debugger.paused: {:?}",
            &ctx.sent[output_start..]
        );
        assert_eq!(paused["params"]["reason"], json!("DOM"), "{paused:?}");
        assert_eq!(
            paused["params"]["data"]["nodeId"],
            json!(root_node_id),
            "{paused:?}"
        );
        assert_eq!(
            paused["params"]["data"]["type"],
            json!("subtree-modified"),
            "{paused:?}"
        );
        assert_eq!(paused["params"]["data"]["insertion"], json!(true));
        let middle_node_id = paused["params"]["data"]["targetNodeId"]
            .as_u64()
            .filter(|node_id| *node_id > 0)
            .unwrap_or_else(|| panic!("subtree pause should bind the target node: {paused:?}"))
            as u32;

        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 180,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "(() => { const fragment = document.createDocumentFragment(); fragment.appendChild(document.createElement('i')); fragment.appendChild(document.createElement('u')); middle.appendChild(fragment); return true; })()",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 181,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let fragment_pause = ctx
            .wait_for_scheduler_message("DocumentFragment insertion DOM pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("DOM")
            })
            .await;
        assert_eq!(
            fragment_pause["params"]["data"]["insertion"],
            json!(true),
            "DocumentFragment insertion should report one insertion batch pause"
        );
        let fragment_result = ctx.take_response_by_id(180);
        assert_eq!(
            fragment_result["result"]["result"]["value"],
            json!(true),
            "DocumentFragment insertion should complete after one resume: {fragment_result:?}"
        );
        let remove = command(
            &mut ctx,
            json!({
                "id": 88,
                "method": "DOMDebugger.removeDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "subtree-modified" }
            }),
            88,
        )
        .await;
        assert_eq!(remove["result"], json!({}), "{remove:?}");
        let unpaused = command(
            &mut ctx,
            json!({
                "id": 89,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "middle.appendChild(document.createElement('i')); true",
                    "returnByValue": true
                }
            }),
            89,
        )
        .await;
        assert_eq!(unpaused["result"]["result"]["value"], json!(true));

        let initial_attribute = command(
            &mut ctx,
            json!({
                "id": 90,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "root.setAttribute('data-value', 'same'); true",
                    "returnByValue": true
                }
            }),
            90,
        )
        .await;
        assert_eq!(initial_attribute["result"]["result"]["value"], json!(true));
        let set_attribute = command(
            &mut ctx,
            json!({
                "id": 91,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "attribute-modified" }
            }),
            91,
        )
        .await;
        assert_eq!(set_attribute["result"], json!({}), "{set_attribute:?}");
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 92,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "root.setAttribute('data-value', 'same'); true",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 93,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let attribute_pause = ctx
            .wait_for_scheduler_message("same-value attribute DOM breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("DOM")
            })
            .await;
        assert_eq!(
            attribute_pause["params"]["data"],
            json!({
                "nodeId": root_node_id,
                "type": "attribute-modified"
            }),
            "{attribute_pause:?}"
        );
        let remove_attribute = command(
            &mut ctx,
            json!({
                "id": 94,
                "method": "DOMDebugger.removeDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "attribute-modified" }
            }),
            94,
        )
        .await;
        assert_eq!(
            remove_attribute["result"],
            json!({}),
            "{remove_attribute:?}"
        );

        let set_subtree = command(
            &mut ctx,
            json!({
                "id": 95,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "subtree-modified" }
            }),
            95,
        )
        .await;
        assert_eq!(set_subtree["result"], json!({}), "{set_subtree:?}");
        let set_node_removed = command(
            &mut ctx,
            json!({
                "id": 98,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": middle_node_id, "type": "node-removed" }
            }),
            98,
        )
        .await;
        assert_eq!(
            set_node_removed["result"],
            json!({}),
            "{set_node_removed:?}"
        );
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 99,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "globalThis.removedMiddle = middle; middle.remove(); true",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 100,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let removal_pause = ctx
            .wait_for_scheduler_message("direct node-removed DOM breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("DOM")
            })
            .await;
        assert_eq!(
            removal_pause["params"]["data"],
            json!({
                "nodeId": middle_node_id,
                "type": "node-removed"
            }),
            "a direct node-removed breakpoint wins over an ancestor subtree breakpoint: \
             {removal_pause:?}"
        );
        let remove_subtree = command(
            &mut ctx,
            json!({
                "id": 101,
                "method": "DOMDebugger.removeDOMBreakpoint",
                "sessionId": "SID-1",
                "params": { "nodeId": root_node_id, "type": "subtree-modified" }
            }),
            101,
        )
        .await;
        assert_eq!(remove_subtree["result"], json!({}), "{remove_subtree:?}");
        let detached_breakpoint_does_not_return = command(
            &mut ctx,
            json!({
                "id": 102,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "root.appendChild(removedMiddle); removedMiddle.remove(); true",
                    "returnByValue": true
                }
            }),
            102,
        )
        .await;
        assert_eq!(
            detached_breakpoint_does_not_return["result"]["result"]["value"],
            json!(true)
        );

        let rebound_root_node_id = dom_node_id(&mut ctx, 103, "#root").await;
        let set_before_disable = command(
            &mut ctx,
            json!({
                "id": 105,
                "method": "DOMDebugger.setDOMBreakpoint",
                "sessionId": "SID-1",
                "params": {
                    "nodeId": rebound_root_node_id,
                    "type": "attribute-modified"
                }
            }),
            105,
        )
        .await;
        assert_eq!(
            set_before_disable["result"],
            json!({}),
            "{set_before_disable:?}"
        );
        let disable = command(
            &mut ctx,
            json!({
                "id": 106,
                "method": "DOM.disable",
                "sessionId": "SID-1"
            }),
            106,
        )
        .await;
        assert_eq!(disable["result"], json!({}), "{disable:?}");
        let after_disable = command(
            &mut ctx,
            json!({
                "id": 107,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "root.setAttribute('data-disabled', '1'); true",
                    "returnByValue": true
                }
            }),
            107,
        )
        .await;
        assert_eq!(after_disable["result"]["result"]["value"], json!(true));
    }

    async fn get_listeners(
        ctx: &mut TestContext,
        id: u64,
        object_id: &str,
        extra_params: Value,
    ) -> Vec<Value> {
        let mut params = json!({ "objectId": object_id });
        params
            .as_object_mut()
            .expect("params should be an object")
            .extend(
                extra_params
                    .as_object()
                    .expect("extra params should be an object")
                    .clone(),
            );
        ctx.process_async(json!({
            "id": id,
            "method": "DOMDebugger.getEventListeners",
            "sessionId": "SID-1",
            "params": params
        }))
        .await;
        let response = ctx.take_response_by_id(id);
        response["result"]["listeners"]
            .as_array()
            .unwrap_or_else(|| panic!("DOMDebugger should return listeners: {response:?}"))
            .clone()
    }

    fn listeners_by_type(listeners: &[Value]) -> HashMap<&str, &Value> {
        listeners
            .iter()
            .map(|listener| {
                (
                    listener["type"]
                        .as_str()
                        .expect("listener should have a type"),
                    listener,
                )
            })
            .collect()
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn get_event_listeners_matches_chromium_node_depth_and_listener_shape() {
        let mut ctx = TestContext::new();
        load_document(
            &mut ctx,
            "<main id=root><button id=child><span id=grand></span></button></main>",
        )
        .await;
        let root_id = evaluate_object(
            &mut ctx,
            1,
            r#"(() => {
                const root = document.querySelector('#root');
                const child = document.querySelector('#child');
                const grand = document.querySelector('#grand');
                function removed() {}
                function duplicate() {}
                root.addEventListener('removed', removed);
                root.removeEventListener('removed', removed);
                root.addEventListener('duplicate', duplicate);
                root.addEventListener('duplicate', duplicate);
                root.addEventListener('root-bubble', function rootBubble() {});
                root.addEventListener('root-capture', function rootCapture() {}, {
                    capture: true,
                    passive: true,
                    once: true
                });
                root.onclick = function rootProperty() {};
                root.addEventListener('group-a', function groupAFirst() {});
                root.addEventListener('group-b', function groupB() {});
                root.addEventListener('group-a', function groupASecond() {});
                child.addEventListener('child-listener', function childListener() {});
                grand.addEventListener('grand-listener', function grandListener() {});
                const shadowHost = document.createElement('section');
                root.append(shadowHost);
                const shadowChild = shadowHost.attachShadow({mode: 'open'}).appendChild(
                    document.createElement('i')
                );
                shadowChild.addEventListener('shadow-listener', function shadowListener() {});
                return root;
            })()"#,
            None,
        )
        .await;

        ctx.process_async(json!({
            "id": 30,
            "method": "Page.getFrameTree",
            "sessionId": "SID-1"
        }))
        .await;
        let frame_tree = ctx.take_response_by_id(30);
        let frame_id = frame_tree["result"]["frameTree"]["frame"]["id"]
            .as_str()
            .unwrap_or_else(|| panic!("Page.getFrameTree should return a frame id: {frame_tree:?}"))
            .to_owned();
        ctx.process_async(json!({
            "id": 31,
            "method": "Page.createIsolatedWorld",
            "sessionId": "SID-1",
            "params": {
                "frameId": frame_id,
                "worldName": "dom-debugger-listener-world"
            }
        }))
        .await;
        let isolated_world = ctx.take_response_by_id(31);
        let isolated_context_id = isolated_world["result"]["executionContextId"]
            .as_i64()
            .unwrap_or_else(|| {
                panic!("Page.createIsolatedWorld should return a context: {isolated_world:?}")
            });
        ctx.process_async(json!({
            "id": 32,
            "method": "Runtime.evaluate",
            "sessionId": "SID-1",
            "params": {
                "contextId": isolated_context_id,
                "expression": "document.querySelector('#root').addEventListener('isolated-listener', function isolatedListener() {})"
            }
        }))
        .await;
        assert!(ctx.take_response_by_id(32).get("error").is_none());

        let default_listeners = get_listeners(&mut ctx, 2, &root_id, json!({})).await;
        assert_eq!(
            default_listeners
                .iter()
                .map(|listener| listener["type"].as_str().unwrap())
                .collect::<Vec<_>>(),
            vec![
                "root-capture",
                "duplicate",
                "root-bubble",
                "click",
                "group-a",
                "group-a",
                "group-b",
            ],
            "Chromium groups listeners by event-type insertion order after capture partitioning"
        );
        let by_type = listeners_by_type(&default_listeners);
        assert!(by_type.contains_key("duplicate"));
        assert!(by_type.contains_key("root-bubble"));
        assert!(by_type.contains_key("click"));
        assert!(!by_type.contains_key("removed"));
        assert!(!by_type.contains_key("child-listener"));
        assert!(!by_type.contains_key("isolated-listener"));
        assert_eq!(by_type["root-capture"]["useCapture"], json!(true));
        assert_eq!(by_type["root-capture"]["passive"], json!(true));
        assert_eq!(by_type["root-capture"]["once"], json!(true));
        let root_backend_id = default_listeners[0]["backendNodeId"]
            .as_u64()
            .expect("node listener should have a backendNodeId");
        for listener in &default_listeners {
            assert_eq!(listener["backendNodeId"], json!(root_backend_id));
            assert!(listener["scriptId"].is_string());
            assert!(listener["lineNumber"].is_i64());
            assert!(listener["columnNumber"].is_i64());
            assert!(listener.get("handler").is_none());
            assert!(listener.get("originalHandler").is_none());
        }

        let depth_two = get_listeners(&mut ctx, 3, &root_id, json!({ "depth": 2 })).await;
        let by_type = listeners_by_type(&depth_two);
        assert!(by_type.contains_key("child-listener"));
        assert!(!by_type.contains_key("grand-listener"));
        assert_ne!(
            by_type["child-listener"]["backendNodeId"],
            json!(root_backend_id)
        );

        let full_subtree = get_listeners(&mut ctx, 4, &root_id, json!({ "depth": -1 })).await;
        let by_type = listeners_by_type(&full_subtree);
        assert!(by_type.contains_key("grand-listener"));
        assert!(!by_type.contains_key("shadow-listener"));
        assert!(!by_type.contains_key("isolated-listener"));

        let pierced_subtree = get_listeners(
            &mut ctx,
            5,
            &root_id,
            json!({ "depth": -1, "pierce": true }),
        )
        .await;
        let by_type = listeners_by_type(&pierced_subtree);
        assert!(by_type.contains_key("shadow-listener"));
        assert!(by_type.contains_key("isolated-listener"));

        let plain_object_id = evaluate_object(&mut ctx, 6, "({ answer: 42 })", None).await;
        assert!(
            get_listeners(&mut ctx, 7, &plain_object_id, json!({}))
                .await
                .is_empty(),
            "Chromium returns an empty listener array for non-EventTarget objects"
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn get_event_listeners_wraps_handlers_in_the_source_object_group() {
        let mut ctx = TestContext::new();
        load_document(&mut ctx, "<!doctype html><title>object listener</title>").await;
        let target_id = evaluate_object(
            &mut ctx,
            10,
            r#"(() => {
                globalThis.inspectorListenerObject = {
                    handleEvent: function inspectorObjectHandler() {}
                };
                const target = new EventTarget();
                function removedNumericTwo() {}
                target.addEventListener('2', removedNumericTwo);
                target.addEventListener('1', function numericOne() {});
                target.removeEventListener('2', removedNumericTwo);
                target.addEventListener('2', function numericTwo() {});
                target.addEventListener('object-event', inspectorListenerObject);
                return target;
            })()"#,
            Some("listener-group"),
        )
        .await;
        let listeners = get_listeners(&mut ctx, 11, &target_id, json!({})).await;
        assert_eq!(
            listeners
                .iter()
                .map(|listener| listener["type"].as_str().unwrap())
                .collect::<Vec<_>>(),
            vec!["1", "2", "object-event"],
            "numeric event names and remove/re-add must retain Chromium's event-type insertion order"
        );
        let listener = listeners
            .iter()
            .find(|listener| listener["type"] == json!("object-event"))
            .expect("object listener should be reported");
        assert!(listener.get("backendNodeId").is_none());
        assert_eq!(listener["handler"]["type"], json!("function"));
        assert_eq!(listener["originalHandler"]["type"], json!("object"));
        let handler_id = listener["handler"]["objectId"]
            .as_str()
            .expect("handler should have a RemoteObject id")
            .to_owned();
        let original_handler_id = listener["originalHandler"]["objectId"]
            .as_str()
            .expect("originalHandler should have a RemoteObject id")
            .to_owned();

        for (id, object_id, expression) in [
            (
                12,
                handler_id.as_str(),
                "function() { return this === inspectorListenerObject.handleEvent; }",
            ),
            (
                13,
                original_handler_id.as_str(),
                "function() { return this === inspectorListenerObject; }",
            ),
        ] {
            ctx.process_async(json!({
                "id": id,
                "method": "Runtime.callFunctionOn",
                "sessionId": "SID-1",
                "params": {
                    "objectId": object_id,
                    "functionDeclaration": expression,
                    "returnByValue": true
                }
            }))
            .await;
            assert_eq!(
                ctx.take_response_by_id(id)["result"]["result"]["value"],
                json!(true)
            );
        }

        ctx.process_async(json!({
            "id": 14,
            "method": "Runtime.releaseObjectGroup",
            "sessionId": "SID-1",
            "params": { "objectGroup": "listener-group" }
        }))
        .await;
        assert_eq!(ctx.take_response_by_id(14)["result"], json!({}));
        ctx.process_async(json!({
            "id": 15,
            "method": "Runtime.getProperties",
            "sessionId": "SID-1",
            "params": { "objectId": handler_id }
        }))
        .await;
        assert_eq!(ctx.take_response_by_id(15)["error"]["code"], json!(-32000));
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn get_event_listeners_rejects_invalid_params_and_stale_object_ids() {
        let mut ctx = TestContext::new();
        load_document(&mut ctx, "<!doctype html><title>invalid object</title>").await;

        ctx.process_async(json!({
            "id": 20,
            "method": "DOMDebugger.getEventListeners",
            "sessionId": "SID-1",
            "params": {}
        }))
        .await;
        assert_eq!(ctx.take_response_by_id(20)["error"]["code"], json!(-32602));

        let object_id = evaluate_object(
            &mut ctx,
            21,
            "(() => { const target = new EventTarget(); return target; })()",
            None,
        )
        .await;
        // The fixture installs SID-1 directly, so advance the test connection's
        // session-id generator before exercising a second real attachment.
        let _ = ctx.conn.gen_session_id();
        ctx.process_async(json!({
            "id": 22,
            "method": "Runtime.releaseObject",
            "sessionId": "SID-1",
            "params": { "objectId": object_id }
        }))
        .await;
        assert_eq!(ctx.take_response_by_id(22)["result"], json!({}));
        ctx.process_async(json!({
            "id": 23,
            "method": "DOMDebugger.getEventListeners",
            "sessionId": "SID-1",
            "params": { "objectId": object_id }
        }))
        .await;
        let response = ctx.take_response_by_id(23);
        assert_eq!(response["error"]["code"], json!(-32000));
        assert_eq!(
            response["error"]["message"],
            json!("Could not find object with given id")
        );

        let other_session_object_id = evaluate_object(
            &mut ctx,
            24,
            "(() => { const target = new EventTarget(); target.addEventListener('x', () => {}); return target; })()",
            None,
        )
        .await;
        ctx.process_async(json!({
            "id": 25,
            "method": "Target.attachToTarget",
            "params": { "targetId": "TID-1", "flatten": true }
        }))
        .await;
        let attached = ctx.take_response_by_id(25);
        let other_session_id = attached["result"]["sessionId"]
            .as_str()
            .unwrap_or_else(|| {
                panic!("Target.attachToTarget should return a session: {attached:?}")
            })
            .to_owned();
        assert_ne!(other_session_id, "SID-1");
        ctx.process_async(json!({
            "id": 26,
            "method": "DOMDebugger.getEventListeners",
            "sessionId": other_session_id,
            "params": { "objectId": other_session_object_id }
        }))
        .await;
        let response = ctx.take_response_by_id(26);
        assert_eq!(
            response["error"]["code"],
            json!(-32000),
            "another Inspector session must not unwrap the first session's object: {response:?}"
        );
        assert_eq!(
            response["error"]["message"],
            json!("Could not find object with given id")
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn event_listener_breakpoint_pauses_matching_callbacks_and_survives_navigation() {
        let mut ctx = TestContext::new();
        load_document(&mut ctx, "<!doctype html><button id=target>run</button>").await;

        let enable = command(
            &mut ctx,
            json!({
                "id": 100,
                "method": "Debugger.enable",
                "sessionId": "SID-1"
            }),
            100,
        )
        .await;
        assert!(enable.get("error").is_none(), "{enable:?}");

        for (id, method) in [
            (101, "DOMDebugger.setEventListenerBreakpoint"),
            (102, "DOMDebugger.removeEventListenerBreakpoint"),
        ] {
            let response = command(
                &mut ctx,
                json!({
                    "id": id,
                    "method": method,
                    "sessionId": "SID-1",
                    "params": { "eventName": "" }
                }),
                id,
            )
            .await;
            assert_eq!(response["error"]["code"], json!(-32000), "{response:?}");
            assert_eq!(
                response["error"]["message"],
                json!("Event name is empty"),
                "{response:?}"
            );
        }

        let set = command(
            &mut ctx,
            json!({
                "id": 103,
                "method": "DOMDebugger.setEventListenerBreakpoint",
                "sessionId": "SID-1",
                "params": { "eventName": "click", "targetName": "button" }
            }),
            103,
        )
        .await;
        assert_eq!(set["result"], json!({}), "{set:?}");

        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 104,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": r#"
                        target.addEventListener('click', function eventBreakpointListener() {
                            globalThis.__eventBreakpointHits =
                                (globalThis.__eventBreakpointHits || 0) + 1;
                        });
                        target.click();
                        true
                    "#,
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 105,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;

        let paused = ctx
            .wait_for_scheduler_message("event listener breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("EventListener")
            })
            .await;
        assert_eq!(
            paused["params"]["data"],
            json!({
                "eventName": "listener:click",
                "targetName": "BUTTON"
            }),
            "{paused:?}"
        );
        let evaluate = ctx.take_response_by_id(104);
        assert_eq!(evaluate["result"]["result"]["value"], json!(true));
        let resume = ctx.take_response_by_id(105);
        assert_eq!(resume["result"], json!({}), "{resume:?}");

        let remove = command(
            &mut ctx,
            json!({
                "id": 106,
                "method": "DOMDebugger.removeEventListenerBreakpoint",
                "sessionId": "SID-1",
                "params": { "eventName": "click", "targetName": "BUTTON" }
            }),
            106,
        )
        .await;
        assert_eq!(remove["result"], json!({}), "{remove:?}");
        let unpaused_click = command(
            &mut ctx,
            json!({
                "id": 107,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "target.click(); globalThis.__eventBreakpointHits",
                    "returnByValue": true
                }
            }),
            107,
        )
        .await;
        assert_eq!(
            unpaused_click["result"]["result"]["value"],
            json!(2),
            "remove must cancel the exact canonical targetName breakpoint: {unpaused_click:?}"
        );

        let restore_set = command(
            &mut ctx,
            json!({
                "id": 108,
                "method": "DOMDebugger.setEventListenerBreakpoint",
                "sessionId": "SID-1",
                "params": { "eventName": "click" }
            }),
            108,
        )
        .await;
        assert_eq!(restore_set["result"], json!({}), "{restore_set:?}");
        let navigate = command(
            &mut ctx,
            json!({
                "id": 109,
                "method": "Page.navigate",
                "sessionId": "SID-1",
                "params": {
                    "url": "data:text/html,<button id=after>after</button>"
                }
            }),
            109,
        )
        .await;
        assert!(navigate["result"]["frameId"].is_string(), "{navigate:?}");
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 110,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "after.addEventListener('click', () => 42); after.click(); true",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 111,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let restored_pause = ctx
            .wait_for_scheduler_message("restored event listener breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("EventListener")
                    && message["params"]["data"]["eventName"] == json!("listener:click")
                    && message["params"]["data"]["targetName"] == json!("BUTTON")
            })
            .await;
        assert_eq!(restored_pause["params"]["reason"], json!("EventListener"));
        let evaluate = ctx.take_response_by_id(110);
        assert_eq!(evaluate["result"]["result"]["value"], json!(true));
        let final_resume = ctx.take_response_by_id(111);
        assert_eq!(final_resume["result"], json!({}), "{final_resume:?}");
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn event_listener_breakpoint_is_session_owned_and_covers_simple_event_targets() {
        let mut ctx = TestContext::new();
        load_document(
            &mut ctx,
            "<!doctype html><title>simple target breakpoint</title>",
        )
        .await;
        {
            let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
            assert!(browser_context.assign_attached_session_to_target(
                "TID-1",
                "SID-event-breakpoint-owner".to_owned(),
            ));
        }

        let primary_enable = command(
            &mut ctx,
            json!({
                "id": 120,
                "method": "Debugger.enable",
                "sessionId": "SID-1"
            }),
            120,
        )
        .await;
        assert!(primary_enable.get("error").is_none(), "{primary_enable:?}");
        let setup = command(
            &mut ctx,
            json!({
                "id": 121,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": r#"
                        globalThis.__breakpointTarget = new EventTarget();
                        globalThis.__breakpointCount = 0;
                        __breakpointTarget.addEventListener('custom', () => ++__breakpointCount);
                        true
                    "#
                }
            }),
            121,
        )
        .await;
        assert_eq!(setup["result"]["result"]["value"], json!(true));
        let set = command(
            &mut ctx,
            json!({
                "id": 122,
                "method": "DOMDebugger.setEventListenerBreakpoint",
                "sessionId": "SID-event-breakpoint-owner",
                "params": { "eventName": "custom", "targetName": "EventTargetImpl" }
            }),
            122,
        )
        .await;
        assert_eq!(set["result"], json!({}), "{set:?}");

        let owner_disabled_dispatch = command(
            &mut ctx,
            json!({
                "id": 123,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "__breakpointTarget.dispatchEvent(new Event('custom')); __breakpointCount",
                    "returnByValue": true
                }
            }),
            123,
        )
        .await;
        assert_eq!(
            owner_disabled_dispatch["result"]["result"]["value"],
            json!(1),
            "a peer Debugger agent must not activate a disabled owner's breakpoint"
        );

        let owner_enable = command(
            &mut ctx,
            json!({
                "id": 124,
                "method": "Debugger.enable",
                "sessionId": "SID-event-breakpoint-owner"
            }),
            124,
        )
        .await;
        assert!(owner_enable.get("error").is_none(), "{owner_enable:?}");
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 125,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "__breakpointTarget.dispatchEvent(new Event('custom')); __breakpointCount",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 126,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;

        for session_id in ["SID-1", "SID-event-breakpoint-owner"] {
            let paused = ctx
                .wait_for_scheduler_message("multi-session event listener pause", |message| {
                    message["method"] == json!("Debugger.paused")
                        && message["sessionId"] == json!(session_id)
                })
                .await;
            if session_id == "SID-event-breakpoint-owner" {
                assert_eq!(paused["params"]["reason"], json!("EventListener"));
                assert_eq!(
                    paused["params"]["data"],
                    json!({
                        "eventName": "listener:custom",
                        "targetName": "EventTargetImpl"
                    }),
                    "{paused:?}"
                );
            } else {
                assert_eq!(paused["params"]["reason"], json!("other"), "{paused:?}");
                assert!(paused["params"].get("data").is_none(), "{paused:?}");
            }
        }
        let dispatched = ctx.take_response_by_id(125);
        assert_eq!(dispatched["result"]["result"]["value"], json!(2));
        let resume = ctx.take_response_by_id(126);
        assert_eq!(resume["result"], json!({}), "{resume:?}");

        let remove = command(
            &mut ctx,
            json!({
                "id": 128,
                "method": "DOMDebugger.removeEventListenerBreakpoint",
                "sessionId": "SID-event-breakpoint-owner",
                "params": { "eventName": "custom", "targetName": "eventtargetimpl" }
            }),
            128,
        )
        .await;
        assert_eq!(remove["result"], json!({}), "{remove:?}");
        let unpaused = command(
            &mut ctx,
            json!({
                "id": 129,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "__breakpointTarget.dispatchEvent(new Event('custom')); __breakpointCount",
                    "returnByValue": true
                }
            }),
            129,
        )
        .await;
        assert_eq!(unpaused["result"]["result"]["value"], json!(3));

        let reset = command(
            &mut ctx,
            json!({
                "id": 130,
                "method": "DOMDebugger.setEventListenerBreakpoint",
                "sessionId": "SID-event-breakpoint-owner",
                "params": { "eventName": "custom", "targetName": "EventTargetImpl" }
            }),
            130,
        )
        .await;
        assert_eq!(reset["result"], json!({}), "{reset:?}");
        let detach = command(
            &mut ctx,
            json!({
                "id": 131,
                "method": "Target.detachFromTarget",
                "sessionId": "SID-1",
                "params": {
                    "targetId": "TID-1",
                    "sessionId": "SID-event-breakpoint-owner"
                }
            }),
            131,
        )
        .await;
        assert_eq!(detach["result"], json!({}), "{detach:?}");
        let after_detach = command(
            &mut ctx,
            json!({
                "id": 132,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "__breakpointTarget.dispatchEvent(new Event('custom')); __breakpointCount",
                    "returnByValue": true
                }
            }),
            132,
        )
        .await;
        assert_eq!(
            after_detach["result"]["result"]["value"],
            json!(4),
            "detaching the owner session must remove its renderer breakpoint state"
        );

        {
            let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
            assert!(browser_context.assign_attached_session_to_target(
                "TID-1",
                "SID-event-breakpoint-owner".to_owned(),
            ));
        }
        let reattached_enable = command(
            &mut ctx,
            json!({
                "id": 133,
                "method": "Debugger.enable",
                "sessionId": "SID-event-breakpoint-owner"
            }),
            133,
        )
        .await;
        assert!(
            reattached_enable.get("error").is_none(),
            "{reattached_enable:?}"
        );
        let after_reattach = command(
            &mut ctx,
            json!({
                "id": 134,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "__breakpointTarget.dispatchEvent(new Event('custom')); __breakpointCount",
                    "returnByValue": true
                }
            }),
            134,
        )
        .await;
        assert_eq!(
            after_reattach["result"]["result"]["value"],
            json!(5),
            "reattaching the same wire session id must not revive detached breakpoints"
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn xhr_breakpoint_pauses_fetch_and_xhr_and_survives_navigation() {
        let mut ctx = TestContext::new();
        load_document(&mut ctx, "<!doctype html><title>XHR breakpoint</title>").await;

        let enable = command(
            &mut ctx,
            json!({
                "id": 200,
                "method": "Debugger.enable",
                "sessionId": "SID-1"
            }),
            200,
        )
        .await;
        assert!(enable.get("error").is_none(), "{enable:?}");

        let invalid = command(
            &mut ctx,
            json!({
                "id": 201,
                "method": "DOMDebugger.setXHRBreakpoint",
                "sessionId": "SID-1",
                "params": {}
            }),
            201,
        )
        .await;
        assert_eq!(invalid["error"]["code"], json!(-32602), "{invalid:?}");

        for (id, url) in [(202, "needle-specific"), (203, "needle")] {
            let set = command(
                &mut ctx,
                json!({
                    "id": id,
                    "method": "DOMDebugger.setXHRBreakpoint",
                    "sessionId": "SID-1",
                    "params": { "url": url }
                }),
                id,
            )
            .await;
            assert_eq!(set["result"], json!({}), "{set:?}");
        }

        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 204,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,needle-specific').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 205,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let fetch_pause = ctx
            .wait_for_scheduler_message("fetch XHR breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("XHR")
            })
            .await;
        assert_eq!(
            fetch_pause["params"]["data"],
            json!({
                "breakpointURL": "needle",
                "url": "data:text/plain,needle-specific"
            }),
            "Chromium chooses the lexicographically first matching URL key: {fetch_pause:?}"
        );
        assert_eq!(
            ctx.take_response_by_id(204)["result"]["result"]["value"],
            json!("needle-specific")
        );
        assert_eq!(ctx.take_response_by_id(205)["result"], json!({}));

        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 206,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": r#"
                        new Promise((resolve, reject) => {
                            const xhr = new XMLHttpRequest();
                            xhr.onload = () => resolve(xhr.responseText);
                            xhr.onerror = () => reject(new Error('XHR failed'));
                            xhr.open('GET', 'data:text/plain,xhr-needle');
                            xhr.send();
                        })
                    "#,
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 207,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let xhr_pause = ctx
            .wait_for_scheduler_message("XMLHttpRequest XHR breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("XHR")
            })
            .await;
        assert_eq!(
            xhr_pause["params"]["data"],
            json!({
                "breakpointURL": "needle",
                "url": "data:text/plain,xhr-needle"
            }),
            "{xhr_pause:?}"
        );
        assert_eq!(
            ctx.take_response_by_id(206)["result"]["result"]["value"],
            json!("xhr-needle")
        );
        assert_eq!(ctx.take_response_by_id(207)["result"], json!({}));

        let set_all = command(
            &mut ctx,
            json!({
                "id": 208,
                "method": "DOMDebugger.setXHRBreakpoint",
                "sessionId": "SID-1",
                "params": { "url": "" }
            }),
            208,
        )
        .await;
        assert_eq!(set_all["result"], json!({}), "{set_all:?}");
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 209,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "(() => { const xhr = new XMLHttpRequest(); try { xhr.send(); } catch (error) { return error.name; } })()",
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 210,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let invalid_state_pause = ctx
            .wait_for_scheduler_message("match-all invalid-state XHR pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("XHR")
            })
            .await;
        assert_eq!(
            invalid_state_pause["params"]["data"],
            json!({ "breakpointURL": "", "url": "" }),
            "Chromium pauses before XMLHttpRequest.send validates OPENED state"
        );
        assert_eq!(
            ctx.take_response_by_id(209)["result"]["result"]["value"],
            json!("InvalidStateError")
        );
        assert_eq!(ctx.take_response_by_id(210)["result"], json!({}));

        let navigate = command(
            &mut ctx,
            json!({
                "id": 211,
                "method": "Page.navigate",
                "sessionId": "SID-1",
                "params": { "url": "data:text/html,<title>after navigation</title>" }
            }),
            211,
        )
        .await;
        assert!(navigate["result"]["frameId"].is_string(), "{navigate:?}");
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 212,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,after-navigation').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 213,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        let restored_pause = ctx
            .wait_for_scheduler_message("restored match-all XHR breakpoint pause", |message| {
                message["method"] == json!("Debugger.paused")
                    && message["sessionId"] == json!("SID-1")
                    && message["params"]["reason"] == json!("XHR")
            })
            .await;
        assert_eq!(
            restored_pause["params"]["data"],
            json!({
                "breakpointURL": "",
                "url": "data:text/plain,after-navigation"
            }),
            "{restored_pause:?}"
        );
        assert_eq!(
            ctx.take_response_by_id(212)["result"]["result"]["value"],
            json!("after-navigation")
        );
        assert_eq!(ctx.take_response_by_id(213)["result"], json!({}));

        for (id, url) in [(214, ""), (215, "needle"), (216, "needle-specific")] {
            let remove = command(
                &mut ctx,
                json!({
                    "id": id,
                    "method": "DOMDebugger.removeXHRBreakpoint",
                    "sessionId": "SID-1",
                    "params": { "url": url }
                }),
                id,
            )
            .await;
            assert_eq!(remove["result"], json!({}), "{remove:?}");
        }
        let unpaused = command(
            &mut ctx,
            json!({
                "id": 217,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,needle').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            217,
        )
        .await;
        assert_eq!(unpaused["result"]["result"]["value"], json!("needle"));
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn xhr_breakpoint_is_session_owned_and_cleared_on_detach() {
        let mut ctx = TestContext::new();
        load_document(&mut ctx, "<!doctype html><title>XHR owner</title>").await;
        {
            let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
            assert!(
                browser_context.assign_attached_session_to_target(
                    "TID-1",
                    "SID-xhr-breakpoint-owner".to_owned(),
                )
            );
        }

        let primary_enable = command(
            &mut ctx,
            json!({
                "id": 300,
                "method": "Debugger.enable",
                "sessionId": "SID-1"
            }),
            300,
        )
        .await;
        assert!(primary_enable.get("error").is_none(), "{primary_enable:?}");
        let set = command(
            &mut ctx,
            json!({
                "id": 301,
                "method": "DOMDebugger.setXHRBreakpoint",
                "sessionId": "SID-xhr-breakpoint-owner",
                "params": { "url": "session-owner" }
            }),
            301,
        )
        .await;
        assert_eq!(set["result"], json!({}), "{set:?}");

        let disabled_owner = command(
            &mut ctx,
            json!({
                "id": 302,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,session-owner-disabled').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            302,
        )
        .await;
        assert_eq!(
            disabled_owner["result"]["result"]["value"],
            json!("session-owner-disabled"),
            "a peer Debugger must not activate a disabled owner's XHR breakpoint"
        );

        let owner_enable = command(
            &mut ctx,
            json!({
                "id": 303,
                "method": "Debugger.enable",
                "sessionId": "SID-xhr-breakpoint-owner"
            }),
            303,
        )
        .await;
        assert!(owner_enable.get("error").is_none(), "{owner_enable:?}");
        run_pausing_evaluate_with_observed_resumes(
            &mut ctx,
            json!({
                "id": 304,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,session-owner-enabled').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            vec![json!({
                "id": 305,
                "method": "Debugger.resume",
                "sessionId": "SID-1"
            })],
        )
        .await;
        for session_id in ["SID-1", "SID-xhr-breakpoint-owner"] {
            let paused = ctx
                .wait_for_scheduler_message("session-owned XHR breakpoint pause", |message| {
                    message["method"] == json!("Debugger.paused")
                        && message["sessionId"] == json!(session_id)
                })
                .await;
            if session_id == "SID-xhr-breakpoint-owner" {
                assert_eq!(paused["params"]["reason"], json!("XHR"), "{paused:?}");
                assert_eq!(
                    paused["params"]["data"],
                    json!({
                        "breakpointURL": "session-owner",
                        "url": "data:text/plain,session-owner-enabled"
                    }),
                    "{paused:?}"
                );
            } else {
                assert_eq!(paused["params"]["reason"], json!("other"), "{paused:?}");
                assert!(paused["params"].get("data").is_none(), "{paused:?}");
            }
        }
        assert_eq!(
            ctx.take_response_by_id(304)["result"]["result"]["value"],
            json!("session-owner-enabled")
        );
        assert_eq!(ctx.take_response_by_id(305)["result"], json!({}));

        let detach = command(
            &mut ctx,
            json!({
                "id": 306,
                "method": "Target.detachFromTarget",
                "sessionId": "SID-1",
                "params": {
                    "targetId": "TID-1",
                    "sessionId": "SID-xhr-breakpoint-owner"
                }
            }),
            306,
        )
        .await;
        assert_eq!(detach["result"], json!({}), "{detach:?}");
        let after_detach = command(
            &mut ctx,
            json!({
                "id": 307,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,session-owner-detached').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            307,
        )
        .await;
        assert_eq!(
            after_detach["result"]["result"]["value"],
            json!("session-owner-detached")
        );

        {
            let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
            assert!(
                browser_context.assign_attached_session_to_target(
                    "TID-1",
                    "SID-xhr-breakpoint-owner".to_owned(),
                )
            );
        }
        let reattached_enable = command(
            &mut ctx,
            json!({
                "id": 308,
                "method": "Debugger.enable",
                "sessionId": "SID-xhr-breakpoint-owner"
            }),
            308,
        )
        .await;
        assert!(
            reattached_enable.get("error").is_none(),
            "{reattached_enable:?}"
        );
        let after_reattach = command(
            &mut ctx,
            json!({
                "id": 309,
                "method": "Runtime.evaluate",
                "sessionId": "SID-1",
                "params": {
                    "expression": "fetch('data:text/plain,session-owner-reattached').then(response => response.text())",
                    "awaitPromise": true,
                    "returnByValue": true
                }
            }),
            309,
        )
        .await;
        assert_eq!(
            after_reattach["result"]["result"]["value"],
            json!("session-owner-reattached"),
            "reattaching the same wire session id must not revive XHR breakpoints"
        );
    }
}