@desklink/host 0.5.7 → 0.5.8

package/docs/PROTOCOL.md

@@ -272,9 +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 a located Hyprland window share the cue gets no pointer or click feedback —
-the engine places the pointer itself, so a stream fraction is not the window's
-desktop point (see Input and clipboard); keys still show. 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;
@@ -382,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
@@ -600,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

package/engine/Cargo.lock

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

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.7"
+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/hyprland.rs

@@ -84,8 +84,18 @@ impl WindowLocator {
         }
     }
 
-    /// Put the pointer on `(x, y)` in the shared window's own pixels.
-    pub fn place(&self, x: i64, y: i64) -> Result<(), String> {
+    /// 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.
@@ -222,7 +232,7 @@ impl WindowLocator {
                 "a shared window cannot take taps where an overlay covers it",
             ));
         }
-        self.warp((px.floor() as i64, py.floor() as i64))
+        Ok((px, py))
     }
 
     /// The address of the one window Hyprland said it is sharing.

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

@@ -136,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")]
@@ -183,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),
                     )
                 }
             }
@@ -199,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

@@ -1267,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 {
@@ -1312,6 +1319,7 @@ impl Session {
                     sink,
                     indicator
                         .as_ref()
+                        .filter(|_| !desktop)
                         .map(crate::indicator::Indicator::position),
                     Box::new({
                         let status = capture_status.clone();
@@ -1754,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")]
@@ -1762,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"),
             };
@@ -1784,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()
@@ -2239,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((
@@ -2271,11 +2300,6 @@ impl Inner {
         let located = lock(&self.window).is_some();
         #[cfg(not(target_os = "linux"))]
         let located = false;
-        let feedback = if located {
-            feedback.filter(|(kind, ..)| *kind == 'T')
-        } else {
-            feedback
-        };
         if self.source.source_type.as_deref() == Some("Window")
             && !located
             && matches!(&message, ControlMessage::Pointer { phase, .. } if !matches!(phase, PointerPhase::Cancel))
@@ -2301,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,
@@ -2402,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((
@@ -2421,19 +2452,21 @@ impl Inner {
                     .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(),
+                PointerPhase::Move => place().map(Some),
                 PointerPhase::Down => {
                     // Refused before the pointer moves: nothing could press.
                     self.with_input(|_| Ok(()))?;
-                    place()?;
-                    self.with_input(|target| target.button(Button::from_number(button), true))
+                    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()
+                    place().map(Some)
                 }
-                PointerPhase::Cancel => self.with_input(InputTarget::release_all),
+                PointerPhase::Cancel => self.with_input(InputTarget::release_all).map(|()| None),
             };
         }
         self.with_input(|target| match phase {
@@ -2448,6 +2481,7 @@ impl Inner {
             }
             PointerPhase::Cancel => target.release_all(),
         })
+        .map(|()| None)
     }
 
     fn wheel(

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@desklink/host",
-    "version": "0.5.7",
+    "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.7",
-        "@desklink/host-darwin-arm64": "0.5.7"
+        "@desklink/host-linux-x64-gnu": "0.5.8",
+        "@desklink/host-darwin-arm64": "0.5.8"
     }
 }