log pressed keys

2026-03-07 20:09:59 +03:00 · 2024-09-23 20:48:45 +02:00
33 changed files with 1158 additions and 1486 deletions
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -55,9 +55,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # 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"
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -66,9 +66,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # 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"
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -51,9 +51,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # 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"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,7 @@ members = [
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.10.0"
+version = "0.9.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -22,13 +22,13 @@ strip = true
 lto = "fat"

 [dependencies]
-input-event = { path = "input-event", version = "0.3.0" }
-input-emulation = { path = "input-emulation", version = "0.3.0", default-features = false }
-input-capture = { path = "input-capture", version = "0.3.0", default-features = false }
-lan-mouse-cli = { path = "lan-mouse-cli", version = "0.2.0" }
-lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.2.0", optional = true }
-lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
-lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
+input-event = { path = "input-event", version = "0.2.1" }
+input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
+input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
+lan-mouse-cli = { path = "lan-mouse-cli", version = "0.1.0" }
+lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.1.0", optional = true }
+lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.1.0" }
+lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }

 hickory-resolver = "0.24.1"
 toml = "0.8"
@@ -49,7 +49,7 @@ tokio = { version = "1.32.0", features = [
 futures = "0.3.28"
 clap = { version = "4.4.11", features = ["derive"] }
 slab = "0.4.9"
-thiserror = "2.0.0"
+thiserror = "1.0.61"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"

@@ -57,21 +57,9 @@ local-channel = "0.1.5"
 libc = "0.2.148"

 [features]
-default = [
-    "gtk",
-    "layer_shell_capture",
-    "x11_capture",
-    "libei_capture",
-    "wlroots_emulation",
-    "libei_emulation",
-    "rdp_emulation",
-    "x11_emulation",
-]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
+wayland = ["input-capture/wayland", "input-emulation/wayland"]
+x11 = ["input-capture/x11", "input-emulation/x11"]
+xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
+libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
 gtk = ["dep:lan-mouse-gtk"]
-layer_shell_capture = ["input-capture/layer_shell"]
-x11_capture = ["input-capture/x11"]
-libei_capture = ["input-event/libei", "input-capture/libei"]
-libei_emulation = ["input-event/libei", "input-emulation/libei"]
-wlroots_emulation = ["input-emulation/wlroots"]
-x11_emulation = ["input-emulation/x11"]
-rdp_emulation = ["input-emulation/remote_desktop_portal"]
--- a/README.md
+++ b/README.md
@@ -1,65 +1,78 @@
 # Lan Mouse
-Lan Mouse is a *cross-platform* mouse and keyboard sharing software similar to universal-control on Apple devices.
-It allows for using multiple PCs via a single set of mouse and keyboard.
+Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices.
+It allows for using multiple pcs with a single set of mouse and keyboard.
 This is also known as a Software KVM switch.

-Goal of this project is to be an open-source alternative to proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/)
-and an alternative to other open source tools like [Deskflow](https://github.com/deskflow/deskflow) or [Input Leap](https://github.com/input-leap) (Synergy fork).
-
-Focus lies on performance, ease of use and a maintainable implementation that can be expanded to support additional backends for e.g. Android, iOS, ... in the future.
-
-***blazingly fast™*** because it's written in rust.
+The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).

 - _Now with a gtk frontend_

 <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="/screenshots/dark.png?raw=true">
-    <source media="(prefers-color-scheme: light)" srcset="/screenshots/light.png?raw=true">
-    <img alt="Screenshot of Lan-Mouse" srcset="/screenshots/dark.png">
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
+    <source media="(prefers-color-scheme: light)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/d6318340-f811-4e16-9d6e-d1b79883c709">
+    <img alt="Screenshot of Lan-Mouse" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
 </picture>


+Goal of this project is to be an open-source replacement for proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/).
+
+Focus lies on performance and a clean, manageable implementation that can easily be expanded to support additional backends like e.g. Android, iOS, ... .
+
+***blazingly fast™*** because it's written in rust.
+
+For an alternative (with slightly different goals) you may check out [Synergy 1 Community Edition](https://github.com/symless/synergy) or [Input Leap](https://github.com/input-leap) (Synergy fork).
+
+
 > [!WARNING]
-> DISCLAIMER:
-> Until [#200](https://github.com/feschber/lan-mouse/pull/200) is merged, all network traffic is **unencrypted** and sent in **plaintext**!
+> Since this tool has gained a bit of popularity over the past couple of days:
+>
+> All network traffic is currently **unencrypted** and sent in **plaintext**.
 >
 > A malicious actor with access to the network could read input data or send input events with spoofed IPs to take control over a device.
 >
-> Therefore you should only use this tool in your local network with trusted devices.
-> I take no responsibility for any security breaches!
+> Therefore you should only use this tool in your local network with trusted devices for now
+> and I take no responsibility for any leakage of data!


 ## OS Support

-Most current desktop environments and operating systems are fully supported, this includes
- GNOME >= 45
- KDE Plasma >= 6.1
- Most wlroots based compositors, including Sway (>= 1.8), Hyprland and Wayfire
- Windows
- MacOS
+The following table shows support for input emulation (to emulate events received from other clients) and
+input capture (to send events *to* other clients) on different operating systems:

-
-### Caveats / Known Issues
+| OS / Desktop Environment  | input emulation          | input capture                        |
+|---------------------------|--------------------------|--------------------------------------|
+| Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (Gnome)           | :heavy_check_mark:       | :heavy_check_mark: (starting at GNOME 45) |
+| Windows                   | :heavy_check_mark:       | :heavy_check_mark:                   |
+| X11                       | :heavy_check_mark:       | WIP                                  |
+| MacOS                     | :heavy_check_mark:       | WIP                                  |

 > [!Important]
-> - **X11** currently only has support for input emulation, i.e. can only be used on the receiving end.
+> Gnome -> Sway only partially works (modifier events are not handled correctly)
+
+> [!Important]
+> **Wayfire**
 >
-> - **Sway / wlroots**: Wlroots based compositors without libei support on the receiving end currently do not handle modifier events on the client side.
-> This results in CTRL / SHIFT / ALT / SUPER keys not working with a sending device that is NOT using the `layer-shell` backend
->
-> - **Wayfire**: If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
+> If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.
->
-> - **Windows**: The mouse cursor will be invisible when sending input to a Windows system if
+
+> [!Important]
+> The mouse cursor will be invisible when sending input to a Windows system if
 > there is no real mouse connected to the machine.

-For more detailed information about os support see [Detailed OS Support](#detailed-os-support)
-
-
 ## Installation
+### Install via cargo
+```sh
+cargo install lan-mouse
+```

-<details>
-    <summary>Arch Linux</summary>
+### Download from Releases
+Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
+
+For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
+
+### Arch Linux

 Lan Mouse can be installed from the [official repositories](https://archlinux.org/packages/extra/x86_64/lan-mouse/):

@@ -67,37 +80,39 @@ Lan Mouse can be installed from the [official repositories](https://archlinux.or
 pacman -S lan-mouse
 ```

-The prerelease version (following `main`) is available on the AUR:
+It is also available on the AUR:

 ```sh
+# git version (includes latest changes)
 paru -S lan-mouse-git
+
+# alternatively
+paru -S lan-mouse-bin
 ```
-</details>
-
-
-<details>
-    <summary>Nix (OS)</summary>

+### Nix
 - nixpkgs: [search.nixos.org](https://search.nixos.org/packages?channel=unstable&show=lan-mouse&from=0&size=50&sort=relevance&type=packages&query=lan-mouse)
 - flake: [README.md](./nix/README.md)
-</details>


-
-<details>
-    <summary>Manual Installation</summary>
+### Manual Installation

 First make sure to [install the necessary dependencies](#installing-dependencies).

-Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
-For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
-
-Alternatively, the `lan-mouse` binary can be compiled from source (see below).
-
-### Installing desktop file, app icon and firewall rules (optional)
+Build in release mode:
 ```sh
-# install lan-mouse (replace path/to/ with the correct path)
-sudo cp path/to/lan-mouse /usr/local/bin/
+cargo build --release
+```
+
+Run directly:
+```sh
+cargo run --release
+```
+
+Install the files:
+```sh
+# install lan-mouse
+sudo cp target/release/lan-mouse /usr/local/bin/

 # install app icon
 sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
@@ -115,34 +130,17 @@ sudo cp firewall/lan-mouse.xml /etc/firewalld/services
 # -> enable the service in firewalld settings
 ```

-Instead of downloading from the releases, the `lan-mouse` binary
-can be easily compiled via cargo or nix:
+### Conditional Compilation

-### Compiling and installing manually:
-```sh
-# compile in release mode
-cargo build --release
+Currently only x11, wayland, windows and MacOS are supported backends.
+Depending on the toolchain used, support for other platforms is omitted
+automatically (it does not make sense to build a Windows `.exe` with
+support for x11 and wayland backends).

-# install lan-mouse
-sudo cp target/release/lan-mouse /usr/local/bin/
-```
+However one might still want to omit support for e.g. wayland, x11 or libei on
+a Linux system.

-### Compiling and installing via cargo:
-```sh
-# will end up in ~/.cargo/bin
-cargo install lan-mouse
-```
-
-### Compiling and installing via nix:
-```sh
-# you can find the executable in result/bin/lan-mouse
-nix-build
-```
-### Conditional compilation
-Support for other platforms is omitted automatically based on the active
-rust toolchain.
-
-Additionally, available backends and frontends can be configured manually via
+This is possible through
 [cargo features](https://doc.rust-lang.org/cargo/reference/features.html).

 E.g. if only wayland support is needed, the following command produces
@@ -151,17 +149,14 @@ an executable with just support for wayland:
 cargo build --no-default-features --features wayland
 ```
 For a detailed list of available features, checkout the [Cargo.toml](./Cargo.toml)
-</details>


-
-
-## Installing Dependencies for Development / Compiling from Source
+## Installing Dependencies
 <details>
    <summary>MacOS</summary>

 ```sh
-brew install libadwaita pkg-config
+brew install libadwaita
 ```
 </details>

@@ -188,24 +183,12 @@ sudo pacman -S libadwaita gtk libx11 libxtst
 sudo dnf install libadwaita-devel libXtst-devel libX11-devel
 ```
 </details>
-<details>
-    <summary>Nix</summary>
-    
-```sh
-nix-shell .
-```
-</details>
-<details>
-    <summary>Nix (flake)</summary>
-    
-```sh
-nix develop
-```
-</details>
-
 <details>
    <summary>Windows</summary>

+> [!NOTE]
+> This is only necessary when building lan-mouse from source. The windows release comes with precompiled gtk dlls.
+
 - First install [Rust](https://www.rust-lang.org/tools/install).

 - Then follow the instructions at [gtk-rs.org](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation_windows.html)
@@ -236,20 +219,18 @@ python -m pipx ensurepath
 pipx install gvsbuild

 # build gtk + libadwaita
-gvsbuild build gtk4 libadwaita librsvg adwaita-icon-theme
+gvsbuild build gtk4 libadwaita librsvg
 ```

 - **Make sure to add the directory** `C:\gtk-build\gtk\x64\release\bin`
 [**to the `PATH` environment variable**]((https://learn.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14))). Otherwise the project will fail to build.

 To avoid building GTK from source, it is possible to disable
-the gtk frontend (see conditional compilation).
+the gtk frontend (see conditional compilation below).
 </details>

 ## Usage
-<details>
-    <summary>Gtk Frontend</summary>
-
+### Gtk Frontend
 By default the gtk frontend will open when running `lan-mouse`.

 To add a new connection, simply click the `Add` button on *both* devices,
@@ -257,11 +238,8 @@ enter the corresponding hostname and activate it.

 If the mouse can not be moved onto a device, make sure you have port `4242` (or the one selected)
 opened up in your firewall.
-</details>
-
-<details>
-    <summary>Command Line Interface</summary>

+### Command Line Interface
 The cli interface can be enabled using `--frontend cli` as commandline arguments.
 Type `help` to list the available commands.

@@ -275,17 +253,13 @@ $ cargo run --release -- --frontend cli
 (...)
 > activate 0
 ```
-</details>
-
-<details>
-    <summary>Daemon Mode</summary>
-
-Lan Mouse can be launched in daemon mode to keep it running in the background (e.g. for use in a systemd-service).

+### Daemon
+Lan Mouse can be launched in daemon mode to keep it running in the background.
 To do so, add `--daemon` to the commandline args:

 ```sh
-lan-mouse --daemon
+$ cargo run --release -- --daemon
 ```

 In order to start lan-mouse with a graphical session automatically,
@@ -298,7 +272,6 @@ cp service/lan-mouse.service ~/.config/systemd/user
 systemctl --user daemon-reload
 systemctl --user enable --now lan-mouse.service
 ```
-</details>

 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.
@@ -354,60 +327,109 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
 - [x] Liveness tracking: Automatically release keys, when server offline
 - [x] MacOS KeyCode Translation
 - [x] Libei Input Capture
- [x] MacOS Input Capture
- [x] Windows Input Capture
- [ ] *Encryption* (WIP)
 - [ ] X11 Input Capture
+- [ ] Windows Input Capture
+- [ ] MacOS Input Capture
 - [ ] Latency measurement and visualization
 - [ ] Bandwidth usage measurement and visualization
 - [ ] Clipboard support
+- [ ] *Encryption*
+
+## Protocol
+Currently *all* mouse and keyboard events are sent via **UDP** for performance reasons.
+Each event is sent as one single datagram, currently without any acknowledgement to guarantee 0% packet loss.
+This means, any packet that is lost results in a discarded mouse / key event, which is ignored for now.
+
+**UDP** also has the additional benefit that no reconnection logic is required.
+Any client can just go offline and it will simply start working again as soon as it comes back online.
+
+Additionally a tcp server is hosted for data that needs to be sent reliably (e.g. the keymap from the server or clipboard contents in the future) can be requested via a tcp connection.
+
+## Bandwidth considerations
+The most bandwidth is taken up by mouse events. A typical office mouse has a polling rate of 125Hz
+while gaming mice typically have a much higher polling rate of 1000Hz.
+A mouse Event consists of 21 Bytes:
+- 1 Byte for the event type enum,
+- 4 Bytes (u32) for the timestamp,
+- 8 Bytes (f64) for dx,
+- 8 Bytes (f64) for dy.
+
+Additionally the IP header with 20 Bytes and the udp header with 8 Bytes take up another 28 Byte.
+So in total there is 49 * 1000 Bytes/s for a 1000Hz gaming mouse.
+This makes for a bandwidth requirement of 392 kbit/s in total _even_ for a high end gaming mouse.
+So bandwidth is a non-issue.
+
+Larger data chunks, like the keymap are offered by the server via tcp listening on the same port.
+This way we dont need to implement any congestion control and leave this up to tcp.
+In the future this can be used for e.g. clipboard contents as well.
+
+## Packets per Second
+While on LAN the performance is great,
+some WIFI cards seem to struggle with the amount of packets per second,
+particularly on high-end gaming mice with 1000Hz+ polling rates.
+
+The plan is to implement a way of accumulating packets and sending them as
+one single key event to reduce the packet rate (basically reducing the polling
+rate artificially).
+
+The way movement data is currently sent is also quite wasteful since even a 16bit integer
+is likely enough to represent even the fastest possible mouse movement.
+A different encoding that is more efficient for smaller values like
+[Protocol Buffers](https://protobuf.dev/programming-guides/encoding/)
+would be a better choice for the future and could also help for WIFI connections.
+
+## Security
+Sending key and mouse event data over the local network might not be the biggest security concern but in any public network or business environment it's *QUITE* a problem to basically broadcast your keystrokes.
+- There should be an encryption layer below the application to enable a secure link.
+- The encryption keys could be generated by the graphical frontend.


-## Detailed OS Support
+## Wayland support
+### Input Emulation (for receiving events)
+On wayland input-emulation is in an early/unstable state as of writing this.

-In order to use a device for sending events, an **input-capture** backend is required, while receiving events requires
-a supported **input-emulation** *and* **input-capture** backend.
+For this reason a suitable backend is chosen based on the active desktop environment / compositor.

-A suitable backend is chosen automatically based on the active desktop environment / compositor.
+Different compositors have different ways of enabling input emulation:

-The following sections detail the emulation and capture backends provided by lan-mouse and their support in desktop environments / operating systems.
+#### Wlroots
+Most wlroots-based compositors like Hyprland and Sway support the following
+unstable wayland protocols for keyboard and mouse emulation:
+- [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1)
+- [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1)

-### Input Emulation Support
+#### KDE
+KDE also has a protocol for input emulation ([kde-fake-input](https://wayland.app/protocols/kde-fake-input)),
+it is however not exposed to third party applications.

-| Desktop / Backend         | layer-shell              | libei                    | windows                  |   macos                                | x11 |
-|---------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|-----|
-| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                                        |     |
-| Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |     |
-| Wayland (Gnome)           |                          | :heavy_check_mark:       |                          |                                        |     |
-| Windows                   |                          |                          | :heavy_check_mark:       |                                        |     |
-| MacOS                     |                          |                          |                          |   :heavy_check_mark:                   |     |
-| X11                       |                          |                          |                          |                                        | WIP |
+The recommended way to emulate input on KDE is the
+[freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop).

- `wlroots`: This backend makes use of the [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1) and [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1) protocols and is supported by most wlroots based compositors.
- `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
- `xdp`: This backend uses the [freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop) and is supported on GNOME and Plasma.
- `x11`: Backend for X11 sessions.
- `windows`: Backend for Windows.
- `macos`: Backend for MacOS.
+#### Gnome
+Gnome uses [libei](https://gitlab.freedesktop.org/libinput/libei) for input emulation and capture,
+which has the goal to become the general approach for emulating and capturing Input on Wayland.

+### Input capture

+To capture mouse and keyboard input, a few things are necessary:
+- Displaying an immovable surface at screen edges
+- Locking the mouse in place
+- (optionally but highly recommended) reading unaccelerated mouse input

-### Input Capture Support
+|  Required Protocols  (Event Emitting)  | Sway               | Kwin                 | Gnome                |
+|----------------------------------------|--------------------|----------------------|----------------------|
+| pointer-constraints-unstable-v1        | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| relative-pointer-unstable-v1           | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| keyboard-shortcuts-inhibit-unstable-v1 | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| wlr-layer-shell-unstable-v1            | :heavy_check_mark: | :heavy_check_mark:   | :x:                  |

-| Desktop / Backend         | wlroots                  | libei                    | remote-desktop portal    | windows                  |   macos                                | x11                |
-|---------------------------|--------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|--------------------|
-| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                          |                                        |                    |
-| Wayland (KDE)             |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
-| Wayland (Gnome)           |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
-| Windows                   |                          |                          |                          | :heavy_check_mark:       |                                        |                    |
-| MacOS                     |                          |                          |                          |                          |   :heavy_check_mark:                   |                    |
-| X11                       |                          |                          |                          |                          |                                        | :heavy_check_mark: |
-
- `layer-shell`: This backend creates a single pixel wide window on the edges of Displays to capture the cursor using the [layer-shell protocol](https://wayland.app/protocols/wlr-layer-shell-unstable-v1).
- `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
- `windows`: Backend for input capture on Windows.
- `macos`: Backend for input capture on MacOS.
- `x11`: TODO (not yet supported)
+The [zwlr\_virtual\_pointer\_manager\_v1](wlr-virtual-pointer-unstable-v1) is required
+to display surfaces on screen edges and used to display the immovable window on
+both wlroots based compositors and KDE.

+Gnome unfortunately does not support this protocol
+and [likely won't ever support it](https://gitlab.gnome.org/GNOME/gnome-shell/-/issues/1141).

+~In order for layershell surfaces to be able to lock the pointer using the pointer\_constraints protocol [this patch](https://github.com/swaywm/sway/pull/7178) needs to be applied to sway.~
+(this works natively on sway versions >= 1.8)

--- a/default.nix
+++ b/default.nix
@@ -1,3 +0,0 @@
-{ pkgs ? import <nixpkgs> { }
-}:
-pkgs.callPackage nix/default.nix { }
--- a/flake.lock
+++ b/flake.lock
@@ -1,12 +1,30 @@
 {
  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1705309234,
+        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1728018373,
-        "narHash": "sha256-NOiTvBbRLIOe5F6RbHaAh6++BNjsb149fGZd1T4+KBg=",
+        "lastModified": 1716293225,
+        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "bc947f541ae55e999ffdb4013441347d83b00feb",
+        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
        "type": "github"
      },
      "original": {
@@ -24,16 +42,17 @@
    },
    "rust-overlay": {
      "inputs": {
+        "flake-utils": "flake-utils",
        "nixpkgs": [
          "nixpkgs"
        ]
      },
      "locked": {
-        "lastModified": 1728181869,
-        "narHash": "sha256-sQXHXsjIcGEoIHkB+RO6BZdrPfB+43V1TEpyoWRI3ww=",
+        "lastModified": 1716257780,
+        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "cd46aa3906c14790ef5cbe278d9e54f2c38f95c0",
+        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
        "type": "github"
      },
      "original": {
@@ -41,6 +60,21 @@
        "repo": "rust-overlay",
        "type": "github"
      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
    }
  },
  "root": "root",
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-capture"
 description = "cross-platform input-capture library used by lan-mouse"
-version = "0.3.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -10,10 +10,10 @@ repository = "https://github.com/feschber/lan-mouse"
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.3.0" }
+input-event = { path = "../input-event", version = "0.2.1" }
 memmap = "0.7"
 tempfile = "3.8"
-thiserror = "2.0.0"
+thiserror = "1.0.61"
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
@@ -40,18 +40,18 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.10", default-features = false, features = [
+ashpd = { version = "0.9", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.4", features = ["tokio"], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.24.0", features = ["highsierra"] }
-core-foundation = "0.10.0"
+core-graphics = { version = "0.23", features = ["highsierra"] }
+core-foundation = "0.9.4"
 core-foundation-sys = "0.8.6"
 libc = "0.2.155"
 keycode = "0.4.0"
-bitflags = "2.6.0"
+bitflags = "2.5.0"

 [target.'cfg(windows)'.dependencies]
 windows = { version = "0.58.0", features = [
@@ -65,8 +65,8 @@ windows = { version = "0.58.0", features = [
 ] }

 [features]
-default = ["layer_shell", "x11", "libei"]
-layer_shell = [
+default = ["wayland", "x11", "libei"]
+wayland = [
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
--- a/input-capture/src/dummy.rs
+++ b/input-capture/src/dummy.rs
@@ -8,7 +8,7 @@ use futures_core::Stream;
 use input_event::PointerEvent;
 use tokio::time::{self, Instant, Interval};

-use super::{Capture, CaptureError, CaptureEvent, Position};
+use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};

 pub struct DummyInputCapture {
    start: Option<Instant>,
@@ -34,11 +34,11 @@ impl Default for DummyInputCapture {

 #[async_trait]
 impl Capture for DummyInputCapture {
-    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }

-    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
        Ok(())
    }

@@ -55,7 +55,7 @@ const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;

 impl Stream for DummyInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let current = ready!(self.interval.poll_tick(cx));
@@ -81,6 +81,6 @@ impl Stream for DummyInputCapture {
                }))
            }
        };
-        Poll::Ready(Some(Ok((Position::Left, event))))
+        Poll::Ready(Some(Ok((0, event))))
    }
 }
--- a/input-capture/src/error.rs
+++ b/input-capture/src/error.rs
@@ -8,9 +8,9 @@ pub enum InputCaptureError {
    Capture(#[from] CaptureError),
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use std::io;
-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
    globals::{BindError, GlobalError},
@@ -19,10 +19,26 @@ use wayland_client::{

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::desktop::ResponseError;
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::{EiConvertEventStreamError, HandshakeError};

 #[cfg(target_os = "macos")]
 use core_graphics::base::CGError;

+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("error in libei stream: {inner:?}")]
+pub struct ReisConvertEventStreamError {
+    inner: EiConvertEventStreamError,
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
+    fn from(e: EiConvertEventStreamError) -> Self {
+        Self { inner: e }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum CaptureError {
    #[error("activation stream closed unexpectedly")]
@@ -32,8 +48,11 @@ pub enum CaptureError {
    #[error("io error: `{0}`")]
    Io(#[from] std::io::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei error: `{0}`")]
-    Reis(#[from] reis::Error),
+    #[error("error in libei stream: `{0}`")]
+    Reis(#[from] ReisConvertEventStreamError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei handshake failed: `{0}`")]
+    Handshake(#[from] HandshakeError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error(transparent)]
    Portal(#[from] ashpd::Error),
@@ -64,7 +83,7 @@ pub enum CaptureCreationError {
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("error creating input-capture-portal backend: `{0}`")]
    Libei(#[from] LibeiCaptureCreationError),
-    #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("error creating layer-shell capture backend: `{0}`")]
    LayerShell(#[from] LayerShellCaptureCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -74,7 +93,7 @@ pub enum CaptureCreationError {
    #[error("error creating windows capture backend")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[error("error creating macos capture backend: `{0}`")]
+    #[error("error creating macos capture backend")]
    MacOS(#[from] MacosCaptureCreationError),
 }

@@ -102,7 +121,7 @@ pub enum LibeiCaptureCreationError {
    Ashpd(#[from] ashpd::Error),
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("{protocol} protocol not supported: {inner}")]
 pub struct WaylandBindError {
@@ -110,14 +129,14 @@ pub struct WaylandBindError {
    protocol: &'static str,
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
        Self { inner, protocol }
    }
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LayerShellCaptureCreationError {
    #[error(transparent)]
@@ -146,9 +165,6 @@ pub enum X11InputCaptureCreationError {
 pub enum MacosCaptureCreationError {
    #[error("event source creation failed!")]
    EventSourceCreation,
-    #[cfg(target_os = "macos")]
-    #[error("event tap creation failed")]
-    EventTapCreation,
    #[error("failed to set CG Cursor property")]
    CGCursorProperty,
    #[cfg(target_os = "macos")]
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -1,9 +1,4 @@
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    fmt::Display,
-    mem::swap,
-    task::{ready, Poll},
-};
+use std::{collections::HashSet, fmt::Display, task::Poll};

 use async_trait::async_trait;
 use futures::StreamExt;
@@ -21,8 +16,8 @@ mod libei;
 #[cfg(target_os = "macos")]
 mod macos;

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
-mod layer_shell;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+mod wayland;

 #[cfg(windows)]
 mod windows;
@@ -87,7 +82,7 @@ impl Display for Position {
 pub enum Backend {
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    InputCapturePortal,
-    #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    LayerShell,
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
@@ -103,7 +98,7 @@ impl Display for Backend {
        match self {
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::InputCapturePortal => write!(f, "input-capture-portal"),
-            #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::LayerShell => write!(f, "layer-shell"),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => write!(f, "X11"),
@@ -117,52 +112,19 @@ impl Display for Backend {
 }

 pub struct InputCapture {
-    /// capture backend
    capture: Box<dyn Capture>,
-    /// keys pressed by active capture
    pressed_keys: HashSet<scancode::Linux>,
-    /// map from position to ids
-    position_map: HashMap<Position, Vec<CaptureHandle>>,
-    /// map from id to position
-    id_map: HashMap<CaptureHandle, Position>,
-    /// pending events
-    pending: VecDeque<(CaptureHandle, CaptureEvent)>,
 }

 impl InputCapture {
    /// create a new client with the given id
    pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
-        assert!(!self.id_map.contains_key(&id));
-
-        self.id_map.insert(id, pos);
-
-        if let Some(v) = self.position_map.get_mut(&pos) {
-            v.push(id);
-            Ok(())
-        } else {
-            self.position_map.insert(pos, vec![id]);
-            self.capture.create(pos).await
-        }
+        self.capture.create(id, pos).await
    }

    /// destroy the client with the given id, if it exists
    pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
-        let pos = self
-            .id_map
-            .remove(&id)
-            .expect("no position for this handle");
-
-        log::debug!("destroying capture {id} @ {pos}");
-        let remaining = self.position_map.get_mut(&pos).expect("id vector");
-        remaining.retain(|&i| i != id);
-
-        log::debug!("remaining ids @ {pos}: {remaining:?}");
-        if remaining.is_empty() {
-            log::debug!("destroying capture @ {pos} - no remaining ids");
-            self.position_map.remove(&pos);
-            self.capture.destroy(pos).await?;
-        }
-        Ok(())
+        self.capture.destroy(id).await
    }

    /// release mouse
@@ -181,9 +143,6 @@ impl InputCapture {
        let capture = create(backend).await?;
        Ok(Self {
            capture,
-            id_map: Default::default(),
-            pending: Default::default(),
-            position_map: Default::default(),
            pressed_keys: HashSet::new(),
        })
    }
@@ -201,6 +160,7 @@ impl InputCapture {
                _ => self.pressed_keys.remove(&scancode),
            };
        }
+        log::info!("pressed keys: {:?}", self.pressed_keys);
    }
 }

@@ -211,65 +171,29 @@ impl Stream for InputCapture {
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> Poll<Option<Self::Item>> {
-        if let Some(e) = self.pending.pop_front() {
-            return Poll::Ready(Some(Ok(e)));
-        }
-
-        // ready
-        let event = ready!(self.capture.poll_next_unpin(cx));
-
-        // stream closed
-        let event = match event {
-            Some(e) => e,
-            None => return Poll::Ready(None),
-        };
-
-        // error occurred
-        let (pos, event) = match event {
-            Ok(e) => e,
-            Err(e) => return Poll::Ready(Some(Err(e))),
-        };
-
-        // handle key presses
-        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = event {
-            self.update_pressed_keys(key, state);
-        }
-
-        let len = self
-            .position_map
-            .get(&pos)
-            .map(|ids| ids.len())
-            .unwrap_or(0);
-
-        match len {
-            0 => Poll::Pending,
-            1 => Poll::Ready(Some(Ok((
-                self.position_map.get(&pos).expect("no id")[0],
-                event,
-            )))),
-            _ => {
-                let mut position_map = HashMap::new();
-                swap(&mut self.position_map, &mut position_map);
+        match self.capture.poll_next_unpin(cx) {
+            Poll::Ready(e) => {
+                if let Some(Ok((
+                    _,
+                    CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })),
+                ))) = e
                {
-                    for &id in position_map.get(&pos).expect("position") {
-                        self.pending.push_back((id, event));
-                    }
+                    self.update_pressed_keys(key, state);
                }
-                swap(&mut self.position_map, &mut position_map);
-
-                Poll::Ready(Some(Ok(self.pending.pop_front().expect("event"))))
+                Poll::Ready(e)
            }
+            Poll::Pending => Poll::Pending,
        }
    }
 }

 #[async_trait]
-trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + Unpin {
+trait Capture: Stream<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>> + Unpin {
    /// create a new client with the given id
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError>;
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;

    /// destroy the client with the given id, if it exists
-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError>;
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;

    /// release mouse
    async fn release(&mut self) -> Result<(), CaptureError>;
@@ -281,14 +205,14 @@ trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + U
 async fn create_backend(
    backend: Backend,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
+    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
    CaptureCreationError,
 > {
    match backend {
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
-        #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
-        Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)),
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
        #[cfg(windows)]
@@ -302,7 +226,7 @@ async fn create_backend(
 async fn create(
    backend: Option<Backend>,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
+    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
    CaptureCreationError,
 > {
    if let Some(backend) = backend {
@@ -316,7 +240,7 @@ async fn create(
    for backend in [
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal,
-        #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
        Backend::LayerShell,
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11,
--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
@@ -1,9 +1,6 @@
 use ashpd::{
    desktop::{
-        input_capture::{
-            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
-            Zones,
-        },
+        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
        Session,
    },
    enumflags2::BitFlags,
@@ -11,15 +8,14 @@ use ashpd::{
 use async_trait::async_trait;
 use futures::{FutureExt, StreamExt};
 use reis::{
-    ei::{self, handshake::ContextType},
-    event::{Connection, DeviceCapability, EiEvent},
-    tokio::EiConvertEventStream,
+    ei,
+    event::{DeviceCapability, EiEvent},
+    tokio::{EiConvertEventStream, EiEventStream},
 };
 use std::{
    cell::Cell,
    collections::HashMap,
    io,
-    num::NonZeroU32,
    os::unix::net::UnixStream,
    pin::Pin,
    rc::Rc,
@@ -36,14 +32,15 @@ use tokio::{
 use tokio_util::sync::CancellationToken;

 use futures_core::Stream;
+use once_cell::sync::Lazy;

 use input_event::Event;

 use crate::CaptureEvent;

 use super::{
-    error::{CaptureError, LibeiCaptureCreationError},
-    Capture as LanMouseInputCapture, Position,
+    error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
+    Capture as LanMouseInputCapture, CaptureHandle, Position,
 };

 /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
@@ -53,21 +50,37 @@ use super::{
 /// events that necessitate restarting the capture session
 #[derive(Clone, Copy, Debug)]
 enum LibeiNotifyEvent {
-    Create(Position),
-    Destroy(Position),
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
 }

 #[allow(dead_code)]
 pub struct LibeiInputCapture<'a> {
    input_capture: Pin<Box<InputCapture<'a>>>,
    capture_task: JoinHandle<Result<(), CaptureError>>,
-    event_rx: Receiver<(Position, CaptureEvent)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
    notify_capture: Sender<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    cancellation_token: CancellationToken,
    terminated: bool,
 }

+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
 /// returns (start pos, end pos), inclusive
 fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
    let (x, y) = (r.x_offset(), r.y_offset());
@@ -104,37 +117,35 @@ impl From<ICBarrier> for Barrier {

 fn select_barriers(
    zones: &Zones,
-    clients: &[Position],
-    next_barrier_id: &mut NonZeroU32,
-) -> (Vec<ICBarrier>, HashMap<BarrierID, Position>) {
-    let mut pos_for_barrier = HashMap::new();
+    clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
+    let mut client_for_barrier = HashMap::new();
    let mut barriers: Vec<ICBarrier> = vec![];

-    for pos in clients {
+    for (handle, pos) in clients {
        let mut client_barriers = zones
            .regions()
            .iter()
            .map(|r| {
                let id = *next_barrier_id;
-                *next_barrier_id = next_barrier_id
-                    .checked_add(1)
-                    .expect("barrier id out of range");
+                *next_barrier_id = id + 1;
                let position = pos_to_barrier(r, *pos);
-                pos_for_barrier.insert(id, *pos);
+                client_for_barrier.insert(id, *handle);
                ICBarrier::new(id, position)
            })
            .collect();
        barriers.append(&mut client_barriers);
    }
-    (barriers, pos_for_barrier)
+    (barriers, client_for_barrier)
 }

 async fn update_barriers(
    input_capture: &InputCapture<'_>,
    session: &Session<'_, InputCapture<'_>>,
-    active_clients: &[Position],
-    next_barrier_id: &mut NonZeroU32,
-) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
    let zones = input_capture.zones(session).await?.response()?;
    log::debug!("zones: {zones:?}");

@@ -157,7 +168,7 @@ async fn create_session<'a>(
    log::debug!("creating input capture session");
    input_capture
        .create_session(
-            None,
+            &ashpd::WindowIdentifier::default(),
            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
        )
        .await
@@ -166,7 +177,7 @@ async fn create_session<'a>(
 async fn connect_to_eis(
    input_capture: &InputCapture<'_>,
    session: &Session<'_, InputCapture<'_>>,
-) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
+) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
    log::debug!("connect_to_eis");
    let fd = input_capture.connect_to_eis(session).await?;

@@ -176,27 +187,34 @@ async fn connect_to_eis(

    // create ei context
    let context = ei::Context::new(stream)?;
-    let (conn, event_stream) = context
-        .handshake_tokio("de.feschber.LanMouse", ContextType::Receiver)
-        .await?;
+    let mut event_stream = EiEventStream::new(context.clone())?;
+    let response = reis::tokio::ei_handshake(
+        &mut event_stream,
+        "de.feschber.LanMouse",
+        ei::handshake::ContextType::Receiver,
+        &INTERFACES,
+    )
+    .await?;
+    let event_stream = EiConvertEventStream::new(event_stream, response.serial);

-    Ok((context, conn, event_stream))
+    Ok((context, event_stream))
 }

 async fn libei_event_handler(
    mut ei_event_stream: EiConvertEventStream,
    context: ei::Context,
-    event_tx: Sender<(Position, CaptureEvent)>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    release_session: Arc<Notify>,
-    current_pos: Rc<Cell<Option<Position>>>,
+    current_client: Rc<Cell<Option<CaptureHandle>>>,
 ) -> Result<(), CaptureError> {
    loop {
        let ei_event = ei_event_stream
            .next()
            .await
-            .ok_or(CaptureError::EndOfStream)??;
+            .ok_or(CaptureError::EndOfStream)?
+            .map_err(ReisConvertEventStreamError::from)?;
        log::trace!("from ei: {ei_event:?}");
-        let client = current_pos.get();
+        let client = current_client.get();
        handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
    }
 }
@@ -242,15 +260,15 @@ async fn do_capture(
    mut capture_event: Receiver<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
-    event_tx: Sender<(Position, CaptureEvent)>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    cancellation_token: CancellationToken,
 ) -> Result<(), CaptureError> {
    let mut session = session.map(|s| s.0);

    /* safety: libei_task does not outlive Self */
    let input_capture = unsafe { &*input_capture };
-    let mut active_clients: Vec<Position> = vec![];
-    let mut next_barrier_id = NonZeroU32::new(1).expect("id must be non-zero");
+    let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
+    let mut next_barrier_id = 1u32;

    let mut zones_changed = input_capture.receive_zones_changed().await?;

@@ -323,8 +341,8 @@ async fn do_capture(
        // update clients if requested
        if let Some(event) = capture_event_occured.take() {
            match event {
-                LibeiNotifyEvent::Create(p) => active_clients.push(p),
-                LibeiNotifyEvent::Destroy(p) => active_clients.retain(|&pos| pos != p),
+                LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
+                LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
            }
        }

@@ -338,21 +356,21 @@ async fn do_capture(
 async fn do_capture_session(
    input_capture: &InputCapture<'_>,
    session: &mut Session<'_, InputCapture<'_>>,
-    event_tx: &Sender<(Position, CaptureEvent)>,
-    active_clients: &[Position],
-    next_barrier_id: &mut NonZeroU32,
+    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
    notify_release: &Notify,
    cancel: (CancellationToken, CancellationToken),
 ) -> Result<(), CaptureError> {
    let (cancel_session, cancel_update) = cancel;
    // current client
-    let current_pos = Rc::new(Cell::new(None));
+    let current_client = Rc::new(Cell::new(None));

    // connect to eis server
-    let (context, _conn, ei_event_stream) = connect_to_eis(input_capture, session).await?;
+    let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;

    // set barriers
-    let (barriers, pos_for_barrier_id) =
+    let (barriers, client_for_barrier_id) =
        update_barriers(input_capture, session, active_clients, next_barrier_id).await?;

    log::debug!("enabling session");
@@ -364,7 +382,7 @@ async fn do_capture_session(
    // async event task
    let cancel_ei_handler = CancellationToken::new();
    let event_chan = event_tx.clone();
-    let pos = current_pos.clone();
+    let client = current_client.clone();
    let cancel_session_clone = cancel_session.clone();
    let release_session_clone = release_session.clone();
    let cancel_ei_handler_clone = cancel_ei_handler.clone();
@@ -375,7 +393,7 @@ async fn do_capture_session(
                context,
                event_chan,
                release_session_clone,
-                pos,
+                client,
            ) => {
                log::debug!("libei exited: {r:?} cancelling session task");
                cancel_session_clone.cancel();
@@ -397,17 +415,17 @@ async fn do_capture_session(

                    // get barrier id from activation
                    let barrier_id = match activated.barrier_id() {
-                        Some(ActivatedBarrier::Barrier(id)) => id,
+                        Some(bid) => bid,
                        // workaround for KDE plasma not reporting barrier ids
-                        Some(ActivatedBarrier::UnknownBarrier) | None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
+                        None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
                    };

                    // find client corresponding to barrier
-                    let pos = *pos_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
-                    current_pos.replace(Some(pos));
+                    let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
+                    current_client.replace(Some(client));

                    // client entered => send event
-                    event_tx.send((pos, CaptureEvent::Begin)).await.expect("no channel");
+                    event_tx.send((client, CaptureEvent::Begin)).await.expect("no channel");

                    tokio::select! {
                        _ = notify_release.notified() => { /* capture release */
@@ -423,7 +441,7 @@ async fn do_capture_session(
                        },
                    }

-                    release_capture(input_capture, session, activated, pos).await?;
+                    release_capture(input_capture, session, activated, client, active_clients).await?;

                }
                _ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
@@ -466,7 +484,8 @@ async fn release_capture<'a>(
    input_capture: &InputCapture<'a>,
    session: &Session<'a, InputCapture<'a>>,
    activated: Activated,
-    current_pos: Position,
+    current_client: CaptureHandle,
+    active_clients: &[(CaptureHandle, Position)],
 ) -> Result<(), CaptureError> {
    if let Some(activation_id) = activated.activation_id() {
        log::debug!("releasing input capture {activation_id}");
@@ -475,7 +494,13 @@ async fn release_capture<'a>(
        .cursor_position()
        .expect("compositor did not report cursor position!");
    log::debug!("client entered @ ({x}, {y})");
-    let (dx, dy) = match current_pos {
+    let pos = active_clients
+        .iter()
+        .filter(|(c, _)| *c == current_client)
+        .map(|(_, p)| p)
+        .next()
+        .unwrap(); // FIXME
+    let (dx, dy) = match pos {
        // offset cursor position to not enter again immediately
        Position::Left => (1., 0.),
        Position::Right => (-1., 0.),
@@ -529,9 +554,9 @@ static ALL_CAPABILITIES: &[DeviceCapability] = &[

 async fn handle_ei_event(
    ei_event: EiEvent,
-    current_client: Option<Position>,
+    current_client: Option<CaptureHandle>,
    context: &ei::Context,
-    event_tx: &Sender<(Position, CaptureEvent)>,
+    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
    release_session: &Notify,
 ) -> Result<(), CaptureError> {
    match ei_event {
@@ -550,9 +575,9 @@ async fn handle_ei_event(
            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
        }
        _ => {
-            if let Some(pos) = current_client {
+            if let Some(handle) = 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((handle, CaptureEvent::Input(event))).await.expect("no channel");
                }
            }
        }
@@ -562,18 +587,18 @@ async fn handle_ei_event(

 #[async_trait]
 impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
        let _ = self
            .notify_capture
-            .send(LibeiNotifyEvent::Create(pos))
+            .send(LibeiNotifyEvent::Create(handle, pos))
            .await;
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
        let _ = self
            .notify_capture
-            .send(LibeiNotifyEvent::Destroy(pos))
+            .send(LibeiNotifyEvent::Destroy(handle))
            .await;
        Ok(())
    }
@@ -604,7 +629,7 @@ impl<'a> Drop for LibeiInputCapture<'a> {
 }

 impl<'a> Stream for LibeiInputCapture<'a> {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match self.capture_task.poll_unpin(cx) {
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -1,4 +1,6 @@
-use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
+use super::{
+    error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle, Position,
+};
 use async_trait::async_trait;
 use bitflags::bitflags;
 use core_foundation::base::{kCFAllocatorDefault, CFRelease};
@@ -18,14 +20,14 @@ use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
-use std::collections::HashSet;
+use std::collections::HashMap;
 use std::ffi::{c_char, CString};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{ready, Context, Poll};
 use std::thread::{self};
-use tokio::sync::mpsc::{self, Receiver, Sender};
-use tokio::sync::{oneshot, Mutex};
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::Mutex;

 #[derive(Debug, Default)]
 struct Bounds {
@@ -37,44 +39,44 @@ struct Bounds {

 #[derive(Debug)]
 struct InputCaptureState {
-    active_clients: Lazy<HashSet<Position>>,
-    current_pos: Option<Position>,
+    client_for_pos: Lazy<HashMap<Position, CaptureHandle>>,
+    current_client: Option<(CaptureHandle, Position)>,
    bounds: Bounds,
 }

 #[derive(Debug)]
 enum ProducerEvent {
    Release,
-    Create(Position),
-    Destroy(Position),
-    Grab(Position),
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+    Grab((CaptureHandle, Position)),
    EventTapDisabled,
 }

 impl InputCaptureState {
    fn new() -> Result<Self, MacosCaptureCreationError> {
        let mut res = Self {
-            active_clients: Lazy::new(HashSet::new),
-            current_pos: None,
+            client_for_pos: Lazy::new(HashMap::new),
+            current_client: None,
            bounds: Bounds::default(),
        };
        res.update_bounds()?;
        Ok(res)
    }

-    fn crossed(&mut self, event: &CGEvent) -> Option<Position> {
+    fn crossed(&mut self, event: &CGEvent) -> Option<(CaptureHandle, Position)> {
        let location = event.location();
        let relative_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X);
        let relative_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y);

-        for &position in self.active_clients.iter() {
-            if (position == Position::Left && (location.x + relative_x) <= self.bounds.xmin)
-                || (position == Position::Right && (location.x + relative_x) >= self.bounds.xmax)
-                || (position == Position::Top && (location.y + relative_y) <= self.bounds.ymin)
-                || (position == Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
+        for (position, client) in self.client_for_pos.iter() {
+            if (position == &Position::Left && (location.x + relative_x) <= self.bounds.xmin)
+                || (position == &Position::Right && (location.x + relative_x) >= self.bounds.xmax)
+                || (position == &Position::Top && (location.y + relative_y) <= self.bounds.ymin)
+                || (position == &Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
            {
-                log::debug!("Crossed barrier into position: {position:?}");
-                return Some(position);
+                log::debug!("Crossed barrier into client: {client}, {position:?}");
+                return Some((*client, *position));
            }
        }
        None
@@ -100,7 +102,7 @@ impl InputCaptureState {
    // to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
    // random location when we exit the client
    fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
-        if let Some(pos) = self.current_pos {
+        if let Some((_, pos)) = self.current_client {
            let location = event.location();
            let edge_offset = 1.0;

@@ -144,31 +146,40 @@ impl InputCaptureState {
        log::debug!("handling event: {producer_event:?}");
        match producer_event {
            ProducerEvent::Release => {
-                if self.current_pos.is_some() {
+                if self.current_client.is_some() {
                    CGDisplay::show_cursor(&CGDisplay::main())
                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_pos = None;
+                    self.current_client = None;
                }
            }
-            ProducerEvent::Grab(pos) => {
-                if self.current_pos.is_none() {
+            ProducerEvent::Grab(client) => {
+                if self.current_client.is_none() {
                    CGDisplay::hide_cursor(&CGDisplay::main())
                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_pos = Some(pos);
+                    self.current_client = Some(client);
                }
            }
-            ProducerEvent::Create(p) => {
-                self.active_clients.insert(p);
+            ProducerEvent::Create(c, p) => {
+                self.client_for_pos.insert(p, c);
            }
-            ProducerEvent::Destroy(p) => {
-                if let Some(current) = self.current_pos {
-                    if current == p {
-                        CGDisplay::show_cursor(&CGDisplay::main())
-                            .map_err(CaptureError::CoreGraphics)?;
-                        self.current_pos = None;
-                    };
+            ProducerEvent::Destroy(c) => {
+                for pos in [
+                    Position::Left,
+                    Position::Right,
+                    Position::Top,
+                    Position::Bottom,
+                ] {
+                    if let Some((current_c, _)) = self.current_client {
+                        if current_c == c {
+                            CGDisplay::show_cursor(&CGDisplay::main())
+                                .map_err(CaptureError::CoreGraphics)?;
+                            self.current_client = None;
+                        };
+                    }
+                    if self.client_for_pos.get(&pos).copied() == Some(c) {
+                        self.client_for_pos.remove(&pos);
+                    }
                }
-                self.active_clients.remove(&p);
            }
            ProducerEvent::EventTapDisabled => return Err(CaptureError::EventTapDisabled),
        };
@@ -322,11 +333,12 @@ fn get_events(
    Ok(())
 }

-fn create_event_tap<'a>(
+fn event_tap_thread(
    client_state: Arc<Mutex<InputCaptureState>>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
-    event_tx: Sender<(Position, CaptureEvent)>,
-) -> Result<CGEventTap<'a>, MacosCaptureCreationError> {
+    exit: tokio::sync::oneshot::Sender<Result<(), &'static str>>,
+) {
    let cg_events_of_interest: Vec<CGEventType> = vec![
        CGEventType::LeftMouseDown,
        CGEventType::LeftMouseUp,
@@ -344,11 +356,15 @@ fn create_event_tap<'a>(
        CGEventType::FlagsChanged,
    ];

-    let event_tap_callback =
-        move |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
+    let tap = CGEventTap::new(
+        CGEventTapLocation::Session,
+        CGEventTapPlacement::HeadInsertEventTap,
+        CGEventTapOptions::Default,
+        cg_events_of_interest,
+        |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
            log::trace!("Got event from tap: {event_type:?}");
            let mut state = client_state.blocking_lock();
-            let mut pos = None;
+            let mut client = None;
            let mut res_events = vec![];

            if matches!(
@@ -364,8 +380,8 @@ fn create_event_tap<'a>(
            }

            // Are we in a client?
-            if let Some(current_pos) = state.current_pos {
-                pos = Some(current_pos);
+            if let Some((current_client, _)) = state.current_client {
+                client = Some(current_client);
                get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
                    log::error!("Failed to get events: {e}");
                });
@@ -379,19 +395,19 @@ fn create_event_tap<'a>(
            }
            // Did we cross a barrier?
            else if matches!(event_type, CGEventType::MouseMoved) {
-                if let Some(new_pos) = state.crossed(cg_ev) {
-                    pos = Some(new_pos);
+                if let Some((new_client, pos)) = state.crossed(cg_ev) {
+                    client = Some(new_client);
                    res_events.push(CaptureEvent::Begin);
                    notify_tx
-                        .blocking_send(ProducerEvent::Grab(new_pos))
+                        .blocking_send(ProducerEvent::Grab((new_client, pos)))
                        .expect("Failed to send notification");
                }
            }

-            if let Some(pos) = pos {
+            if let Some(client) = client {
                res_events.iter().for_each(|e| {
                    event_tx
-                        .blocking_send((pos, *e))
+                        .blocking_send((client, *e))
                        .expect("Failed to send event");
                });
                // Returning None should stop the event from being processed
@@ -399,16 +415,9 @@ fn create_event_tap<'a>(
                cg_ev.set_type(CGEventType::Null);
            }
            Some(cg_ev.to_owned())
-        };
-
-    let tap = CGEventTap::new(
-        CGEventTapLocation::Session,
-        CGEventTapPlacement::HeadInsertEventTap,
-        CGEventTapOptions::Default,
-        cg_events_of_interest,
-        event_tap_callback,
+        },
    )
-    .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
+    .expect("Failed creating tap");

    let tap_source: CFRunLoopSource = tap
        .mach_port
@@ -419,43 +428,22 @@ fn create_event_tap<'a>(
        CFRunLoop::get_current().add_source(&tap_source, kCFRunLoopCommonModes);
    }

-    Ok(tap)
-}
-
-fn event_tap_thread(
-    client_state: Arc<Mutex<InputCaptureState>>,
-    event_tx: Sender<(Position, CaptureEvent)>,
-    notify_tx: Sender<ProducerEvent>,
-    ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
-    exit: oneshot::Sender<Result<(), &'static str>>,
-) {
-    let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
-        Err(e) => {
-            ready.send(Err(e)).expect("channel closed");
-            return;
-        }
-        Ok(tap) => {
-            ready.send(Ok(())).expect("channel closed");
-            tap
-        }
-    };
    CFRunLoop::run_current();

    let _ = exit.send(Err("tap thread exited"));
 }

 pub struct MacOSInputCapture {
-    event_rx: Receiver<(Position, CaptureEvent)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
 }

 impl MacOSInputCapture {
    pub async fn new() -> Result<Self, MacosCaptureCreationError> {
        let state = Arc::new(Mutex::new(InputCaptureState::new()?));
-        let (event_tx, event_rx) = mpsc::channel(32);
-        let (notify_tx, mut notify_rx) = mpsc::channel(32);
-        let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-        let (tap_exit_tx, mut tap_exit_rx) = oneshot::channel();
+        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
+        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
+        let (tap_exit_tx, mut tap_exit_rx) = tokio::sync::oneshot::channel();

        unsafe {
            configure_cf_settings()?;
@@ -469,14 +457,10 @@ impl MacOSInputCapture {
                event_tap_thread_state,
                event_tx,
                event_tap_notify,
-                ready_tx,
                tap_exit_tx,
            )
        });

-        // wait for event tap creation result
-        ready_rx.recv().expect("channel closed")?;
-
        let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
            loop {
                tokio::select! {
@@ -507,21 +491,21 @@ impl MacOSInputCapture {

 #[async_trait]
 impl Capture for MacOSInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
-            log::debug!("creating capture, {pos}");
-            let _ = notify_tx.send(ProducerEvent::Create(pos)).await;
+            log::debug!("creating client {id}, {pos}");
+            let _ = notify_tx.send(ProducerEvent::Create(id, pos)).await;
            log::debug!("done !");
        });
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
-            log::debug!("destroying capture {pos}");
-            let _ = notify_tx.send(ProducerEvent::Destroy(pos)).await;
+            log::debug!("destroying client {id}");
+            let _ = notify_tx.send(ProducerEvent::Destroy(id)).await;
            log::debug!("done !");
        });
        Ok(())
@@ -542,7 +526,7 @@ impl Capture for MacOSInputCapture {
 }

 impl Stream for MacOSInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
--- a/input-capture/src/layer_shell.rs
+++ b/input-capture/src/layer_shell.rs
@@ -64,7 +64,7 @@ use crate::{CaptureError, CaptureEvent};

 use super::{
    error::{LayerShellCaptureCreationError, WaylandBindError},
-    Capture, Position,
+    Capture, CaptureHandle, Position,
 };

 struct Globals {
@@ -102,13 +102,13 @@ struct State {
    pointer_lock: Option<ZwpLockedPointerV1>,
    rel_pointer: Option<ZwpRelativePointerV1>,
    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    active_windows: Vec<Arc<Window>>,
-    focused: Option<Arc<Window>>,
+    client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
+    focused: Option<(Arc<Window>, CaptureHandle)>,
    g: Globals,
    wayland_fd: RawFd,
    read_guard: Option<ReadEventsGuard>,
    qh: QueueHandle<Self>,
-    pending_events: VecDeque<(Position, CaptureEvent)>,
+    pending_events: VecDeque<(CaptureHandle, CaptureEvent)>,
    output_info: Vec<(WlOutput, OutputInfo)>,
    scroll_discrete_pending: bool,
 }
@@ -124,7 +124,7 @@ impl AsRawFd for Inner {
    }
 }

-pub struct LayerShellInputCapture(AsyncFd<Inner>);
+pub struct WaylandInputCapture(AsyncFd<Inner>);

 struct Window {
    buffer: wl_buffer::WlBuffer,
@@ -256,7 +256,7 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
    }
 }

-impl LayerShellInputCapture {
+impl WaylandInputCapture {
    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
        let conn = Connection::connect_to_env()?;
        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
@@ -323,7 +323,7 @@ impl LayerShellInputCapture {
            pointer_lock: None,
            rel_pointer: None,
            shortcut_inhibitor: None,
-            active_windows: Vec::new(),
+            client_for_window: Vec::new(),
            focused: None,
            qh,
            wayland_fd,
@@ -370,18 +370,23 @@ impl LayerShellInputCapture {

        let inner = AsyncFd::new(Inner { queue, state })?;

-        Ok(LayerShellInputCapture(inner))
+        Ok(WaylandInputCapture(inner))
    }

-    fn add_client(&mut self, pos: Position) {
-        self.0.get_mut().state.add_client(pos);
+    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
+        self.0.get_mut().state.add_client(handle, pos);
    }

-    fn delete_client(&mut self, pos: Position) {
+    fn delete_client(&mut self, handle: CaptureHandle) {
        let inner = self.0.get_mut();
        // remove all windows corresponding to this client
-        while let Some(i) = inner.state.active_windows.iter().position(|w| w.pos == pos) {
-            inner.state.active_windows.remove(i);
+        while let Some(i) = inner
+            .state
+            .client_for_window
+            .iter()
+            .position(|(_, c)| *c == handle)
+        {
+            inner.state.client_for_window.remove(i);
            inner.state.focused = None;
        }
    }
@@ -395,7 +400,7 @@ impl State {
        serial: u32,
        qh: &QueueHandle<State>,
    ) {
-        let window = self.focused.as_ref().unwrap();
+        let (window, _) = self.focused.as_ref().unwrap();

        // hide the cursor
        pointer.set_cursor(serial, None, 0, 0);
@@ -438,7 +443,7 @@ impl State {

    fn ungrab(&mut self) {
        // get focused client
-        let window = match self.focused.as_ref() {
+        let (window, _client) = match self.focused.as_ref() {
            Some(focused) => focused,
            None => return,
        };
@@ -468,23 +473,27 @@ impl State {
        }
    }

-    fn add_client(&mut self, pos: Position) {
+    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
        let outputs = get_output_configuration(self, pos);

        log::debug!("outputs: {outputs:?}");
        outputs.iter().for_each(|(o, i)| {
            let window = Window::new(self, &self.qh, o, pos, i.size);
            let window = Arc::new(window);
-            self.active_windows.push(window);
+            self.client_for_window.push((window, client));
        });
    }

    fn update_windows(&mut self) {
        log::debug!("updating windows");
        log::debug!("output info: {:?}", self.output_info);
-        let clients: Vec<_> = self.active_windows.drain(..).map(|w| w.pos).collect();
-        for pos in clients {
-            self.add_client(pos);
+        let clients: Vec<_> = self
+            .client_for_window
+            .drain(..)
+            .map(|(w, c)| (c, w.pos))
+            .collect();
+        for (client, pos) in clients {
+            self.add_client(client, pos);
        }
    }
 }
@@ -557,15 +566,15 @@ impl Inner {
 }

 #[async_trait]
-impl Capture for LayerShellInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.add_client(pos);
+impl Capture for WaylandInputCapture {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        self.add_client(handle, pos);
        let inner = self.0.get_mut();
        Ok(inner.flush_events()?)
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.delete_client(pos);
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        self.delete_client(handle);
        let inner = self.0.get_mut();
        Ok(inner.flush_events()?)
    }
@@ -582,8 +591,8 @@ impl Capture for LayerShellInputCapture {
    }
 }

-impl Stream for LayerShellInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+impl Stream for WaylandInputCapture {
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
@@ -648,16 +657,10 @@ impl Dispatch<wl_seat::WlSeat, ()> for State {
            capabilities: WEnum::Value(capabilities),
        } = event
        {
-            if capabilities.contains(wl_seat::Capability::Pointer) {
-                if let Some(p) = state.pointer.take() {
-                    p.release();
-                }
+            if capabilities.contains(wl_seat::Capability::Pointer) && state.pointer.is_none() {
                state.pointer.replace(seat.get_pointer(qh, ()));
            }
-            if capabilities.contains(wl_seat::Capability::Keyboard) {
-                if let Some(k) = state.keyboard.take() {
-                    k.release();
-                }
+            if capabilities.contains(wl_seat::Capability::Keyboard) && state.keyboard.is_none() {
                seat.get_keyboard(qh, ());
            }
        }
@@ -682,20 +685,23 @@ impl Dispatch<WlPointer, ()> for State {
            } => {
                // get client corresponding to the focused surface
                {
-                    if let Some(window) = app.active_windows.iter().find(|w| w.surface == surface) {
-                        app.focused = Some(window.clone());
+                    if let Some((window, client)) = app
+                        .client_for_window
+                        .iter()
+                        .find(|(w, _c)| w.surface == surface)
+                    {
+                        app.focused = Some((window.clone(), *client));
                        app.grab(&surface, pointer, serial, qh);
                    } else {
                        return;
                    }
                }
-                let pos = app
-                    .active_windows
+                let (_, client) = app
+                    .client_for_window
                    .iter()
-                    .find(|w| w.surface == surface)
-                    .map(|w| w.pos)
+                    .find(|(w, _c)| w.surface == surface)
                    .unwrap();
-                app.pending_events.push_back((pos, CaptureEvent::Begin));
+                app.pending_events.push_back((*client, CaptureEvent::Begin));
            }
            wl_pointer::Event::Leave { .. } => {
                /* There are rare cases, where when a window is opened in
@@ -716,9 +722,9 @@ impl Dispatch<WlPointer, ()> for State {
                button,
                state,
            } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                app.pending_events.push_back((
-                    window.pos,
+                    *client,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                        time,
                        button,
@@ -727,7 +733,7 @@ impl Dispatch<WlPointer, ()> for State {
                ));
            }
            wl_pointer::Event::Axis { time, axis, value } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                if app.scroll_discrete_pending {
                    // each axisvalue120 event is coupled with
                    // a corresponding axis event, which needs to
@@ -735,7 +741,7 @@ impl Dispatch<WlPointer, ()> for State {
                    app.scroll_discrete_pending = false;
                } else {
                    app.pending_events.push_back((
-                        window.pos,
+                        *client,
                        CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
                            time,
                            axis: u32::from(axis) as u8,
@@ -745,10 +751,10 @@ impl Dispatch<WlPointer, ()> for State {
                }
            }
            wl_pointer::Event::AxisValue120 { axis, value120 } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                app.scroll_discrete_pending = true;
                app.pending_events.push_back((
-                    window.pos,
+                    *client,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::AxisDiscrete120 {
                        axis: u32::from(axis) as u8,
                        value: value120,
@@ -774,7 +780,10 @@ impl Dispatch<WlKeyboard, ()> for State {
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        let window = &app.focused;
+        let (_window, client) = match &app.focused {
+            Some(focused) => (Some(&focused.0), Some(&focused.1)),
+            None => (None, None),
+        };
        match event {
            wl_keyboard::Event::Key {
                serial: _,
@@ -782,9 +791,9 @@ impl Dispatch<WlKeyboard, ()> for State {
                key,
                state,
            } => {
-                if let Some(window) = window {
+                if let Some(client) = client {
                    app.pending_events.push_back((
-                        window.pos,
+                        *client,
                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
                            time,
                            key,
@@ -800,9 +809,9 @@ impl Dispatch<WlKeyboard, ()> for State {
                mods_locked,
                group,
            } => {
-                if let Some(window) = window {
+                if let Some(client) = client {
                    app.pending_events.push_back((
-                        window.pos,
+                        *client,
                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Modifiers {
                            depressed: mods_depressed,
                            latched: mods_latched,
@@ -834,10 +843,10 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
            ..
        } = event
        {
-            if let Some(window) = &app.focused {
+            if let Some((_window, client)) = &app.focused {
                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                app.pending_events.push_back((
-                    window.pos,
+                    *client,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
                ));
            }
@@ -855,10 +864,10 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
        _: &QueueHandle<Self>,
    ) {
        if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
-            if let Some(window) = app
-                .active_windows
+            if let Some((window, _client)) = app
+                .client_for_window
                .iter()
-                .find(|w| &w.layer_surface == layer_surface)
+                .find(|(w, _c)| &w.layer_surface == layer_surface)
            {
                // client corresponding to the layer_surface
                let surface = &window.surface;
--- a/input-capture/src/windows.rs
+++ b/input-capture/src/windows.rs
@@ -3,12 +3,12 @@ use core::task::{Context, Poll};
 use futures::Stream;
 use once_cell::unsync::Lazy;

-use std::collections::HashSet;
+use std::collections::HashMap;
 use std::ptr::{addr_of, addr_of_mut};

 use futures::executor::block_on;
 use std::default::Default;
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{mpsc, Mutex};
 use std::task::ready;
 use std::{pin::Pin, thread};
@@ -37,15 +37,15 @@ use input_event::{
    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };

-use super::{Capture, CaptureError, CaptureEvent, Position};
+use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};

 enum Request {
-    Create(Position),
-    Destroy(Position),
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
 }

 pub struct WindowsInputCapture {
-    event_rx: Receiver<(Position, CaptureEvent)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
    msg_thread: Option<std::thread::JoinHandle<()>>,
 }

@@ -65,22 +65,22 @@ unsafe fn signal_message_thread(event_type: EventType) {

 #[async_trait]
 impl Capture for WindowsInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Create(pos));
+                requests.push(Request::Create(handle, pos));
            }
            signal_message_thread(EventType::Request);
        }
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Destroy(pos));
+                requests.push(Request::Destroy(handle));
            }
            signal_message_thread(EventType::Request);
        }
@@ -98,9 +98,9 @@ impl Capture for WindowsInputCapture {
 }

 static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
-static mut ACTIVE_CLIENT: Option<Position> = None;
-static mut CLIENTS: Lazy<HashSet<Position>> = Lazy::new(HashSet::new);
-static mut EVENT_TX: Option<Sender<(Position, CaptureEvent)>> = None;
+static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
+static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
+static mut EVENT_TX: Option<Sender<(CaptureHandle, CaptureEvent)>> = None;
 static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
 unsafe fn set_event_tid(tid: u32) {
    EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
@@ -281,12 +281,12 @@ unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
    };

    /* check if a client is registered for the barrier */
-    if !CLIENTS.contains(&pos) {
+    let Some(client) = CLIENT_FOR_POS.get(&pos) else {
        return ret;
-    }
+    };

    /* update active client and entry point */
-    ACTIVE_CLIENT.replace(pos);
+    ACTIVE_CLIENT.replace(*client);
    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);

    /* notify main thread */
@@ -305,7 +305,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    }

    /* get active client if any */
-    let Some(pos) = ACTIVE_CLIENT else {
+    let Some(client) = ACTIVE_CLIENT else {
        return LRESULT(1);
    };

@@ -313,7 +313,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
        return LRESULT(1);
    };
-    let event = (pos, CaptureEvent::Input(Event::Pointer(pointer_event)));
+    let event = (client, CaptureEvent::Input(Event::Pointer(pointer_event)));

    /* notify mainthread (drop events if sending too fast) */
    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
@@ -493,8 +493,6 @@ fn get_msg() -> Option<MSG> {
    }
 }

-static WINDOW_CLASS_REGISTERED: AtomicBool = AtomicBool::new(false);
-
 fn message_thread(ready_tx: mpsc::Sender<()>) {
    unsafe {
        set_event_tid(GetCurrentThreadId());
@@ -515,15 +513,9 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            ..Default::default()
        };

-        if WINDOW_CLASS_REGISTERED
-            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
-            .is_ok()
-        {
-            /* register window class if not yet done so */
-            let ret = RegisterClassW(&window_class);
-            if ret == 0 {
-                panic!("RegisterClassW");
-            }
+        let ret = RegisterClassW(&window_class);
+        if ret == 0 {
+            panic!("RegisterClassW");
        }

        /* window is used ro receive WM_DISPLAYCHANGE messages */
@@ -583,16 +575,23 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {

 fn update_clients(request: Request) {
    match request {
-        Request::Create(pos) => {
-            unsafe { CLIENTS.insert(pos) };
+        Request::Create(handle, pos) => {
+            unsafe { CLIENT_FOR_POS.insert(pos, handle) };
        }
-        Request::Destroy(pos) => unsafe {
-            if let Some(active_pos) = ACTIVE_CLIENT {
-                if pos == active_pos {
-                    let _ = ACTIVE_CLIENT.take();
+        Request::Destroy(handle) => unsafe {
+            for pos in [
+                Position::Left,
+                Position::Right,
+                Position::Top,
+                Position::Bottom,
+            ] {
+                if ACTIVE_CLIENT == Some(handle) {
+                    ACTIVE_CLIENT.take();
+                }
+                if CLIENT_FOR_POS.get(&pos).copied() == Some(handle) {
+                    CLIENT_FOR_POS.remove(&pos);
                }
            }
-            CLIENTS.remove(&pos);
        },
    }
 }
@@ -615,7 +614,7 @@ impl WindowsInputCapture {
 }

 impl Stream for WindowsInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
            None => Poll::Ready(None),
--- a/input-capture/src/x11.rs
+++ b/input-capture/src/x11.rs
@@ -3,7 +3,10 @@ use std::task::Poll;
 use async_trait::async_trait;
 use futures_core::Stream;

-use super::{error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
+use super::{
+    error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle,
+    Position,
+};

 pub struct X11InputCapture {}

@@ -15,11 +18,11 @@ impl X11InputCapture {

 #[async_trait]
 impl Capture for X11InputCapture {
-    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }

-    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
        Ok(())
    }

@@ -33,7 +36,7 @@ impl Capture for X11InputCapture {
 }

 impl Stream for X11InputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(
        self: std::pin::Pin<&mut Self>,
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-emulation"
 description = "cross-platform input emulation library used by lan-mouse"
-version = "0.3.0"
+version = "0.2.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -10,8 +10,8 @@ repository = "https://github.com/feschber/lan-mouse"
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.3.0" }
-thiserror = "2.0.0"
+input-event = { path = "../input-event", version = "0.2.1" }
+thiserror = "1.0.61"
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
@@ -38,14 +38,13 @@ wayland-protocols-misc = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.10", default-features = false, features = [
+ashpd = { version = "0.9", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.4", features = ["tokio"], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
-bitflags = "2.6.0"
-core-graphics = { version = "0.24.0", features = ["highsierra"] }
+core-graphics = { version = "0.23", features = ["highsierra"] }
 keycode = "0.4.0"

 [target.'cfg(windows)'.dependencies]
@@ -60,13 +59,13 @@ windows = { version = "0.58.0", features = [
 ] }

 [features]
-default = ["wlroots", "x11", "remote_desktop_portal", "libei"]
-wlroots = [
+default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
+wayland = [
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
    "dep:wayland-protocols-misc",
 ]
 x11 = ["dep:x11"]
-remote_desktop_portal = ["dep:ashpd"]
+xdg_desktop_portal = ["dep:ashpd"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-emulation/src/error.rs
+++ b/input-emulation/src/error.rs
@@ -6,35 +6,53 @@ pub enum InputEmulationError {
    Emulate(#[from] EmulationError),
 }

-#[cfg(all(
-    unix,
-    any(feature = "remote_desktop_portal", feature = "libei"),
-    not(target_os = "macos")
-))]
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::{desktop::ResponseError, Error::Response};
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::EiConvertEventStreamError;
 use std::io;
 use thiserror::Error;

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
    globals::{BindError, GlobalError},
    ConnectError, DispatchError,
 };

+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::HandshakeError;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("error in libei stream: {inner:?}")]
+pub struct ReisConvertStreamError {
+    inner: EiConvertEventStreamError,
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl From<EiConvertEventStreamError> for ReisConvertStreamError {
+    fn from(e: EiConvertEventStreamError) -> Self {
+        Self { inner: e }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum EmulationError {
    #[error("event stream closed")]
    EndOfStream,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei error: `{0}`")]
-    Libei(#[from] reis::Error),
-    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+    #[error("libei error flushing events: `{0}`")]
+    Libei(#[from] reis::event::Error),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("")]
+    LibeiConvertStream(#[from] ReisConvertStreamError),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wayland error: `{0}`")]
    Wayland(#[from] wayland_client::backend::WaylandError),
    #[cfg(all(
        unix,
-        any(feature = "remote_desktop_portal", feature = "libei"),
+        any(feature = "xdg_desktop_portal", feature = "libei"),
        not(target_os = "macos")
    ))]
    #[error("xdg-desktop-portal: `{0}`")]
@@ -45,13 +63,13 @@ pub enum EmulationError {

 #[derive(Debug, Error)]
 pub enum EmulationCreationError {
-    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wlroots backend: `{0}`")]
    Wlroots(#[from] WlrootsEmulationCreationError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei backend: `{0}`")]
    Libei(#[from] LibeiEmulationCreationError),
-    #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    #[error("xdg-desktop-portal: `{0}`")]
    Xdp(#[from] XdpEmulationCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -79,7 +97,7 @@ impl EmulationCreationError {
        ) {
            return true;
        }
-        #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
        if matches!(
            self,
            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
@@ -92,7 +110,7 @@ impl EmulationCreationError {
    }
 }

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum WlrootsEmulationCreationError {
    #[error(transparent)]
@@ -109,7 +127,7 @@ pub enum WlrootsEmulationCreationError {
    Io(#[from] std::io::Error),
 }

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("wayland protocol \"{protocol}\" not supported: {inner}")]
 pub struct WaylandBindError {
@@ -117,7 +135,7 @@ pub struct WaylandBindError {
    protocol: &'static str,
 }

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
        Self { inner, protocol }
@@ -132,10 +150,10 @@ pub enum LibeiEmulationCreationError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
-    Reis(#[from] reis::Error),
+    Handshake(#[from] HandshakeError),
 }

-#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum XdpEmulationCreationError {
    #[error(transparent)]
--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -14,10 +14,10 @@ mod windows;
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 mod x11;

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 mod wlroots;

-#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 mod xdg_desktop_portal;

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
@@ -34,11 +34,11 @@ pub type EmulationHandle = u64;

 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Backend {
-    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    Wlroots,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    Libei,
-    #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    Xdp,
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
@@ -52,11 +52,11 @@ pub enum Backend {
 impl Display for Backend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::Wlroots => write!(f, "wlroots"),
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp => write!(f, "xdg-desktop-portal"),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => write!(f, "X11"),
@@ -78,13 +78,13 @@ pub struct InputEmulation {
 impl InputEmulation {
    async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
        let emulation: Box<dyn Emulation> = match backend {
-            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => Box::new(x11::X11Emulation::new()?),
-            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
            #[cfg(windows)]
            Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
@@ -109,11 +109,11 @@ impl InputEmulation {
        }

        for backend in [
-            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::Wlroots,
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei,
-            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp,
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11,
@@ -217,13 +217,15 @@ impl InputEmulation {
            return false;
        };

-        if state == 0 {
+        let ret = if state == 0 {
            // currently pressed => can release
            pressed_keys.remove(&key)
        } else {
            // currently not pressed => can press
            pressed_keys.insert(key)
-        }
+        };
+        log::info!("client {handle}: pressed keys: {:?}", pressed_keys);
+        ret
    }
 }

--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -1,18 +1,23 @@
 use futures::{future, StreamExt};
+use once_cell::sync::Lazy;
 use std::{
+    collections::HashMap,
    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
    sync::{
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicU32, Ordering},
        Arc, Mutex, RwLock,
    },
    time::{SystemTime, UNIX_EPOCH},
 };
 use tokio::task::JoinHandle;

-use ashpd::desktop::{
-    remote_desktop::{DeviceType, RemoteDesktop},
-    PersistMode, Session,
+use ashpd::{
+    desktop::{
+        remote_desktop::{DeviceType, RemoteDesktop},
+        PersistMode, Session,
+    },
+    WindowIdentifier,
 };
 use async_trait::async_trait;

@@ -21,16 +26,32 @@ use reis::{
        self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
        Pointer, Scroll,
    },
-    event::{self, Connection, DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
-    tokio::EiConvertEventStream,
+    event::{DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
+    tokio::{ei_handshake, EiConvertEventStream, EiEventStream},
 };

 use input_event::{Event, KeyboardEvent, PointerEvent};

-use crate::error::EmulationError;
+use crate::error::{EmulationError, ReisConvertStreamError};

 use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};

+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
 #[derive(Clone, Default)]
 struct Devices {
    pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
@@ -41,11 +62,11 @@ struct Devices {

 pub(crate) struct LibeiEmulation<'a> {
    context: ei::Context,
-    conn: event::Connection,
    devices: Devices,
    ei_task: JoinHandle<()>,
    error: Arc<Mutex<Option<EmulationError>>>,
    libei_error: Arc<AtomicBool>,
+    serial: AtomicU32,
    _remote_desktop: RemoteDesktop<'a>,
    session: Session<'a, RemoteDesktop<'a>>,
 }
@@ -68,7 +89,10 @@ async fn get_ei_fd<'a>(
        .await?;

    log::info!("requesting permission for input emulation");
-    let _devices = remote_desktop.start(&session, None).await?.response()?;
+    let _devices = remote_desktop
+        .start(&session, &WindowIdentifier::default())
+        .await?
+        .response()?;

    let fd = remote_desktop.connect_to_eis(&session).await?;
    Ok((remote_desktop, session, fd))
@@ -80,15 +104,20 @@ impl<'a> LibeiEmulation<'a> {
        let stream = UnixStream::from(eifd);
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
-        let (conn, events) = context
-            .handshake_tokio("de.feschber.LanMouse", ContextType::Sender)
-            .await?;
+        let mut events = EiEventStream::new(context.clone())?;
+        let handshake = ei_handshake(
+            &mut events,
+            "de.feschber.LanMouse",
+            ContextType::Sender,
+            &INTERFACES,
+        )
+        .await?;
+        let events = EiConvertEventStream::new(events, handshake.serial);
        let devices = Devices::default();
        let libei_error = Arc::new(AtomicBool::default());
        let error = Arc::new(Mutex::new(None));
        let ei_handler = ei_task(
            events,
-            conn.clone(),
            context.clone(),
            devices.clone(),
            libei_error.clone(),
@@ -96,13 +125,15 @@ impl<'a> LibeiEmulation<'a> {
        );
        let ei_task = tokio::task::spawn_local(ei_handler);

+        let serial = AtomicU32::new(handshake.serial);
+
        Ok(Self {
            context,
-            conn,
            devices,
            ei_task,
            error,
            libei_error,
+            serial,
            _remote_desktop,
            session,
        })
@@ -138,7 +169,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                    let pointer_device = self.devices.pointer.read().unwrap();
                    if let Some((d, p)) = pointer_device.as_ref() {
                        p.motion_relative(dx as f32, dy as f32);
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                PointerEvent::Button {
@@ -155,7 +186,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                                _ => ButtonState::Press,
                            },
                        );
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                PointerEvent::Axis {
@@ -169,7 +200,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                            0 => s.scroll(0., value as f32),
                            _ => s.scroll(value as f32, 0.),
                        }
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -179,7 +210,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                            0 => s.scroll_discrete(0, value),
                            _ => s.scroll_discrete(value, 0),
                        }
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
            },
@@ -198,7 +229,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                                _ => KeyState::Press,
                            },
                        );
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                KeyboardEvent::Modifiers { .. } => {}
@@ -221,7 +252,6 @@ impl<'a> Emulation for LibeiEmulation<'a> {

 async fn ei_task(
    mut events: EiConvertEventStream,
-    _conn: Connection,
    context: ei::Context,
    devices: Devices,
    libei_error: Arc<AtomicBool>,
@@ -246,7 +276,11 @@ async fn ei_event_handler(
    devices: &Devices,
 ) -> Result<(), EmulationError> {
    loop {
-        let event = events.next().await.ok_or(EmulationError::EndOfStream)??;
+        let event = events
+            .next()
+            .await
+            .ok_or(EmulationError::EndOfStream)?
+            .map_err(ReisConvertStreamError::from)?;
        const CAPABILITIES: &[DeviceCapability] = &[
            DeviceCapability::Pointer,
            DeviceCapability::PointerAbsolute,
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -1,23 +1,18 @@
 use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
-use bitflags::bitflags;
 use core_graphics::base::CGFloat;
 use core_graphics::display::{
    CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
 };
 use core_graphics::event::{
-    CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField,
-    ScrollEventUnit,
+    CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
-use std::cell::Cell;
 use std::ops::{Index, IndexMut};
-use std::rc::Rc;
-use std::sync::Arc;
 use std::time::Duration;
-use tokio::{sync::Notify, task::JoinHandle};
+use tokio::task::AbortHandle;

 use super::error::MacOSEmulationCreationError;

@@ -26,10 +21,8 @@ const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

 pub(crate) struct MacOSEmulation {
    event_source: CGEventSource,
-    repeat_task: Option<JoinHandle<()>>,
+    repeat_task: Option<AbortHandle>,
    button_state: ButtonState,
-    modifier_state: Rc<Cell<XMods>>,
-    notify_repeat_task: Arc<Notify>,
 }

 struct ButtonState {
@@ -75,8 +68,6 @@ impl MacOSEmulation {
            event_source,
            button_state,
            repeat_task: None,
-            notify_repeat_task: Arc::new(Notify::new()),
-            modifier_state: Rc::new(Cell::new(XMods::empty())),
        })
    }

@@ -88,40 +79,25 @@ impl MacOSEmulation {
    async fn spawn_repeat_task(&mut self, key: u16) {
        // there can only be one repeating key and it's
        // always the last to be pressed
-        self.cancel_repeat_task().await;
+        self.kill_repeat_task();
        let event_source = self.event_source.clone();
-        let notify = self.notify_repeat_task.clone();
-        let modifiers = self.modifier_state.clone();
        let repeat_task = tokio::task::spawn_local(async move {
-            let stop = tokio::select! {
-                _ = tokio::time::sleep(DEFAULT_REPEAT_DELAY) => false,
-                _ = notify.notified() => true,
-            };
-            if !stop {
-                loop {
-                    key_event(event_source.clone(), key, 1, modifiers.get());
-                    tokio::select! {
-                        _ = tokio::time::sleep(DEFAULT_REPEAT_INTERVAL) => {},
-                        _ = notify.notified() => break,
-                    }
-                }
+            tokio::time::sleep(DEFAULT_REPEAT_DELAY).await;
+            loop {
+                key_event(event_source.clone(), key, 1);
+                tokio::time::sleep(DEFAULT_REPEAT_INTERVAL).await;
            }
-            // release key when cancelled
-            update_modifiers(&modifiers, key as u32, 0);
-            key_event(event_source.clone(), key, 0, modifiers.get());
        });
-        self.repeat_task = Some(repeat_task);
+        self.repeat_task = Some(repeat_task.abort_handle());
    }
-
-    async fn cancel_repeat_task(&mut self) {
+    fn kill_repeat_task(&mut self) {
        if let Some(task) = self.repeat_task.take() {
-            self.notify_repeat_task.notify_waiters();
-            let _ = task.await;
+            task.abort();
        }
    }
 }

-fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods) {
+fn key_event(event_source: CGEventSource, key: u16, state: u8) {
    let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
        Ok(e) => e,
        Err(_) => {
@@ -129,21 +105,7 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods)
            return;
        }
    };
-    event.set_flags(to_cgevent_flags(modifiers));
    event.post(CGEventTapLocation::HID);
-    log::trace!("key event: {key} {state}");
-}
-
-fn modifier_event(event_source: CGEventSource, depressed: XMods) {
-    let Ok(event) = CGEvent::new(event_source) else {
-        log::warn!("could not create CGEvent");
-        return;
-    };
-    let flags = to_cgevent_flags(depressed);
-    event.set_type(CGEventType::FlagsChanged);
-    event.set_flags(flags);
-    event.post(CGEventTapLocation::HID);
-    log::trace!("modifiers updated: {depressed:?}");
 }

 fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
@@ -384,25 +346,11 @@ impl Emulation for MacOSEmulation {
                    match state {
                        // pressed
                        1 => self.spawn_repeat_task(code).await,
-                        _ => self.cancel_repeat_task().await,
+                        _ => self.kill_repeat_task(),
                    }
-                    update_modifiers(&self.modifier_state, key, state);
-                    key_event(
-                        self.event_source.clone(),
-                        code,
-                        state,
-                        self.modifier_state.get(),
-                    );
-                }
-                KeyboardEvent::Modifiers {
-                    depressed,
-                    latched,
-                    locked,
-                    group,
-                } => {
-                    set_modifiers(&self.modifier_state, depressed, latched, locked, group);
-                    modifier_event(self.event_source.clone(), self.modifier_state.get());
+                    key_event(self.event_source.clone(), code, state)
                }
+                KeyboardEvent::Modifiers { .. } => {}
            },
        }
        // FIXME
@@ -415,81 +363,3 @@ impl Emulation for MacOSEmulation {

    async fn terminate(&mut self) {}
 }
-
-fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
-    if let Ok(key) = scancode::Linux::try_from(key) {
-        let mask = match key {
-            scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
-            scancode::Linux::KeyCapsLock => XMods::LockMask,
-            scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
-            scancode::Linux::KeyLeftAlt | scancode::Linux::KeyRightalt => XMods::Mod1Mask,
-            scancode::Linux::KeyLeftMeta | scancode::Linux::KeyRightmeta => XMods::Mod4Mask,
-            _ => XMods::empty(),
-        };
-        // unchanged
-        if mask.is_empty() {
-            return false;
-        }
-        let mut mods = modifiers.get();
-        match state {
-            1 => mods.insert(mask),
-            _ => mods.remove(mask),
-        }
-        modifiers.set(mods);
-        true
-    } else {
-        false
-    }
-}
-
-fn set_modifiers(
-    active_modifiers: &Cell<XMods>,
-    depressed: u32,
-    latched: u32,
-    locked: u32,
-    group: u32,
-) {
-    let depressed = XMods::from_bits(depressed).unwrap_or_default();
-    let _latched = XMods::from_bits(latched).unwrap_or_default();
-    let _locked = XMods::from_bits(locked).unwrap_or_default();
-    let _group = XMods::from_bits(group).unwrap_or_default();
-
-    // we only care about the depressed modifiers for now
-    active_modifiers.replace(depressed);
-}
-
-fn to_cgevent_flags(depressed: XMods) -> CGEventFlags {
-    let mut flags = CGEventFlags::empty();
-    if depressed.contains(XMods::ShiftMask) {
-        flags |= CGEventFlags::CGEventFlagShift;
-    }
-    if depressed.contains(XMods::LockMask) {
-        flags |= CGEventFlags::CGEventFlagAlphaShift;
-    }
-    if depressed.contains(XMods::ControlMask) {
-        flags |= CGEventFlags::CGEventFlagControl;
-    }
-    if depressed.contains(XMods::Mod1Mask) {
-        flags |= CGEventFlags::CGEventFlagAlternate;
-    }
-    if depressed.contains(XMods::Mod4Mask) {
-        flags |= CGEventFlags::CGEventFlagCommand;
-    }
-    flags
-}
-
-// From X11/X.h
-bitflags! {
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-    struct XMods: u32 {
-        const ShiftMask = (1<<0);
-        const LockMask = (1<<1);
-        const ControlMask = (1<<2);
-        const Mod1Mask = (1<<3);
-        const Mod2Mask = (1<<4);
-        const Mod3Mask = (1<<5);
-        const Mod4Mask = (1<<6);
-        const Mod5Mask = (1<<7);
-    }
-}
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -4,6 +4,7 @@ use ashpd::{
        PersistMode, Session,
    },
    zbus::AsyncDrop,
+    WindowIdentifier,
 };
 use async_trait::async_trait;

@@ -42,7 +43,10 @@ impl<'a> DesktopPortalEmulation<'a> {
            .await?;

        log::info!("requesting permission for input emulation");
-        let _devices = proxy.start(&session, None).await?.response()?;
+        let _devices = proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()?;

        log::debug!("started session");
        let session = session;
--- a/input-event/Cargo.toml
+++ b/input-event/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.3.0"
+version = "0.2.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -11,10 +11,10 @@ futures-core = "0.3.30"
 log = "0.4.22"
 num_enum = "0.7.2"
 serde = { version = "1.0", features = ["derive"] }
-thiserror = "2.0.0"
+thiserror = "1.0.61"

 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.4", optional = true }
+reis = { version = "0.2.0", optional = true }

 [features]
 default = ["libei"]
--- a/lan-mouse-cli/Cargo.toml
+++ b/lan-mouse-cli/Cargo.toml
@@ -1,14 +1,14 @@
 [package]
 name = "lan-mouse-cli"
 description = "CLI Frontend for lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"

 [dependencies]
 futures = "0.3.30"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
--- a/lan-mouse-gtk/Cargo.toml
+++ b/lan-mouse-gtk/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse-gtk"
 description = "GTK4 / Libadwaita Frontend for lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -12,7 +12,7 @@ adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
 async-channel = { version = "2.1.1" }
 hostname = "0.4.0"
 log = "0.4.20"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }

 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }
--- a/lan-mouse-ipc/Cargo.toml
+++ b/lan-mouse-ipc/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse-ipc"
 description = "library for communication between lan-mouse service and frontends"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -11,6 +11,6 @@ futures = "0.3.30"
 log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
-thiserror = "2.0.0"
+thiserror = "1.0.63"
 tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
 tokio-stream = { version = "0.1.15", features = ["io-util"] }
--- a/lan-mouse-proto/Cargo.toml
+++ b/lan-mouse-proto/Cargo.toml
@@ -1,13 +1,13 @@
 [package]
 name = "lan-mouse-proto"
 description = "network protocol for lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"

 [dependencies]
 num_enum = "0.7.2"
-thiserror = "2.0.0"
-input-event = { path = "../input-event", version = "0.3.0" }
+thiserror = "1.0.61"
+input-event = { path = "../input-event", version = "0.2.1" }
 paste = "1.0"
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -44,9 +44,6 @@ rustPlatform.buildRustPackage {
  postInstall = ''
    wrapProgram "$out/bin/lan-mouse" \
      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
-
-    install -Dm444 *.desktop -t $out/share/applications
-    install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
  '';

  meta = with lib; {
--- a/screenshots/dark.png
+++ b/screenshots/dark.png
--- a/screenshots/light.png
+++ b/screenshots/light.png
--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -11,7 +11,6 @@ pub async fn run(config: Config) -> Result<(), InputCaptureError> {
        let mut input_capture = InputCapture::new(backend).await?;
        log::info!("creating clients");
        input_capture.create(0, Position::Left).await?;
-        input_capture.create(4, Position::Left).await?;
        input_capture.create(1, Position::Right).await?;
        input_capture.create(2, Position::Top).await?;
        input_capture.create(3, Position::Bottom).await?;
@@ -29,13 +28,12 @@ async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError
            .await
            .ok_or(CaptureError::EndOfStream)??;
        let pos = match client {
-            0 | 4 => Position::Left,
+            0 => Position::Left,
            1 => Position::Right,
            2 => Position::Top,
-            3 => Position::Bottom,
-            _ => panic!(),
+            _ => Position::Bottom,
        };
-        log::info!("position: {client} ({pos}), event: {event}");
+        log::info!("position: {pos}, event: {event}");
        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key: 1, .. })) = event {
            input_capture.release().await?;
            break Ok(());
--- a/src/config.rs
+++ b/src/config.rs
@@ -85,33 +85,27 @@ struct CliArgs {

 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum CaptureBackend {
-    #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
-    #[serde(rename = "input-capture-portal")]
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    InputCapturePortal,
-    #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
-    #[serde(rename = "layer-shell")]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    LayerShell,
-    #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
-    #[serde(rename = "x11")]
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
    #[cfg(windows)]
-    #[serde(rename = "windows")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[serde(rename = "macos")]
    MacOs,
-    #[serde(rename = "dummy")]
    Dummy,
 }

 impl Display for CaptureBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
-            #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            CaptureBackend::LayerShell => write!(f, "layer-shell"),
-            #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            CaptureBackend::X11 => write!(f, "X11"),
            #[cfg(windows)]
            CaptureBackend::Windows => write!(f, "windows"),
@@ -125,11 +119,11 @@ impl Display for CaptureBackend {
 impl From<CaptureBackend> for input_capture::Backend {
    fn from(backend: CaptureBackend) -> Self {
        match backend {
-            #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            CaptureBackend::InputCapturePortal => Self::InputCapturePortal,
-            #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            CaptureBackend::LayerShell => Self::LayerShell,
-            #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            CaptureBackend::X11 => Self::X11,
            #[cfg(windows)]
            CaptureBackend::Windows => Self::Windows,
@@ -142,38 +136,31 @@ impl From<CaptureBackend> for input_capture::Backend {

 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum EmulationBackend {
-    #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
-    #[serde(rename = "wlroots")]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    Wlroots,
-    #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
-    #[serde(rename = "libei")]
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    Libei,
-    #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
-    #[serde(rename = "xdp")]
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    Xdp,
-    #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
-    #[serde(rename = "x11")]
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
    #[cfg(windows)]
-    #[serde(rename = "windows")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[serde(rename = "macos")]
    MacOs,
-    #[serde(rename = "dummy")]
    Dummy,
 }

 impl From<EmulationBackend> for input_emulation::Backend {
    fn from(backend: EmulationBackend) -> Self {
        match backend {
-            #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            EmulationBackend::Wlroots => Self::Wlroots,
-            #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            EmulationBackend::Libei => Self::Libei,
-            #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            EmulationBackend::Xdp => Self::Xdp,
-            #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            EmulationBackend::X11 => Self::X11,
            #[cfg(windows)]
            EmulationBackend::Windows => Self::Windows,
@@ -187,13 +174,13 @@ impl From<EmulationBackend> for input_emulation::Backend {
 impl Display for EmulationBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            EmulationBackend::Wlroots => write!(f, "wlroots"),
-            #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            EmulationBackend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
-            #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            EmulationBackend::X11 => write!(f, "X11"),
            #[cfg(windows)]
            EmulationBackend::Windows => write!(f, "windows"),
@@ -206,9 +193,7 @@ impl Display for EmulationBackend {

 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
 pub enum Frontend {
-    #[serde(rename = "gtk")]
    Gtk,
-    #[serde(rename = "cli")]
    Cli,
 }