fix(libei): only restart the capture session on device change under GNOME

`EiEvent::DeviceRemoved` currently tears down and recreates the whole
input-capture session. That is a workaround for mutter, which stops
delivering events after a device change, but it is applied on every
compositor.

Elsewhere the restart is pure overhead: every device change costs a
CreateSession + ConnectToEIS round trip. On compositors that keep
per-session state around it is worse than overhead - Hyprland keeps a
keymap fd per EIS session and never reaps sessions whose client went
away, so the churn drives it out of file descriptors and eventually
crashes it. On this machine the churn ran at ~35 ConnectToEIS per 38
minutes; gating it to GNOME brought that to 0 with no change in capture
behaviour.

`SeatRemoved` still releases unconditionally - a seat going away really
does invalidate the session.

The default is derived from XDG_CURRENT_DESKTOP and can be overridden
with LM_RESTART_SESSION_ON_DEVICE_CHANGE=1/0 for compositors that need
the mutter behaviour but do not advertise themselves as GNOME.

.github/workflows/release.yml

@@ -105,7 +105,7 @@ jobs:
         # see https://github.com/wingtk/gvsbuild/pull/1004
         Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
         Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
-        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
+        gvsbuild build --vs-ver=vs2026 --msys-dir=C:\msys64 gtk4 libadwaita librsvg
         Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
         Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
     - uses: actions/checkout@v6

.github/workflows/rust.yml

@@ -40,7 +40,6 @@ jobs:
           - test
     steps:
       - uses: actions/checkout@v6
-      - uses: Swatinem/rust-cache@v2
       - name: Install Linux deps
         if: runner.os == 'Linux'
         run: |
@@ -49,6 +48,13 @@ jobs:
       - name: Install macOS dependencies
         if: runner.os == 'macOS'
         run: brew install gtk4 libadwaita imagemagick
+      - name: Record macOS native lib versions for cache key
+        if: runner.os == 'macOS'
+        run: |
+          echo "MACOS_LIB_VER=$(brew list --versions glib gtk4 libadwaita | tr '\n' '_')" >> "$GITHUB_ENV"
+      - uses: Swatinem/rust-cache@v2
+        with:
+          prefix-key: ${{ env.MACOS_LIB_VER }}
       - name: Install Windows Dependencies - create gtk dir
         if: runner.os == 'Windows'
         run: mkdir C:\gtk-build\gtk\x64\release
@@ -77,7 +83,7 @@ jobs:
           py -m venv .venv
           .venv\Scripts\activate.ps1
           py -m pip install gvsbuild
-          gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
+          gvsbuild build --vs-ver=vs2026 --msys-dir=C:\msys64 gtk4 libadwaita librsvg
       - name: cargo build
         if: matrix.job == 'build'
         run: cargo build

input-capture/src/layer_shell.rs

@@ -123,7 +123,6 @@ struct State {
     focused: Option<Arc<Window>>,
     global_list: GlobalList,
     globals: Globals,
-    wayland_fd: RawFd,
     read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
     pending_events: VecDeque<(Position, CaptureEvent)>,
@@ -138,7 +137,7 @@ struct Inner {
 
 impl AsRawFd for Inner {
     fn as_raw_fd(&self) -> RawFd {
-        self.state.wayland_fd
+        self.queue.as_fd().as_raw_fd()
     }
 }
 
@@ -332,7 +331,6 @@ impl LayerShellInputCapture {
             active_windows: Vec::new(),
             focused: None,
             qh,
-            wayland_fd: queue.as_fd().as_raw_fd(),
             read_guard: None,
             pending_events: VecDeque::new(),
             outputs: vec![],
@@ -548,13 +546,12 @@ impl State {
 }
 
 impl Inner {
-    fn read(&mut self) -> bool {
+    fn read(&mut self) {
         match self.state.read_guard.take().unwrap().read() {
-            Ok(_) => true,
-            Err(WaylandError::Io(e)) if e.kind() == ErrorKind::WouldBlock => false,
+            Ok(_) => {}
+            Err(WaylandError::Io(e)) if e.kind() == ErrorKind::WouldBlock => {}
             Err(WaylandError::Io(e)) => {
                 log::error!("error reading from wayland socket: {e}");
-                false
             }
             Err(WaylandError::Protocol(e)) => {
                 panic!("wayland protocol violation: {e}")
@@ -564,16 +561,11 @@ impl Inner {
 
     fn prepare_read(&mut self) -> io::Result<()> {
         loop {
-            match self.queue.prepare_read() {
-                None => match self.queue.dispatch_pending(&mut self.state) {
-                    Ok(_) => continue,
-                    Err(DispatchError::Backend(WaylandError::Io(e))) => return Err(e),
-                    Err(e) => panic!("failed to dispatch wayland events: {e}"),
-                },
-                Some(r) => {
-                    self.state.read_guard = Some(r);
-                    break Ok(());
-                }
+            if let Some(guard) = self.queue.prepare_read() {
+                self.state.read_guard = Some(guard);
+                break Ok(());
+            } else {
+                self.dispatch_events();
             }
         }
     }
@@ -655,13 +647,7 @@ impl Stream for LayerShellInputCapture {
                 let inner = guard.get_inner_mut();
 
                 // read events
-                while inner.read() {
-                    // prepare next read
-                    match inner.prepare_read() {
-                        Ok(_) => {}
-                        Err(e) => return Poll::Ready(Some(Err(e.into()))),
-                    }
-                }
+                inner.read();
 
                 // dispatch the events
                 inner.dispatch_events();

input-capture/src/libei.rs

@@ -18,12 +18,12 @@ use reis::{
 use std::{
     cell::Cell,
     collections::HashMap,
-    io,
+    env, io,
     num::NonZeroU32,
     os::unix::net::UnixStream,
     pin::Pin,
     rc::Rc,
-    sync::Arc,
+    sync::{Arc, LazyLock},
     task::{Context, Poll},
 };
 use tokio::{
@@ -50,6 +50,25 @@ use super::{
  * prevents receiving further events after a session has been disabled once.
  * Therefore the session needs to be recreated when the barriers are updated */
 
+/* mutter also kills the session whenever ei devices come and go, so there the
+ * whole session has to be torn down and recreated on every device change.
+ * Elsewhere that is pure overhead: each restart costs a CreateSession +
+ * ConnectToEIS round trip, and compositors that keep per-session state around
+ * (hyprland leaks a keymap fd per eis session, see hyprwm/Hyprland) can be
+ * driven out of file descriptors by the churn.
+ * Set LM_RESTART_SESSION_ON_DEVICE_CHANGE=1/0 to override the default. */
+static RESTART_SESSION_ON_DEVICE_CHANGE: LazyLock<bool> =
+    LazyLock::new(restart_session_on_device_change);
+
+fn restart_session_on_device_change() -> bool {
+    match env::var("LM_RESTART_SESSION_ON_DEVICE_CHANGE").as_deref() {
+        Ok("1") => true,
+        Ok("0") => false,
+        _ => env::var("XDG_CURRENT_DESKTOP")
+            .is_ok_and(|desktops| desktops.to_uppercase().split(':').any(|d| d == "GNOME")),
+    }
+}
+
 /// events that necessitate restarting the capture session
 #[derive(Clone, Copy, Debug)]
 enum LibeiNotifyEvent {
@@ -555,20 +574,32 @@ async fn handle_ei_event(
             s.seat.bind_capabilities(all_capabilities);
             context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
         }
-        EiEvent::SeatRemoved(_) | /* EiEvent::DeviceAdded(_) | */ EiEvent::DeviceRemoved(_) => {
+        EiEvent::SeatRemoved(_) => {
             log::debug!("releasing session: {ei_event:?}");
             release_session.notify_waiters();
         }
+        /* EiEvent::DeviceAdded(_) | */
+        EiEvent::DeviceRemoved(_) => {
+            if *RESTART_SESSION_ON_DEVICE_CHANGE {
+                log::debug!("releasing session: {ei_event:?}");
+                release_session.notify_waiters();
+            } else {
+                log::debug!("ignoring device change: {ei_event:?}");
+            }
+        }
         EiEvent::DevicePaused(_) | EiEvent::DeviceResumed(_) => {}
         EiEvent::DeviceStartEmulating(_) => log::debug!("START EMULATING"),
         EiEvent::DeviceStopEmulating(_) => log::debug!("STOP EMULATING"),
         EiEvent::Disconnected(d) => {
-            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
+            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)));
         }
         _ => {
             if let Some(pos) = current_client {
                 for event in Event::from_ei_event(ei_event) {
-                    event_tx.send((pos, CaptureEvent::Input(event))).await.expect("no channel");
+                    event_tx
+                        .send((pos, CaptureEvent::Input(event)))
+                        .await
+                        .expect("no channel");
                 }
             }
         }

src/config.rs

@@ -518,7 +518,7 @@ impl Config {
     }
 
     pub fn read_from_disk(&mut self) -> Result<bool, io::Error> {
-        log::info!("reading config from {:?}", &self.config_path);
+        log::info!("reading config from {:?}", self.config_path);
 
         let current_config = fs::read_to_string(&self.config_path)?;
         let current_config = match current_config.parse::<DocumentMut>() {
@@ -548,7 +548,7 @@ impl Config {
     }
 
     pub fn write_back(&mut self) -> Result<(), io::Error> {
-        log::info!("writing config to {:?}", &self.config_path);
+        log::info!("writing config to {:?}", self.config_path);
         /* the new config */
         let new_config = self.config_toml.clone().unwrap_or_default();
         let new_config = toml_edit::ser::to_string_pretty(&new_config).expect("config");