Skip to content

armgit / moli

Public Imported from GitHub
0

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

65.2 KB
Raw Blame
use super::*;

#[tokio::test]
async fn websocket_cdp_file_navigation_returns_stable_error_without_events_or_replacement() {
    let (cdp_addr, cdp_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect browser CDP websocket");
    let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
    let target = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;

    let _ = send_cdp_command(
        &mut socket,
        4,
        "Page.enable",
        Some(&target.session_id),
        json!({}),
    )
    .await;
    let _ = send_cdp_command(
        &mut socket,
        5,
        "Network.enable",
        Some(&target.session_id),
        json!({}),
    )
    .await;

    let rejected = send_cdp_command(
        &mut socket,
        6,
        "Page.navigate",
        Some(&target.session_id),
        json!({ "url": "file:///moli-policy-must-not-open" }),
    )
    .await;
    let response = rejected
        .iter()
        .find(|message| message["id"] == json!(6_u64))
        .expect("rejected Page.navigate response");
    assert_eq!(response["sessionId"], json!(target.session_id));
    assert_eq!(response["error"]["code"], json!(-32000));
    assert_eq!(
        response["error"]["message"],
        json!("Navigation to a local file URL requires an explicitly granted browser capability.")
    );
    assert!(
        rejected.iter().all(|message| {
            !matches!(
                message["method"].as_str(),
                Some("Page.frameStartedNavigating")
                    | Some("Page.frameStartedLoading")
                    | Some("Page.domContentEventFired")
                    | Some("Page.loadEventFired")
                    | Some("Network.requestWillBeSent")
                    | Some("Network.loadingFailed")
            )
        }),
        "rejected file navigation must not emit CDP load events: {rejected:?}"
    );

    let location_messages = send_cdp_command(
        &mut socket,
        7,
        "Runtime.evaluate",
        Some(&target.session_id),
        json!({
            "expression": "location.href",
            "returnByValue": true
        }),
    )
    .await;
    assert!(
        location_messages.iter().all(|message| {
            !matches!(
                message["method"].as_str(),
                Some("Page.frameStartedNavigating")
                    | Some("Page.frameStartedLoading")
                    | Some("Page.domContentEventFired")
                    | Some("Page.loadEventFired")
                    | Some("Network.requestWillBeSent")
                    | Some("Network.loadingFailed")
            )
        }),
        "rejected file navigation must not leak delayed CDP events: {location_messages:?}"
    );
    let location = location_messages
        .iter()
        .find(|message| message["id"] == json!(7_u64))
        .expect("Runtime.evaluate location response");
    assert_eq!(location["result"]["result"]["value"], json!("about:blank"));

    let _ = send_cdp_command(
        &mut socket,
        8,
        "Target.closeTarget",
        None,
        json!({ "targetId": target.target_id }),
    )
    .await;
    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
}

#[tokio::test]
async fn websocket_cdp_localstorage_profile_persists_across_server_restart() {
    let profile = TempDir::new("localstorage-profile");
    let paths = BrowserProfilePaths::new(&profile.path);
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to profiled cdp websocket");
    let page_url = format!("http://{fixture_addr}/page");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let write = cdp_runtime_evaluate_string(
        &mut socket,
        &session_id,
        6,
        "localStorage.clear(); sessionStorage.clear(); localStorage.setItem('persisted', 'yes'); sessionStorage.setItem('ephemeral', 'yes'); 'ok'",
    )
    .await;
    assert_eq!(write, "ok");
    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;

    let persisted = std::fs::read_to_string(&paths.local_storage_path)
        .expect("profiled localStorage json should be written");
    assert!(
        persisted.contains("\"persisted\"") && persisted.contains("\"yes\""),
        "profile file should contain persisted localStorage entry: {persisted}"
    );

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("reconnect to profiled cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let read = cdp_runtime_evaluate_string(
        &mut socket,
        &session_id,
        6,
        "`${localStorage.getItem('persisted')}|${String(sessionStorage.getItem('ephemeral'))}`",
    )
    .await;
    assert_eq!(read, "yes|null");

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_imported_cookies_with_profile_dir_persist_across_server_restart() {
    let profile = TempDir::new("imported-cookie-profile");
    let paths = BrowserProfilePaths::new(&profile.path);
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_url = format!("http://{fixture_addr}/page");
    let mut imported = stored_cookie("session", "fixture");
    imported.domain = fixture_addr.ip().to_string();
    imported.host_only = true;

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server_with_cookie_profile(
        profile.path.clone(),
        vec![imported],
    )
    .await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to profiled cdp websocket with imported cookies");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let read_imported =
        cdp_runtime_evaluate_string(&mut socket, &session_id, 6, "document.cookie").await;
    assert!(
        read_imported.contains("session=fixture"),
        "default context should see imported cookie: {read_imported}"
    );
    let _ = socket.close(None).await;
    let persisted = wait_for_cookie_profile(&paths.cookies_path, |cookies| {
        cookies
            .iter()
            .any(|cookie| cookie.name == "session" && cookie.value == "fixture")
    })
    .await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;
    assert!(
        persisted
            .iter()
            .any(|cookie| cookie.name == "session" && cookie.value == "fixture"),
        "profile should contain imported cookie after socket shutdown: {persisted:?}"
    );

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("reconnect to profiled cdp websocket without imported cookies");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let read_profile =
        cdp_runtime_evaluate_string(&mut socket, &session_id, 6, "document.cookie").await;
    assert!(
        read_profile.contains("session=fixture"),
        "default context should restore imported cookie from profile: {read_profile}"
    );

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_indexeddb_profile_persists_across_server_restart() {
    let profile = TempDir::new("indexeddb-profile");
    let paths = BrowserProfilePaths::new(&profile.path);
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_url = format!("http://{fixture_addr}/page");

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to profiled cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let write = cdp_runtime_evaluate_string(
        &mut socket,
        &session_id,
        6,
        r#"
(() => {
  globalThis.__idbProfileWrite = "pending";
  const open = indexedDB.open("profile-db", 1);
  open.onerror = () => {
    globalThis.__idbProfileWrite = `open-error:${open.error && open.error.name}`;
  };
  open.onupgradeneeded = () => {
    open.result.createObjectStore("kv");
  };
  open.onsuccess = () => {
    const db = open.result;
    const tx = db.transaction("kv", "readwrite");
    const put = tx.objectStore("kv").put("persisted", "answer");
    put.onerror = () => {
      globalThis.__idbProfileWrite = `put-error:${put.error && put.error.name}`;
    };
    tx.oncomplete = () => {
      db.close();
      globalThis.__idbProfileWrite = "stored";
    };
    tx.onerror = () => {
      globalThis.__idbProfileWrite = `tx-error:${tx.error && tx.error.name}`;
    };
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(write, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &session_id,
        7,
        "String(globalThis.__idbProfileWrite)",
        "stored",
    )
    .await;
    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;

    assert!(
        std::fs::read_dir(&paths.indexeddb_root)
            .expect("profiled IndexedDB root should exist")
            .next()
            .is_some(),
        "profiled IndexedDB root should contain persisted origin data"
    );

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("reconnect to profiled cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let read = cdp_runtime_evaluate_string(
        &mut socket,
        &session_id,
        8,
        r#"
(() => {
  globalThis.__idbProfileRead = "pending";
  const open = indexedDB.open("profile-db", 1);
  open.onerror = () => {
    globalThis.__idbProfileRead = `open-error:${open.error && open.error.name}`;
  };
  open.onsuccess = () => {
    const db = open.result;
    const tx = db.transaction("kv", "readonly");
    const get = tx.objectStore("kv").get("answer");
    get.onsuccess = () => {
      globalThis.__idbProfileRead = String(get.result);
    };
    get.onerror = () => {
      globalThis.__idbProfileRead = `get-error:${get.error && get.error.name}`;
    };
    tx.oncomplete = () => db.close();
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(read, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &session_id,
        9,
        "String(globalThis.__idbProfileRead)",
        "persisted",
    )
    .await;

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_clear_data_for_origin_indexeddb_persists_across_server_restart() {
    let profile = TempDir::new("indexeddb-clear-data-origin-profile");
    let paths = BrowserProfilePaths::new(&profile.path);
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_origin = format!("http://{fixture_addr}");
    let page_url = format!("{page_origin}/page");

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to profiled cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let write = cdp_runtime_evaluate_string(
        &mut socket,
        &session_id,
        6,
        r#"
(() => {
  globalThis.__idbClearWrite = "pending";
  const open = indexedDB.open("profile-clear-db", 1);
  open.onerror = () => {
    globalThis.__idbClearWrite = `open-error:${open.error && open.error.name}`;
  };
  open.onupgradeneeded = () => {
    open.result.createObjectStore("kv");
  };
  open.onsuccess = () => {
    const db = open.result;
    const tx = db.transaction("kv", "readwrite");
    const put = tx.objectStore("kv").put("persisted", "answer");
    put.onerror = () => {
      globalThis.__idbClearWrite = `put-error:${put.error && put.error.name}`;
    };
    tx.oncomplete = () => {
      db.close();
      globalThis.__idbClearWrite = "stored";
    };
    tx.onerror = () => {
      globalThis.__idbClearWrite = `tx-error:${tx.error && tx.error.name}`;
    };
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(write, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &session_id,
        7,
        "String(globalThis.__idbClearWrite)",
        "stored",
    )
    .await;

    let clear = send_cdp_command(
        &mut socket,
        8,
        "Storage.clearDataForOrigin",
        Some(&session_id),
        json!({
            "origin": page_origin,
            "storageTypes": "indexeddb",
        }),
    )
    .await;
    let clear_response = clear
        .iter()
        .find(|message| message["id"] == json!(8_u64))
        .expect("clearDataForOrigin response");
    assert_eq!(clear_response["result"], json!({}));

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;

    let (cdp_addr, cdp_server) = spawn_profiled_test_protocol_server(profile.path.clone()).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("reconnect to profiled cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(&mut socket, &page_url).await;
    let read = cdp_runtime_evaluate_string(
        &mut socket,
        &session_id,
        9,
        r#"
(() => {
  globalThis.__idbClearRead = "pending";
  let oldVersion = "no-upgrade";
  const open = indexedDB.open("profile-clear-db", 1);
  open.onerror = () => {
    globalThis.__idbClearRead = `open-error:${open.error && open.error.name}`;
  };
  open.onupgradeneeded = (event) => {
    oldVersion = String(event.oldVersion);
    open.result.createObjectStore("fresh");
  };
  open.onsuccess = () => {
    const db = open.result;
    globalThis.__idbClearRead = [
      oldVersion,
      String(db.objectStoreNames.contains("kv")),
      String(db.objectStoreNames.contains("fresh"))
    ].join("|");
    db.close();
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(read, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &session_id,
        10,
        "String(globalThis.__idbClearRead)",
        "0|false|true",
    )
    .await;

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_cookie_profile_delete_commands_persist_across_server_restart() {
    for command in [
        ProfileCookieDeleteCommand::NetworkClearBrowserCookies,
        ProfileCookieDeleteCommand::StorageClearCookies,
        ProfileCookieDeleteCommand::StorageDeleteCookies,
        ProfileCookieDeleteCommand::StorageClearDataForOrigin,
    ] {
        assert_profile_cookie_delete_command_persists_across_restart(command).await;
    }
}

#[tokio::test]
async fn websocket_cdp_ephemeral_context_cookie_changes_do_not_clear_cookie_profile() {
    let profile = TempDir::new("ephemeral-cookie-profile");
    let paths = BrowserProfilePaths::new(&profile.path);
    cookie_cache::save_cookie_cache(&paths.cookies_path, vec![stored_cookie("sid", "profile")])
        .expect("seed cookie profile");

    let (cdp_addr, cdp_server) =
        spawn_profiled_test_protocol_server_with_cookie_profile(profile.path.clone(), Vec::new())
            .await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to profiled cdp websocket");

    let context_id = cdp_create_browser_context(&mut socket, 1).await;
    let cookies = send_cdp_command(
        &mut socket,
        2,
        "Storage.getCookies",
        None,
        json!({ "browserContextId": context_id }),
    )
    .await;
    assert!(
        cookies.iter().any(|message| {
            message["id"] == json!(2_u64) && message["result"]["cookies"] == json!([])
        }),
        "ephemeral context should not inherit profile cookies: {cookies:?}"
    );

    let _ = socket.close(None).await;
    sleep(Duration::from_millis(100)).await;
    abort_test_cdp_server(cdp_server).await;
    wait_for_profile_lock_release(&paths).await;

    let persisted = cookie_cache::load_cookie_cache(&paths.cookies_path)
        .expect("profile cookie cache should survive ephemeral-only connection");
    assert_eq!(persisted.len(), 1);
    assert_eq!(persisted[0].name, "sid");
    assert_eq!(persisted[0].value, "profile");
}

#[tokio::test]
async fn websocket_cdp_browser_contexts_isolate_localstorage() {
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_url = format!("http://{fixture_addr}/page");
    let (cdp_addr, cdp_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    let context_a = cdp_create_browser_context(&mut socket, 1).await;
    let context_b = cdp_create_browser_context(&mut socket, 2).await;
    let target_a = cdp_create_attached_target(&mut socket, 3, &context_a).await;
    let target_b = cdp_create_attached_target(&mut socket, 5, &context_b).await;
    cdp_navigate_and_wait_for_load(&mut socket, 7, &target_a.session_id, &page_url).await;
    cdp_navigate_and_wait_for_load(&mut socket, 8, &target_b.session_id, &page_url).await;

    let write = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        9,
        "localStorage.clear(); localStorage.setItem('ctx', 'a'); 'ok'",
    )
    .await;
    assert_eq!(write, "ok");

    let read_a = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        10,
        "String(localStorage.getItem('ctx'))",
    )
    .await;
    assert_eq!(read_a, "a");
    let read_b = cdp_runtime_evaluate_string(
        &mut socket,
        &target_b.session_id,
        11,
        "String(localStorage.getItem('ctx'))",
    )
    .await;
    assert_eq!(read_b, "null");

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_same_context_targets_share_localstorage_and_isolate_sessionstorage() {
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_url = format!("http://{fixture_addr}/page");
    let (cdp_addr, cdp_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    let context_id = cdp_create_browser_context(&mut socket, 1).await;
    let target_a = cdp_create_attached_target(&mut socket, 2, &context_id).await;
    let target_b = cdp_create_attached_target(&mut socket, 4, &context_id).await;
    cdp_navigate_and_wait_for_load(&mut socket, 6, &target_a.session_id, &page_url).await;
    cdp_navigate_and_wait_for_load(&mut socket, 7, &target_b.session_id, &page_url).await;

    let write = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        8,
        "localStorage.clear(); sessionStorage.clear(); localStorage.setItem('shared', 'yes'); sessionStorage.setItem('target', 'a'); 'ok'",
    )
    .await;
    assert_eq!(write, "ok");

    let read_b = cdp_runtime_evaluate_string(
        &mut socket,
        &target_b.session_id,
        9,
        "`${localStorage.getItem('shared')}|${String(sessionStorage.getItem('target'))}`",
    )
    .await;
    assert_eq!(read_b, "yes|null");

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_browser_contexts_isolate_cookies_sessionstorage_and_indexeddb() {
    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_url = format!("http://{fixture_addr}/page");
    let (cdp_addr, cdp_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    let context_a = cdp_create_browser_context(&mut socket, 1).await;
    let context_b = cdp_create_browser_context(&mut socket, 2).await;
    let target_a = cdp_create_attached_target(&mut socket, 3, &context_a).await;
    let target_b = cdp_create_attached_target(&mut socket, 5, &context_b).await;
    cdp_navigate_and_wait_for_load(&mut socket, 7, &target_a.session_id, &page_url).await;
    cdp_navigate_and_wait_for_load(&mut socket, 8, &target_b.session_id, &page_url).await;

    let write_cookie_and_session = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        9,
        "document.cookie = 'ctxcookie=a; path=/'; sessionStorage.setItem('ctx', 'a'); 'ok'",
    )
    .await;
    assert_eq!(write_cookie_and_session, "ok");

    let write_idb = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        10,
        r#"
(() => {
  globalThis.__idbContextWrite = "pending";
  const open = indexedDB.open("ctx-db", 1);
  open.onerror = () => {
    globalThis.__idbContextWrite = `open-error:${open.error && open.error.name}`;
  };
  open.onupgradeneeded = () => {
    open.result.createObjectStore("kv");
  };
  open.onsuccess = () => {
    const db = open.result;
    const tx = db.transaction("kv", "readwrite");
    const put = tx.objectStore("kv").put("a", "ctx");
    put.onerror = () => {
      globalThis.__idbContextWrite = `put-error:${put.error && put.error.name}`;
    };
    tx.oncomplete = () => {
      db.close();
      globalThis.__idbContextWrite = "stored";
    };
    tx.onerror = () => {
      globalThis.__idbContextWrite = `tx-error:${tx.error && tx.error.name}`;
    };
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(write_idb, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &target_a.session_id,
        11,
        "String(globalThis.__idbContextWrite)",
        "stored",
    )
    .await;

    let read_a = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        12,
        "`${document.cookie.includes('ctxcookie=a')}|${sessionStorage.getItem('ctx')}`",
    )
    .await;
    assert_eq!(read_a, "true|a");
    let read_b = cdp_runtime_evaluate_string(
        &mut socket,
        &target_b.session_id,
        13,
        "`${document.cookie.includes('ctxcookie=a')}|${String(sessionStorage.getItem('ctx'))}`",
    )
    .await;
    assert_eq!(read_b, "false|null");

    let cookies_a = send_cdp_command(
        &mut socket,
        14,
        "Storage.getCookies",
        None,
        json!({ "browserContextId": context_a }),
    )
    .await;
    assert!(
        cookies_a.iter().any(|message| {
            message["id"] == json!(14_u64)
                && message["result"]["cookies"]
                    .as_array()
                    .is_some_and(|cookies| {
                        cookies.iter().any(|cookie| {
                            cookie["name"] == json!("ctxcookie") && cookie["value"] == json!("a")
                        })
                    })
        }),
        "context A Storage.getCookies should see ctxcookie: {cookies_a:?}"
    );
    let cookies_b = send_cdp_command(
        &mut socket,
        15,
        "Storage.getCookies",
        None,
        json!({ "browserContextId": context_b }),
    )
    .await;
    assert!(
        cookies_b.iter().any(|message| {
            message["id"] == json!(15_u64) && message["result"]["cookies"] == json!([])
        }),
        "context B Storage.getCookies should not see context A cookie: {cookies_b:?}"
    );

    let read_idb_a = cdp_runtime_evaluate_string(
        &mut socket,
        &target_a.session_id,
        16,
        r#"
(() => {
  globalThis.__idbContextReadA = "pending";
  const open = indexedDB.open("ctx-db", 1);
  open.onerror = () => {
    globalThis.__idbContextReadA = `open-error:${open.error && open.error.name}`;
  };
  open.onsuccess = () => {
    const db = open.result;
    const tx = db.transaction("kv", "readonly");
    const get = tx.objectStore("kv").get("ctx");
    get.onsuccess = () => {
      globalThis.__idbContextReadA = String(get.result);
    };
    get.onerror = () => {
      globalThis.__idbContextReadA = `get-error:${get.error && get.error.name}`;
    };
    tx.oncomplete = () => db.close();
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(read_idb_a, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &target_a.session_id,
        17,
        "String(globalThis.__idbContextReadA)",
        "a",
    )
    .await;

    let read_idb_b = cdp_runtime_evaluate_string(
        &mut socket,
        &target_b.session_id,
        18,
        r#"
(() => {
  globalThis.__idbContextReadB = "pending";
  const open = indexedDB.open("ctx-db", 1);
  open.onerror = () => {
    globalThis.__idbContextReadB = `open-error:${open.error && open.error.name}`;
  };
  open.onupgradeneeded = () => {
    globalThis.__idbContextReadB = "missing";
  };
  open.onsuccess = () => {
    const db = open.result;
    if (!db.objectStoreNames.contains("kv")) {
      db.close();
      globalThis.__idbContextReadB = "missing";
      return;
    }
    const tx = db.transaction("kv", "readonly");
    const get = tx.objectStore("kv").get("ctx");
    get.onsuccess = () => {
      globalThis.__idbContextReadB = String(get.result);
    };
    get.onerror = () => {
      globalThis.__idbContextReadB = `get-error:${get.error && get.error.name}`;
    };
    tx.oncomplete = () => db.close();
  };
  return "scheduled";
})()
"#,
    )
    .await;
    assert_eq!(read_idb_b, "scheduled");
    wait_for_cdp_runtime_string(
        &mut socket,
        &target_b.session_id,
        19,
        "String(globalThis.__idbContextReadB)",
        "missing",
    )
    .await;

    let _ = socket.close(None).await;
    abort_test_cdp_server(cdp_server).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_clear_browser_cache_clears_configured_http_cache_dir() {
    let nonce = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system clock should be after epoch")
        .as_nanos();
    let cache_dir = std::env::temp_dir().join(format!(
        "moli-cdp-http-cache-clear-{}-{nonce}",
        std::process::id()
    ));
    let entry_dir = cache_dir.join("0123456789abcdef.entry");
    fs::create_dir_all(&entry_dir).expect("cache entry dir should be created");
    fs::write(entry_dir.join("body.test.bin"), b"cached")
        .expect("cache body fixture should be written");
    fs::write(cache_dir.join("owner.lock"), b"keep")
        .expect("unrelated cache root file should be written");

    let mut fetch_config = FetchConfig::default();
    fetch_config.set_http_cache_dir(Some(cache_dir.display().to_string()));

    let (fixture_addr, fixture_server) = spawn_local_storage_fixture_server().await;
    let page_url = format!("http://{fixture_addr}/page");
    let (cdp_addr, protocol_server) =
        spawn_test_protocol_server_with_fetch_config(fetch_config).await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");
    let session_id = cdp_create_session_and_navigate(&mut socket, &page_url).await;

    socket
        .send(WsMessage::Text(
            json!({
                "id": 6_u64,
                "method": "Network.clearBrowserCache",
                "sessionId": session_id,
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send clearBrowserCache");
    let clear_response = recv_until_id(&mut socket, 6).await;
    assert!(
        clear_response
            .iter()
            .any(|message| message["id"] == json!(6_u64) && message["result"] == json!({})),
        "clearBrowserCache should succeed: {clear_response:?}"
    );

    assert!(!entry_dir.exists());
    assert!(cache_dir.join("owner.lock").exists());

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
    fixture_server.abort();
    let _ = fs::remove_dir_all(cache_dir);
}

#[tokio::test]
async fn websocket_cdp_create_isolated_world_resolves_during_about_blank_prewarm() {
    // Regression test for the createIsolatedWorld fast-ack defer path.
    // When createIsolatedWorld arrives while the about:blank prewarm
    // started by createTarget is still in flight, the handler must
    // return an empty reply set immediately and the deferred task must
    // produce a valid executionContextId once the prewarm resolves.
    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    socket
        .send(WsMessage::Text(
            json!({ "id": 1_u64, "method": "Target.createBrowserContext" })
                .to_string()
                .into(),
        ))
        .await
        .expect("send createBrowserContext");
    let create_browser_context = recv_until_id(&mut socket, 1).await;
    let browser_context_id = create_browser_context
        .iter()
        .find(|message| message["id"] == json!(1_u64))
        .and_then(|message| message["result"]["browserContextId"].as_str())
        .expect("browserContextId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 2_u64,
                "method": "Target.createTarget",
                "params": {
                    "browserContextId": browser_context_id,
                    "url": "about:blank"
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send createTarget");
    let create_target = recv_until_id(&mut socket, 2).await;
    let target_id = create_target
        .iter()
        .find(|message| message["id"] == json!(2_u64))
        .and_then(|message| message["result"]["targetId"].as_str())
        .expect("targetId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 3_u64,
                "method": "Target.attachToTarget",
                "params": { "targetId": target_id, "flatten": true }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send attachToTarget");
    let attach = recv_until_id(&mut socket, 3).await;
    let session_id = attach
        .iter()
        .find(|message| message["id"] == json!(3_u64))
        .and_then(|message| message["result"]["sessionId"].as_str())
        .expect("sessionId")
        .to_owned();

    // Send Page.createIsolatedWorld immediately — the about:blank
    // prewarm kicked off by createTarget is still in flight on the
    // renderer thread. The handler should defer and the socket loop
    // should drain the deferred completion when the prewarm resolves.
    socket
        .send(WsMessage::Text(
            json!({
                "id": 4_u64,
                "method": "Page.createIsolatedWorld",
                "sessionId": session_id,
                "params": {
                    "frameId": target_id,
                    "worldName": "utility-deferred"
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send createIsolatedWorld");
    let created = recv_until_id(&mut socket, 4).await;
    let response = created
        .iter()
        .find(|message| message["id"] == json!(4_u64))
        .expect("createIsolatedWorld response");
    assert_eq!(response["sessionId"].as_str(), Some(session_id.as_str()));
    let execution_context_id = response["result"]["executionContextId"]
        .as_i64()
        .expect("executionContextId from deferred createIsolatedWorld");
    assert!(
        execution_context_id != 0,
        "executionContextId should be non-zero, got {execution_context_id}"
    );

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
}

#[tokio::test]
async fn websocket_cdp_create_isolated_world_during_prewarm_then_close_target_does_not_panic() {
    // Race test: createIsolatedWorld arrives during prewarm, then
    // closeTarget is sent before the prewarm resolves. The deferred
    // completion must be silently dropped (target no longer current)
    // and the socket must remain healthy enough to reply to the close.
    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    socket
        .send(WsMessage::Text(
            json!({ "id": 1_u64, "method": "Target.createBrowserContext" })
                .to_string()
                .into(),
        ))
        .await
        .expect("send createBrowserContext");
    let create_browser_context = recv_until_id(&mut socket, 1).await;
    let browser_context_id = create_browser_context
        .iter()
        .find(|message| message["id"] == json!(1_u64))
        .and_then(|message| message["result"]["browserContextId"].as_str())
        .expect("browserContextId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 2_u64,
                "method": "Target.createTarget",
                "params": {
                    "browserContextId": browser_context_id,
                    "url": "about:blank"
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send createTarget");
    let create_target = recv_until_id(&mut socket, 2).await;
    let target_id = create_target
        .iter()
        .find(|message| message["id"] == json!(2_u64))
        .and_then(|message| message["result"]["targetId"].as_str())
        .expect("targetId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 3_u64,
                "method": "Target.attachToTarget",
                "params": { "targetId": target_id, "flatten": true }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send attachToTarget");
    let attach = recv_until_id(&mut socket, 3).await;
    let session_id = attach
        .iter()
        .find(|message| message["id"] == json!(3_u64))
        .and_then(|message| message["result"]["sessionId"].as_str())
        .expect("sessionId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 4_u64,
                "method": "Page.createIsolatedWorld",
                "sessionId": session_id,
                "params": {
                    "frameId": target_id,
                    "worldName": "utility-pre-close"
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send createIsolatedWorld");

    socket
        .send(WsMessage::Text(
            json!({
                "id": 5_u64,
                "method": "Target.closeTarget",
                "params": { "targetId": target_id }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send closeTarget");
    // Wait for the closeTarget reply. The createIsolatedWorld deferred
    // completion may or may not have arrived first; either way the
    // socket must remain healthy and not panic.
    let _ = recv_until_match(&mut socket, |message| message["id"] == json!(5_u64)).await;

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
}

#[tokio::test]
async fn websocket_cdp_debugger_pause_interrupts_in_flight_runtime_evaluate() {
    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(
        &mut socket,
        "data:text/html,<body>debugger pause</body>",
    )
    .await;

    let enabled = send_cdp_command(
        &mut socket,
        6,
        "Debugger.enable",
        Some(&session_id),
        json!({}),
    )
    .await;
    assert!(
        enabled
            .iter()
            .any(|message| message["id"] == json!(6_u64) && message.get("error").is_none()),
        "Debugger.enable should succeed: {enabled:#?}"
    );

    // Local Chromium and V8's inspector tests acknowledge Debugger.pause
    // before the next JavaScript statement enters the nested pause loop.
    let pause = send_cdp_command(
        &mut socket,
        7,
        "Debugger.pause",
        Some(&session_id),
        json!({}),
    )
    .await;
    assert!(
        pause.iter().all(|message| {
            message["sessionId"].as_str() != Some(session_id.as_str())
                || message["method"] != json!("Debugger.paused")
        }),
        "Debugger.paused must not precede the Debugger.pause response: {pause:#?}"
    );

    socket
        .send(WsMessage::Text(
            json!({
                "id": 8_u64,
                "method": "Runtime.evaluate",
                "sessionId": session_id,
                "params": {
                    "expression": "globalThis.__moliDebuggerPauseProbe = 1",
                    "returnByValue": true,
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send Runtime.evaluate that enters the debugger pause");
    let paused = recv_until_match(&mut socket, |message| {
        message["sessionId"].as_str() == Some(session_id.as_str())
            && message["method"] == json!("Debugger.paused")
    })
    .await;
    assert!(
        paused.iter().all(|message| message["id"] != json!(8_u64)),
        "Runtime.evaluate must not complete before Debugger.paused: {paused:#?}"
    );

    let mut resumed = send_cdp_command(
        &mut socket,
        9,
        "Debugger.resume",
        Some(&session_id),
        json!({}),
    )
    .await;
    if resumed.iter().all(|message| message["id"] != json!(8_u64)) {
        resumed
            .extend(recv_until_match(&mut socket, |message| message["id"] == json!(8_u64)).await);
    }
    assert!(
        resumed.iter().any(|message| {
            message["id"] == json!(8_u64) && message["result"]["result"]["value"] == json!(1_u64)
        }),
        "Debugger.resume should release the pending Runtime.evaluate: {resumed:#?}"
    );

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
}

#[tokio::test]
async fn websocket_cdp_io_terminate_interrupts_busy_main_thread_and_skips_main_follower() {
    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");
    let session_id = cdp_create_default_session_and_navigate(
        &mut socket,
        "data:text/html,<body>IO interrupt</body>",
    )
    .await;

    let enabled = send_cdp_command(
        &mut socket,
        6,
        "Debugger.enable",
        Some(&session_id),
        json!({}),
    )
    .await;
    assert!(
        enabled
            .iter()
            .any(|message| message["id"] == json!(6_u64) && message.get("error").is_none()),
        "Debugger.enable should succeed: {enabled:#?}"
    );

    socket
        .send(WsMessage::Text(
            json!({
                "id": 7_u64,
                "method": "Runtime.evaluate",
                "sessionId": session_id,
                "params": {
                    "expression": "debugger; for (;;) {}",
                    "returnByValue": true,
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send the non-yielding MainThread Runtime.evaluate");
    let mut observed = recv_until_match(&mut socket, |message| {
        message["sessionId"].as_str() == Some(session_id.as_str())
            && message["method"] == json!("Debugger.paused")
    })
    .await;
    assert!(
        observed.iter().all(|message| message["id"] != json!(7_u64)),
        "the busy Runtime.evaluate must still be in flight at its debugger barrier: {observed:#?}"
    );

    observed.extend(
        send_cdp_command(
            &mut socket,
            8,
            "Debugger.resume",
            Some(&session_id),
            json!({}),
        )
        .await,
    );
    if observed.iter().all(|message| {
        message["sessionId"].as_str() != Some(session_id.as_str())
            || message["method"] != json!("Debugger.resumed")
    }) {
        observed.extend(
            recv_until_match(&mut socket, |message| {
                message["sessionId"].as_str() == Some(session_id.as_str())
                    && message["method"] == json!("Debugger.resumed")
            })
            .await,
        );
    }
    assert!(
        observed.iter().all(|message| message["id"] != json!(7_u64)),
        "the resumed Runtime.evaluate must enter its non-yielding loop: {observed:#?}"
    );

    // This MainThread follower is deliberately queued before the IO command.
    // An interrupt callback must skip it, dispatch terminateExecution, and
    // leave the follower for ordinary owner dispatch after V8 unwinds.
    socket
        .send(WsMessage::Text(
            json!({
                "id": 9_u64,
                "method": "Runtime.evaluate",
                "sessionId": session_id,
                "params": {
                    "expression": "6 * 7",
                    "returnByValue": true,
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("queue the MainThread follower");
    let terminated = tokio::time::timeout(
        Duration::from_secs(10),
        send_cdp_command(
            &mut socket,
            10,
            "Runtime.terminateExecution",
            Some(&session_id),
            json!({}),
        ),
    )
    .await
    .expect("IO terminateExecution must interrupt non-yielding MainThread JavaScript");
    observed.extend(terminated);

    let mut saw_busy_response = observed.iter().any(|message| message["id"] == json!(7_u64));
    let mut saw_follower_response = observed.iter().any(|message| message["id"] == json!(9_u64));
    if !saw_busy_response || !saw_follower_response {
        observed.extend(
            recv_until_match(&mut socket, |message| {
                saw_busy_response |= message["id"] == json!(7_u64);
                saw_follower_response |= message["id"] == json!(9_u64);
                saw_busy_response && saw_follower_response
            })
            .await,
        );
    }

    let terminate_response = observed
        .iter()
        .find(|message| message["id"] == json!(10_u64))
        .expect("terminateExecution response");
    assert_eq!(
        terminate_response["result"],
        json!({}),
        "terminateExecution must complete through the IO V8 interrupt: {observed:#?}"
    );
    let busy_response = observed
        .iter()
        .find(|message| message["id"] == json!(7_u64))
        .expect("terminated Runtime.evaluate response");
    assert!(
        busy_response.get("error").is_some()
            || busy_response["result"]["exceptionDetails"].is_object(),
        "the non-yielding evaluation must report termination: {busy_response:#?}"
    );
    let follower_response = observed
        .iter()
        .find(|message| message["id"] == json!(9_u64))
        .expect("MainThread follower response");
    assert_eq!(
        follower_response["result"]["result"]["value"],
        json!(42),
        "the skipped MainThread follower must run normally after termination: {observed:#?}"
    );
    let terminate_response_index = observed
        .iter()
        .position(|message| message["id"] == json!(10_u64))
        .expect("terminateExecution response position");
    let follower_response_index = observed
        .iter()
        .position(|message| message["id"] == json!(9_u64))
        .expect("MainThread follower response position");
    assert!(
        terminate_response_index < follower_response_index,
        "the MainThread follower must not first-dispatch ahead of IO termination: {observed:#?}"
    );

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
}

#[tokio::test]
async fn websocket_cdp_active_js_interrupt_preserves_main_and_io_lanes_across_sessions() {
    let entered_busy_loop = Arc::new(tokio::sync::Notify::new());
    let entered_busy_loop_route = Arc::clone(&entered_busy_loop);
    let fixture_app = Router::new()
        .route(
            "/",
            get(|| async {
                (
                    [(header::CONTENT_TYPE.as_str(), "text/html")],
                    "<!doctype html><html><body>active JavaScript interrupt</body></html>",
                )
            }),
        )
        .route(
            "/entered",
            get(move || {
                let entered_busy_loop = Arc::clone(&entered_busy_loop_route);
                async move {
                    entered_busy_loop.notify_one();
                    "entered"
                }
            }),
        );
    let (fixture_addr, _fixture_server) =
        spawn_dedicated_fixture_server(fixture_app, "active-js-interrupt");

    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");
    let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
    let primary = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;
    let _ = send_cdp_command(
        &mut socket,
        4,
        "Runtime.enable",
        Some(&primary.session_id),
        json!({}),
    )
    .await;
    let _ = cdp_navigate_and_wait_for_load(
        &mut socket,
        5,
        &primary.session_id,
        &format!("http://{fixture_addr}/"),
    )
    .await;

    let attached_session_response = send_cdp_command(
        &mut socket,
        6,
        "Target.attachToTarget",
        None,
        json!({ "targetId": primary.target_id, "flatten": true }),
    )
    .await;
    let attached_session_id = attached_session_response
        .iter()
        .find(|message| message["id"] == json!(6_u64))
        .and_then(|message| message["result"]["sessionId"].as_str())
        .expect("attached session id")
        .to_owned();
    for (id, method, session_id) in [
        (7, "Debugger.enable", primary.session_id.as_str()),
        (8, "Runtime.enable", attached_session_id.as_str()),
        (9, "Debugger.enable", attached_session_id.as_str()),
    ] {
        let enabled = send_cdp_command(&mut socket, id, method, Some(session_id), json!({})).await;
        assert!(
            enabled
                .iter()
                .any(|message| message["id"] == json!(id) && message.get("error").is_none()),
            "{method} should succeed before the active-JS matrix: {enabled:#?}"
        );
    }

    let busy_source = r#"const xhr = new XMLHttpRequest();
xhr.open('GET', '/entered', false);
xhr.send();
console.log('moli-active-js-loop-entered');
for (;;) {}"#;
    let compiled = send_cdp_command(
        &mut socket,
        10,
        "Runtime.compileScript",
        Some(&primary.session_id),
        json!({
            "expression": busy_source,
            "sourceURL": "moli-active-js-interrupt.js",
            "persistScript": true,
        }),
    )
    .await;
    let script_id = compiled
        .iter()
        .find(|message| message["id"] == json!(10_u64))
        .and_then(|message| message["result"]["scriptId"].as_str())
        .unwrap_or_else(|| panic!("Runtime.compileScript should return scriptId: {compiled:#?}"))
        .to_owned();

    send_cdp_command_without_wait(
        &mut socket,
        11,
        "Runtime.runScript",
        Some(&primary.session_id),
        json!({ "scriptId": script_id }),
    )
    .await;
    timeout(Duration::from_secs(5), entered_busy_loop.notified())
        .await
        .expect("compiled JavaScript should complete its synchronous external witness");

    // These Main commands are queued on a different DevTools session while
    // the primary session owns the renderer in non-yielding JavaScript.
    send_cdp_command_without_wait(
        &mut socket,
        12,
        "Runtime.evaluate",
        Some(&attached_session_id),
        json!({
            "expression": "(globalThis.__moliMainLane ??= []).push('m1')",
            "returnByValue": true,
        }),
    )
    .await;
    send_cdp_command_without_wait(
        &mut socket,
        13,
        "Runtime.evaluate",
        Some(&attached_session_id),
        json!({
            "expression": "globalThis.__moliMainLane.push('m2')",
            "returnByValue": true,
        }),
    )
    .await;
    let mut observed = recv_cdp_messages_for(&mut socket, Duration::from_millis(250)).await;
    assert!(
        observed
            .iter()
            .all(|message| !matches!(message["id"].as_u64(), Some(11..=13))),
        "the active script and its Main followers must remain blocked before IO arrives: \
         {observed:#?}"
    );

    // All three commands use the attached session's IO lane. The two source
    // lookups prove FIFO before terminateExecution releases the Main owner.
    for (id, method, params) in [
        (
            14,
            "Debugger.getScriptSource",
            json!({ "scriptId": script_id }),
        ),
        (
            15,
            "Debugger.getScriptSource",
            json!({ "scriptId": script_id }),
        ),
        (16, "Runtime.terminateExecution", json!({})),
    ] {
        send_cdp_command_without_wait(&mut socket, id, method, Some(&attached_session_id), params)
            .await;
    }

    let expected_ids = [11_u64, 12, 13, 14, 15, 16];
    let mut response_ids = observed
        .iter()
        .filter_map(|message| message["id"].as_u64())
        .collect::<std::collections::BTreeSet<_>>();
    observed.extend(
        recv_until_match(&mut socket, |message| {
            if let Some(id) = message["id"].as_u64() {
                response_ids.insert(id);
            }
            expected_ids
                .iter()
                .all(|expected_id| response_ids.contains(expected_id))
        })
        .await,
    );

    for id in expected_ids {
        assert_eq!(
            observed
                .iter()
                .filter(|message| message["id"] == json!(id))
                .count(),
            1,
            "each command must produce exactly one response (id {id}): {observed:#?}"
        );
    }
    for id in [14_u64, 15] {
        let response = observed
            .iter()
            .find(|message| message["id"] == json!(id))
            .expect("getScriptSource response");
        assert_eq!(
            response["result"]["scriptSource"],
            json!(busy_source),
            "IO source lookup {id} must reach the live attached Inspector session: \
             {observed:#?}"
        );
    }
    let position = |id| {
        observed
            .iter()
            .position(|message| message["id"] == json!(id))
            .unwrap_or_else(|| panic!("missing response position for id {id}: {observed:#?}"))
    };
    assert!(
        position(14) < position(15) && position(15) < position(16),
        "same-session IO commands must first-dispatch FIFO: {observed:#?}"
    );
    assert!(
        position(16) < position(12) && position(12) < position(13),
        "IO may overtake Main, but the attached Main lane must remain FIFO: {observed:#?}"
    );
    assert_eq!(
        observed
            .iter()
            .find(|message| message["id"] == json!(16_u64))
            .expect("terminateExecution response")["result"],
        json!({}),
        "terminateExecution must complete through a true V8 interrupt: {observed:#?}"
    );
    let busy_response = observed
        .iter()
        .find(|message| message["id"] == json!(11_u64))
        .expect("terminated runScript response");
    assert!(
        busy_response.get("error").is_some()
            || busy_response["result"]["exceptionDetails"].is_object(),
        "the active Runtime.runScript must report termination: {busy_response:#?}"
    );
    assert!(
        observed.iter().any(|message| {
            message["sessionId"].as_str() == Some(primary.session_id.as_str())
                && message["method"] == json!("Runtime.consoleAPICalled")
                && message["params"]["args"][0]["value"] == json!("moli-active-js-loop-entered")
        }),
        "the buffered console witness must prove JavaScript passed XHR and entered the loop: \
         {observed:#?}"
    );
    for (id, value) in [(12_u64, 1_u64), (13, 2)] {
        assert_eq!(
            observed
                .iter()
                .find(|message| message["id"] == json!(id))
                .expect("Main follower response")["result"]["result"]["value"],
            json!(value),
            "Main follower {id} must execute once and in order: {observed:#?}"
        );
    }

    let recovered = send_cdp_command(
        &mut socket,
        17,
        "Runtime.evaluate",
        Some(&primary.session_id),
        json!({
            "expression": "globalThis.__moliMainLane.join(',')",
            "returnByValue": true,
        }),
    )
    .await;
    assert!(
        recovered.iter().any(|message| {
            message["id"] == json!(17_u64) && message["result"]["result"]["value"] == json!("m1,m2")
        }),
        "the isolate and owner must recover with exactly-once Main state: {recovered:#?}"
    );

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
}

#[tokio::test]
async fn websocket_cdp_raw_client_runtime_evaluate_immediately_after_page_navigate_succeeds() {
    // Regression test for the raw-CDP race: a raw client can pipeline
    // `Runtime.evaluate` directly behind `Page.navigate` without waiting for a
    // lifecycle event. The scheduler must finish the in-flight navigation
    // before dispatching evaluate; otherwise it observes `NoDocumentLoaded`.
    async fn page() -> impl IntoResponse {
        (
            [(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
            "<!doctype html><html><body><a id='link' href='/next'>link</a></body></html>",
        )
    }
    let fixture_app = Router::new().route("/", get(page));
    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, fixture_app).await });
    let fixture_url = format!("http://{fixture_addr}/");

    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    socket
        .send(WsMessage::Text(
            json!({ "id": 1_u64, "method": "Target.createBrowserContext" })
                .to_string()
                .into(),
        ))
        .await
        .expect("send createBrowserContext");
    let create_browser_context = recv_until_id(&mut socket, 1).await;
    let browser_context_id = create_browser_context
        .iter()
        .find(|message| message["id"] == json!(1_u64))
        .and_then(|message| message["result"]["browserContextId"].as_str())
        .expect("browserContextId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 2_u64,
                "method": "Target.createTarget",
                "params": { "browserContextId": browser_context_id, "url": "about:blank" }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send createTarget");
    let create_target = recv_until_id(&mut socket, 2).await;
    let target_id = create_target
        .iter()
        .find(|message| message["id"] == json!(2_u64))
        .and_then(|message| message["result"]["targetId"].as_str())
        .expect("targetId")
        .to_owned();

    socket
        .send(WsMessage::Text(
            json!({
                "id": 3_u64,
                "method": "Target.attachToTarget",
                "params": { "targetId": target_id, "flatten": true }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send attachToTarget");
    let attach = recv_until_id(&mut socket, 3).await;
    let session_id = attach
        .iter()
        .find(|message| message["id"] == json!(3_u64))
        .and_then(|message| message["result"]["sessionId"].as_str())
        .expect("sessionId")
        .to_owned();

    // Send Page.navigate then Runtime.evaluate back-to-back without
    // waiting for any lifecycle event. This mirrors what raw-CDP clients
    // do. The socket loop must drain the pending background navigation
    // completion BEFORE dispatching Runtime.evaluate, otherwise evaluate
    // would observe `NoDocumentLoaded`.
    socket
        .send(WsMessage::Text(
            json!({
                "id": 4_u64,
                "method": "Page.navigate",
                "sessionId": session_id,
                "params": { "url": fixture_url }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send Page.navigate");
    socket
        .send(WsMessage::Text(
            json!({
                "id": 5_u64,
                "method": "Runtime.evaluate",
                "sessionId": session_id,
                "params": {
                    "expression": "document.querySelector('#link') ? document.querySelector('#link').textContent : ''",
                    "returnByValue": true
                }
            })
            .to_string()
            .into(),
        ))
        .await
        .expect("send Runtime.evaluate");

    let messages = recv_until_id(&mut socket, 5).await;
    let evaluate_response = messages
        .iter()
        .find(|message| message["id"] == json!(5_u64))
        .expect("Runtime.evaluate response");
    assert!(
        evaluate_response.get("error").is_none(),
        "Runtime.evaluate must not return NoDocumentLoaded after pipelined Page.navigate; got {evaluate_response}"
    );
    let value = evaluate_response["result"]["result"]["value"]
        .as_str()
        .expect("string value from evaluate");
    assert_eq!(
        value, "link",
        "evaluate must observe the new document body (got `{value}`)"
    );

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
    fixture_server.abort();
}

#[tokio::test]
async fn websocket_cdp_offline_emulation_navigation_fails_like_network_error() {
    async fn page() -> impl IntoResponse {
        (
            [(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
            "<!doctype html><html><body><div id='probe'>online</div></body></html>",
        )
    }
    let fixture_app = Router::new().route("/", get(page));
    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, fixture_app).await });
    let fixture_url = format!("http://{fixture_addr}/");

    let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
    let (mut socket, _) = connect_async(format!(
        "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
    ))
    .await
    .expect("connect to cdp websocket");

    let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
    let session = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;

    let network_enable = send_cdp_command(
        &mut socket,
        4,
        "Network.enable",
        Some(&session.session_id),
        json!({}),
    )
    .await;
    assert!(
        network_enable
            .iter()
            .any(|message| message["id"] == json!(4_u64) && message.get("error").is_none()),
        "Network.enable should succeed: {network_enable:?}"
    );

    // Turn offline emulation on. Chromium blocks loopback too, so the
    // navigation must fail as a network error rather than succeed.
    let emulate = send_cdp_command(
        &mut socket,
        5,
        "Network.emulateNetworkConditions",
        Some(&session.session_id),
        json!({
            "offline": true,
            "latency": 0,
            "downloadThroughput": -1,
            "uploadThroughput": -1
        }),
    )
    .await;
    assert!(
        emulate
            .iter()
            .any(|message| message["id"] == json!(5_u64) && message.get("error").is_none()),
        "offline emulation should be accepted: {emulate:?}"
    );

    let navigate = send_cdp_command(
        &mut socket,
        6,
        "Page.navigate",
        Some(&session.session_id),
        json!({ "url": fixture_url }),
    )
    .await;
    let navigate_response = navigate
        .iter()
        .find(|message| message["id"] == json!(6_u64))
        .expect("Page.navigate response");
    assert!(
        navigate_response.get("error").is_none(),
        "an offline navigation must not be a -32000 protocol error; got {navigate_response:#?}"
    );
    assert!(
        navigate_response["result"]["frameId"].is_string(),
        "Page.navigate must still resolve with a frameId; got {navigate_response:#?}"
    );
    assert!(
        navigate.iter().any(|message| {
            message["sessionId"].as_str() == Some(session.session_id.as_str())
                && message["method"] == json!("Network.loadingFailed")
                && message["params"]["errorText"] == json!("net::ERR_INTERNET_DISCONNECTED")
        }),
        "offline navigation must emit Network.loadingFailed with net::ERR_INTERNET_DISCONNECTED: {navigate:#?}"
    );
    if let Some(error_text) = navigate_response["result"]["errorText"].as_str() {
        assert_eq!(
            error_text, "net::ERR_INTERNET_DISCONNECTED",
            "Page.navigate errorText must match the network error"
        );
    }

    // The committed error Document keeps the target responsive.
    let value =
        cdp_runtime_evaluate_string(&mut socket, &session.session_id, 7, "String(1 + 1)").await;
    assert_eq!(value, "2");

    // Restoring offline:false lets the same loopback navigation succeed.
    let restore = send_cdp_command(
        &mut socket,
        8,
        "Network.emulateNetworkConditions",
        Some(&session.session_id),
        json!({
            "offline": false,
            "latency": 0,
            "downloadThroughput": -1,
            "uploadThroughput": -1
        }),
    )
    .await;
    assert!(
        restore
            .iter()
            .any(|message| message["id"] == json!(8_u64) && message.get("error").is_none()),
        "offline:false should be accepted: {restore:?}"
    );

    let reloaded = send_cdp_command(
        &mut socket,
        9,
        "Page.navigate",
        Some(&session.session_id),
        json!({ "url": fixture_url }),
    )
    .await;
    let reloaded_response = reloaded
        .iter()
        .find(|message| message["id"] == json!(9_u64))
        .expect("recovered Page.navigate response");
    assert!(
        reloaded_response.get("error").is_none(),
        "navigation after offline:false must succeed; got {reloaded_response:#?}"
    );
    assert!(
        reloaded_response["result"]
            .get("errorText")
            .is_none_or(|value| value.is_null()),
        "a recovered navigation must not report an errorText; got {reloaded_response:#?}"
    );
    let body = cdp_runtime_evaluate_string(
        &mut socket,
        &session.session_id,
        10,
        "document.querySelector('#probe')?.textContent ?? ''",
    )
    .await;
    assert_eq!(body, "online");

    let _ = socket.close(None).await;
    abort_test_cdp_server(protocol_server).await;
    fixture_server.abort();
}