@desklink/host 0.5.6 → 0.5.8

package/docs/PROTOCOL.md

@@ -198,7 +198,9 @@ build has, not what this machine can necessarily use.
 
 `input.unavailable_reason` and `input.grant` describe the portal/uinput path:
 without kernel input access a portal session opens and captures, but input
-messages are refused with `input-unavailable`. X display capture uses XTest
+messages are refused with `input-unavailable`. A Hyprland window share's
+pointer moves are the exception: they warp through Hyprland's own IPC instead
+of any device (see Input and clipboard). X display capture uses XTest
 instead and does not require that grant. The engine probes XTest on that named
 display; if it is unavailable, capture and clipboard still open, and input
 messages are refused with `input-unavailable`. X11 clipboard uses CLIPBOARD on the
@@ -270,7 +272,12 @@ animating in and out, with light and dark keylines so it reads on any content.
 On Wayland it uses a click-through layer-shell surface with an edge glow, drawn
 at the highest announced output integer scale, capped at 4; its bounded area is
 masked before capture/diff (pixels behind the effect can remain briefly stale).
-On bare X11 it is an override-redirect, click-through window that follows the
+On a located Hyprland window share each pointer cue goes to the desktop point
+the pointer landed on — the window's place plus the tapped point (see Input and
+clipboard) — and the window's picture holds no layer surface, so nothing is
+masked; a refused tap draws no cue. Known limit: the cue's surface sits on the
+one output the compositor gave it as the share started, and a tap landing on
+another output draws no cue. On bare X11 it is an override-redirect, click-through window that follows the
 pointer, so it stays
 visible over windows that set their own cursor and never replaces the cursor.
 Its size follows `Xft.dpi` from 96–384 DPI, defaulting to 1x otherwise;
@@ -378,6 +385,12 @@ lease, or guarantee recovery within 2 seconds. Engine-side ends remain terminal.
 //   "description":{"type":"offer","sdp":"v=0\r\n…"}}}
 ```
 
+The engine offers UDP host candidates on every IPv4 interface and, when this
+computer has an IPv6 address other than loopback and link-local, on every such
+IPv6 address too. A phone off home Wi-Fi often has only a carrier IPv6 address,
+and that is its one direct path here. Loopback and link-local addresses are
+never offered.
+
 With `loopback_tcp`, the engine also listens for ICE over TCP on
 `127.0.0.1` and offers that passive candidate. It is for a client whose only
 way to this computer is a forward of its loopback, such as an SSH tunnel: the
@@ -596,7 +609,11 @@ label. A new point replaces the previous one and restarts its timer.
 Coordinates are integers in the **selected desktop's original pixels**, top-left
 origin, before video scaling (`geometry.source`, not `geometry.encoded`). On X11
 this is the root screen; on macOS it is the selected display, with native pixels
-converted to display points. Both coordinates must be within its bounds. The
+converted to display points. On a located Hyprland window share (see Input and
+clipboard) they are the window's own pixels, and the ring shows on the desktop
+point a press there would land, on the output holding it; a point the window
+cannot take there is refused with `indicator-unavailable` and the reason. Both
+coordinates must be within its bounds. The
 ring may clip at an edge; its label stays inside the display. `timeout_ms`
 defaults to 3000 and must be an integer from 1 to 120000. Labels are at most 96
 printable ASCII bytes, including spaces; other labels are refused rather than
@@ -688,6 +705,25 @@ so a tap would land at the same fraction of the desktop instead of on the
 window. Keys, text, wheel, pointer `cancel` and `release_all` are unaffected;
 share the monitor to point and click.
 
+On Hyprland the engine places the pointer itself. Hyprland announces each
+window share by title on its event socket, and the engine takes the one window
+in `j/clients` with that title and the stream's size. That match runs once, at
+the first tap, and the announcement says nothing else about which share it is:
+if the shared window's title changes before that first tap and another window
+of the stream's size now carries the announced title, taps land on the other
+window; and when two window shares are announced at once (another session, or
+any other consumer of the portal), the engine cannot tell which announcement
+is this share's, so every tap refuses with `input-unavailable` for the
+session's lifetime. Each `move`, `down` and
+`up` warps the pointer to the window's current position plus the local point
+(so a window moved after the share started still maps); buttons and keys go
+through the input device as before. A tap is still refused with
+`input-unavailable` when the window cannot be told apart (no announcement,
+no such window, or several that look alike), when it has closed or sits on a
+hidden workspace, when another window covers the tapped point or a layer
+surface sits over it, or when the window hangs off screen. Other compositors
+keep the refusal above.
+
 The engine holds its own pressed-key/button state. `close`, `release_all`,
 control-channel loss and process exit all synthesize releases for exactly the
 keys and buttons this session pressed, so a dropped connection cannot leave a

package/engine/Cargo.lock

@@ -536,7 +536,7 @@ checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 
 [[package]]
 name = "desklink-host"
-version = "0.5.6"
+version = "0.5.8"
 dependencies = [
  "anyhow",
  "ashpd",

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.6"
+version = "0.5.8"
 edition = "2021"
 rust-version = "1.97.1"
 license = "Apache-2.0"

package/engine/native/agent_overlay_wayland.c

@@ -97,7 +97,26 @@ struct Overlay {
     struct wl_surface *surface;
     struct Buffer buffers[2];
     int width, height, scale, source_w, source_h, configured, closed;
+    // Desktop mode: points are compositor layout coordinates, drawn only on
+    // the output this surface is on (`mine`), never scaled onto another.
+    int desktop; struct Output *mine;
 };
+static int locate(struct Overlay *o, double px, double py, double *x, double *y) {
+    if(!o->desktop)return desklink_wayland_geometry(o->source_w,o->source_h,o->width,o->height,px,py,x,y);
+    struct Output *m=o->mine;
+    if(!m||!m->valid||px<m->x||py<m->y||px>=m->x+m->w||py>=m->y+m->h)return 0;
+    *x=px-m->x;*y=py-m->y;
+    return 1;
+}
+static void surface_enter(void *data, struct wl_surface *surface, struct wl_output *output) {
+    (void)surface;struct Overlay *o=data;
+    for(int i=0;i<o->output_count;i++)if(o->outputs[i].handle==output)o->mine=&o->outputs[i];
+}
+static void surface_leave(void *data, struct wl_surface *surface, struct wl_output *output) {
+    (void)surface;struct Overlay *o=data;
+    if(o->mine&&o->mine->handle==output)o->mine=NULL;
+}
+static const struct wl_surface_listener surface_listener={.enter=surface_enter,.leave=surface_leave};
 static double now(void) { struct timespec t; clock_gettime(CLOCK_MONOTONIC,&t); return t.tv_sec+t.tv_nsec/1e9; }
 static void registry_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
     struct Overlay *o=data;
@@ -214,9 +233,9 @@ static void draw_point(struct Overlay *o,struct Buffer *b,double x,double y,cons
     }
 }
 
-static int overlay_main(int source_w,int source_h,int point_mode,int origin_known,int origin_x,int origin_y) {
+static int overlay_main(int source_w,int source_h,int point_mode,int origin_known,int origin_x,int origin_y,int desktop) {
 
-    struct Overlay o={.source_w=source_w,.source_h=source_h,.scale=1};
+    struct Overlay o={.source_w=source_w,.source_h=source_h,.scale=1,.desktop=desktop};
     o.display=wl_display_connect(NULL);
     if(!o.display)return 2;
     struct wl_registry *registry=wl_display_get_registry(o.display);
@@ -225,18 +244,18 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
     if(!o.shell){puts("layer_shell_unavailable");fflush(stdout);wl_display_disconnect(o.display);return 2;}
     if(!o.compositor||!o.shm){wl_display_disconnect(o.display);return 2;}
     struct wl_output *selected=NULL;int matches=0;
-    if(point_mode) {
-        if(o.output_manager) {
-            for(int i=0;i<o.output_count;i++) {
-                struct Output *out=&o.outputs[i];
-                out->logical=wl_proxy_marshal_flags(o.output_manager,1,&xdg_output_interface,wl_proxy_get_version(o.output_manager),0,NULL,out->handle);
-                wl_proxy_add_listener(out->logical,logical_listener,out);
-            }
-            if(wl_display_roundtrip(o.display)<0)return 2;
+    if((point_mode||desktop) && o.output_manager) {
+        for(int i=0;i<o.output_count;i++) {
+            struct Output *out=&o.outputs[i];
+            out->logical=wl_proxy_marshal_flags(o.output_manager,1,&xdg_output_interface,wl_proxy_get_version(o.output_manager),0,NULL,out->handle);
+            wl_proxy_add_listener(out->logical,logical_listener,out);
         }
+        if(wl_display_roundtrip(o.display)<0)return 2;
+    }
+    if(point_mode) {
         for(int i=0;i<o.output_count;i++) {
             struct Output *out=&o.outputs[i];
-            if(origin_known && out->valid && origin_x>=out->x && origin_y>=out->y && origin_x<out->x+out->w && origin_y<out->y+out->h){selected=out->handle;matches++;}
+            if(origin_known && out->valid && origin_x>=out->x && origin_y>=out->y && origin_x<out->x+out->w && origin_y<out->y+out->h){selected=out->handle;o.mine=out;matches++;}
         }
         if(matches>1)selected=NULL;
         if(!selected && o.output_count==1 && (!origin_known || !o.output_manager))selected=o.outputs[0].handle;
@@ -250,6 +269,8 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
     FT_Library library=NULL;FT_Face font=point_mode?point_font(&library):NULL;
     if(point_mode&&!font){wl_display_disconnect(o.display);return 2;}
     o.surface=wl_compositor_create_surface(o.compositor);
+    // An agent cue's surface lands where the compositor puts it; it learns which output that is.
+    if(desktop && !point_mode)wl_surface_add_listener(o.surface,&surface_listener,&o);
     o.layer=wl_proxy_marshal_flags(o.shell,0,&layer_surface_interface,1,0,NULL,o.surface,selected,3,point_mode?"desklink-point":"desklink-agent");
     wl_proxy_add_listener(o.layer,layer_listener,&o);
     uint32_t anchor,keyboard_focus,empty_input;
@@ -289,19 +310,23 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
                     if(point_mode && kind=='P') {
                         unsigned timeout=0;int offset=0;
                         if(sscanf(pending,"P %lf %lf %u %n",&px,&py,&timeout,&offset)==3 && offset && timeout>=1 && timeout<=120000 && strlen(pending+offset)<=96) {
-                            desklink_wayland_geometry(o.source_w,o.source_h,o.width,o.height,px,py,&x,&y);
-                            snprintf(label,sizeof(label),"%s",pending+offset);deadline=now()+timeout/1000.0;active=1;dirty=1;visible=1;
+                            snprintf(label,sizeof(label),"%s",pending+offset);deadline=now()+timeout/1000.0;active=1;dirty=1;
+                            visible=locate(&o,px,py,&x,&y);
                         }
                     }
                     else if(kind=='S')ending=now();
                     else if(kind=='M'||kind=='C'||kind=='T'||kind=='A') {
+                        int placed=1;
                         if(px>=0&&py>=0) {
-                            if(desklink_wayland_geometry(o.source_w,o.source_h,o.width,o.height,px,py,&tx,&ty)
-                                && !positioned){x=tx;y=ty;positioned=1;cue_started=now();}
+                            placed=locate(&o,px,py,&tx,&ty);
+                            if(placed && !positioned){x=tx;y=ty;positioned=1;cue_started=now();}
+                            // A desktop point off this output has no place here:
+                            // the cue hides rather than show anywhere else.
+                            if(!placed && o.desktop){positioned=0;cue_started=0;}
                         }
                         if(!active)started=now();
                         active=1;
-                        if(kind=='C')click=now();
+                        if(kind=='C' && (placed||!o.desktop))click=now();
                         if(kind=='T')typed=now();
                     }
                 }
@@ -331,8 +356,8 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
     return 0;
 }
 
-int desklink_agent_overlay_wayland(int w,int h){return overlay_main(w,h,0,0,0,0);}
-int desklink_point_overlay_wayland(int w,int h,int known,int x,int y){return overlay_main(w,h,1,known,x,y);}
+int desklink_agent_overlay_wayland(int w,int h,int desktop){return overlay_main(w,h,0,0,0,0,desktop);}
+int desklink_point_overlay_wayland(int w,int h,int known,int x,int y,int desktop){return overlay_main(w,h,1,known,x,y,desktop);}
 
 // Read-only capability probe for idempotent clear before a helper exists.
 int desklink_wayland_layer_shell_available(void) {

package/engine/src/capture.rs

@@ -303,7 +303,6 @@ fn run_loop(
         *pw::keys::MEDIA_CATEGORY => "Capture",
         *pw::keys::MEDIA_ROLE => "Screen",
     };
-    props.insert(*pw::keys::TARGET_OBJECT, node_id.to_string());
     let stream = pw::stream::StreamBox::new(&core, "desklink-capture", props)
         .context("pw_stream_new failed")?;
 

package/engine/src/hyprland.rs

@@ -0,0 +1,329 @@
+//! Where a shared window sits on a Hyprland desktop, from Hyprland's own IPC.
+//!
+//! Hyprland's ScreenCast portal reports every stream at (0, 0) and never says
+//! which window was picked, while the pointer device spans the whole desktop.
+//! Hyprland itself announces each window share by title on its event socket
+//! (`screencastv2>>1,window,<title>`) and lists every window's place in
+//! `j/clients`. So the shared window is the one with that title and the
+//! stream's size, followed by its address from then on, and the pointer goes
+//! onto it through Hyprland's own cursor warp at the window's current place:
+//! a window moved after the share started still maps. Anything less certain
+//! (no announcement, no such window, two alike, a window off screen) is a
+//! refusal, never a guess.
+
+use serde_json::Value;
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::Shutdown;
+use std::os::unix::net::UnixStream;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex, MutexGuard};
+
+use crate::session::WINDOW_POINTER_REFUSAL as UNKNOWN;
+
+fn instance() -> Option<PathBuf> {
+    let signature = std::env::var_os("HYPRLAND_INSTANCE_SIGNATURE")?;
+    let runtime = std::env::var_os("XDG_RUNTIME_DIR")?;
+    Some(PathBuf::from(runtime).join("hypr").join(signature))
+}
+
+fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
+    mutex
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+/// Hyprland's window-share announcements, heard from before the portal asks
+/// for consent. Dropping it closes the event socket, which ends its reader.
+pub struct ShareWatch {
+    socket: UnixStream,
+    titles: Arc<Mutex<Vec<String>>>,
+}
+
+impl ShareWatch {
+    /// `None` when this is not a Hyprland session.
+    pub fn start() -> Option<Self> {
+        let socket = UnixStream::connect(instance()?.join(".socket2.sock")).ok()?;
+        let reader = socket.try_clone().ok()?;
+        let titles = Arc::new(Mutex::new(Vec::new()));
+        let heard = titles.clone();
+        std::thread::spawn(move || {
+            for line in BufReader::new(reader).lines().map_while(Result::ok) {
+                if let Some(title) = line.strip_prefix("screencastv2>>1,window,") {
+                    lock(&heard).push(title.to_owned());
+                }
+            }
+        });
+        Some(Self { socket, titles })
+    }
+}
+
+impl Drop for ShareWatch {
+    fn drop(&mut self) {
+        let _ = self.socket.shutdown(Shutdown::Both);
+    }
+}
+
+/// The window a portal window share shows, placed by Hyprland.
+pub struct WindowLocator {
+    watch: ShareWatch,
+    /// The stream's own pixel size, which the window's size times its
+    /// monitor's scale must match.
+    source: (i64, i64),
+    address: Mutex<Option<String>>,
+    /// Whether this Hyprland reads a Lua config, whose `dispatch` takes Lua.
+    lua: Mutex<Option<bool>>,
+}
+
+impl WindowLocator {
+    pub fn new(watch: ShareWatch, width: i32, height: i32) -> Self {
+        Self {
+            watch,
+            source: (i64::from(width.max(1)), i64::from(height.max(1))),
+            address: Mutex::new(None),
+            lua: Mutex::new(None),
+        }
+    }
+
+    /// Put the pointer on `(x, y)` in the shared window's own pixels, and say
+    /// which desktop point that was.
+    pub fn place(&self, x: i64, y: i64) -> Result<(i64, i64), String> {
+        let (px, py) = self.locate(x, y)?;
+        let point = (px.floor() as i64, py.floor() as i64);
+        self.warp(point)?;
+        Ok(point)
+    }
+
+    /// The desktop point `(x, y)` in the shared window's own pixels shows
+    /// at, when a press there would reach the window.
+    pub fn locate(&self, x: i64, y: i64) -> Result<(f64, f64), String> {
+        let (clients, monitors) = (query("j/clients")?, query("j/monitors")?);
+        let clients = clients.as_array().map(Vec::as_slice).unwrap_or_default();
+        // A window nobody sees has no point on the screen.
+        let shown = |window: &Value| {
+            let workspace = &window["workspace"]["id"];
+            window["mapped"].as_bool() != Some(false)
+                && window["hidden"].as_bool() != Some(true)
+                && (window["pinned"].as_bool() == Some(true)
+                    || monitors.as_array().into_iter().flatten().any(|monitor| {
+                        &monitor["activeWorkspace"]["id"] == workspace
+                            || &monitor["specialWorkspace"]["id"] == workspace
+                    }))
+        };
+        let mut address = lock(&self.address);
+        if address.is_none() {
+            *address = Some(self.identify(clients, &monitors)?);
+        }
+        let index = clients
+            .iter()
+            .position(|client| client["address"].as_str() == address.as_deref())
+            .ok_or("a shared window cannot take taps: the window has closed")?;
+        let window = &clients[index];
+        if !shown(window) {
+            return Err(String::from(
+                "a shared window cannot take taps while it is on a hidden workspace",
+            ));
+        }
+        let (left, top, width, height) = bounds(window).ok_or(UNKNOWN)?;
+        let (source_w, source_h) = self.source;
+        let (px, py) = (
+            left + x as f64 * width / source_w as f64,
+            top + y as f64 * height / source_h as f64,
+        );
+        // Hyprland clamps the cursor to the screen edge, so a point off every
+        // monitor would press something else or nothing.
+        let on_screen = monitors.as_array().into_iter().flatten().any(|monitor| {
+            let scale = monitor["scale"].as_f64().filter(|scale| *scale > 0.0);
+            monitor["disabled"].as_bool() != Some(true)
+                && matches!(
+                    (
+                        monitor["x"].as_f64(),
+                        monitor["y"].as_f64(),
+                        monitor["width"].as_f64(),
+                        monitor["height"].as_f64(),
+                        scale
+                    ),
+                    (Some(mx), Some(my), Some(mw), Some(mh), Some(scale))
+                        if (mx..mx + mw / scale).contains(&px)
+                            && (my..my + mh / scale).contains(&py)
+                )
+        });
+        if !on_screen {
+            return Err(String::from(
+                "a shared window cannot take taps where it hangs off screen",
+            ));
+        }
+        // Hyprland draws tiled windows, then floating ones, then fullscreen
+        // ones, and pinned ones above all; j/clients lists them in the
+        // compositor's own stacking order, so a later layer-mate holding the
+        // point is what a press there would reach. A floating window let over
+        // fullscreen draws above it, but j/clients cannot tell that one from
+        // any floating window, so either pairing over the point is a refusal.
+        let layer = |w: &Value| {
+            if w["pinned"].as_bool() == Some(true) {
+                3
+            } else if w["fullscreen"].as_i64().is_some_and(|mode| mode > 0) {
+                2
+            } else {
+                u8::from(w["floating"].as_bool() == Some(true))
+            }
+        };
+        let covered = clients.iter().enumerate().any(|(i, other)| {
+            shown(other)
+                && bounds(other).is_some_and(|(l, t, w, h)| {
+                    (l..l + w).contains(&px) && (t..t + h).contains(&py)
+                })
+                && match (layer(other), layer(window), i > index) {
+                    (1, 2, _) | (2, 1, _) => true,
+                    (above, own, later) => above > own || (above == own && later),
+                }
+        });
+        if covered {
+            return Err(String::from(
+                "a shared window cannot take taps where another window covers it",
+            ));
+        }
+        // Bars, notifications and other layer surfaces draw above windows and
+        // are absent from the window-only video: a top or overlay one holding
+        // the point is what a press there would reach. Their boxes come local
+        // to their monitor, which j/monitors places.
+        let anchored = |name: &str| -> Option<(f64, f64)> {
+            for monitor in monitors.as_array().into_iter().flatten() {
+                if monitor["name"].as_str() == Some(name) {
+                    return Some((monitor["x"].as_f64()?, monitor["y"].as_f64()?));
+                }
+            }
+            None
+        };
+        let overlaid = query("j/layers")?
+            .as_object()
+            .into_iter()
+            .flatten()
+            .map(|(name, monitor)| Some((anchored(name)?, monitor)))
+            .collect::<Option<Vec<((f64, f64), &Value)>>>()
+            .ok_or(String::from(
+                "a shared window cannot take taps: a screen's layers are unknown",
+            ))?
+            .into_iter()
+            .any(|((mx, my), monitor)| {
+                monitor["levels"]
+                    .as_object()
+                    .into_iter()
+                    .flatten()
+                    .any(|(level, surfaces)| {
+                        let level = level.parse::<u8>().unwrap_or(0);
+                        (level >= 2)
+                            && surfaces.as_array().into_iter().flatten().any(|surface| {
+                                let (sx, sy) = (surface["x"].as_f64(), surface["y"].as_f64());
+                                let (sw, sh) = (surface["w"].as_f64(), surface["h"].as_f64());
+                                !matches!(
+                                    surface["namespace"].as_str(),
+                                    Some("desklink-agent" | "desklink-point")
+                                ) && matches!(
+                                    (sx, sy, sw, sh),
+                                    (Some(sx), Some(sy), Some(sw), Some(sh))
+                                        if (mx + sx..mx + sx + sw).contains(&px)
+                                            && (my + sy..my + sy + sh).contains(&py)
+                                )
+                            })
+                    })
+            });
+        if overlaid {
+            return Err(String::from(
+                "a shared window cannot take taps where an overlay covers it",
+            ));
+        }
+        Ok((px, py))
+    }
+
+    /// The address of the one window Hyprland said it is sharing.
+    fn identify(&self, clients: &[Value], monitors: &Value) -> Result<String, String> {
+        let mut titles = lock(&self.watch.titles).clone();
+        titles.dedup();
+        let [title] = titles.as_slice() else {
+            return Err(String::from(UNKNOWN));
+        };
+        let (source_w, source_h) = self.source;
+        let scale = |monitor: &Value| {
+            monitors
+                .as_array()
+                .into_iter()
+                .flatten()
+                .find(|m| &m["id"] == monitor)
+                .and_then(|m| m["scale"].as_f64())
+        };
+        let alike: Vec<&Value> = clients
+            .iter()
+            .filter(|client| {
+                let size = |i: usize| client["size"][i].as_f64();
+                client["title"].as_str() == Some(title.as_str())
+                    && client["mapped"].as_bool() != Some(false)
+                    && client["hidden"].as_bool() != Some(true)
+                    && matches!(
+                        (size(0), size(1), scale(&client["monitor"])),
+                        (Some(w), Some(h), Some(s))
+                            if ((w * s).round() as i64 - source_w).abs() <= 1
+                                && ((h * s).round() as i64 - source_h).abs() <= 1
+                    )
+            })
+            .collect();
+        match alike.as_slice() {
+            [window] => window["address"]
+                .as_str()
+                .map(str::to_owned)
+                .ok_or_else(|| String::from(UNKNOWN)),
+            [] => Err(String::from(UNKNOWN)),
+            _ => Err(format!(
+                "a shared window cannot take taps: {} windows look like it; share the whole screen to point and click",
+                alike.len()
+            )),
+        }
+    }
+
+    fn warp(&self, (x, y): (i64, i64)) -> Result<(), String> {
+        let legacy = format!("dispatch movecursor {x} {y}");
+        let lua = format!("dispatch hl.dsp.cursor.move({{ x = {x}, y = {y} }})");
+        let mut dialect = lock(&self.lua);
+        let tries: &[(bool, &str)] = match *dialect {
+            Some(true) => &[(true, &lua)],
+            Some(false) => &[(false, &legacy)],
+            None => &[(false, &legacy), (true, &lua)],
+        };
+        let mut said = String::new();
+        for (is_lua, command) in tries {
+            said = request(command)?;
+            if said.trim() == "ok" {
+                *dialect = Some(*is_lua);
+                return Ok(());
+            }
+        }
+        Err(format!(
+            "Hyprland did not move the pointer: {}",
+            said.trim()
+        ))
+    }
+}
+
+/// A window's box in the layout: left, top, width, height.
+fn bounds(window: &Value) -> Option<(f64, f64, f64, f64)> {
+    let pair = |key: &str| Some((window[key][0].as_f64()?, window[key][1].as_f64()?));
+    let ((left, top), (width, height)) = pair("at").zip(pair("size"))?;
+    Some((left, top, width, height))
+}
+
+fn request(command: &str) -> Result<String, String> {
+    let ask = || -> std::io::Result<String> {
+        let path = instance()
+            .ok_or_else(|| std::io::Error::other("HYPRLAND_INSTANCE_SIGNATURE is not set"))?;
+        let mut socket = UnixStream::connect(path.join(".socket.sock"))?;
+        socket.write_all(command.as_bytes())?;
+        let mut reply = String::new();
+        socket.read_to_string(&mut reply)?;
+        Ok(reply)
+    };
+    ask().map_err(|error| format!("Hyprland's control socket did not answer: {error}"))
+}
+
+fn query(command: &str) -> Result<Value, String> {
+    serde_json::from_str(&request(command)?)
+        .map_err(|error| format!("Hyprland's {command} was not JSON: {error}"))
+}

package/engine/src/indicator.rs

@@ -157,11 +157,14 @@ impl Indicator {
         )
     }
 
+    /// `desktop`: points are compositor layout coordinates, drawn on the
+    /// output that holds `position`.
     #[cfg(target_os = "linux")]
     pub fn start_point_wayland(
         width: i32,
         height: i32,
         position: Option<(i32, i32)>,
+        desktop: bool,
     ) -> Result<Self> {
         let (x, y) = position.unwrap_or_default();
         Self::spawn(
@@ -173,6 +176,7 @@ impl Indicator {
                     i32::from(position.is_some()).to_string(),
                     x.to_string(),
                     y.to_string(),
+                    i32::from(desktop).to_string(),
                 ]),
             1.0,
             1.0,
@@ -217,14 +221,17 @@ impl Indicator {
         }
     }
 
+    /// `desktop`: cues are compositor layout coordinates, drawn only where
+    /// they fall on the output the overlay opened on.
     #[cfg(target_os = "linux")]
-    pub fn start_wayland(width: usize, height: usize) -> Result<Self> {
+    pub fn start_wayland(width: usize, height: usize, desktop: bool) -> Result<Self> {
         let executable = std::env::current_exe()?;
         Self::spawn(
             Command::new(executable)
                 .arg("agent-overlay-wayland")
                 .arg(width.to_string())
-                .arg(height.to_string()),
+                .arg(height.to_string())
+                .args(desktop.then_some("desktop")),
             1.0,
             1.0,
         )

package/engine/src/main.rs

@@ -45,6 +45,8 @@ mod h264_openh264;
 mod h264_vaapi;
 #[cfg(all(target_os = "macos", desklink_vpx))]
 mod h264_vt;
+#[cfg(target_os = "linux")]
+mod hyprland;
 #[cfg(any(
     target_os = "linux",
     all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
@@ -134,9 +136,16 @@ use tokio::sync::mpsc as tokio_mpsc;
 unsafe extern "C" {
     fn desklink_point_overlay_main(display: *const std::ffi::c_char) -> i32;
     fn desklink_agent_overlay_main(display: *const std::ffi::c_char) -> i32;
-    fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32) -> i32;
+    fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32, desktop: i32) -> i32;
     fn desklink_wayland_layer_shell_available() -> i32;
-    fn desklink_point_overlay_wayland(w: i32, h: i32, known: i32, x: i32, y: i32) -> i32;
+    fn desklink_point_overlay_wayland(
+        w: i32,
+        h: i32,
+        known: i32,
+        x: i32,
+        y: i32,
+        desktop: i32,
+    ) -> i32;
 }
 
 #[cfg(target_os = "linux")]
@@ -181,12 +190,17 @@ fn main() {
         },
         "point-overlay-wayland" => {
             let values: Vec<i32> = args.iter().skip(1).filter_map(|v| v.parse().ok()).collect();
-            if values.len() != 5 || values[0] <= 0 || values[1] <= 0 {
+            if !(5..=6).contains(&values.len()) || values[0] <= 0 || values[1] <= 0 {
                 2
             } else {
                 unsafe {
                     desklink_point_overlay_wayland(
-                        values[0], values[1], values[2], values[3], values[4],
+                        values[0],
+                        values[1],
+                        values[2],
+                        values[3],
+                        values[4],
+                        values.get(5).copied().unwrap_or(0),
                     )
                 }
             }
@@ -197,7 +211,8 @@ fn main() {
             if width <= 0 || height <= 0 {
                 2
             } else {
-                unsafe { desklink_agent_overlay_wayland(width, height) }
+                let desktop = i32::from(args.get(3).map(String::as_str) == Some("desktop"));
+                unsafe { desklink_agent_overlay_wayland(width, height, desktop) }
             }
         }
         "capabilities" => {

package/engine/src/peer.rs

@@ -267,6 +267,33 @@ pub struct TransportOptions {
     pub pace_bps: f64,
 }
 
+/// The UDP sockets ICE gathers host candidates from: an ephemeral port on every
+/// IPv4 interface and, when this computer has an IPv6 address a peer could
+/// reach, on every IPv6 one too. Mobile carriers commonly hand a phone a global
+/// IPv6 address, and a stateful firewall passes the simultaneous checks, so
+/// IPv6 can be the only direct path a phone off home Wi-Fi has. The library
+/// expands a wildcard into the interfaces' own addresses, skipping loopback and
+/// link-local; with none left it binds the wildcard itself and offers `::`,
+/// which no peer can use, so `[::]` is asked for only when there is one.
+fn udp_addrs() -> Vec<std::net::SocketAddr> {
+    let has_ipv6 = rtc::shared::ifaces::ifaces()
+        .unwrap_or_default()
+        .iter()
+        .filter_map(|interface| interface.addr)
+        .any(|addr| match addr.ip() {
+            std::net::IpAddr::V6(ip) => {
+                // fe80::/10; `Ipv6Addr::is_unicast_link_local` is still unstable.
+                !ip.is_loopback() && !ip.is_unspecified() && ip.segments()[0] & 0xffc0 != 0xfe80
+            }
+            std::net::IpAddr::V4(_) => false,
+        });
+    let mut addrs = vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))];
+    if has_ipv6 {
+        addrs.push(std::net::SocketAddr::from(([0u16; 8], 0)));
+    }
+    addrs
+}
+
 /// What the pacer lets go back to back: a few dozen packets. A 4K key frame is
 /// hundreds of packets, and released at once it overflows the receiver's
 /// socket buffer, which loses the frame and draws another key frame request —
@@ -899,7 +926,7 @@ impl VideoPeer {
             // An ephemeral port on every interface: ICE needs a socket to gather
             // candidates from, and the peer needs no fixed port because the
             // consumer's authenticated channel carries the candidates.
-            .with_udp_addrs(vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))])
+            .with_udp_addrs(udp_addrs())
             .with_tcp_addrs(if options.loopback_tcp {
                 vec![std::net::SocketAddr::from(([127, 0, 0, 1], 0))]
             } else {
@@ -1258,7 +1285,7 @@ pub(crate) mod tests {
             .with_interceptor_registry(registry)
             .with_runtime(default_runtime().expect("a runtime"))
             .with_handler(Arc::new(NoopHandler))
-            .with_udp_addrs(vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))])
+            .with_udp_addrs(udp_addrs())
             .build()
             .await
             .expect("an answering peer");
@@ -1667,7 +1694,10 @@ pub(crate) mod tests {
         }
     }
 
-    async fn media_receiver(receiver: Arc<MediaReceiver>) -> Arc<dyn PeerConnection> {
+    async fn media_receiver(
+        receiver: Arc<MediaReceiver>,
+        udp: Vec<std::net::SocketAddr>,
+    ) -> Arc<dyn PeerConnection> {
         let mut media_engine = MediaEngine::default();
         media_engine
             .register_codec(vp9_codec(), RtpCodecKind::Video)
@@ -1679,18 +1709,25 @@ pub(crate) mod tests {
             .with_interceptor_registry(registry)
             .with_runtime(default_runtime().expect("a runtime"))
             .with_handler(receiver)
-            .with_udp_addrs(vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))])
+            .with_udp_addrs(udp)
             .build()
             .await
             .expect("a receiving peer");
         Arc::new(peer)
     }
 
-    /// A restart offer/answer round must not interrupt media already flowing on
-    /// the selected pair: the picture keeps advancing (no gap over 200 ms) while
-    /// the old pair stays reachable, and the ICE generation still turns over.
-    #[tokio::test]
-    async fn a_restart_keeps_media_flowing_on_the_selected_pair_until_the_new_one_nominates() {
+    /// An engine and a client receiving on `client_udp`, offered, answered and
+    /// connected over ICE, with the client's RTP arrival times and the
+    /// candidates the engine offered.
+    struct Connected {
+        engine: Arc<VideoPeer>,
+        offer: String,
+        client: Arc<dyn PeerConnection>,
+        arrivals: Arc<Mutex<Vec<Instant>>>,
+        offered: Arc<Mutex<Vec<String>>>,
+    }
+
+    async fn connected(client_udp: Vec<std::net::SocketAddr>) -> Connected {
         let (events, mut events_rx) = tokio::sync::mpsc::unbounded_channel();
         let (engine, offer) = VideoPeer::offer(transport(), events, VideoCodec::Vp9)
             .await
@@ -1706,7 +1743,7 @@ pub(crate) mod tests {
             arrivals: Arc::clone(&arrivals),
             connected: Arc::clone(&connected),
         });
-        let client = media_receiver(Arc::clone(&receiver)).await;
+        let client = media_receiver(Arc::clone(&receiver), client_udp).await;
 
         client
             .set_remote_description(RTCSessionDescription::offer(offer.clone()).expect("an offer"))
@@ -1724,6 +1761,8 @@ pub(crate) mod tests {
 
         // The engine's candidates reach the client.
         let client_for_engine_candidates = Arc::clone(&client);
+        let offered: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
+        let offered_by_engine = Arc::clone(&offered);
         tokio::spawn(async move {
             while let Some(event) = events_rx.recv().await {
                 if let PeerEvent::Candidate {
@@ -1732,6 +1771,7 @@ pub(crate) mod tests {
                     sdp_m_line_index,
                 } = event
                 {
+                    offered_by_engine.lock().unwrap().push(candidate.clone());
                     let _ = client_for_engine_candidates
                         .add_ice_candidate(RTCIceCandidateInit {
                             candidate,
@@ -1757,9 +1797,35 @@ pub(crate) mod tests {
         // Wait for the ICE path to come up on both ends.
         let deadline = Instant::now() + Duration::from_secs(5);
         while !(engine.is_connected() && connected.load(Ordering::SeqCst)) {
-            assert!(Instant::now() < deadline, "the peers never connected");
+            assert!(
+                Instant::now() < deadline,
+                "the peers never connected; the engine offered {:?}",
+                offered.lock().unwrap()
+            );
             tokio::time::sleep(Duration::from_millis(10)).await;
         }
+        Connected {
+            engine,
+            offer,
+            client,
+            arrivals,
+            offered,
+        }
+    }
+
+    /// A restart offer/answer round must not interrupt media already flowing on
+    /// the selected pair: the picture keeps advancing (no gap over 200 ms) while
+    /// the old pair stays reachable, and the ICE generation still turns over.
+    #[tokio::test]
+    async fn a_restart_keeps_media_flowing_on_the_selected_pair_until_the_new_one_nominates() {
+        let Connected {
+            engine,
+            offer,
+            client,
+            arrivals,
+            offered,
+        } = connected(vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))]).await;
+        eprintln!("restart: the engine offered {:?}", offered.lock().unwrap());
 
         // Any bytes the VP9 packetizer turns into one access unit.
         let frame: Vec<u8> = (0..200u32).map(|i| (i % 251) as u8).collect();
@@ -1886,6 +1952,61 @@ pub(crate) mod tests {
         let _ = client.close().await;
     }
 
+    /// A phone whose only direct way here is IPv6, such as one on a carrier that
+    /// hands it a global IPv6 address, still gets the picture: the engine offers
+    /// its IPv6 addresses, never a loopback or link-local one, and a client that
+    /// can only send from `::1` connects and receives media.
+    #[tokio::test]
+    async fn a_client_with_only_an_ipv6_route_gets_the_picture() {
+        if !udp_addrs().iter().any(std::net::SocketAddr::is_ipv6) {
+            eprintln!("ipv6: skipped, this computer has no IPv6 address a peer could reach");
+            return;
+        }
+        let Connected {
+            engine,
+            client,
+            arrivals,
+            offered,
+            ..
+        } = connected(vec![std::net::SocketAddr::from((
+            std::net::Ipv6Addr::LOCALHOST,
+            0,
+        ))])
+        .await;
+        let offered = offered.lock().unwrap().clone();
+        eprintln!("ipv6: the engine offered {offered:?}");
+        let ipv6: Vec<std::net::Ipv6Addr> = offered
+            .iter()
+            .filter_map(|candidate| candidate.split(' ').nth(4)?.parse().ok())
+            .collect();
+        assert!(!ipv6.is_empty(), "no IPv6 candidate was offered");
+        assert!(
+            !ipv6
+                .iter()
+                .any(|ip| ip.is_loopback() || ip.segments()[0] & 0xffc0 == 0xfe80),
+            "a loopback or link-local address reached the client: {ipv6:?}"
+        );
+
+        let frame: Vec<u8> = (0..200u32).map(|i| (i % 251) as u8).collect();
+        for _ in 0..50 {
+            engine
+                .send_frame(&frame, true, Instant::now())
+                .await
+                .expect("a frame is sent");
+            tokio::time::sleep(Duration::from_millis(5)).await;
+        }
+        tokio::time::sleep(Duration::from_millis(200)).await;
+        let received = arrivals.lock().unwrap().len();
+        eprintln!("ipv6: {received} of 50 frames arrived at a client on ::1");
+        assert!(
+            received >= 25,
+            "the picture did not arrive over IPv6: {received} packets"
+        );
+
+        engine.close().await;
+        let _ = client.close().await;
+    }
+
     #[tokio::test]
     async fn a_forwarded_client_is_offered_ice_over_tcp_on_the_loopback() {
         let offered = |loopback_tcp: bool| async move {

package/engine/src/session.rs

@@ -816,6 +816,11 @@ struct Inner {
     point_overlay: Mutex<Option<crate::indicator::Indicator>>,
     #[cfg(target_os = "linux")]
     point_desktop: PointDesktop,
+    /// A portal window share's place on a Hyprland desktop; absent elsewhere,
+    /// where a shared window's taps are refused. Dropped on close, which
+    /// closes its Hyprland event socket.
+    #[cfg(target_os = "linux")]
+    window: Mutex<Option<crate::hyprland::WindowLocator>>,
     capture: Mutex<Option<FrameSource>>,
     /// Absent for an encoded source: there is no local keyboard to translate a
     /// character through, because the client's keys are forwarded instead.
@@ -1195,6 +1200,8 @@ impl Session {
                 None
             };
         let mut cursor_info = serde_json::json!({"mode":"embedded", "positions":false});
+        #[cfg(target_os = "linux")]
+        let mut share_watch = None;
         let Selected {
             source,
             capture,
@@ -1225,6 +1232,9 @@ impl Session {
                     _ => {
                         #[cfg(target_os = "linux")]
                         {
+                            // Hyprland names the window it shares only on its
+                            // event socket, as the share starts.
+                            share_watch = crate::hyprland::ShareWatch::start();
                             portal::open(request.restore_token.as_deref(), request.cursor).await
                         }
                         #[cfg(not(target_os = "linux"))]
@@ -1257,9 +1267,16 @@ impl Session {
                 let source_h = source.height.max(1) as usize;
                 let (width, height) =
                     fit(source_w, source_h, request.max_width, request.max_height);
+                // A Hyprland window share's cues go to the desktop point each
+                // press lands on, and its picture holds no layer surface to mask.
+                #[cfg(target_os = "linux")]
+                let desktop =
+                    share_watch.is_some() && source.source_type.as_deref() == Some("Window");
                 #[cfg(target_os = "linux")]
                 if request.agent_indicator {
-                    indicator = crate::indicator::Indicator::start_wayland(source_w, source_h).ok();
+                    indicator =
+                        crate::indicator::Indicator::start_wayland(source_w, source_h, desktop)
+                            .ok();
                 }
                 #[cfg(target_os = "macos")]
                 if request.agent_indicator {
@@ -1302,6 +1319,7 @@ impl Session {
                     sink,
                     indicator
                         .as_ref()
+                        .filter(|_| !desktop)
                         .map(crate::indicator::Indicator::position),
                     Box::new({
                         let status = capture_status.clone();
@@ -1354,6 +1372,10 @@ impl Session {
         let source_w = source.width.max(1) as usize;
         let source_h = source.height.max(1) as usize;
         let (width, height) = fit(source_w, source_h, request.max_width, request.max_height);
+        #[cfg(target_os = "linux")]
+        let window = share_watch
+            .filter(|_| source.source_type.as_deref() == Some("Window"))
+            .map(|watch| crate::hyprland::WindowLocator::new(watch, source.width, source.height));
 
         let bitrate_kbps = if request.bitrate_kbps == 0 {
             auto_bitrate(width, height)
@@ -1469,6 +1491,8 @@ impl Session {
             } else {
                 PointDesktop::Wayland
             },
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(window),
             capture: Mutex::new(Some(capture)),
             layout: Mutex::new(Some(layout)),
             #[cfg(target_os = "linux")]
@@ -1567,6 +1591,8 @@ impl Session {
             point_overlay: Mutex::new(None),
             #[cfg(target_os = "linux")]
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(None),
             capture: Mutex::new(None),
             layout: Mutex::new(None),
             #[cfg(target_os = "linux")]
@@ -1736,6 +1762,22 @@ impl Session {
                 "timeout must be 1..120000 ms; label must be at most 96 printable ASCII bytes",
             ));
         }
+        // A located window's point shows where a press there would land, on
+        // the output holding it; the next may land on another output, so each
+        // gets its own helper.
+        #[cfg(target_os = "linux")]
+        let landed = match lock(&self.inner.window).as_ref() {
+            Some(window) => {
+                let (px, py) = window
+                    .locate(x, y)
+                    .map_err(|message| SessionError::new("indicator-unavailable", message))?;
+                if let Some(helper) = overlay.take() {
+                    helper.stop();
+                }
+                Some((px.floor() as i64, py.floor() as i64))
+            }
+            None => None,
+        };
         #[cfg(not(target_os = "windows"))]
         if overlay.is_none() {
             #[cfg(target_os = "linux")]
@@ -1744,7 +1786,10 @@ impl Session {
                 PointDesktop::Wayland => crate::indicator::Indicator::start_point_wayland(
                     source.width,
                     source.height,
-                    source.position,
+                    landed
+                        .map(|(x, y)| (x as i32, y as i32))
+                        .or(source.position),
+                    landed.is_some(),
                 ),
                 PointDesktop::Unavailable(_) => unreachable!("validated point target"),
             };
@@ -1766,6 +1811,8 @@ impl Session {
                 }
             })?);
         }
+        #[cfg(target_os = "linux")]
+        let (x, y) = landed.unwrap_or((x, y));
         #[cfg(not(target_os = "windows"))]
         return overlay
             .as_mut()
@@ -2118,6 +2165,8 @@ impl Inner {
         drop(capture);
         #[cfg(target_os = "linux")]
         drop(self.audio.lock().ok().and_then(|mut held| held.take()));
+        #[cfg(target_os = "linux")]
+        drop(lock(&self.window).take());
         self.notify(SessionEvent::State {
             capture: "ended",
             transport: String::from("closed"),
@@ -2219,7 +2268,7 @@ impl Inner {
             }
             *last = seq;
         }
-        let feedback = match &message {
+        let mut feedback = match &message {
             ControlMessage::Pointer { phase, x, y, .. } if lock(&self.encoded).is_none() => {
                 let (x, y) = to_source_pixels(*x, *y, self.encoded_size(), &self.source);
                 Some((
@@ -2245,17 +2294,26 @@ impl Inner {
         }
         // A shared window's place on the desktop is unknown (the portal reports
         // no origin for it), while the pointer device spans the whole desktop:
-        // a tap would land somewhere the person never pointed.
+        // a tap would land somewhere the person never pointed. Only Hyprland
+        // says where the window is.
+        #[cfg(target_os = "linux")]
+        let located = lock(&self.window).is_some();
+        #[cfg(not(target_os = "linux"))]
+        let located = false;
         if self.source.source_type.as_deref() == Some("Window")
+            && !located
             && matches!(&message, ControlMessage::Pointer { phase, .. } if !matches!(phase, PointerPhase::Cancel))
         {
             self.reject(seq, "input-unavailable", WINDOW_POINTER_REFUSAL);
             return;
         }
+        // A located window's pointer moves through the compositor; only its
+        // buttons need the input device, which `pointer` checks first.
         if !matches!(
             &message,
             ControlMessage::ClipboardRead { .. } | ControlMessage::ClipboardWrite { .. }
-        ) && lock(&self.input).is_none()
+        ) && !(located && matches!(&message, ControlMessage::Pointer { .. }))
+            && lock(&self.input).is_none()
         {
             self.reject(seq, "input-unavailable", "no input backend");
             return;
@@ -2267,7 +2325,14 @@ impl Inner {
                 y,
                 button,
                 ..
-            } => self.pointer(phase, x, y, button, seq),
+            } => self.pointer(phase, x, y, button, seq).map(|landed| {
+                // A located window's cue goes where the press landed, or nowhere.
+                if located {
+                    feedback = feedback
+                        .zip(landed)
+                        .map(|((kind, ..), (x, y))| (kind, x, y));
+                }
+            }),
             ControlMessage::Wheel { dx, dy, .. } => self.wheel(dx, dy, seq),
             ControlMessage::Key {
                 name,
@@ -2368,7 +2433,7 @@ impl Inner {
         y: i64,
         button: i64,
         _seq: u64,
-    ) -> std::result::Result<(), (&'static str, String)> {
+    ) -> std::result::Result<Option<(i64, i64)>, (&'static str, String)> {
         let (width, height) = self.encoded_size();
         if !(0..width as i64).contains(&x) || !(0..height as i64).contains(&y) {
             return Err((
@@ -2380,6 +2445,30 @@ impl Inner {
         // created for, and clamps to, the source's own pixels. One conversion
         // here keeps every caller honest.
         let (x, y) = to_source_pixels(x, y, (width, height), &self.source);
+        #[cfg(target_os = "linux")]
+        if let Some(window) = lock(&self.window).as_ref() {
+            let place = || {
+                window
+                    .place(x, y)
+                    .map_err(|message| ("input-unavailable", message))
+            };
+            // The desktop point the pointer landed on, where its cue belongs.
+            return match phase {
+                PointerPhase::Move => place().map(Some),
+                PointerPhase::Down => {
+                    // Refused before the pointer moves: nothing could press.
+                    self.with_input(|_| Ok(()))?;
+                    let point = place()?;
+                    self.with_input(|target| target.button(Button::from_number(button), true))?;
+                    Ok(Some(point))
+                }
+                PointerPhase::Up => {
+                    self.with_input(|target| target.button(Button::from_number(button), false))?;
+                    place().map(Some)
+                }
+                PointerPhase::Cancel => self.with_input(InputTarget::release_all).map(|()| None),
+            };
+        }
         self.with_input(|target| match phase {
             PointerPhase::Move => target.move_absolute(x, y),
             PointerPhase::Down => {
@@ -2392,6 +2481,7 @@ impl Inner {
             }
             PointerPhase::Cancel => target.release_all(),
         })
+        .map(|()| None)
     }
 
     fn wheel(
@@ -3407,7 +3497,10 @@ fn spawn_peer_events(inner: &Arc<Inner>, mut events: tokio_mpsc::UnboundedReceiv
                     // desklink scout trace: the session's transport emit, one
                     // line after the peer event that caused it.
                     if crate::peer::dl_trace_on() {
-                        crate::peer::dl_eng!("session_transport_emit {}", format!("{state}").to_lowercase());
+                        crate::peer::dl_eng!(
+                            "session_transport_emit {}",
+                            format!("{state}").to_lowercase()
+                        );
                     }
                 }
                 PeerEvent::ControlOpen => {
@@ -3467,7 +3560,7 @@ fn available_parallelism() -> usize {
         .unwrap_or(4)
 }
 
-const WINDOW_POINTER_REFUSAL: &str = "a shared window cannot take taps: its place on the desktop is unknown; share the whole screen to point and click";
+pub(crate) const WINDOW_POINTER_REFUSAL: &str = "a shared window cannot take taps: its place on the desktop is unknown; share the whole screen to point and click";
 
 /// Encoded-surface pixels to the source's own pixels. The client aims at what it
 /// sees; the applier is sized and clamped to the source, so the layout origin
@@ -3583,6 +3676,8 @@ mod tests {
             point_overlay: Mutex::new(None),
             #[cfg(target_os = "linux")]
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(None),
             capture: Mutex::new(None),
             layout: Mutex::new(None),
             #[cfg(target_os = "linux")]
@@ -3842,6 +3937,8 @@ mod tests {
             point_overlay: Mutex::new(None),
             #[cfg(target_os = "linux")]
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(None),
             layout: Mutex::new(Some(Layout::from_environment().expect("a keymap"))),
             #[cfg(target_os = "linux")]
             audio: Mutex::new(None),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@desklink/host",
-    "version": "0.5.6",
+    "version": "0.5.8",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -38,7 +38,7 @@
         "ws": "8.21.3"
     },
     "optionalDependencies": {
-        "@desklink/host-linux-x64-gnu": "0.5.6",
-        "@desklink/host-darwin-arm64": "0.5.6"
+        "@desklink/host-linux-x64-gnu": "0.5.8",
+        "@desklink/host-darwin-arm64": "0.5.8"
     }
 }