Skip to content

Automate browser based workflows with AI

136 KB
Raw Blame
from __future__ import annotations

import asyncio
import json
from collections.abc import AsyncIterator
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest
import pytest_asyncio
from aiohttp import ClientSession, ClientWebSocketResponse

import skyvern.browser_extension.cdp_adapter as cdp_adapter_module
from skyvern.browser_extension.cdp_adapter import ExtensionCdpAdapter
from skyvern.browser_extension.errors import (
    BrowserExtensionBrokerError,
    BrowserExtensionNotConnectedError,
    ExtensionRequestError,
)
from skyvern.browser_extension.event_order import EventHold
from skyvern.browser_extension.protocol import PAGE_CHANGED_BEFORE_START_MESSAGE, PAGE_CHANGED_WHILE_RUNNING_MESSAGE
from skyvern.browser_extension.runtime import BrowserExtensionRuntime
from skyvern.browser_extension.target_registry import VirtualTargetRegistry


class StubRelay:
    def __init__(self, scoped_tabs: list[dict] | None = None) -> None:
        self.scoped_tabs = scoped_tabs or []
        self.connected = True
        self.calls: list[tuple[str, dict]] = []
        self.next_tab_id = 100
        self.fail_next: BrowserExtensionBrokerError | ExtensionRequestError | None = None
        self.fail_attach_tab_ids: set[int] = set()
        self.block_attach_tab_id: int | None = None
        self.attach_started = asyncio.Event()
        self.release_attach = asyncio.Event()
        self.block_detach_tab_id: int | None = None
        self.detach_started = asyncio.Event()
        self.release_detach = asyncio.Event()
        self.main_frame_ids: dict[int, str] = {}
        self.block_send_keys: set[tuple[str | None, str]] = set()
        self.fail_send_keys: dict[
            tuple[str | None, str],
            BrowserExtensionBrokerError
            | BrowserExtensionNotConnectedError
            | ExtensionRequestError
            | list[ExtensionRequestError]
            | asyncio.CancelledError,
        ] = {}
        self.send_started: dict[tuple[str | None, str], asyncio.Event] = {}
        self.release_send: dict[tuple[str | None, str], asyncio.Event] = {}
        self.released_tabs: list[int] = []

    async def request(self, op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None) -> dict:
        self.calls.append((op, args))
        if self.fail_next is not None:
            error = self.fail_next
            self.fail_next = None
            raise error
        if op == "debugger.attach":
            tab_id = args["tabId"]
            if tab_id in self.fail_attach_tab_ids:
                raise ExtensionRequestError("ATTACH_FAILED", "attach failed")
            if tab_id == self.block_attach_tab_id:
                self.attach_started.set()
                await self.release_attach.wait()
        if op == "debugger.detach" and args["tabId"] == self.block_detach_tab_id:
            self.detach_started.set()
            await self.release_detach.wait()
        if op == "tabs.create":
            tab_id = self.next_tab_id
            self.next_tab_id += 1
            return {"tabId": tab_id}
        if op == "debugger.send":
            key = (args.get("sessionId"), args["method"])
            if key in self.block_send_keys:
                self.send_started.setdefault(key, asyncio.Event()).set()
                await self.release_send.setdefault(key, asyncio.Event()).wait()
            if key in self.fail_send_keys:
                send_error = self.fail_send_keys.pop(key)
                if isinstance(send_error, list):
                    next_error = send_error.pop(0)
                    if send_error:
                        self.fail_send_keys[key] = send_error
                    raise next_error
                raise send_error
            if args["method"] == "Page.getFrameTree" and args["tabId"] in self.main_frame_ids:
                frame_id = self.main_frame_ids[args["tabId"]]
                return {"result": {"frameTree": {"frame": {"id": frame_id}}}}
            return {"result": {"forwardedMethod": args["method"]}}
        return {}

    async def release_tab(self, tab_id: int) -> None:
        self.released_tabs.append(tab_id)
        await self.request("debugger.detach", {"tabId": tab_id}, timeout=2.0)


@pytest_asyncio.fixture
async def adapter_server() -> AsyncIterator[tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry]]:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        yield adapter, relay, registry
    finally:
        await adapter.stop()


async def receive_response(ws: ClientWebSocketResponse, request_id: int) -> dict:
    while True:
        message = await ws.receive_json(timeout=2)
        if message.get("id") == request_id:
            return message


async def receive_event(ws: ClientWebSocketResponse, method: str) -> dict:
    while True:
        message = await ws.receive_json(timeout=2)
        if message.get("method") == method:
            return message


def assert_subset(actual: dict, expected: dict) -> None:
    for key, value in expected.items():
        if isinstance(value, dict):
            assert_subset(actual[key], value)
        else:
            assert actual[key] == value


# Derived from chromium/crBrowser.js, chromium/crConnection.js, and chromium/chromium.js.
ROOT_CONNECT_CONTRACT = [
    (
        "Browser.getVersion",
        {"product": "Chrome/999.0.0.0", "userAgent": "Skyvern-Extension-Bridge"},
    ),
    ("Target.setAutoAttach", {}),
    ("Browser.setDownloadBehavior", {}),
    ("Target.getTargetInfo", {"targetInfo": {"targetId": "skyvern-browser", "type": "browser"}}),
]

ROOT_CONNECT_PARAMS = {
    "Browser.getVersion": {},
    "Target.setAutoAttach": {"autoAttach": True, "waitForDebuggerOnStart": True, "flatten": True},
    "Browser.setDownloadBehavior": {"behavior": "allowAndName", "eventsEnabled": True},
    "Target.getTargetInfo": {},
}


@pytest.mark.asyncio
async def test_capability_path_is_required(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, _ = adapter_server
    wrong_url = adapter.cdp_ws_url.rsplit("/", 1)[0] + "/wrong"

    async with ClientSession() as client:
        response = await client.get(wrong_url.replace("ws://", "http://"))
        assert response.status == 404
        response.release()

        ws = await client.ws_connect(adapter.cdp_ws_url)
        assert not ws.closed
        await ws.close()


@pytest.mark.asyncio
async def test_root_connect_contract_fixture(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, _ = adapter_server

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        for request_id, (method, minimal_reply) in enumerate(ROOT_CONNECT_CONTRACT, start=1):
            await ws.send_json({"id": request_id, "method": method, "params": ROOT_CONNECT_PARAMS[method]})
            response = await receive_response(ws, request_id)
            assert "error" not in response
            assert_subset(response["result"], minimal_reply)


@pytest.mark.asyncio
async def test_auto_attach_creates_blank_tab_when_scope_is_empty(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        assert await receive_response(ws, 1) == {"id": 1, "result": {}}
        attached = await receive_event(ws, "Target.attachedToTarget")
        root_session_id = registry.root_session_id(100)

    assert relay.calls[:2] == [
        ("tabs.create", {"url": "about:blank"}),
        ("debugger.attach", {"tabId": 100}),
    ]
    assert attached["params"] == {
        "sessionId": root_session_id,
        "targetInfo": {
            "targetId": "tab-100",
            "type": "page",
            "title": "",
            "url": "about:blank",
            "attached": True,
            "canAccessOpener": False,
            "browserContextId": "skyvern-default",
        },
        "waitingForDebugger": False,
    }


@pytest.mark.asyncio
async def test_auto_attach_scope_event_during_blank_tab_creation_attaches_once(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, _ = adapter_server
    relay.block_attach_tab_id = 100
    original_request = relay.request

    async def request_with_scope_event(
        op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
    ) -> dict:
        result = await original_request(op, args, timeout)
        if op == "tabs.create":
            await adapter.handle_extension_event(
                "scope.tabAdded",
                {"tabId": result["tabId"], "url": args["url"], "title": ""},
            )
            asyncio.get_running_loop().call_soon(relay.release_attach.set)
        return result

    relay.request = request_with_scope_event

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        assert await receive_response(ws, 1) == {"id": 1, "result": {}}
        await receive_event(ws, "Target.attachedToTarget")

    assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
        ("debugger.attach", {"tabId": 100}),
    ]


@pytest.mark.asyncio
async def test_auto_attach_existing_and_later_scoped_tabs() -> None:
    relay = StubRelay(
        [
            {"tabId": 7, "url": "https://one.example", "title": "One"},
            {"tabId": 8, "url": "https://two.example", "title": "Two"},
        ]
    )
    relay.fail_next = ExtensionRequestError("CDP_ERROR", "Another debugger is already attached")
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            await receive_response(ws, 1)
            events = [await receive_event(ws, "Target.attachedToTarget") for _ in range(2)]

            await adapter.handle_extension_event(
                "scope.tabAdded", {"tabId": 9, "url": "https://three.example", "title": "Three"}
            )
            later = await receive_event(ws, "Target.attachedToTarget")

            await adapter.handle_extension_event(
                "tabs.created", {"tabId": 10, "openerTabId": 7, "url": "https://popup.example"}
            )
            popup = await receive_event(ws, "Target.attachedToTarget")
    finally:
        await adapter.stop()

    assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
        ("debugger.attach", {"tabId": 7}),
        ("debugger.attach", {"tabId": 8}),
        ("debugger.attach", {"tabId": 9}),
        ("debugger.attach", {"tabId": 10}),
    ]
    assert [event["params"]["targetInfo"]["targetId"] for event in events] == ["tab-7", "tab-8"]
    assert later["params"]["targetInfo"]["targetId"] == "tab-9"
    assert popup["params"]["targetInfo"]["openerId"] == "tab-7"


@pytest.mark.asyncio
async def test_coded_attach_failed_already_attached_error_propagates_without_unsharing_tab() -> None:
    tab = {"tabId": 11, "url": "https://shared.example", "title": "Shared"}
    relay = StubRelay([tab])
    relay.fail_next = ExtensionRequestError("ATTACH_FAILED", "Another debugger is already attached")
    adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), relay)
    adapter._send = AsyncMock()

    await adapter._handle_client_text(
        None,  # type: ignore[arg-type]
        json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
    )

    adapter._send.assert_awaited_once_with(
        None,
        {"id": 1, "error": {"code": -32000, "message": "ATTACH_FAILED: Another debugger is already attached"}},
    )
    assert relay.scoped_tabs == [tab]
    assert not any(op == "debugger.detach" for op, _ in relay.calls)
    assert not any(op == "debugger.send" for op, _ in relay.calls)


@pytest.mark.asyncio
async def test_adopted_group_tab_uses_same_attach_flow_as_session_created_tab() -> None:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._auto_attach = True
    emit_attached = AsyncMock()
    adapter._emit_attached = emit_attached
    try:
        await adapter.handle_extension_event(
            "tabs.created",
            {"tabId": 50, "url": "https://created.example", "title": "Created"},
        )
        await asyncio.gather(*list(adapter._background_tasks))
        await adapter.handle_extension_event(
            "scope.tabAdded",
            {"tabId": 51, "url": "https://adopted.example", "title": "Adopted"},
        )
        await asyncio.gather(*list(adapter._background_tasks))
    finally:
        await adapter.stop()

    assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
        ("debugger.attach", {"tabId": 50}),
        ("debugger.attach", {"tabId": 51}),
    ]
    assert [call.args[:2] for call in emit_attached.await_args_list] == [
        (50, "tab-50"),
        (51, "tab-51"),
    ]


@pytest.mark.asyncio
async def test_root_target_discovery_waits_for_auto_attach_while_session_commands_continue() -> None:
    scoped_tabs = [
        {"tabId": 41, "url": "https://one.example", "title": "One"},
        {"tabId": 42, "url": "https://two.example", "title": "Two"},
    ]
    relay = StubRelay(scoped_tabs)
    relay.main_frame_ids = {41: "frame-41", 42: "frame-42"}
    relay.block_attach_tab_id = 42
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.handle_extension_event("extension.hello", {"scopedTabs": scoped_tabs})
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            await asyncio.wait_for(relay.attach_started.wait(), 1)

            attached_session_id = registry.root_session_id(41)
            await ws.send_json({"id": 2, "method": "Target.getTargets", "params": {}})
            await ws.send_json({"id": 3, "sessionId": attached_session_id, "method": "Runtime.enable", "params": {}})

            early_get_targets = None
            session_response = None
            while session_response is None:
                message = await ws.receive_json(timeout=1)
                if message.get("id") == 2:
                    early_get_targets = message
                elif message.get("id") == 3:
                    session_response = message
            assert early_get_targets is None
            assert session_response == {
                "id": 3,
                "sessionId": attached_session_id,
                "result": {"forwardedMethod": "Runtime.enable"},
            }

            relay.release_attach.set()
            assert await receive_response(ws, 1) == {"id": 1, "result": {}}
            targets = await receive_response(ws, 2)
    finally:
        relay.release_attach.set()
        await adapter.stop()

    assert {info["targetId"] for info in targets["result"]["targetInfos"]} == {"frame-41", "frame-42"}


@pytest.mark.asyncio
async def test_auto_attach_failure_reaches_client_instead_of_acknowledging_success() -> None:
    relay = StubRelay([{"tabId": 30, "url": "https://bad.example", "title": "Bad"}])
    relay.fail_attach_tab_ids.add(30)
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._send = AsyncMock()

    await adapter._handle_client_text(
        None,  # type: ignore[arg-type]
        json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
    )

    adapter._send.assert_awaited_once_with(
        None,
        {"id": 1, "error": {"code": -32000, "message": "ATTACH_FAILED: attach failed"}},
    )


@pytest.mark.asyncio
async def test_repeated_auto_attach_failure_restores_enabled_state_for_later_scoped_tabs() -> None:
    relay = StubRelay([{"tabId": 30, "url": "https://good.example", "title": "Good"}])
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            assert await receive_response(ws, 1) == {"id": 1, "result": {}}
            await receive_event(ws, "Target.attachedToTarget")

            relay.scoped_tabs.append({"tabId": 31, "url": "https://bad.example", "title": "Bad"})
            relay.fail_attach_tab_ids.add(31)
            await ws.send_json({"id": 2, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            assert await receive_response(ws, 2) == {
                "id": 2,
                "error": {"code": -32000, "message": "ATTACH_FAILED: attach failed"},
            }
            assert adapter._auto_attach is True

            relay.fail_attach_tab_ids.remove(31)
            await adapter.handle_extension_event(
                "scope.tabAdded", {"tabId": 32, "url": "https://later.example", "title": "Later"}
            )
            later = await receive_event(ws, "Target.attachedToTarget")
    finally:
        await adapter.stop()

    assert later["params"]["targetInfo"]["targetId"] == "tab-32"


@pytest.mark.asyncio
async def test_empty_scope_auto_attach_broker_failure_reaches_client() -> None:
    relay = StubRelay()
    relay.fail_next = BrowserExtensionBrokerError("BROKER_UNAVAILABLE", "broker unavailable")
    adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), relay)
    adapter._send = AsyncMock()

    await adapter._handle_client_text(
        None,  # type: ignore[arg-type]
        json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
    )

    adapter._send.assert_awaited_once_with(
        None,
        {"id": 1, "error": {"code": -32000, "message": "BROKER_UNAVAILABLE: broker unavailable"}},
    )
    assert adapter._auto_attach is False


@pytest.mark.asyncio
async def test_auto_attach_replies_before_a_concurrent_scope_event() -> None:
    relay = StubRelay()
    relay.block_attach_tab_id = 100
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    original_request = relay.request
    order: list[str] = []

    async def request_with_scope_event(
        op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
    ) -> dict:
        result = await original_request(op, args, timeout)
        if op == "tabs.create":
            await adapter.handle_extension_event(
                "scope.tabAdded",
                {"tabId": result["tabId"], "url": args["url"], "title": ""},
            )
            asyncio.get_running_loop().call_soon(relay.release_attach.set)
        return result

    relay.request = request_with_scope_event
    adapter._reply = AsyncMock(side_effect=lambda *_args: order.append("reply"))
    adapter._emit_attached = AsyncMock(side_effect=lambda *_args: order.append("attached"))

    await adapter._handle_root_command(None, 1, "Target.setAutoAttach", {"autoAttach": True})  # type: ignore[arg-type]
    await asyncio.gather(*list(adapter._background_tasks))

    assert order == ["reply", "attached"]
    assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
        ("debugger.attach", {"tabId": 100}),
    ]


@pytest.mark.asyncio
async def test_frame_discovery_timeout_does_not_register_a_phantom_attached_page() -> None:
    relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
    relay.fail_send_keys[(None, "Page.getFrameTree")] = ExtensionRequestError(
        "COMMAND_TIMEOUT", "frame discovery timed out"
    )
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    generation = adapter._begin_tab_scope(32)

    with pytest.raises(ExtensionRequestError, match="frame discovery timed out"):
        await adapter._ensure_attached(relay.scoped_tabs[0], generation=generation)

    assert 32 not in adapter._attached_tabs
    with pytest.raises(KeyError):
        registry.target_id_for_tab(32)
    assert ("debugger.detach", {"tabId": 32}) in relay.calls


@pytest.mark.asyncio
@pytest.mark.parametrize("message", [PAGE_CHANGED_BEFORE_START_MESSAGE, PAGE_CHANGED_WHILE_RUNNING_MESSAGE])
@pytest.mark.parametrize("cancel_twice", [False, True])
async def test_page_changed_read_has_two_identical_sends_and_one_response(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry], message: str, cancel_twice: bool
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    registry.register_child_session(42, "child-42", {"targetId": "frame-42", "type": "iframe"})
    args = {"tabId": 42, "sessionId": "child-42", "method": "Page.captureScreenshot", "params": {"format": "png"}}
    relay.fail_send_keys[("child-42", "Page.captureScreenshot")] = [
        ExtensionRequestError("COMMAND_TIMEOUT", message) for _ in range(2 if cancel_twice else 1)
    ]

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 17, "sessionId": "child-42", "method": args["method"], "params": args["params"]})
        messages = [await ws.receive_json(timeout=2)]
        with pytest.raises(TimeoutError):
            messages.append(await ws.receive_json(timeout=0.05))

    assert [m["id"] for m in messages] == [17]
    assert ("error" in messages[0]) is cancel_twice
    assert relay.calls == [("debugger.send", args), ("debugger.send", args)]


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("method", "params", "code", "message", "attempts"),
    [
        ("Input.dispatchMouseEvent", {"type": "mousePressed"}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
        ("Runtime.callFunctionOn", {}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
        ("Runtime.evaluate", {"expression": "1"}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
        (
            "Runtime.evaluate",
            {
                "expression": "(() => { const module = {};\nreturn new (module.exports.UtilityScript())(globalThis, false);\n})();",
                "contextId": 1,
            },
            "COMMAND_TIMEOUT",
            PAGE_CHANGED_WHILE_RUNNING_MESSAGE,
            2,
        ),
        (
            "Runtime.evaluate",
            {
                "expression": '(() => { const module = {};\nreturn new (module.exports.InjectedScript())(globalThis, {"browserName":"chromium"});\n})();',
                "contextId": 0,
            },
            "COMMAND_TIMEOUT",
            PAGE_CHANGED_BEFORE_START_MESSAGE,
            2,
        ),
        ("Runtime.runIfWaitingForDebugger", {}, "COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE, 1),
        ("Runtime.runIfWaitingForDebugger", {}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 2),
        ("Page.enable", {}, "RESTRICTED_URL", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
        ("Page.enable", {}, "COMMAND_TIMEOUT", "operation timed out", 1),
        (
            "Page.addScriptToEvaluateOnNewDocument",
            {"source": ""},
            "COMMAND_TIMEOUT",
            PAGE_CHANGED_WHILE_RUNNING_MESSAGE,
            2,
        ),
        (
            "Page.addScriptToEvaluateOnNewDocument",
            {"source": "1"},
            "COMMAND_TIMEOUT",
            PAGE_CHANGED_BEFORE_START_MESSAGE,
            1,
        ),
        (
            "Page.addScriptToEvaluateOnNewDocument",
            {"source": "", "runImmediately": True},
            "COMMAND_TIMEOUT",
            PAGE_CHANGED_BEFORE_START_MESSAGE,
            1,
        ),
    ],
)
async def test_page_changed_retry_allowlist(method: str, params: dict, code: str, message: str, attempts: int) -> None:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    registry.register_tab(42, "about:blank", "")
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._send = AsyncMock()
    relay.fail_send_keys[(None, method)] = ExtensionRequestError(code, message)

    await adapter._handle_client_text(
        None,  # type: ignore[arg-type]
        json.dumps({"id": 17, "sessionId": registry.root_session_id(42), "method": method, "params": params}),
    )

    assert relay.calls == [("debugger.send", {"tabId": 42, "method": method, "params": params})] * attempts
    adapter._send.assert_awaited_once()
    assert ("error" in adapter._send.call_args.args[1]) is (attempts == 1)


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("method", "params", "newer_method", "newer_params"),
    [
        (
            "Target.setAutoAttach",
            {"autoAttach": True, "filter": [{"type": "iframe", "exclude": False}]},
            "Target.setAutoAttach",
            {"autoAttach": False},
        ),
        ("Page.setLifecycleEventsEnabled", {"enabled": True}, "Page.setLifecycleEventsEnabled", {"enabled": False}),
        (
            "Emulation.setFocusEmulationEnabled",
            {"enabled": True},
            "Emulation.setFocusEmulationEnabled",
            {"enabled": False},
        ),
        ("Emulation.setEmulatedMedia", {"media": "print"}, "Emulation.setEmulatedMedia", {"media": "screen"}),
        ("Page.enable", {}, "Page.disable", {}),
        ("Runtime.enable", {}, "Runtime.disable", {}),
        ("Log.enable", {}, "Log.disable", {}),
        ("Network.enable", {}, "Network.disable", {}),
    ],
)
@pytest.mark.parametrize("identical", [False, True])
@pytest.mark.parametrize("newer_in_flight", [False, True])
async def test_page_changed_reissue_respects_latest_requested_state(
    method: str, params: dict, newer_method: str, newer_params: dict, identical: bool, newer_in_flight: bool
) -> None:
    if identical:
        newer_method, newer_params = method, params
    message = (
        PAGE_CHANGED_BEFORE_START_MESSAGE if method.startswith("Emulation.") else PAGE_CHANGED_WHILE_RUNNING_MESSAGE
    )
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    registry.register_tab(42, "about:blank", "")
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._send = AsyncMock()
    key = (None, method)
    relay.block_send_keys.add(key)
    session_id = registry.root_session_id(42)
    older = asyncio.create_task(
        adapter._handle_client_text(
            None,  # type: ignore[arg-type]
            json.dumps({"id": 1, "sessionId": session_id, "method": method, "params": params}),
        )
    )
    await asyncio.wait_for(relay.send_started.setdefault(key, asyncio.Event()).wait(), 1)
    release_older = relay.release_send.pop(key)
    relay.send_started.pop(key)
    relay.block_send_keys.remove(key)
    newer_key = (None, newer_method)
    if newer_in_flight:
        relay.block_send_keys.add(newer_key)
    newer = asyncio.create_task(
        adapter._handle_client_text(
            None,  # type: ignore[arg-type]
            json.dumps({"id": 2, "sessionId": session_id, "method": newer_method, "params": newer_params}),
        )
    )
    try:
        if newer_in_flight:
            await asyncio.wait_for(relay.send_started.setdefault(newer_key, asyncio.Event()).wait(), 1)
        else:
            await asyncio.wait_for(newer, 1)
        relay.fail_send_keys[key] = ExtensionRequestError("COMMAND_TIMEOUT", message)
        relay.block_send_keys.discard(newer_key)
        release_older.set()
        await asyncio.wait_for(older, 1)
    finally:
        if newer_in_flight:
            relay.release_send[newer_key].set()
        await asyncio.wait_for(newer, 1)

    expected_commands = [(method, params), (newer_method, newer_params)]
    if identical:
        expected_commands.append((method, params))
    assert [(args["method"], args["params"]) for op, args in relay.calls if op == "debugger.send"] == expected_commands
    messages = [call.args[1] for call in adapter._send.await_args_list]
    assert [m["id"] for m in messages] == ([1, 2] if newer_in_flight else [2, 1])
    responses = {m["id"]: m for m in messages}
    assert responses[2]["result"] == {"forwardedMethod": newer_method}
    if identical:
        assert responses[1]["result"] == {"forwardedMethod": method}
    else:
        assert responses[1]["error"] == {
            "code": -32000,
            "message": f"COMMAND_TIMEOUT: {message}",
        }


@pytest.mark.asyncio
@pytest.mark.parametrize("invalidate", ["scope", "session", "connection"])
async def test_page_changed_retry_requires_original_scope_session_and_connection(invalidate: str) -> None:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    registry.register_tab(42, "about:blank", "")
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._send = AsyncMock()
    key = (None, "Page.getLayoutMetrics")
    relay.block_send_keys.add(key)
    relay.fail_send_keys[key] = ExtensionRequestError("COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE)
    command = asyncio.create_task(
        adapter._handle_client_text(
            None,  # type: ignore[arg-type]
            json.dumps({"id": 1, "sessionId": registry.root_session_id(42), "method": key[1]}),
        )
    )
    await asyncio.wait_for(relay.send_started.setdefault(key, asyncio.Event()).wait(), 1)
    if invalidate == "scope":
        adapter._revoke_tab_scope(42)
    elif invalidate == "session":
        registry.remove_tab(42)
    else:
        adapter._connection_generation += 1
    relay.release_send[key].set()
    await asyncio.wait_for(command, 1)

    assert len(relay.calls) == 1
    adapter._send.assert_awaited_once()
    assert "error" in adapter._send.call_args.args[1]


@pytest.mark.asyncio
@pytest.mark.parametrize("message", [PAGE_CHANGED_BEFORE_START_MESSAGE, PAGE_CHANGED_WHILE_RUNNING_MESSAGE])
@pytest.mark.parametrize("registered", [False, True])
async def test_page_changed_probe_preserves_attachment_and_next_probe_recovers(message: str, registered: bool) -> None:
    tab = {"tabId": 32, "url": "about:blank", "title": ""}
    relay = StubRelay([tab])
    relay.main_frame_ids[32] = "frame-32"
    relay.fail_send_keys[(None, "Page.getFrameTree")] = [ExtensionRequestError("COMMAND_TIMEOUT", message)] * 2
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    generation = adapter._begin_tab_scope(32)
    if registered:
        adapter._register_scoped_tabs()
    old_target_id = registry.target_id_for_tab(32) if registered else "tab-32"

    with pytest.raises(ExtensionRequestError, match=message):
        await adapter._ensure_attached(tab, generation=generation)

    assert 32 in adapter._attached_tabs
    assert adapter._scope_is_current(32, generation)
    adapter._register_scoped_tabs()
    assert registry.has_tab(32) is registered
    assert adapter._page_target_infos() == []
    adapter._send = AsyncMock()
    adapter._emit = AsyncMock()
    await adapter._handle_root_command(None, 1, "Target.getTargets", {})
    assert adapter._send.call_args.args[1]["result"]["targetInfos"] == []
    await adapter._handle_root_command(None, 2, "Target.getTargetInfo", {"targetId": old_target_id})
    assert adapter._send.call_args.args[1]["error"]["message"] == "target not found"
    await adapter._handle_root_command(None, 3, "Target.setDiscoverTargets", {"discover": True})
    assert all(call.args[1]["targetInfo"]["type"] == "browser" for call in adapter._emit.await_args_list)
    if registered:
        await adapter._handle_session_command(None, 4, registry.root_session_id(32), "Target.getTargetInfo", {})
        assert adapter._send.call_args.args[1]["error"]["message"] == "target not found"
        registry.register_tab(33, "about:blank", "")
        params = {"filter": [{"type": "iframe", "exclude": False}, {"exclude": True}]}
        for request_id, tab_id in enumerate((32, 33), start=6):
            await adapter._handle_session_command(
                None, request_id, registry.root_session_id(tab_id), "Target.getTargets", params
            )
            assert relay.calls[-1] == (
                "debugger.send",
                {"tabId": tab_id, "method": "Target.getTargets", "params": params},
            )
            assert adapter._send.call_args.args[1]["result"] == {"forwardedMethod": "Target.getTargets"}
        await adapter._handle_session_command(
            None, 8, registry.root_session_id(33), "Target.getTargetInfo", {"targetId": old_target_id}
        )
        assert adapter._send.call_args.args[1]["error"]["message"] == "target not found"
        registry.remove_tab(33)
    assert not any(op == "debugger.detach" for op, _ in relay.calls)
    relay.fail_attach_tab_ids.add(32)
    assert await adapter._ensure_attached(tab, generation=generation) == ("frame-32", True)
    assert registry.target_id_for_tab(32) == "frame-32"
    assert [op for op, _ in relay.calls].count("debugger.attach") == 1
    assert [op for op, _ in relay.calls].count("debugger.send") == (5 if registered else 3)
    assert adapter.target_attachment_snapshot("frame-32")
    assert [info["targetId"] for info in adapter._page_target_infos()] == ["frame-32"]
    await adapter._handle_root_command(None, 5, "Target.getTargetInfo", {"targetId": "frame-32"})
    assert adapter._send.call_args.args[1]["result"]["targetInfo"]["targetId"] == "frame-32"


@pytest.mark.asyncio
async def test_page_session_get_targets_propagates_relay_failure() -> None:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    registry.register_tab(42, "about:blank", "")
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._send = AsyncMock()
    relay.fail_send_keys[(None, "Target.getTargets")] = ExtensionRequestError("COMMAND_TIMEOUT", "probe timed out")

    await adapter._handle_client_text(
        None,  # type: ignore[arg-type]
        json.dumps({"id": 1, "sessionId": registry.root_session_id(42), "method": "Target.getTargets"}),
    )

    adapter._send.assert_awaited_once()
    assert adapter._send.call_args.args[1]["error"] == {"code": -32000, "message": "COMMAND_TIMEOUT: probe timed out"}


@pytest.mark.asyncio
@pytest.mark.parametrize("other_tab", [False, True])
async def test_auto_attach_page_changed_probe_replies_then_recovers_deferred_tab(other_tab: bool) -> None:
    tabs = [{"tabId": 32, "url": "about:blank", "title": ""}]
    if other_tab:
        tabs.append({"tabId": 33, "url": "about:blank", "title": ""})
    relay = StubRelay(tabs)
    relay.fail_send_keys[(None, "Page.getFrameTree")] = [
        ExtensionRequestError("COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE)
    ] * 2
    adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), relay)
    order: list[object] = []
    adapter._reply = AsyncMock(side_effect=lambda *_args: order.append("reply"))
    adapter._emit_attached = AsyncMock(side_effect=lambda tab_id, *_args: order.append(tab_id))

    await adapter._handle_root_command(None, 1, "Target.setAutoAttach", {"autoAttach": True})  # type: ignore[arg-type]
    await asyncio.gather(*list(adapter._background_tasks))

    assert order == (["reply", 33, 32] if other_tab else ["reply", 32])
    assert adapter._auto_attach
    assert not any(op == "debugger.detach" for op, _ in relay.calls)
    assert [args["tabId"] for op, args in relay.calls if op == "debugger.attach"] == ([32, 33] if other_tab else [32])


@pytest.mark.asyncio
@pytest.mark.parametrize("close_browser", [False, True])
async def test_unexposed_attachment_browser_close_releases_or_raw_reconnect_exposes(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry], close_browser: bool
) -> None:
    adapter, relay, registry = adapter_server
    tab = {"tabId": 32, "url": "about:blank", "title": ""}
    relay.scoped_tabs = [tab]
    relay.fail_send_keys[(None, "Page.getFrameTree")] = [
        ExtensionRequestError("COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE)
    ] * 2
    async with ClientSession() as client:
        ws = await client.ws_connect(adapter.cdp_ws_url)
        with pytest.raises(ExtensionRequestError):
            await adapter._ensure_attached(tab)
        assert not registry.has_tab(32)
        if close_browser:
            relay.scoped_tabs = []  # Release must include the adapter's own attachment record.
            await ws.send_json({"id": 9, "method": "Browser.close"})
            assert await ws.receive_json(timeout=2) == {"id": 9, "result": {}}
            await ws.receive(timeout=2)
            assert relay.released_tabs == [32]
            assert ("debugger.detach", {"tabId": 32}) in relay.calls
        else:
            await ws.close()
            assert relay.released_tabs == []
            relay.fail_next = ExtensionRequestError("CDP_ERROR", "already attached")
            async with client.ws_connect(adapter.cdp_ws_url) as reconnected:
                await reconnected.send_json(
                    {"id": 10, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}
                )
                messages = [await reconnected.receive_json(timeout=2) for _ in range(2)]
                assert messages[0] == {"id": 10, "result": {}}
                assert messages[1]["method"] == "Target.attachedToTarget"
                assert registry.has_tab(32)


@pytest.mark.asyncio
async def test_child_auto_attach_reissues_while_only_pending_with_original_timeout() -> None:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    registry.register_tab(42, "about:blank", "")
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._auto_attach = True
    adapter._pending_child_sessions.add("child-42")
    relay.fail_send_keys[("child-42", "Target.setAutoAttach")] = ExtensionRequestError(
        "COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE
    )
    original_request = relay.request

    async def request_while_pending(
        op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
    ) -> dict:
        assert "child-42" in adapter._pending_child_sessions
        with pytest.raises(KeyError):
            registry.resolve_session("child-42")
        assert timeout == 3.0
        return await original_request(op, args, timeout)

    relay.request = request_while_pending
    target_info = {"targetId": "frame-42", "type": "iframe"}
    await adapter._initialize_child_target(
        42, "child-42", target_info, {"sessionId": "child-42", "targetInfo": target_info}, registry.root_session_ids(42)
    )

    assert len(relay.calls) == 2 and relay.calls[0] == relay.calls[1]
    assert registry.resolve_session("child-42") == (42, "child-42")
    assert "child-42" not in adapter._pending_child_sessions


@pytest.mark.asyncio
async def test_frame_discovery_not_connected_discards_attachment_and_restores_auto_attach() -> None:
    relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
    relay.fail_send_keys[(None, "Page.getFrameTree")] = BrowserExtensionNotConnectedError()
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)

    with pytest.raises(BrowserExtensionNotConnectedError):
        await adapter._set_auto_attach(None, 1, {"autoAttach": True}, None)  # type: ignore[arg-type]

    assert adapter._auto_attach is False
    assert 32 not in adapter._attached_tabs
    with pytest.raises(KeyError):
        registry.target_id_for_tab(32)
    assert ("debugger.detach", {"tabId": 32}) in relay.calls


@pytest.mark.asyncio
async def test_frame_discovery_cancellation_discards_attachment_and_restores_auto_attach() -> None:
    relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
    relay.fail_send_keys[(None, "Page.getFrameTree")] = asyncio.CancelledError()
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)

    with pytest.raises(asyncio.CancelledError):
        await adapter._set_auto_attach(None, 1, {"autoAttach": True}, None)  # type: ignore[arg-type]

    assert adapter._auto_attach is False
    assert 32 not in adapter._attached_tabs
    with pytest.raises(KeyError):
        registry.target_id_for_tab(32)
    assert ("debugger.detach", {"tabId": 32}) in relay.calls


@pytest.mark.asyncio
async def test_frame_discovery_broker_failure_discards_attachment_and_restores_auto_attach() -> None:
    relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
    relay.fail_send_keys[(None, "Page.getFrameTree")] = BrowserExtensionBrokerError(
        "EXTENSION_RESET_IN_PROGRESS", "extension reset in progress"
    )
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    adapter._send = AsyncMock()

    await adapter._handle_client_text(
        None,  # type: ignore[arg-type]
        json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
    )

    adapter._send.assert_awaited_once_with(
        None,
        {
            "id": 1,
            "error": {
                "code": -32000,
                "message": "EXTENSION_RESET_IN_PROGRESS: extension reset in progress",
            },
        },
    )
    assert adapter._auto_attach is False
    assert 32 not in adapter._attached_tabs
    with pytest.raises(KeyError):
        registry.target_id_for_tab(32)
    assert ("debugger.detach", {"tabId": 32}) in relay.calls


@pytest.mark.asyncio
async def test_create_target_reuses_the_scope_the_echoed_tab_added_event_opened(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    # The extension announces a created tab before it answers tabs.create, so the announcement's
    # attach is always the one already in flight when Target.createTarget resumes.
    adapter, relay, _registry = adapter_server
    adapter._auto_attach = True
    relay.block_attach_tab_id = 100
    original_request = relay.request

    async def request_announcing_the_tab_before_returning_it(
        op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
    ) -> dict:
        result = await original_request(op, args, timeout)
        if op == "tabs.create":
            await adapter.handle_extension_event(
                "scope.tabAdded", {"tabId": result["tabId"], "url": args["url"], "title": ""}
            )
        return result

    relay.request = request_announcing_the_tab_before_returning_it
    async with ClientSession() as session:
        async with session.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.createTarget", "params": {"url": "https://new.example"}})
            await asyncio.wait_for(relay.attach_started.wait(), timeout=2)
            relay.release_attach.set()

            response = await receive_response(ws, 1)
            assert "error" not in response, response
            assert response["result"]["targetId"]
            assert ("debugger.detach", {"tabId": 100}) not in relay.calls


@pytest.mark.asyncio
async def test_create_target_survives_a_tab_added_event_that_lands_mid_attach(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, _registry = adapter_server
    relay.block_attach_tab_id = 100
    async with ClientSession() as session:
        async with session.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.createTarget", "params": {"url": "https://new.example"}})
            await asyncio.wait_for(relay.attach_started.wait(), timeout=2)
            await adapter.handle_extension_event(
                "scope.tabAdded", {"tabId": 100, "url": "https://new.example", "title": ""}
            )
            relay.release_attach.set()

            response = await receive_response(ws, 1)
            assert "error" not in response, response
            assert response["result"]["targetId"]


@pytest.mark.asyncio
async def test_scope_revoked_during_frame_discovery_discards_the_attachment() -> None:
    relay = StubRelay([{"tabId": 33, "url": "https://racy.example", "title": "Racy"}])
    frame_key = (None, "Page.getFrameTree")
    relay.block_send_keys.add(frame_key)
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    generation = adapter._begin_tab_scope(33)

    attaching = asyncio.create_task(adapter._ensure_attached(relay.scoped_tabs[0], generation=generation))
    await relay.send_started.setdefault(frame_key, asyncio.Event()).wait()
    adapter._revoke_tab_scope(33)
    relay.release_send.setdefault(frame_key, asyncio.Event()).set()

    assert await attaching is None
    assert 33 not in adapter._attached_tabs
    assert ("debugger.detach", {"tabId": 33}) in relay.calls


@pytest.mark.asyncio
async def test_auto_attach_scope_revocation_cancellation_rolls_back_prior_tabs() -> None:
    relay = StubRelay(
        [
            {"tabId": 33, "url": "https://first.example", "title": "First"},
            {"tabId": 34, "url": "https://revoked.example", "title": "Revoked"},
        ]
    )
    relay.block_detach_tab_id = 34
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    original_request = relay.request
    revoked_detach_finished = asyncio.Event()

    async def request_with_scope_revocation(
        op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
    ) -> dict:
        result = await original_request(op, args, timeout)
        if op == "debugger.send" and args["tabId"] == 34 and args["method"] == "Page.getFrameTree":
            adapter._revoke_tab_scope(34)
        if op == "debugger.detach" and args["tabId"] == 34:
            revoked_detach_finished.set()
        return result

    relay.request = request_with_scope_revocation
    attaching = asyncio.create_task(
        adapter._set_auto_attach(None, 1, {"autoAttach": True}, None)  # type: ignore[arg-type]
    )
    await relay.detach_started.wait()

    attaching.cancel()
    with pytest.raises(asyncio.CancelledError):
        await attaching

    relay.release_detach.set()
    await asyncio.wait_for(revoked_detach_finished.wait(), timeout=1)

    assert adapter._auto_attach is False
    assert adapter._attached_tabs == set()
    assert ("debugger.detach", {"tabId": 33}) in relay.calls
    with pytest.raises(KeyError):
        registry.target_id_for_tab(33)
    with pytest.raises(KeyError):
        registry.target_id_for_tab(34)


@pytest.mark.asyncio
async def test_auto_attach_transactional_failure_restores_state_without_second_response() -> None:
    relay = StubRelay(
        [
            {"tabId": 30, "url": "https://bad.example", "title": "Bad"},
            {"tabId": 31, "url": "https://good.example", "title": "Good"},
        ]
    )
    relay.fail_attach_tab_ids.add(30)
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})

            assert await receive_response(ws, 1) == {
                "id": 1,
                "error": {"code": -32000, "message": "ATTACH_FAILED: attach failed"},
            }
            with pytest.raises(TimeoutError):
                await ws.receive_json(timeout=0.05)
    finally:
        await adapter.stop()


@pytest.mark.asyncio
async def test_tab_removal_tombstones_in_flight_background_attach() -> None:
    relay = StubRelay([{"tabId": 40, "url": "https://existing.example", "title": "Existing"}])
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            await receive_response(ws, 1)
            await receive_event(ws, "Target.attachedToTarget")

            relay.block_attach_tab_id = 41
            await adapter.handle_extension_event(
                "scope.tabAdded", {"tabId": 41, "url": "https://racy.example", "title": "Racy"}
            )
            await asyncio.wait_for(relay.attach_started.wait(), 1)
            removal_task = asyncio.create_task(
                adapter.handle_extension_event("scope.tabRemoved", {"tabId": 41, "reason": "unshared"})
            )
            await asyncio.sleep(0)
            relay.release_attach.set()
            await removal_task

            with pytest.raises(KeyError):
                registry.root_session_id(41)
            with pytest.raises(TimeoutError):
                await ws.receive_json(timeout=0.05)
    finally:
        await adapter.stop()


@pytest.mark.asyncio
async def test_session_command_routes_to_relay_and_preserves_session_id(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {"id": 5, "sessionId": session_id, "method": "Runtime.evaluate", "params": {"expression": "1+1"}}
        )
        response = await receive_response(ws, 5)

        await ws.send_json({"id": 6, "sessionId": "missing", "method": "Runtime.enable", "params": {}})
        missing = await receive_response(ws, 6)

    assert relay.calls[-1] == (
        "debugger.send",
        {"tabId": 42, "method": "Runtime.evaluate", "params": {"expression": "1+1"}},
    )
    assert response == {"id": 5, "sessionId": session_id, "result": {"forwardedMethod": "Runtime.evaluate"}}
    assert missing == {
        "id": 6,
        "sessionId": "missing",
        "error": {"code": -32001, "message": "session not found"},
    }


@pytest.mark.asyncio
async def test_navigation_response_precedes_buffered_commit_events(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)
    navigation_events = [
        {
            "method": "Page.frameStartedNavigating",
            "params": {"frameId": "frame-42", "url": "https://destination.example"},
        },
        {
            "method": "Network.requestWillBeSent",
            "params": {"requestId": "request-42", "type": "Document"},
        },
        {
            "method": "Network.responseReceived",
            "params": {"requestId": "request-42", "type": "Document"},
        },
        {
            "method": "Page.lifecycleEvent",
            "params": {"frameId": "frame-42", "name": "init"},
        },
        {
            "method": "Page.frameNavigated",
            "params": {"frame": {"id": "frame-42", "url": "https://destination.example", "title": "Destination"}},
        },
    ]

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://destination.example"},
            }
        )
        await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)

        for event in navigation_events:
            await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})

        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        relay.release_send[navigation_key].set()
        messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]

    assert messages[0] == {
        "id": 1,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
    assert registry.target_info_for_tab(42)["url"] == "https://destination.example"


@pytest.mark.asyncio
async def test_stale_navigation_cleanup_does_not_clear_new_connection_navigation(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    old_session_id = registry.root_session_id(42)
    old_send_started = asyncio.Event()
    old_cleanup_started = asyncio.Event()
    old_response_cancelled = asyncio.Event()
    original_cancel_client_tasks = adapter._cancel_client_tasks

    async def block_old_client_cleanup(*args: object) -> None:
        old_cleanup_started.set()
        await original_cancel_client_tasks(*args)

    async with ClientSession() as client:
        old = await client.ws_connect(adapter.cdp_ws_url)
        old_server_ws = adapter._client_ws
        assert old_server_ws is not None
        original_send_json = old_server_ws.send_json

        async def block_old_response(payload: dict, *args: object, **kwargs: object) -> None:
            if payload.get("id") == 1:
                old_send_started.set()
                try:
                    await asyncio.Event().wait()
                except asyncio.CancelledError:
                    old_response_cancelled.set()
                    raise
            await original_send_json(payload, *args, **kwargs)

        with (
            patch.object(adapter, "_cancel_client_tasks", side_effect=block_old_client_cleanup),
            patch.object(old_server_ws, "send_json", side_effect=block_old_response),
        ):
            await old.send_json(
                {
                    "id": 1,
                    "sessionId": old_session_id,
                    "method": "Page.navigate",
                    "params": {"url": "https://old.example"},
                }
            )
            await asyncio.wait_for(old_send_started.wait(), 1)

            disconnect_task = asyncio.create_task(adapter.on_extension_disconnect())
            await asyncio.wait_for(old_cleanup_started.wait(), 1)

            new = await client.ws_connect(adapter.cdp_ws_url)
            registry.register_tab(42, "https://example.com", "Example")
            new_session_id = registry.root_session_id(42)
            navigation_key = (None, "Page.navigate")
            relay.block_send_keys.add(navigation_key)
            await new.send_json(
                {
                    "id": 1,
                    "sessionId": new_session_id,
                    "method": "Page.navigate",
                    "params": {"url": "https://new.example"},
                }
            )
            await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 42,
                    "method": "Page.frameNavigated",
                    "params": {
                        "frame": {
                            "id": "frame-42",
                            "url": "https://new.example",
                            "title": "New",
                        }
                    },
                },
            )

            await asyncio.wait_for(disconnect_task, 2)
            await asyncio.wait_for(old_response_cancelled.wait(), 1)
            relay.release_send[navigation_key].set()
            messages = [await new.receive_json(timeout=2) for _ in range(2)]
            assert registry.target_info_for_tab(42)["url"] == "https://new.example"
            await new.close()

    assert messages == [
        {
            "id": 1,
            "sessionId": new_session_id,
            "result": {"forwardedMethod": "Page.navigate"},
        },
        {
            "method": "Page.frameNavigated",
            "params": {
                "frame": {
                    "id": "frame-42",
                    "url": "https://new.example",
                    "title": "New",
                }
            },
            "sessionId": new_session_id,
        },
    ]


@pytest.mark.asyncio
async def test_stale_navigation_cleanup_after_new_navigation_flush_is_noop(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    old_send_started = asyncio.Event()
    release_old_send = asyncio.Event()
    sent: list[dict] = []

    async def record_send(_ws: object, payload: dict, _scope_guard: tuple[int, int] | None = None) -> None:
        if payload.get("id") == "old":
            old_send_started.set()
            await release_old_send.wait()
        sent.append(payload)

    adapter._client_ws = MagicMock(closed=False)
    adapter._client_ws.close = AsyncMock()
    old_ws = MagicMock()
    new_ws = MagicMock()
    old_session_id = registry.root_session_id(42)
    old_marker = await adapter._begin_navigation(42)
    old_cleanup = asyncio.create_task(
        adapter._finish_navigation(
            old_ws,
            "old",
            old_session_id,
            42,
            old_marker,
            result={"source": "old"},
        )
    )

    with patch.object(adapter, "_send", side_effect=record_send):
        await asyncio.wait_for(old_send_started.wait(), 1)
        adapter._reset_connection_state()
        registry.register_tab(42, "https://example.com", "Example")
        new_session_id = registry.root_session_id(42)

        new_marker = await adapter._begin_navigation(42)
        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 42,
                "method": "Page.frameNavigated",
                "params": {
                    "frame": {
                        "id": "frame-42",
                        "url": "https://new.example",
                        "title": "New",
                    }
                },
            },
        )
        await adapter._finish_navigation(
            new_ws,
            "new",
            new_session_id,
            42,
            new_marker,
            result={"source": "new"},
        )
        assert sent == [
            {"id": "new", "sessionId": new_session_id, "result": {"source": "new"}},
            {
                "method": "Page.frameNavigated",
                "params": {
                    "frame": {
                        "id": "frame-42",
                        "url": "https://new.example",
                        "title": "New",
                    }
                },
                "sessionId": new_session_id,
            },
        ]
        assert not adapter._navigation_in_flight
        assert not adapter._navigation_events

        latest_marker = await adapter._begin_navigation(42)
        await adapter.handle_extension_event(
            "debugger.event",
            {"tabId": 42, "method": "Page.lifecycleEvent", "params": {"name": "init"}},
        )
        release_old_send.set()
        await asyncio.wait_for(old_cleanup, 1)
        assert adapter._navigation_in_flight[42] == {latest_marker}
        assert len(adapter._navigation_events[42]) == 1

        await adapter._finish_navigation(
            new_ws,
            "latest",
            new_session_id,
            42,
            latest_marker,
            result={"source": "latest"},
        )

    assert sent[-2:] == [
        {"id": "latest", "sessionId": new_session_id, "result": {"source": "latest"}},
        {
            "method": "Page.lifecycleEvent",
            "params": {"name": "init"},
            "sessionId": new_session_id,
        },
    ]
    assert not adapter._navigation_in_flight
    assert not adapter._navigation_events


@pytest.mark.asyncio
async def test_stale_navigation_batch_is_dropped_after_connection_reset(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    old_session_id = registry.root_session_id(42)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)
    old_event_started = asyncio.Event()
    release_old_event = asyncio.Event()
    old_event_finished = asyncio.Event()
    old_cleanup_started = asyncio.Event()
    release_old_cleanup = asyncio.Event()
    original_cancel_client_tasks = adapter._cancel_client_tasks

    async def block_old_client_cleanup(*args: object) -> None:
        old_cleanup_started.set()
        await release_old_cleanup.wait()
        await original_cancel_client_tasks(*args)

    async with ClientSession() as client:
        old = await client.ws_connect(adapter.cdp_ws_url)
        old_server_ws = adapter._client_ws
        assert old_server_ws is not None
        original_send_json = old_server_ws.send_json

        async def block_old_event(payload: dict, *args: object, **kwargs: object) -> None:
            if payload.get("method") == "Page.lifecycleEvent":
                old_event_started.set()
                await release_old_event.wait()
                old_event_finished.set()
                return
            await original_send_json(payload, *args, **kwargs)

        with (
            patch.object(adapter, "_cancel_client_tasks", side_effect=block_old_client_cleanup),
            patch.object(old_server_ws, "send_json", side_effect=block_old_event),
        ):
            await old.send_json(
                {
                    "id": 1,
                    "sessionId": old_session_id,
                    "method": "Page.navigate",
                    "params": {"url": "https://old.example"},
                }
            )
            await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 42,
                    "method": "Page.lifecycleEvent",
                    "params": {"frameId": "frame-42", "name": "init"},
                },
            )
            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 42,
                    "method": "Page.frameNavigated",
                    "params": {
                        "frame": {
                            "id": "frame-42",
                            "url": "https://old.example/commit",
                            "title": "Old",
                        }
                    },
                },
            )
            relay.release_send[navigation_key].set()
            assert await receive_response(old, 1) == {
                "id": 1,
                "sessionId": old_session_id,
                "result": {"forwardedMethod": "Page.navigate"},
            }
            await asyncio.wait_for(old_event_started.wait(), 1)

            disconnect_task = asyncio.create_task(adapter.on_extension_disconnect())
            await asyncio.wait_for(old_cleanup_started.wait(), 1)

            new = await client.ws_connect(adapter.cdp_ws_url)
            registry.register_tab(42, "https://new.example", "New")
            new_session_id = registry.root_session_id(42)
            assert new_session_id != old_session_id

            release_old_event.set()
            await asyncio.wait_for(old_event_finished.wait(), 1)
            release_old_cleanup.set()
            await asyncio.wait_for(disconnect_task, 2)

            with pytest.raises(TimeoutError):
                await new.receive_json(timeout=0.05)
            assert registry.target_info_for_tab(42)["url"] == "https://new.example"
            await new.close()


@pytest.mark.asyncio
async def test_stale_navigation_overflow_batch_is_dropped_after_connection_reset(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    adapter._client_ws = MagicMock(closed=False)
    adapter._client_ws.close = AsyncMock()
    sent: list[dict] = []
    flush_started = asyncio.Event()
    release_flush = asyncio.Event()
    original_flush = adapter._flush_navigation_events

    async def pause_flush(
        tab_id: int,
        events: list[dict] | None = None,
        event_generation: int | None = None,
        *,
        forward_navigation_sensitive: bool = True,
    ) -> None:
        flush_started.set()
        await release_flush.wait()
        await original_flush(
            tab_id,
            events,
            event_generation,
            forward_navigation_sensitive=forward_navigation_sensitive,
        )

    async def record_send(_ws: object, payload: dict, _scope_guard: tuple[int, int] | None = None) -> None:
        sent.append(payload)

    await adapter._begin_navigation(42)
    for index in range(cdp_adapter_module._NAVIGATION_EVENT_BUFFER_LIMIT):
        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 42,
                "method": "Network.requestWillBeSent",
                "params": {"requestId": f"request-{index}"},
            },
        )

    with (
        patch.object(adapter, "_flush_navigation_events", side_effect=pause_flush),
        patch.object(adapter, "_send", side_effect=record_send),
        patch.object(cdp_adapter_module.LOG, "debug") as debug,
    ):
        overflow_task = asyncio.create_task(
            adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 42,
                    "method": "Page.frameNavigated",
                    "params": {
                        "frame": {
                            "id": "frame-42",
                            "url": "https://old.example/commit",
                            "title": "Old",
                        }
                    },
                },
            )
        )
        await asyncio.wait_for(flush_started.wait(), 1)
        adapter._reset_connection_state()
        registry.register_tab(42, "https://new.example", "New")
        release_flush.set()
        await asyncio.wait_for(overflow_task, 1)

        debug.assert_called_once_with(
            "browser_extension_stale_navigation_event_batch_dropped",
            tab_id=42,
            batch_generation=0,
            current_generation=1,
            buffered_event_count=cdp_adapter_module._NAVIGATION_EVENT_BUFFER_LIMIT,
        )

    assert sent == []
    assert registry.target_info_for_tab(42)["url"] == "https://new.example"


@pytest.mark.asyncio
async def test_stale_navigation_detach_batch_is_dropped_after_connection_reset(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    adapter._client_ws = MagicMock(closed=False)
    adapter._client_ws.close = AsyncMock()
    sent: list[dict] = []
    flush_started = asyncio.Event()
    release_flush = asyncio.Event()
    original_flush = adapter._flush_navigation_events

    async def pause_flush(
        tab_id: int,
        events: list[dict] | None = None,
        event_generation: int | None = None,
        *,
        forward_navigation_sensitive: bool = True,
    ) -> None:
        flush_started.set()
        await release_flush.wait()
        await original_flush(
            tab_id,
            events,
            event_generation,
            forward_navigation_sensitive=forward_navigation_sensitive,
        )

    async def record_send(_ws: object, payload: dict, _scope_guard: tuple[int, int] | None = None) -> None:
        sent.append(payload)

    await adapter._begin_navigation(42)
    await adapter.handle_extension_event(
        "debugger.event",
        {
            "tabId": 42,
            "method": "Page.frameNavigated",
            "params": {
                "frame": {
                    "id": "frame-42",
                    "url": "https://old.example/commit",
                    "title": "Old",
                }
            },
        },
    )

    with (
        patch.object(adapter, "_flush_navigation_events", side_effect=pause_flush),
        patch.object(adapter, "_send", side_effect=record_send),
        patch.object(cdp_adapter_module.LOG, "debug") as debug,
    ):
        detach_task = asyncio.create_task(adapter._abort_navigation(42))
        await asyncio.wait_for(flush_started.wait(), 1)
        adapter._reset_connection_state()
        registry.register_tab(42, "https://new.example", "New")
        release_flush.set()
        await asyncio.wait_for(detach_task, 1)

        debug.assert_called_once_with(
            "browser_extension_stale_navigation_event_batch_dropped",
            tab_id=42,
            batch_generation=0,
            current_generation=1,
            buffered_event_count=1,
        )

    assert sent == []
    assert registry.target_info_for_tab(42)["url"] == "https://new.example"


@pytest.mark.asyncio
async def test_debugger_detached_discards_buffered_navigation_event_before_error_response(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)
    relay.fail_send_keys[navigation_key] = ExtensionRequestError(
        "RESTRICTED_URL", "Navigation to a restricted URL is not allowed"
    )

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://restricted.example"},
            }
        )
        await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 42,
                "method": "Page.frameNavigated",
                "params": {"frame": {"id": "frame-42", "url": "https://restricted.example"}},
            },
        )

        await adapter.handle_extension_event("debugger.detached", {"tabId": 42, "reason": "canceled_by_user"})
        teardown = [await ws.receive_json(timeout=2) for _ in range(2)]
        assert [message["method"] for message in teardown] == [
            "Target.detachedFromTarget",
            "Target.targetDestroyed",
        ]
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        relay.release_send[navigation_key].set()
        navigation_response = await receive_response(ws, 1)
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

    assert navigation_response == {
        "id": 1,
        "sessionId": session_id,
        "error": {"code": -32000, "message": "RESTRICTED_URL: Navigation to a restricted URL is not allowed"},
    }
    assert teardown[0]["params"] == {"sessionId": session_id, "targetId": "tab-42"}
    assert teardown[1]["params"] == {"targetId": "tab-42"}


@pytest.mark.asyncio
async def test_navigation_response_first_passes_events_through_unchanged(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://destination.example"},
            }
        )
        response = await receive_response(ws, 1)
        event_params = {"frameId": "frame-42", "name": "init"}
        await adapter.handle_extension_event(
            "debugger.event",
            {"tabId": 42, "method": "Page.lifecycleEvent", "params": event_params},
        )
        event = await receive_event(ws, "Page.lifecycleEvent")

    assert response == {
        "id": 1,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert event == {"method": "Page.lifecycleEvent", "params": event_params, "sessionId": session_id}


@pytest.mark.asyncio
async def test_navigation_error_flushes_buffered_events(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)
    relay.fail_send_keys[navigation_key] = ExtensionRequestError("COMMAND_TIMEOUT", "navigation timed out")
    navigation_events = [
        {"method": "Page.frameStartedNavigating", "params": {"frameId": "frame-42"}},
        {"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
    ]

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://destination.example"},
            }
        )
        await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
        for event in navigation_events:
            await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})

        relay.release_send[navigation_key].set()
        messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]

    assert messages[0] == {
        "id": 1,
        "sessionId": session_id,
        "error": {"code": -32000, "message": "COMMAND_TIMEOUT: navigation timed out"},
    }
    assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]


@pytest.mark.asyncio
async def test_navigation_events_for_another_tab_are_not_held(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://one.example", "One")
    registry.register_tab(43, "https://two.example", "Two")
    session_id = registry.root_session_id(42)
    other_session_id = registry.root_session_id(43)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://destination.example"},
            }
        )
        await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
        event_params = {"frameId": "frame-43", "name": "init"}
        await adapter.handle_extension_event(
            "debugger.event",
            {"tabId": 43, "method": "Page.lifecycleEvent", "params": event_params},
        )
        other_tab_event = await receive_event(ws, "Page.lifecycleEvent")

        relay.release_send[navigation_key].set()
        navigation_response = await receive_response(ws, 1)

    assert other_tab_event == {
        "method": "Page.lifecycleEvent",
        "params": event_params,
        "sessionId": other_session_id,
    }
    assert navigation_response["result"] == {"forwardedMethod": "Page.navigate"}


@pytest.mark.asyncio
async def test_navigation_event_buffer_overflow_flushes_and_warns(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)
    event_count = cdp_adapter_module._NAVIGATION_EVENT_BUFFER_LIMIT + 1

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://destination.example"},
            }
        )
        await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
        with patch.object(cdp_adapter_module.LOG, "warning") as warning:
            for index in range(event_count):
                await adapter.handle_extension_event(
                    "debugger.event",
                    {
                        "tabId": 42,
                        "method": "Network.requestWillBeSent",
                        "params": {"requestId": f"request-{index}"},
                    },
                )

            relay.release_send[navigation_key].set()
            messages = [await ws.receive_json(timeout=2) for _ in range(event_count + 1)]
            warning.assert_called_once()

    assert [message["params"]["requestId"] for message in messages[:-1]] == [
        f"request-{index}" for index in range(event_count)
    ]
    assert messages[-1] == {
        "id": 1,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert warning.call_args.args == ("browser_extension_navigation_event_buffer_overflow",)
    assert warning.call_args.kwargs["tab_id"] == 42
    assert warning.call_args.kwargs["forwarded_non_navigation_event_count"] == event_count
    assert warning.call_args.kwargs["buffered_navigation_event_count"] == 0


def test_navigation_sensitive_event_bound_keeps_execution_context_events() -> None:
    adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), StubRelay())
    execution_context_event = {
        "method": "Runtime.executionContextCreated",
        "params": {"context": {"id": 1}},
    }
    other_events = [
        {"method": "Page.frameAttached", "params": {"frameId": f"frame-{index}"}}
        for index in range(cdp_adapter_module._NAVIGATION_SENSITIVE_EVENT_BUFFER_LIMIT + 1)
    ]

    with patch.object(cdp_adapter_module.LOG, "warning") as warning:
        retained_events = adapter._bound_navigation_sensitive_events(42, [execution_context_event, *other_events])

    assert len(retained_events) == cdp_adapter_module._NAVIGATION_SENSITIVE_EVENT_BUFFER_LIMIT
    assert retained_events[0] == execution_context_event
    assert retained_events[1:] == other_events[-(cdp_adapter_module._NAVIGATION_SENSITIVE_EVENT_BUFFER_LIMIT - 1) :]
    assert warning.call_args.kwargs["dropped_execution_context_event_count"] == 0


@pytest.mark.asyncio
async def test_navigation_event_overflow_keeps_sensitive_events_until_response(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    navigation_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigation_key)
    network_event_count = 2500
    navigation_events = [
        {"method": "Page.frameStartedLoading", "params": {"frameId": "frame-42"}},
        {
            "method": "Page.frameNavigated",
            "params": {
                "frame": {
                    "id": "frame-42",
                    "url": "https://destination.example",
                    "title": "Destination",
                }
            },
        },
        {"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
    ]

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://destination.example"},
            }
        )
        await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)

        for index in range(network_event_count):
            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 42,
                    "method": "Network.requestWillBeSent",
                    "params": {"requestId": f"request-{index}"},
                },
            )

        early_messages = [await ws.receive_json(timeout=2) for _ in range(network_event_count)]
        assert [message["method"] for message in early_messages] == ["Network.requestWillBeSent"] * network_event_count
        assert [message["params"]["requestId"] for message in early_messages] == [
            f"request-{index}" for index in range(network_event_count)
        ]

        for event in navigation_events:
            await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        relay.release_send[navigation_key].set()
        messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]

    assert messages[0] == {
        "id": 1,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
    assert registry.target_info_for_tab(42)["url"] == "https://destination.example"


@pytest.mark.asyncio
async def test_overlapping_navigation_error_waits_for_earlier_response_before_flushing_events(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    first_started = asyncio.Event()
    second_started = asyncio.Event()
    release_first = asyncio.Event()
    navigation_count = 0
    original_request = relay.request

    async def request_in_answer_order(op: str, args: dict, timeout: float = 30.0) -> dict:
        nonlocal navigation_count
        if op == "debugger.send" and args["method"] == "Page.navigate":
            navigation_count += 1
            if navigation_count == 1:
                first_started.set()
                await release_first.wait()
            else:
                second_started.set()
                raise ExtensionRequestError("RESOURCE_LIMIT", "navigation rejected")
        return await original_request(op, args, timeout)

    relay.request = request_in_answer_order
    navigation_events = [
        {
            "method": "Page.frameNavigated",
            "params": {"frame": {"id": "frame-42", "url": "https://destination.example", "title": "Destination"}},
        },
        {"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
    ]

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://first.example"},
            }
        )
        await asyncio.wait_for(first_started.wait(), 1)
        await ws.send_json(
            {
                "id": 2,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://second.example"},
            }
        )
        await asyncio.wait_for(second_started.wait(), 1)

        second_error = await receive_response(ws, 2)
        for event in navigation_events:
            await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        release_first.set()
        messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]

    assert second_error == {
        "id": 2,
        "sessionId": session_id,
        "error": {"code": -32000, "message": "RESOURCE_LIMIT: navigation rejected"},
    }
    assert messages[0] == {
        "id": 1,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]


@pytest.mark.asyncio
async def test_overlapping_navigation_responses_flush_interleaved_events_after_both_responses(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    first_started = asyncio.Event()
    second_started = asyncio.Event()
    release_first = asyncio.Event()
    release_second = asyncio.Event()
    navigation_count = 0
    original_request = relay.request

    async def request_in_answer_order(op: str, args: dict, timeout: float = 30.0) -> dict:
        nonlocal navigation_count
        if op == "debugger.send" and args["method"] == "Page.navigate":
            navigation_count += 1
            if navigation_count == 1:
                first_started.set()
                await release_first.wait()
            else:
                second_started.set()
                await release_second.wait()
        return await original_request(op, args, timeout)

    relay.request = request_in_answer_order
    navigation_events = [
        {"method": "Page.frameStartedNavigating", "params": {"frameId": "frame-42", "url": "https://first.example"}},
        {"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
        {
            "method": "Page.frameNavigated",
            "params": {"frame": {"id": "frame-42", "url": "https://second.example", "title": "Second"}},
        },
    ]

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://first.example"},
            }
        )
        await asyncio.wait_for(first_started.wait(), 1)
        await ws.send_json(
            {
                "id": 2,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://second.example"},
            }
        )
        await asyncio.wait_for(second_started.wait(), 1)

        await adapter.handle_extension_event("debugger.event", {"tabId": 42, **navigation_events[0]})
        release_first.set()
        first_response = await receive_response(ws, 1)
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        await adapter.handle_extension_event("debugger.event", {"tabId": 42, **navigation_events[1]})
        await adapter.handle_extension_event("debugger.event", {"tabId": 42, **navigation_events[2]})
        release_second.set()
        messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]

    assert first_response == {
        "id": 1,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert messages[0] == {
        "id": 2,
        "sessionId": session_id,
        "result": {"forwardedMethod": "Page.navigate"},
    }
    assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]


@pytest.mark.asyncio
async def test_navigation_completion_does_not_flush_events_while_another_navigation_is_outstanding(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)
    first_started = asyncio.Event()
    second_started = asyncio.Event()
    release_first = asyncio.Event()
    navigation_count = 0
    original_request = relay.request

    async def request_with_second_completion_first(op: str, args: dict, timeout: float = 30.0) -> dict:
        nonlocal navigation_count
        if op == "debugger.send" and args["method"] == "Page.navigate":
            navigation_count += 1
            if navigation_count == 1:
                first_started.set()
                await release_first.wait()
            else:
                second_started.set()
        return await original_request(op, args, timeout)

    relay.request = request_with_second_completion_first

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json(
            {
                "id": 1,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://first.example"},
            }
        )
        await asyncio.wait_for(first_started.wait(), 1)
        await ws.send_json(
            {
                "id": 2,
                "sessionId": session_id,
                "method": "Page.navigate",
                "params": {"url": "https://second.example"},
            }
        )
        await asyncio.wait_for(second_started.wait(), 1)
        assert await receive_response(ws, 2) == {
            "id": 2,
            "sessionId": session_id,
            "result": {"forwardedMethod": "Page.navigate"},
        }

        event = {"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}}
        await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        release_first.set()
        assert await receive_response(ws, 1) == {
            "id": 1,
            "sessionId": session_id,
            "result": {"forwardedMethod": "Page.navigate"},
        }
        assert await receive_event(ws, "Page.lifecycleEvent") == {
            "method": "Page.lifecycleEvent",
            "params": event["params"],
            "sessionId": session_id,
        }


@pytest.mark.parametrize(
    ("method", "params"),
    [
        ("Network.getAllCookies", {}),
        ("Network.getCookies", {"urls": ["https://unshared.example"]}),
    ],
)
@pytest.mark.asyncio
async def test_session_command_rejects_denied_cdp_methods(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
    method: str,
    params: dict,
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(42, "https://example.com", "Example")
    session_id = registry.root_session_id(42)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "sessionId": session_id, "method": method, "params": params})
        response = await receive_response(ws, 1)

    assert response == {
        "id": 1,
        "sessionId": session_id,
        "error": {
            "code": -32000,
            "message": "CDP_METHOD_NOT_ALLOWED: The requested CDP method is not allowed.",
        },
    }
    assert relay.calls == []


@pytest.mark.asyncio
async def test_page_attach_aliases_are_unique_route_commands_and_receive_root_events() -> None:
    relay = StubRelay([{"tabId": 42, "url": "https://example.com", "title": "Example"}])
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            await receive_response(ws, 1)
            primary_attached = await receive_event(ws, "Target.attachedToTarget")
            primary_session_id = primary_attached["params"]["sessionId"]

            for request_id in (2, 3):
                await ws.send_json(
                    {
                        "id": request_id,
                        "method": "Target.attachToTarget",
                        "params": {"targetId": "tab-42", "flatten": True},
                    }
                )
            first_alias = (await receive_response(ws, 2))["result"]["sessionId"]
            second_alias = (await receive_response(ws, 3))["result"]["sessionId"]

            assert len({primary_session_id, first_alias, second_alias}) == 3
            await ws.send_json({"id": 4, "sessionId": first_alias, "method": "Runtime.enable", "params": {}})
            assert (await receive_response(ws, 4))["sessionId"] == first_alias

            event_params = {"name": "networkAlmostIdle", "frameId": "main"}
            await adapter.handle_extension_event(
                "debugger.event",
                {"tabId": 42, "method": "Page.lifecycleEvent", "params": event_params},
            )
            routed_events = [await receive_event(ws, "Page.lifecycleEvent") for _ in range(3)]
            assert {event["sessionId"] for event in routed_events} == {
                primary_session_id,
                first_alias,
                second_alias,
            }

            await ws.send_json({"id": 5, "method": "Target.detachFromTarget", "params": {"sessionId": first_alias}})
            assert await receive_response(ws, 5) == {"id": 5, "result": {}}
            assert all(op != "debugger.detach" for op, _ in relay.calls)
            with pytest.raises(KeyError):
                registry.resolve_session(first_alias)
            assert registry.resolve_session(second_alias) == (42, None)
    finally:
        await adapter.stop()


@pytest.mark.asyncio
async def test_browser_alias_routes_root_commands_and_detaches_independently(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.attachToBrowserTarget", "params": {}})
        first_alias = (await receive_response(ws, 1))["result"]["sessionId"]
        await ws.send_json({"id": 2, "method": "Target.attachToBrowserTarget", "params": {}})
        second_alias = (await receive_response(ws, 2))["result"]["sessionId"]

        assert first_alias != second_alias
        await ws.send_json({"id": 3, "sessionId": first_alias, "method": "Browser.getVersion", "params": {}})
        version = await receive_response(ws, 3)
        assert version["sessionId"] == first_alias
        assert version["result"]["protocolVersion"] == "1.3"

        await ws.send_json({"id": 4, "method": "Target.detachFromTarget", "params": {"sessionId": first_alias}})
        assert await receive_response(ws, 4) == {"id": 4, "result": {}}
        assert not registry.is_browser_session_alias(first_alias)
        assert registry.is_browser_session_alias(second_alias)

        await ws.send_json({"id": 5, "sessionId": first_alias, "method": "Browser.getVersion", "params": {}})
        assert (await receive_response(ws, 5))["error"]["code"] == -32001


@pytest.mark.asyncio
async def test_child_attach_recurses_and_detach_unregisters(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(12, "https://example.com", "Example")
    root_session_id = registry.root_session_id(12)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        await receive_response(ws, 1)
        await receive_event(ws, "Target.attachedToTarget")
        relay.calls.clear()

        target_info = {
            "targetId": "frame-12",
            "type": "iframe",
            "title": "",
            "url": "https://example.com/frame",
            "attached": True,
            "canAccessOpener": False,
            "browserContextId": "skyvern-default",
        }
        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 12,
                "method": "Target.attachedToTarget",
                "params": {"sessionId": "child-12", "targetInfo": target_info, "waitingForDebugger": False},
            },
        )
        attached = await receive_event(ws, "Target.attachedToTarget")

        await ws.send_json({"id": 2, "sessionId": "child-12", "method": "Runtime.enable", "params": {}})
        await receive_response(ws, 2)

        await adapter.handle_extension_event(
            "debugger.event",
            {"tabId": 12, "method": "Target.detachedFromTarget", "params": {"sessionId": "child-12"}},
        )
        detached = await receive_event(ws, "Target.detachedFromTarget")

    assert attached["sessionId"] == root_session_id
    assert relay.calls[0] == (
        "debugger.send",
        {
            "tabId": 12,
            "sessionId": "child-12",
            "method": "Target.setAutoAttach",
            "params": {
                "flatten": True,
                "autoAttach": True,
                "waitForDebuggerOnStart": False,
                "filter": [{"type": "iframe", "exclude": False}],
            },
        },
    )
    assert relay.calls[1][1]["sessionId"] == "child-12"
    assert detached["params"] == {"sessionId": "child-12"}
    with pytest.raises(KeyError):
        registry.resolve_session("child-12")


@pytest.mark.asyncio
async def test_child_detach_during_post_registration_window_emits_and_unregisters(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(17, "https://example.com", "Example")
    child_session_id = "child-17"
    replay_started = asyncio.Event()
    release_replay = asyncio.Event()

    async def block_replay(session_id: str) -> None:
        assert session_id == child_session_id
        replay_started.set()
        await release_replay.wait()

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        await receive_response(ws, 1)
        await receive_event(ws, "Target.attachedToTarget")

        with patch.object(adapter, "_replay_buffered_child_events", side_effect=block_replay):
            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 17,
                    "method": "Target.attachedToTarget",
                    "params": {
                        "sessionId": child_session_id,
                        "targetInfo": {
                            "targetId": "frame-17",
                            "type": "iframe",
                            "title": "",
                            "url": "https://example.com/frame",
                            "attached": True,
                            "canAccessOpener": False,
                            "browserContextId": "skyvern-default",
                        },
                        "waitingForDebugger": False,
                    },
                },
            )
            await receive_event(ws, "Target.attachedToTarget")
            await asyncio.wait_for(replay_started.wait(), 1)
            assert child_session_id in adapter._pending_child_sessions
            assert registry.resolve_session(child_session_id) == (17, child_session_id)

            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 17,
                    "method": "Target.detachedFromTarget",
                    "params": {"sessionId": child_session_id},
                },
            )
            detached = await receive_event(ws, "Target.detachedFromTarget")

            await ws.send_json({"id": 2, "sessionId": child_session_id, "method": "Runtime.enable", "params": {}})
            missing = await receive_response(ws, 2)
            release_replay.set()

    assert detached["params"] == {"sessionId": child_session_id}
    assert missing == {
        "id": 2,
        "sessionId": child_session_id,
        "error": {"code": -32001, "message": "session not found"},
    }


@pytest.mark.asyncio
async def test_child_detach_before_probe_completes_is_swallowed_and_tombstones_initialization(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(18, "https://example.com", "Example")
    child_session_id = "child-18"
    probe_key = (child_session_id, "Target.setAutoAttach")
    relay.block_send_keys.add(probe_key)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        await receive_response(ws, 1)
        await receive_event(ws, "Target.attachedToTarget")

        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 18,
                "method": "Target.attachedToTarget",
                "params": {
                    "sessionId": child_session_id,
                    "targetInfo": {
                        "targetId": "frame-18",
                        "type": "iframe",
                        "title": "",
                        "url": "https://example.com/frame",
                        "attached": True,
                        "canAccessOpener": False,
                        "browserContextId": "skyvern-default",
                    },
                    "waitingForDebugger": False,
                },
            },
        )
        await asyncio.wait_for(relay.send_started.setdefault(probe_key, asyncio.Event()).wait(), 1)
        initialization_task = next(task for task in adapter._background_tasks if not task.done())

        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 18,
                "method": "Target.detachedFromTarget",
                "params": {"sessionId": child_session_id},
            },
        )
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

        relay.release_send[probe_key].set()
        await asyncio.wait_for(initialization_task, 1)

    with pytest.raises(KeyError):
        registry.resolve_session(child_session_id)


@pytest.mark.asyncio
async def test_nested_child_attach_during_parent_probe_is_replayed_in_parent_first_order(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(13, "https://parent.example", "Parent")
    root_session_id = registry.root_session_id(13)
    parent_session_id = "parent-child-13"
    grandchild_session_id = "grandchild-13"
    parent_probe_key = (parent_session_id, "Target.setAutoAttach")
    relay.block_send_keys.add(parent_probe_key)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        await receive_response(ws, 1)
        await receive_event(ws, "Target.attachedToTarget")
        relay.calls.clear()

        parent_params = {
            "sessionId": parent_session_id,
            "targetInfo": {
                "targetId": "parent-frame-13",
                "type": "iframe",
                "title": "",
                "url": "https://parent.example/frame",
                "attached": True,
                "canAccessOpener": False,
                "browserContextId": "skyvern-default",
            },
            "waitingForDebugger": False,
        }
        await adapter.handle_extension_event(
            "debugger.event",
            {"tabId": 13, "method": "Target.attachedToTarget", "params": parent_params},
        )
        await asyncio.wait_for(relay.send_started.setdefault(parent_probe_key, asyncio.Event()).wait(), 1)

        grandchild_params = {
            "sessionId": grandchild_session_id,
            "targetInfo": {
                "targetId": "grandchild-frame-13",
                "type": "iframe",
                "title": "",
                "url": "https://grandchild.example/frame",
                "attached": True,
                "canAccessOpener": False,
                "browserContextId": "skyvern-default",
            },
            "waitingForDebugger": False,
        }
        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 13,
                "sessionId": parent_session_id,
                "method": "Target.attachedToTarget",
                "params": grandchild_params,
            },
        )

        relay.release_send[parent_probe_key].set()
        parent_attached = await receive_event(ws, "Target.attachedToTarget")
        grandchild_attached = await receive_event(ws, "Target.attachedToTarget")
        assert registry.resolve_session(grandchild_session_id) == (13, grandchild_session_id)

    assert parent_attached["sessionId"] == root_session_id
    assert parent_attached["params"] == parent_params
    assert grandchild_attached["sessionId"] == parent_session_id
    assert grandchild_attached["params"] == grandchild_params


@pytest.mark.asyncio
async def test_nested_child_attach_is_detached_when_parent_probe_fails(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(15, "https://parent.example", "Parent")
    parent_session_id = "parent-child-15"
    grandchild_session_id = "grandchild-15"
    parent_probe_key = (parent_session_id, "Target.setAutoAttach")
    relay.block_send_keys.add(parent_probe_key)
    relay.fail_send_keys[parent_probe_key] = ExtensionRequestError("INTERNAL", "parent probe failed")

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
        await receive_response(ws, 1)
        await receive_event(ws, "Target.attachedToTarget")
        relay.calls.clear()

        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 15,
                "method": "Target.attachedToTarget",
                "params": {
                    "sessionId": parent_session_id,
                    "targetInfo": {
                        "targetId": "parent-frame-15",
                        "type": "iframe",
                        "title": "",
                        "url": "https://parent.example/frame",
                        "attached": True,
                        "canAccessOpener": False,
                        "browserContextId": "skyvern-default",
                    },
                    "waitingForDebugger": False,
                },
            },
        )
        await asyncio.wait_for(relay.send_started.setdefault(parent_probe_key, asyncio.Event()).wait(), 1)

        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 15,
                "sessionId": parent_session_id,
                "method": "Target.attachedToTarget",
                "params": {
                    "sessionId": grandchild_session_id,
                    "targetInfo": {
                        "targetId": "grandchild-frame-15",
                        "type": "iframe",
                        "title": "",
                        "url": "https://grandchild.example/frame",
                        "attached": True,
                        "canAccessOpener": False,
                        "browserContextId": "skyvern-default",
                    },
                    "waitingForDebugger": False,
                },
            },
        )

        relay.release_send[parent_probe_key].set()
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)
        with pytest.raises(KeyError):
            registry.resolve_session(parent_session_id)
        with pytest.raises(KeyError):
            registry.resolve_session(grandchild_session_id)

    assert (
        "debugger.send",
        {
            "tabId": 15,
            "sessionId": grandchild_session_id,
            "method": "Runtime.runIfWaitingForDebugger",
            "params": {},
        },
    ) in relay.calls
    assert (
        "debugger.send",
        {
            "tabId": 15,
            "method": "Target.detachFromTarget",
            "params": {"sessionId": grandchild_session_id},
        },
    ) in relay.calls


@pytest.mark.asyncio
async def test_pending_child_detach_does_not_wait_for_buffered_grandchild_cleanup(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(19, "https://parent.example", "Parent")
    parent_session_id = "parent-child-19"
    grandchild_session_id = "grandchild-19"
    resume_key = (grandchild_session_id, "Runtime.runIfWaitingForDebugger")
    relay.block_send_keys.add(resume_key)
    adapter._pending_child_sessions.add(parent_session_id)
    adapter._pending_child_events[parent_session_id] = [
        {
            "tabId": 19,
            "sessionId": parent_session_id,
            "method": "Target.attachedToTarget",
            "params": {
                "sessionId": grandchild_session_id,
                "targetInfo": {
                    "targetId": "grandchild-frame-19",
                    "type": "iframe",
                    "title": "",
                    "url": "https://grandchild.example/frame",
                    "attached": True,
                    "canAccessOpener": False,
                    "browserContextId": "skyvern-default",
                },
                "waitingForDebugger": False,
            },
        }
    ]

    await asyncio.wait_for(
        adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 19,
                "method": "Target.detachedFromTarget",
                "params": {"sessionId": parent_session_id},
            },
        ),
        0.5,
    )
    await asyncio.wait_for(relay.send_started.setdefault(resume_key, asyncio.Event()).wait(), 0.5)
    relay.release_send.setdefault(resume_key, asyncio.Event()).set()

    async def grandchild_detached() -> None:
        expected = (
            "debugger.send",
            {
                "tabId": 19,
                "method": "Target.detachFromTarget",
                "params": {"sessionId": grandchild_session_id},
            },
        )
        while expected not in relay.calls:
            await asyncio.sleep(0)

    await asyncio.wait_for(grandchild_detached(), 0.5)
    assert parent_session_id not in adapter._pending_child_sessions
    assert parent_session_id not in adapter._pending_child_events


@pytest.mark.asyncio
async def test_child_initialization_keeps_live_outer_alias_when_another_alias_is_dead(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(20, "https://parent.example", "Parent")
    adapter._auto_attach = True
    dead_alias = registry.create_root_session_alias(20)
    live_alias = registry.create_root_session_alias(20)
    assert registry.remove_root_session_alias(dead_alias)
    child_session_id = "child-20"
    target_info = {
        "targetId": "frame-20",
        "type": "iframe",
        "title": "",
        "url": "https://child.example/frame",
        "attached": True,
        "canAccessOpener": False,
        "browserContextId": "skyvern-default",
    }
    event_params = {
        "sessionId": child_session_id,
        "targetInfo": target_info,
        "waitingForDebugger": False,
    }
    adapter._pending_child_sessions.add(child_session_id)

    with patch.object(adapter, "_emit_to_sessions", wraps=adapter._emit_to_sessions) as emit_to_sessions:
        await adapter._initialize_child_target(
            20,
            child_session_id,
            target_info,
            event_params,
            [dead_alias, live_alias],
        )

    assert registry.resolve_session(child_session_id) == (20, child_session_id)
    emit_to_sessions.assert_awaited_once_with("Target.attachedToTarget", event_params, [live_alias])


@pytest.mark.asyncio
async def test_child_initialization_resumes_and_detaches_when_all_outer_aliases_are_dead(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(21, "https://parent.example", "Parent")
    adapter._auto_attach = True
    outer_session_ids = registry.root_session_ids(21)
    registry.remove_tab(21)
    child_session_id = "child-21"
    target_info = {
        "targetId": "frame-21",
        "type": "iframe",
        "title": "",
        "url": "https://child.example/frame",
        "attached": True,
        "canAccessOpener": False,
        "browserContextId": "skyvern-default",
    }
    adapter._pending_child_sessions.add(child_session_id)

    await adapter._initialize_child_target(
        21,
        child_session_id,
        target_info,
        {"sessionId": child_session_id, "targetInfo": target_info, "waitingForDebugger": False},
        outer_session_ids,
    )

    assert (
        "debugger.send",
        {
            "tabId": 21,
            "sessionId": child_session_id,
            "method": "Runtime.runIfWaitingForDebugger",
            "params": {},
        },
    ) in relay.calls
    assert (
        "debugger.send",
        {
            "tabId": 21,
            "method": "Target.detachFromTarget",
            "params": {"sessionId": child_session_id},
        },
    ) in relay.calls
    assert child_session_id not in adapter._pending_child_sessions
    with pytest.raises(KeyError):
        registry.resolve_session(child_session_id)


@pytest.mark.asyncio
async def test_child_auto_attach_failure_skips_session_and_navigation_lifecycle_continues() -> None:
    relay = StubRelay([{"tabId": 14, "url": "https://page.example", "title": "Page"}])
    registry = VirtualTargetRegistry()
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
            await receive_response(ws, 1)
            await receive_event(ws, "Target.attachedToTarget")
            relay.calls.clear()
            relay.fail_send_keys[("unsupported-child", "Target.setAutoAttach")] = ExtensionRequestError(
                "INTERNAL", "child target does not support auto-attach"
            )

            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 14,
                    "method": "Target.attachedToTarget",
                    "params": {
                        "sessionId": "unsupported-child",
                        "targetInfo": {
                            "targetId": "unsupported-target",
                            "type": "iframe",
                            "title": "",
                            "url": "https://frame.example",
                            "attached": True,
                            "canAccessOpener": False,
                            "browserContextId": "skyvern-default",
                        },
                        "waitingForDebugger": False,
                    },
                },
            )
            await asyncio.sleep(0)

            with pytest.raises(KeyError):
                registry.resolve_session("unsupported-child")
            with pytest.raises(TimeoutError):
                await ws.receive_json(timeout=0.05)

            root_session_id = registry.root_session_id(14)
            await ws.send_json(
                {
                    "id": 2,
                    "sessionId": root_session_id,
                    "method": "Page.navigate",
                    "params": {"url": "https://destination.example"},
                }
            )
            assert (await receive_response(ws, 2))["result"] == {"forwardedMethod": "Page.navigate"}

            lifecycle_params = {"name": "DOMContentLoaded", "frameId": "main"}
            await adapter.handle_extension_event(
                "debugger.event",
                {
                    "tabId": 14,
                    "method": "Page.lifecycleEvent",
                    "params": lifecycle_params,
                },
            )
            lifecycle = await receive_event(ws, "Page.lifecycleEvent")
            assert lifecycle["sessionId"] == root_session_id
            assert lifecycle["params"] == lifecycle_params
    finally:
        await adapter.stop()

    assert (
        "debugger.send",
        {
            "tabId": 14,
            "method": "Target.detachFromTarget",
            "params": {"sessionId": "unsupported-child"},
        },
    ) in relay.calls


@pytest.mark.asyncio
async def test_slow_session_command_does_not_block_independent_session_command() -> None:
    relay = StubRelay()
    registry = VirtualTargetRegistry()
    registry.register_tab(16, "https://page.example", "Page")
    session_id = registry.root_session_id(16)
    navigate_key = (None, "Page.navigate")
    relay.block_send_keys.add(navigate_key)
    adapter = ExtensionCdpAdapter(registry, relay)
    await adapter.start()
    try:
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json(
                {
                    "id": 1,
                    "sessionId": session_id,
                    "method": "Page.navigate",
                    "params": {"url": "https://destination.example"},
                }
            )
            await asyncio.wait_for(relay.send_started.setdefault(navigate_key, asyncio.Event()).wait(), 1)

            await ws.send_json(
                {
                    "id": 2,
                    "sessionId": session_id,
                    "method": "Runtime.runIfWaitingForDebugger",
                    "params": {},
                }
            )
            fast_response = await receive_response(ws, 2)
            assert fast_response["result"] == {"forwardedMethod": "Runtime.runIfWaitingForDebugger"}

            relay.release_send.setdefault(navigate_key, asyncio.Event()).set()
            navigate_response = await receive_response(ws, 1)
            assert navigate_response["result"] == {"forwardedMethod": "Page.navigate"}
    finally:
        relay.release_send.setdefault(navigate_key, asyncio.Event()).set()
        await adapter.stop()


@pytest.mark.asyncio
async def test_get_target_info_returns_registered_child_target(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(13, "https://example.com", "Example")
    child_target_info = {
        "targetId": "frame-13",
        "type": "iframe",
        "title": "Frame",
        "url": "https://example.com/frame",
        "attached": True,
        "canAccessOpener": False,
        "browserContextId": "skyvern-default",
    }
    registry.register_child_session(13, "child-13", child_target_info)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.getTargetInfo", "params": {"targetId": "frame-13"}})
        response = await receive_response(ws, 1)

    assert response == {"id": 1, "result": {"targetInfo": child_target_info}}


@pytest.mark.asyncio
async def test_root_session_target_info_is_answered_locally_but_explicit_target_is_forwarded(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(13, "https://example.com", "Example")
    root_session_id = registry.root_session_id(13)
    alias_session_id = registry.create_root_session_alias(13)
    adapter._active_scope_generation(13)
    adapter._attached_tabs.add(13)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "sessionId": alias_session_id, "method": "Target.getTargetInfo", "params": {}})
        local_response = await receive_response(ws, 1)
        await ws.send_json(
            {
                "id": 2,
                "sessionId": alias_session_id,
                "method": "Target.getTargetInfo",
                "params": {"targetId": "tab-13"},
            }
        )
        forwarded_response = await receive_response(ws, 2)
        await ws.send_json({"id": 3, "method": "Target.detachFromTarget", "params": {"sessionId": alias_session_id}})
        assert await receive_response(ws, 3) == {"id": 3, "result": {}}
        await ws.send_json({"id": 4, "sessionId": root_session_id, "method": "Runtime.evaluate", "params": {}})
        main_response = await receive_response(ws, 4)

    assert local_response["result"]["targetInfo"]["targetId"] == "tab-13"
    assert forwarded_response["result"] == {"forwardedMethod": "Target.getTargetInfo"}
    assert main_response["result"] == {"forwardedMethod": "Runtime.evaluate"}
    assert relay.calls == [
        (
            "debugger.send",
            {"tabId": 13, "method": "Target.getTargetInfo", "params": {"targetId": "tab-13"}},
        ),
        (
            "debugger.send",
            {"tabId": 13, "method": "Runtime.evaluate", "params": {}},
        ),
    ]


@pytest.mark.asyncio
async def test_revoked_root_session_target_info_uses_forwarded_error(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(14, "https://example.com", "Example")
    adapter._active_scope_generation(14)
    adapter._attached_tabs.add(14)
    alias_session_id = registry.create_root_session_alias(14)
    lock = adapter._attach_locks.setdefault(14, asyncio.Lock())
    await lock.acquire()
    removal_task = asyncio.create_task(adapter._remove_tab_with_events(14))
    try:
        await asyncio.sleep(0)
        relay.fail_next = BrowserExtensionBrokerError("LEASE_REQUIRED", "Tab 14 is not in the controlled scope")
        async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
            await ws.send_json({"id": 1, "sessionId": alias_session_id, "method": "Target.getTargetInfo", "params": {}})
            response = await receive_response(ws, 1)
    finally:
        lock.release()
        await removal_task

    assert response == {
        "id": 1,
        "sessionId": alias_session_id,
        "error": {"code": -32000, "message": "LEASE_REQUIRED: Tab 14 is not in the controlled scope"},
    }


@pytest.mark.asyncio
async def test_target_attachment_snapshot_requires_attached_live_root_target(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(15, "https://example.com", "Example")
    generation = adapter._active_scope_generation(15)
    assert generation is not None
    target_id = registry.target_id_for_tab(15)

    assert adapter.target_attachment_snapshot(target_id) is False
    adapter._attached_tabs.add(15)
    assert adapter.target_attachment_snapshot(target_id) is True

    await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "canceled_by_user"})
    assert adapter.target_attachment_snapshot(target_id) is False


@pytest.mark.asyncio
async def test_debugger_detached_relay_clears_page_attachment_and_forwards_target_detach_once(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(15, "https://example.com", "Example")
    adapter._active_scope_generation(15)
    adapter._attached_tabs.add(15)
    target_id = registry.target_id_for_tab(15)
    session_id = registry.root_session_id(15)
    runtime = BrowserExtensionRuntime(relay, adapter)

    page = MagicMock()
    page.is_closed.return_value = False
    cdp_session = MagicMock()
    cdp_session.send = AsyncMock(return_value={"targetInfo": {"targetId": target_id}})
    cdp_session.detach = AsyncMock()
    page.context = SimpleNamespace(new_cdp_session=AsyncMock(return_value=cdp_session))

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        assert await runtime.page_debugger_attached(page) is True
        await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "controllability_lost"})
        await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "controllability_lost"})
        assert await runtime.page_debugger_attached(page) is False
        assert adapter.target_attachment_snapshot(target_id) is False

        detached = await receive_event(ws, "Target.detachedFromTarget")
        destroyed = await receive_event(ws, "Target.targetDestroyed")
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)

    assert detached["params"] == {"sessionId": session_id, "targetId": target_id}
    assert destroyed["params"] == {"targetId": target_id}
    assert 15 not in adapter._attached_tabs
    with pytest.raises(KeyError):
        registry.target_id_for_tab(15)


@pytest.mark.asyncio
async def test_target_attachment_snapshot_rejects_revoked_disconnect_and_reset(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(16, "https://example.com", "Example")
    generation = adapter._active_scope_generation(16)
    assert generation is not None
    target_id = registry.target_id_for_tab(16)
    adapter._attached_tabs.add(16)
    assert adapter.target_attachment_snapshot(target_id) is True

    adapter._revoke_tab_scope(16)
    assert adapter.target_attachment_snapshot(target_id) is False

    adapter._begin_tab_scope(16)
    adapter._attached_tabs.add(16)
    assert adapter.target_attachment_snapshot(target_id) is True
    await adapter.on_extension_disconnect()
    assert adapter.target_attachment_snapshot(target_id) is False

    registry.register_tab(16, "https://example.com", "Example")
    adapter._active_scope_generation(16)
    adapter._attached_tabs.add(16)
    adapter._reset_connection_state()
    assert adapter.target_attachment_snapshot(target_id) is False


@pytest.mark.asyncio
async def test_create_and_close_target(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, _ = adapter_server

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.createTarget", "params": {"url": "https://example.com"}})
        attached = await receive_event(ws, "Target.attachedToTarget")
        created = await receive_response(ws, 1)

        await ws.send_json({"id": 2, "method": "Target.closeTarget", "params": {"targetId": "tab-100"}})
        closed = await receive_response(ws, 2)
        await adapter.handle_extension_event("scope.tabRemoved", {"tabId": 100, "reason": "closed"})
        detached = await receive_event(ws, "Target.detachedFromTarget")
        destroyed = await receive_event(ws, "Target.targetDestroyed")

    assert created == {"id": 1, "result": {"targetId": "tab-100"}}
    assert attached["params"]["targetInfo"]["url"] == "https://example.com"
    assert closed == {"id": 2, "result": {"success": True}}
    assert detached["params"]["sessionId"].startswith("sess-tab-100-")
    assert destroyed["params"] == {"targetId": "tab-100"}
    assert ("tabs.remove", {"tabId": 100}) in relay.calls


@pytest.mark.asyncio
async def test_create_target_and_scope_event_register_tab_once(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    original_request = relay.request

    async def request_with_scope_event(
        op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
    ) -> dict:
        result = await original_request(op, args, timeout)
        if op == "tabs.create":
            await adapter.handle_extension_event(
                "scope.tabAdded",
                {"tabId": result["tabId"], "url": args["url"], "title": ""},
            )
        return result

    relay.request = request_with_scope_event

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Target.setDiscoverTargets", "params": {"discover": True}})
        assert await receive_response(ws, 1) == {"id": 1, "result": {}}
        browser_created = await receive_event(ws, "Target.targetCreated")
        assert browser_created["params"]["targetInfo"]["targetId"] == "skyvern-browser"

        with patch.object(registry, "register_tab", wraps=registry.register_tab) as register_tab:
            await ws.send_json({"id": 2, "method": "Target.createTarget", "params": {"url": "https://example.com"}})
            target_created = await receive_event(ws, "Target.targetCreated")
            await receive_event(ws, "Target.attachedToTarget")
            created = await receive_response(ws, 2)

        assert register_tab.call_count == 1
        assert target_created["params"]["targetInfo"]["targetId"] == "tab-100"
        assert created == {"id": 2, "result": {"targetId": "tab-100"}}
        assert len(registry.list_page_targets()) == 1
        await adapter.handle_extension_event(
            "scope.tabAdded",
            {"tabId": 100, "url": "https://example.com", "title": ""},
        )
        with pytest.raises(TimeoutError):
            await ws.receive_json(timeout=0.05)


@pytest.mark.asyncio
async def test_debugger_detached_emits_destroyed_and_navigation_updates_target(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(15, "https://old.example", "Old")
    session_id = registry.root_session_id(15)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await adapter.handle_extension_event(
            "debugger.event",
            {
                "tabId": 15,
                "method": "Page.frameNavigated",
                "params": {"frame": {"id": "main", "url": "https://new.example"}},
            },
        )
        navigated = await receive_event(ws, "Page.frameNavigated")
        assert navigated["sessionId"] == session_id
        assert registry.target_info("tab-15")["url"] == "https://new.example"

        await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "canceled_by_user"})
        detached = await receive_event(ws, "Target.detachedFromTarget")
        destroyed = await receive_event(ws, "Target.targetDestroyed")

    assert detached["params"] == {"sessionId": session_id, "targetId": "tab-15"}
    assert destroyed["params"] == {"targetId": "tab-15"}
    with pytest.raises(KeyError):
        registry.root_session_id(15)


@pytest.mark.asyncio
async def test_unknown_root_and_extension_request_errors(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(18, "https://example.com", "Example")
    session_id = registry.root_session_id(18)

    async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
        await ws.send_json({"id": 1, "method": "Nope.missing", "params": {}})
        unknown = await receive_response(ws, 1)

        relay.fail_next = ExtensionRequestError("CDP_ERROR", "command failed")
        await ws.send_json({"id": 2, "sessionId": session_id, "method": "Runtime.enable", "params": {}})
        failed = await receive_response(ws, 2)

    assert unknown == {"id": 1, "error": {"code": -32601, "message": "'Nope.missing' wasn't found"}}
    assert failed == {
        "id": 2,
        "sessionId": session_id,
        "error": {"code": -32000, "message": "CDP_ERROR: command failed"},
    }


@pytest.mark.asyncio
async def test_second_client_rejected_and_disconnect_allows_future_client(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, _, registry = adapter_server
    registry.register_tab(20, "https://example.com", "Example")

    async with ClientSession() as client:
        first = await client.ws_connect(adapter.cdp_ws_url)
        second = await client.ws_connect(adapter.cdp_ws_url)
        await second.receive(timeout=2)
        assert second.close_code == 4409

        await adapter.on_extension_disconnect()
        await first.receive(timeout=2)
        assert first.close_code == 1001
        assert registry.list_page_targets() == []

        future = await client.ws_connect(adapter.cdp_ws_url)
        await future.send_json({"id": 1, "method": "Browser.getVersion", "params": {}})
        assert (await receive_response(future, 1))["result"]["protocolVersion"] == "1.3"
        await future.close()


@pytest.mark.asyncio
async def test_old_client_disconnect_does_not_cancel_new_client_command(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    old_cancel_started = asyncio.Event()
    release_old_cancel = asyncio.Event()
    original_cancel_client_tasks = adapter._cancel_client_tasks

    async def block_old_cancel(*args: object) -> None:
        old_cancel_started.set()
        await release_old_cancel.wait()
        await original_cancel_client_tasks(*args)

    async with ClientSession() as client:
        await client.ws_connect(adapter.cdp_ws_url)
        with patch.object(adapter, "_cancel_client_tasks", side_effect=block_old_cancel):
            disconnect_task = asyncio.create_task(adapter.on_extension_disconnect())
            await asyncio.wait_for(old_cancel_started.wait(), 1)

            new = await client.ws_connect(adapter.cdp_ws_url)
            registry.register_tab(24, "https://example.com", "Example")
            session_id = registry.root_session_id(24)
            send_key = (None, "Runtime.evaluate")
            relay.block_send_keys.add(send_key)
            await new.send_json(
                {"id": 1, "sessionId": session_id, "method": "Runtime.evaluate", "params": {"expression": "1+1"}}
            )
            await asyncio.wait_for(relay.send_started.setdefault(send_key, asyncio.Event()).wait(), 1)

            release_old_cancel.set()
            await asyncio.wait_for(disconnect_task, 2)
            relay.release_send[send_key].set()

            assert await receive_response(new, 1) == {
                "id": 1,
                "sessionId": session_id,
                "result": {"forwardedMethod": "Runtime.evaluate"},
            }
            await asyncio.sleep(0)
            assert adapter._client_tasks == {}
            await new.close()


@pytest.mark.asyncio
async def test_browser_close_detaches_all_tabs_when_client_closes_after_reply(
    adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
    adapter, relay, registry = adapter_server
    registry.register_tab(22, "https://example.com", "Example")
    registry.register_tab(23, "https://other.example", "Other")
    relay.block_detach_tab_id = 22

    async with ClientSession() as client:
        ws = await client.ws_connect(adapter.cdp_ws_url)
        await ws.send_json({"id": 9, "method": "Browser.close", "params": {}})
        assert await receive_response(ws, 9) == {"id": 9, "result": {}}
        close_task = asyncio.create_task(ws.close())
        await asyncio.wait_for(relay.detach_started.wait(), 1)
        await asyncio.sleep(0.05)
        relay.release_detach.set()
        await asyncio.wait_for(close_task, 2)

    assert {args["tabId"] for op, args in relay.calls if op == "debugger.detach"} == {22, 23}
    assert all(op != "tabs.remove" for op, _ in relay.calls)
    assert set(relay.released_tabs) == {22, 23}


@pytest.mark.asyncio
@pytest.mark.parametrize("method", ["Target.targetCreated", "Target.targetInfoChanged", "Target.attachedToTarget"])
async def test_unexposed_target_events_are_hidden_at_delivery(method: str) -> None:
    registry = VirtualTargetRegistry()
    registry.register_tab(32, "about:blank", "")
    adapter = ExtensionCdpAdapter(registry, StubRelay())
    ws = SimpleNamespace(closed=False, send_json=AsyncMock())
    payload = {"method": method, "params": {"targetInfo": registry.target_info_for_tab(32)}}
    async with adapter._send_lock:
        pending = asyncio.create_task(adapter._send(ws, payload))
        await asyncio.sleep(0)
        adapter._unexposed_attached_tabs.add(32)
    await pending
    ws.send_json.assert_not_awaited()
    adapter._unexposed_attached_tabs.clear()
    await adapter._send(ws, payload)
    ws.send_json.assert_awaited_once_with(payload)