v1.27: eager screenshot pickup + lazy-compress + stale-clipboard overrides + payload telemetry

Five distinct user-reported failure modes from a single afternoon's
debugging session, each fixed once the live-state probes made the
root cause visible.

  * Eager fresh-screenshot pickup on every paste (ipc.rs). GNOME's
    screenshot tool atomically renames its tempfile into place but
    KEEPS THE FD OPEN for 3–5 s while rendering its in-shell "saved"
    toast, so inotify's CLOSE_WRITE doesn't fire until that fd
    closes. A paste right after PrtScr saw the old staged_text and
    dispatched the URL the user had on the clipboard before. Defence
    in depth: every paste stats the screenshots dir for the newest
    PNG/JPG; if its mtime beats staged_image.captured_at, read it
    inline (~5–20 ms for a 500 KB PNG) and stage before dispatch.
    Symptom journal entry: "staged screenshot from inotify" landing
    4 s AFTER the file's mtime, with stale-text PASTED lines in
    between. Helpers: `newest_image_in`, `mime_for_path`,
    `now_unix_secs`.

  * Lazy compression on the inotify path (inotify_watch.rs). The
    synchronous `compress_for_attach_env` call re-encodes 4K PNGs to
    WebP and was blocking the stage for 500–2000 ms on big screens.
    Fix: read raw bytes and stage them right away (one fs::read,
    ~5–20 ms), then spawn a std::thread to compress in the
    background; re-stage only if the compressed result actually wins
    on bytes. The brief window where X11 serves the raw PNG is fine
    — selection requests read from our in-memory buffer regardless
    of size.

  * 3 s freshness gate on the external-text override (ipc.rs). v1.26
    added "if X11 advertises text-only, override staged image with
    the live text" — correct in principle but fired on EVERY paste
    right after a screenshot, because the daemon's X11 re-claim is
    asynchronous (wakes x11.rs via stage_notifier_tx and re-issues
    SetSelectionOwner ~100–300 ms later) and the probe saw the OLD
    text targets in the meantime. Gate the probe behind `age >
    Duration::from_secs(3)` on staged_image; any deliberate text-copy
    after a screenshot takes at least ~1 s of human action, so 3 s
    is comfortably above the X11 re-claim race window without being
    above any real workflow.

  * Stale-text override probe in the Text branch (ipc.rs). Symmetric
    to v1.26's image-side override. When kitty's
    copy_and_clear_or_interrupt fires (Ctrl+C with a live selection),
    kitty writes the bytes straight to the X11 CLIPBOARD without
    going through `flashpaste-trigger --stage-text`. The daemon's
    in-memory staged_text stayed at whatever clipboard-set.sh last
    set it to, so every paste delivered the old text. Probe live
    X11; if it differs from the staged bytes, re-stage with the
    live text. Companion: `~/.config/kitty/kitty.conf` got
    `map ctrl+c copy_and_clear_or_interrupt` so the kitty side
    actually copies on Ctrl+C with a selection.

  * "What are we pasting?" payload telemetry (paste.rs +
    flashpaste-shoot/src/main.rs). The previous `dispatched image
    paste pane=%X` told you nothing about WHICH image. v1.27 emits
    `PASTED image pane=%X kind=image payload_bytes=N
    payload_mime=image/png payload_name=<basename> payload_path=…
    ms_*` — every dispatch now self-describes. Same shape on the
    shoot path: `ms_portal`, `ms_write`, `ms_annotate`, `ms_stage`
    so the screenshot pipeline's latency is broken down per phase.

Companion shell-side improvements (already in main):
  - `flashpaste-logs` got `[shot]`, `[clip]` (xclip-only by default
    to avoid the dock flash on Mutter), `[kitty]`, `[claude]`
    streams and `--all` shortcut.
  - `bin/clipboard-set.sh` mirrors text to xclip when daemon
    accepts a stage so the bash fallback dispatcher's `wl-paste
    --list-types` probe sees text (was seeing image/png from a
    stale prior screenshot).

No behaviour change for the existing fast paths. Daemon dispatch
latency stays at single-digit ms; the new pickup probe adds ~1 ms
when the screenshots dir is unchanged and ~5–20 ms when there's a
fresh file to read.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: NagyVikt

rs/flashpaste-shoot/src/main.rs

@@ -554,14 +554,28 @@ async fn main() -> Result<()> {
         return run_ocr_only_path().await;
     }
 
+    // Per-phase timing. Emitted as a single SHOT structured line at the
+    // end so the user can see exactly where the screenshot-to-ready time
+    // is going. User asked (2026-05-19): "can we measure the speed with
+    // a cli logs?" — so we always emit the summary, not gated on -v.
+    let t_start = std::time::Instant::now();
+    let mut t_phase = t_start;
+    let mut take_phase = || -> u64 {
+        let now = std::time::Instant::now();
+        let ms = now.duration_since(t_phase).as_millis() as u64;
+        t_phase = now;
+        ms
+    };
+
     // 1. Portal capture (with timeout).
     let portal_path = timeout(
         Duration::from_millis(cli.timeout_ms),
         take_portal_screenshot(cli.interactive),
     )
     .await
     .map_err(|_| anyhow!("portal screenshot timed out after {} ms", cli.timeout_ms))??;
-    info!(src = %portal_path.display(), "portal screenshot captured");
+    let ms_portal = take_phase();
+    info!(src = %portal_path.display(), ms_portal, "portal screenshot captured");
 
     // 2. Determine output path.
     let output_path: PathBuf = match cli.output {
@@ -573,33 +587,55 @@ async fn main() -> Result<()> {
             dir.join(format!("flashpaste-shoot-{}.png", unix_secs()))
         }
     };
+    let ms_outpath = take_phase();
 
     // 3. Stream bytes from portal temp file to output path. Sniff mime
     //    while we're at it.
     let mime = copy_with_sniff(&portal_path, &output_path)
         .context("copy portal output to destination")?;
-    info!(dst = %output_path.display(), mime = mime, "wrote screenshot");
+    let ms_write = take_phase();
+    info!(dst = %output_path.display(), mime = mime, ms_write, "wrote screenshot");
 
     // 4. Optional annotation pass. Runs BEFORE daemon stage so the
     //    daemon sees the annotated bytes, not the raw capture. Blocking
     //    by design — the user is in the editor and we want the final
     //    file before we tell anyone about it.
-    if cli.annotate {
+    let ms_annotate = if cli.annotate {
         if let Err(e) = run_annotate(&output_path) {
             warn!("annotate failed ({e:#}); proceeding with raw capture");
         }
-    }
+        take_phase()
+    } else {
+        take_phase()
+    };
 
     // 5. Best-effort daemon stage. The file is already on disk so even if
     //    this fails, auto-pickup in tmux-paste-dispatch.sh will find it.
-    if !cli.no_daemon {
+    let ms_daemon = if !cli.no_daemon {
         match try_stage_to_daemon(&output_path, mime).await {
             Ok(()) => info!("daemon stage ok"),
             Err(e) => warn!("daemon stage failed ({e:#}); file on disk is the fallback"),
         }
+        take_phase()
     } else {
         debug!("--no-daemon set; skipping daemon stage");
-    }
+        take_phase()
+    };
+
+    let ms_total = t_start.elapsed().as_millis() as u64;
+    // Single SHOT summary line. Goes to stderr (info!) so stdout stays
+    // clean for --print-path. Read with `journalctl --user --since="1
+    // minute ago" | grep SHOT` if running via systemd-launched keybind.
+    info!(
+        path = %output_path.display(),
+        ms_portal,
+        ms_outpath,
+        ms_write,
+        ms_annotate,
+        ms_daemon,
+        ms_total,
+        "SHOT"
+    );
 
     // 6. Optional OCR. Done AFTER daemon stage so we don't delay the
     //    clipboard becoming usable — OCR can take a few hundred ms even

rs/flashpasted/src/inotify_watch.rs

@@ -137,91 +137,128 @@ fn run_watcher(
                 continue;
             }
 
-            // Auto-compress before staging. The common case (small PNG
-            // from PrtScr) is a pure pass-through and is no more expensive
-            // than the previous `fs::read` — `compress_for_attach` stats
-            // first and only reads if it returns early. The big-screen
-            // case (4K multimon → 12 MB PNG) gets re-encoded to ~1 MB
-            // WebP. Env-vars `FLASHPASTE_MAX_BYTES` and `FLASHPASTE_MAX_DIM`
-            // tune the thresholds.
+            // ── Fast path: stage RAW bytes immediately, compress later.
             //
-            // If compression itself errors out we fall back to the raw
-            // file — staging *something* is better than staging nothing,
-            // and the user can still pick the file up via auto-pickup.
-            let (bytes, mime, staged_path) = match compress::compress_for_attach_env(&path) {
-                Ok((b, m)) if m == "image/png" || m == "image/jpeg" => {
-                    let mime = mime_for_string(&m);
-                    (b, mime, path.clone())
-                }
-                Ok((b, m)) => {
-                    // The compressor returned re-encoded bytes (likely
-                    // WebP). Write them to a sibling tmpfile so X11
-                    // selection requests (which serve from-disk in some
-                    // paths) and downstream tools that want a file path
-                    // both see the smaller artifact. The original PNG
-                    // is left in place — never destroy user data.
-                    let tmp = make_compressed_tmp_path(&path, &m);
-                    match std::fs::write(&tmp, &b) {
-                        Ok(()) => {
-                            info!(
-                                src = %path.display(),
-                                dst = %tmp.display(),
-                                bytes = b.len(),
-                                mime = %m,
-                                "wrote compressed sibling for staging"
-                            );
-                            let mime = mime_for_string(&m);
-                            (b, mime, tmp)
-                        }
-                        Err(e) => {
-                            warn!(
-                                path = %tmp.display(),
-                                error = %e,
-                                "failed to write compressed sibling — staging raw bytes from original path"
-                            );
-                            let mime = mime_for_string(&m);
-                            (b, mime, path.clone())
-                        }
-                    }
-                }
+            // User feedback (2026-05-19): "screenshot has big delay, can
+            // it be lightspeed fast?" — the synchronous compression call
+            // below (`compress_for_attach_env`) re-encodes 4K multimon
+            // PNGs (12 MB+) to WebP, which can take 500-2000ms on this
+            // box. During that window the daemon's staged_image slot
+            // still holds whatever was there before (often stale text),
+            // so a paste right after PrtScr delivers the OLD content.
+            //
+            // Fix: read raw bytes from disk, stage them right now (single
+            // file read, ~5-20ms), then kick off compression in a
+            // background spawn_blocking thread that re-stages with the
+            // smaller artifact once it's ready. The brief window where
+            // we serve raw bytes is fine — X11 SelectionRequest serves
+            // from our in-memory buffer regardless of size.
+            let raw_bytes = match std::fs::read(&path) {
+                Ok(b) => b,
                 Err(e) => {
-                    warn!(
-                        path = %path.display(),
-                        error = ?e,
-                        "compress_for_attach failed — falling back to raw read"
-                    );
-                    match std::fs::read(&path) {
-                        Ok(b) => (b, mime_for(&path), path.clone()),
-                        Err(e2) => {
-                            warn!(
-                                path = %path.display(),
-                                error = %e2,
-                                "failed to read new screenshot"
-                            );
-                            continue;
-                        }
-                    }
+                    warn!(path = %path.display(), error = %e, "failed to read new screenshot — skipping stage");
+                    continue;
                 }
             };
-            let len = bytes.len();
-            let staged = StagedImage {
-                bytes: Arc::new(bytes),
-                mime,
-                path: staged_path,
+            let raw_len = raw_bytes.len();
+            let raw_mime = mime_for(&path);
+            let staged_raw = StagedImage {
+                bytes: Arc::new(raw_bytes),
+                mime: raw_mime,
+                path: path.clone(),
                 captured_at: SystemTime::now(),
             };
-            // Cross thread back into tokio for the write. block_on inside
-            // spawn_blocking is fine — we're not on a worker.
-            let state_clone = state.clone();
-            handle.block_on(async move {
-                state_clone.set_staged_image(staged).await;
-            });
+            {
+                let state_clone = state.clone();
+                handle.block_on(async move {
+                    state_clone.set_staged_image(staged_raw).await;
+                });
+            }
             info!(
                 path = %path.display(),
-                bytes = len,
-                mime = mime,
-                "staged screenshot from inotify"
+                bytes = raw_len,
+                mime = raw_mime,
+                "staged screenshot from inotify (raw, pre-compress)"
             );
+
+            // Now spawn the compression on a separate blocking thread so
+            // the inotify loop can immediately serve the next event. If
+            // compression produces smaller bytes, re-stage. If it errors
+            // or produces the same bytes, leave the raw stage in place.
+            let path_for_compress = path.clone();
+            let state_for_compress = state.clone();
+            let handle_for_compress = handle.clone();
+            std::thread::spawn(move || {
+                let result = compress::compress_for_attach_env(&path_for_compress);
+                // Reuse the original compression decision tree but only
+                // *replace* the stage if it actually wins on bytes — never
+                // regress from a smaller raw to a larger compressed result.
+                let compressed: Option<(Vec<u8>, &'static str, std::path::PathBuf)> = match result {
+                    Ok((b, m)) if m == "image/png" || m == "image/jpeg" => {
+                        // Pass-through (no real compression happened, or
+                        // shape was already acceptable). Only re-stage
+                        // if bytes actually shrank — otherwise the raw
+                        // stage we did synchronously above is better.
+                        if b.len() < raw_len {
+                            Some((b, mime_for_string(&m), path_for_compress.clone()))
+                        } else {
+                            None
+                        }
+                    }
+                    Ok((b, m)) => {
+                        // Re-encoded (likely WebP). Write sibling tmpfile.
+                        let tmp = make_compressed_tmp_path(&path_for_compress, &m);
+                        match std::fs::write(&tmp, &b) {
+                            Ok(()) => {
+                                info!(
+                                    src = %path_for_compress.display(),
+                                    dst = %tmp.display(),
+                                    bytes = b.len(),
+                                    mime = %m,
+                                    "wrote compressed sibling for staging"
+                                );
+                                Some((b, mime_for_string(&m), tmp))
+                            }
+                            Err(e) => {
+                                warn!(
+                                    path = %tmp.display(),
+                                    error = %e,
+                                    "failed to write compressed sibling — keeping raw stage"
+                                );
+                                None
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        warn!(
+                            path = %path_for_compress.display(),
+                            error = ?e,
+                            "compress_for_attach failed — keeping raw stage"
+                        );
+                        None
+                    }
+                };
+
+                if let Some((bytes, mime, staged_path)) = compressed {
+                    let len = bytes.len();
+                    let staged = StagedImage {
+                        bytes: Arc::new(bytes),
+                        mime,
+                        path: staged_path,
+                        captured_at: SystemTime::now(),
+                    };
+                    handle_for_compress.block_on(async move {
+                        state_for_compress.set_staged_image(staged).await;
+                    });
+                    info!(
+                        path = %path_for_compress.display(),
+                        bytes = len,
+                        mime = mime,
+                        raw_bytes = raw_len,
+                        "re-staged screenshot after background compression"
+                    );
+                }
+            });
         }
     }
 }