logiguard fork: GPUI xdg-activation keyboard-focus serial fix

Single-commit orphan branch: full zed-industries/zed @ 8c74db0 source tree
with a 3-file patch applied (no upstream history).

Patch (crates/gpui_linux/src/linux/wayland/):
  - serial.rs: add SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; add latest_serial_of()
  - window.rs: activate() uses keyboard-enter serial (Mutter focus gate)

Mutter honors window activation only when the token carries the keyboard-
focus serial from wl_keyboard.enter; GPUI used a stale mouse-press serial.
See docs/tray-window-focus-wayland.md in logiguard.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/gpui_web/src/display.rs

@@ -0,0 +1,98 @@
+use anyhow::Result;
+use gpui::{Bounds, DisplayId, Pixels, PlatformDisplay, Point, Size, px};
+
+#[derive(Debug)]
+pub struct WebDisplay {
+    id: DisplayId,
+    uuid: uuid::Uuid,
+    browser_window: web_sys::Window,
+}
+
+// Safety: WASM is single-threaded — there is no concurrent access to `web_sys::Window`.
+unsafe impl Send for WebDisplay {}
+unsafe impl Sync for WebDisplay {}
+
+impl WebDisplay {
+    pub fn new(browser_window: web_sys::Window) -> Self {
+        WebDisplay {
+            id: DisplayId::new(1),
+            uuid: uuid::Uuid::new_v4(),
+            browser_window,
+        }
+    }
+
+    fn screen_size(&self) -> Size<Pixels> {
+        let Some(screen) = self.browser_window.screen().ok() else {
+            return Size {
+                width: px(1920.),
+                height: px(1080.),
+            };
+        };
+
+        let width = screen.width().unwrap_or(1920) as f32;
+        let height = screen.height().unwrap_or(1080) as f32;
+
+        Size {
+            width: px(width),
+            height: px(height),
+        }
+    }
+
+    fn viewport_size(&self) -> Size<Pixels> {
+        let width = self
+            .browser_window
+            .inner_width()
+            .ok()
+            .and_then(|v| v.as_f64())
+            .unwrap_or(1920.0) as f32;
+        let height = self
+            .browser_window
+            .inner_height()
+            .ok()
+            .and_then(|v| v.as_f64())
+            .unwrap_or(1080.0) as f32;
+
+        Size {
+            width: px(width),
+            height: px(height),
+        }
+    }
+}
+
+impl PlatformDisplay for WebDisplay {
+    fn id(&self) -> DisplayId {
+        self.id
+    }
+
+    fn uuid(&self) -> Result<uuid::Uuid> {
+        Ok(self.uuid)
+    }
+
+    fn bounds(&self) -> Bounds<Pixels> {
+        let size = self.screen_size();
+        Bounds {
+            origin: Point::default(),
+            size,
+        }
+    }
+
+    fn visible_bounds(&self) -> Bounds<Pixels> {
+        let size = self.viewport_size();
+        Bounds {
+            origin: Point::default(),
+            size,
+        }
+    }
+
+    fn default_bounds(&self) -> Bounds<Pixels> {
+        let visible = self.visible_bounds();
+        let width = visible.size.width * 0.75;
+        let height = visible.size.height * 0.75;
+        let origin_x = (visible.size.width - width) / 2.0;
+        let origin_y = (visible.size.height - height) / 2.0;
+        Bounds {
+            origin: Point::new(origin_x, origin_y),
+            size: Size { width, height },
+        }
+    }
+}