Skip to content

armgit / moli

Public Imported from GitHub
0

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

228 KB
Raw Blame
use super::*;

mod auto_attach_startup;
mod auxiliary_page_identity;
mod auxiliary_page_retirement;
mod blank_navigation_inheritance;
mod browser_close;
mod noopener_blank_inheritance;
mod popup_navigation_referrer;

type TestCdpSocket =
    tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>;

async fn navigate_fixture_document(
    browser: &mut TestCdpSocket,
    navigation_id: u64,
    target: &TestCdpTargetSession,
    url: &str,
) {
    let session = Some(target.session_id.as_str());
    for (id, method, params) in [
        (90, "Page.enable", json!({})),
        (
            91,
            "Page.setLifecycleEventsEnabled",
            json!({"enabled": true}),
        ),
    ] {
        let enabled = send_cdp_command(browser, id, method, session, params).await;
        assert_eq!(response_by_id(&enabled, id)["result"], json!({}));
    }
    let navigation = send_cdp_command(
        browser,
        navigation_id,
        "Page.navigate",
        session,
        json!({"url": url}),
    )
    .await;
    assert!(response_by_id(&navigation, navigation_id)["error"].is_null());
    let loader = response_by_id(&navigation, navigation_id)["result"]["loaderId"]
        .as_str()
        .expect("fixture navigation loader");
    // Navigation can acknowledge before parsing finishes and invalidates an
    // earlier DOM root. Wait for this session and loader's parsed document;
    // an initial-document lifecycle replay must not satisfy the fixture gate.
    let parsed = |message: &serde_json::Value| {
        message["sessionId"] == target.session_id
            && message["method"] == "Page.lifecycleEvent"
            && message["params"]["loaderId"] == loader
            && message["params"]["name"] == "DOMContentLoaded"
    };
    if !navigation.iter().any(parsed) {
        recv_until_match(browser, parsed).await;
    }
}

async fn create_dynamic_target(browser: &mut TestCdpSocket, command_id: u64) -> String {
    send_cdp_command(
        browser,
        command_id,
        "Target.createTarget",
        None,
        json!({ "url": "about:blank" }),
    )
    .await
    .iter()
    .find(|message| message["id"] == json!(command_id))
    .and_then(|message| message["result"]["targetId"].as_str())
    .expect("dynamic target id")
    .to_owned()
}

async fn connect_dynamic_page(addr: std::net::SocketAddr, target_id: &str) -> TestCdpSocket {
    connect_async(format!("ws://{addr}/devtools/page/{target_id}"))
        .await
        .expect("dynamic page websocket should connect")
        .0
}

async fn discovered_tab_websocket_url(addr: std::net::SocketAddr, tab_target_id: &str) -> String {
    let (status, body) = fetch_server_response(addr, "GET", "/json/list?for_tab").await;
    assert_eq!(status, 200);
    let targets: Vec<serde_json::Value> =
        serde_json::from_slice(&body).expect("parse tab target discovery response");
    let target = targets
        .iter()
        .find(|target| target["id"] == json!(tab_target_id))
        .expect("discovered tab target");
    assert_eq!(target["type"], json!("tab"));
    assert_eq!(
        target["devtoolsFrontendUrl"],
        json!(format!(
            "/devtools/inspector.html?ws={addr}/devtools/page/{tab_target_id}"
        )),
        "remote discovery uses the same inspector URL shape for Page and Tab hosts"
    );
    let websocket_url = target["webSocketDebuggerUrl"]
        .as_str()
        .expect("tab websocket URL");
    assert!(websocket_url.contains("/devtools/page/"));
    websocket_url.to_owned()
}

async fn connect_discovered_tab(addr: std::net::SocketAddr, tab_target_id: &str) -> TestCdpSocket {
    let websocket_url = discovered_tab_websocket_url(addr, tab_target_id).await;
    connect_async(websocket_url)
        .await
        .expect("tab websocket should connect")
        .0
}

async fn enable_tab_page(
    socket: &mut TestCdpSocket,
    command_id: u64,
    page_target_id: &str,
) -> String {
    send_cdp_command_without_wait(
        socket,
        command_id,
        "Target.setAutoAttach",
        None,
        json!({
            "autoAttach": true,
            "waitForDebuggerOnStart": true,
            "flatten": true
        }),
    )
    .await;
    let mut saw_response = false;
    let mut attached_session_id = None;
    let messages = recv_until_match(socket, |message| {
        saw_response |= message["id"] == json!(command_id);
        if message["method"] == json!("Target.attachedToTarget")
            && message["params"]["targetInfo"]["targetId"] == json!(page_target_id)
        {
            attached_session_id = message["params"]["sessionId"].as_str().map(str::to_owned);
        }
        saw_response && attached_session_id.is_some()
    })
    .await;
    assert_eq!(response_by_id(&messages, command_id)["result"], json!({}));
    attached_session_id.expect("tab child page session")
}

async fn wait_for_websocket_close(socket: &mut TestCdpSocket, label: &str) {
    let wait_for_close = async {
        loop {
            match socket.next().await {
                None | Some(Ok(WsMessage::Close(_))) => break,
                Some(Ok(_)) => continue,
                Some(Err(error)) => panic!("{label} websocket close failed: {error}"),
            }
        }
    };
    timeout(Duration::from_secs(5), wait_for_close)
        .await
        .expect("websocket should close");
}

fn response_by_id(messages: &[serde_json::Value], id: u64) -> &serde_json::Value {
    messages
        .iter()
        .find(|message| message["id"] == json!(id))
        .unwrap_or_else(|| panic!("missing response id {id}: {messages:#?}"))
}

fn is_screencast_visibility(message: &serde_json::Value, visible: bool) -> bool {
    message["method"] == json!("Page.screencastVisibilityChanged")
        && message["params"]["visible"] == json!(visible)
}

fn is_target_created_for_url(message: &serde_json::Value, url: &str) -> bool {
    message["method"] == json!("Target.targetCreated")
        && message["params"]["targetInfo"]["url"] == json!(url)
}

async fn expect_screencast_visibility(socket: &mut TestCdpSocket, visible: bool) {
    let messages =
        recv_until_match(socket, |message| is_screencast_visibility(message, visible)).await;
    assert!(
        messages
            .iter()
            .any(|message| is_screencast_visibility(message, visible))
    );
}

async fn enable_runtime_and_expect_default_context(
    socket: &mut TestCdpSocket,
    command_id: u64,
    session_id: Option<&str>,
    label: &str,
) -> Vec<serde_json::Value> {
    let messages =
        send_cdp_command(socket, command_id, "Runtime.enable", session_id, json!({})).await;
    assert_eq!(response_by_id(&messages, command_id)["result"], json!({}));
    // V8RuntimeAgentImpl::enable reports existing contexts synchronously;
    // Blink's DevToolsSession flushes those notifications before the reply.
    // Waiting for another command would conceal a broken enable boundary.
    assert!(
        messages.iter().any(|message| {
            message.get("sessionId").and_then(serde_json::Value::as_str) == session_id
                && message["method"] == json!("Runtime.executionContextCreated")
                && message["params"]["context"]["auxData"]["isDefault"] == json!(true)
        }),
        "{label} did not report the existing default context before Runtime.enable replied: {messages:#?}"
    );
    messages
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn pipelined_frame_tree_replies_precede_runtime_context_replay() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let browser_context_id = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &browser_context_id).await;
    let session_id = Some(target.session_id.as_str());
    let warmup = send_cdp_command(
        &mut browser,
        4,
        "Runtime.evaluate",
        session_id,
        json!({ "expression": "globalThis.frameTreeReplayMarker = 42" }),
    )
    .await;
    assert_eq!(
        response_by_id(&warmup, 4)["result"]["result"]["value"],
        json!(42)
    );

    // These are real, asynchronous renderer snapshots. Pipeline them with
    // Runtime.enable as clients do during initial page attachment, without
    // waiting for a frame-tree response before sending the next command.
    for round in 0..20_u64 {
        let base = 100 + round * 20;
        let disabled =
            send_cdp_command(&mut browser, base, "Runtime.disable", session_id, json!({})).await;
        assert_eq!(response_by_id(&disabled, base)["result"], json!({}));
        for id in base + 1..=base + 8 {
            send_cdp_command_without_wait(
                &mut browser,
                id,
                "Page.getFrameTree",
                session_id,
                json!({}),
            )
            .await;
        }
        send_cdp_command_without_wait(
            &mut browser,
            base + 9,
            "Runtime.enable",
            session_id,
            json!({}),
        )
        .await;
        // Startup also requests browser-owned target metadata. Its handler
        // may await renderer work while these asynchronous replies are still
        // pending, so receipt must release the Main handoff before decoding.
        send_cdp_command_without_wait(
            &mut browser,
            base + 10,
            "Target.getTargetInfo",
            None,
            json!({ "targetId": target.target_id }),
        )
        .await;
        let mut tree_responses = std::collections::HashSet::new();
        let mut saw_enable_response = false;
        let mut saw_target_info = false;
        let mut context_id = None;
        let messages = recv_until_match(&mut browser, |message| {
            if message["id"] == json!(base + 10) {
                assert_eq!(message["result"]["targetInfo"]["targetId"], json!(target.target_id));
                saw_target_info = true;
                return tree_responses.len() == 8 && saw_enable_response && context_id.is_some();
            }
            if message["sessionId"].as_str() != session_id {
                return false;
            }
            if let Some(id) = message["id"].as_u64()
                && (base + 1..=base + 8).contains(&id)
            {
                assert_eq!(
                    message["result"]["frameTree"]["frame"]["id"],
                    json!(target.target_id)
                );
                tree_responses.insert(id);
            }
            if message["id"] == json!(base + 9) {
                assert_eq!(message["result"], json!({}));
                assert!(
                    context_id.is_some(),
                    "Runtime.enable replied before replaying the default context in round {round}"
                );
                saw_enable_response = true;
            }
            if message["method"] == json!("Runtime.executionContextCreated")
                && message["params"]["context"]["auxData"]["isDefault"] == json!(true)
            {
                assert_eq!(
                    tree_responses.len(),
                    8,
                    "Runtime context replay overtook a frame-tree response in round {round}: {tree_responses:?}"
                );
                context_id = message["params"]["context"]["id"].as_i64();
            }
            tree_responses.len() == 8 && saw_enable_response && saw_target_info && context_id.is_some()
        })
        .await;
        assert!(
            context_id.is_some(),
            "missing default context: {messages:#?}"
        );
        let evaluation = send_cdp_command(
            &mut browser,
            base + 11,
            "Runtime.evaluate",
            session_id,
            json!({ "expression": "frameTreeReplayMarker", "contextId": context_id }),
        )
        .await;
        assert_eq!(
            response_by_id(&evaluation, base + 11)["result"]["result"]["value"],
            json!(42)
        );
    }
    browser.close(None).await.expect("close browser websocket");
    abort_test_cdp_server(server).await;
}

// The ordering contracts below mirror the local Chromium probes documented in
// docs/inner/cdp-command-ordering.md. All fixtures are owned by this test: a
// fresh about:blank target, inline JavaScript, and protocol completion gates.
#[tokio::test(flavor = "current_thread")]
async fn native_snapshot_reply_precedes_later_inspector_context_replay() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    send_cdp_command(
        &mut browser,
        4,
        "Runtime.evaluate",
        session,
        json!({"expression": "document.body.innerHTML = '<p>native snapshot</p>'"}),
    )
    .await;
    for id in 10..14 {
        send_cdp_command_without_wait(
            &mut browser,
            id,
            "DOMSnapshot.captureSnapshot",
            session,
            json!({"computedStyles": ["display"]}),
        )
        .await;
    }
    send_cdp_command_without_wait(&mut browser, 20, "Runtime.enable", session, json!({})).await;
    let mut replies = std::collections::HashSet::new();
    let mut saw_context = false;
    recv_until_match(&mut browser, |message| {
        if message["sessionId"] != target.session_id {
            return false;
        }
        if let Some(id) = message["id"].as_u64()
            && (10..14).contains(&id)
        {
            assert!(message["error"].is_null(), "{message}");
            assert!(
                !message["result"]["documents"]
                    .as_array()
                    .unwrap()
                    .is_empty()
            );
            assert!(replies.insert(id), "duplicate native reply: {message}");
        }
        if message["method"] == "Runtime.executionContextCreated"
            && message["params"]["context"]["auxData"]["isDefault"] == true
        {
            assert_eq!(
                replies.len(),
                4,
                "Inspector event overtook a completed native snapshot"
            );
            saw_context = true;
        }
        if message["id"] == 20 {
            assert!(saw_context);
            return true;
        }
        false
    })
    .await;
    browser.close(None).await.unwrap();
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "current_thread")]
async fn native_node_queries_publish_before_later_inspector_replay() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    send_cdp_command(&mut browser, 4, "Runtime.evaluate", session, json!({
        "expression": "document.head.innerHTML = '<style>button {display: block}</style>'; document.body.innerHTML = '<button id=target style=\"color: red\">native query</button>'"
    })).await;
    let document = send_cdp_command(&mut browser, 5, "DOM.getDocument", session, json!({})).await;
    let root = response_by_id(&document, 5)["result"]["root"]["nodeId"]
        .as_u64()
        .unwrap();
    let node = send_cdp_command(
        &mut browser,
        6,
        "DOM.querySelector",
        session,
        json!({"nodeId": root, "selector": "#target"}),
    )
    .await;
    let node_id = response_by_id(&node, 6)["result"]["nodeId"]
        .as_u64()
        .unwrap();
    let described = send_cdp_command(
        &mut browser,
        7,
        "DOM.describeNode",
        session,
        json!({"nodeId": node_id}),
    )
    .await;
    let backend_id = response_by_id(&described, 7)["result"]["node"]["backendNodeId"]
        .as_u64()
        .unwrap();
    let queries = [
        ("CSS.getComputedStyleForNode", json!({"nodeId": node_id})),
        ("Accessibility.getPartialAXTree", json!({"nodeId": node_id})),
        ("CSS.getComputedStyleForNode", json!({"nodeId": 2147483647})),
        ("CSS.getInlineStylesForNode", json!({"nodeId": node_id})),
        ("Accessibility.getRootAXNode", json!({})),
        ("CSS.enable", json!({})),
        ("DOM.getAttributes", json!({"nodeId": node_id})),
        ("DOM.describeNode", json!({"nodeId": node_id})),
        (
            "DOM.querySelector",
            json!({"nodeId": root, "selector": "#target"}),
        ),
        ("DOM.getOuterHTML", json!({"nodeId": node_id})),
        (
            "DOM.setAttributeValue",
            json!({"nodeId": node_id, "name": "data-order", "value": "ready"}),
        ),
        ("DOM.focus", json!({"nodeId": node_id})),
        ("DOM.scrollIntoViewIfNeeded", json!({"nodeId": node_id})),
        ("DOM.setNodeStackTracesEnabled", json!({"enable": true})),
        ("DOM.getNodeStackTraces", json!({"nodeId": node_id})),
        (
            "DOM.removeAttribute",
            json!({"nodeId": node_id, "name": "data-order"}),
        ),
        ("DOM.disable", json!({})),
        ("Page.getLayoutMetrics", json!({})),
        ("Page.captureSnapshot", json!({})),
        ("Page.setBypassCSP", json!({"enabled": true})),
        ("Page.resetNavigationHistory", json!({})),
        (
            "DOM.resolveNode",
            json!({"backendNodeId": backend_id, "objectGroup": "native-order"}),
        ),
        (
            "DOMDebugger.setXHRBreakpoint",
            json!({"url": "native-order"}),
        ),
        (
            "DOMDebugger.removeXHRBreakpoint",
            json!({"url": "native-order"}),
        ),
        (
            "Autofill.trigger",
            json!({"fieldId": 0, "card": {"number": "4111111111111111", "name": "Test", "expiryMonth": "12", "expiryYear": "2030", "cvc": "123"}}),
        ),
        (
            "Page.createIsolatedWorld",
            json!({"frameId": target.target_id, "worldName": "native-order"}),
        ),
        (
            "Page.addScriptToEvaluateOnNewDocument",
            json!({"source": "window.nativePreloadRan = true", "runImmediately": true}),
        ),
        ("Page.getResourceTree", json!({})),
        (
            "Emulation.setHardwareConcurrencyOverride",
            json!({"hardwareConcurrency": 4}),
        ),
        (
            "Emulation.setDataSaverOverride",
            json!({"dataSaverEnabled": true}),
        ),
        ("Emulation.setAutomationOverride", json!({"enabled": true})),
        (
            "Emulation.setTouchEmulationEnabled",
            json!({"enabled": true, "maxTouchPoints": 2}),
        ),
        ("Emulation.setEmulatedMedia", json!({"media": "print"})),
        (
            "Emulation.setFocusEmulationEnabled",
            json!({"enabled": true}),
        ),
        (
            "Emulation.setGeolocationOverride",
            json!({"latitude": 40.0, "longitude": 116.0, "accuracy": 1.0}),
        ),
        ("Emulation.clearGeolocationOverride", json!({})),
        (
            "Emulation.setIdleOverride",
            json!({"isUserActive": false, "isScreenUnlocked": false}),
        ),
        ("Emulation.clearIdleOverride", json!({})),
        (
            "Emulation.setDeviceMetricsOverride",
            json!({"width": 900, "height": 650, "deviceScaleFactor": 1, "mobile": false}),
        ),
        ("Emulation.clearDeviceMetricsOverride", json!({})),
    ];
    let response_end = 10 + queries.len() as u64;
    for (offset, (method, params)) in queries.into_iter().enumerate() {
        send_cdp_command_without_wait(&mut browser, 10 + offset as u64, method, session, params)
            .await;
    }
    send_cdp_command_without_wait(&mut browser, 140, "Runtime.enable", session, json!({})).await;
    let mut replies = Vec::new();
    let mut preload_identifier = None;
    let mut resolved_object = None;
    let mut saw_stylesheet = false;
    let mut saw_context = false;
    recv_until_match(&mut browser, |message| {
        if message["sessionId"] != target.session_id {
            return false;
        }
        if message["method"] == "CSS.styleSheetAdded" {
            assert!(
                !replies.contains(&15),
                "CSS notification must precede its ready response"
            );
            saw_stylesheet = true;
        }
        if let Some(id) = message["id"].as_u64()
            && (10..response_end).contains(&id)
        {
            assert!(!replies.contains(&id), "duplicate response: {message}");
            if id == 12 {
                assert_eq!(message["error"]["code"], -32000);
            } else if id == 34 {
                assert_eq!(message["error"]["code"], -32600);
            } else {
                assert!(message["error"].is_null(), "{message}");
            }
            match id {
                10 => assert!(message["result"]["computedStyle"].as_array().is_some_and(
                    |styles| {
                        styles.iter().any(|style| {
                            style["name"] == "color" && style["value"] == "rgb(255, 0, 0)"
                        })
                    }
                )),
                11 => assert!(message["result"]["nodes"].as_array().is_some_and(|nodes| {
                    nodes.iter().any(|node| {
                        node["role"]["value"] == "button" && node["name"]["value"] == "native query"
                    })
                })),
                13 => assert!(message["result"]["inlineStyle"]["cssProperties"].is_array()),
                14 => assert!(message["result"]["node"].is_object()),
                15 => assert!(saw_stylesheet),
                16 => assert!(
                    message["result"]["attributes"]
                        .as_array()
                        .is_some_and(|attributes| attributes.contains(&json!("target")))
                ),
                17 => assert_eq!(message["result"]["node"]["nodeName"], "BUTTON"),
                18 => assert_eq!(message["result"]["nodeId"], node_id),
                19 => assert!(
                    message["result"]["outerHTML"]
                        .as_str()
                        .is_some_and(|html| html.contains("native query"))
                ),
                27 => assert!(message["result"]["cssLayoutViewport"].is_object()),
                28 => assert!(
                    message["result"]["data"]
                        .as_str()
                        .is_some_and(|snapshot| snapshot.contains("MIME-Version: 1.0"))
                ),
                35 => assert!(message["result"]["executionContextId"].as_i64().is_some()),
                36 => {
                    preload_identifier =
                        message["result"]["identifier"].as_str().map(str::to_owned);
                }
                37 => assert!(message["result"]["frameTree"]["resources"].is_array()),
                31 => {
                    resolved_object = message["result"]["object"]["objectId"]
                        .as_str()
                        .map(str::to_owned);
                }
                _ => {}
            }
            replies.push(id);
        }
        if message["method"] == "Runtime.executionContextCreated"
            && message["params"]["context"]["auxData"]["isDefault"] == true
        {
            assert_eq!(
                replies,
                (10..response_end).collect::<Vec<_>>(),
                "native lookup/response was overtaken by Inspector"
            );
            saw_context = true;
        }
        if message["id"] == 140 {
            assert!(saw_context);
            return true;
        }
        false
    })
    .await;
    let state = send_cdp_command(&mut browser, 141, "Runtime.evaluate", session, json!({
        "expression": "({preload: window.nativePreloadRan, focused: document.activeElement.id, attribute: document.querySelector('#target').getAttribute('data-order')})", "returnByValue": true
    })).await;
    assert_eq!(
        response_by_id(&state, 141)["result"]["result"]["value"],
        json!({"preload": true, "focused": "target", "attribute": null})
    );
    let object_id = resolved_object.expect("native resolveNode object");
    let listeners = send_cdp_command(
        &mut browser,
        142,
        "DOMDebugger.getEventListeners",
        session,
        json!({"objectId": object_id}),
    )
    .await;
    assert!(response_by_id(&listeners, 142)["result"]["listeners"].is_array());
    let released = send_cdp_command(
        &mut browser,
        143,
        "Runtime.releaseObjectGroup",
        session,
        json!({"objectGroup": "native-order"}),
    )
    .await;
    assert!(response_by_id(&released, 143)["error"].is_null());
    let stale = send_cdp_command(
        &mut browser,
        144,
        "Runtime.getProperties",
        session,
        json!({"objectId": object_id}),
    )
    .await;
    assert_eq!(response_by_id(&stale, 144)["error"]["code"], -32000);
    let removed = send_cdp_command(
        &mut browser,
        145,
        "Page.removeScriptToEvaluateOnNewDocument",
        session,
        json!({"identifier": preload_identifier.unwrap()}),
    )
    .await;
    assert!(response_by_id(&removed, 145)["error"].is_null());
    browser.close(None).await.unwrap();
    abort_test_cdp_server(server).await;
}

async fn assert_pause_command_ordering(instrumentation: bool) {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().route(
            "/page",
            get(|| async { axum::response::Html("<!doctype html><body>pause fixture</body>") }),
        ),
        "native-pause-snapshot",
    );
    let fixture_url = format!("http://{fixture_addr}/page");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    navigate_fixture_document(&mut browser, 9, &target, &fixture_url).await;

    let dom = send_cdp_command(&mut browser, 5, "DOM.getDocument", session, json!({})).await;
    let root = response_by_id(&dom, 5)["result"]["root"]["nodeId"]
        .as_u64()
        .unwrap();
    let nodes = send_cdp_command(
        &mut browser,
        6,
        "DOM.querySelector",
        session,
        json!({"nodeId": root, "selector": "body"}),
    )
    .await;
    let body = response_by_id(&nodes, 6)["result"]["nodeId"]
        .as_u64()
        .unwrap();
    let enabled = send_cdp_command(&mut browser, 10, "Debugger.enable", session, json!({})).await;
    assert!(response_by_id(&enabled, 10).get("error").is_none());
    if instrumentation {
        let breakpoint = send_cdp_command(
            &mut browser,
            11,
            "Debugger.setInstrumentationBreakpoint",
            session,
            json!({ "instrumentation": "beforeScriptExecution" }),
        )
        .await;
        assert!(response_by_id(&breakpoint, 11).get("error").is_none());
    }
    send_cdp_command_without_wait(
        &mut browser,
        12,
        "Runtime.evaluate",
        session,
        json!({
            "expression": if instrumentation { "21 * 2" } else { "(() => { history.replaceState(null, '', '#paused'); document.body.setAttribute('data-paused', 'ready'); document.body.setAttribute('style', 'width: 12px'); debugger; return 42; })()" },
            "returnByValue": true
        }),
    )
    .await;
    let paused = recv_until_match(&mut browser, |message| {
        message["sessionId"] == json!(target.session_id)
            && message["method"] == json!("Debugger.paused")
    })
    .await;
    assert!(paused.iter().all(|message| message["id"] != json!(12)));
    if instrumentation {
        assert_eq!(
            paused.last().unwrap()["params"]["reason"],
            json!("instrumentation")
        );
    }
    send_cdp_command_without_wait(&mut browser, 13, "Page.getFrameTree", session, json!({})).await;
    // IO completion proves the paused renderer has processed a later command;
    // it is a gate, not a timed assumption about a missing Main response.
    let gate = if instrumentation {
        send_cdp_command(
            &mut browser,
            14,
            "Performance.getMetrics",
            session,
            json!({}),
        )
        .await
    } else {
        recv_until_id(&mut browser, 13).await
    };
    assert!(gate.iter().all(|message| message["id"] != json!(12)));
    if instrumentation {
        assert!(response_by_id(&gate, 14).get("error").is_none());
        assert!(
            gate.iter().all(|message| message["id"] != json!(13)),
            "instrumentation pause must not pump Main: {gate:#?}"
        );
    } else {
        assert_eq!(
            response_by_id(&gate, 13)["result"]["frameTree"]["frame"]["id"],
            json!(target.target_id)
        );
    }
    if !instrumentation {
        for (id, method) in [
            (20, "CSS.getInlineStylesForNode"),
            (21, "CSS.getMatchedStylesForNode"),
        ] {
            let styles =
                send_cdp_command(&mut browser, id, method, session, json!({"nodeId": body})).await;
            assert!(styles.iter().all(|message| message["id"] != 12));
            let response = response_by_id(&styles, id);
            assert!(response.get("error").is_none(), "{response}");
            let properties = response["result"]["inlineStyle"]["cssProperties"]
                .as_array()
                .expect("inline properties must be readable before resume");
            assert!(
                properties
                    .iter()
                    .any(|property| { property["name"] == "width" && property["value"] == "12px" })
            );
        }
        // Native wrapping must preserve the isolate-entry constraint of both
        // an opaque node-resolution chain and a world-creation handler.
        send_cdp_command_without_wait(
            &mut browser,
            16,
            "DOM.setAttributeValue",
            session,
            json!({"nodeId": body, "name": "data-after-pause", "value": "ready"}),
        )
        .await;
        send_cdp_command_without_wait(
            &mut browser,
            17,
            "DOM.resolveNode",
            session,
            json!({"nodeId": body}),
        )
        .await;
        send_cdp_command_without_wait(
            &mut browser,
            18,
            "Page.createIsolatedWorld",
            session,
            json!({"frameId": target.target_id, "worldName": "after-pause"}),
        )
        .await;
        let io = send_cdp_command(
            &mut browser,
            19,
            "Performance.getMetrics",
            session,
            json!({}),
        )
        .await;
        assert!(
            io.iter()
                .all(|message| message["id"] != 16 && message["id"] != 17 && message["id"] != 18),
            "owner-only native handlers must wait for the enclosing V8 entry: {io:?}"
        );
    }
    send_cdp_command_without_wait(&mut browser, 15, "Debugger.resume", session, json!({})).await;
    let mut completed = std::collections::HashSet::new();
    let resumed = recv_until_match(&mut browser, |message| {
        if message["sessionId"] == json!(target.session_id)
            && let Some(id) = message["id"].as_u64()
        {
            assert!(
                completed.insert(id),
                "duplicate terminal response: {message}"
            );
        }
        completed.contains(&12)
            && completed.contains(&15)
            && (!instrumentation || completed.contains(&13))
            && (instrumentation
                || (completed.contains(&16) && completed.contains(&17) && completed.contains(&18)))
    })
    .await;
    assert_eq!(
        response_by_id(&resumed, 12)["result"]["result"]["value"],
        json!(42)
    );
    assert!(response_by_id(&resumed, 15).get("error").is_none());
    if instrumentation {
        assert_eq!(
            response_by_id(&resumed, 13)["result"]["frameTree"]["frame"]["id"],
            json!(target.target_id)
        );
    }
    if !instrumentation {
        let edited = resumed
            .iter()
            .position(|message| {
                message["method"] == "DOM.attributeModified"
                    && message["params"]["name"] == "data-after-pause"
            })
            .expect("resumed mutation notification");
        let edit_response = resumed
            .iter()
            .position(|message| message["id"] == 16)
            .unwrap();
        assert!(
            edited < edit_response,
            "mutation notification precedes response: {resumed:?}"
        );
        assert!(response_by_id(&resumed, 17)["result"]["object"]["objectId"].is_string());
        assert!(response_by_id(&resumed, 18)["result"]["executionContextId"].is_i64());
        let prefix = paused.iter().chain(gate.iter()).collect::<Vec<_>>();
        let event = prefix
            .iter()
            .position(|message| {
                message["method"] == "DOM.attributeModified"
                    && message["params"]["name"] == "data-paused"
            })
            .expect("nested mutation must publish before resume");
        let response = prefix
            .iter()
            .position(|message| message["id"] == 13)
            .unwrap();
        assert!(
            event < response,
            "native terminal must flush the suspended turn DOM prefix: {prefix:?}"
        );
        assert_eq!(
            response_by_id(&gate, 13)["result"]["frameTree"]["frame"]["url"],
            format!("{fixture_url}#paused")
        );
    }
    browser.close(None).await.expect("close browser websocket");
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cdp_ordering_normal_pause_allows_nested_main() {
    assert_pause_command_ordering(false).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cdp_ordering_dom_agent_frontend_commands_complete_before_resume() {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().route("/page", get(|| async {
            axum::response::Html("<!doctype html><style>#probe {width:100px;height:100px}</style><div id=probe>probe</div>")
        })),
        "native-paused-dom-agent",
    );
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    navigate_fixture_document(
        &mut browser,
        4,
        &target,
        &format!("http://{fixture_addr}/page"),
    )
    .await;
    let document = send_cdp_command(&mut browser, 5, "DOM.getDocument", session, json!({})).await;
    let query = send_cdp_command(
        &mut browser,
        6,
        "DOM.querySelector",
        session,
        json!({
            "nodeId": response_by_id(&document, 5)["result"]["root"]["nodeId"], "selector": "#probe"
        }),
    )
    .await;
    let node = response_by_id(&query, 6)["result"]["nodeId"]
        .as_u64()
        .unwrap();
    let describe = send_cdp_command(
        &mut browser,
        7,
        "DOM.describeNode",
        session,
        json!({"nodeId": node}),
    )
    .await;
    let backend = response_by_id(&describe, 7)["result"]["node"]["backendNodeId"].clone();
    let geometry = send_cdp_command(&mut browser, 8, "Runtime.evaluate", session, json!({
        "expression": "(() => { const r = document.getElementById('probe').getBoundingClientRect(); return {x: Math.floor(r.left + r.width / 2), y: Math.floor(r.top + r.height / 2)}; })()",
        "returnByValue": true
    })).await;
    let point = response_by_id(&geometry, 8)["result"]["result"]["value"].clone();
    assert!(point["x"].is_number() && point["y"].is_number());
    let enabled = send_cdp_command(&mut browser, 10, "Debugger.enable", session, json!({})).await;
    assert!(response_by_id(&enabled, 10)["error"].is_null());
    send_cdp_command_without_wait(
        &mut browser,
        12,
        "Runtime.evaluate",
        session,
        json!({
            "expression": "(() => { debugger; return 42; })()", "returnByValue": true
        }),
    )
    .await;
    let paused = recv_until_match(&mut browser, |message| {
        message["sessionId"] == target.session_id && message["method"] == "Debugger.paused"
    })
    .await;
    assert!(paused.iter().all(|message| message["id"] != 12));

    // Exercise the frontend SessionSink wrappers: the typed backend commands
    // were already PageAgent, while their native wrappers incorrectly waited
    // for the suspended outer evaluation to return. Do not send resume until
    // every one of these actual wire replies has arrived.
    let commands = [
        (100, "DOM.getNodeForLocation", point),
        (101, "DOM.getNodeStackTraces", json!({"nodeId": node})),
        (
            102,
            "DOM.setNodeStackTracesEnabled",
            json!({"enable": true}),
        ),
        (103, "DOM.disable", json!({})),
    ];
    for (id, method, params) in &commands {
        send_cdp_command_without_wait(&mut browser, *id, method, session, params.clone()).await;
    }
    let mut completed = std::collections::HashSet::new();
    let inspected = recv_until_match(&mut browser, |message| {
        if message["sessionId"] == target.session_id
            && let Some(id) = message["id"].as_u64()
        {
            assert!(completed.insert(id), "duplicate terminal: {message}");
        }
        commands.iter().all(|(id, _, _)| completed.contains(id))
    })
    .await;
    assert!(
        inspected.iter().all(|message| message["id"] != 12
            && !(message["sessionId"] == target.session_id
                && message["method"] == "Debugger.resumed")),
        "DOM inspection must retain the paused outer evaluation: {inspected:#?}"
    );
    for (id, method, _) in &commands {
        let response = response_by_id(&inspected, *id);
        assert_eq!(response["sessionId"], target.session_id);
        assert!(response["error"].is_null(), "{method}: {response}");
        if *id == 100 {
            assert_eq!(response["result"]["backendNodeId"], backend);
            assert_eq!(response["result"]["frameId"], target.target_id);
        } else {
            assert_eq!(response["result"], json!({}), "{method}");
        }
    }
    let stale = send_cdp_command(
        &mut browser,
        14,
        "DOM.getAttributes",
        session,
        json!({"nodeId": node}),
    )
    .await;
    assert_eq!(
        response_by_id(&stale, 14)["error"]["code"],
        -32000,
        "DOM.disable must invalidate the frontend node before acknowledging it"
    );
    assert!(stale.iter().all(|message| message["id"] != 12));
    assert!(completed.insert(14));

    send_cdp_command_without_wait(&mut browser, 15, "Debugger.resume", session, json!({})).await;
    let resumed = recv_until_match(&mut browser, |message| {
        if message["sessionId"] == target.session_id
            && let Some(id) = message["id"].as_u64()
        {
            assert!(completed.insert(id), "duplicate terminal: {message}");
        }
        completed.contains(&12) && completed.contains(&15)
    })
    .await;
    assert_eq!(
        response_by_id(&resumed, 12)["result"]["result"]["value"],
        42
    );
    assert!(response_by_id(&resumed, 15)["error"].is_null());
    let follower =
        send_cdp_command(&mut browser, 16, "Page.getFrameTree", session, json!({})).await;
    assert!(
        follower.iter().all(|message| message["id"]
            .as_u64()
            .is_none_or(|id| !completed.contains(&id))),
        "duplicate terminal: {follower:?}"
    );
    assert!(response_by_id(&follower, 16)["error"].is_null());
    browser.close(None).await.unwrap();
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cdp_ordering_instrumentation_pause_only_allows_io() {
    assert_pause_command_ordering(true).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cdp_ordering_deferred_reply_allows_its_later_resolver() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    send_cdp_command_without_wait(
        &mut browser, 10, "Runtime.evaluate", session,
        json!({ "expression": "new Promise(resolve => globalThis.finishOrderingProbe = resolve)", "awaitPromise": true, "returnByValue": true }),
    ).await;
    let later = send_cdp_command(
        &mut browser,
        11,
        "Runtime.evaluate",
        session,
        json!({ "expression": "typeof finishOrderingProbe", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&later, 11)["result"]["result"]["value"],
        json!("function")
    );
    assert!(
        later.iter().all(|message| message["id"] != json!(10)),
        "an unresolved Promise must have no terminal reply: {later:#?}"
    );
    send_cdp_command_without_wait(
        &mut browser,
        12,
        "Runtime.evaluate",
        session,
        json!({ "expression": "finishOrderingProbe(42); 'resolved'", "returnByValue": true }),
    )
    .await;
    let mut terminal_ids = std::collections::HashSet::new();
    let completed = recv_until_match(&mut browser, |message| {
        if let Some(id) = message["id"].as_u64() {
            assert!(
                terminal_ids.insert(id),
                "duplicate terminal reply: {message}"
            );
        }
        terminal_ids.contains(&10) && terminal_ids.contains(&12)
    })
    .await;
    assert_eq!(
        response_by_id(&completed, 10)["result"]["result"]["value"],
        json!(42)
    );
    assert_eq!(
        response_by_id(&completed, 12)["result"]["result"]["value"],
        json!("resolved")
    );
    browser.close(None).await.expect("close browser websocket");
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cdp_ordering_native_focus_can_reenter_main_before_reply() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    let fixture = send_cdp_command(
        &mut browser,
        10,
        "Runtime.evaluate",
        session,
        json!({
            "expression": r#"
            document.body.innerHTML = '<input id="ordering-focus">';
            document.querySelector('input').addEventListener('focus', () => {
                debugger;
                globalThis.focusCallbackFinished = true;
            });
        "#
        }),
    )
    .await;
    assert!(
        response_by_id(&fixture, 10)["result"]
            .get("exceptionDetails")
            .is_none()
    );
    let enabled = send_cdp_command(&mut browser, 11, "Debugger.enable", session, json!({})).await;
    assert!(response_by_id(&enabled, 11).get("error").is_none());
    let document = send_cdp_command(&mut browser, 12, "DOM.getDocument", session, json!({})).await;
    let root = response_by_id(&document, 12)["result"]["root"]["nodeId"]
        .as_u64()
        .expect("document node id");
    let node = send_cdp_command(
        &mut browser,
        13,
        "DOM.querySelector",
        session,
        json!({ "nodeId": root, "selector": "#ordering-focus" }),
    )
    .await;
    let node_id = response_by_id(&node, 13)["result"]["nodeId"]
        .as_u64()
        .expect("input node id");
    send_cdp_command_without_wait(
        &mut browser,
        14,
        "DOM.focus",
        session,
        json!({ "nodeId": node_id }),
    )
    .await;
    let paused = recv_until_match(&mut browser, |message| {
        message["sessionId"] == json!(target.session_id)
            && message["method"] == json!("Debugger.paused")
    })
    .await;
    assert!(paused.iter().all(|message| message["id"] != json!(14)));
    // DOM.focus has a synchronous Blink backend signature, but can execute
    // user JavaScript. Its unfinished stack must not lock nested Main work.
    let nested = send_cdp_command(&mut browser, 15, "Page.getFrameTree", session, json!({})).await;
    assert_eq!(
        response_by_id(&nested, 15)["result"]["frameTree"]["frame"]["id"],
        json!(target.target_id)
    );
    assert!(nested.iter().all(|message| message["id"] != json!(14)));
    send_cdp_command_without_wait(&mut browser, 16, "Debugger.resume", session, json!({})).await;
    let mut terminal_ids = std::collections::HashSet::new();
    let completed = recv_until_match(&mut browser, |message| {
        if let Some(id) = message["id"].as_u64() {
            assert!(
                terminal_ids.insert(id),
                "duplicate terminal reply: {message}"
            );
        }
        terminal_ids.contains(&14) && terminal_ids.contains(&16)
    })
    .await;
    assert_eq!(response_by_id(&completed, 14)["result"], json!({}));
    assert_eq!(response_by_id(&completed, 16)["result"], json!({}));
    let value = send_cdp_command(
        &mut browser,
        17,
        "Runtime.evaluate",
        session,
        json!({ "expression": "focusCallbackFinished", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&value, 17)["result"]["result"]["value"],
        json!(true)
    );
    browser.close(None).await.expect("close browser websocket");
    abort_test_cdp_server(server).await;
}

async fn puppeteer_auto_attach_existing_page(
    browser: &mut TestCdpSocket,
    command_id: u64,
    page_target_id: &str,
    tab_target_id: &str,
) -> String {
    send_cdp_command_without_wait(
        browser,
        command_id,
        "Target.setAutoAttach",
        None,
        json!({
            "autoAttach": true,
            "waitForDebuggerOnStart": true,
            "flatten": true,
            "filter": [
                { "type": "page", "exclude": true },
                {}
            ]
        }),
    )
    .await;
    let mut saw_root_response = false;
    let mut saw_tab_attach = false;
    let root_auto_attach = recv_until_match(browser, |message| {
        saw_root_response |= message["id"] == json!(command_id);
        saw_tab_attach |= message["method"] == json!("Target.attachedToTarget")
            && message["params"]["targetInfo"]["targetId"] == json!(tab_target_id);
        saw_root_response && saw_tab_attach
    })
    .await;
    assert_eq!(
        response_by_id(&root_auto_attach, command_id)["result"],
        json!({})
    );
    let tab_session_id = root_auto_attach
        .iter()
        .find(|message| {
            message["method"] == json!("Target.attachedToTarget")
                && message["params"]["targetInfo"]["targetId"] == json!(tab_target_id)
        })
        .and_then(|message| message["params"]["sessionId"].as_str())
        .expect("auto-attached tab session")
        .to_owned();

    let child_command_id = command_id + 1;
    send_cdp_command_without_wait(
        browser,
        child_command_id,
        "Target.setAutoAttach",
        Some(&tab_session_id),
        json!({
            "autoAttach": true,
            "waitForDebuggerOnStart": false,
            "flatten": true,
            "filter": [{}]
        }),
    )
    .await;
    let mut saw_child_response = false;
    let mut saw_page_attach = false;
    let tab_auto_attach = recv_until_match(browser, |message| {
        saw_child_response |= message["id"] == json!(child_command_id);
        saw_page_attach |= message["sessionId"] == json!(tab_session_id)
            && message["method"] == json!("Target.attachedToTarget")
            && message["params"]["targetInfo"]["targetId"] == json!(page_target_id);
        saw_child_response && saw_page_attach
    })
    .await;
    assert_eq!(
        response_by_id(&tab_auto_attach, child_command_id)["result"],
        json!({})
    );
    tab_auto_attach
        .iter()
        .find(|message| {
            message["sessionId"] == json!(tab_session_id)
                && message["method"] == json!("Target.attachedToTarget")
                && message["params"]["targetInfo"]["targetId"] == json!(page_target_id)
        })
        .and_then(|message| message["params"]["sessionId"].as_str())
        .expect("auto-attached page session")
        .to_owned()
}

async fn fetch_server_json(addr: std::net::SocketAddr, path: &str) -> serde_json::Value {
    let (status, body) = fetch_server_response(addr, "GET", path).await;
    assert_eq!(status, 200, "unexpected HTTP status for {path}");
    serde_json::from_slice(&body).expect("protocol server JSON response")
}

async fn fetch_server_response(
    addr: std::net::SocketAddr,
    method: &str,
    path: &str,
) -> (u16, Vec<u8>) {
    let mut stream = tokio::net::TcpStream::connect(addr)
        .await
        .expect("connect protocol server HTTP route");
    stream
        .write_all(
            format!("{method} {path} HTTP/1.1\r\nHost: {addr}\r\nConnection: close\r\n\r\n")
                .as_bytes(),
        )
        .await
        .expect("write protocol server HTTP request");
    let mut response = Vec::new();
    stream
        .read_to_end(&mut response)
        .await
        .expect("read protocol server HTTP response");
    let header_end = response
        .windows(4)
        .position(|window| window == b"\r\n\r\n")
        .expect("HTTP response header terminator");
    let headers = std::str::from_utf8(&response[..header_end]).expect("HTTP response headers");
    let status = headers
        .lines()
        .next()
        .and_then(|line| line.split_whitespace().nth(1))
        .and_then(|status| status.parse::<u16>().ok())
        .expect("HTTP response status");
    (status, response[header_end + 4..].to_vec())
}

async fn dispatch_primary_click(
    socket: &mut TestCdpSocket,
    command_id: u64,
    session_id: Option<&str>,
    x: u32,
    y: u32,
) -> Vec<serde_json::Value> {
    let mut messages = Vec::new();
    for (offset, event_type) in [(0, "mousePressed"), (1, "mouseReleased")] {
        let response = send_cdp_command(
            socket,
            command_id + offset,
            "Input.dispatchMouseEvent",
            session_id,
            json!({
                "type": event_type,
                "x": x,
                "y": y,
                "button": "left",
                "buttons": if event_type == "mousePressed" { 1 } else { 0 },
                "clickCount": 1
            }),
        )
        .await;
        assert!(
            response_by_id(&response, command_id + offset)
                .get("result")
                .is_some()
        );
        messages.extend(response);
    }
    messages
}

async fn evaluate_page_surface(socket: &mut TestCdpSocket, command_id: u64) -> serde_json::Value {
    let response = send_cdp_command(
        socket,
        command_id,
        "Runtime.evaluate",
        None,
        json!({
            "expression": "({ href: location.href, hidden: document.hidden, visibility: document.visibilityState, focused: document.hasFocus() })",
            "returnByValue": true
        }),
    )
    .await;
    response_by_id(&response, command_id)["result"]["result"]["value"].clone()
}

fn assert_page_surface_active(surface: &serde_json::Value, expected_active: bool) {
    assert_eq!(surface["hidden"], json!(!expected_active));
    assert_eq!(
        surface["visibility"],
        json!(if expected_active { "visible" } else { "hidden" })
    );
    assert_eq!(surface["focused"], json!(expected_active));
}

async fn wait_for_target_list(
    addr: std::net::SocketAddr,
    label: &str,
    predicate: impl Fn(&[serde_json::Value]) -> bool,
) -> Vec<serde_json::Value> {
    timeout(Duration::from_secs(5), async {
        loop {
            let response = fetch_server_json(addr, "/json/list").await;
            if let Some(targets) = response.as_array()
                && predicate(targets)
            {
                return targets.clone();
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .unwrap_or_else(|_| panic!("{label}"))
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_mouse_wheel_scrolls_page_and_honors_prevent_default() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;

    let installed = send_cdp_command(
        &mut page,
        1,
        "Runtime.evaluate",
        None,
        json!({
            "expression": r#"
                (() => {
                  document.documentElement.style.margin = "0";
                  document.body.style.margin = "0";
                  document.body.innerHTML =
                    '<div style="height: 500px"></div>' +
                    '<div id="marker" style="height: 20px"></div>' +
                    '<div style="height: 2500px"></div>';
                  window.__wheelDeltas = [];
                  window.addEventListener("wheel", event => {
                    window.__wheelDeltas.push(event.deltaY);
                  }, { capture: true });
                  return document.getElementById("marker").getBoundingClientRect().top;
                })()
            "#,
            "returnByValue": true
        }),
    )
    .await;
    assert!(response_by_id(&installed, 1).get("result").is_some());
    let captured = send_cdp_command(&mut page, 90, "Page.captureScreenshot", None, json!({})).await;
    assert!(response_by_id(&captured, 90).get("result").is_some());
    let measured = send_cdp_command(&mut page, 91, "Runtime.evaluate", None,
        json!({"expression": "document.getElementById('marker').getBoundingClientRect().top", "returnByValue": true})).await;
    let marker_before = response_by_id(&measured, 91)["result"]["result"]["value"]
        .as_f64()
        .expect("initial marker top");

    let wheel = send_cdp_command(
        &mut page,
        2,
        "Input.dispatchMouseEvent",
        None,
        json!({
            "type": "mouseWheel",
            "x": 10,
            "y": 10,
            "deltaX": 0,
            "deltaY": 120
        }),
    )
    .await;
    assert!(response_by_id(&wheel, 2).get("result").is_some());

    let scrolled = send_cdp_command(
        &mut page,
        3,
        "Runtime.evaluate",
        None,
        json!({
            "expression": r#"
                ({
                  scrollY,
                  markerTop: document.getElementById("marker").getBoundingClientRect().top,
                  wheelDeltas: window.__wheelDeltas
                })
            "#,
            "returnByValue": true
        }),
    )
    .await;
    let value = &response_by_id(&scrolled, 3)["result"]["result"]["value"];
    assert_eq!(value["scrollY"], json!(120));
    // Ordinary geometry reads retain the last published visual world.
    assert_eq!(
        value["markerTop"].as_f64().expect("scrolled marker top"),
        marker_before
    );
    assert_eq!(value["wheelDeltas"], json!([120]));

    let cancel = send_cdp_command(
        &mut page,
        4,
        "Runtime.evaluate",
        None,
        json!({
            "expression": r#"
                window.addEventListener("wheel", event => event.preventDefault(), {
                  capture: true,
                  passive: false
                })
            "#
        }),
    )
    .await;
    assert!(response_by_id(&cancel, 4).get("result").is_some());
    let canceled_wheel = send_cdp_command(
        &mut page,
        5,
        "Input.dispatchMouseEvent",
        None,
        json!({
            "type": "mouseWheel",
            "x": 10,
            "y": 10,
            "deltaX": 0,
            "deltaY": 80
        }),
    )
    .await;
    assert!(response_by_id(&canceled_wheel, 5).get("result").is_some());
    let final_scroll = send_cdp_command(
        &mut page,
        6,
        "Runtime.evaluate",
        None,
        json!({ "expression": "scrollY", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&final_scroll, 6)["result"]["result"]["value"],
        json!(120)
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_routes_to_existing_target_owner() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let target_list = fetch_server_json(addr, "/json/list").await;
    let listed_target = target_list
        .as_array()
        .expect("target list array")
        .iter()
        .find(|target| target["id"] == json!(target_id))
        .expect("dynamic target should be listed");
    assert_eq!(listed_target["url"], json!("about:blank"));
    assert_eq!(
        listed_target["webSocketDebuggerUrl"],
        json!(format!("ws://{addr}/devtools/page/{target_id}"))
    );
    assert_eq!(
        listed_target["devtoolsFrontendUrl"],
        json!(format!(
            "/devtools/inspector.html?ws={addr}/devtools/page/{target_id}"
        ))
    );
    let mut page = connect_dynamic_page(addr, &target_id).await;

    page.send(WsMessage::Text("{".into()))
        .await
        .expect("send malformed direct page command");
    let parse_error = timeout(Duration::from_secs(5), recv_ws_json(&mut page))
        .await
        .expect("direct page should receive its parse error");
    assert_eq!(parse_error["id"], serde_json::Value::Null);
    assert_eq!(parse_error["error"]["code"], json!(-32700));
    if let Ok(message) =
        tokio::time::timeout(Duration::from_millis(100), recv_ws_json(&mut browser)).await
    {
        panic!("browser frontend received direct-page parse output: {message:#?}");
    }

    let page_owner_info =
        send_cdp_command(&mut page, 7000, "Target.getTargetInfo", None, json!({})).await;
    assert_eq!(
        response_by_id(&page_owner_info, 7000)["result"]["targetInfo"]["targetId"],
        json!(target_id)
    );
    assert_eq!(
        response_by_id(&page_owner_info, 7000)["result"]["targetInfo"]["type"],
        json!("page")
    );

    let frame_tree = send_cdp_command(&mut page, 1, "Page.getFrameTree", None, json!({})).await;
    let frame_tree_response = response_by_id(&frame_tree, 1);
    assert_eq!(
        frame_tree_response["result"]["frameTree"]["frame"]["id"],
        json!(target_id)
    );
    assert!(
        frame_tree_response.get("sessionId").is_none(),
        "direct page response leaked its private flattened session: {frame_tree_response:#?}"
    );

    let page_set = send_cdp_command(
        &mut page,
        2,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_page_bridge = 'from-page'" }),
    )
    .await;
    assert_eq!(
        response_by_id(&page_set, 2)["result"]["result"]["value"],
        json!("from-page")
    );

    let browser_probe =
        send_cdp_command(&mut browser, 2, "Browser.getVersion", None, json!({})).await;
    assert!(
        browser_probe
            .iter()
            .all(|message| message["method"] != json!("Target.attachedToTarget")),
        "private page frontend attach leaked to browser frontend: {browser_probe:#?}"
    );
    let browser_page_command =
        send_cdp_command(&mut browser, 3, "Page.getFrameTree", None, json!({})).await;
    assert_eq!(
        response_by_id(&browser_page_command, 3)["error"],
        json!({
            "code": -32601,
            "message": "'Page.getFrameTree' wasn't found"
        }),
        "the Browser AgentHost must not proxy Page commands to the active target"
    );

    let attach = send_cdp_command(
        &mut browser,
        3,
        "Target.attachToTarget",
        None,
        json!({ "targetId": target_id }),
    )
    .await;
    let browser_session_id = response_by_id(&attach, 3)["result"]["sessionId"]
        .as_str()
        .expect("browser target session")
        .to_owned();
    let browser_read = send_cdp_command(
        &mut browser,
        4,
        "Runtime.evaluate",
        Some(&browser_session_id),
        json!({ "expression": "globalThis.__moli_page_bridge" }),
    )
    .await;
    assert_eq!(
        response_by_id(&browser_read, 4)["result"]["result"]["value"],
        json!("from-page"),
        "browser and direct page frontends did not observe the same runtime"
    );

    browser
        .send(WsMessage::Text(
            json!({
                "id": 77_u64,
                "method": "Runtime.evaluate",
                "sessionId": browser_session_id,
                "params": { "expression": "'browser-response'" }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send browser command with colliding id");
    page.send(WsMessage::Text(
        json!({
            "id": 77_u64,
            "method": "Runtime.evaluate",
            "params": { "expression": "'page-response'" }
        })
        .to_string()
        .into(),
    ))
    .await
    .expect("send page command with colliding id");
    let browser_collision = recv_until_id(&mut browser, 77).await;
    let page_collision = recv_until_id(&mut page, 77).await;
    assert_eq!(
        response_by_id(&browser_collision, 77)["result"]["result"]["value"],
        json!("browser-response")
    );
    assert_eq!(
        response_by_id(&page_collision, 77)["result"]["result"]["value"],
        json!("page-response")
    );
    assert!(
        response_by_id(&page_collision, 77)
            .get("sessionId")
            .is_none()
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn target_create_for_tab_exposes_distinct_chromium_agent_hosts() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");

    let discover = send_cdp_command(
        &mut browser,
        1,
        "Target.setDiscoverTargets",
        None,
        json!({ "discover": true, "filter": [{}] }),
    )
    .await;
    assert_eq!(response_by_id(&discover, 1)["result"], json!({}));

    send_cdp_command_without_wait(
        &mut browser,
        2,
        "Target.createTarget",
        None,
        json!({ "url": "about:blank", "forTab": true }),
    )
    .await;
    let mut saw_response = false;
    let mut page_target_id = None;
    let mut tab_target_id = None;
    let created = recv_until_match(&mut browser, |message| {
        saw_response |= message["id"] == json!(2_u64);
        if message["method"] == json!("Target.targetCreated") {
            let info = &message["params"]["targetInfo"];
            let target_id = info["targetId"].as_str().map(str::to_owned);
            match info["type"].as_str() {
                Some("page") if target_id.as_deref() != Some(DEFAULT_TARGET_ID) => {
                    page_target_id = target_id;
                }
                Some("tab") if target_id.as_deref() != Some(DEFAULT_TAB_TARGET_ID) => {
                    tab_target_id = target_id;
                }
                _ => {}
            }
        }
        saw_response && page_target_id.is_some() && tab_target_id.is_some()
    })
    .await;
    let page_target_id = page_target_id.expect("created Page target id");
    let tab_target_id = tab_target_id.expect("created Tab target id");
    assert_ne!(page_target_id, tab_target_id);
    assert_eq!(
        response_by_id(&created, 2)["result"]["targetId"],
        json!(tab_target_id),
        "forTab=true must return the stable Tab AgentHost"
    );
    let tab_created = created
        .iter()
        .position(|message| {
            message["method"] == json!("Target.targetCreated")
                && message["params"]["targetInfo"]["targetId"] == json!(tab_target_id)
        })
        .expect("Tab targetCreated");
    let page_created = created
        .iter()
        .position(|message| {
            message["method"] == json!("Target.targetCreated")
                && message["params"]["targetInfo"]["targetId"] == json!(page_target_id)
        })
        .expect("Page targetCreated");
    assert!(
        tab_created < page_created,
        "Chromium publishes the WebContents Tab host before its primary Page host: {created:#?}"
    );

    let mut tab = connect_discovered_tab(addr, &tab_target_id).await;
    let tab_info = send_cdp_command(&mut tab, 1, "Target.getTargetInfo", None, json!({})).await;
    assert_eq!(
        response_by_id(&tab_info, 1)["result"]["targetInfo"]["targetId"],
        json!(tab_target_id)
    );
    assert_eq!(
        response_by_id(&tab_info, 1)["result"]["targetInfo"]["type"],
        json!("tab")
    );
    let tab_page_session = enable_tab_page(&mut tab, 2, &page_target_id).await;
    let child_info = send_cdp_command(
        &mut tab,
        4,
        "Target.getTargetInfo",
        Some(&tab_page_session),
        json!({}),
    )
    .await;
    assert_eq!(
        response_by_id(&child_info, 4)["result"]["targetInfo"]["targetId"],
        json!(page_target_id)
    );
    assert_eq!(
        response_by_id(&child_info, 4)["result"]["targetInfo"]["type"],
        json!("page")
    );

    send_cdp_command_without_wait(
        &mut browser,
        3,
        "Target.closeTarget",
        None,
        json!({ "targetId": tab_target_id }),
    )
    .await;
    let mut saw_close_response = false;
    let mut saw_page_destroyed = false;
    let mut saw_tab_destroyed = false;
    let closed = recv_until_match(&mut browser, |message| {
        saw_close_response |= message["id"] == json!(3_u64);
        if message["method"] == json!("Target.targetDestroyed") {
            saw_page_destroyed |= message["params"]["targetId"] == json!(page_target_id);
            saw_tab_destroyed |= message["params"]["targetId"] == json!(tab_target_id);
        }
        saw_close_response && saw_page_destroyed && saw_tab_destroyed
    })
    .await;
    assert_eq!(response_by_id(&closed, 3)["result"]["success"], json!(true));
    let page_destroyed = closed
        .iter()
        .position(|message| {
            message["method"] == json!("Target.targetDestroyed")
                && message["params"]["targetId"] == json!(page_target_id)
        })
        .expect("Page targetDestroyed");
    let tab_destroyed = closed
        .iter()
        .position(|message| {
            message["method"] == json!("Target.targetDestroyed")
                && message["params"]["targetId"] == json!(tab_target_id)
        })
        .expect("Tab targetDestroyed");
    assert!(
        page_destroyed < tab_destroyed,
        "Chromium destroys the Page host before its owning Tab host: {closed:#?}"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn new_windows_keep_independent_tab_selection_and_bounds() {
    for (first_new_window, background) in
        [(false, false), (false, true), (true, false), (true, true)]
    {
        verify_independent_window_selection(first_new_window, background).await;
    }
}

async fn verify_independent_window_selection(first_new_window: bool, background: bool) {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let first_created = send_cdp_command(
        &mut browser,
        1,
        "Target.createTarget",
        None,
        json!({"url": "about:blank", "newWindow": first_new_window}),
    )
    .await;
    let first_target = response_by_id(&first_created, 1)["result"]["targetId"]
        .as_str()
        .unwrap()
        .to_owned();
    let created = send_cdp_command(
        &mut browser,
        2,
        "Target.createTarget",
        None,
        json!({"url": "about:blank", "newWindow": true, "background": background}),
    )
    .await;
    let second_target = response_by_id(&created, 2)["result"]["targetId"]
        .as_str()
        .unwrap()
        .to_owned();
    let third_target = create_dynamic_target(&mut browser, 3).await;
    let mut windows = Vec::new();
    for (index, target) in [&first_target, &second_target, &third_target]
        .into_iter()
        .enumerate()
    {
        let id = 10 + index as u64;
        let messages = send_cdp_command(
            &mut browser,
            id,
            "Browser.getWindowForTarget",
            None,
            json!({"targetId": target}),
        )
        .await;
        windows.push(response_by_id(&messages, id)["result"]["windowId"].clone());
    }
    assert_ne!(windows[0], windows[1]);
    assert_eq!(windows[if background { 0 } else { 1 }], windows[2]);
    let mut first = connect_dynamic_page(addr, &first_target).await;
    let mut second = connect_dynamic_page(addr, &second_target).await;
    let mut third = connect_dynamic_page(addr, &third_target).await;
    async fn activity(socket: &mut TestCdpSocket, id: u64) -> serde_json::Value {
        let messages = send_cdp_command(socket, id, "Runtime.evaluate", None,
            json!({"expression": "[document.hasFocus(), document.visibilityState]", "returnByValue": true})).await;
        response_by_id(&messages, id)["result"]["result"]["value"].clone()
    }
    assert_eq!(
        activity(&mut first, 1).await,
        json!([false, if background { "hidden" } else { "visible" }])
    );
    assert_eq!(
        activity(&mut second, 1).await,
        json!([false, if background { "visible" } else { "hidden" }])
    );
    assert_eq!(activity(&mut third, 1).await, json!([true, "visible"]));
    send_cdp_command(
        &mut browser,
        20,
        "Target.activateTarget",
        None,
        json!({"targetId": first_target}),
    )
    .await;
    assert_eq!(activity(&mut first, 2).await, json!([true, "visible"]));
    assert_eq!(
        activity(&mut third, 2).await,
        json!([false, if background { "hidden" } else { "visible" }])
    );
    send_cdp_command(
        &mut browser,
        21,
        "Target.closeTarget",
        None,
        json!({"targetId": third_target}),
    )
    .await;
    assert_eq!(activity(&mut second, 2).await, json!([false, "visible"]));
    for (index, target) in [&first_target, &second_target].into_iter().enumerate() {
        let id = 30 + index as u64;
        let set = send_cdp_command(&mut browser, id, "Browser.setWindowBounds", None,
            json!({"windowId": windows[index], "bounds": {"width": 700 + index * 100, "height": 600}})).await;
        assert_eq!(response_by_id(&set, id)["result"], json!({}));
        let get = send_cdp_command(
            &mut browser,
            id + 10,
            "Browser.getWindowForTarget",
            None,
            json!({"targetId": target}),
        )
        .await;
        assert_eq!(
            response_by_id(&get, id + 10)["result"]["bounds"]["width"],
            json!(700 + index * 100)
        );
    }
    send_cdp_command(
        &mut browser,
        50,
        "Target.activateTarget",
        None,
        json!({"targetId": second_target}),
    )
    .await;
    send_cdp_command(
        &mut browser,
        51,
        "Target.closeTarget",
        None,
        json!({"targetId": second_target}),
    )
    .await;
    assert_eq!(activity(&mut first, 3).await, json!([true, "visible"]));
    let closed_window = send_cdp_command(
        &mut browser,
        52,
        "Browser.setWindowBounds",
        None,
        json!({"windowId": windows[1], "bounds": {"width": 900}}),
    )
    .await;
    assert!(response_by_id(&closed_window, 52).get("error").is_some());
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn browser_focus_moves_between_contexts_without_hiding_their_windows() {
    async fn activity(socket: &mut TestCdpSocket, id: u64) -> serde_json::Value {
        let messages = send_cdp_command(socket, id, "Runtime.evaluate", None,
            json!({"expression": "[document.hasFocus(), document.visibilityState]", "returnByValue": true})).await;
        response_by_id(&messages, id)["result"]["result"]["value"].clone()
    }
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let first_target = create_dynamic_target(&mut browser, 1).await;
    let mut first = connect_dynamic_page(addr, &first_target).await;
    let created = send_cdp_command(
        &mut browser,
        2,
        "Target.createBrowserContext",
        None,
        json!({}),
    )
    .await;
    let context_id = response_by_id(&created, 2)["result"]["browserContextId"]
        .as_str()
        .unwrap();
    let created = send_cdp_command(
        &mut browser,
        3,
        "Target.createTarget",
        None,
        json!({"url": "about:blank", "browserContextId": context_id}),
    )
    .await;
    let second_target = response_by_id(&created, 3)["result"]["targetId"]
        .as_str()
        .unwrap();
    let mut second = connect_dynamic_page(addr, second_target).await;
    assert_eq!(activity(&mut first, 1).await, json!([false, "visible"]));
    assert_eq!(activity(&mut second, 1).await, json!([true, "visible"]));
    send_cdp_command(
        &mut browser,
        4,
        "Target.activateTarget",
        None,
        json!({"targetId": first_target}),
    )
    .await;
    assert_eq!(activity(&mut first, 2).await, json!([true, "visible"]));
    assert_eq!(activity(&mut second, 2).await, json!([false, "visible"]));
    send_cdp_command(&mut second, 3, "Page.bringToFront", None, json!({})).await;
    assert_eq!(activity(&mut first, 3).await, json!([false, "visible"]));
    assert_eq!(activity(&mut second, 4).await, json!([true, "visible"]));
    send_cdp_command(
        &mut browser,
        5,
        "Target.disposeBrowserContext",
        None,
        json!({"browserContextId": context_id}),
    )
    .await;
    assert_eq!(activity(&mut first, 4).await, json!([true, "visible"]));
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn foreground_operations_do_not_wait_for_an_unchanged_busy_context() {
    let entered = Arc::new(tokio::sync::Notify::new());
    let witness = Arc::clone(&entered);
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new()
            .route(
                "/",
                get(|| async { axum::response::Html("<title>Busy background</title>") }),
            )
            .route(
                "/entered",
                get(move || {
                    let witness = Arc::clone(&witness);
                    async move {
                        witness.notify_one();
                        "entered"
                    }
                }),
            ),
        "unrelated-busy-context",
    );
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let first_id = create_dynamic_target(&mut browser, 1).await;
    let second_id = create_dynamic_target(&mut browser, 2).await;
    let mut first = connect_dynamic_page(addr, &first_id).await;
    let mut second = connect_dynamic_page(addr, &second_id).await;
    let context = send_cdp_command(
        &mut browser,
        3,
        "Target.createBrowserContext",
        None,
        json!({}),
    )
    .await;
    let context_id = response_by_id(&context, 3)["result"]["browserContextId"]
        .as_str()
        .unwrap();
    let created = send_cdp_command(
        &mut browser,
        4,
        "Target.createTarget",
        None,
        json!({"url": "about:blank", "browserContextId": context_id}),
    )
    .await;
    let busy_id = response_by_id(&created, 4)["result"]["targetId"]
        .as_str()
        .unwrap();
    let mut busy = connect_dynamic_page(addr, busy_id).await;
    send_cdp_command(&mut busy, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut busy, 2, &format!("http://{fixture_addr}/")).await;
    send_cdp_command(
        &mut browser,
        5,
        "Target.activateTarget",
        None,
        json!({"targetId": first_id}),
    )
    .await;
    assert_eq!(
        evaluate_window_name_probe(
            &mut busy,
            3,
            "[document.hasFocus(), document.visibilityState]"
        )
        .await,
        json!([false, "visible"])
    );

    send_cdp_command_without_wait(&mut busy, 4, "Runtime.evaluate", None, json!({
        "expression": "const xhr = new XMLHttpRequest(); xhr.open('GET', '/entered', false); xhr.send(); const until = Date.now() + 20000; while (Date.now() < until) {} 'expired'",
        "returnByValue": true,
    })).await;
    timeout(Duration::from_secs(5), entered.notified())
        .await
        .expect("busy script entered renderer");
    let operations = timeout(Duration::from_secs(5), async {
        let bring = send_cdp_command(&mut first, 1, "Page.bringToFront", None, json!({})).await;
        let activate = send_cdp_command(
            &mut browser,
            6,
            "Target.activateTarget",
            None,
            json!({"targetId": second_id}),
        )
        .await;
        let temporary = send_cdp_command(
            &mut browser,
            7,
            "Target.createTarget",
            None,
            json!({"url": "about:blank"}),
        )
        .await;
        let temporary_id = response_by_id(&temporary, 7)["result"]["targetId"]
            .as_str()
            .unwrap();
        let close = send_cdp_command(
            &mut browser,
            8,
            "Target.closeTarget",
            None,
            json!({"targetId": temporary_id}),
        )
        .await;
        (bring, activate, temporary, close)
    })
    .await;
    // Always release the witness script before asserting the liveness result.
    // Its own deadline also bounds cleanup if the IO termination path fails.
    let terminated =
        send_cdp_command(&mut busy, 5, "Runtime.terminateExecution", None, json!({})).await;
    assert!(
        response_by_id(&terminated, 5)["error"].is_null(),
        "{terminated:#?}"
    );
    assert!(
        !terminated
            .iter()
            .any(|message| message["id"] == 4 && message["result"]["result"]["value"] == "expired"),
        "the witness must still be busy until termination"
    );
    let (bring, activate, temporary, close) = operations.expect(
        "foreground operations must complete while an unrelated context remains in synchronous JS",
    );
    for (response, id) in [(&bring, 1), (&activate, 6), (&temporary, 7), (&close, 8)] {
        assert!(
            response_by_id(response, id)["error"].is_null(),
            "{response:#?}"
        );
    }
    assert_eq!(
        evaluate_window_name_probe(
            &mut second,
            1,
            "[document.hasFocus(), document.visibilityState]"
        )
        .await,
        json!([true, "visible"])
    );
    assert_eq!(
        evaluate_window_name_probe(
            &mut busy,
            6,
            "[document.hasFocus(), document.visibilityState]"
        )
        .await,
        json!([false, "visible"])
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn background_page_metadata_tracks_titles_and_same_document_navigation() {
    let fixture_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let fixture_url = format!("http://{}/", fixture_listener.local_addr().unwrap());
    let fixture_server = tokio::spawn(async move {
        axum::serve(
            fixture_listener,
            axum::Router::new().route(
                "/",
                axum::routing::get(|| async {
                    axum::response::Html("<title>Background navigation</title><h1>loaded</h1>")
                }),
            ),
        )
        .await
    });
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    send_cdp_command(
        &mut browser,
        1,
        "Target.setDiscoverTargets",
        None,
        json!({"discover": true}),
    )
    .await;
    let background_target = create_dynamic_target(&mut browser, 2).await;
    let mut page = connect_dynamic_page(addr, &background_target).await;
    create_dynamic_target(&mut browser, 3).await;
    send_cdp_command(&mut page, 1, "Page.enable", None, json!({})).await;
    send_cdp_command_without_wait(
        &mut page,
        2,
        "Page.navigate",
        None,
        json!({"url": fixture_url}),
    )
    .await;
    let mut response_received = false;
    let mut loaded = false;
    recv_until_match(&mut page, |message| {
        response_received |= message["id"] == json!(2);
        loaded |= message["method"] == json!("Page.loadEventFired");
        response_received && loaded
    })
    .await;

    let targets = send_cdp_command(&mut browser, 4, "Target.getTargets", None, json!({})).await;
    let target = response_by_id(&targets, 4)["result"]["targetInfos"]
        .as_array()
        .unwrap()
        .iter()
        .find(|target| target["targetId"] == background_target)
        .unwrap();
    assert_eq!(target["title"], "Background navigation");

    for (index, (expression, suffix)) in [
        ("history.pushState({}, '', '/pushed')", "pushed"),
        ("history.replaceState({}, '', '/replaced')", "replaced"),
        ("location.hash = 'fragment'", "replaced#fragment"),
    ]
    .into_iter()
    .enumerate()
    {
        let url = format!("{fixture_url}{suffix}");
        let response = send_cdp_command(
            &mut page,
            10 + index as u64,
            "Runtime.evaluate",
            None,
            json!({"expression": expression}),
        )
        .await;
        assert!(
            response_by_id(&response, 10 + index as u64)
                .get("error")
                .is_none()
        );
        recv_until_match(&mut browser, |message| {
            message["method"] == "Target.targetInfoChanged"
                && message["params"]["targetInfo"]["targetId"] == background_target
                && message["params"]["targetInfo"]["url"] == url
        })
        .await;
        timeout(Duration::from_secs(5), async {
            loop {
                let descriptors = fetch_server_json(addr, "/json/list").await;
                if descriptors.as_array().unwrap().iter().any(|target| {
                    target["id"] == background_target
                        && target["url"] == url
                        && target["title"] == "Background navigation"
                }) {
                    break;
                }
                tokio::time::sleep(Duration::from_millis(10)).await;
            }
        })
        .await
        .expect("HTTP discovery must follow background page metadata");
    }
    abort_test_cdp_server(server).await;
    fixture_server.abort();
}

async fn evaluate_window_name_probe(
    page: &mut TestCdpSocket,
    id: u64,
    expression: &str,
) -> serde_json::Value {
    let messages = send_cdp_command(
        page,
        id,
        "Runtime.evaluate",
        None,
        json!({"expression": expression, "returnByValue": true}),
    )
    .await;
    let response = response_by_id(&messages, id);
    assert!(response["error"].is_null(), "{response}");
    assert!(
        response["result"]["exceptionDetails"].is_null(),
        "{response}"
    );
    response["result"]["result"]["value"].clone()
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn window_name_survives_ordinary_navigations_and_is_available_to_parser_scripts() {
    // Chromium's cross-site Window.name clearing feature is disabled by
    // default. Changing the name-lookup group does not erase the stored name.
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(|| async {
            axum::response::Html("<script>window.initialName = window.name</script>")
        })),
        "window-name",
    );
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let target = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target).await;
    send_cdp_command(&mut page, 1, "Page.enable", None, json!({})).await;
    assert_eq!(
        evaluate_window_name_probe(&mut page, 2, "window.name = 'keep-me'").await,
        "keep-me"
    );
    for (index, (method, params, expected)) in [
        (
            "Page.navigate",
            json!({"url": format!("http://{fixture_addr}/first")}),
            "keep-me",
        ),
        ("Page.reload", json!({}), "keep-me"),
        (
            "Page.navigate",
            json!({"url": format!("http://{fixture_addr}/second")}),
            "keep-me",
        ),
        (
            "Page.navigate",
            json!({"url": format!("http://localhost:{}/unrelated", fixture_addr.port())}),
            "keep-me",
        ),
        ("Page.reload", json!({}), "keep-me"),
    ]
    .into_iter()
    .enumerate()
    {
        let id = 10 + index as u64 * 2;
        send_cdp_command_without_wait(&mut page, id, method, None, params).await;
        let mut response = false;
        let mut loaded = false;
        recv_until_match(&mut page, |message| {
            response |= message["id"] == id;
            loaded |= message["method"] == "Page.loadEventFired";
            response && loaded
        })
        .await;
        assert_eq!(
            evaluate_window_name_probe(&mut page, id + 1, "[window.name, window.initialName]")
                .await,
            json!([expected, expected])
        );
    }
    let other = create_dynamic_target(&mut browser, 2).await;
    let mut other_page = connect_dynamic_page(addr, &other).await;
    assert_eq!(
        evaluate_window_name_probe(&mut other_page, 1, "window.name").await,
        ""
    );
    evaluate_window_name_probe(&mut page, 30, "window.name = 'unrelated-root'").await;
    let target_count = fetch_server_json(addr, "/json/list")
        .await
        .as_array()
        .unwrap()
        .len();
    assert_eq!(
        evaluate_window_name_probe(
            &mut other_page,
            2,
            "window.open('about:blank', 'unrelated-root') !== null"
        )
        .await,
        true
    );
    wait_for_target_list(
        addr,
        "an unrelated named CDP root must not be reused",
        |targets| targets.len() == target_count + 1,
    )
    .await;
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn named_popup_rename_is_shared_with_opener_and_named_target_lookup() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    assert_eq!(
        evaluate_window_name_probe(
            &mut opener,
            1,
            "window.popup = window.open('about:blank', 'original'); popup.name"
        )
        .await,
        "original"
    );
    let targets = wait_for_target_list(addr, "named popup published", |targets| {
        targets.len() == baseline_ids.len() + 1
    })
    .await;
    let popup_id = targets
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]))
        .unwrap()["id"]
        .as_str()
        .unwrap();
    let mut popup = connect_dynamic_page(addr, popup_id).await;
    assert_eq!(
        evaluate_window_name_probe(&mut popup, 1, "window.name").await,
        "original"
    );
    assert_eq!(
        evaluate_window_name_probe(&mut popup, 2, "window.name = 'renamed'").await,
        "renamed"
    );
    assert_eq!(
        evaluate_window_name_probe(
            &mut opener,
            2,
            "[popup.name, window.open('about:blank', 'renamed') === popup]"
        )
        .await,
        json!(["renamed", true])
    );
    let after_reuse = fetch_server_json(addr, "/json/list").await;
    assert_eq!(after_reuse.as_array().unwrap().len(), targets.len());
    assert_eq!(
        evaluate_window_name_probe(
            &mut opener,
            3,
            "window.open('about:blank', 'original') !== popup"
        )
        .await,
        true
    );
    wait_for_target_list(
        addr,
        "old name must no longer resolve to the renamed target",
        |current| current.len() == targets.len() + 1,
    )
    .await;
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn accepted_popup_identity_survives_same_turn_rename_and_name_collision() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    evaluate_window_name_probe(
        &mut opener,
        1,
        "window.p = open('about:blank', 'report'); true",
    )
    .await;
    let targets = wait_for_target_list(addr, "original popup created", |targets| {
        targets.len() == baseline_ids.len() + 1
    })
    .await;
    let original_id = targets
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]))
        .unwrap()["id"]
        .as_str()
        .unwrap()
        .to_owned();
    assert_eq!(evaluate_window_name_probe(&mut opener, 2,
        "(() => { const reused = open('about:blank', 'report'); reused.name = 'renamed'; return reused === p; })()"
    ).await, true);
    assert_eq!(
        fetch_server_json(addr, "/json/list")
            .await
            .as_array()
            .unwrap()
            .len(),
        targets.len()
    );
    let mut original = connect_dynamic_page(addr, &original_id).await;
    assert_eq!(
        evaluate_window_name_probe(&mut original, 1, "name").await,
        "renamed"
    );

    // Conversely, choosing a new context and then giving it an existing name
    // must not let protocol redirect that creation into the older target.
    assert_eq!(
        evaluate_window_name_probe(
            &mut opener,
            3,
            "window.q = open('about:blank', 'new-window'); q.name = 'renamed'; q !== p"
        )
        .await,
        true
    );
    let with_second =
        wait_for_target_list(addr, "second identity remains independent", |targets| {
            targets.len() == baseline_ids.len() + 2
        })
        .await;
    let second_id = with_second
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]) && target["id"] != original_id)
        .unwrap()["id"]
        .as_str()
        .unwrap()
        .to_owned();
    evaluate_window_name_probe(&mut opener, 4, "p.close(); true").await;
    let after_close = wait_for_target_list(addr, "only the original identity closes", |targets| {
        targets.len() == baseline_ids.len() + 1
    })
    .await;
    assert!(!after_close.iter().any(|target| target["id"] == original_id));
    assert!(after_close.iter().any(|target| target["id"] == second_id));
    assert_eq!(
        evaluate_window_name_probe(&mut opener, 5, "[p.closed, q.closed]").await,
        json!([true, false])
    );
    evaluate_window_name_probe(&mut opener, 6, "q.close(); true").await;
    wait_for_target_list(
        addr,
        "both identities close without leaving duplicate targets",
        |targets| targets.len() == baseline_ids.len(),
    )
    .await;
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn popup_close_routes_script_and_protocol_requests_to_the_same_target() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    for (index, close_kind) in ["self", "reference", "protocol"].into_iter().enumerate() {
        assert_eq!(
            evaluate_window_name_probe(
                &mut opener,
                100 + index as u64,
                "window.popup = window.open('about:blank', 'closable'); popup.closed"
            )
            .await,
            false
        );
        let targets = wait_for_target_list(addr, "popup published", |current| {
            current.len() == baseline_ids.len() + 1
        })
        .await;
        let popup_id = targets
            .iter()
            .find(|target| !baseline_ids.contains(&target["id"]))
            .unwrap()["id"]
            .as_str()
            .unwrap()
            .to_owned();
        match close_kind {
            "self" => {
                let mut popup = connect_dynamic_page(addr, &popup_id).await;
                assert_eq!(
                    evaluate_window_name_probe(
                        &mut popup,
                        1,
                        "window.close(); 'response-before-detach'"
                    )
                    .await,
                    "response-before-detach"
                );
            }
            "reference" => {
                assert_eq!(
                    evaluate_window_name_probe(&mut opener, 200, "popup.close(); popup.closed")
                        .await,
                    true
                );
            }
            _ => {
                let messages = send_cdp_command(
                    &mut browser,
                    200,
                    "Target.closeTarget",
                    None,
                    json!({"targetId": popup_id}),
                )
                .await;
                assert_eq!(response_by_id(&messages, 200)["result"]["success"], true);
            }
        }
        wait_for_target_list(addr, "closed popup removed from discovery", |current| {
            !current.iter().any(|target| target["id"] == popup_id)
        })
        .await;
        assert_eq!(
            evaluate_window_name_probe(
                &mut opener,
                300 + index as u64,
                "[popup.closed, popup.opener === window, document.hasFocus()]"
            )
            .await,
            json!([true, false, true])
        );
    }
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn popups_from_different_openers_keep_independent_close_identities() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let first = create_dynamic_target(&mut browser, 1).await;
    let second = create_dynamic_target(&mut browser, 2).await;
    let mut first_opener = connect_dynamic_page(addr, &first).await;
    let mut second_opener = connect_dynamic_page(addr, &second).await;
    let baseline = fetch_server_json(addr, "/json/list")
        .await
        .as_array()
        .unwrap()
        .len();
    for (page, name) in [(&mut first_opener, "first"), (&mut second_opener, "second")] {
        assert_eq!(
            evaluate_window_name_probe(
                page,
                1,
                &format!("window.popup = window.open('about:blank', '{name}'); popup.closed")
            )
            .await,
            false
        );
    }
    wait_for_target_list(addr, "both popups published", |current| {
        current.len() == baseline + 2
    })
    .await;
    assert_eq!(
        evaluate_window_name_probe(&mut second_opener, 2, "popup.close(); popup.closed").await,
        true
    );
    wait_for_target_list(addr, "only second popup removed", |current| {
        current.len() == baseline + 1
    })
    .await;
    assert_eq!(
        evaluate_window_name_probe(&mut first_opener, 2, "popup.closed").await,
        false
    );
    // Replacing the opener's Document must not recycle its former popup ID.
    send_cdp_command(
        &mut second_opener,
        3,
        "Page.navigate",
        None,
        json!({"url": "about:blank"}),
    )
    .await;
    assert_eq!(
        evaluate_window_name_probe(
            &mut second_opener,
            4,
            "window.popup = window.open('about:blank', 'third'); popup.closed"
        )
        .await,
        false
    );
    wait_for_target_list(addr, "third popup published", |current| {
        current.len() == baseline + 2
    })
    .await;
    assert_eq!(
        evaluate_window_name_probe(&mut first_opener, 5, "popup.close(); popup.closed").await,
        true
    );
    wait_for_target_list(addr, "only first popup removed", |current| {
        current.len() == baseline + 1
    })
    .await;
    assert_eq!(
        evaluate_window_name_probe(&mut second_opener, 5, "popup.closed").await,
        false
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn named_popup_references_from_sibling_pages_share_the_close_lifetime() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    evaluate_window_name_probe(&mut opener, 1, "window.child = window.open('about:blank', 'child'); window.sibling = window.open('about:blank', 'sibling'); true").await;
    let targets = wait_for_target_list(addr, "both related popups published", |targets| {
        targets.len() == baseline_ids.len() + 2
    })
    .await;
    let mut child_page = None;
    let mut sibling_page = None;
    for target in targets
        .iter()
        .filter(|target| !baseline_ids.contains(&target["id"]))
    {
        let mut page = connect_dynamic_page(addr, target["id"].as_str().unwrap()).await;
        match evaluate_window_name_probe(&mut page, 1, "window.name")
            .await
            .as_str()
            .unwrap()
        {
            "child" => child_page = Some(page),
            "sibling" => sibling_page = Some(page),
            name => panic!("unexpected popup name {name}"),
        }
    }
    let mut child = child_page.unwrap();
    let mut sibling = sibling_page.unwrap();
    assert_eq!(
        evaluate_window_name_probe(
            &mut sibling,
            2,
            "window.other = window.open('about:blank', 'child'); other.closed"
        )
        .await,
        false
    );
    assert_eq!(
        fetch_server_json(addr, "/json/list")
            .await
            .as_array()
            .unwrap()
            .len(),
        targets.len()
    );
    assert_eq!(
        evaluate_window_name_probe(&mut child, 2, "close(); 'closed'").await,
        "closed"
    );
    wait_for_target_list(addr, "shared child target closed", |current| {
        current.len() == targets.len() - 1
    })
    .await;
    assert_eq!(
        evaluate_window_name_probe(&mut sibling, 3, "other.closed").await,
        true
    );
    assert_eq!(
        evaluate_window_name_probe(&mut opener, 2, "[child.closed, sibling.closed]").await,
        json!([true, false])
    );
    abort_test_cdp_server(server).await;
}

async fn navigate_dynamic_page_and_wait_for_load(page: &mut TestCdpSocket, id: u64, url: &str) {
    send_cdp_command(
        page,
        id,
        "Page.setLifecycleEventsEnabled",
        None,
        json!({"enabled": true}),
    )
    .await;
    let navigation = send_cdp_command(page, id, "Page.navigate", None, json!({"url": url})).await;
    let response = response_by_id(&navigation, id);
    assert!(response["error"].is_null(), "{response}");
    let loader = response["result"]["loaderId"]
        .as_str()
        .expect("dynamic navigation loader");
    // A popup's previous load may still be queued. Only the requested
    // navigation's loader can establish that its document has finished.
    let loaded = |message: &serde_json::Value| {
        message["method"] == "Page.lifecycleEvent"
            && message["params"]["loaderId"] == loader
            && message["params"]["name"] == "load"
    };
    if !navigation.iter().any(loaded) {
        recv_until_match(page, loaded).await;
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn page_location_navigation_preserves_replace_and_reload_history() {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(|uri: axum::http::Uri| async move {
            axum::response::Html(format!("<h1>{}</h1>", uri.path()))
        })),
        "page-location-history",
    );
    let base = format!("http://{fixture_addr}");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let target = create_dynamic_target(&mut browser, 1).await;
    let mut observer = connect_dynamic_page(addr, &target).await;
    send_cdp_command(&mut observer, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut observer, 2, &format!("{base}/start")).await;
    let mut script = connect_dynamic_page(addr, &target).await;
    let history = send_cdp_command(
        &mut observer,
        3,
        "Page.getNavigationHistory",
        None,
        json!({}),
    )
    .await;
    let initial_length = response_by_id(&history, 3)["result"]["entries"]
        .as_array()
        .unwrap()
        .len();
    let mut previous_history = serde_json::Value::Null;
    for (index, (operation, path)) in [
        ("location.assign('/assigned')", "/assigned"),
        ("location.replace('/replaced')", "/replaced"),
        ("location.reload()", "/replaced"),
    ]
    .into_iter()
    .enumerate()
    {
        evaluate_window_name_probe(
            &mut script,
            10 + index as u64,
            &format!("window.navigationSentinel = true; {operation}; true"),
        )
        .await;
        recv_until_match(&mut observer, |message| {
            message["method"] == "Page.loadEventFired"
        })
        .await;
        assert_eq!(
            evaluate_window_name_probe(
                &mut script,
                20 + index as u64,
                "[location.pathname, document.querySelector('h1').textContent, history.length, typeof navigationSentinel]",
            )
            .await,
            json!([path, path, initial_length + 1, "undefined"]),
            "{operation} must commit a new Document with the intended history mutation",
        );
        let id = 30 + index as u64;
        let messages = send_cdp_command(
            &mut observer,
            id,
            "Page.getNavigationHistory",
            None,
            json!({}),
        )
        .await;
        let history = &response_by_id(&messages, id)["result"];
        let entries = history["entries"].as_array().unwrap();
        assert_eq!(entries.len(), initial_length + 1, "{operation}");
        assert_eq!(history["currentIndex"], json!(initial_length));
        assert_eq!(entries[initial_length]["url"], format!("{base}{path}"));
        assert_eq!(entries[initial_length]["transitionType"], "link");
        if index > 0 {
            assert_eq!(
                entries[initial_length]["id"], previous_history["entries"][initial_length]["id"],
                "replace and reload retain the current entry identity",
            );
        }
        if index == 2 {
            assert_eq!(history, &previous_history, "reload preserves history");
        }
        previous_history = history.clone();
    }
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn popup_reference_location_navigates_its_real_page_and_preserves_history_operations() {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(|uri: axum::http::Uri| async move {
            axum::response::Html(format!(
                "<title>{0}</title><h1>{0}</h1><script>window.loadToken = Math.random()</script>",
                uri.path()
            ))
        })),
        "popup-reference-navigation",
    );
    let base = format!("http://{fixture_addr}");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    send_cdp_command(&mut opener, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut opener, 2, &format!("{base}/opener")).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    evaluate_window_name_probe(
        &mut opener,
        3,
        "window.popup = open('about:blank', 'navigation'); true",
    )
    .await;
    let targets = wait_for_target_list(addr, "popup created", |targets| {
        targets.len() == baseline_ids.len() + 1
    })
    .await;
    let popup_id = targets
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]))
        .unwrap()["id"]
        .as_str()
        .unwrap()
        .to_owned();
    let mut popup = connect_dynamic_page(addr, &popup_id).await;
    send_cdp_command(&mut popup, 1, "Page.enable", None, json!({})).await;
    evaluate_window_name_probe(
        &mut opener,
        4,
        &format!(
            "popup.location.href = {}; true",
            json!(format!("{base}/start"))
        ),
    )
    .await;
    recv_until_match(&mut popup, |message| {
        message["method"] == "Page.loadEventFired"
    })
    .await;
    let history =
        send_cdp_command(&mut popup, 3, "Page.getNavigationHistory", None, json!({})).await;
    let initial_history_len = response_by_id(&history, 3)["result"]["entries"]
        .as_array()
        .unwrap()
        .len();
    assert_eq!(initial_history_len, 1, "replace the initial empty document");
    let unrelated_id = create_dynamic_target(&mut browser, 2).await;
    let mut unrelated = connect_dynamic_page(addr, &unrelated_id).await;

    for (index, (method, path)) in [("assign", "/assigned"), ("replace", "/replaced")]
        .into_iter()
        .enumerate()
    {
        let url = format!("{base}{path}");
        let expression = format!("popup.location.{method}({}); 'accepted'", json!(url));
        assert_eq!(
            evaluate_window_name_probe(&mut opener, 10 + index as u64, &expression).await,
            "accepted"
        );
        recv_until_match(&mut popup, |message| {
            message["method"] == "Page.loadEventFired"
        })
        .await;
        assert_eq!(
            evaluate_window_name_probe(
                &mut popup,
                10 + index as u64,
                "[location.href, document.querySelector('h1').textContent]"
            )
            .await,
            json!([url, path])
        );
        let id = 20 + index as u64;
        let history =
            send_cdp_command(&mut popup, id, "Page.getNavigationHistory", None, json!({})).await;
        let history = &response_by_id(&history, id)["result"];
        assert_eq!(
            history["entries"].as_array().unwrap().len(),
            initial_history_len + 1
        );
        assert_eq!(
            history["entries"][history["currentIndex"].as_u64().unwrap() as usize]["url"],
            url
        );
        assert_eq!(
            history["entries"][history["currentIndex"].as_u64().unwrap() as usize]["transitionType"],
            "link"
        );
        wait_for_target_list(addr, "navigation published to discovery", |targets| {
            targets
                .iter()
                .any(|target| target["id"] == popup_id && target["url"] == url)
        })
        .await;
    }
    assert_eq!(
        evaluate_window_name_probe(&mut unrelated, 1, "[location.href, document.hasFocus()]").await,
        json!(["about:blank", true])
    );
    assert_eq!(
        evaluate_window_name_probe(&mut opener, 30, "location.pathname").await,
        "/opener"
    );

    evaluate_window_name_probe(&mut opener, 31, "popup.location.hash = 'fragment'; true").await;
    recv_until_match(&mut popup, |message| {
        message["method"] == "Page.navigatedWithinDocument"
    })
    .await;
    let fragment_history =
        send_cdp_command(&mut popup, 50, "Page.getNavigationHistory", None, json!({})).await;
    let fragment_history_len = response_by_id(&fragment_history, 50)["result"]["entries"]
        .as_array()
        .unwrap()
        .len();
    evaluate_window_name_probe(
        &mut opener,
        51,
        &format!(
            "popup.location.replace({}); true",
            json!(format!("{base}/replaced#replaced-fragment"))
        ),
    )
    .await;
    recv_until_match(&mut popup, |message| {
        message["method"] == "Page.navigatedWithinDocument"
    })
    .await;
    let history =
        send_cdp_command(&mut popup, 51, "Page.getNavigationHistory", None, json!({})).await;
    assert_eq!(
        response_by_id(&history, 51)["result"]["entries"]
            .as_array()
            .unwrap()
            .len(),
        fragment_history_len
    );
    assert_eq!(
        evaluate_window_name_probe(&mut popup, 52, "history.length").await,
        json!(fragment_history_len)
    );
    // A same-document replace must not leave a pending replacement that can
    // accidentally consume the next cross-document push.
    evaluate_window_name_probe(
        &mut opener,
        52,
        &format!(
            "popup.location.assign({}); true",
            json!(format!("{base}/after-fragment#reload"))
        ),
    )
    .await;
    recv_until_match(&mut popup, |message| {
        message["method"] == "Page.loadEventFired"
    })
    .await;
    let history =
        send_cdp_command(&mut popup, 53, "Page.getNavigationHistory", None, json!({})).await;
    assert_eq!(
        response_by_id(&history, 53)["result"]["entries"]
            .as_array()
            .unwrap()
            .len(),
        fragment_history_len + 1
    );
    let before_reload = evaluate_window_name_probe(&mut popup, 30, "window.loadToken").await;
    let history =
        send_cdp_command(&mut popup, 31, "Page.getNavigationHistory", None, json!({})).await;
    let before_reload_len = response_by_id(&history, 31)["result"]["entries"]
        .as_array()
        .unwrap()
        .len();
    let before_reload_history = response_by_id(&history, 31)["result"].clone();
    evaluate_window_name_probe(&mut opener, 32, "popup.location.reload(); 'accepted'").await;
    recv_until_match(&mut popup, |message| {
        message["method"] == "Page.loadEventFired"
    })
    .await;
    assert_eq!(
        evaluate_window_name_probe(&mut popup, 32, "location.href").await,
        format!("{base}/after-fragment#reload")
    );
    assert_ne!(
        evaluate_window_name_probe(&mut popup, 33, "window.loadToken").await,
        before_reload
    );
    let history =
        send_cdp_command(&mut popup, 34, "Page.getNavigationHistory", None, json!({})).await;
    assert_eq!(
        response_by_id(&history, 34)["result"]["entries"]
            .as_array()
            .unwrap()
            .len(),
        before_reload_len
    );
    assert_eq!(
        response_by_id(&history, 34)["result"],
        before_reload_history
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn page_agent_host_and_tab_host_survive_document_navigation() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let (mut page, _) = connect_async(format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"))
        .await
        .expect("connect default Page websocket");
    let mut tab = connect_discovered_tab(addr, DEFAULT_TAB_TARGET_ID).await;

    let discover = send_cdp_command(
        &mut browser,
        1,
        "Target.setDiscoverTargets",
        None,
        json!({ "discover": true, "filter": [{}] }),
    )
    .await;
    assert_eq!(response_by_id(&discover, 1)["result"], json!({}));

    let page_before = send_cdp_command(&mut page, 1, "Target.getTargetInfo", None, json!({})).await;
    let tab_before = send_cdp_command(&mut tab, 1, "Target.getTargetInfo", None, json!({})).await;
    assert_eq!(
        response_by_id(&page_before, 1)["result"]["targetInfo"]["targetId"],
        json!(DEFAULT_TARGET_ID)
    );
    assert_eq!(
        response_by_id(&tab_before, 1)["result"]["targetInfo"]["targetId"],
        json!(DEFAULT_TAB_TARGET_ID)
    );

    let destination = "data:text/html,<title>Stable Navigation Host</title>";
    let destination_title = "Stable Navigation Host";
    let navigation = send_cdp_command(
        &mut page,
        2,
        "Page.navigate",
        None,
        json!({ "url": destination }),
    )
    .await;
    assert_eq!(
        response_by_id(&navigation, 2)["result"]["frameId"],
        json!(DEFAULT_TARGET_ID),
        "the stable Page AgentHost id is also the main Frame id"
    );
    let title = send_cdp_command(
        &mut page,
        3,
        "Runtime.evaluate",
        None,
        json!({ "expression": "document.title", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&title, 3)["result"]["result"]["value"],
        json!(destination_title)
    );

    let mut target_events = recv_until_match(&mut browser, |message| {
        message["method"] == json!("Target.targetInfoChanged")
            && message["params"]["targetInfo"]["targetId"] == json!(DEFAULT_TARGET_ID)
            && message["params"]["targetInfo"]["url"] == json!(destination)
    })
    .await;
    target_events
        .extend(send_cdp_command(&mut browser, 2, "Browser.getVersion", None, json!({})).await);
    target_events.extend(recv_cdp_messages_for(&mut browser, Duration::from_millis(100)).await);
    // The Tab frontend attaches on a separate socket, so its about:blank
    // attached-state delta may reach this discovery owner after navigation
    // starts. Only a Tab update carrying this document's metadata would mean
    // that the Page navigation was incorrectly mirrored onto the Tab host.
    let mirrored_tab_navigation = target_events.iter().find(|message| {
        message["method"] == json!("Target.targetInfoChanged")
            && message["params"]["targetInfo"]["targetId"] == json!(DEFAULT_TAB_TARGET_ID)
            && (message["params"]["targetInfo"]["url"] == json!(destination)
                || message["params"]["targetInfo"]["title"] == json!(destination_title))
    });
    assert!(
        mirrored_tab_navigation.is_none(),
        "document navigation must update the Page target without mirroring a Tab event: {target_events:#?}"
    );

    let descriptors = timeout(Duration::from_secs(5), async {
        loop {
            let descriptors = fetch_server_json(addr, "/json/list?for_tab").await;
            if descriptors.as_array().is_some_and(|targets| {
                targets.iter().any(|target| {
                    target["id"] == json!(DEFAULT_TAB_TARGET_ID)
                        && target["url"] == json!(destination)
                        && target["title"] == json!(destination_title)
                })
            }) {
                break descriptors;
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .expect("Tab discovery metadata should follow its primary Page");
    assert!(descriptors.as_array().is_some_and(|targets| {
        targets.iter().any(|target| {
            target["id"] == json!(DEFAULT_TARGET_ID)
                && target["type"] == json!("page")
                && target["url"] == json!(destination)
        })
    }));

    let frame_tree = send_cdp_command(&mut page, 4, "Page.getFrameTree", None, json!({})).await;
    assert_eq!(
        response_by_id(&frame_tree, 4)["result"]["frameTree"]["frame"]["id"],
        json!(DEFAULT_TARGET_ID)
    );
    let page_after = send_cdp_command(&mut page, 5, "Target.getTargetInfo", None, json!({})).await;
    let tab_after = send_cdp_command(&mut tab, 2, "Target.getTargetInfo", None, json!({})).await;
    assert_eq!(
        response_by_id(&page_after, 5)["result"]["targetInfo"]["targetId"],
        json!(DEFAULT_TARGET_ID)
    );
    assert_eq!(
        response_by_id(&tab_after, 2)["result"]["targetInfo"]["targetId"],
        json!(DEFAULT_TAB_TARGET_ID)
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn tab_websocket_stays_bound_to_its_page_when_a_popup_becomes_active() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut opener, _) = connect_async(format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"))
        .await
        .expect("connect default page websocket");
    let opener_tab_websocket_url = discovered_tab_websocket_url(addr, DEFAULT_TAB_TARGET_ID).await;
    let mut opener_tab = connect_async(&opener_tab_websocket_url)
        .await
        .expect("connect opener tab websocket")
        .0;
    let tab_owner_info = send_cdp_command(
        &mut opener_tab,
        9001,
        "Target.getTargetInfo",
        None,
        json!({}),
    )
    .await;
    assert_eq!(
        response_by_id(&tab_owner_info, 9001)["result"]["targetInfo"]["targetId"],
        json!(DEFAULT_TAB_TARGET_ID)
    );
    assert_eq!(
        response_by_id(&tab_owner_info, 9001)["result"]["targetInfo"]["type"],
        json!("tab")
    );
    let tab_page_command =
        send_cdp_command(&mut opener_tab, 9002, "Page.getFrameTree", None, json!({})).await;
    assert_eq!(
        response_by_id(&tab_page_command, 9002)["error"],
        json!({
            "code": -32601,
            "message": "'Page.getFrameTree' wasn't found"
        }),
        "the Tab AgentHost must expose its Page through Target auto-attach"
    );
    let opener_page_session = enable_tab_page(&mut opener_tab, 1, DEFAULT_TARGET_ID).await;
    let popup_url = "data:text/html,%3Ctitle%3EStable%20Popup%3C/title%3E";
    let popup_final_url = "data:text/html,<title>Stable Popup</title>";
    let opener_url = format!(
        "data:text/html,<title>Stable Opener</title>\
         <a id='popup' href='{popup_url}' \
         target='_blank' style='display:block;width:200px;height:100px'>open</a>"
    );

    let navigation = send_cdp_command(
        &mut opener,
        1,
        "Page.navigate",
        None,
        json!({ "url": &opener_url }),
    )
    .await;
    assert!(response_by_id(&navigation, 1).get("result").is_some());
    assert!(
        response_by_id(
            &send_cdp_command(&mut opener, 2, "Page.enable", None, json!({})).await,
            2,
        )
        .get("result")
        .is_some()
    );
    assert!(
        response_by_id(
            &send_cdp_command(
                &mut opener,
                3,
                "Target.setDiscoverTargets",
                None,
                json!({ "discover": true }),
            )
            .await,
            3,
        )
        .get("result")
        .is_some()
    );
    let screencast_started =
        send_cdp_command(&mut opener, 4, "Page.startScreencast", None, json!({})).await;
    assert_eq!(response_by_id(&screencast_started, 4)["result"], json!({}));
    assert!(
        screencast_started
            .iter()
            .any(|message| is_screencast_visibility(message, true))
    );

    let opener_link = send_cdp_command(
        &mut opener_tab,
        3,
        "Runtime.evaluate",
        Some(&opener_page_session),
        json!({
            "expression": "(() => { const link = document.getElementById('popup'); const rect = link?.getBoundingClientRect(); return { href: location.href, link: link?.href, x: rect?.x, y: rect?.y, width: rect?.width, height: rect?.height, hit: document.elementFromPoint(20, 20)?.id }; })()",
            "returnByValue": true
        }),
    )
    .await;
    assert_eq!(
        response_by_id(&opener_link, 3)["result"]["result"]["value"]["link"],
        json!(popup_final_url)
    );

    dispatch_primary_click(&mut opener_tab, 5, Some(&opener_page_session), 20, 20).await;
    let mut activation_messages = recv_until_match(&mut opener, |message| {
        is_target_created_for_url(message, popup_final_url)
            || is_screencast_visibility(message, false)
    })
    .await;
    let mut saw_popup_created = activation_messages
        .iter()
        .any(|message| is_target_created_for_url(message, popup_final_url));
    let mut saw_opener_hidden = activation_messages
        .iter()
        .any(|message| is_screencast_visibility(message, false));
    if !saw_popup_created || !saw_opener_hidden {
        activation_messages.extend(
            recv_until_match(&mut opener, |message| {
                saw_popup_created |= is_target_created_for_url(message, popup_final_url);
                saw_opener_hidden |= is_screencast_visibility(message, false);
                saw_popup_created && saw_opener_hidden
            })
            .await,
        );
    }
    let popup_created_index = activation_messages
        .iter()
        .position(|message| is_target_created_for_url(message, popup_final_url))
        .expect("foreground click should create the popup target");
    let opener_hidden_index = activation_messages
        .iter()
        .position(|message| is_screencast_visibility(message, false))
        .expect("foreground click should hide the opener screencast");
    assert!(
        popup_created_index < opener_hidden_index,
        "Chromium reports popup creation before the opener becomes inactive: {activation_messages:#?}"
    );
    let popup_target_id = activation_messages
        .iter()
        .find(|message| is_target_created_for_url(message, popup_final_url))
        .and_then(|message| message["params"]["targetInfo"]["targetId"].as_str())
        .expect("foreground popup target id")
        .to_owned();

    let targets = wait_for_target_list(
        addr,
        "foreground popup should become the first browser surface",
        |targets| {
            targets.len() == 2
                && targets[0]["id"] != json!(DEFAULT_TARGET_ID)
                && targets[0]["title"] == json!("Stable Popup")
                && targets[1]["title"] == json!("Stable Opener")
        },
    )
    .await;
    assert_eq!(targets[0]["id"], json!(&popup_target_id));

    // A tab endpoint is a durable DevToolsAgentHost. Bringing another tab to
    // the foreground must not detach its child Page session or retarget the
    // socket to the new foreground Page.
    let opener_after_popup = send_cdp_command(
        &mut opener_tab,
        9,
        "Runtime.evaluate",
        Some(&opener_page_session),
        json!({
            "expression": "location.href",
            "returnByValue": true
        }),
    )
    .await;
    assert_eq!(
        response_by_id(&opener_after_popup, 9)["result"]["result"]["value"],
        json!(&opener_url)
    );
    assert!(
        opener_after_popup.iter().all(|message| {
            let detached_from_opener = message["method"] == json!("Target.detachedFromTarget")
                && message["params"]["sessionId"] == json!(opener_page_session);
            let attached_to_popup = message["method"] == json!("Target.attachedToTarget")
                && message["params"]["targetInfo"]["targetId"] == json!(popup_target_id);
            !(detached_from_opener || attached_to_popup)
        }),
        "the opener tab socket migrated to the foreground popup: {opener_after_popup:#?}"
    );
    assert_eq!(targets[0]["title"], json!("Stable Popup"));
    assert_eq!(targets[1]["id"], json!(DEFAULT_TARGET_ID));
    assert_eq!(targets[1]["title"], json!("Stable Opener"));
    assert_eq!(targets[1]["url"], json!(&opener_url));

    let tab_targets = fetch_server_json(addr, "/json/list?for_tab").await;
    let tab_targets = tab_targets.as_array().expect("tab target list");
    let opener_tab_descriptor = tab_targets
        .iter()
        .find(|target| target["id"] == json!(DEFAULT_TAB_TARGET_ID))
        .expect("stable opener tab descriptor");
    assert_eq!(opener_tab_descriptor["title"], json!("Stable Opener"));
    assert_eq!(opener_tab_descriptor["url"], json!(&opener_url));
    let popup_tab_target_id = tab_targets
        .iter()
        .find(|target| target["type"] == json!("tab") && target["title"] == json!("Stable Popup"))
        .and_then(|target| target["id"].as_str())
        .expect("stable popup tab target id")
        .to_owned();
    assert_ne!(popup_tab_target_id, DEFAULT_TAB_TARGET_ID);

    // This URL was discovered before popup activation. It still identifies
    // the opener tab after the browser context's active page has changed.
    let mut late_opener_tab = connect_async(&opener_tab_websocket_url)
        .await
        .expect("connect opener tab from stale discovery descriptor")
        .0;
    let late_opener_page_session =
        enable_tab_page(&mut late_opener_tab, 1, DEFAULT_TARGET_ID).await;
    let late_opener_location = send_cdp_command(
        &mut late_opener_tab,
        3,
        "Runtime.evaluate",
        Some(&late_opener_page_session),
        json!({ "expression": "location.href", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&late_opener_location, 3)["result"]["result"]["value"],
        json!(&opener_url)
    );

    let mut popup_tab = connect_discovered_tab(addr, &popup_tab_target_id).await;
    let popup_page_session = enable_tab_page(&mut popup_tab, 1, &popup_target_id).await;
    let popup_location = send_cdp_command(
        &mut popup_tab,
        3,
        "Runtime.evaluate",
        Some(&popup_page_session),
        json!({ "expression": "location.href", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&popup_location, 3)["result"]["result"]["value"],
        json!(popup_final_url)
    );

    let opener_surface = evaluate_page_surface(&mut opener, 7).await;
    assert_eq!(opener_surface["href"], json!(&opener_url));
    assert_page_surface_active(&opener_surface, false);
    let parked_opener_screencast =
        send_cdp_command(&mut opener, 8, "Page.startScreencast", None, json!({})).await;
    assert_eq!(
        response_by_id(&parked_opener_screencast, 8)["result"],
        json!({})
    );
    assert!(
        parked_opener_screencast
            .iter()
            .any(|message| is_screencast_visibility(message, false))
    );

    let mut popup = connect_dynamic_page(addr, &popup_target_id).await;
    let popup_surface = evaluate_page_surface(&mut popup, 9).await;
    assert_page_surface_active(&popup_surface, true);
    let popup_screencast_started =
        send_cdp_command(&mut popup, 10, "Page.startScreencast", None, json!({})).await;
    assert_eq!(
        response_by_id(&popup_screencast_started, 10)["result"],
        json!({})
    );
    assert!(
        popup_screencast_started
            .iter()
            .any(|message| is_screencast_visibility(message, true))
    );

    let (activate_status, _) = fetch_server_response(
        addr,
        "GET",
        &format!("/json/activate/{DEFAULT_TAB_TARGET_ID}"),
    )
    .await;
    assert_eq!(activate_status, 200);
    wait_for_target_list(
        addr,
        "activating the opener should restore it as the browser surface",
        |targets| {
            targets
                .first()
                .is_some_and(|target| target["id"] == json!(DEFAULT_TARGET_ID))
        },
    )
    .await;

    expect_screencast_visibility(&mut opener, true).await;
    expect_screencast_visibility(&mut popup, false).await;

    let restored_opener = send_cdp_command(
        &mut opener_tab,
        10,
        "Runtime.evaluate",
        Some(&opener_page_session),
        json!({
            "expression": "location.href",
            "returnByValue": true
        }),
    )
    .await;
    assert_eq!(
        response_by_id(&restored_opener, 10)["result"]["result"]["value"],
        json!(&opener_url)
    );
    let background_popup = send_cdp_command(
        &mut popup_tab,
        4,
        "Runtime.evaluate",
        Some(&popup_page_session),
        json!({ "expression": "location.href", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&background_popup, 4)["result"]["result"]["value"],
        json!(popup_final_url)
    );

    let restored_opener_surface = evaluate_page_surface(&mut opener, 11).await;
    assert_page_surface_active(&restored_opener_surface, true);
    let background_popup_surface = evaluate_page_surface(&mut popup, 12).await;
    assert_page_surface_active(&background_popup_surface, false);

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_parser_script_navigation_delivers_load_event() {
    async fn page() -> impl IntoResponse {
        (
            [(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
            concat!(
                "<!doctype html><html><head>",
                "<meta charset=\"utf-8\"><title>CDP Core Fixture</title>",
                "<script src=\"/app.js\"></script></head><body>",
                "<h1 id=\"title\">CDP Core Fixture</h1>",
                "<script>window.__fixtureReady = true;</script>",
                "</body></html>"
            ),
        )
    }

    async fn app_script() -> impl IntoResponse {
        (
            [(
                axum::http::header::CONTENT_TYPE.as_str(),
                "application/javascript",
            )],
            "window.__scriptLoaded = true;",
        )
    }

    let fixture_listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind fixture listener");
    let fixture_addr = fixture_listener.local_addr().expect("fixture addr");
    let fixture_server = tokio::spawn(async move {
        axum::serve(
            fixture_listener,
            Router::new()
                .route("/", get(page))
                .route("/app.js", get(app_script)),
        )
        .await
    });
    let fixture_url = format!("http://{fixture_addr}/");

    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 100).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;

    let enabled = send_cdp_command(&mut page, 1, "Page.enable", None, json!({})).await;
    assert_eq!(response_by_id(&enabled, 1)["result"], json!({}));

    page.send(WsMessage::Text(
        json!({
            "id": 2_u64,
            "method": "Page.navigate",
            "params": { "url": "about:blank" }
        })
        .to_string()
        .into(),
    ))
    .await
    .expect("send first direct page navigation");

    let mut saw_first_response = false;
    let mut saw_first_load = false;
    let first_messages = recv_until_match(&mut page, |message| {
        saw_first_response |= message["id"] == json!(2_u64);
        saw_first_load |= message["method"] == json!("Page.loadEventFired");
        saw_first_response && saw_first_load
    })
    .await;
    assert!(
        response_by_id(&first_messages, 2).get("error").is_none(),
        "first direct page navigation failed: {first_messages:#?}"
    );

    let disabled = send_cdp_command(&mut page, 3, "Page.disable", None, json!({})).await;
    assert_eq!(response_by_id(&disabled, 3)["result"], json!({}));
    let reenabled = send_cdp_command(&mut page, 4, "Page.enable", None, json!({})).await;
    assert_eq!(response_by_id(&reenabled, 4)["result"], json!({}));

    page.send(WsMessage::Text(
        json!({
            "id": 5_u64,
            "method": "Page.navigate",
            "params": { "url": fixture_url }
        })
        .to_string()
        .into(),
    ))
    .await
    .expect("send direct page navigation");

    let mut saw_second_response = false;
    let mut saw_second_load = false;
    let second_messages = recv_until_match(&mut page, |message| {
        saw_second_response |= message["id"] == json!(5_u64);
        saw_second_load |= message["method"] == json!("Page.loadEventFired");
        saw_second_response && saw_second_load
    })
    .await;
    assert!(
        second_messages
            .iter()
            .any(|message| message["method"] == json!("Page.loadEventFired")),
        "second direct page navigation did not receive loadEventFired: {second_messages:#?}"
    );
    assert!(
        response_by_id(&second_messages, 5).get("error").is_none(),
        "second direct page navigation failed: {second_messages:#?}"
    );

    let _ = page.close(None).await;
    let _ = browser.close(None).await;
    abort_test_cdp_server(server).await;
    fixture_server.abort();
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn http_cdp_target_management_uses_live_agent_host_directory() {
    let (addr, server) = spawn_test_protocol_server().await;

    let (new_status, new_body) =
        fetch_server_response(addr, "PUT", "/json/new?about%3Ablank").await;
    assert_eq!(new_status, 200);
    let created: serde_json::Value =
        serde_json::from_slice(&new_body).expect("created target descriptor");
    let target_id = created["id"]
        .as_str()
        .expect("created target id")
        .to_owned();
    assert_ne!(target_id, DEFAULT_TARGET_ID);
    assert_eq!(created["url"], json!("about:blank"));

    let listed = fetch_server_json(addr, "/json/list").await;
    assert!(
        listed
            .as_array()
            .expect("target list")
            .iter()
            .any(|target| target["id"] == json!(target_id))
    );

    let mut page = connect_dynamic_page(addr, &target_id).await;
    let frame_tree = send_cdp_command(&mut page, 1, "Page.getFrameTree", None, json!({})).await;
    assert_eq!(
        response_by_id(&frame_tree, 1)["result"]["frameTree"]["frame"]["id"],
        json!(target_id)
    );

    let (activate_status, activate_body) =
        fetch_server_response(addr, "GET", &format!("/json/activate/{target_id}")).await;
    assert_eq!(activate_status, 200);
    assert_eq!(
        std::str::from_utf8(&activate_body).expect("activate response"),
        "Target activated"
    );

    let (close_status, close_body) =
        fetch_server_response(addr, "GET", &format!("/json/close/{target_id}")).await;
    assert_eq!(close_status, 200);
    assert_eq!(
        std::str::from_utf8(&close_body).expect("close response"),
        "Target is closing"
    );
    wait_for_websocket_close(&mut page, "HTTP-closed target page").await;

    let listed = fetch_server_json(addr, "/json/list").await;
    assert!(
        listed
            .as_array()
            .expect("target list")
            .iter()
            .all(|target| target["id"] != json!(target_id))
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn http_cdp_target_management_preserves_browser_discovery_events() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let discover = send_cdp_command(
        &mut browser,
        1,
        "Target.setDiscoverTargets",
        None,
        json!({
            "discover": true,
            "filter": [{ "type": "page" }]
        }),
    )
    .await;
    assert_eq!(response_by_id(&discover, 1)["result"], json!({}));

    let (new_status, new_body) =
        fetch_server_response(addr, "PUT", "/json/new?about%3Ablank").await;
    assert_eq!(new_status, 200);
    let created: serde_json::Value =
        serde_json::from_slice(&new_body).expect("created target descriptor");
    let target_id = created["id"]
        .as_str()
        .expect("created target id")
        .to_owned();

    let created_events = recv_until_match(&mut browser, |message| {
        message["method"] == json!("Target.targetCreated")
            && message["params"]["targetInfo"]["targetId"] == json!(target_id)
    })
    .await;
    assert!(
        created_events.iter().any(|message| {
            message["method"] == json!("Target.targetCreated")
                && message["params"]["targetInfo"]["targetId"] == json!(target_id)
        }),
        "HTTP target creation did not reach the existing browser frontend: {created_events:#?}"
    );

    let (close_status, _) =
        fetch_server_response(addr, "GET", &format!("/json/close/{target_id}")).await;
    assert_eq!(close_status, 200);
    let destroyed_events = recv_until_match(&mut browser, |message| {
        message["method"] == json!("Target.targetDestroyed")
            && message["params"]["targetId"] == json!(target_id)
    })
    .await;
    assert!(
        destroyed_events.iter().any(|message| {
            message["method"] == json!("Target.targetDestroyed")
                && message["params"]["targetId"] == json!(target_id)
        }),
        "HTTP target destruction did not reach the existing browser frontend: {destroyed_events:#?}"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_child_session_routes_to_child_target() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let first_target_id = create_dynamic_target(&mut browser, 1).await;
    let second_target_id = create_dynamic_target(&mut browser, 2).await;
    let mut first_page = connect_dynamic_page(addr, &first_target_id).await;
    let mut second_page = connect_dynamic_page(addr, &second_target_id).await;

    let first_marker = send_cdp_command(
        &mut first_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_child_route = 'first-target'" }),
    )
    .await;
    assert_eq!(
        response_by_id(&first_marker, 1)["result"]["result"]["value"],
        json!("first-target")
    );
    let second_marker = send_cdp_command(
        &mut second_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_child_route = 'second-target'" }),
    )
    .await;
    assert_eq!(
        response_by_id(&second_marker, 1)["result"]["result"]["value"],
        json!("second-target")
    );

    let attach = send_cdp_command(
        &mut first_page,
        2,
        "Target.attachToTarget",
        None,
        json!({ "targetId": second_target_id, "flatten": true }),
    )
    .await;
    let child_session_id = response_by_id(&attach, 2)["result"]["sessionId"]
        .as_str()
        .expect("direct page child session")
        .to_owned();

    let child_read = send_cdp_command(
        &mut first_page,
        3,
        "Runtime.evaluate",
        Some(&child_session_id),
        json!({ "expression": "globalThis.__moli_child_route" }),
    )
    .await;
    let child_response = response_by_id(&child_read, 3);
    assert_eq!(
        child_response["result"]["result"]["value"],
        json!("second-target"),
        "child session command was executed against the direct page base target"
    );
    assert_eq!(
        child_response["sessionId"],
        json!(child_session_id),
        "flattened child session id was removed from the direct page wire response"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_rejects_unknown_child_session() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;

    let invalid = send_cdp_command(
        &mut page,
        1,
        "Runtime.evaluate",
        Some("SID-does-not-exist"),
        json!({ "expression": "globalThis.__moli_unknown_child_ran = true" }),
    )
    .await;
    let invalid_response = response_by_id(&invalid, 1);
    assert_eq!(invalid_response["error"]["code"], json!(-32001));
    assert_eq!(
        invalid_response["error"]["message"],
        json!("Unknown sessionId")
    );

    let probe = send_cdp_command(
        &mut page,
        2,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_unknown_child_ran" }),
    )
    .await;
    assert_eq!(
        response_by_id(&probe, 2)["result"]["result"]["type"],
        json!("undefined"),
        "unknown child session command executed against the base target"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_detach_reconnect_and_target_close_follow_host_lifecycle() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut first_page = connect_dynamic_page(addr, &target_id).await;
    let mut second_page = connect_dynamic_page(addr, &target_id).await;

    let first_set = send_cdp_command(
        &mut first_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_reconnect_state = 41" }),
    )
    .await;
    assert_eq!(
        response_by_id(&first_set, 1)["result"]["result"]["value"],
        json!(41)
    );
    let second_read = send_cdp_command(
        &mut second_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_reconnect_state + 1" }),
    )
    .await;
    assert_eq!(
        response_by_id(&second_read, 1)["result"]["result"]["value"],
        json!(42),
        "two direct page clients did not get independent sessions on the same target"
    );

    first_page
        .close(None)
        .await
        .expect("close first page socket");
    let mut reconnected_page = connect_dynamic_page(addr, &target_id).await;
    let reconnected_read = send_cdp_command(
        &mut reconnected_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_reconnect_state" }),
    )
    .await;
    assert_eq!(
        response_by_id(&reconnected_read, 1)["result"]["result"]["value"],
        json!(41),
        "page frontend disconnect destroyed or replaced the target runtime"
    );

    let close = send_cdp_command(
        &mut browser,
        2,
        "Target.closeTarget",
        None,
        json!({ "targetId": target_id }),
    )
    .await;
    assert_eq!(response_by_id(&close, 2)["result"]["success"], json!(true));
    assert!(
        close
            .iter()
            .all(|message| message["method"] != json!("Target.detachedFromTarget")),
        "browser frontend received a private direct-page detach event: {close:#?}"
    );
    if let Ok(message) =
        tokio::time::timeout(Duration::from_millis(100), recv_ws_json(&mut browser)).await
    {
        panic!("browser frontend received private direct-page output: {message:#?}");
    }

    wait_for_websocket_close(&mut reconnected_page, "closed target page").await;
    assert_eq!(
        rejected_websocket_status(format!("ws://{addr}/devtools/page/{target_id}")).await,
        404
    );
    let target_list = fetch_server_json(addr, "/json/list").await;
    assert!(
        target_list
            .as_array()
            .expect("target list array")
            .iter()
            .all(|target| target["id"] != json!(target_id)),
        "closed target remained in /json/list: {target_list:#?}"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_supports_concurrent_browser_frontends_with_isolated_sessions() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut first_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect first browser websocket");
    let (mut second_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect second browser websocket");

    for browser in [&mut first_browser, &mut second_browser] {
        browser
            .send(WsMessage::Text(
                json!({ "id": 1, "method": "Browser.getVersion", "params": {} })
                    .to_string()
                    .into(),
            ))
            .await
            .expect("send colliding browser command id");
    }
    let first_probe = recv_until_id(&mut first_browser, 1).await;
    let second_probe = recv_until_id(&mut second_browser, 1).await;
    assert!(
        response_by_id(&first_probe, 1)["result"]["product"]
            .as_str()
            .is_some(),
        "first browser frontend did not respond"
    );
    assert!(
        response_by_id(&second_probe, 1)["result"]["product"]
            .as_str()
            .is_some(),
        "second browser frontend did not respond"
    );
    assert!(
        first_probe
            .iter()
            .chain(&second_probe)
            .all(|message| message.get("sessionId").is_none()),
        "a hidden browser base session leaked onto the public wire"
    );

    let discover = send_cdp_command(
        &mut first_browser,
        2,
        "Target.setDiscoverTargets",
        None,
        json!({ "discover": true, "filter": [{ "type": "page" }] }),
    )
    .await;
    assert_eq!(response_by_id(&discover, 2)["result"], json!({}));
    let create = send_cdp_command(
        &mut second_browser,
        2,
        "Target.createTarget",
        None,
        json!({ "url": "about:blank" }),
    )
    .await;
    let target_id = response_by_id(&create, 2)["result"]["targetId"]
        .as_str()
        .expect("created target id")
        .to_owned();
    assert!(
        create.iter().all(|message| {
            message["method"] != json!("Target.targetCreated")
                || message["params"]["targetInfo"]["targetId"] != json!(target_id)
        }),
        "second frontend inherited first frontend's discovery state: {create:#?}"
    );
    let discovered = recv_until_match(&mut first_browser, |message| {
        message["method"] == json!("Target.targetCreated")
            && message["params"]["targetInfo"]["targetId"] == json!(target_id)
    })
    .await;
    assert!(
        discovered
            .last()
            .is_some_and(|message| message.get("sessionId").is_none()),
        "discovery event leaked the first browser's hidden base session"
    );

    let first_attach = send_cdp_command(
        &mut first_browser,
        3,
        "Target.attachToTarget",
        None,
        json!({ "targetId": target_id, "flatten": true }),
    )
    .await;
    let first_session_id = response_by_id(&first_attach, 3)["result"]["sessionId"]
        .as_str()
        .expect("first target session id")
        .to_owned();
    let second_attach = send_cdp_command(
        &mut second_browser,
        3,
        "Target.attachToTarget",
        None,
        json!({ "targetId": target_id, "flatten": true }),
    )
    .await;
    let second_session_id = response_by_id(&second_attach, 3)["result"]["sessionId"]
        .as_str()
        .expect("second target session id")
        .to_owned();
    assert_ne!(first_session_id, second_session_id);

    let first_write = send_cdp_command(
        &mut first_browser,
        4,
        "Runtime.evaluate",
        Some(&first_session_id),
        json!({ "expression": "globalThis.__moli_multi_browser = 41" }),
    )
    .await;
    assert_eq!(
        response_by_id(&first_write, 4)["result"]["result"]["value"],
        json!(41)
    );
    let second_read = send_cdp_command(
        &mut second_browser,
        4,
        "Runtime.evaluate",
        Some(&second_session_id),
        json!({ "expression": "globalThis.__moli_multi_browser" }),
    )
    .await;
    assert_eq!(
        response_by_id(&second_read, 4)["result"]["result"]["value"],
        json!(41),
        "browser frontends did not share the target runtime"
    );

    let foreign_flat_session = send_cdp_command(
        &mut second_browser,
        5,
        "Runtime.evaluate",
        Some(&first_session_id),
        json!({ "expression": "1" }),
    )
    .await;
    assert_eq!(
        response_by_id(&foreign_flat_session, 5)["error"]["code"],
        json!(-32001)
    );
    let foreign_legacy_session = send_cdp_command(
        &mut second_browser,
        6,
        "Target.detachFromTarget",
        None,
        json!({ "sessionId": first_session_id }),
    )
    .await;
    assert_eq!(
        response_by_id(&foreign_legacy_session, 6)["error"]["code"],
        json!(-32602)
    );

    first_browser
        .close(None)
        .await
        .expect("close first browser websocket");
    wait_for_websocket_close(&mut first_browser, "first concurrent browser").await;
    let surviving_read = send_cdp_command(
        &mut second_browser,
        7,
        "Runtime.evaluate",
        Some(&second_session_id),
        json!({ "expression": "globalThis.__moli_multi_browser + 1" }),
    )
    .await;
    assert_eq!(
        response_by_id(&surviving_read, 7)["result"]["result"]["value"],
        json!(42),
        "disconnecting one browser detached another browser's target session"
    );

    let (mut third_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect third browser while second remains connected");
    let third_probe =
        send_cdp_command(&mut third_browser, 1, "Browser.getVersion", None, json!({})).await;
    assert!(
        response_by_id(&third_probe, 1)["result"]["product"]
            .as_str()
            .is_some(),
        "replacement browser could not connect alongside surviving browser"
    );
    let third_attach = send_cdp_command(
        &mut third_browser,
        2,
        "Target.attachToTarget",
        None,
        json!({ "targetId": target_id, "flatten": true }),
    )
    .await;
    let third_session_id = response_by_id(&third_attach, 2)["result"]["sessionId"]
        .as_str()
        .expect("third target session id")
        .to_owned();
    let third_read = send_cdp_command(
        &mut third_browser,
        3,
        "Runtime.evaluate",
        Some(&third_session_id),
        json!({ "expression": "globalThis.__moli_multi_browser" }),
    )
    .await;
    assert_eq!(
        response_by_id(&third_read, 3)["result"]["result"]["value"],
        json!(41)
    );

    let close = send_cdp_command(
        &mut third_browser,
        4,
        "Target.closeTarget",
        None,
        json!({ "targetId": target_id }),
    )
    .await;
    assert_eq!(response_by_id(&close, 4)["result"]["success"], json!(true));
    let second_detached = recv_until_match(&mut second_browser, |message| {
        message["method"] == json!("Target.detachedFromTarget")
            && message["params"]["sessionId"] == json!(second_session_id)
    })
    .await;
    assert!(
        second_detached
            .last()
            .is_some_and(|message| message.get("sessionId").is_none()),
        "target-close detach leaked the second browser's hidden base session"
    );
    let stale_session = send_cdp_command(
        &mut second_browser,
        8,
        "Runtime.evaluate",
        Some(&second_session_id),
        json!({ "expression": "1" }),
    )
    .await;
    assert_eq!(
        response_by_id(&stale_session, 8)["error"]["code"],
        json!(-32001),
        "closed target session remained routable"
    );
    let final_second_probe = send_cdp_command(
        &mut second_browser,
        9,
        "Browser.getVersion",
        None,
        json!({}),
    )
    .await;
    assert!(
        response_by_id(&final_second_probe, 9)["result"]["product"]
            .as_str()
            .is_some(),
        "closing a shared target disrupted the surviving browser frontend"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_browser_reconnect_resets_discovery_state() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut discovering_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect discovering browser websocket");

    let discover = send_cdp_command(
        &mut discovering_browser,
        1,
        "Target.setDiscoverTargets",
        None,
        json!({
            "discover": true,
            "filter": [{ "type": "page" }]
        }),
    )
    .await;
    assert_eq!(response_by_id(&discover, 1)["result"], json!({}));

    discovering_browser
        .close(None)
        .await
        .expect("close discovering browser websocket");
    wait_for_websocket_close(&mut discovering_browser, "discovering browser").await;

    let (mut replacement_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect replacement browser websocket");
    let create = send_cdp_command(
        &mut replacement_browser,
        1,
        "Target.createTarget",
        None,
        json!({ "url": "about:blank" }),
    )
    .await;
    let target_id = response_by_id(&create, 1)["result"]["targetId"]
        .as_str()
        .expect("created target id")
        .to_owned();
    assert!(
        create.iter().all(|message| {
            message["method"] != json!("Target.targetCreated")
                || message["params"]["targetInfo"]["targetId"] != json!(target_id)
        }),
        "target discovery state leaked into a replacement browser frontend: {create:#?}"
    );

    let replacement_probe = send_cdp_command(
        &mut replacement_browser,
        2,
        "Target.getTargets",
        None,
        json!({}),
    )
    .await;
    assert!(
        replacement_probe.iter().all(|message| {
            message["method"] != json!("Target.targetCreated")
                || message["params"]["targetInfo"]["targetId"] != json!(target_id)
        }),
        "late discovery output leaked into the replacement browser: {replacement_probe:#?}"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_browser_reconnect_can_control_existing_target() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut first_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect first browser websocket");
    let target_id = create_dynamic_target(&mut first_browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;
    let marker = send_cdp_command(
        &mut page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_browser_reconnect = 73" }),
    )
    .await;
    assert_eq!(
        response_by_id(&marker, 1)["result"]["result"]["value"],
        json!(73)
    );

    first_browser
        .close(None)
        .await
        .expect("close first browser websocket");
    wait_for_websocket_close(&mut first_browser, "first browser frontend").await;

    let (mut second_browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect replacement browser websocket");
    let targets =
        send_cdp_command(&mut second_browser, 1, "Target.getTargets", None, json!({})).await;
    assert!(
        response_by_id(&targets, 1)["result"]["targetInfos"]
            .as_array()
            .expect("replacement browser targetInfos")
            .iter()
            .any(|target| target["targetId"] == json!(target_id)),
        "replacement browser did not discover the existing target"
    );

    let attach = send_cdp_command(
        &mut second_browser,
        2,
        "Target.attachToTarget",
        None,
        json!({ "targetId": target_id, "flatten": true }),
    )
    .await;
    let session_id = response_by_id(&attach, 2)["result"]["sessionId"]
        .as_str()
        .expect("replacement browser target session")
        .to_owned();
    let read = send_cdp_command(
        &mut second_browser,
        3,
        "Runtime.evaluate",
        Some(&session_id),
        json!({ "expression": "globalThis.__moli_browser_reconnect" }),
    )
    .await;
    assert_eq!(
        response_by_id(&read, 3)["result"]["result"]["value"],
        json!(73)
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_default_page_created_target_has_global_identity_and_route() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let browser_target_id = create_dynamic_target(&mut browser, 1).await;
    let mut browser_page = connect_dynamic_page(addr, &browser_target_id).await;
    let browser_marker = send_cdp_command(
        &mut browser_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_owner_identity = 'browser-owner'" }),
    )
    .await;
    assert_eq!(
        response_by_id(&browser_marker, 1)["result"]["result"]["value"],
        json!("browser-owner")
    );

    let (mut default_page, _) =
        connect_async(format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"))
            .await
            .expect("connect default page websocket");
    let default_page_target_id = create_dynamic_target(&mut default_page, 2).await;
    assert_ne!(
        browser_target_id, default_page_target_id,
        "all protocol-server owners must allocate target ids from one namespace"
    );

    let attach = send_cdp_command(
        &mut default_page,
        3,
        "Target.attachToTarget",
        None,
        json!({ "targetId": default_page_target_id, "flatten": true }),
    )
    .await;
    let default_page_session_id = response_by_id(&attach, 3)["result"]["sessionId"]
        .as_str()
        .expect("default page target session")
        .to_owned();
    let default_page_marker = send_cdp_command(
        &mut default_page,
        4,
        "Runtime.evaluate",
        Some(&default_page_session_id),
        json!({ "expression": "globalThis.__moli_owner_identity = 'default-page-owner'" }),
    )
    .await;
    assert_eq!(
        response_by_id(&default_page_marker, 4)["result"]["result"]["value"],
        json!("default-page-owner")
    );

    default_page
        .close(None)
        .await
        .expect("close default page frontend");
    wait_for_websocket_close(&mut default_page, "default page frontend").await;

    let mut routed_page = connect_dynamic_page(addr, &default_page_target_id).await;
    let routed_marker = send_cdp_command(
        &mut routed_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_owner_identity" }),
    )
    .await;
    assert_eq!(
        response_by_id(&routed_marker, 1)["result"]["result"]["value"],
        json!("default-page-owner"),
        "the published route did not resolve to the target that returned its id"
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_pending_runtime_command_does_not_block_later_command() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;

    page.send(WsMessage::Text(
        json!({
            "id": 1_u64,
            "method": "Runtime.evaluate",
            "params": {
                "expression": "new Promise(resolve => { globalThis.__moli_resolve_page = resolve; })",
                "awaitPromise": true,
                "returnByValue": true
            }
        })
        .to_string()
        .into(),
    ))
    .await
    .expect("send pending direct page command");
    page.send(WsMessage::Text(
        json!({
            "id": 2_u64,
            "method": "Runtime.evaluate",
            "params": {
                "expression": "globalThis.__moli_resolve_page('resolved'); 'released'",
                "returnByValue": true
            }
        })
        .to_string()
        .into(),
    ))
    .await
    .expect("send command that resolves pending direct page command");

    let mut saw_pending_response = false;
    let mut saw_release_response = false;
    let messages = recv_until_match(&mut page, |message| {
        saw_pending_response |= message["id"] == json!(1_u64);
        saw_release_response |= message["id"] == json!(2_u64);
        saw_pending_response && saw_release_response
    })
    .await;
    assert_eq!(
        response_by_id(&messages, 1)["result"]["result"]["value"],
        json!("resolved")
    );
    assert_eq!(
        response_by_id(&messages, 2)["result"]["result"]["value"],
        json!("released")
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_matches_chromium_browser_attach_access_modes() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;

    let specialized = send_cdp_command(
        &mut page,
        1,
        "Target.attachToBrowserTarget",
        None,
        json!({}),
    )
    .await;
    let specialized_response = response_by_id(&specialized, 1);
    assert_eq!(specialized_response["error"]["code"], json!(-32000));
    assert_eq!(
        specialized_response["error"]["message"],
        json!("Not allowed")
    );
    assert!(specialized_response.get("sessionId").is_none());

    let discovery = send_cdp_command(
        &mut page,
        2,
        "Target.setDiscoverTargets",
        None,
        json!({ "discover": true, "filter": [{}] }),
    )
    .await;
    let browser_target_id = discovery
        .iter()
        .find(|message| {
            message["method"] == json!("Target.targetCreated")
                && message["params"]["targetInfo"]["type"] == json!("browser")
        })
        .and_then(|message| message["params"]["targetInfo"]["targetId"].as_str())
        .expect("direct page discovery should report the browser target")
        .to_owned();

    let attach = send_cdp_command(
        &mut page,
        3,
        "Target.attachToTarget",
        None,
        json!({ "targetId": browser_target_id, "flatten": true }),
    )
    .await;
    let attach_response = response_by_id(&attach, 3);
    assert!(attach_response.get("sessionId").is_none());
    let browser_session_id = attach_response["result"]["sessionId"]
        .as_str()
        .expect("generic browser target session")
        .to_owned();
    assert!(attach.iter().any(|message| {
        message["method"] == json!("Target.attachedToTarget")
            && message.get("sessionId").is_none()
            && message["params"]["sessionId"] == json!(browser_session_id)
            && message["params"]["targetInfo"]["type"] == json!("browser")
    }));

    let version = send_cdp_command(
        &mut page,
        4,
        "Browser.getVersion",
        Some(&browser_session_id),
        json!({}),
    )
    .await;
    let version_response = response_by_id(&version, 4);
    assert_eq!(version_response["sessionId"], json!(browser_session_id));
    assert!(version_response["result"]["product"].is_string());

    page.close(None).await.expect("close page websocket");
    browser.close(None).await.expect("close browser websocket");
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_survives_browser_frontend_disconnect_until_target_close() {
    let (addr, server, owner_registry) = spawn_test_protocol_server_with_owner_registry().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;
    let initial = send_cdp_command(
        &mut page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_stage3_state = 73" }),
    )
    .await;
    assert_eq!(
        response_by_id(&initial, 1)["result"]["result"]["value"],
        json!(73)
    );
    let runtime_enabled = send_cdp_command(&mut page, 10, "Runtime.enable", None, json!({})).await;
    assert_eq!(response_by_id(&runtime_enabled, 10)["result"], json!({}));
    let binding_added = send_cdp_command(
        &mut page,
        11,
        "Runtime.addBinding",
        None,
        json!({ "name": "__moli_stage3_binding" }),
    )
    .await;
    assert_eq!(response_by_id(&binding_added, 11)["result"], json!({}));
    let browser_attach = send_cdp_command(
        &mut browser,
        2,
        "Target.attachToTarget",
        None,
        json!({ "targetId": target_id.clone(), "flatten": true }),
    )
    .await;
    assert!(
        response_by_id(&browser_attach, 2)["result"]["sessionId"]
            .as_str()
            .is_some()
    );
    assert_eq!(owner_registry.owner_count(), 1);

    browser
        .close(None)
        .await
        .expect("close browser frontend socket");
    wait_for_websocket_close(&mut browser, "client-closed browser").await;
    assert_eq!(
        owner_registry.owner_count(),
        1,
        "browser detach destroyed an owner that still had a live dynamic target"
    );
    let target_list = fetch_server_json(addr, "/json/list").await;
    assert!(
        target_list
            .as_array()
            .expect("target list array")
            .iter()
            .any(|target| target["id"] == json!(target_id)),
        "browser detach removed a live target from /json/list: {target_list:#?}"
    );

    let after_browser_close = send_cdp_command(
        &mut page,
        2,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_stage3_state + 1" }),
    )
    .await;
    assert_eq!(
        response_by_id(&after_browser_close, 2)["result"]["result"]["value"],
        json!(74)
    );
    page.send(WsMessage::Text(
        json!({
            "id": 12_u64,
            "method": "Runtime.evaluate",
            "params": {
                "expression": "__moli_stage3_binding('after-browser-close')"
            }
        })
        .to_string()
        .into(),
    ))
    .await
    .expect("invoke direct page binding after browser detach");
    let mut saw_binding_response = false;
    let mut saw_binding_event = false;
    let binding_messages = recv_until_match(&mut page, |message| {
        saw_binding_response |= message["id"] == json!(12_u64);
        saw_binding_event |= message["method"] == json!("Runtime.bindingCalled")
            && message["params"]["name"] == json!("__moli_stage3_binding")
            && message["params"]["payload"] == json!("after-browser-close");
        saw_binding_response && saw_binding_event
    })
    .await;
    assert!(
        binding_messages
            .iter()
            .any(|message| message["method"] == json!("Runtime.bindingCalled")),
        "browser detach removed the direct page frontend Runtime binding state"
    );

    page.close(None).await.expect("close first page frontend");
    let mut reconnected_page = connect_dynamic_page(addr, &target_id).await;
    let after_reconnect = send_cdp_command(
        &mut reconnected_page,
        1,
        "Runtime.evaluate",
        None,
        json!({ "expression": "globalThis.__moli_stage3_state" }),
    )
    .await;
    assert_eq!(
        response_by_id(&after_reconnect, 1)["result"]["result"]["value"],
        json!(73)
    );

    let close = send_cdp_command(
        &mut reconnected_page,
        2,
        "Target.closeTarget",
        None,
        json!({ "targetId": target_id }),
    )
    .await;
    assert_eq!(response_by_id(&close, 2)["result"]["success"], json!(true));
    wait_for_websocket_close(&mut reconnected_page, "last closed target page").await;
    assert_eq!(
        owner_registry.owner_count(),
        1,
        "the server-level CDP control plane must survive after its last dynamic target closes"
    );
    assert_eq!(
        rejected_websocket_status(format!("ws://{addr}/devtools/page/{target_id}")).await,
        404
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_owner_registry_shutdown_closes_frontends_and_joins_owner() {
    let (addr, server, owner_registry) = spawn_test_protocol_server_with_owner_registry().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let target_id = create_dynamic_target(&mut browser, 1).await;
    let mut page = connect_dynamic_page(addr, &target_id).await;
    assert_eq!(owner_registry.owner_count(), 1);

    timeout(Duration::from_secs(5), owner_registry.shutdown())
        .await
        .expect("owner registry shutdown should join all owner threads");
    assert_eq!(owner_registry.owner_count(), 0);
    wait_for_websocket_close(&mut browser, "registry-shutdown browser").await;
    wait_for_websocket_close(&mut page, "registry-shutdown page").await;
    assert_eq!(
        rejected_websocket_status(format!("ws://{addr}/devtools/page/{target_id}")).await,
        404
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_shared_owner_survives_idle_browser_reconnect() {
    let (addr, server, owner_registry) = spawn_test_protocol_server_with_owner_registry().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let attach = send_cdp_command(
        &mut browser,
        1,
        "Target.attachToTarget",
        None,
        json!({ "targetId": DEFAULT_TARGET_ID, "flatten": true }),
    )
    .await;
    let session_id = response_by_id(&attach, 1)["result"]["sessionId"]
        .as_str()
        .expect("default target session")
        .to_owned();
    let marker = send_cdp_command(
        &mut browser,
        2,
        "Runtime.evaluate",
        Some(&session_id),
        json!({ "expression": "globalThis.__moli_idle_reconnect = 29" }),
    )
    .await;
    assert_eq!(
        response_by_id(&marker, 2)["result"]["result"]["value"],
        json!(29)
    );
    assert_eq!(owner_registry.owner_count(), 1);

    browser
        .close(None)
        .await
        .expect("close browser frontend socket");
    wait_for_websocket_close(&mut browser, "detached empty browser").await;
    assert_eq!(owner_registry.owner_count(), 1);

    let (mut replacement, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("reconnect browser websocket");
    let attach = send_cdp_command(
        &mut replacement,
        1,
        "Target.attachToTarget",
        None,
        json!({ "targetId": DEFAULT_TARGET_ID, "flatten": true }),
    )
    .await;
    let replacement_session_id = response_by_id(&attach, 1)["result"]["sessionId"]
        .as_str()
        .expect("replacement default target session")
        .to_owned();
    let marker = send_cdp_command(
        &mut replacement,
        2,
        "Runtime.evaluate",
        Some(&replacement_session_id),
        json!({ "expression": "globalThis.__moli_idle_reconnect" }),
    )
    .await;
    assert_eq!(
        response_by_id(&marker, 2)["result"]["result"]["value"],
        json!(29),
        "idle browser reconnect did not reuse the server-level target control plane"
    );
    assert_eq!(owner_registry.owner_count(), 1);

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_puppeteer_reconnect_recreates_session_owned_runtime_context() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (status, body) = fetch_server_response(addr, "PUT", "/json/new?about%3Ablank").await;
    assert_eq!(status, 200);
    let created_target: serde_json::Value =
        serde_json::from_slice(&body).expect("created target descriptor");
    let created_target_id = created_target["id"]
        .as_str()
        .expect("created target id")
        .to_owned();
    assert_ne!(created_target_id, DEFAULT_TARGET_ID);
    // Materializing a second Page leaves the old default Page in the
    // background. Puppeteer's first Page command selects that existing target
    // again, which is the reconnect lifecycle that regressed.
    let target_id = DEFAULT_TARGET_ID.to_owned();

    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect first browser websocket");
    let page_session_id =
        puppeteer_auto_attach_existing_page(&mut browser, 1, &target_id, DEFAULT_TAB_TARGET_ID)
            .await;
    let page_enabled = send_cdp_command(
        &mut browser,
        3,
        "Page.enable",
        Some(&page_session_id),
        json!({}),
    )
    .await;
    assert_eq!(response_by_id(&page_enabled, 3)["result"], json!({}));
    let _ = enable_runtime_and_expect_default_context(
        &mut browser,
        4,
        Some(&page_session_id),
        "first Runtime.enable",
    )
    .await;
    let utility_world = send_cdp_command(
        &mut browser,
        6,
        "Page.createIsolatedWorld",
        Some(&page_session_id),
        json!({
            "frameId": target_id,
            "worldName": "__puppeteer_utility_world__moli_reconnect",
            "grantUniveralAccess": true
        }),
    )
    .await;
    let first_utility_context_id =
        response_by_id(&utility_world, 6)["result"]["executionContextId"]
            .as_i64()
            .unwrap_or_else(|| panic!("failed to create the utility world: {utility_world:#?}"));

    browser
        .close(None)
        .await
        .expect("close first browser frontend");
    wait_for_websocket_close(&mut browser, "first browser frontend").await;

    let (mut replacement, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect replacement browser websocket");
    let replacement_page_session_id =
        puppeteer_auto_attach_existing_page(&mut replacement, 1, &target_id, DEFAULT_TAB_TARGET_ID)
            .await;
    assert_ne!(replacement_page_session_id, page_session_id);
    let page_enabled = send_cdp_command(
        &mut replacement,
        3,
        "Page.enable",
        Some(&replacement_page_session_id),
        json!({}),
    )
    .await;
    assert_eq!(response_by_id(&page_enabled, 3)["result"], json!({}));
    let replay = enable_runtime_and_expect_default_context(
        &mut replacement,
        4,
        Some(&replacement_page_session_id),
        "replacement Runtime.enable",
    )
    .await;
    assert!(
        replay.iter().all(|message| {
            message["sessionId"] != json!(replacement_page_session_id)
                || message["method"] != json!("Runtime.executionContextCreated")
                || message["params"]["context"]["name"]
                    != json!("__puppeteer_utility_world__moli_reconnect")
        }),
        "replacement Runtime.enable inherited a detached session's utility world: {replay:#?}"
    );

    let replacement_utility_world = send_cdp_command(
        &mut replacement,
        6,
        "Page.createIsolatedWorld",
        Some(&replacement_page_session_id),
        json!({
            "frameId": target_id,
            "worldName": "__puppeteer_utility_world__moli_reconnect",
            "grantUniveralAccess": true
        }),
    )
    .await;
    let replacement_utility_context_id =
        response_by_id(&replacement_utility_world, 6)["result"]["executionContextId"]
            .as_i64()
            .unwrap_or_else(|| {
                panic!(
                    "replacement session failed to recreate its utility world: \
                 {replacement_utility_world:#?}"
                )
            });
    assert_ne!(replacement_utility_context_id, first_utility_context_id);

    let evaluated = send_cdp_command(
        &mut replacement,
        7,
        "Runtime.evaluate",
        Some(&replacement_page_session_id),
        json!({ "expression": "6 * 7", "returnByValue": true }),
    )
    .await;
    assert_eq!(
        response_by_id(&evaluated, 7)["result"]["result"]["value"],
        json!(42)
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_browser_reconnect_clears_detached_session_emulated_media() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("connect browser websocket");
    let attach = send_cdp_command(
        &mut browser,
        1,
        "Target.attachToTarget",
        None,
        json!({ "targetId": DEFAULT_TARGET_ID, "flatten": true }),
    )
    .await;
    let session_id = response_by_id(&attach, 1)["result"]["sessionId"]
        .as_str()
        .expect("default target session")
        .to_owned();
    let media = json!({
        "features": [
            { "name": "prefers-color-scheme", "value": "dark" }
        ]
    });
    let set_dark = send_cdp_command(
        &mut browser,
        2,
        "Emulation.setEmulatedMedia",
        Some(&session_id),
        media.clone(),
    )
    .await;
    assert!(response_by_id(&set_dark, 2).get("result").is_some());
    let dark = send_cdp_command(
        &mut browser,
        3,
        "Runtime.evaluate",
        Some(&session_id),
        json!({
            "expression": "matchMedia('(prefers-color-scheme: dark)').matches",
            "returnByValue": true
        }),
    )
    .await;
    assert_eq!(
        response_by_id(&dark, 3)["result"]["result"]["value"],
        json!(true)
    );

    browser
        .close(None)
        .await
        .expect("close first browser frontend");
    wait_for_websocket_close(&mut browser, "detached browser frontend").await;

    let (mut replacement, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .expect("reconnect browser websocket");
    let attach = send_cdp_command(
        &mut replacement,
        1,
        "Target.attachToTarget",
        None,
        json!({ "targetId": DEFAULT_TARGET_ID, "flatten": true }),
    )
    .await;
    let replacement_session_id = response_by_id(&attach, 1)["result"]["sessionId"]
        .as_str()
        .expect("replacement default target session")
        .to_owned();
    let reset = send_cdp_command(
        &mut replacement,
        2,
        "Runtime.evaluate",
        Some(&replacement_session_id),
        json!({
            "expression": "matchMedia('(prefers-color-scheme: dark)').matches",
            "returnByValue": true
        }),
    )
    .await;
    assert_eq!(
        response_by_id(&reset, 2)["result"]["result"]["value"],
        json!(false),
        "a detached CDP session leaked its media override into the replacement frontend"
    );

    let set_dark = send_cdp_command(
        &mut replacement,
        3,
        "Emulation.setEmulatedMedia",
        Some(&replacement_session_id),
        media,
    )
    .await;
    assert!(response_by_id(&set_dark, 3).get("result").is_some());
    let dark = send_cdp_command(
        &mut replacement,
        4,
        "Runtime.evaluate",
        Some(&replacement_session_id),
        json!({
            "expression": "matchMedia('(prefers-color-scheme: dark)').matches",
            "returnByValue": true
        }),
    )
    .await;
    assert_eq!(
        response_by_id(&dark, 4)["result"]["result"]["value"],
        json!(true)
    );

    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_owner_registry_shutdown_joins_shared_default_page_owner() {
    let (addr, server, owner_registry) = spawn_test_protocol_server_with_owner_registry().await;
    let (mut page, _) = connect_async(format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"))
        .await
        .expect("connect default page websocket");
    let frame_tree = send_cdp_command(&mut page, 1, "Page.getFrameTree", None, json!({})).await;
    assert!(response_by_id(&frame_tree, 1).get("result").is_some());
    assert_eq!(owner_registry.owner_count(), 1);

    timeout(Duration::from_secs(5), owner_registry.shutdown())
        .await
        .expect("registry shutdown should join shared default page owner");
    assert_eq!(owner_registry.owner_count(), 0);
    wait_for_websocket_close(&mut page, "shared owner default page").await;

    abort_test_cdp_server(server).await;
}

async fn assert_native_isolate_handler_waits_for_resume(method: &str) {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().route("/page", get(|| async {
            axum::response::Html("<!doctype html><style>input {color: red}</style><form><input id=number autocomplete=cc-number></form>")
        })),
        "native-isolate-entry",
    );
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let context = cdp_create_browser_context(&mut browser, 1).await;
    let target = cdp_create_attached_target(&mut browser, 2, &context).await;
    let session = Some(target.session_id.as_str());
    navigate_fixture_document(
        &mut browser,
        4,
        &target,
        &format!("http://{fixture_addr}/page"),
    )
    .await;
    let document = send_cdp_command(&mut browser, 5, "DOM.getDocument", session, json!({})).await;
    let root = response_by_id(&document, 5)["result"]["root"]["nodeId"]
        .as_u64()
        .unwrap();
    let query = send_cdp_command(
        &mut browser,
        6,
        "DOM.querySelector",
        session,
        json!({"nodeId": root, "selector": "#number"}),
    )
    .await;
    let node = response_by_id(&query, 6)["result"]["nodeId"]
        .as_u64()
        .unwrap_or_else(|| panic!("fixture query failed after parsing: {query:#?}"));
    let describe = send_cdp_command(
        &mut browser,
        7,
        "DOM.describeNode",
        session,
        json!({"nodeId": node}),
    )
    .await;
    let backend = response_by_id(&describe, 7)["result"]["node"]["backendNodeId"]
        .as_u64()
        .unwrap();
    let css = send_cdp_command(&mut browser, 8, "CSS.enable", session, json!({})).await;
    let stylesheet = css
        .iter()
        .find(|message| message["method"] == "CSS.styleSheetAdded")
        .expect("fixture inline stylesheet")["params"]["header"]["styleSheetId"]
        .clone();
    let (params, expression, expected) = match method {
        "Page.setDocumentContent" => (
            json!({"frameId": target.target_id, "html": "<!doctype html><body>resumed content</body>"}),
            "document.body.textContent",
            json!("resumed content"),
        ),
        "Page.resetNavigationHistory" => (json!({}), "history.length", json!(1)),
        "Autofill.trigger" => (
            json!({"fieldId": backend, "card": {
                "number": "4444444444444448", "name": "Test Card", "expiryMonth": "12", "expiryYear": "2030", "cvc": "123"
            }}),
            "document.getElementById('number').value",
            json!("4444444444444448"),
        ),
        "CSS.setStyleSheetText" => (
            json!({"styleSheetId": stylesheet, "text": "input {color: blue}"}),
            "document.querySelector('style').textContent",
            json!("input {color: blue}"),
        ),
        "Emulation.setHardwareConcurrencyOverride" => (
            json!({"hardwareConcurrency": 4}),
            "navigator.hardwareConcurrency",
            json!(4),
        ),
        _ => panic!("unsupported isolate-entry fixture: {method}"),
    };
    let enabled = send_cdp_command(&mut browser, 10, "Debugger.enable", session, json!({})).await;
    assert!(response_by_id(&enabled, 10)["error"].is_null());
    send_cdp_command_without_wait(
        &mut browser,
        12,
        "Runtime.evaluate",
        session,
        json!({
            "expression": "(() => { history.pushState(null, '', '#one'); debugger; return 42; })()",
            "returnByValue": true
        }),
    )
    .await;
    let paused = recv_until_match(&mut browser, |message| {
        message["sessionId"] == target.session_id && message["method"] == "Debugger.paused"
    })
    .await;
    assert!(paused.iter().all(|message| message["id"] != 12));

    // This must be the first Main command after pausing. An earlier owner-only
    // command would hide a missing requirement by blocking the session lane.
    send_cdp_command_without_wait(&mut browser, 13, method, session, params).await;
    let gate = send_cdp_command(
        &mut browser,
        14,
        "Performance.getMetrics",
        session,
        json!({}),
    )
    .await;
    assert!(response_by_id(&gate, 14)["error"].is_null());
    assert!(
        gate.iter()
            .all(|message| message["id"] != 12 && message["id"] != 13),
        "{method} must wait for its independent V8 entry: {gate:?}"
    );
    send_cdp_command_without_wait(&mut browser, 15, "Debugger.resume", session, json!({})).await;
    let mut completed = std::collections::HashSet::new();
    let resumed = recv_until_match(&mut browser, |message| {
        if message["sessionId"] == target.session_id
            && let Some(id) = message["id"].as_u64()
        {
            assert!(completed.insert(id), "duplicate terminal: {message}");
        }
        [12, 13, 15].iter().all(|id| completed.contains(id))
    })
    .await;
    assert_eq!(
        response_by_id(&resumed, 12)["result"]["result"]["value"],
        42
    );
    assert!(
        response_by_id(&resumed, 13)["error"].is_null(),
        "{method}: {resumed:?}"
    );
    assert!(response_by_id(&resumed, 15)["error"].is_null());
    let state = send_cdp_command(
        &mut browser,
        16,
        "Runtime.evaluate",
        session,
        json!({"expression": expression, "returnByValue": true}),
    )
    .await;
    assert_eq!(
        response_by_id(&state, 16)["result"]["result"]["value"],
        expected,
        "{method}: {state:?}"
    );
    assert!(
        state.iter().all(|message| message["id"] != 13),
        "duplicate terminal: {state:?}"
    );
    browser.close(None).await.unwrap();
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "current_thread")]
async fn cdp_ordering_document_content_waits_for_isolate_owner() {
    assert_native_isolate_handler_waits_for_resume("Page.setDocumentContent").await;
}

#[tokio::test(flavor = "current_thread")]
async fn cdp_ordering_history_reset_waits_for_isolate_owner() {
    assert_native_isolate_handler_waits_for_resume("Page.resetNavigationHistory").await;
}

#[tokio::test(flavor = "current_thread")]
async fn cdp_ordering_autofill_waits_for_isolate_owner() {
    assert_native_isolate_handler_waits_for_resume("Autofill.trigger").await;
}

#[tokio::test(flavor = "current_thread")]
async fn cdp_ordering_stylesheet_edit_waits_for_isolate_owner() {
    assert_native_isolate_handler_waits_for_resume("CSS.setStyleSheetText").await;
}

#[tokio::test(flavor = "current_thread")]
async fn cdp_ordering_navigator_configuration_waits_for_isolate_owner() {
    assert_native_isolate_handler_waits_for_resume("Emulation.setHardwareConcurrencyOverride")
        .await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn named_popup_reuse_preserves_history_for_current_url_and_commits_new_documents() {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(|uri: axum::http::Uri| async move {
            axum::response::Html(format!("<title>{0}</title><h1>{0}</h1>", uri.path()))
        })),
        "named-popup-history",
    );
    let base = format!("http://{fixture_addr}");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    send_cdp_command(&mut opener, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut opener, 2, &format!("{base}/opener")).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    evaluate_window_name_probe(
        &mut opener,
        3,
        "window.popup = open('about:blank', 'report'); true",
    )
    .await;
    let targets = wait_for_target_list(addr, "initial popup", |targets| {
        targets.len() == baseline_ids.len() + 1
    })
    .await;
    let popup_id = targets
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]))
        .unwrap()["id"]
        .as_str()
        .unwrap();
    let mut popup = connect_dynamic_page(addr, popup_id).await;
    send_cdp_command(&mut popup, 1, "Page.enable", None, json!({})).await;
    let mut first_entry_id = None;
    for (index, (path, expected_length)) in [("/first", 1), ("/first", 1), ("/second", 2)]
        .into_iter()
        .enumerate()
    {
        let command_id = 30 + index as u64 * 3;
        evaluate_window_name_probe(&mut popup, command_id, "window.dirty = true").await;
        evaluate_window_name_probe(
            &mut opener,
            command_id,
            &format!(
                "window.open({}, 'report'); true",
                json!(format!("{base}{path}"))
            ),
        )
        .await;
        recv_until_match(&mut popup, |message| {
            message["method"] == "Page.loadEventFired"
        })
        .await;
        let messages = send_cdp_command(
            &mut popup,
            command_id + 1,
            "Page.getNavigationHistory",
            None,
            json!({}),
        )
        .await;
        let history = &response_by_id(&messages, command_id + 1)["result"];
        let entries = history["entries"].as_array().unwrap();
        assert_eq!(
            entries.len(),
            expected_length,
            "operation {index}: {history}"
        );
        assert_eq!(history["currentIndex"], expected_length - 1);
        assert!(
            entries
                .iter()
                .all(|entry| entry["transitionType"] == "link")
        );
        if index == 0 {
            first_entry_id = Some(entries[0]["id"].clone());
        } else {
            assert_eq!(Some(entries[0]["id"].clone()), first_entry_id);
        }
        assert_eq!(
            evaluate_window_name_probe(
                &mut popup,
                command_id + 2,
                "[history.length, typeof dirty, document.querySelector('h1').textContent]"
            )
            .await,
            json!([
                expected_length,
                if index == 0 { "boolean" } else { "undefined" },
                path
            ])
        );
    }
    assert_eq!(
        fetch_server_json(addr, "/json/list")
            .await
            .as_array()
            .unwrap()
            .len(),
        targets.len()
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn unrelated_same_origin_pages_do_not_reuse_each_others_named_popups() {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(|| async {
            axum::response::Html("<title>related pages</title>")
        })),
        "named-popup-related-pages",
    );
    let base = format!("http://{fixture_addr}");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let first_id = create_dynamic_target(&mut browser, 1).await;
    let second_id = create_dynamic_target(&mut browser, 2).await;
    let mut first = connect_dynamic_page(addr, &first_id).await;
    let mut second = connect_dynamic_page(addr, &second_id).await;
    send_cdp_command(&mut first, 1, "Page.enable", None, json!({})).await;
    send_cdp_command(&mut second, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut first, 2, &format!("{base}/first")).await;
    navigate_dynamic_page_and_wait_for_load(&mut second, 2, &format!("{base}/second")).await;
    let baseline = fetch_server_json(addr, "/json/list")
        .await
        .as_array()
        .unwrap()
        .len();
    for (index, opener) in [&mut first, &mut second].into_iter().enumerate() {
        evaluate_window_name_probe(
            opener,
            3,
            &format!(
                "window.popup = open({}, 'report'); true",
                json!(format!("{base}/popup-{index}"))
            ),
        )
        .await;
        wait_for_target_list(
            addr,
            "each unrelated opener creates its own popup",
            |targets| targets.len() == baseline + index + 1,
        )
        .await;
    }
    evaluate_window_name_probe(
        &mut second,
        4,
        &format!(
            "window.reused = open({}, 'report'); reused === popup",
            json!(format!("{base}/popup-1"))
        ),
    )
    .await;
    assert_eq!(
        fetch_server_json(addr, "/json/list")
            .await
            .as_array()
            .unwrap()
            .len(),
        baseline + 2
    );
    assert_eq!(
        evaluate_window_name_probe(&mut second, 5, "reused === popup").await,
        true
    );
    evaluate_window_name_probe(&mut first, 4, "popup.close(); true").await;
    let remaining = wait_for_target_list(
        addr,
        "closing one group leaves the other popup live",
        |targets| targets.len() == baseline + 1,
    )
    .await;
    assert!(
        remaining
            .iter()
            .any(|target| target["url"] == format!("{base}/popup-1"))
    );
    assert_eq!(
        evaluate_window_name_probe(&mut second, 6, "popup.closed").await,
        false
    );
    assert_eq!(
        evaluate_window_name_probe(&mut first, 5, "popup.closed").await,
        true
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn browser_cross_site_navigation_changes_named_group_and_history_restores_it() {
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(|| async {
            axum::response::Html("<title>navigation groups</title>")
        })),
        "named-popup-navigation-groups",
    );
    let base = format!("http://{fixture_addr}");
    let cross_site = format!("http://localhost:{}", fixture_addr.port());
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    send_cdp_command(&mut opener, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut opener, 2, &format!("{base}/opener")).await;
    let baseline = fetch_server_json(addr, "/json/list").await;
    let baseline_ids: Vec<_> = baseline
        .as_array()
        .unwrap()
        .iter()
        .map(|target| target["id"].clone())
        .collect();
    evaluate_window_name_probe(
        &mut opener,
        3,
        &format!(
            "open({}, 'report'); true",
            json!(format!("{base}/first-child"))
        ),
    )
    .await;
    let targets = wait_for_target_list(addr, "first named child", |targets| {
        targets.len() == baseline_ids.len() + 1
    })
    .await;
    let first_child_id = targets
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]))
        .unwrap()["id"]
        .clone();

    navigate_dynamic_page_and_wait_for_load(&mut opener, 4, &format!("{base}/same-site")).await;
    let mut child = connect_dynamic_page(addr, first_child_id.as_str().unwrap()).await;
    send_cdp_command(&mut child, 1, "Page.enable", None, json!({})).await;
    // A child can navigate across sites without losing its parent's named reference.
    evaluate_window_name_probe(
        &mut child,
        2,
        &format!(
            "location.href = {}; true",
            json!(format!("{cross_site}/script-navigation"))
        ),
    )
    .await;
    recv_until_match(&mut child, |message| {
        message["method"] == "Page.loadEventFired"
    })
    .await;
    send_cdp_command(&mut child, 3, "Page.reload", None, json!({})).await;
    recv_until_match(&mut child, |message| {
        message["method"] == "Page.loadEventFired"
    })
    .await;
    evaluate_window_name_probe(
        &mut opener,
        6,
        &format!(
            "open({}, 'report'); true",
            json!(format!("{base}/reused-after-script"))
        ),
    )
    .await;
    wait_for_target_list(
        addr,
        "script navigation retains original child",
        |targets| {
            targets.len() == baseline_ids.len() + 1
                && targets.iter().any(|target| {
                    target["id"] == first_child_id
                        && target["url"] == format!("{base}/reused-after-script")
                })
        },
    )
    .await;
    let history =
        send_cdp_command(&mut opener, 7, "Page.getNavigationHistory", None, json!({})).await;
    let history = &response_by_id(&history, 7)["result"];
    let original_entry_id =
        history["entries"][history["currentIndex"].as_u64().unwrap() as usize]["id"].clone();

    // An address-bar-style cross-site navigation selects a different group.
    navigate_dynamic_page_and_wait_for_load(
        &mut opener,
        8,
        &format!("{cross_site}/browser-navigation"),
    )
    .await;
    evaluate_window_name_probe(
        &mut opener,
        9,
        &format!(
            "open({}, 'report'); true",
            json!(format!("{cross_site}/second-child"))
        ),
    )
    .await;
    let targets = wait_for_target_list(addr, "new group creates its own named child", |targets| {
        targets.len() == baseline_ids.len() + 2
    })
    .await;
    let second_child_id = targets
        .iter()
        .find(|target| !baseline_ids.contains(&target["id"]) && target["id"] != first_child_id)
        .unwrap()["id"]
        .clone();
    let history = send_cdp_command(
        &mut opener,
        10,
        "Page.getNavigationHistory",
        None,
        json!({}),
    )
    .await;
    let history = &response_by_id(&history, 10)["result"];
    let replacement_entry_id =
        history["entries"][history["currentIndex"].as_u64().unwrap() as usize]["id"].clone();

    for (index, (entry_id, child_id, url)) in [
        (
            original_entry_id,
            first_child_id,
            format!("{base}/back-child"),
        ),
        (
            replacement_entry_id,
            second_child_id,
            format!("{cross_site}/forward-child"),
        ),
    ]
    .into_iter()
    .enumerate()
    {
        let id = 20 + index as u64 * 2;
        send_cdp_command(
            &mut opener,
            id,
            "Page.navigateToHistoryEntry",
            None,
            json!({"entryId": entry_id}),
        )
        .await;
        recv_until_match(&mut opener, |message| {
            message["method"] == "Page.loadEventFired"
        })
        .await;
        evaluate_window_name_probe(
            &mut opener,
            id + 1,
            &format!("open({}, 'report'); true", json!(url)),
        )
        .await;
        wait_for_target_list(
            addr,
            "history restores the corresponding named group",
            |targets| {
                targets.len() == baseline_ids.len() + 2
                    && targets
                        .iter()
                        .any(|target| target["id"] == child_id && target["url"] == url)
            },
        )
        .await;
    }
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn popup_navigation_replaces_pending_load_while_runtime_read_waits() {
    let gate = std::sync::Arc::new(tokio::sync::Notify::new());
    let response_gate = gate.clone();
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(move |uri: axum::http::Uri| {
            let response_gate = response_gate.clone();
            async move {
                if uri.path() == "/slow" {
                    response_gate.notified().await;
                }
                axum::response::Html(format!("<title>{0}</title><h1>{0}</h1>", uri.path()))
            }
        })),
        "popup-replace-pending-load",
    );
    let base = format!("http://{fixture_addr}");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    send_cdp_command(&mut opener, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut opener, 2, &format!("{base}/parent")).await;
    evaluate_window_name_probe(&mut opener, 3, "window.p = open('/ready', 'pending'); true").await;
    let targets = wait_for_target_list(addr, "pending popup target", |targets| {
        targets
            .iter()
            .any(|target| target["url"] == json!(format!("{base}/ready")))
    })
    .await;
    let popup_id = targets
        .iter()
        .find(|target| target["url"] == json!(format!("{base}/ready")))
        .unwrap()["id"]
        .as_str()
        .unwrap();
    let mut popup = connect_dynamic_page(addr, popup_id).await;
    send_cdp_command(&mut popup, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut popup, 2, &format!("{base}/ready-loaded")).await;
    send_cdp_command(&mut popup, 3, "Network.enable", None, json!({})).await;

    for (index, replacement) in [
        "open('/replacement-named', 'pending'); true",
        "p.location.replace('/replacement-reference'); true",
    ]
    .into_iter()
    .enumerate()
    {
        let id = 10 + index as u64 * 10;
        let slow_url = format!("{base}/slow?case={index}");
        evaluate_window_name_probe(
            &mut opener,
            id,
            &format!("p.location.href = {}; true", json!(slow_url)),
        )
        .await;
        recv_until_match(&mut popup, |event| {
            event["method"] == "Network.requestWillBeSent"
                && event["params"]["request"]["url"] == slow_url
        })
        .await;
        // A client reading the loading target must not prevent the opener's
        // replacement from reaching the owner that can cancel the old load.
        send_cdp_command_without_wait(
            &mut popup,
            id,
            "Runtime.evaluate",
            None,
            json!({
                "expression":"document.URL", "returnByValue":true,
            }),
        )
        .await;
        evaluate_window_name_probe(&mut opener, id + 1, replacement).await;
        let expected_path = if index == 0 {
            "/replacement-named"
        } else {
            "/replacement-reference"
        };
        let expected_url = format!("{base}{expected_path}");
        let mut saw_reply = false;
        let mut saw_commit = false;
        timeout(
            Duration::from_secs(5),
            recv_until_match(&mut popup, |event| {
                saw_reply |= event["id"] == id;
                saw_commit |= event["method"] == "Page.frameNavigated"
                    && event["params"]["frame"]["url"] == expected_url;
                saw_reply && saw_commit
            }),
        )
        .await
        .expect("a popup replacement must commit before the old response is released");
        assert_eq!(
            evaluate_window_name_probe(
                &mut popup,
                id + 1,
                "document.querySelector('h1')?.textContent"
            )
            .await,
            json!(expected_path)
        );
        gate.notify_waiters();
    }
    abort_test_cdp_server(server).await;
}

async fn wait_for_popup_response_text(
    opener: &mut TestCdpSocket,
    popup: &mut TestCdpSocket,
    expected: &str,
) {
    let mut last = (serde_json::Value::Null, serde_json::Value::Null);
    timeout(Duration::from_secs(10), async {
        let mut id = 1000;
        loop {
            let child = evaluate_window_name_probe(
                popup,
                id,
                "document.querySelector('h1')?.textContent || ''",
            )
            .await;
            let reference = evaluate_window_name_probe(
                opener,
                id,
                "p.document.querySelector('h1')?.textContent || ''",
            )
            .await;
            if child == json!(expected) && reference == json!(expected) {
                break;
            }
            last = (child, reference);
            id += 1;
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .unwrap_or_else(|_| {
        panic!("expected shared response {expected:?}; actual Page/reference: {last:?}")
    });
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn popup_document_navigation_uses_one_network_response() {
    use axum::response::IntoResponse as _;
    let counts = std::sync::Arc::new(parking_lot::Mutex::new(std::collections::HashMap::<
        String,
        usize,
    >::new()));
    let seen = counts.clone();
    let slow_response = std::sync::Arc::new(tokio::sync::Notify::new());
    let response_gate = slow_response.clone();
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new().fallback(get(move |uri: axum::http::Uri| {
            let seen = seen.clone();
            let response_gate = response_gate.clone();
            async move {
                let count = {
                    let mut seen = seen.lock();
                    let count = seen.entry(uri.path().to_owned()).or_default();
                    *count += 1;
                    *count
                };
                if uri.path() == "/raced" && count == 1 {
                    response_gate.notified().await;
                }
                if uri.path() == "/redirect" {
                    return (
                        axum::http::StatusCode::FOUND,
                        [("location", "/redirected")],
                        "",
                    )
                        .into_response();
                }
                if uri.path() == "/attachment" {
                    return (
                        [("content-disposition", "attachment; filename=popup.txt")],
                        "download body",
                    )
                        .into_response();
                }
                (
                    [("cache-control", "no-store")],
                    axum::response::Html(format!(
                        "<title>response</title><h1>{}:{count}</h1>",
                        uri.path()
                    )),
                )
                    .into_response()
            }
        })),
        "popup-single-response",
    );
    let base = format!("http://{fixture_addr}");
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    send_cdp_command(&mut opener, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut opener, 2, &format!("{base}/parent")).await;
    evaluate_window_name_probe(
        &mut opener,
        3,
        "window.p = open('/first', 'response'); true",
    )
    .await;
    let targets = wait_for_target_list(addr, "popup response target", |targets| {
        targets
            .iter()
            .any(|target| target["url"] == json!(format!("{base}/first")))
    })
    .await;
    let popup_id = targets
        .iter()
        .find(|target| target["url"] == json!(format!("{base}/first")))
        .unwrap()["id"]
        .as_str()
        .unwrap();
    let mut popup = connect_dynamic_page(addr, popup_id).await;
    wait_for_popup_response_text(&mut opener, &mut popup, "/first:1").await;
    for (index, (expression, expected)) in [
        ("open('/first', 'response') === p", "/first:2"),
        ("p.location.assign('/second'); true", "/second:1"),
        ("p.location.reload(); true", "/second:2"),
        ("p.location.assign('/redirect'); true", "/redirected:1"),
        ("p.location.replace('/third'); true", "/third:1"),
    ]
    .into_iter()
    .enumerate()
    {
        assert_eq!(
            evaluate_window_name_probe(&mut opener, index as u64 + 10, expression).await,
            true
        );
        wait_for_popup_response_text(&mut opener, &mut popup, expected).await;
        assert_eq!(
            evaluate_window_name_probe(&mut opener, index as u64 + 100, "p.location.href").await,
            evaluate_window_name_probe(&mut popup, index as u64 + 100, "location.href").await,
        );
    }
    evaluate_window_name_probe(&mut opener, 20, "p.location.assign('/attachment'); true").await;
    timeout(Duration::from_secs(5), async {
        let mut id = 2000;
        loop {
            let path = evaluate_window_name_probe(&mut opener, id, "p.location.pathname").await;
            if counts.lock().get("/attachment") == Some(&1) && path == "/third" {
                break;
            }
            id += 1;
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .expect("a download must preserve the popup's previous document and URL");
    wait_for_popup_response_text(&mut opener, &mut popup, "/third:1").await;
    // Distinct navigations to the same URL must not share a response ticket.
    // The replacement must complete while the earlier response is held back.
    evaluate_window_name_probe(&mut opener, 30, "open('/raced', 'response'); true").await;
    timeout(Duration::from_secs(5), async {
        while counts.lock().get("/raced") != Some(&1) {
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .expect("first raced request should reach the server");
    evaluate_window_name_probe(&mut opener, 31, "open('/raced', 'response'); true").await;
    timeout(Duration::from_secs(5), async {
        while counts.lock().get("/raced") != Some(&2) {
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .unwrap_or_else(|_| {
        panic!(
            "replacement request did not reach server: {:?}",
            counts.lock()
        )
    });
    wait_for_popup_response_text(&mut opener, &mut popup, "/raced:2").await;
    slow_response.notify_one();
    assert_eq!(counts.lock().get("/raced"), Some(&2));
    let observed = counts.lock().clone();
    assert_eq!(observed.get("/first"), Some(&2));
    assert_eq!(observed.get("/second"), Some(&2));
    assert_eq!(observed.get("/third"), Some(&1));
    assert_eq!(observed.get("/redirect"), Some(&1));
    assert_eq!(observed.get("/redirected"), Some(&1));
    assert_eq!(observed.get("/attachment"), Some(&1));
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn popup_reference_waits_for_debugger_and_consumes_fetch_fulfillment() {
    use base64::Engine as _;
    let requests = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
    let seen = requests.clone();
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new()
            .route(
                "/parent",
                get(|| async { axum::response::Html("<title>parent</title>") }),
            )
            .route(
                "/intercepted",
                get(move || {
                    seen.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
                    async { axum::response::Html("<h1>unexpected network response</h1>") }
                }),
            ),
        "popup-intercepted-response",
    );
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    send_cdp_command(&mut opener, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(
        &mut opener,
        2,
        &format!("http://{fixture_addr}/parent"),
    )
    .await;
    send_cdp_command(
        &mut browser,
        2,
        "Target.setAutoAttach",
        None,
        json!({
            "autoAttach": true, "waitForDebuggerOnStart": true, "flatten": true,
            "filter": [{"type":"page"}],
        }),
    )
    .await;
    evaluate_window_name_probe(
        &mut opener,
        3,
        "window.p = open('/intercepted', 'response'); true",
    )
    .await;
    let attached = recv_until_match(&mut browser, |event| {
        event["method"] == "Target.attachedToTarget"
            && event["params"]["targetInfo"]["url"]
                == json!(format!("http://{fixture_addr}/intercepted"))
    })
    .await;
    let popup = attached
        .iter()
        .find(|event| {
            event["method"] == "Target.attachedToTarget"
                && event["params"]["targetInfo"]["url"]
                    == json!(format!("http://{fixture_addr}/intercepted"))
        })
        .unwrap();
    let session_id = popup["params"]["sessionId"].as_str().unwrap().to_owned();
    let popup_id = popup["params"]["targetInfo"]["targetId"]
        .as_str()
        .unwrap()
        .to_owned();
    assert_eq!(requests.load(std::sync::atomic::Ordering::SeqCst), 0);
    let enabled = send_cdp_command(
        &mut browser,
        3,
        "Fetch.enable",
        Some(&session_id),
        json!({
            "patterns": [{"urlPattern":"*", "resourceType":"Document", "requestStage":"Request"}],
        }),
    )
    .await;
    assert!(response_by_id(&enabled, 3).get("error").is_none());
    send_cdp_command_without_wait(
        &mut browser,
        4,
        "Runtime.runIfWaitingForDebugger",
        Some(&session_id),
        json!({}),
    )
    .await;
    let mut resumed = false;
    let mut paused = None;
    recv_until_match(&mut browser, |event| {
        resumed |= event["id"] == 4;
        if event["method"] == "Fetch.requestPaused" && event["sessionId"] == session_id {
            paused = event["params"]["requestId"].as_str().map(str::to_owned);
        }
        resumed && paused.is_some()
    })
    .await;
    assert_eq!(requests.load(std::sync::atomic::Ordering::SeqCst), 0);
    let fulfilled = send_cdp_command(&mut browser, 5, "Fetch.fulfillRequest", Some(&session_id), json!({
        "requestId": paused.unwrap(), "responseCode": 200,
        "responseHeaders": [{"name":"Content-Type","value":"text/html; charset=windows-1252"}],
        "body": base64::engine::general_purpose::STANDARD.encode(b"<title>fulfilled</title><h1>caf\xe9</h1>"),
    })).await;
    assert!(response_by_id(&fulfilled, 5).get("error").is_none());
    let mut popup = connect_dynamic_page(addr, &popup_id).await;
    wait_for_popup_response_text(&mut opener, &mut popup, "café").await;
    assert_eq!(
        requests.load(std::sync::atomic::Ordering::SeqCst),
        0,
        "the opener's reference must not issue an un-intercepted duplicate request"
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn blank_popup_display_title_does_not_change_document_title() {
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    let opener_id = create_dynamic_target(&mut browser, 1).await;
    let mut opener = connect_dynamic_page(addr, &opener_id).await;
    let before = fetch_server_json(addr, "/json/list").await;
    evaluate_window_name_probe(&mut opener, 1, "window.p = open('about:blank'); true").await;
    let targets = wait_for_target_list(addr, "blank popup target", |targets| {
        targets.iter().any(|target| {
            !before
                .as_array()
                .unwrap()
                .iter()
                .any(|old| old["id"] == target["id"])
        })
    })
    .await;
    let target = targets
        .iter()
        .find(|target| {
            !before
                .as_array()
                .unwrap()
                .iter()
                .any(|old| old["id"] == target["id"])
        })
        .unwrap();
    let popup_id = target["id"].as_str().unwrap().to_owned();
    let mut popup = connect_dynamic_page(addr, &popup_id).await;
    send_cdp_command(&mut popup, 1, "Page.enable", None, json!({})).await;
    for (index, (expression, document_title, display_title)) in [
        ("true", "", "about:blank"),
        ("document.title='Named';true", "Named", "Named"),
        ("document.title='';true", "", "about:blank"),
        ("location.hash='fragment';true", "", "about:blank"),
        (
            "document.title='Named again';true",
            "Named again",
            "Named again",
        ),
        ("document.title='';true", "", "about:blank#fragment"),
    ]
    .into_iter()
    .enumerate()
    {
        let id = 10 + index as u64 * 3;
        evaluate_window_name_probe(&mut popup, id, expression).await;
        assert_eq!(
            evaluate_window_name_probe(&mut popup, id + 1, "document.title").await,
            document_title
        );
        let info = send_cdp_command(
            &mut browser,
            id,
            "Target.getTargetInfo",
            None,
            json!({"targetId":popup_id}),
        )
        .await;
        assert_eq!(
            response_by_id(&info, id)["result"]["targetInfo"]["title"],
            display_title
        );
        wait_for_target_list(addr, "matching HTTP display title", |targets| {
            targets
                .iter()
                .any(|target| target["id"] == popup_id && target["title"] == display_title)
        })
        .await;
    }
    evaluate_window_name_probe(&mut popup, 49, "location.hash='new-document';true").await;
    send_cdp_command_without_wait(&mut popup, 50, "Page.reload", None, json!({})).await;
    let mut responded = false;
    let mut loaded = false;
    recv_until_match(&mut popup, |message| {
        responded |= message["id"] == 50;
        loaded |= message["method"] == "Page.loadEventFired";
        responded && loaded
    })
    .await;
    let info = send_cdp_command(
        &mut browser,
        50,
        "Target.getTargetInfo",
        None,
        json!({"targetId":popup_id}),
    )
    .await;
    assert_eq!(
        response_by_id(&info, 50)["result"]["targetInfo"]["title"],
        "about:blank#fragment"
    );
    assert_eq!(
        evaluate_window_name_probe(&mut popup, 51, "document.title").await,
        ""
    );
    navigate_dynamic_page_and_wait_for_load(&mut popup, 52, "about:blank?next").await;
    let info = send_cdp_command(
        &mut browser,
        53,
        "Target.getTargetInfo",
        None,
        json!({"targetId":popup_id}),
    )
    .await;
    assert_eq!(
        response_by_id(&info, 53)["result"]["targetInfo"]["title"],
        "about:blank?next"
    );
    assert_eq!(
        evaluate_window_name_probe(&mut popup, 54, "[document.title,document.body.textContent]")
            .await,
        json!(["", ""])
    );
    abort_test_cdp_server(server).await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn focus_change_does_not_wait_for_a_focused_busy_context() {
    let entered = Arc::new(tokio::sync::Notify::new());
    let witness = Arc::clone(&entered);
    let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
        Router::new()
            .route(
                "/",
                get(|| async { axum::response::Html("<title>Busy background</title>") }),
            )
            .route(
                "/entered",
                get(move || {
                    let witness = Arc::clone(&witness);
                    async move {
                        witness.notify_one();
                        "entered"
                    }
                }),
            ),
        "unrelated-busy-context",
    );
    let (addr, server) = spawn_test_protocol_server().await;
    let (mut browser, _) =
        connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
            .await
            .unwrap();
    create_dynamic_target(&mut browser, 1).await;
    let second_id = create_dynamic_target(&mut browser, 2).await;
    let context = send_cdp_command(
        &mut browser,
        3,
        "Target.createBrowserContext",
        None,
        json!({}),
    )
    .await;
    let context_id = response_by_id(&context, 3)["result"]["browserContextId"]
        .as_str()
        .unwrap();
    let created = send_cdp_command(
        &mut browser,
        4,
        "Target.createTarget",
        None,
        json!({"url": "about:blank", "browserContextId": context_id}),
    )
    .await;
    let busy_id = response_by_id(&created, 4)["result"]["targetId"]
        .as_str()
        .unwrap();
    let mut busy = connect_dynamic_page(addr, busy_id).await;
    send_cdp_command(&mut busy, 1, "Page.enable", None, json!({})).await;
    navigate_dynamic_page_and_wait_for_load(&mut busy, 2, &format!("http://{fixture_addr}/")).await;
    assert_eq!(
        evaluate_window_name_probe(
            &mut busy,
            3,
            "[document.hasFocus(), document.visibilityState]"
        )
        .await,
        json!([true, "visible"])
    );

    send_cdp_command_without_wait(&mut busy, 4, "Runtime.evaluate", None, json!({
        "expression": "const xhr = new XMLHttpRequest(); xhr.open('GET', '/entered', false); xhr.send(); const until = Date.now() + 5000; while (Date.now() < until) {} 'expired'",
        "returnByValue": true,
    })).await;
    timeout(Duration::from_secs(5), entered.notified())
        .await
        .expect("busy script entered renderer");
    let activation_started = std::time::Instant::now();
    send_cdp_command_without_wait(
        &mut browser,
        6,
        "Target.activateTarget",
        None,
        json!({"targetId": second_id}),
    )
    .await;
    tokio::time::sleep(Duration::from_millis(100)).await;
    let version_started = std::time::Instant::now();
    send_cdp_command_without_wait(&mut browser, 7, "Browser.getVersion", None, json!({})).await;
    let mut activation_elapsed = None;
    let mut version_elapsed = None;
    let responses = recv_until_match(&mut browser, |message| {
        if message["id"] == 6 {
            activation_elapsed = Some(activation_started.elapsed());
        }
        if message["id"] == 7 {
            version_elapsed = Some(version_started.elapsed());
        }
        activation_elapsed.is_some() && version_elapsed.is_some()
    })
    .await;
    let activation_elapsed = activation_elapsed.unwrap();
    let version_elapsed = version_elapsed.unwrap();
    let reversal_started = std::time::Instant::now();
    let reversal = send_cdp_command(
        &mut browser,
        8,
        "Target.activateTarget",
        None,
        json!({"targetId": busy_id}),
    )
    .await;
    let reversal_elapsed = reversal_started.elapsed();
    eprintln!(
        "focused_busy_context_latency: activate_ms={}, version_ms={}",
        activation_elapsed.as_millis(),
        version_elapsed.as_millis()
    );
    let expired = recv_until_id(&mut busy, 4).await;
    assert_eq!(
        response_by_id(&expired, 4)["result"]["result"]["value"],
        "expired"
    );
    let final_activity = evaluate_window_name_probe(
        &mut busy,
        5,
        "[document.hasFocus(),document.visibilityState]",
    )
    .await;
    abort_test_cdp_server(server).await;
    assert!(
        response_by_id(&reversal, 8)["error"].is_null(),
        "{reversal:#?}"
    );
    assert_eq!(final_activity, json!([true, "visible"]));
    for id in [6, 7] {
        assert!(
            response_by_id(&responses, id)["error"].is_null(),
            "{responses:#?}"
        );
    }
    assert!(
        activation_elapsed < Duration::from_secs(1)
            && version_elapsed < Duration::from_secs(1)
            && reversal_elapsed < Duration::from_secs(1),
        "a focused busy renderer must not block activation or Browser.getVersion: activate={activation_elapsed:?}, version={version_elapsed:?}"
    );
}