E2E: stop relying on OS focus for the Escape-binding tests

The two `Escape closes the X window (production binding)` tests in
settings.spec.ts and viewer.spec.ts went through `keyboard.press('Escape')`,
which delivers the keystroke via the OS. Under Xvfb on Linux CI the
keystroke routinely lands on the main window (the previous test left
focus there, or the open-animation hasn't transferred it yet), the
scoped webview never sees it, and the test sits waiting for a
window-close that doesn't come. The existing two-attempt focus poll
helped but didn't eliminate the race — both tests flaked on the most
recent PR run.

Switch both to a synthetic `document.dispatchEvent(new KeyboardEvent('keydown',
{ key: 'Escape', bubbles: true }))` via `evaluate`. That bubbles through
the `<svelte:window on:keydown>` listener regardless of OS focus, which
is what the test is actually meant to exercise (the handler's close
logic). The Tauri/webkit2gtk OS → webview event pipeline isn't cmdr's
responsibility to test.

Pattern matches `network-toggle.spec.ts` and `file-operations.spec.ts`,
which already use synthetic Escape dispatch for the same reason. Drops
the helper `tryEscape` / focus-poll machinery; the test is now linear.

Author: vdavid

apps/desktop/test/e2e-playwright/settings.spec.ts

@@ -314,42 +314,25 @@ test.describe('Settings keyboard binding', () => {
     const settings = await openSettingsWindowViaProd(main)
     await settings.waitForSelector('.settings-window', 3000)
 
-    // Verify focus is actually inside the settings webview before pressing
-    // Escape. Without this the keystroke can land on the main window (or
-    // wherever focus drifted to during async onMount in the settings UI),
-    // the settings window never receives it, and the test sits waiting for
-    // a window-close that won't come. Two attempts max as cheap insurance.
-    const tryEscape = async (): Promise<boolean> => {
-      const focused = await pollUntil(
-        settings,
-        async () =>
-          settings.evaluate<boolean>(`(function(){
-            if (!document.hasFocus()) return false;
-            var root = document.querySelector('.settings-window');
-            return !!(root && document.activeElement && root.contains(document.activeElement));
-          })()`),
-        1000,
-      )
-      if (!focused) {
-        // Re-focus inside the settings webview and let the caller retry.
-        await settings.evaluate(`(function(){
-          var root = document.querySelector('.settings-window');
-          if (root && 'focus' in root) root.focus();
-        })()`)
-        return false
-      }
-      // Fire-and-forget: the dispatched Escape triggers getCurrentWindow().close()
-      // synchronously inside the handler, so the window may die before pw_result
-      // fires back. The poll on listWindows() below is the assertion.
-      settings.keyboard.press('Escape').catch(() => {
+    // Dispatch a synthetic Escape keydown into the settings webview rather
+    // than going through Playwright's OS-level `keyboard.press`. The handler
+    // we want to exercise is the JS `<svelte:window on:keydown>` in
+    // `routes/settings/+page.svelte` — bubbling from `document` fires that
+    // listener regardless of OS focus. Going through the OS path adds a
+    // focus dependency that flakes under Xvfb on Linux CI (the keystroke
+    // lands on the main window and the settings webview never sees it).
+    // The Tauri/webkit2gtk OS → webview event pipeline isn't cmdr's
+    // responsibility to test; this binding is.
+    //
+    // Fire-and-forget: the dispatched Escape triggers
+    // `getCurrentWindow().close()` (after a 2-rAF defer) inside the handler,
+    // so the window may die before the evaluate promise's `pw_result` fires
+    // back. The poll on `listWindows()` below is the assertion that matters.
+    settings
+      .evaluate(`document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }))`)
+      .catch(() => {
         /* window died mid-script before pw_result; expected */
       })
-      return true
-    }
-
-    if (!(await tryEscape())) {
-      await tryEscape()
-    }
 
     const gone = await pollUntil(
       main,

apps/desktop/test/e2e-playwright/viewer.spec.ts

@@ -189,43 +189,25 @@ test.describe('File viewer keyboard binding', () => {
     const label = viewer.targetWindow
     if (!label) throw new Error('Scoped viewer page has no targetWindow label')
 
-    // Verify focus is inside the viewer webview before pressing Escape. If the
-    // keystroke lands on the main window (focus race with the open animation,
-    // or a late-mounting modal stealing focus), the viewer never receives it
-    // and the test sits waiting for the window-close. Two attempts max.
-    const tryEscape = async (): Promise<boolean> => {
-      const focused = await pollUntil(
-        viewer,
-        async () =>
-          viewer.evaluate<boolean>(`(function(){
-            if (!document.hasFocus()) return false;
-            var root = document.querySelector('.viewer-container');
-            return !!(root && document.activeElement && root.contains(document.activeElement));
-          })()`),
-        1000,
-      )
-      if (!focused) {
-        await viewer.evaluate(`(function(){
-          var root = document.querySelector('.viewer-container');
-          if (root && 'focus' in root) root.focus();
-        })()`)
-        return false
-      }
-      // Fire-and-forget: the eval that dispatches Escape may not resolve if the
-      // window dies before pw_result fires back to the test runner. The
-      // closeWindow() path uses two rAFs before calling .close(), so in practice
-      // the eval usually resolves first, but defending against either ordering
-      // keeps the test deterministic. We assert on the windowDisappeared, not
-      // on the press itself.
-      viewer.keyboard.press('Escape').catch(() => {
+    // Dispatch a synthetic Escape keydown into the viewer webview rather
+    // than going through Playwright's OS-level `keyboard.press`. The handler
+    // we want to exercise is the JS `<svelte:window on:keydown>` in
+    // `routes/viewer/+page.svelte` — bubbling from `document` fires that
+    // listener regardless of OS focus. Going through the OS path adds a
+    // focus dependency that flakes under Xvfb on Linux CI (the keystroke
+    // lands on the main window and the viewer webview never sees it).
+    // The Tauri/webkit2gtk OS → webview event pipeline isn't cmdr's
+    // responsibility to test; this binding is.
+    //
+    // Fire-and-forget: the dispatched Escape triggers `closeWindow()`
+    // (which itself defers via two rAFs before calling `.close()`), so the
+    // window may die before the evaluate promise's `pw_result` fires back.
+    // The poll on `listWindows()` below is the assertion that matters.
+    viewer
+      .evaluate(`document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }))`)
+      .catch(() => {
         /* window died mid-script before pw_result; expected */
       })
-      return true
-    }
-
-    if (!(await tryEscape())) {
-      await tryEscape()
-    }
 
     const gone = await pollUntil(
       main,