fix(sync): fail fast instead of spinning at 100% CPU when the dispatcher fiber dies

When the driver connection ends without going through Connection.cleanup()
- e.g. the driver process dies, or a remote CDP connection wedges and the
transport takes the silent IncompleteReadError path - the dispatcher fiber
finishes with sync calls still pending. Their tasks can never complete, and
because switching to a dead greenlet returns immediately to its parent, the
waiting loop in SyncBase._sync degenerates into a pure userspace busy-loop:
the thread pins one core, holds the GIL, and neither raises nor logs.
Observed in production via strace (100% futex, zero IO syscalls) with py-spy
showing threads stopped on the same _sync line for the process lifetime.

Detect the dead dispatcher inside the waiting loop and raise
TargetClosedError instead. A dead fiber can never complete the task, so
raising there is always correct.

The regression test recreates the failure end to end: kill the driver on the
silent path, then make one more sync call. Without the fix the call spins
forever (the subprocess times out); with it, it raises promptly.

Co-authored-by: Claude <noreply@anthropic.com>

Author: the-asura

playwright/_impl/_sync_base.py

@@ -32,6 +32,7 @@
 import greenlet
 
 from playwright._impl._connection import _capture_stack_trace
+from playwright._impl._errors import TargetClosedError
 from playwright._impl._helper import Error
 from playwright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
 
@@ -110,6 +111,17 @@ def _sync(
 
         task.add_done_callback(lambda _: g_self.switch())
         while not task.done():
+            if self._dispatcher_fiber.dead:
+                # The dispatcher fiber runs the connection's event loop; when the
+                # transport ends without going through Connection.cleanup() (e.g.
+                # the driver process dies or a remote connection drops), the fiber
+                # finishes with this task still pending. Switching to a dead
+                # greenlet returns immediately to its parent - this very loop -
+                # so without this check the thread spins at 100% CPU forever.
+                task.cancel()
+                raise TargetClosedError(
+                    "Playwright connection closed while this call was pending"
+                )
             self._dispatcher_fiber.switch()
         asyncio._set_running_loop(self._loop)
         return task.result()

tests/sync/test_sync.py

@@ -399,6 +399,47 @@ def test_should_not_orphan_callback_on_non_serializable_params(
     assert "Future exception was never retrieved" not in result.stderr
 
 
+@pytest.mark.only_browser("chromium")  # browser-agnostic; run once
+def test_sync_call_fails_fast_when_dispatcher_dies_mid_call(tmp_path: Path) -> None:
+    # When the driver process dies without the transport reporting an error
+    # (its stdout hits EOF on the not-self-initiated stop path), the dispatcher
+    # fiber finishes silently and Connection.cleanup() never runs, so a pending
+    # sync call's task can never complete. Switching to the dead fiber returns
+    # immediately, degenerating the _sync() waiting loop into a 100% CPU spin
+    # that raises nothing and logs nothing. The loop must detect the dead
+    # dispatcher and raise instead. Run in a subprocess: without the fix the
+    # doomed call spins forever and this test would hang, not fail.
+    script = tmp_path / "dead_dispatcher.py"
+    script.write_text(
+        textwrap.dedent(
+            """
+            import sys
+
+            from playwright.sync_api import Error, sync_playwright
+
+            p = sync_playwright().start()
+            transport = p._impl_obj._connection._transport
+            # Emulate an abrupt driver death that reports no transport error:
+            # the same shape a wedged remote connection produces in the wild.
+            transport._stopped = True
+            transport._proc.kill()
+            try:
+                p.chromium.launch()
+                sys.exit(2)  # returned normally: the driver is gone, impossible
+            except Error:
+                sys.exit(0)  # failed fast instead of spinning
+            """
+        )
+    )
+    result = subprocess.run(
+        [sys.executable, str(script)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, (result.stdout, result.stderr)
+
+
 def test_click_should_accept_timedelta_for_timeout(page: Page) -> None:
     with pytest.raises(TimeoutError, match="Timeout 1ms exceeded"):
         page.click("does-not-exist", timeout=timedelta(milliseconds=1))