@desklink/host 0.3.1 → 0.4.0

package/engine/native/agent_overlay_x11.c

@@ -1,40 +1,82 @@
-// The X server draws cursors outside GetImage(root). No overlay window can
-// expose black pixels, intercept input, or poison agent frame diffs.
+// The agent cue is a click-through override-redirect window that follows the
+// pointer, so it stays visible over windows that set their own cursor and never
+// replaces the person's cursor. With a compositing manager it uses an ARGB
+// visual; without one, a 1-bit shape. It appears in GetImage(root), so each
+// state is reported on stdout before it is drawn and the engine restores the
+// covered pixels in X11 capture (desklink_indicator_covered below).
 #include <X11/Xlib.h>
-#include <X11/Xcursor/Xcursor.h>
+#include <X11/Xutil.h>
+#include <X11/Xresource.h>
+#include <X11/extensions/shape.h>
 #include <math.h>
 #include <fcntl.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
+#include "agent_indicator.h"
+
+// The same coverage test the helper draws with, for the engine's capture mask.
+int desklink_indicator_covered(double x, double y, double opacity, double click, double typed, unsigned threshold, double reveal) {
+    return hypot(x,y)<reveal && (indicator_pixel(x,y,opacity,click,typed)>>24) >= threshold;
+}
 
 static double now(void) { struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return t.tv_sec + t.tv_nsec/1e9; }
 
-static unsigned pixel(double distance, double radius, double opacity) {
-    double edge = fmax(0, 1 - fabs(distance-radius)/2.5);
-    unsigned alpha = (unsigned)(fmin(1, edge * opacity) * 255);
-    return (alpha << 24) | 0x4c9ed0;
+static double desktop_scale(Display *d) {
+    double scale=1;
+    const char *resources=XResourceManagerString(d);
+    if(!resources) return scale;
+    XrmInitialize(); XrmDatabase db=XrmGetStringDatabase(resources);
+    XrmValue value; char *type;
+    if(db && XrmGetResource(db,"Xft.dpi","Xft.Dpi",&type,&value) && value.addr) {
+        double dpi=strtod(value.addr,NULL);
+        if(isfinite(dpi) && dpi>=96 && dpi<=384)scale=dpi/96;
+    }
+    if(db)XrmDestroyDatabase(db);
+    return scale;
 }
 
 int desklink_agent_overlay_main(const char *display_name) {
     Display *d = XOpenDisplay(display_name);
     if (!d) return 2;
-    Window root = DefaultRootWindow(d);
-    unsigned best_w=64,best_h=64;
-    XQueryBestCursor(d,root,64,64,&best_w,&best_h);
-    unsigned size = best_w < best_h ? best_w : best_h;
-    if (size < 32) { XCloseDisplay(d); return 2; }
-    if (size > 96) size = 96;
-    XcursorImage *image = XcursorImageCreate(size,size);
-    if (!image) { XCloseDisplay(d); return 2; }
-    image->version = XCURSOR_IMAGE_VERSION;
-    Cursor previous = None;
+    int event_base, error_base, screen=DefaultScreen(d);
+    if (!XShapeQueryExtension(d,&event_base,&error_base)) { XCloseDisplay(d); return 2; }
+    Window root = RootWindow(d,screen);
+    double scale=desktop_scale(d);
+    // The arrow reaches 36 logical px from the cue's center.
+    int size=(int)ceil(80*scale);
+    char selection[32]; snprintf(selection,sizeof(selection),"_NET_WM_CM_S%d",screen);
+    XVisualInfo argb;
+    int alpha = XGetSelectionOwner(d,XInternAtom(d,selection,False))!=None
+        && XMatchVisualInfo(d,screen,32,TrueColor,&argb);
+    XSetWindowAttributes attrs={0};
+    attrs.override_redirect=True;
+    attrs.background_pixmap=None;
+    attrs.border_pixel=0;
+    unsigned long mask=CWOverrideRedirect|CWBackPixmap|CWBorderPixel;
+    Visual *visual=DefaultVisual(d,screen); int depth=DefaultDepth(d,screen);
+    if(alpha) {
+        visual=argb.visual; depth=32;
+        attrs.colormap=XCreateColormap(d,root,visual,AllocNone); mask|=CWColormap;
+    } else if(depth<24) { XCloseDisplay(d); return 2; }
+    Window window=XCreateWindow(d,root,0,0,size,size,0,depth,InputOutput,visual,mask,&attrs);
+    XStoreName(d,window,"Desklink agent");
+    XShapeCombineRectangles(d,window,ShapeInput,0,0,NULL,0,ShapeSet,Unsorted);
+    XSelectInput(d,window,ExposureMask);
+    XSelectInput(d,root,SubstructureNotifyMask);
+    GC gc=XCreateGC(d,window,0,NULL);
+    uint32_t *pixels=calloc((size_t)size*size,4);
+    int row=(size+7)/8;
+    char *bits=calloc((size_t)row*size,1);
+    XImage *image=pixels?XCreateImage(d,visual,depth,ZPixmap,0,(char *)pixels,size,size,32,0):NULL;
+    if(!image || !bits || image->bits_per_pixel!=32) { XCloseDisplay(d); return 2; }
     int stdin_flags = fcntl(STDIN_FILENO, F_GETFL);
     fcntl(STDIN_FILENO, F_SETFL, stdin_flags | O_NONBLOCK);
     puts("READY"); fflush(stdout);
-    double target_x=0,target_y=0,cursor_x=0,cursor_y=0,click=0,typed=0,ending=0;
-    int active=0;
+    double target_x=0,target_y=0,cue_x=0,cue_y=0,click=0,typed=0,ending=0,started=0;
+    int active=0,mapped=0,redraw=0,was_animating=0,last_x=-100000,last_y=-100000;
     char pending[128]; size_t used=0;
     for (;;) {
         char bytes[128]; ssize_t n = read(STDIN_FILENO, bytes, sizeof(bytes));
@@ -44,11 +86,12 @@ int desklink_agent_overlay_main(const char *display_name) {
                 pending[used]=0; char kind=0; double px=0,py=0;
                 if (sscanf(pending,"%c %lf %lf",&kind,&px,&py)>=1) {
                     if (kind=='S') ending=now();
-                    else if (kind=='M'||kind=='C'||kind=='T') {
+                    else if ((kind=='M'||kind=='C'||kind=='T') && (active || (px>=0 && py>=0))) {
                         if (px>=0 && py>=0) {
                             target_x=px; target_y=py;
-                            if (!active) { cursor_x=px; cursor_y=py; }
+                            if (!active) { cue_x=px; cue_y=py; }
                         }
+                        if (!active) started=now();
                         active=1;
                         if (kind=='C') click=now();
                         if (kind=='T') typed=now();
@@ -57,48 +100,66 @@ int desklink_agent_overlay_main(const char *display_name) {
                 used=0;
             } else if (used < sizeof(pending)-1) pending[used++]=bytes[i];
         }
+        while (XPending(d)) {
+            XEvent event; XNextEvent(d,&event);
+            if (event.type==Expose && event.xexpose.window==window) redraw=1;
+            // Stay above windows and menus mapped or restacked after us.
+            if (mapped && ((event.type==MapNotify && event.xmap.window!=window)
+                || (event.type==ConfigureNotify && event.xconfigure.window!=window))) XRaiseWindow(d,window);
+        }
         double t=now();
-        if (ending && t-ending>0.55) break;
+        if (ending && (!active || t-ending>0.55)) break;
         if (active) {
-            cursor_x += (target_x-cursor_x)*0.24;
-            cursor_y += (target_y-cursor_y)*0.24;
-            int radius=(int)size/2-3;
-            image->xhot = (unsigned)fmax(0,fmin(size-1,(double)size/2+target_x-cursor_x));
-            image->yhot = (unsigned)fmax(0,fmin(size-1,(double)size/2+target_y-cursor_y));
-            for (unsigned y=0;y<size;y++) for (unsigned x=0;x<size;x++) {
-                double distance=hypot(x-(double)size/2,y-(double)size/2);
-                double opacity=ending ? fmax(0,1-(t-ending)/0.55) : 1;
-                unsigned color=pixel(distance,12,0.72*opacity);
-                if (distance>=16 && distance<=radius) {
-                    unsigned outer=pixel(distance,20,0.20*opacity);
-                    if ((outer>>24)>(color>>24)) color=outer;
+            cue_x += (target_x-cue_x)*0.24;
+            cue_y += (target_y-cue_y)*0.24;
+            double opacity=ending ? fmax(0,1-(t-ending)/0.55) : fmin(1,(t-started)/0.18);
+            double c=click?(t-click)/0.55:-1, k=typed?(t-typed)/0.4:-1;
+            int animating = opacity<1 || (c>=0 && c<1) || (k>=0 && k<1);
+            // One more frame once an animation ends, so the rest state is exact.
+            if (!animating && was_animating) redraw=1;
+            was_animating=animating;
+            int x=(int)lround(cue_x), y=(int)lround(cue_y);
+            if (animating || redraw || x!=last_x || y!=last_y) {
+                // A 1-bit shape cannot fade: reveal outward from the tip and
+                // retract inward, so coverage only grows while appearing and a
+                // still cue never uncovers stale pixels.
+                double unit=scale, reveal=alpha?99:40*opacity*(2-opacity);
+                memset(bits,0,(size_t)row*size);
+                for (int py=0;py<size;py++) for (int px=0;px<size;px++) {
+                    double lx=(px-size/2.0)/unit, ly=(py-size/2.0)/unit;
+                    uint32_t color=hypot(lx,ly)<reveal?indicator_pixel(lx,ly,alpha?opacity:1,c,k):0;
+                    unsigned a=color>>24;
+                    if (alpha) { pixels[py*size+px]=color; continue; }
+                    if (a<128) { pixels[py*size+px]=0; continue; }
+                    bits[py*row+px/8]|=(char)(1<<(px%8));
+                    // Un-premultiply: the shaped path paints opaque pixels.
+                    pixels[py*size+px]=((((color>>16)&255)*255/a)<<16)|((((color>>8)&255)*255/a)<<8)|((color&255)*255/a);
                 }
-                if (click && t-click<0.5) {
-                    double progress=(t-click)/0.5;
-                    unsigned ripple=pixel(distance,12+(radius-14)*progress,0.6*(1-progress)*opacity);
-                    if ((ripple>>24)>(color>>24)) color=ripple;
+                // Announce first: capture reads this pipe after each grab, so
+                // every state a grab can see is already announced.
+                printf("P %d %d %d %.6f %.4f %.4f %.4f %u %.4f\n",x-size/2,y-size/2,size,unit,alpha?opacity:1,c,k,alpha?1u:128u,reveal);
+                // No reader means the engine is gone: leave at once rather
+                // than animate unmasked into whatever captures next.
+                if (fflush(stdout)) break;
+                if (!alpha) {
+                    Pixmap shape=XCreateBitmapFromData(d,window,bits,size,size);
+                    XShapeCombineMask(d,window,ShapeBounding,0,0,shape,ShapeSet);
+                    XFreePixmap(d,shape);
                 }
-                if (typed && t-typed<0.35) {
-                    double progress=(t-typed)/0.35;
-                    if (distance<5+progress*12) {
-                        unsigned pulse=(unsigned)(0.22*(1-progress)*opacity*255);
-                        if (pulse>(color>>24)) color=(pulse<<24)|0x5baed8;
-                    }
-                }
-                image->pixels[y*size+x]=color;
-            }
-            Cursor next=XcursorImageLoadCursor(d,image);
-            if (next!=None) {
-                XDefineCursor(d,root,next); XFlush(d);
-                if (previous!=None) XFreeCursor(d,previous);
-                previous=next;
+                if (x!=last_x || y!=last_y) XMoveWindow(d,window,x-size/2,y-size/2);
+                if (!mapped) { XMapRaised(d,window); mapped=1; }
+                XPutImage(d,window,gc,image,0,0,0,0,size,size);
+                // Wait until the server has drawn it, so at most the newest
+                // announced state is not on screen yet.
+                XSync(d,False);
+                last_x=x; last_y=y; redraw=0;
             }
         }
         usleep(16000);
     }
-    XUndefineCursor(d,root); XFlush(d);
-    if (previous!=None) XFreeCursor(d,previous);
-    XcursorImageDestroy(image); XCloseDisplay(d);
+    XDestroyWindow(d,window);
+    XDestroyImage(image); free(bits);
+    XFreeGC(d,gc); XCloseDisplay(d);
     return 0;
 }
 
@@ -106,8 +167,6 @@ int desklink_agent_overlay_main(const char *display_name) {
 // window works without a compositor; an empty input shape passes every event
 // through and mapping it never asks for keyboard focus. It intentionally appears
 // in GetImage(root), so the local person and the video observer share the cue.
-#include <X11/extensions/shape.h>
-#include <stdlib.h>
 
 int desklink_point_overlay_main(const char *display_name) {
     Display *d = XOpenDisplay(display_name);

package/engine/src/capture.rs

@@ -541,7 +541,8 @@ fn run_loop(
 
 // The portal composites layer-shell into its pixels. Keep the last clean
 // backing for the helper's bounded circle and edge strips before diff/encode;
-// the center stays live so a click marker at the caret remains observable.
+// the center (4 logical px, which the cue leaves clear) stays live so a
+// click marker at the caret remains observable.
 struct IndicatorMask {
     position: Arc<Mutex<Option<(i64, i64)>>>,
     clean: Option<Vec<u8>>,
@@ -591,6 +592,7 @@ impl IndicatorMask {
                     )
                 });
             let radius = (150 * width / source_w).max(55) as i64;
+            let hole = (4 * width / source_w) as i64;
             let edge = (20 * width / source_w)
                 .max(8)
                 .min(width / 2)
@@ -630,7 +632,7 @@ impl IndicatorMask {
                         };
                         (col as i64 - cx).pow(2) + (row as i64 - cy).pow(2) <= radius * radius
                     });
-                    if (distance <= radius * radius || along) && distance > 16 {
+                    if (distance <= radius * radius || along) && distance > hole * hole {
                         let at = start + col * 4;
                         raw[at..at + 4].copy_from_slice(&clean[at..at + 4]);
                     }

package/engine/src/clipboard.rs

@@ -97,6 +97,180 @@ pub fn read_or_explain() -> Result<(String, bool), String> {
     }
 }
 
+/// Each operation uses its own connection: capture drains selection events.
+fn x11_window(display: &str) -> Result<(x11rb::rust_connection::RustConnection, u32)> {
+    use x11rb::connection::Connection;
+    use x11rb::protocol::xproto::{ConnectionExt, CreateWindowAux, WindowClass};
+    let (connection, screen) = x11rb::connect(Some(display))?;
+    let window = connection.generate_id()?;
+    connection
+        .create_window(
+            0,
+            window,
+            connection.setup().roots[screen].root,
+            0,
+            0,
+            1,
+            1,
+            0,
+            WindowClass::INPUT_ONLY,
+            0,
+            &CreateWindowAux::new(),
+        )?
+        .check()?;
+    Ok((connection, window))
+}
+
+fn x11_atom(connection: &impl x11rb::connection::Connection, name: &[u8]) -> Result<u32> {
+    use x11rb::protocol::xproto::ConnectionExt;
+    Ok(connection.intern_atom(false, name)?.reply()?.atom)
+}
+
+/// Own CLIPBOARD until another client replaces it, the engine exits, or X dies.
+/// No INCR send: a single bounded property is the entire supported transfer.
+pub fn x11_write(display: &str, text: &str) -> Result<()> {
+    use x11rb::connection::{Connection, RequestConnection};
+    use x11rb::protocol::{xproto::*, Event};
+    use x11rb::wrapper::ConnectionExt as _;
+    anyhow::ensure!(
+        text.len() <= MAX_CLIPBOARD_BYTES,
+        "refusing to place {} bytes on the clipboard",
+        text.len()
+    );
+    let (connection, window) = x11_window(display)?;
+    // Leave room for the ChangeProperty header and alignment padding.
+    anyhow::ensure!(
+        text.len() <= connection.maximum_request_bytes().saturating_sub(28),
+        "clipboard text is too large for one transfer (INCR is unsupported)"
+    );
+    let selection = x11_atom(&connection, b"CLIPBOARD")?;
+    let targets = x11_atom(&connection, b"TARGETS")?;
+    let utf8 = x11_atom(&connection, b"UTF8_STRING")?;
+    let text_target = x11_atom(&connection, b"TEXT")?;
+    connection
+        .set_selection_owner(window, selection, x11rb::CURRENT_TIME)?
+        .check()?;
+    anyhow::ensure!(
+        connection.get_selection_owner(selection)?.reply()?.owner == window,
+        "the X server refused clipboard ownership"
+    );
+    let text = text.to_owned();
+    std::thread::Builder::new()
+        .name(String::from("desklink-x11-clipboard"))
+        .spawn(move || -> Result<()> {
+            loop {
+                match connection.wait_for_event()? {
+                    Event::SelectionClear(_) => break,
+                    Event::SelectionRequest(request) => {
+                        let property = if request.property == x11rb::NONE {
+                            request.target
+                        } else {
+                            request.property
+                        };
+                        let accepted = if request.target == targets {
+                            connection
+                                .change_property32(
+                                    PropMode::REPLACE,
+                                    request.requestor,
+                                    property,
+                                    AtomEnum::ATOM,
+                                    &[targets, utf8, text_target],
+                                )?
+                                .check()
+                                .is_ok()
+                        } else if request.target == utf8 || request.target == text_target {
+                            connection
+                                .change_property8(
+                                    PropMode::REPLACE,
+                                    request.requestor,
+                                    property,
+                                    utf8,
+                                    text.as_bytes(),
+                                )?
+                                .check()
+                                .is_ok()
+                        } else {
+                            false
+                        };
+                        let reply = SelectionNotifyEvent {
+                            response_type: SELECTION_NOTIFY_EVENT,
+                            sequence: 0,
+                            time: request.time,
+                            requestor: request.requestor,
+                            selection: request.selection,
+                            target: request.target,
+                            property: if accepted { property } else { x11rb::NONE },
+                        };
+                        connection.send_event(
+                            false,
+                            request.requestor,
+                            EventMask::NO_EVENT,
+                            reply,
+                        )?;
+                        connection.flush()?;
+                    }
+                    _ => {}
+                }
+            }
+            Ok(())
+        })?;
+    Ok(())
+}
+
+pub fn x11_read(display: &str) -> Result<(String, bool)> {
+    use x11rb::connection::Connection;
+    use x11rb::protocol::{xproto::ConnectionExt, Event};
+    let (connection, window) = x11_window(display)?;
+    let selection = x11_atom(&connection, b"CLIPBOARD")?;
+    anyhow::ensure!(
+        connection.get_selection_owner(selection)?.reply()?.owner != x11rb::NONE,
+        "the desktop clipboard has no text"
+    );
+    let utf8 = x11_atom(&connection, b"UTF8_STRING")?;
+    let incr = x11_atom(&connection, b"INCR")?;
+    let property = x11_atom(&connection, b"DESKLINK_CLIPBOARD")?;
+    connection.convert_selection(window, selection, utf8, property, x11rb::CURRENT_TIME)?;
+    connection.flush()?;
+    let deadline = std::time::Instant::now() + std::time::Duration::from_millis(2500);
+    loop {
+        if let Some(Event::SelectionNotify(event)) = connection.poll_for_event()? {
+            if event.requestor != window || event.selection != selection {
+                continue;
+            }
+            anyhow::ensure!(
+                event.property != x11rb::NONE,
+                "the desktop clipboard has no text"
+            );
+            let reply = connection
+                .get_property(
+                    true,
+                    window,
+                    property,
+                    x11rb::protocol::xproto::AtomEnum::ANY,
+                    0,
+                    (MAX_CLIPBOARD_BYTES / 4 + 1) as u32,
+                )?
+                .reply()?;
+            // ponytail: one property only; implement INCR when larger transfers are needed.
+            anyhow::ensure!(
+                reply.type_ != incr,
+                "clipboard text is too large for one transfer (INCR is unsupported)"
+            );
+            anyhow::ensure!(
+                reply.format == 8 && reply.type_ == utf8,
+                "the clipboard contents are not UTF-8 text"
+            );
+            let (text, truncated) = bounded_text(&reply.value, MAX_CLIPBOARD_BYTES)?;
+            return Ok((text, truncated || reply.bytes_after > 0));
+        }
+        anyhow::ensure!(
+            std::time::Instant::now() < deadline,
+            "the clipboard owner did not answer"
+        );
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/engine/src/indicator.rs

@@ -4,6 +4,89 @@ use anyhow::{Context, Result};
 use std::io::{BufRead, BufReader, Write};
 use std::process::{Child, ChildStdin, Command, Stdio};
 
+/// One drawn state of the X11 agent cue, announced by the helper before it
+/// reaches the screen: the window's origin and size plus the inputs of
+/// `desklink_indicator_covered`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Cue {
+    pub x: i64,
+    pub y: i64,
+    pub size: i64,
+    pub unit: f64,
+    pub opacity: f64,
+    pub click: f64,
+    pub typed: f64,
+    pub threshold: u32,
+    /// Logical radius drawn so far while the shaped cue appears or leaves.
+    pub reveal: f64,
+}
+
+impl Cue {
+    fn parse(line: &str) -> Option<Self> {
+        let mut parts = line.strip_prefix("P ")?.split(' ');
+        let mut next = || parts.next();
+        Some(Self {
+            x: next()?.parse().ok()?,
+            y: next()?.parse().ok()?,
+            size: next()?
+                .parse()
+                .ok()
+                .filter(|size| (1..=1024).contains(size))?,
+            unit: next()?
+                .parse()
+                .ok()
+                .filter(|unit: &f64| unit.is_finite() && *unit > 0.0)?,
+            opacity: next()?.parse().ok()?,
+            click: next()?.parse().ok()?,
+            typed: next()?.parse().ok()?,
+            threshold: next()?.parse().ok()?,
+            reveal: next()?.parse().ok()?,
+        })
+    }
+}
+
+/// The X11 agent cue's announcements, read by the capture loop itself. The
+/// helper writes each state before drawing it, so everything a grab can
+/// contain is already in the pipe when the grab returns.
+#[derive(Default)]
+pub struct CueFeed {
+    reader: Option<BufReader<std::process::ChildStdout>>,
+    line: Vec<u8>,
+    recent: Vec<Cue>,
+}
+
+impl CueFeed {
+    /// The last two states (the newer may not be drawn yet) plus every state
+    /// announced since the previous call.
+    pub fn drain(&mut self) -> Vec<Cue> {
+        let mut states = self.recent.clone();
+        while let Some(reader) = self.reader.as_mut() {
+            match reader.read_until(b'\n', &mut self.line) {
+                Ok(_) if self.line.ends_with(b"\n") => {
+                    if let Some(cue) = Cue::parse(String::from_utf8_lossy(&self.line).trim()) {
+                        states.push(cue);
+                        self.recent.push(cue);
+                        if self.recent.len() > 2 {
+                            self.recent.remove(0);
+                        }
+                    }
+                    self.line.clear();
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
+                Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {}
+                // The helper exited, and it closes its window before that.
+                _ => {
+                    self.reader = None;
+                    self.recent.clear();
+                }
+            }
+        }
+        states
+    }
+}
+
+pub type Cues = std::sync::Arc<std::sync::Mutex<CueFeed>>;
+
 pub struct Indicator {
     child: Option<Child>,
     input: Option<ChildStdin>,
@@ -11,6 +94,7 @@ pub struct Indicator {
     scale_y: f64,
     #[cfg(target_os = "linux")]
     position: std::sync::Arc<std::sync::Mutex<Option<(i64, i64)>>>,
+    cues: Cues,
 }
 
 #[cfg(target_os = "linux")]
@@ -161,24 +245,42 @@ impl Indicator {
         let stdout = child.stdout.take().unwrap();
         let (ready_tx, ready_rx) = std::sync::mpsc::channel();
         let reader = std::thread::spawn(move || {
+            let mut reader = BufReader::new(stdout);
             let mut ready = String::new();
-            let result = BufReader::new(stdout).read_line(&mut ready);
-            let _ = ready_tx.send(if result.is_ok() {
-                ready.trim().to_owned()
-            } else {
-                String::new()
-            });
+            let _ = reader.read_line(&mut ready);
+            let _ = ready_tx.send((ready.trim().to_owned(), reader));
         });
-        let ready = ready_rx
-            .recv_timeout(std::time::Duration::from_secs(5))
-            .unwrap_or_default();
+        let (ready, reader_after) = match ready_rx.recv_timeout(std::time::Duration::from_secs(5)) {
+            Ok((ready, reader)) => (ready, Some(reader)),
+            Err(_) => (String::new(), None),
+        };
         if ready != "READY" {
             let _ = child.kill();
             let _ = child.wait();
             let _ = reader.join();
             anyhow::bail!("agent indicator did not open its overlay within 5s: {ready}");
         }
-        let _ = reader.join();
+        drop(reader);
+        // Only the X11 agent cue writes after READY, and only its capture loop
+        // reads; the helper blocks on a full pipe rather than draw unannounced.
+        let cues = Cues::default();
+        #[cfg(not(unix))]
+        drop(reader_after);
+        #[cfg(unix)]
+        if let Some(reader) = reader_after {
+            use std::os::fd::AsRawFd;
+            let fd = reader.get_ref().as_raw_fd();
+            unsafe {
+                libc::fcntl(
+                    fd,
+                    libc::F_SETFL,
+                    libc::fcntl(fd, libc::F_GETFL) | libc::O_NONBLOCK,
+                )
+            };
+            if let Ok(mut feed) = cues.lock() {
+                feed.reader = Some(reader);
+            }
+        }
         Ok(Self {
             input: child.stdin.take(),
             child: Some(child),
@@ -186,9 +288,14 @@ impl Indicator {
             scale_y,
             #[cfg(target_os = "linux")]
             position: Default::default(),
+            cues,
         })
     }
 
+    pub fn cues(&self) -> Cues {
+        self.cues.clone()
+    }
+
     #[cfg(target_os = "macos")]
     pub fn pid(&self) -> u32 {
         self.child.as_ref().unwrap().id()
@@ -215,8 +322,12 @@ impl Drop for Indicator {
         // Closing stdin fades the edge and exits; do not wait for the animation.
         self.input.take();
         if let Some(mut child) = self.child.take() {
+            // Keep reading the cue's pipe open until it exits, so it can
+            // still animate out; it leaves at once only when the engine does.
+            let cues = self.cues.clone();
             std::thread::spawn(move || {
                 let _ = child.wait();
+                drop(cues);
             });
         }
     }
@@ -224,6 +335,60 @@ impl Drop for Indicator {
 
 #[cfg(all(test, target_os = "linux"))]
 mod tests {
+    #[test]
+    fn cue_feed_keeps_recent_states_until_the_helper_exits() {
+        use std::os::fd::AsRawFd;
+        let mut child = std::process::Command::new("sh")
+            .args([
+                "-c",
+                "for x in 1 2 3; do echo \"P $x 0 110 1 1 -1 -1 128 99\"; done; read _",
+            ])
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .spawn()
+            .unwrap();
+        let reader = super::BufReader::new(child.stdout.take().unwrap());
+        let fd = reader.get_ref().as_raw_fd();
+        unsafe {
+            libc::fcntl(
+                fd,
+                libc::F_SETFL,
+                libc::fcntl(fd, libc::F_GETFL) | libc::O_NONBLOCK,
+            )
+        };
+        let mut feed = super::CueFeed {
+            reader: Some(reader),
+            ..Default::default()
+        };
+        let mut drained = vec![];
+        for _ in 0..200 {
+            drained.extend(feed.drain().into_iter().map(|cue| cue.x));
+            if drained.len() >= 3 {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+        assert_eq!(
+            drained,
+            [1, 2, 3],
+            "a drain that finds nothing does not block"
+        );
+        let xs =
+            |feed: &mut super::CueFeed| feed.drain().iter().map(|cue| cue.x).collect::<Vec<_>>();
+        assert_eq!(
+            xs(&mut feed),
+            [2, 3],
+            "either of the last two may be on screen"
+        );
+        drop(child.stdin.take());
+        child.wait().unwrap();
+        assert_eq!(xs(&mut feed), [2, 3]);
+        assert!(
+            xs(&mut feed).is_empty(),
+            "a closed helper has no window left"
+        );
+    }
+
     unsafe extern "C" {
         fn desklink_wayland_geometry(
             source_w: i32,