Skip to content

armgit / moli

Public Imported from GitHub
0

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

71.7 KB
Raw Blame
use super::*;
use crate::testing::TestContext;
use moli_core::page::{MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH, is_renderer_backend_node_id};

#[test]
fn registered_adapter_reply_route_owns_exactly_one_receiver() {
    let (_response_tx, response_rx) = tokio::sync::oneshot::channel();
    let mut route = RuntimeProtocolResponseRoute::for_registered_delivery(
        RendererInspectorResponseDelivery::AdapterReply,
        Some(response_rx),
    );

    assert_eq!(
        route.delivery(),
        RendererInspectorResponseDelivery::AdapterReply
    );
    assert!(route.take_adapter_reply_receiver().is_some());
    assert!(route.take_adapter_reply_receiver().is_none());
}

#[test]
#[should_panic(expected = "registered adapter-reply route must allocate its receiver")]
fn registered_adapter_reply_route_rejects_a_missing_receiver() {
    let _ = RuntimeProtocolResponseRoute::for_registered_delivery(
        RendererInspectorResponseDelivery::AdapterReply,
        None,
    );
}

#[test]
fn registered_devtools_session_route_has_no_adapter_reply_receiver() {
    let mut route = RuntimeProtocolResponseRoute::for_registered_delivery(
        RendererInspectorResponseDelivery::SessionSink,
        None,
    );

    assert_eq!(
        route.delivery(),
        RendererInspectorResponseDelivery::SessionSink
    );
    assert!(route.take_adapter_reply_receiver().is_none());
}

#[test]
#[should_panic(expected = "session-sink response cannot retain an adapter-reply receiver")]
fn devtools_session_route_rejects_adapter_reply_receiver() {
    let (_response_tx, response_rx) = tokio::sync::oneshot::channel();
    let _ = RuntimeProtocolResponseRoute::for_registered_delivery(
        RendererInspectorResponseDelivery::SessionSink,
        Some(response_rx),
    );
}

#[test]
fn replay_response_routes_never_claim_a_second_local_receiver() {
    let mut adapter_reply = RuntimeProtocolResponseRoute::without_local_receiver_for_delivery(
        RendererInspectorResponseDelivery::AdapterReply,
    );
    let mut devtools_session = RuntimeProtocolResponseRoute::without_local_receiver_for_delivery(
        RendererInspectorResponseDelivery::SessionSink,
    );

    assert_eq!(
        adapter_reply.delivery(),
        RendererInspectorResponseDelivery::AdapterReply
    );
    assert_eq!(
        devtools_session.delivery(),
        RendererInspectorResponseDelivery::SessionSink
    );
    assert!(adapter_reply.take_adapter_reply_receiver().is_none());
    assert!(devtools_session.take_adapter_reply_receiver().is_none());
}

#[test]
fn runtime_inspector_command_rewrites_large_frontend_id_to_renderer_call_id() {
    let frontend_command_id = FrontendCommandId::new(i32::MAX as u64 + 73);
    let raw_json = json!({
        "id": frontend_command_id.get(),
        "method": "Runtime.evaluate",
        "params": { "expression": "42" },
        "sessionId": "SID-large-id",
    })
    .to_string();

    let rewritten = rewrite_runtime_inspector_command_for_renderer(
        &raw_json,
        Some((frontend_command_id, RendererCallId::new(11))),
        None,
    )
    .unwrap();
    let rewritten: Value = serde_json::from_str(&rewritten).unwrap();

    assert_eq!(rewritten["id"], json!(11));
    assert_eq!(rewritten["method"], json!("Runtime.evaluate"));
    assert_eq!(rewritten["params"]["expression"], json!("42"));
    assert_eq!(rewritten["sessionId"], json!("SID-large-id"));
}

#[test]
fn runtime_inspector_command_rewrite_rejects_mismatched_wire_id() {
    let error = rewrite_runtime_inspector_command_for_renderer(
        r#"{"id":8,"method":"Runtime.evaluate","params":{}}"#,
        Some((FrontendCommandId::new(9), RendererCallId::new(1))),
        None,
    )
    .unwrap_err();

    assert_eq!(
        error,
        "runtime Inspector command id mismatch: expected 9, got 8"
    );
}

#[test]
fn runtime_inspector_command_dequalifies_current_owner_unique_context_id() {
    let raw_json = json!({
        "id": 8,
        "method": "Runtime.callFunctionOn",
        "params": {
            "functionDeclaration": "function() { return 42; }",
            "uniqueContextId": "TID-current:17.23"
        }
    })
    .to_string();

    let rewritten =
        rewrite_runtime_inspector_command_for_renderer(&raw_json, None, Some("TID-current"))
            .unwrap();
    let rewritten: Value = serde_json::from_str(&rewritten).unwrap();

    assert_eq!(rewritten["params"]["uniqueContextId"], json!("17.23"));
}

#[test]
fn runtime_inspector_command_does_not_dequalify_another_owners_realm() {
    let raw_json = json!({
        "id": 8,
        "method": "Runtime.evaluate",
        "params": {
            "expression": "42",
            "uniqueContextId": "TID-stale:17.23"
        }
    })
    .to_string();

    let rewritten =
        rewrite_runtime_inspector_command_for_renderer(&raw_json, None, Some("TID-current"))
            .unwrap();
    let rewritten: Value = serde_json::from_str(&rewritten).unwrap();

    assert_eq!(
        rewritten["params"]["uniqueContextId"],
        json!("TID-stale:17.23")
    );
}

fn connection_with_bidi_page_session() -> CdpConnection {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-owner".to_owned());
    browser_context.set_active_target_id("TID-active");
    browser_context.attach_active_session("SID-active".to_owned());
    browser_context
        .active_page_target_mut()
        .runtime_slot
        .set_page_attachment_id_for_test(1);
    conn.install_browser_context_fixture_for_test(browser_context);
    conn
}

#[test]
fn runtime_remote_object_validation_allows_session_local_id_collisions() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-owner".to_owned());
    browser_context.set_active_target_id("TID-active");
    browser_context.attach_active_session("SID-active".to_owned());
    assert!(
        browser_context.assign_attached_session_to_target("TID-active", "SID-attached".to_owned(),)
    );
    conn.install_browser_context_fixture_for_test(browser_context);

    conn.register_runtime_remote_object_ids_for_session_owner(
        Some("SID-active"),
        vec!["same-wire-id".to_owned()],
    );
    conn.register_runtime_remote_object_ids_for_session_owner(
        Some("SID-attached"),
        vec!["same-wire-id".to_owned(), "attached-only".to_owned()],
    );

    assert!(
        conn.validate_runtime_remote_object_ids_for_session_owner(
            Some("SID-active"),
            &["same-wire-id".to_owned()],
        )
        .is_ok(),
        "a current-session handle must win over an identical wire id in another session"
    );
    assert!(
        conn.validate_runtime_remote_object_ids_for_session_owner(
            Some("SID-attached"),
            &["same-wire-id".to_owned()],
        )
        .is_ok(),
        "the same V8 wire id can independently belong to the attached session"
    );
    assert_eq!(
        conn.validate_runtime_remote_object_ids_for_session_owner(
            Some("SID-active"),
            &["attached-only".to_owned()],
        ),
        Err("Cannot find object with given id".to_owned()),
        "an id known only to another session must remain inaccessible"
    );
}

#[test]
fn runtime_remote_object_validation_tolerates_an_empty_browser_context() {
    let mut conn = connection_with_bidi_page_session();
    conn.insert_browser_context(BrowserContext::new("BID-empty".to_owned()));

    assert!(
        conn.validate_runtime_remote_object_ids_for_session_owner(
            Some("SID-active"),
            &["unregistered-wire-id".to_owned()],
        )
        .is_ok(),
        "an unrelated BrowserContext without a Page target must not be dereferenced as active"
    );
}

fn bidi_channel_listener_for_test(channel: &str) -> PendingBidiChannelListener {
    PendingBidiChannelListener::new(
        Some(DevToolsTargetId::from("TID-active")),
        Some(crate::automation::DevToolsRealmId::from("realm-active")),
        crate::automation::DevToolsRemoteHandleId::from(format!("channel-proxy-{channel}")),
        format!("webdriver-bidi-channel-{channel}"),
        crate::automation::DevToolsBidiChannelProperties {
            channel: channel.to_owned(),
            ownership: DevToolsResultOwnership::None,
            serialization_options: None,
        },
    )
    .expect("test listener should include target and realm")
}

fn renderer_command_descriptor_for_test(command_id: u64) -> RendererCommandDescriptor {
    RendererCommandDescriptor::from_synthesized_payload(
        json!({
            "id": command_id,
            "method": "Runtime.evaluate",
            "params": { "expression": "1" },
        })
        .to_string(),
    )
    .unwrap()
}

fn devtools_session_renderer_command_descriptor_for_test(
    command_id: u64,
) -> RendererCommandDescriptor {
    let frontend_payload = json!({
        "id": command_id,
        "method": "Runtime.evaluate",
        "params": { "expression": command_id.to_string() },
    })
    .to_string();
    let frontend =
        ParsedCdpCommand::parse_str(&frontend_payload).expect("frontend command should parse");
    RendererCommandDescriptor::from_frontend_policy(
        frontend.json().to_owned(),
        frontend.renderer_policy(),
        RendererInspectorResponseDelivery::SessionSink,
    )
}

fn register_devtools_session_response_for_test(
    conn: &mut CdpConnection,
    session_id: &str,
    frontend_command_id: u64,
    attachment_id: RendererAgentAttachmentId,
    frontend_payload: &str,
) -> RendererCommandCorrelation {
    let frontend =
        ParsedCdpCommand::parse_str(frontend_payload).expect("frontend command should parse");
    let prepared = conn
        .try_register_renderer_call_for_session_owner(
            Some(session_id),
            frontend_command_id,
            Some(attachment_id),
            RendererCommandDescriptor::from_frontend_policy(
                frontend.json().to_owned(),
                frontend.renderer_policy(),
                RendererInspectorResponseDelivery::SessionSink,
            ),
        )
        .expect("frontend response correlation should register");
    let (correlation, response_sender, response_receiver) = prepared.into_parts();
    assert!(
        response_receiver.is_none(),
        "SessionSink delivery must not allocate an adapter-reply receiver"
    );
    drop(response_sender);
    correlation
}

#[test]
fn navigation_termination_consumes_a_devtools_session_frontend_call() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-navigation-termination".to_owned());
    browser_context.set_active_target_id("TID-navigation-termination".to_owned());
    browser_context.attach_active_session("SID-navigation-termination".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let old_attachment = RendererAgentAttachmentId::allocate();
    let terminal_attachment = RendererAgentAttachmentId::allocate();
    let prepared = conn
        .try_register_renderer_call_for_session_owner(
            Some("SID-navigation-termination"),
            69,
            Some(old_attachment),
            devtools_session_renderer_command_descriptor_for_test(69),
        )
        .expect("frontend response correlation should register");
    let (old_correlation, old_sender, response_receiver) = prepared.into_parts();
    assert!(response_receiver.is_none());

    let replacements = {
        let browser_context = conn
            .browser_context
            .as_mut()
            .expect("test browser context should remain loaded");
        let page_state = browser_context.active_page_target_mut();
        page_state
            .devtools_sessions
            .prepare_renderer_call_replacements(
                Some("SID-navigation-termination"),
                old_attachment,
                terminal_attachment,
            )
            .expect("navigation replacement should prepare")
    };
    let (replacement_attachment, terminations, replays) = replacements.into_parts();
    assert_eq!(replacement_attachment, terminal_attachment);
    assert_eq!(terminations.len(), 1);
    assert!(replays.is_empty());
    assert!(
        old_sender
            .send(json!({
                "id": old_correlation.renderer_call_id().get(),
                "result": {},
            }))
            .is_err(),
        "navigation termination must invalidate the old renderer lease"
    );
    assert_eq!(
        conn.renderer_call_for_frontend_for_session_owner(Some("SID-navigation-termination"), 69,),
        Some(old_correlation),
        "direct session termination must retain the original correlation until settlement"
    );

    let termination_events = conn.terminate_prepared_renderer_calls_after_navigation(
        terminations,
        "Inspected target navigated or closed",
    );
    assert_eq!(termination_events.len(), 1);
    let response = termination_events[0]
        .protocol_message()
        .expect("DevToolsSession termination should emit a frontend response");
    assert_eq!(response["id"], json!(69));
    assert_eq!(response["sessionId"], json!("SID-navigation-termination"));
    assert_eq!(response["error"]["code"], json!(-32000));
    assert_eq!(
        response["error"]["message"],
        json!("Inspected target navigated or closed")
    );

    assert!(
        conn.renderer_runtime_command_cause_for_frontend(Some("SID-navigation-termination"), 69,)
            .is_none(),
        "navigation termination must consume the frontend correlation"
    );
}

#[test]
fn navigation_termination_isolated_same_frontend_id_by_devtools_session() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-navigation-sessions".to_owned());
    browser_context.set_active_target_id("TID-navigation-sessions".to_owned());
    browser_context.attach_active_session("SID-navigation-primary".to_owned());
    assert!(browser_context.assign_attached_session_to_target(
        "TID-navigation-sessions",
        "SID-navigation-attached".to_owned(),
    ));
    conn.install_browser_context_fixture_for_test(browser_context);

    let old_attachment = RendererAgentAttachmentId::allocate();
    let terminal_attachment = RendererAgentAttachmentId::allocate();
    let primary = conn
        .try_register_renderer_call_for_session_owner(
            Some("SID-navigation-primary"),
            71,
            Some(old_attachment),
            devtools_session_renderer_command_descriptor_for_test(71),
        )
        .expect("primary frontend response correlation should register");
    let attached = conn
        .try_register_renderer_call_for_session_owner(
            Some("SID-navigation-attached"),
            71,
            Some(old_attachment),
            devtools_session_renderer_command_descriptor_for_test(71),
        )
        .expect("attached frontend response correlation should register");
    let (primary_correlation, primary_sender, primary_receiver) = primary.into_parts();
    let (attached_correlation, attached_sender, attached_receiver) = attached.into_parts();
    assert!(primary_receiver.is_none());
    assert!(attached_receiver.is_none());

    let replacements = {
        let browser_context = conn
            .browser_context
            .as_mut()
            .expect("test browser context should remain loaded");
        let page_state = browser_context.active_page_target_mut();
        page_state
            .devtools_sessions
            .prepare_renderer_call_replacements(
                Some("SID-navigation-primary"),
                old_attachment,
                terminal_attachment,
            )
            .expect("navigation replacement should prepare for every session")
    };
    let (_, terminations, replays) = replacements.into_parts();
    assert_eq!(terminations.len(), 2);
    assert!(replays.is_empty());
    for (correlation, sender) in [
        (primary_correlation, primary_sender),
        (attached_correlation, attached_sender),
    ] {
        assert!(
            sender
                .send(json!({
                    "id": correlation.renderer_call_id().get(),
                    "result": {},
                }))
                .is_err(),
            "navigation replacement must invalidate every old session lease"
        );
    }
    assert_eq!(
        conn.renderer_call_for_frontend_for_session_owner(Some("SID-navigation-primary"), 71,),
        Some(primary_correlation)
    );
    assert_eq!(
        conn.renderer_call_for_frontend_for_session_owner(Some("SID-navigation-attached"), 71,),
        Some(attached_correlation)
    );

    let termination_events = conn.terminate_prepared_renderer_calls_after_navigation(
        terminations,
        "Inspected target navigated or closed",
    );
    assert_eq!(termination_events.len(), 2);
    let session_ids = termination_events
        .iter()
        .map(|event| {
            let response = event
                .protocol_message()
                .expect("each session termination should emit a frontend response");
            assert_eq!(response["id"], json!(71));
            assert_eq!(response["error"]["code"], json!(-32000));
            response["sessionId"]
                .as_str()
                .expect("attached sessions must retain sessionId")
                .to_owned()
        })
        .collect::<std::collections::BTreeSet<_>>();
    assert_eq!(
        session_ids,
        std::collections::BTreeSet::from([
            "SID-navigation-primary".to_owned(),
            "SID-navigation-attached".to_owned(),
        ])
    );
    assert!(
        conn.renderer_runtime_command_cause_for_frontend(Some("SID-navigation-primary"), 71,)
            .is_none()
    );
    assert!(
        conn.renderer_runtime_command_cause_for_frontend(Some("SID-navigation-attached"), 71,)
            .is_none()
    );
}

#[test]
fn navigation_termination_preserves_sessionless_page_response_shape() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-navigation-sessionless".to_owned());
    browser_context.set_active_target_id("TID-navigation-sessionless".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let old_attachment = RendererAgentAttachmentId::allocate();
    let terminal_attachment = RendererAgentAttachmentId::allocate();
    let prepared = conn
        .try_register_renderer_call_for_session_owner(
            None,
            72,
            Some(old_attachment),
            devtools_session_renderer_command_descriptor_for_test(72),
        )
        .expect("sessionless frontend response correlation should register");
    let (old_correlation, old_sender, response_receiver) = prepared.into_parts();
    assert!(response_receiver.is_none());

    let replacements = {
        let browser_context = conn
            .browser_context
            .as_mut()
            .expect("test browser context should remain loaded");
        let page_state = browser_context.active_page_target_mut();
        page_state
            .devtools_sessions
            .prepare_renderer_call_replacements(None, old_attachment, terminal_attachment)
            .expect("sessionless navigation replacement should prepare")
    };
    let (_, terminations, replays) = replacements.into_parts();
    assert_eq!(terminations.len(), 1);
    assert!(replays.is_empty());
    drop(old_sender);
    assert_eq!(
        conn.renderer_call_for_frontend_for_session_owner(None, 72),
        Some(old_correlation)
    );

    let termination_events = conn.terminate_prepared_renderer_calls_after_navigation(
        terminations,
        "Inspected target navigated or closed",
    );
    assert_eq!(termination_events.len(), 1);
    let response = termination_events[0]
        .protocol_message()
        .expect("sessionless termination should emit a frontend response");
    assert_eq!(response["id"], json!(72));
    assert!(response.get("sessionId").is_none());
    assert_eq!(response["error"]["code"], json!(-32000));
    assert!(
        conn.renderer_runtime_command_cause_for_frontend(None, 72)
            .is_none()
    );
}

#[test]
fn devtools_session_output_wrong_attachment_does_not_consume_live_correlation() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-attachment-race".to_owned());
    browser_context.set_active_target_id("TID-attachment-race".to_owned());
    browser_context.attach_active_session("SID-attachment-race".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let live_attachment = RendererAgentAttachmentId::allocate();
    let stale_attachment = RendererAgentAttachmentId::allocate();
    let correlation = register_devtools_session_response_for_test(
        &mut conn,
        "SID-attachment-race",
        70,
        live_attachment,
        r#"{"id":70,"method":"Runtime.evaluate","params":{"expression":"70"}}"#,
    );
    let response = || {
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": correlation.renderer_call_id().get(),
            "result": { "result": { "type": "number", "value": 70 } },
        }))
    };

    let mut stale_messages = vec![response()];
    conn.restore_frontend_command_ids_in_devtools_session_output_for_owner(
        &CommandOwnerScope::for_session("SID-attachment-race"),
        Some(stale_attachment),
        &mut stale_messages,
        true,
    );
    assert!(
        stale_messages.is_empty(),
        "a response from the retired attachment must be dropped"
    );
    assert!(
        conn.renderer_runtime_command_cause_for_frontend(Some("SID-attachment-race"), 70,)
            .is_some(),
        "the retired attachment must not consume the live correlation"
    );

    let mut live_messages = vec![response()];
    conn.restore_frontend_command_ids_in_devtools_session_output_for_owner(
        &CommandOwnerScope::for_session("SID-attachment-race"),
        Some(live_attachment),
        &mut live_messages,
        true,
    );
    let [RendererRuntimeInspectorMessage::Protocol(message)] = live_messages.as_slice() else {
        panic!("the live attachment must publish exactly one response");
    };
    assert_eq!(message.value()["id"], json!(70));
    assert!(
        conn.renderer_runtime_command_cause_for_frontend(Some("SID-attachment-race"), 70,)
            .is_none(),
        "the live attachment must consume the correlation exactly once"
    );
}

#[test]
fn devtools_session_output_keeps_first_of_duplicate_terminal_responses() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-duplicate-response".to_owned());
    browser_context.set_active_target_id("TID-duplicate-response".to_owned());
    browser_context.attach_active_session("SID-duplicate-response".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let attachment_id = RendererAgentAttachmentId::allocate();
    let correlation = register_devtools_session_response_for_test(
        &mut conn,
        "SID-duplicate-response",
        71,
        attachment_id,
        r#"{"id":71,"method":"Runtime.evaluate","params":{"expression":"71"}}"#,
    );
    let mut messages = vec![
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": correlation.renderer_call_id().get(),
            "result": { "result": { "type": "string", "value": "first" } },
        })),
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": correlation.renderer_call_id().get(),
            "result": { "result": { "type": "string", "value": "duplicate" } },
        })),
    ];

    conn.restore_frontend_command_ids_in_devtools_session_output_for_owner(
        &CommandOwnerScope::for_session("SID-duplicate-response"),
        Some(attachment_id),
        &mut messages,
        true,
    );

    let [RendererRuntimeInspectorMessage::Protocol(message)] = messages.as_slice() else {
        panic!("duplicate terminal responses must collapse to one frontend response");
    };
    assert_eq!(message.value()["id"], json!(71));
    assert_eq!(message.value()["result"]["result"]["value"], json!("first"));
}

#[test]
fn devtools_session_output_restores_interleaved_calls_without_reordering() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-interleaved-response".to_owned());
    browser_context.set_active_target_id("TID-interleaved-response".to_owned());
    browser_context.attach_active_session("SID-interleaved-response".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let attachment_id = RendererAgentAttachmentId::allocate();
    let first = register_devtools_session_response_for_test(
        &mut conn,
        "SID-interleaved-response",
        80,
        attachment_id,
        r#"{"id":80,"method":"Runtime.evaluate","params":{"expression":"80"}}"#,
    );
    let second = register_devtools_session_response_for_test(
        &mut conn,
        "SID-interleaved-response",
        81,
        attachment_id,
        r#"{"id":81,"method":"Runtime.evaluate","params":{"expression":"81"}}"#,
    );
    let mut messages = vec![
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": second.renderer_call_id().get(),
            "result": { "result": { "type": "number", "value": 81 } },
        })),
        RendererRuntimeInspectorMessage::protocol(json!({
            "method": "Debugger.scriptParsed",
            "params": { "scriptId": "interleaved" },
        })),
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": first.renderer_call_id().get(),
            "result": { "result": { "type": "number", "value": 80 } },
        })),
    ];

    conn.restore_frontend_command_ids_in_devtools_session_output_for_owner(
        &CommandOwnerScope::for_session("SID-interleaved-response"),
        Some(attachment_id),
        &mut messages,
        true,
    );

    assert_eq!(messages.len(), 3);
    let RendererRuntimeInspectorMessage::Protocol(second_response) = &messages[0] else {
        panic!("the second call response must remain first");
    };
    let RendererRuntimeInspectorMessage::Protocol(notification) = &messages[1] else {
        panic!("the notification must remain between the responses");
    };
    let RendererRuntimeInspectorMessage::Protocol(first_response) = &messages[2] else {
        panic!("the first call response must remain last");
    };
    assert_eq!(second_response.value()["id"], json!(81));
    assert_eq!(
        notification.value()["method"],
        json!("Debugger.scriptParsed")
    );
    assert_eq!(first_response.value()["id"], json!(80));
}

#[tokio::test]
async fn devtools_session_output_restores_only_the_exact_registered_frontend_response() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-session-output".to_owned());
    browser_context.set_active_target_id("TID-session-output".to_owned());
    browser_context.attach_active_session("SID-session-output".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let attachment_id = RendererAgentAttachmentId::allocate();
    let frontend = ParsedCdpCommand::parse_str(
            r#"{"id":44,"method":"Runtime.evaluate","params":{"expression":"({ answer: 42 })","objectGroup":"nested-main"}}"#,
        )
        .expect("frontend command should parse");
    let prepared = conn
        .try_register_renderer_call_for_session_owner(
            Some("SID-session-output"),
            44,
            Some(attachment_id),
            RendererCommandDescriptor::from_frontend_policy(
                frontend.json().to_owned(),
                frontend.renderer_policy(),
                RendererInspectorResponseDelivery::SessionSink,
            ),
        )
        .expect("frontend response correlation should register");
    let (correlation, response_sender, response_receiver) = prepared.into_parts();
    assert!(
        response_receiver.is_none(),
        "SessionSink delivery must not allocate an adapter-reply receiver"
    );
    drop(response_sender);
    let mut messages = vec![
        RendererRuntimeInspectorMessage::protocol(json!({
            "method": "Debugger.scriptParsed",
            "params": { "scriptId": "7" },
        })),
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": correlation.renderer_call_id().get(),
            "result": {
                "result": {
                    "type": "object",
                    "objectId": "nested-main-object"
                }
            },
        })),
        RendererRuntimeInspectorMessage::protocol(json!({
            "id": correlation.renderer_call_id().get() + 1,
            "result": { "scriptSource": "stale" },
        })),
    ];

    conn.restore_frontend_command_ids_in_devtools_session_output_for_owner(
        &CommandOwnerScope::for_session("SID-session-output"),
        Some(attachment_id),
        &mut messages,
        true,
    );

    assert_eq!(
        messages.len(),
        2,
        "stale renderer responses must be dropped"
    );
    let RendererRuntimeInspectorMessage::Protocol(response) = &messages[1] else {
        panic!("expected a protocol response");
    };
    assert_eq!(response.value()["id"], json!(44));
    assert_eq!(
        conn.runtime_remote_object_group_for_session_owner(
            Some("SID-session-output"),
            "nested-main-object",
        ),
        Some("nested-main".to_owned()),
        "session output must retain Runtime object ownership metadata",
    );
    assert!(
        conn.renderer_runtime_command_cause_for_frontend(Some("SID-session-output"), 44,)
            .is_none(),
        "publishing the session response must consume its exact correlation"
    );
}

#[test]
fn devtools_session_output_preserves_remote_object_group_projection() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-session-projection".to_owned());
    browser_context.set_active_target_id("TID-session-projection".to_owned());
    browser_context.attach_active_session("SID-session-projection".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let session_id = Some("SID-session-projection");
    let attachment_id = RendererAgentAttachmentId::allocate();

    conn.register_runtime_remote_object_ids_from_value_for_session_owner_with_group(
        session_id,
        &json!({ "objectId": "nested-parent-object" }),
        "nested-object-group",
    );

    let get_properties = ParsedCdpCommand::parse_str(
            r#"{"id":45,"method":"Runtime.getProperties","params":{"objectId":"nested-parent-object","ownProperties":true}}"#,
        )
        .expect("getProperties command should parse");
    let prepared = conn
        .try_register_renderer_call_for_session_owner(
            session_id,
            45,
            Some(attachment_id),
            RendererCommandDescriptor::from_frontend_policy(
                get_properties.json().to_owned(),
                get_properties.renderer_policy(),
                RendererInspectorResponseDelivery::SessionSink,
            ),
        )
        .expect("getProperties response correlation should register");
    let (correlation, response_sender, response_receiver) = prepared.into_parts();
    assert!(response_receiver.is_none());
    drop(response_sender);
    let mut messages = vec![RendererRuntimeInspectorMessage::protocol(json!({
        "id": correlation.renderer_call_id().get(),
        "result": {
            "result": [{
                "name": "child",
                "value": {
                    "type": "object",
                    "objectId": "nested-child-object"
                }
            }]
        },
    }))];
    conn.restore_frontend_command_ids_in_devtools_session_output_for_owner(
        &CommandOwnerScope::for_session("SID-session-projection"),
        Some(attachment_id),
        &mut messages,
        true,
    );
    assert_eq!(
        conn.runtime_remote_object_group_for_session_owner(session_id, "nested-child-object",),
        Some("nested-object-group".to_owned()),
        "getProperties results must inherit the receiver object's group",
    );
}

fn bidi_channel_listener_residence_for_test(
    conn: &CdpConnection,
    session_id: &str,
    channel: &str,
) -> BidiChannelListenerResidence {
    BidiChannelListenerResidence::new(
        BidiChannelPageOwner::capture_for_owner(conn, CommandOwnerScope::for_session(session_id))
            .expect("test Page attachment"),
        bidi_channel_listener_for_test(channel),
    )
}

fn deeply_nested_plain_value(mut value: Value, depth: usize) -> Value {
    for _ in 0..depth {
        value = json!({ "child": [value] });
    }
    value
}

fn run_deep_protocol_value_test(name: &'static str, test: impl FnOnce() + Send + 'static) {
    let result = std::thread::Builder::new()
        .name(name.to_owned())
        .stack_size(32 * 1024 * 1024)
        .spawn(test)
        .expect("large-stack protocol value test thread should spawn")
        .join();
    if let Err(payload) = result {
        std::panic::resume_unwind(payload);
    }
}

fn take_only_protocol_work(
    conn: &mut CdpConnection,
) -> crate::domains::activity::ProtocolSchedulerWork {
    let scheduler_events = conn.take_scheduler_events();
    let [CdpSchedulerEvent::ProtocolWorkPublished { work }] = <[_; 1]>::try_from(scheduler_events)
        .expect("test action must publish exactly one protocol work")
    else {
        unreachable!("array pattern fixes the only event kind")
    };
    work
}

#[test]
fn runtime_remote_object_ids_include_await_promise_handles() {
    let value = json!({
        "params": {
            "errorObjectId": "error-1",
            "promiseObjectId": "promise-1",
            "arguments": [{ "objectId": "arg-1" }]
        }
    });
    let object_ids = runtime_remote_object_ids_in_value(&value);

    assert_eq!(
        object_ids,
        vec![
            "arg-1".to_owned(),
            "error-1".to_owned(),
            "promise-1".to_owned()
        ],
        "Runtime object-owner validation must include objectId, promiseObjectId, and errorObjectId handles"
    );
    assert_eq!(
        runtime_remote_object_ids_in_map(
            value
                .as_object()
                .expect("the test protocol payload must be an object")
        ),
        object_ids,
        "validated object params must preserve the existing recursive handle scan"
    );
}

#[test]
fn runtime_remote_object_ids_respect_protocol_depth_cap() {
    run_deep_protocol_value_test("runtime-remote-object-ids-depth-cap", || {
        let object_ids = runtime_remote_object_ids_in_value(&deeply_nested_plain_value(
            json!({ "objectId": "too-deep" }),
            MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH + 8,
        ));

        assert!(object_ids.is_empty());
    });
}

#[test]
fn bidi_channel_listener_owner_work_publishes_concrete_scheduler_work() {
    let mut conn = connection_with_bidi_page_session();
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "wake");
    conn.publish_bidi_channel_listener_start(listener);

    let scheduler_events = conn.take_scheduler_events();
    let [CdpSchedulerEvent::ProtocolWorkPublished { work }] = scheduler_events.as_slice() else {
        panic!("listener start must publish one concrete protocol work: {scheduler_events:?}");
    };
    assert_eq!(
        work.kind(),
        crate::domains::activity::ProtocolSchedulerWorkKind::BidiChannelOwnerAction
    );
    assert_eq!(
        work.bidi_channel_owner_action_kind(),
        Some(BidiChannelOwnerActionKind::StartListener)
    );
    assert_eq!(work.publish_sequence().get(), 1);
}

#[test]
fn bidi_channel_actions_keep_causal_publication_order() {
    let mut conn = connection_with_bidi_page_session();
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "ordered");
    let owner = listener.owner().clone();
    conn.publish_bidi_channel_listener_start(listener);
    conn.publish_bidi_channel_object_group_release(owner, "webdriver-bidi-channel-ordered");
    let scheduler_events = conn.take_scheduler_events();
    let works = scheduler_events
        .iter()
        .map(|event| {
            let CdpSchedulerEvent::ProtocolWorkPublished { work } = event else {
                panic!("BiDi action must not fall back to source-shaped capture: {event:?}");
            };
            (
                work.publish_sequence().get(),
                work.bidi_channel_owner_action_kind(),
            )
        })
        .collect::<Vec<_>>();
    assert_eq!(
        works,
        vec![
            (1, Some(BidiChannelOwnerActionKind::StartListener)),
            (2, Some(BidiChannelOwnerActionKind::ReleaseObjectGroup)),
        ],
        "concrete actions must retain publication order instead of regrouping releases"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn document_node_snapshot_for_backend_node_id_reads_live_renderer_snapshot() {
    let mut ctx = TestContext::new();
    let mut browser_context = BrowserContext::new("BID-runtime-node-snapshot".to_owned());
    browser_context.set_active_target_id("TID-runtime-node-snapshot".to_owned());
    ctx.conn
        .install_browser_context_fixture_for_test(browser_context);
    ctx.install_navigation_fixture_for_session_owner(
        "data:text/html,<html><body><article id='target'>live</article></body></html>",
        None,
    )
    .await;
    ctx.sent.clear();

    ctx.process_async(json!({
        "id": 1,
        "method": "Runtime.evaluate",
        "params": { "expression": "document.querySelector('#target')" }
    }))
    .await;
    let evaluated = ctx.take_response_by_id(1);
    let object_id = evaluated["result"]["result"]["objectId"]
        .as_str()
        .map(str::to_owned)
        .unwrap_or_else(|| panic!("Runtime.evaluate should return target objectId: {evaluated}"));

    ctx.process_async(json!({
        "id": 2,
        "method": "DOM.describeNode",
        "params": { "objectId": object_id, "depth": 0 }
    }))
    .await;
    let described = ctx.take_response_by_id(2);
    let backend_node_id = described["result"]["node"]["backendNodeId"]
        .as_u64()
        .and_then(|node_id| u32::try_from(node_id).ok())
        .expect("DOM.describeNode should return backendNodeId");

    let owner = CommandOwnerScope::capture(&ctx.conn, None);
    let snapshot = ctx
        .conn
        .document_node_snapshot_for_backend_node_id_for_owner_async(
            &owner,
            backend_node_id,
            1,
            false,
        )
        .await
        .expect("document node id snapshot command should complete")
        .expect("target node snapshot should exist");
    assert_eq!(snapshot.snapshot.local_name, "article");
    assert!(
        snapshot
            .snapshot
            .attributes
            .iter()
            .any(|attribute| attribute.local_name == "id" && attribute.value == "target"),
        "snapshot should preserve target id attribute: {snapshot:?}"
    );
    let backend_node_id = snapshot
        .snapshot
        .backend_node_id
        .expect("renderer snapshot should assign backendNodeId");
    assert!(
        is_renderer_backend_node_id(backend_node_id),
        "node-id snapshot helper should return renderer backend id namespace: {snapshot:?}"
    );
    assert!(
        snapshot
            .snapshot
            .children
            .iter()
            .any(|child| child.node_value == "live"),
        "depth=1 snapshot should include text child: {snapshot:?}"
    );
}

#[test]
fn runtime_realm_inventory_conversion_keeps_context_without_native_realm_id() {
    let event = runtime_realm_info_to_execution_context_event(
        RendererRuntimeRealmInfo {
            context_id: 7,
            realm_id: None,
            frame_id: Some("FRAME-child".to_owned()),
            origin: "https://example.test".to_owned(),
            name: String::new(),
            is_default: true,
            context_type: "default".to_owned(),
            grant_universal_access: None,
        },
        Some("FRAME-owner"),
        None,
    )
    .expect("Script.getRealms must not fail when DevTools attaches after context creation");
    assert_eq!(event.context_id, Some(7));
    assert_eq!(
        event.frame_id.as_ref().map(|frame_id| frame_id.as_str()),
        Some("FRAME-child")
    );
    assert_eq!(
        event.realm_id, None,
        "protocol should not synthesize a realm id when renderer did not capture V8 uniqueId"
    );
}

#[test]
fn runtime_realm_inventory_conversion_uses_owner_frame_when_renderer_frame_is_missing() {
    let event = runtime_realm_info_to_execution_context_event(
        RendererRuntimeRealmInfo {
            context_id: 9,
            realm_id: Some("native-realm-9".to_owned()),
            frame_id: None,
            origin: "https://example.test".to_owned(),
            name: "https://example.test/page".to_owned(),
            is_default: true,
            context_type: "default".to_owned(),
            grant_universal_access: None,
        },
        Some("FRAME-owner"),
        Some(DevToolsTargetId::from("TARGET-1")),
    )
    .expect("native renderer realm ids should convert");
    assert_eq!(
        event.realm_id.as_ref().map(|realm_id| realm_id.as_str()),
        Some("TARGET-1:native-realm-9"),
        "external realm ids must include the target owner because native V8 uniqueIds are only unique within a renderer runtime"
    );
    assert_eq!(
        event.frame_id.as_ref().map(|frame_id| frame_id.as_str()),
        Some("FRAME-owner"),
        "owner frame is used only when renderer realm inventory has no per-realm frame id"
    );
    assert_eq!(
        event.target_id.as_ref().map(|target_id| target_id.as_str()),
        Some("TARGET-1")
    );
}

#[test]
fn route_inspector_notifications_strip_stale_session_id_without_current_session() {
    let mut conn = CdpConnection::default();
    let mut response_events = Vec::new();
    let mut background_events = Vec::new();

    let current_seen = conn.route_inspector_messages_into(
        vec![json!({
            "method": "Runtime.executionContextCreated",
            "sessionId": "STALE",
            "params": {
                "context": {
                    "id": 7,
                    "origin": "https://example.test",
                    "name": "",
                    "uniqueId": "realm-7",
                    "auxData": {
                        "isDefault": true,
                        "type": "default",
                        "frameId": "FRAME-1"
                    }
                }
            }
        })],
        None,
        None,
        &mut response_events,
        &mut background_events,
    );

    assert!(!current_seen);
    assert!(
        response_events.is_empty(),
        "inspector notifications must not be routed through command response output"
    );
    assert_eq!(background_events.len(), 1);
    assert!(
        background_events[0].protocol_message().is_none(),
        "runtime context notification should remain typed until wire projection"
    );
    let (message, automation_event) = background_events[0].clone().into_parts();
    assert!(matches!(
        automation_event,
        Some(AutomationEvent::RuntimeExecutionContextCreated(_))
    ));
    assert!(
        message.get("sessionId").is_none(),
        "notifications routed without a current session must not leak a stale sessionId"
    );
    assert_eq!(message["method"], json!("Runtime.executionContextCreated"));
    assert_eq!(message["params"]["context"]["id"], json!(7));
    assert_eq!(message["params"]["context"]["uniqueId"], json!("realm-7"));
}

#[test]
fn route_inspector_runtime_context_notifications_use_current_session() {
    let mut conn = CdpConnection::default();
    let mut response_events = Vec::new();
    let mut background_events = Vec::new();

    let current_seen = conn.route_inspector_messages_into(
        vec![
            json!({
                "method": "Runtime.executionContextDestroyed",
                "sessionId": "STALE",
                "params": {
                    "executionContextId": 7,
                    "executionContextUniqueId": "realm-7"
                }
            }),
            json!({
                "method": "Runtime.executionContextsCleared",
                "sessionId": "STALE",
                "params": {}
            }),
        ],
        None,
        Some("SID-1"),
        &mut response_events,
        &mut background_events,
    );

    assert!(!current_seen);
    assert!(
        response_events.is_empty(),
        "inspector notifications must not be routed through command response output"
    );
    assert_eq!(background_events.len(), 2);
    assert!(
        background_events[0].protocol_message().is_none(),
        "destroyed notification should remain typed until wire projection"
    );
    assert!(
        background_events[1].protocol_message().is_none(),
        "cleared notification should remain typed until wire projection"
    );
    let (destroyed, destroyed_automation_event) = background_events[0].clone().into_parts();
    let (cleared, cleared_automation_event) = background_events[1].clone().into_parts();
    assert!(matches!(
        destroyed_automation_event,
        Some(AutomationEvent::RuntimeExecutionContextDestroyed(_))
    ));
    assert!(matches!(
        cleared_automation_event,
        Some(AutomationEvent::RuntimeExecutionContextsCleared(_))
    ));
    assert_eq!(destroyed["sessionId"], json!("SID-1"));
    assert_eq!(
        destroyed["method"],
        json!("Runtime.executionContextDestroyed")
    );
    assert_eq!(destroyed["params"]["executionContextId"], json!(7));
    assert_eq!(
        destroyed["params"]["executionContextUniqueId"],
        json!("realm-7")
    );
    assert_eq!(cleared["sessionId"], json!("SID-1"));
    assert_eq!(cleared["method"], json!("Runtime.executionContextsCleared"));
    assert_eq!(cleared["params"], json!({}));
}

#[test]
fn pending_inspector_await_registry_scopes_entries_to_devtools_session() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-owner".to_owned());
    browser_context.set_active_target_id("TID-active".to_owned());
    browser_context.attach_active_session("SID-active".to_owned());
    browser_context.insert_page_target_host(PageTargetHost::with_url(
        "TID-bg".to_owned(),
        Some("SID-bg".to_owned()),
        "about:blank#bg".to_owned(),
    ));
    conn.install_browser_context_fixture_for_test(browser_context);

    conn.register_pending_inspector_await(1, Some("SID-active"));
    conn.register_pending_inspector_await(2, Some("SID-bg"));

    {
        let browser_context = conn.browser_context.as_ref().expect("browser context");
        assert!(
            browser_context.active_page_target().devtools_sessions
                [moli_page_types::DevToolsSessionKey::Primary]
                .has_pending_inspector_awaits(),
            "active DevTools session should physically store its pending await"
        );
        assert!(
            browser_context
                .background_target("TID-bg")
                .filter(|target| target.has_non_default_session_state())
                .is_some_and(|state| state.devtools_sessions
                    [moli_page_types::DevToolsSessionKey::Primary]
                    .has_pending_inspector_awaits()),
            "background DevTools session should physically store its pending await"
        );
    }

    assert!(conn.has_pending_inspector_awaits_for_session_owner(Some("SID-active")));
    assert!(conn.has_pending_inspector_awaits_for_session_owner(Some("SID-bg")));

    let mut direct_events = Vec::new();
    let mut claimed_events = Vec::new();
    conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
        &mut direct_events,
        &mut claimed_events,
        Some("SID-active"),
        "Page closed",
    );
    assert!(claimed_events.is_empty());
    assert_eq!(direct_events.len(), 1);
    let (message, automation_event) = direct_events.remove(0).into_parts();
    assert!(automation_event.is_none());
    assert_eq!(message["id"], json!(1));
    assert_eq!(message["sessionId"], json!("SID-active"));

    assert!(!conn.has_pending_inspector_awaits_for_session_owner(Some("SID-active")));
    assert!(conn.has_pending_inspector_awaits_for_session_owner(Some("SID-bg")));

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    let seen = conn.route_inspector_messages_into(
        vec![json!({
            "id": 2,
            "result": { "result": { "type": "string", "value": "bg" } }
        })],
        None,
        Some("SID-bg"),
        &mut response_events,
        &mut background_events,
    );
    assert!(background_events.is_empty());
    assert!(!seen);
    assert_eq!(response_events.len(), 1);
    let message = response_events[0]
        .protocol_message()
        .expect("owner routed response should carry protocol message");
    assert_eq!(message["id"], json!(2));
    assert_eq!(message["sessionId"], json!("SID-bg"));
    assert!(!conn.has_pending_inspector_awaits());
}

#[test]
fn same_pending_inspector_await_id_is_isolated_by_devtools_session() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-same-id".to_owned());
    browser_context.set_active_target_id("TID-active".to_owned());
    browser_context.attach_active_session("SID-active".to_owned());
    browser_context.insert_page_target_host(PageTargetHost::with_url(
        "TID-bg".to_owned(),
        Some("SID-bg".to_owned()),
        "about:blank#bg".to_owned(),
    ));
    conn.install_browser_context_fixture_for_test(browser_context);

    conn.register_pending_inspector_await(1, Some("SID-active"));
    conn.register_pending_inspector_await(1, Some("SID-bg"));
    conn.register_runtime_await_job_for_owner(
        1,
        &CommandOwnerScope::for_session("SID-active"),
        None,
        "evaluate",
    );
    conn.register_runtime_await_job_for_owner(
        1,
        &CommandOwnerScope::for_session("SID-bg"),
        None,
        "evaluate",
    );

    assert_eq!(conn.pending_runtime_await_jobs.len(), 2);
    let claimed = conn
        .claim_pending_inspector_await_for_scheduler_deferred_reply(
            1,
            &CommandOwnerScope::for_session("SID-active"),
        )
        .expect("active session await should be independently claimable");
    assert!(conn.has_claimed_pending_inspector_awaits_for_session_owner(Some("SID-active")));
    assert!(!conn.has_unclaimed_pending_inspector_awaits_for_session_owner(Some("SID-active")));
    assert!(conn.has_unclaimed_pending_inspector_awaits_for_session_owner(Some("SID-bg")));

    conn.cancel_claimed_pending_inspector_await_for_scheduler_deferred_reply(
        Some(claimed),
        "forgotten",
    );
    assert!(!conn.has_pending_inspector_awaits_for_session_owner(Some("SID-active")));
    assert!(conn.has_pending_inspector_awaits_for_session_owner(Some("SID-bg")));
    assert_eq!(conn.pending_runtime_await_jobs.len(), 1);
    assert_eq!(
        conn.runtime_await_job_trace_fields(1, Some("SID-bg"))["sessionId"],
        json!("SID-bg")
    );

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    let stale_session_seen = conn.route_inspector_messages_into(
        vec![json!({
            "id": 1,
            "result": { "result": { "type": "string", "value": "stale" } }
        })],
        None,
        Some("SID-active"),
        &mut response_events,
        &mut background_events,
    );
    assert!(!stale_session_seen);
    assert!(response_events.is_empty());
    assert!(background_events.is_empty());
    assert!(conn.has_pending_inspector_awaits_for_session_owner(Some("SID-bg")));
    assert_eq!(conn.pending_runtime_await_jobs.len(), 1);

    let background_seen = conn.route_inspector_messages_into(
        vec![json!({
            "id": 1,
            "result": { "result": { "type": "string", "value": "bg" } }
        })],
        Some(1),
        Some("SID-bg"),
        &mut response_events,
        &mut background_events,
    );
    assert!(background_seen);
    assert!(background_events.is_empty());
    assert_eq!(response_events.len(), 1);
    let message = response_events[0]
        .protocol_message()
        .expect("background response should remain a protocol response");
    assert_eq!(message["id"], json!(1));
    assert_eq!(message["sessionId"], json!("SID-bg"));
    assert!(!conn.has_pending_inspector_awaits());
    assert!(conn.pending_runtime_await_jobs.is_empty());
}

#[test]
fn failed_await_registration_does_not_discard_existing_renderer_owner() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-duplicate-owner".to_owned());
    browser_context.set_active_target_id("TID-duplicate-owner".to_owned());
    browser_context.attach_active_session("SID-duplicate-owner".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let original = conn
        .try_register_renderer_call_for_session_owner(
            Some("SID-duplicate-owner"),
            17,
            None,
            renderer_command_descriptor_for_test(17),
        )
        .expect("first renderer command should own the frontend id")
        .correlation();
    conn.try_register_pending_inspector_await_with_object_group_for_owner(
        17,
        &CommandOwnerScope::for_session("SID-duplicate-owner"),
        None,
    )
    .expect("await state is registered before renderer dispatch");
    assert_eq!(
        conn.try_register_renderer_call_for_session_owner(
            Some("SID-duplicate-owner"),
            17,
            None,
            renderer_command_descriptor_for_test(17),
        )
        .unwrap_err(),
        "Duplicate `id` in protocol request"
    );

    conn.forget_pending_inspector_await(17, Some("SID-duplicate-owner"));

    assert_eq!(
        conn.take_renderer_call_for_frontend_for_session_owner(Some("SID-duplicate-owner"), 17,),
        Some(original),
        "failed await dispatch must not consume the older command's correlation"
    );
}

#[test]
fn bidi_listener_cancellation_discards_correlation_registered_first() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-listener-cancel".to_owned());
    browser_context.set_active_target_id("TID-listener-cancel".to_owned());
    browser_context.attach_active_session("SID-listener-cancel".to_owned());
    browser_context
        .active_page_target_mut()
        .runtime_slot
        .set_page_attachment_id_for_test(1);
    conn.install_browser_context_fixture_for_test(browser_context);

    conn.try_register_renderer_call_for_session_owner(
        Some("SID-listener-cancel"),
        23,
        Some(RendererAgentAttachmentId::allocate()),
        renderer_command_descriptor_for_test(23),
    )
    .expect("listener renderer command should register before listener ownership");
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-listener-cancel", "cancel");
    conn.register_pending_bidi_channel_listener(23, Some("SID-listener-cancel"), listener);

    let mut direct_events = Vec::new();
    let mut claimed_events = Vec::new();
    conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
        &mut direct_events,
        &mut claimed_events,
        Some("SID-listener-cancel"),
        "Page navigated",
    );

    assert!(direct_events.is_empty());
    assert!(claimed_events.is_empty());
    assert!(
        conn.try_register_renderer_call_for_session_owner(
            Some("SID-listener-cancel"),
            23,
            None,
            renderer_command_descriptor_for_test(23),
        )
        .is_ok(),
        "listener cancellation must release the frontend command id"
    );
}

#[test]
fn non_await_cancellation_releases_frontend_command_id() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-command-cancel".to_owned());
    browser_context.set_active_target_id("TID-command-cancel".to_owned());
    browser_context.attach_active_session("SID-command-cancel".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    conn.try_register_renderer_call_for_session_owner(
        Some("SID-command-cancel"),
        29,
        None,
        renderer_command_descriptor_for_test(29),
    )
    .expect("non-await command should register a renderer correlation");

    conn.forget_pending_inspector_await(29, Some("SID-command-cancel"));

    assert!(
        conn.try_register_renderer_call_for_session_owner(
            Some("SID-command-cancel"),
            29,
            None,
            renderer_command_descriptor_for_test(29),
        )
        .is_ok(),
        "cancelled non-await command must release the frontend command id"
    );
}

#[tokio::test]
async fn terminal_session_cleanup_completes_non_await_once_and_releases_frontend_id() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-terminal".to_owned());
    browser_context.set_active_target_id("TID-terminal".to_owned());
    browser_context.attach_active_session("SID-terminal".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let attachment = RendererAgentAttachmentId::allocate();
    let prepared = conn
        .try_register_renderer_call_for_session_owner(
            Some("SID-terminal"),
            31,
            Some(attachment),
            RendererCommandDescriptor::from_synthesized_payload(
                json!({
                    "id": 31,
                    "method": "Console.clearMessages",
                    "params": {},
                })
                .to_string(),
            )
            .unwrap(),
        )
        .expect("non-await command should register");
    let (correlation, old_sender, response_receiver) = prepared.into_parts();
    let response_receiver = response_receiver
        .expect("a synthesized AdapterReply call must allocate a response receiver");

    let mut direct_events = Vec::new();
    let mut claimed_events = Vec::new();
    conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
        &mut direct_events,
        &mut claimed_events,
        Some("SID-terminal"),
        "Inspector detached",
    );

    assert!(claimed_events.is_empty());
    assert_eq!(direct_events.len(), 1);
    let (message, automation_event) = direct_events.remove(0).into_parts();
    assert!(automation_event.is_none());
    assert_eq!(message["id"], json!(31));
    assert_eq!(message["sessionId"], json!("SID-terminal"));
    assert_eq!(message["error"]["code"], json!(-32000));
    assert_eq!(message["error"]["message"], json!("Inspector detached"));
    assert!(
        old_sender
            .send(json!({
                "id": correlation.renderer_call_id().get(),
                "result": {},
            }))
            .is_err(),
        "terminal transition must invalidate the renderer's old response lease"
    );

    let completion = response_receiver
        .await
        .expect("terminal transition should complete the shared receiver");
    assert_eq!(completion.renderer_agent_attachment_id(), None);
    let terminal = completion
        .output
        .protocol_response(completion.call_id)
        .expect("terminal response payload");
    assert_eq!(terminal["error"]["code"], json!(-32000));
    assert_eq!(terminal["error"]["message"], json!("Inspector detached"));
    assert!(
        conn.try_register_renderer_call_for_session_owner(
            Some("SID-terminal"),
            31,
            None,
            renderer_command_descriptor_for_test(31),
        )
        .is_ok(),
        "terminal cleanup must release the frontend command id"
    );
}

#[test]
fn pending_inspector_await_response_routes_through_owner_runtime_response() {
    let mut conn = CdpConnection::default();
    let mut browser_context = BrowserContext::new("BID-owner-output".to_owned());
    browser_context.set_active_target_id("TID-active".to_owned());
    browser_context.attach_active_session("SID-active".to_owned());
    browser_context.insert_page_target_host(PageTargetHost::with_url(
        "TID-bg".to_owned(),
        Some("SID-bg".to_owned()),
        "about:blank#bg".to_owned(),
    ));
    conn.install_browser_context_fixture_for_test(browser_context);

    conn.try_register_pending_inspector_await_with_object_group_for_owner(
        77,
        &CommandOwnerScope::for_session("SID-bg"),
        Some("runtime-group"),
    )
    .unwrap();
    conn.register_runtime_await_job_for_owner(
        77,
        &CommandOwnerScope::for_session("SID-bg"),
        Some("runtime-group"),
        "evaluate",
    );

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    let seen = conn.route_inspector_messages_with_background_events_into(
        vec![json!({
            "id": 77,
            "result": {
                "result": {
                    "type": "object",
                    "objectId": "object-bg-1"
                }
            }
        })],
        Some(77),
        Some("SID-bg"),
        &mut response_events,
        &mut background_events,
    );

    assert!(
        seen,
        "matching owner runtime response should complete the current command"
    );
    assert!(
        background_events.is_empty(),
        "plain Runtime.evaluate response should not become a side event"
    );
    assert_eq!(response_events.len(), 1);
    let message = response_events[0]
        .protocol_message()
        .expect("owner routed response should carry protocol message");
    assert_eq!(message["id"], json!(77));
    assert_eq!(message["sessionId"], json!("SID-bg"));
    assert!(
        !conn.has_pending_inspector_awaits(),
        "owner runtime response should consume pending inspector await state"
    );
    assert_eq!(
        conn.runtime_remote_object_group_for_session_owner(Some("SID-bg"), "object-bg-1"),
        Some("runtime-group".to_owned()),
        "owner runtime response should register handles against the producing owner"
    );
}

#[tokio::test]
async fn failing_pending_awaits_retire_concrete_listener_work_without_client_error() {
    let mut conn = connection_with_bidi_page_session();

    conn.register_pending_inspector_await(1, Some("SID-active"));
    conn.register_runtime_remote_object_ids_for_session_owner_with_group(
        Some("SID-active"),
        vec!["channel-proxy".to_owned()],
        "webdriver-bidi-channel-test",
    );
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "test");
    conn.register_pending_bidi_channel_listener(2, Some("SID-active"), listener.clone());
    conn.publish_bidi_channel_listener_start(listener);
    let held_listener_work = take_only_protocol_work(&mut conn);

    conn.runtime_session_owner_slot_mut(Some("SID-active"))
        .expect("test runtime slot")
        .replace_page_attachment_id_for_test();

    let mut direct_events = Vec::new();
    let mut claimed_events = Vec::new();
    conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
        &mut direct_events,
        &mut claimed_events,
        Some("SID-active"),
        "Page navigated",
    );

    assert!(claimed_events.is_empty());
    assert_eq!(direct_events.len(), 1);
    let (message, automation_event) = direct_events.remove(0).into_parts();
    assert!(automation_event.is_none());
    assert_eq!(message["id"], json!(1));
    assert_eq!(message["sessionId"], json!("SID-active"));
    assert!(!conn.has_pending_inspector_awaits_for_session_owner(Some("SID-active")));
    assert!(
        conn.runtime_remote_object_group_for_session_owner(Some("SID-active"), "channel-proxy")
            .is_none(),
        "invalidated BiDi listener should remove its channel object group"
    );
    let outcome = conn
        .complete_ready_protocol_scheduler_work_turn(held_listener_work)
        .await;
    assert!(
        outcome.into_parts().0.is_empty(),
        "stale concrete listener work must not produce protocol output"
    );
    assert!(
        !conn.has_pending_inspector_awaits_for_session_owner(Some("SID-active")),
        "held listener work must not enter the replacement Page runtime"
    );

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    let seen = conn.route_inspector_messages_with_background_events_into(
        vec![json!({
            "id": 2,
            "result": { "result": { "type": "string", "value": "late" } }
        })],
        None,
        Some("SID-active"),
        &mut response_events,
        &mut background_events,
    );
    assert!(!seen);
    assert!(
        response_events.is_empty(),
        "stale listener reply must not surface as a protocol message: {response_events:?}"
    );
    assert!(
        background_events.is_empty(),
        "stale listener reply must not surface as script.message"
    );
}

#[tokio::test]
async fn failed_bidi_listener_reply_publishes_concrete_object_group_release() {
    let mut conn = connection_with_bidi_page_session();
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "error");
    conn.register_runtime_remote_object_ids_for_session_owner_with_group(
        Some("SID-active"),
        vec!["channel-proxy-error".to_owned()],
        "webdriver-bidi-channel-error",
    );
    conn.register_pending_bidi_channel_listener(7, Some("SID-active"), listener);

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    let seen = conn.route_inspector_messages_with_background_events_into(
        vec![json!({
            "id": 7,
            "error": {
                "code": -32000,
                "message": "Cannot find context with specified id"
            }
        })],
        None,
        Some("SID-active"),
        &mut response_events,
        &mut background_events,
    );

    assert!(!seen);
    assert!(response_events.is_empty());
    assert!(background_events.is_empty());
    let work = take_only_protocol_work(&mut conn);
    assert_eq!(
        work.bidi_channel_owner_action_kind(),
        Some(BidiChannelOwnerActionKind::ReleaseObjectGroup)
    );
    conn.complete_ready_protocol_scheduler_work_turn(work).await;
    assert!(
        conn.runtime_remote_object_group_for_session_owner(
            Some("SID-active"),
            "channel-proxy-error"
        )
        .is_none(),
        "the concrete release must own and consume the listener's object group"
    );
}

#[tokio::test]
async fn stale_bidi_object_group_release_does_not_mutate_replacement_page_state() {
    let mut conn = connection_with_bidi_page_session();
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "stale-release");
    conn.register_pending_bidi_channel_listener(8, Some("SID-active"), listener);

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    conn.route_inspector_messages_with_background_events_into(
        vec![json!({
            "id": 8,
            "error": {
                "code": -32000,
                "message": "Cannot find context with specified id"
            }
        })],
        None,
        Some("SID-active"),
        &mut response_events,
        &mut background_events,
    );
    let work = take_only_protocol_work(&mut conn);

    conn.runtime_session_owner_slot_mut(Some("SID-active"))
        .expect("test runtime slot")
        .replace_page_attachment_id_for_test();
    conn.register_runtime_remote_object_ids_for_session_owner_with_group(
        Some("SID-active"),
        vec!["replacement-object".to_owned()],
        "webdriver-bidi-channel-stale-release",
    );

    conn.complete_ready_protocol_scheduler_work_turn(work).await;

    assert_eq!(
        conn.runtime_remote_object_group_for_session_owner(
            Some("SID-active"),
            "replacement-object"
        ),
        Some("webdriver-bidi-channel-stale-release".to_owned()),
        "an old release must not touch an identically named group in the replacement Page"
    );
}

#[test]
fn stale_bidi_listener_reply_does_not_emit_or_restart_on_replacement_page() {
    let mut conn = connection_with_bidi_page_session();
    let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "stale-reply");
    conn.register_pending_bidi_channel_listener(9, Some("SID-active"), listener);

    conn.runtime_session_owner_slot_mut(Some("SID-active"))
        .expect("test runtime slot")
        .replace_page_attachment_id_for_test();
    conn.register_runtime_remote_object_ids_for_session_owner_with_group(
        Some("SID-active"),
        vec!["replacement-object".to_owned()],
        "webdriver-bidi-channel-stale-reply",
    );

    let mut response_events = Vec::new();
    let mut background_events = Vec::new();
    let seen = conn.route_inspector_messages_with_background_events_into(
        vec![json!({
            "id": 9,
            "result": {
                "result": {
                    "type": "string",
                    "value": "late message"
                }
            }
        })],
        None,
        Some("SID-active"),
        &mut response_events,
        &mut background_events,
    );

    assert!(!seen);
    assert!(
        response_events.is_empty() && background_events.is_empty(),
        "a stale listener reply must not emit script.message: response={response_events:?}, background={background_events:?}"
    );
    assert!(
        conn.take_scheduler_events().is_empty(),
        "a stale listener reply must not restart itself on the replacement Page"
    );
    assert_eq!(
        conn.runtime_remote_object_group_for_session_owner(
            Some("SID-active"),
            "replacement-object"
        ),
        Some("webdriver-bidi-channel-stale-reply".to_owned()),
        "discarding the old reply must not clean up replacement runtime state"
    );
}

#[test]
fn bidi_listener_result_handles_stay_in_user_object_group() {
    let listener = PendingBidiChannelListener::new(
        Some(DevToolsTargetId::from("TID-active")),
        Some(crate::automation::DevToolsRealmId::from("realm-active")),
        crate::automation::DevToolsRemoteHandleId::from("channel-proxy"),
        "webdriver-bidi-channel-infra".to_owned(),
        crate::automation::DevToolsBidiChannelProperties {
            channel: "preload".to_owned(),
            ownership: DevToolsResultOwnership::Root,
            serialization_options: None,
        },
    )
    .expect("test listener should include target and realm");

    let command: Value =
        serde_json::from_str(&bidi_channel_listener_call_function_json(9, &listener))
            .expect("listener command should serialize as JSON");

    assert_eq!(command["params"]["objectId"], json!("channel-proxy"));
    assert_eq!(command["params"]["objectGroup"], json!("webdriver-bidi"));
    assert_ne!(
        command["params"]["objectGroup"],
        json!(listener.channel_object_group()),
        "script.message data handles must not be tied to the channel infra group"
    );
}

#[test]
fn bidi_listener_uses_deep_serialization_additional_parameters() {
    let listener = PendingBidiChannelListener::new(
        Some(DevToolsTargetId::from("TID-active")),
        Some(crate::automation::DevToolsRealmId::from("realm-active")),
        crate::automation::DevToolsRemoteHandleId::from("channel-proxy"),
        "webdriver-bidi-channel-infra".to_owned(),
        crate::automation::DevToolsBidiChannelProperties {
            channel: "preload".to_owned(),
            ownership: DevToolsResultOwnership::None,
            serialization_options: Some(crate::automation::DevToolsSerializationOptions {
                max_object_depth: Some(1),
                max_dom_depth: Some(2),
                include_shadow_tree: Some("open".to_owned()),
            }),
        },
    )
    .expect("test listener should include target and realm");

    let command: Value =
        serde_json::from_str(&bidi_channel_listener_call_function_json(9, &listener))
            .expect("listener command should serialize as JSON");

    assert_eq!(
        command["params"]["serializationOptions"]["serialization"],
        json!("deep")
    );
    assert_eq!(
        command["params"]["serializationOptions"]["maxDepth"],
        json!(1)
    );
    assert_eq!(
        command["params"]["serializationOptions"]["additionalParameters"]["maxNodeDepth"],
        json!(2)
    );
    assert_eq!(
        command["params"]["serializationOptions"]["additionalParameters"]["includeShadowTree"],
        json!("open")
    );
}