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/examples/move_entity_between_windows.rs

@@ -0,0 +1,154 @@
+//! An entity registers callbacks via the `_in` API family and then gets
+//! re-hosted in a new window via a click. The point of the example is to
+//! demonstrate that callbacks dispatched after the move correctly target the
+//! entity's *current* window rather than the window it was in at
+//! registration time.
+//!
+//! To run:  cargo run -p gpui --example move_entity_between_windows
+
+#![cfg_attr(target_family = "wasm", no_main)]
+
+use std::time::Duration;
+
+use gpui::{
+    App, AppContext as _, Bounds, Context, EventEmitter, MouseButton, Render, SharedString,
+    Subscription, Task, Window, WindowBounds, WindowOptions, div, prelude::*, px, rgb, size,
+};
+use gpui_platform::application;
+
+struct MoveToNewWindow;
+
+struct HelloWorld {
+    text: SharedString,
+    tick_count: u32,
+    move_count: u32,
+    _tasks: Vec<Task<()>>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl EventEmitter<MoveToNewWindow> for HelloWorld {}
+
+impl HelloWorld {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let self_entity = cx.entity();
+
+        let task = cx.spawn_in(window, async move |this, cx| {
+            loop {
+                cx.background_executor().timer(Duration::from_secs(1)).await;
+                let result = this.update_in(cx, |this, window, _cx| {
+                    this.tick_count += 1;
+                    println!(
+                        "tick #{} fired in entity's current window {}",
+                        this.tick_count,
+                        window.window_handle().window_id().as_u64(),
+                    );
+                });
+                if let Err(err) = result {
+                    println!("tick task giving up: {err}");
+                    return;
+                }
+            }
+        });
+
+        let subscription = cx.subscribe_in::<_, MoveToNewWindow>(
+            &self_entity,
+            window,
+            move |this, _emitter, _event, window, cx| {
+                let entered_window_id = window.window_handle().window_id().as_u64();
+                println!(
+                    "MoveToNewWindow handler fired in entity's current window {entered_window_id}",
+                );
+
+                this.move_count += 1;
+                cx.notify();
+
+                let entity = cx.entity();
+                let old_window = window.window_handle();
+                cx.defer(move |cx| {
+                    let bounds = Bounds::centered(None, size(px(500.0), px(500.0)), cx);
+                    cx.open_window(
+                        WindowOptions {
+                            window_bounds: Some(WindowBounds::Windowed(bounds)),
+                            ..Default::default()
+                        },
+                        move |_, _| entity,
+                    )
+                    .expect("failed to open new window");
+                    old_window
+                        .update(cx, |_, window, _| window.remove_window())
+                        .ok();
+                });
+            },
+        );
+
+        Self {
+            text: "World".into(),
+            tick_count: 0,
+            move_count: 0,
+            _tasks: vec![task],
+            _subscriptions: vec![subscription],
+        }
+    }
+}
+
+impl Render for HelloWorld {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let window_id = window.window_handle().window_id().as_u64();
+
+        div()
+            .flex()
+            .flex_col()
+            .gap_3()
+            .bg(rgb(0x505050))
+            .size(px(500.0))
+            .justify_center()
+            .items_center()
+            .text_xl()
+            .text_color(rgb(0xffffff))
+            .child(format!("Hello, {}!", &self.text))
+            .child(format!("Rendering in window: {window_id}"))
+            .child(format!("Ticks observed by entity: {}", self.tick_count))
+            .child(format!("Moves observed by entity: {}", self.move_count))
+            .child(
+                div()
+                    .px_4()
+                    .py_2()
+                    .bg(rgb(0x4040ff))
+                    .rounded_md()
+                    .child("Move me to a new window")
+                    .on_mouse_down(
+                        MouseButton::Left,
+                        cx.listener(|_this, _, _window, cx| {
+                            cx.emit(MoveToNewWindow);
+                        }),
+                    ),
+            )
+    }
+}
+
+fn run_example() {
+    application().run(|cx: &mut App| {
+        let bounds = Bounds::centered(None, size(px(500.0), px(500.0)), cx);
+        cx.open_window(
+            WindowOptions {
+                window_bounds: Some(WindowBounds::Windowed(bounds)),
+                ..Default::default()
+            },
+            |window, cx| cx.new(|cx| HelloWorld::new(window, cx)),
+        )
+        .unwrap();
+        cx.activate(true);
+    });
+}
+
+#[cfg(not(target_family = "wasm"))]
+fn main() {
+    run_example();
+}
+
+#[cfg(target_family = "wasm")]
+#[wasm_bindgen::prelude::wasm_bindgen(start)]
+pub fn start() {
+    gpui_platform::web_init();
+    run_example();
+}