From 5075a84d18c324c1fc0597dec191e6d102cff80c Mon Sep 17 00:00:00 2001
From: rgdevment <mhidalgorg@gmail.com>
Date: Tue, 6 Oct 2026 02:31:10 -0300
Subject: [PATCH 1/3] fix(macos): panel takes typing and hides on leave,
 settings use native traffic lights, Ctrl+Alt+V by default

---
 .github/ISSUE_TEMPLATE/bug_report.yml  |  2 +-
 README.md                              |  4 +-
 app/src-tauri/src/keys.rs              |  6 +--
 app/src-tauri/src/tray.rs              | 50 +++++++++++++++++++++----
 app/src/index.css                      | 50 +------------------------
 app/src/ui/Chrome.tsx                  |  3 +-
 crates/cp-config/src/lib.rs            | 10 +++--
 crates/cp-config/src/lib_test.rs       | 20 ++++++++++
 crates/cp-mac-sys/src/activation.rs    |  3 +-
 crates/cp-mac-sys/src/floating.rs      | 51 ++++++++++++++++++++++++++
 crates/cp-mac-sys/src/floating_test.rs | 39 ++++++++++++++++++++
 crates/cp-mac-sys/src/lib.rs           |  2 +
 crates/cp-mac-sys/src/titlebar.rs      | 20 ++++++++++
 crates/cp-mac-sys/src/titlebar_test.rs | 39 ++++++++++++++++++++
 crates/cp-panel/src/here.rs            |  9 ++++-
 15 files changed, 239 insertions(+), 69 deletions(-)
 create mode 100644 crates/cp-mac-sys/src/floating.rs
 create mode 100644 crates/cp-mac-sys/src/floating_test.rs
 create mode 100644 crates/cp-mac-sys/src/titlebar.rs
 create mode 100644 crates/cp-mac-sys/src/titlebar_test.rs

diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index bf191b21..85c548c0 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -69,7 +69,7 @@ body:
       description: "Name the application you copied from or pasted into: most clipboard bugs belong to one pair of them."
       placeholder: |
         1. Copy an image from Firefox
-        2. Open the panel with Ctrl+Alt+V (⌥⌘V on a Mac)
+        2. Open the panel with Ctrl+Alt+V (⌃⌥V on a Mac)
         3. Press Enter on the image
         4. It pastes as text in Word
     validations:
diff --git a/README.md b/README.md
index 93227d50..c3f012e6 100644
--- a/README.md
+++ b/README.md
@@ -248,7 +248,7 @@ keyboard does not have are replaced by the ones it does.
 | Where | Windows | macOS | Action |
 | :---- | :------ | :---- | :----- |
 | App you're in | Ctrl+V | ⌘V | Normal paste. CopyPaste does not intercept it. |
-| Anywhere | Ctrl+Alt+V | ⌥⌘V | Open the panel. Change it in Settings → Keyboard shortcuts; if another program already uses it, free alternatives are offered. |
+| Anywhere | Ctrl+Alt+V | ⌃⌥V | Open the panel. Change it in Settings → Keyboard shortcuts; if another program already uses it, free alternatives are offered. |
 | Panel | Enter | ⏎ | Paste the selected item. |
 | Panel | Shift + Enter | ⇧⏎ | Paste as plain text. |
 | Panel | Alt + Enter  ·  Ctrl + Enter | ⌥⏎  ·  ⌘⏎ | Open or close "Paste as…". |
@@ -339,7 +339,7 @@ emptying the history.
 | **Windows** | Microsoft Store                   | Standalone `.exe` · winget (coming soon)           |
 | **macOS**   | Homebrew                          | Standalone `.dmg`                                  |
 
-After installing, open the panel with **Ctrl+Alt+V** on Windows or **⌥⌘V** on a
+After installing, open the panel with **Ctrl+Alt+V** on Windows or **⌃⌥V** on a
 Mac. Both are customizable in Settings → Keyboard shortcuts, and the first run
 walks you through it.
 
diff --git a/app/src-tauri/src/keys.rs b/app/src-tauri/src/keys.rs
index 6ceca8f0..d091ded0 100644
--- a/app/src-tauri/src/keys.rs
+++ b/app/src-tauri/src/keys.rs
@@ -48,12 +48,10 @@ fn remember<R: Runtime>(app: &AppHandle<R>, said: Option<&str>) {
 
 #[cfg(target_os = "macos")]
 pub const SPARE: &[&str] = &[
-    "Alt+Cmd+V",
+    "Ctrl+Alt+V",
     "Shift+Cmd+V",
-    "Alt+Cmd+C",
+    "Ctrl+Shift+V",
     "Shift+Cmd+Space",
-    "Ctrl+Alt+V",
-    "Alt+Cmd+Space",
 ];
 #[cfg(not(target_os = "macos"))]
 pub const SPARE: &[&str] = &[
diff --git a/app/src-tauri/src/tray.rs b/app/src-tauri/src/tray.rs
index 0d78d550..4c8ac909 100644
--- a/app/src-tauri/src/tray.rs
+++ b/app/src-tauri/src/tray.rs
@@ -136,18 +136,54 @@ pub fn surface_at<R: Runtime>(app: &AppHandle<R>, rail: Option<&str>) {
     let page = rail.map_or(WebviewUrl::default(), |rail| {
         WebviewUrl::App(format!("index.html#{rail}").into())
     });
-    let built = WebviewWindowBuilder::new(app, "main", page)
-        .title("CopyPaste")
-        .inner_size(780.0, 580.0)
-        .min_inner_size(620.0, 460.0)
-        .decorations(false)
-        .center()
-        .build();
+    let built = framed(
+        WebviewWindowBuilder::new(app, "main", page)
+            .title("CopyPaste")
+            .inner_size(780.0, 580.0)
+            .min_inner_size(620.0, 460.0)
+            .center(),
+    )
+    .build();
     if let Ok(window) = built {
+        unzoomed(&window);
         ahead(&window);
     }
 }
 
+#[cfg(target_os = "macos")]
+fn unzoomed<R: Runtime>(window: &tauri::WebviewWindow<R>) {
+    let Ok(ns_window) = window.ns_window() else {
+        return;
+    };
+    let at = ns_window as usize;
+    let _ = window.run_on_main_thread(move || {
+        if let Some(ns_window) = std::ptr::NonNull::new(at as *mut std::ffi::c_void) {
+            cp_mac_sys::titlebar::without_zoom(ns_window);
+        }
+    });
+}
+
+#[cfg(not(target_os = "macos"))]
+fn unzoomed<R: Runtime>(_window: &tauri::WebviewWindow<R>) {}
+
+#[cfg(target_os = "macos")]
+fn framed<'a, R: Runtime, M: Manager<R>>(
+    builder: WebviewWindowBuilder<'a, R, M>,
+) -> WebviewWindowBuilder<'a, R, M> {
+    builder
+        .title_bar_style(tauri::TitleBarStyle::Overlay)
+        .hidden_title(true)
+        .maximizable(false)
+        .traffic_light_position(tauri::LogicalPosition::new(14.0, 17.0))
+}
+
+#[cfg(not(target_os = "macos"))]
+fn framed<'a, R: Runtime, M: Manager<R>>(
+    builder: WebviewWindowBuilder<'a, R, M>,
+) -> WebviewWindowBuilder<'a, R, M> {
+    builder.decorations(false)
+}
+
 fn ahead<R: Runtime>(window: &tauri::WebviewWindow<R>) {
     let was = window.is_always_on_top().unwrap_or(false);
     let _ = window.set_always_on_top(true);
diff --git a/app/src/index.css b/app/src/index.css
index f84f681a..196ff7f6 100644
--- a/app/src/index.css
+++ b/app/src/index.css
@@ -157,61 +157,15 @@ body {
 }
 
 .chrome.mac {
-  padding-left: 0;
+  padding-left: 64px;
   padding-right: 13px;
 }
 
-/* on a Mac the left inset comes from the knobs, so a window without them needs its own */
+/* on a Mac the left inset leaves room for the system's traffic lights, so a window without them needs its own */
 .chrome.mac.bare {
   padding-left: 13px;
 }
 
-.chrome.mac .chrome-does {
-  order: -1;
-  flex-direction: row-reverse;
-  align-items: center;
-  gap: 8px;
-  height: auto;
-  padding: 0 8px 0 13px;
-}
-
-.chrome.mac .chrome-knob {
-  width: 12px;
-  height: 12px;
-  border-radius: 50%;
-  background: var(--hair);
-}
-
-.chrome.mac .chrome-knob svg {
-  width: 8px;
-  height: 8px;
-  opacity: 0;
-  stroke: rgba(0, 0, 0, 0.55);
-  stroke-width: 1.4;
-}
-
-.chrome.mac .chrome-knob.shut {
-  background: #ff5f57;
-}
-
-.chrome.mac .chrome-knob:not(.shut) {
-  background: #febc2e;
-}
-
-.chrome.mac .chrome-does:hover .chrome-knob svg {
-  opacity: 1;
-}
-
-.chrome.mac .chrome-knob:hover,
-.chrome.mac .chrome-knob.shut:hover {
-  background: inherit;
-}
-
-.chrome.mac .chrome-knob:hover svg,
-.chrome.mac .chrome-knob.shut:hover svg {
-  stroke: rgba(0, 0, 0, 0.55);
-}
-
 .shell {
   display: grid;
   grid-template-columns: 186px minmax(0, 1fr);
diff --git a/app/src/ui/Chrome.tsx b/app/src/ui/Chrome.tsx
index 32555b9d..1e052167 100644
--- a/app/src/ui/Chrome.tsx
+++ b/app/src/ui/Chrome.tsx
@@ -8,13 +8,14 @@ export default function Chrome({ knobs = true }: { knobs?: boolean }) {
   held.current ??= getCurrentWindow();
   const win = held.current;
   const mac = onMac();
+  const drawn = knobs && !mac;
 
   return (
     <div className={`chrome${mac ? " mac" : ""}${knobs ? "" : " bare"}`} data-tauri-drag-region>
       <span className="chrome-who" data-tauri-drag-region>
         CopyPaste
       </span>
-      {knobs && (
+      {drawn && (
         <div className="chrome-does">
           <button
             type="button"
diff --git a/crates/cp-config/src/lib.rs b/crates/cp-config/src/lib.rs
index f75bb509..a21bde0b 100644
--- a/crates/cp-config/src/lib.rs
+++ b/crates/cp-config/src/lib.rs
@@ -5,11 +5,11 @@ use std::sync::atomic::{AtomicU64, Ordering};
 
 pub const FILE: &str = "config.toml";
 
-#[cfg(target_os = "macos")]
-pub const SHORTCUT: &str = "Cmd+Alt+V";
-#[cfg(not(target_os = "macos"))]
 pub const SHORTCUT: &str = "Ctrl+Alt+V";
 
+#[cfg(target_os = "macos")]
+const FORMER_SHORTCUT: &str = "Cmd+Alt+V";
+
 pub const KEEPS_DAYS: u16 = 30;
 
 #[derive(Debug, thiserror::Error)]
@@ -90,6 +90,10 @@ impl Config {
             self.shortcut = SHORTCUT.to_owned();
         }
         self.shortcut = self.shortcut.trim().to_owned();
+        #[cfg(target_os = "macos")]
+        if self.shortcut == FORMER_SHORTCUT {
+            self.shortcut = SHORTCUT.to_owned();
+        }
         if self.keeps_days == Some(0) {
             self.keeps_days = None;
         }
diff --git a/crates/cp-config/src/lib_test.rs b/crates/cp-config/src/lib_test.rs
index 7492e617..84b89626 100644
--- a/crates/cp-config/src/lib_test.rs
+++ b/crates/cp-config/src/lib_test.rs
@@ -332,3 +332,23 @@ fn a_blank_welcome_is_no_welcome() {
     .sane();
     assert_eq!(kept.welcomed.as_deref(), Some("3.0.1"));
 }
+
+#[cfg(target_os = "macos")]
+#[test]
+fn the_old_mac_default_moves_to_the_one_handed_one_when_read() {
+    let dir = a_dir();
+    let path = at(dir.path());
+    std::fs::write(&path, "shortcut = \"Cmd+Alt+V\"\n").expect("writes");
+    assert_eq!(read(&path).expect("reads").shortcut, SHORTCUT);
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn a_command_option_v_picked_by_hand_is_left_alone() {
+    let asked = Config {
+        shortcut: "Alt+Cmd+V".into(),
+        ..Config::default()
+    }
+    .sane();
+    assert_eq!(asked.shortcut, "Alt+Cmd+V");
+}
diff --git a/crates/cp-mac-sys/src/activation.rs b/crates/cp-mac-sys/src/activation.rs
index b3f5e912..b3e859c1 100644
--- a/crates/cp-mac-sys/src/activation.rs
+++ b/crates/cp-mac-sys/src/activation.rs
@@ -11,7 +11,8 @@ pub fn as_accessory() -> bool {
 
 pub fn is_ours_up_front() -> Option<bool> {
     let mtm = MainThreadMarker::new()?;
-    Some(NSApplication::sharedApplication(mtm).isActive())
+    let app = NSApplication::sharedApplication(mtm);
+    Some(app.isActive() || app.keyWindow().is_some())
 }
 
 pub fn is_accessory() -> Option<bool> {
diff --git a/crates/cp-mac-sys/src/floating.rs b/crates/cp-mac-sys/src/floating.rs
new file mode 100644
index 00000000..7aef7bbc
--- /dev/null
+++ b/crates/cp-mac-sys/src/floating.rs
@@ -0,0 +1,51 @@
+use objc2::runtime::AnyObject;
+use objc2::{ClassType, MainThreadOnly, define_class};
+use objc2_app_kit::{NSPanel, NSResponder, NSView, NSWindow, NSWindowStyleMask};
+use objc2_foundation::{MainThreadMarker, NSObject, NSObjectProtocol};
+use std::ffi::c_void;
+use std::ptr::NonNull;
+
+define_class!(
+    #[unsafe(super(NSPanel, NSWindow, NSResponder, NSObject))]
+    #[thread_kind = MainThreadOnly]
+    #[name = "CopyPastePanel"]
+    pub struct Floating;
+
+    impl Floating {
+        #[unsafe(method(canBecomeKeyWindow))]
+        fn can_become_key(&self) -> bool {
+            true
+        }
+
+        #[unsafe(method(canBecomeMainWindow))]
+        fn can_become_main(&self) -> bool {
+            false
+        }
+    }
+);
+
+pub fn keys_without_activating(ns_view: NonNull<c_void>) -> bool {
+    if MainThreadMarker::new().is_none() {
+        return false;
+    }
+    let view: &NSView = unsafe { ns_view.cast::<NSView>().as_ref() };
+    let Some(window) = view.window() else {
+        return false;
+    };
+    if !window.isKindOfClass(Floating::class()) {
+        floats(&window);
+    }
+    window.makeKeyAndOrderFront(None);
+    window.isKeyWindow()
+}
+
+fn floats(window: &NSWindow) {
+    let object: &AnyObject = window.as_ref();
+    unsafe { AnyObject::set_class(object, Floating::class()) };
+    window.setStyleMask(window.styleMask() | NSWindowStyleMask::NonactivatingPanel);
+    window.setHidesOnDeactivate(false);
+}
+
+#[cfg(test)]
+#[path = "floating_test.rs"]
+mod tests;
diff --git a/crates/cp-mac-sys/src/floating_test.rs b/crates/cp-mac-sys/src/floating_test.rs
new file mode 100644
index 00000000..4f552b0d
--- /dev/null
+++ b/crates/cp-mac-sys/src/floating_test.rs
@@ -0,0 +1,39 @@
+use super::*;
+use objc2_app_kit::NSBackingStoreType;
+use objc2_foundation::{NSPoint, NSRect, NSSize};
+
+#[test]
+fn off_the_main_thread_it_refuses_before_it_looks_at_the_view() {
+    if MainThreadMarker::new().is_some() {
+        return;
+    }
+    assert!(!keys_without_activating(NonNull::dangling()));
+}
+
+#[test]
+fn a_plain_window_becomes_a_panel_that_never_activates_the_app() {
+    let Some(mtm) = MainThreadMarker::new() else {
+        return;
+    };
+    let window = unsafe {
+        NSWindow::initWithContentRect_styleMask_backing_defer(
+            NSWindow::alloc(mtm),
+            NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(40.0, 40.0)),
+            NSWindowStyleMask::Borderless,
+            NSBackingStoreType::Buffered,
+            false,
+        )
+    };
+    let view = window
+        .contentView()
+        .expect("a window always has a content view");
+    keys_without_activating(NonNull::from(&*view).cast());
+    assert!(window.isKindOfClass(Floating::class()));
+    assert!(
+        window
+            .styleMask()
+            .contains(NSWindowStyleMask::NonactivatingPanel)
+    );
+    assert!(!window.hidesOnDeactivate());
+    window.orderOut(None);
+}
diff --git a/crates/cp-mac-sys/src/lib.rs b/crates/cp-mac-sys/src/lib.rs
index 5ee1a3d9..8f80b903 100644
--- a/crates/cp-mac-sys/src/lib.rs
+++ b/crates/cp-mac-sys/src/lib.rs
@@ -4,6 +4,7 @@ pub mod activation;
 pub mod clock;
 pub mod dragging;
 pub mod files;
+pub mod floating;
 pub mod frontmost;
 pub mod keyboard;
 pub mod keystroke;
@@ -16,3 +17,4 @@ pub mod permissions;
 pub mod processes;
 pub mod runloop;
 pub mod theme;
+pub mod titlebar;
diff --git a/crates/cp-mac-sys/src/titlebar.rs b/crates/cp-mac-sys/src/titlebar.rs
new file mode 100644
index 00000000..d8f52b1d
--- /dev/null
+++ b/crates/cp-mac-sys/src/titlebar.rs
@@ -0,0 +1,20 @@
+use objc2_app_kit::{NSWindow, NSWindowButton};
+use objc2_foundation::MainThreadMarker;
+use std::ffi::c_void;
+use std::ptr::NonNull;
+
+pub fn without_zoom(ns_window: NonNull<c_void>) -> bool {
+    if MainThreadMarker::new().is_none() {
+        return false;
+    }
+    let window: &NSWindow = unsafe { ns_window.cast::<NSWindow>().as_ref() };
+    let Some(zoom) = window.standardWindowButton(NSWindowButton::ZoomButton) else {
+        return false;
+    };
+    zoom.setHidden(true);
+    true
+}
+
+#[cfg(test)]
+#[path = "titlebar_test.rs"]
+mod tests;
diff --git a/crates/cp-mac-sys/src/titlebar_test.rs b/crates/cp-mac-sys/src/titlebar_test.rs
new file mode 100644
index 00000000..6aa631d4
--- /dev/null
+++ b/crates/cp-mac-sys/src/titlebar_test.rs
@@ -0,0 +1,39 @@
+use super::*;
+use objc2::MainThreadOnly;
+use objc2_app_kit::{NSBackingStoreType, NSWindowStyleMask};
+use objc2_foundation::{NSPoint, NSRect, NSSize};
+
+#[test]
+fn off_the_main_thread_it_refuses_before_it_looks_at_the_window() {
+    if MainThreadMarker::new().is_some() {
+        return;
+    }
+    assert!(!without_zoom(NonNull::dangling()));
+}
+
+#[test]
+fn a_titled_window_keeps_close_and_minimise_but_loses_zoom() {
+    let Some(mtm) = MainThreadMarker::new() else {
+        return;
+    };
+    let window = unsafe {
+        NSWindow::initWithContentRect_styleMask_backing_defer(
+            NSWindow::alloc(mtm),
+            NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(200.0, 120.0)),
+            NSWindowStyleMask::Titled
+                | NSWindowStyleMask::Closable
+                | NSWindowStyleMask::Miniaturizable,
+            NSBackingStoreType::Buffered,
+            false,
+        )
+    };
+    assert!(without_zoom(NonNull::from(&*window).cast()));
+    let zoom = window
+        .standardWindowButton(NSWindowButton::ZoomButton)
+        .expect("a titled window has a zoom button");
+    assert!(zoom.isHidden());
+    let close = window
+        .standardWindowButton(NSWindowButton::CloseButton)
+        .expect("a titled window has a close button");
+    assert!(!close.isHidden());
+}
diff --git a/crates/cp-panel/src/here.rs b/crates/cp-panel/src/here.rs
index 2099b432..2a43cc0a 100644
--- a/crates/cp-panel/src/here.rs
+++ b/crates/cp-panel/src/here.rs
@@ -318,8 +318,13 @@ mod platform {
 
     pub fn dress(_handle: RawWindowHandle, _wanted: &str, _light: bool) {}
 
-    pub fn forward(_handle: RawWindowHandle) {
-        cp_mac_sys::frontmost::bring_to_front(cp_mac_sys::frontmost::our_pid());
+    pub fn forward(handle: RawWindowHandle) {
+        let RawWindowHandle::AppKit(appkit) = handle else {
+            return;
+        };
+        if !cp_mac_sys::floating::keys_without_activating(appkit.ns_view) {
+            cp_mac_sys::frontmost::bring_to_front(cp_mac_sys::frontmost::our_pid());
+        }
     }
 
     pub use cp_mac_sys::dragging::Dragged;

From 09edb9520d5c2f6750aa1c26ce8b3be497048415 Mon Sep 17 00:00:00 2001
From: rgdevment <mhidalgorg@gmail.com>
Date: Tue, 6 Oct 2026 03:54:15 -0300
Subject: [PATCH 2/3] fix(macos): pasting no longer crashes the panel and the
 panel closes cleanly after taking the keys

---
 app/src-tauri/src/tray.rs               |   8 +-
 crates/cp-mac-sys/src/floating.rs       | 136 +++++++++++--
 crates/cp-mac-sys/src/floating_test.rs  |  69 ++++---
 crates/cp-mac-sys/src/titlebar.rs       |  44 +++-
 crates/cp-mac-sys/src/titlebar_test.rs  |  30 +--
 crates/cp-mac/examples/mac_probe.rs     |   3 +
 crates/cp-mac/examples/probe/battery.rs |   2 +
 crates/cp-mac/examples/probe/panel.rs   |  76 +++++++
 crates/cp-mac/src/paste.rs              | 167 +++++++++++-----
 crates/cp-mac/src/paste_test.rs         | 254 ++++++++++++++++++++++++
 crates/cp-panel/src/app.rs              |  49 +++--
 crates/cp-panel/src/here.rs             |  50 ++++-
 crates/cp-panel/src/here_test.rs        | 144 +++++++++++++-
 13 files changed, 879 insertions(+), 153 deletions(-)
 create mode 100644 crates/cp-mac/examples/probe/panel.rs

diff --git a/app/src-tauri/src/tray.rs b/app/src-tauri/src/tray.rs
index 4c8ac909..3fbe2ad9 100644
--- a/app/src-tauri/src/tray.rs
+++ b/app/src-tauri/src/tray.rs
@@ -152,12 +152,8 @@ pub fn surface_at<R: Runtime>(app: &AppHandle<R>, rail: Option<&str>) {
 
 #[cfg(target_os = "macos")]
 fn unzoomed<R: Runtime>(window: &tauri::WebviewWindow<R>) {
-    let Ok(ns_window) = window.ns_window() else {
-        return;
-    };
-    let at = ns_window as usize;
-    let _ = window.run_on_main_thread(move || {
-        if let Some(ns_window) = std::ptr::NonNull::new(at as *mut std::ffi::c_void) {
+    let _ = window.with_webview(|webview| {
+        if let Some(ns_window) = std::ptr::NonNull::new(webview.ns_window()) {
             cp_mac_sys::titlebar::without_zoom(ns_window);
         }
     });
diff --git a/crates/cp-mac-sys/src/floating.rs b/crates/cp-mac-sys/src/floating.rs
index 7aef7bbc..3a5f4528 100644
--- a/crates/cp-mac-sys/src/floating.rs
+++ b/crates/cp-mac-sys/src/floating.rs
@@ -1,7 +1,15 @@
-use objc2::runtime::AnyObject;
-use objc2::{ClassType, MainThreadOnly, define_class};
-use objc2_app_kit::{NSPanel, NSResponder, NSView, NSWindow, NSWindowStyleMask};
-use objc2_foundation::{MainThreadMarker, NSObject, NSObjectProtocol};
+use objc2::rc::Retained;
+use objc2::runtime::{AnyClass, AnyObject};
+use objc2::{ClassType, MainThreadOnly, define_class, msg_send};
+use objc2_app_kit::{
+    NSBackingStoreType, NSPanel, NSResponder, NSView, NSWindow, NSWindowCollectionBehavior,
+    NSWindowStyleMask,
+};
+use objc2_foundation::{
+    MainThreadMarker, NSKeyValueObservingOptions, NSObject, NSObjectNSKeyValueObserverRegistration,
+    NSObjectProtocol, NSPoint, NSRect, NSSize, NSString,
+};
+use std::cell::Cell;
 use std::ffi::c_void;
 use std::ptr::NonNull;
 
@@ -9,21 +17,50 @@ define_class!(
     #[unsafe(super(NSPanel, NSWindow, NSResponder, NSObject))]
     #[thread_kind = MainThreadOnly]
     #[name = "CopyPastePanel"]
-    pub struct Floating;
+    struct Floating;
 
     impl Floating {
         #[unsafe(method(canBecomeKeyWindow))]
         fn can_become_key(&self) -> bool {
             true
         }
+    }
+);
+
+define_class!(
+    #[unsafe(super(NSObject))]
+    #[thread_kind = MainThreadOnly]
+    #[name = "CopyPastePanelLooker"]
+    struct Looker;
 
-        #[unsafe(method(canBecomeMainWindow))]
-        fn can_become_main(&self) -> bool {
-            false
+    impl Looker {
+        #[unsafe(method(observeValueForKeyPath:ofObject:change:context:))]
+        fn looked(
+            &self,
+            _path: Option<&NSString>,
+            _of: Option<&AnyObject>,
+            _change: Option<&AnyObject>,
+            _context: *mut c_void,
+        ) {
         }
     }
 );
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Floated {
+    pub became_a_panel: bool,
+    pub never_activates: bool,
+    pub joins_full_screen: bool,
+    pub follows_the_space: bool,
+    pub took_the_keys: bool,
+    pub counts_as_ours: bool,
+    pub back_as_it_was: bool,
+}
+
+thread_local! {
+    static WAS: Cell<Option<&'static AnyClass>> = const { Cell::new(None) };
+}
+
 pub fn keys_without_activating(ns_view: NonNull<c_void>) -> bool {
     if MainThreadMarker::new().is_none() {
         return false;
@@ -32,18 +69,93 @@ pub fn keys_without_activating(ns_view: NonNull<c_void>) -> bool {
     let Some(window) = view.window() else {
         return false;
     };
-    if !window.isKindOfClass(Floating::class()) {
-        floats(&window);
+    if !window.isKindOfClass(Floating::class()) && !floats(&window) {
+        return false;
     }
     window.makeKeyAndOrderFront(None);
     window.isKeyWindow()
 }
 
-fn floats(window: &NSWindow) {
+fn floats(window: &NSWindow) -> bool {
     let object: &AnyObject = window.as_ref();
+    if !fits(Floating::class(), object.class()) {
+        return false;
+    }
+    WAS.with(|was| was.set(Some(object.class())));
     unsafe { AnyObject::set_class(object, Floating::class()) };
     window.setStyleMask(window.styleMask() | NSWindowStyleMask::NonactivatingPanel);
-    window.setHidesOnDeactivate(false);
+    window.setCollectionBehavior(
+        window.collectionBehavior()
+            | NSWindowCollectionBehavior::MoveToActiveSpace
+            | NSWindowCollectionBehavior::FullScreenAuxiliary,
+    );
+    true
+}
+
+fn fits(panel: &AnyClass, window: &AnyClass) -> bool {
+    panel.instance_size() <= window.instance_size()
+}
+
+pub fn grounded(ns_view: NonNull<c_void>) -> bool {
+    if MainThreadMarker::new().is_none() {
+        return false;
+    }
+    let view: &NSView = unsafe { ns_view.cast::<NSView>().as_ref() };
+    let Some(window) = view.window() else {
+        return false;
+    };
+    let Some(was) = WAS.with(Cell::get) else {
+        return false;
+    };
+    if !window.isKindOfClass(Floating::class()) {
+        return false;
+    }
+    let object: &AnyObject = window.as_ref();
+    unsafe { AnyObject::set_class(object, was) };
+    true
+}
+
+pub fn a_panel_would_float() -> Option<Floated> {
+    let mtm = MainThreadMarker::new()?;
+    let window = unsafe {
+        NSWindow::initWithContentRect_styleMask_backing_defer(
+            NSWindow::alloc(mtm),
+            NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(40.0, 40.0)),
+            NSWindowStyleMask::Borderless,
+            NSBackingStoreType::Buffered,
+            false,
+        )
+    };
+    unsafe { window.setReleasedWhenClosed(false) };
+    let looker: Retained<Looker> = unsafe { msg_send![Looker::alloc(mtm), init] };
+    let looked = NSString::from_str("effectiveAppearance");
+    unsafe {
+        window.addObserver_forKeyPath_options_context(
+            &looker,
+            &looked,
+            NSKeyValueObservingOptions::New,
+            std::ptr::null_mut(),
+        );
+    }
+    let view = window.contentView()?;
+    let at = NonNull::from(&*view).cast();
+    let took_the_keys = keys_without_activating(at);
+    let behaviour = window.collectionBehavior();
+    let floated = Floated {
+        became_a_panel: window.isKindOfClass(Floating::class()),
+        never_activates: window
+            .styleMask()
+            .contains(NSWindowStyleMask::NonactivatingPanel),
+        joins_full_screen: behaviour.contains(NSWindowCollectionBehavior::FullScreenAuxiliary),
+        follows_the_space: behaviour.contains(NSWindowCollectionBehavior::MoveToActiveSpace),
+        took_the_keys,
+        counts_as_ours: crate::activation::is_ours_up_front() == Some(true),
+        back_as_it_was: grounded(at) && !window.isKindOfClass(Floating::class()),
+    };
+    window.orderOut(None);
+    unsafe { window.removeObserver_forKeyPath(&looker, &looked) };
+    window.close();
+    Some(floated)
 }
 
 #[cfg(test)]
diff --git a/crates/cp-mac-sys/src/floating_test.rs b/crates/cp-mac-sys/src/floating_test.rs
index 4f552b0d..d6db2082 100644
--- a/crates/cp-mac-sys/src/floating_test.rs
+++ b/crates/cp-mac-sys/src/floating_test.rs
@@ -1,6 +1,4 @@
 use super::*;
-use objc2_app_kit::NSBackingStoreType;
-use objc2_foundation::{NSPoint, NSRect, NSSize};
 
 #[test]
 fn off_the_main_thread_it_refuses_before_it_looks_at_the_view() {
@@ -11,29 +9,48 @@ fn off_the_main_thread_it_refuses_before_it_looks_at_the_view() {
 }
 
 #[test]
-fn a_plain_window_becomes_a_panel_that_never_activates_the_app() {
-    let Some(mtm) = MainThreadMarker::new() else {
+fn off_the_main_thread_nothing_is_put_back() {
+    if MainThreadMarker::new().is_some() {
+        return;
+    }
+    assert!(!grounded(NonNull::dangling()));
+}
+
+#[test]
+fn off_the_main_thread_the_probe_has_nothing_to_say() {
+    if MainThreadMarker::new().is_some() {
         return;
-    };
-    let window = unsafe {
-        NSWindow::initWithContentRect_styleMask_backing_defer(
-            NSWindow::alloc(mtm),
-            NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(40.0, 40.0)),
-            NSWindowStyleMask::Borderless,
-            NSBackingStoreType::Buffered,
-            false,
-        )
-    };
-    let view = window
-        .contentView()
-        .expect("a window always has a content view");
-    keys_without_activating(NonNull::from(&*view).cast());
-    assert!(window.isKindOfClass(Floating::class()));
-    assert!(
-        window
-            .styleMask()
-            .contains(NSWindowStyleMask::NonactivatingPanel)
-    );
-    assert!(!window.hidesOnDeactivate());
-    window.orderOut(None);
+    }
+    assert_eq!(a_panel_would_float(), None);
+}
+
+#[test]
+fn the_panel_fits_inside_a_plain_window() {
+    assert!(fits(Floating::class(), NSWindow::class()));
+}
+
+#[test]
+fn a_panel_of_the_system_is_the_same_size_as_a_window() {
+    assert!(fits(NSPanel::class(), NSWindow::class()));
+    assert!(fits(NSWindow::class(), NSPanel::class()));
+}
+
+#[test]
+fn a_class_bigger_than_the_window_is_never_swapped_in() {
+    assert!(!fits(NSWindow::class(), NSObject::class()));
+}
+
+#[test]
+fn a_smaller_class_fits_in_a_bigger_one() {
+    assert!(fits(NSObject::class(), NSWindow::class()));
+}
+
+#[test]
+fn the_panel_is_a_panel_of_the_system() {
+    assert!(Floating::class().superclass() == Some(NSPanel::class()));
+}
+
+#[test]
+fn nothing_was_swapped_on_a_thread_that_never_floated_a_window() {
+    assert_eq!(WAS.with(Cell::get), None);
 }
diff --git a/crates/cp-mac-sys/src/titlebar.rs b/crates/cp-mac-sys/src/titlebar.rs
index d8f52b1d..6b897403 100644
--- a/crates/cp-mac-sys/src/titlebar.rs
+++ b/crates/cp-mac-sys/src/titlebar.rs
@@ -1,8 +1,16 @@
-use objc2_app_kit::{NSWindow, NSWindowButton};
-use objc2_foundation::MainThreadMarker;
+use objc2::MainThreadOnly;
+use objc2_app_kit::{NSBackingStoreType, NSWindow, NSWindowButton, NSWindowStyleMask};
+use objc2_foundation::{MainThreadMarker, NSPoint, NSRect, NSSize};
 use std::ffi::c_void;
 use std::ptr::NonNull;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Buttons {
+    pub zoom_shown: bool,
+    pub close_shown: bool,
+    pub minimise_shown: bool,
+}
+
 pub fn without_zoom(ns_window: NonNull<c_void>) -> bool {
     if MainThreadMarker::new().is_none() {
         return false;
@@ -15,6 +23,38 @@ pub fn without_zoom(ns_window: NonNull<c_void>) -> bool {
     true
 }
 
+pub fn a_titled_window_would_lose_zoom() -> Option<Buttons> {
+    let mtm = MainThreadMarker::new()?;
+    let window = unsafe {
+        NSWindow::initWithContentRect_styleMask_backing_defer(
+            NSWindow::alloc(mtm),
+            NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(200.0, 120.0)),
+            NSWindowStyleMask::Titled
+                | NSWindowStyleMask::Closable
+                | NSWindowStyleMask::Miniaturizable
+                | NSWindowStyleMask::Resizable,
+            NSBackingStoreType::Buffered,
+            false,
+        )
+    };
+    unsafe { window.setReleasedWhenClosed(false) };
+    if !without_zoom(NonNull::from(&*window).cast()) {
+        return None;
+    }
+    let shown = |which| {
+        window
+            .standardWindowButton(which)
+            .is_some_and(|button| !button.isHidden())
+    };
+    let buttons = Buttons {
+        zoom_shown: shown(NSWindowButton::ZoomButton),
+        close_shown: shown(NSWindowButton::CloseButton),
+        minimise_shown: shown(NSWindowButton::MiniaturizeButton),
+    };
+    window.close();
+    Some(buttons)
+}
+
 #[cfg(test)]
 #[path = "titlebar_test.rs"]
 mod tests;
diff --git a/crates/cp-mac-sys/src/titlebar_test.rs b/crates/cp-mac-sys/src/titlebar_test.rs
index 6aa631d4..6971fda9 100644
--- a/crates/cp-mac-sys/src/titlebar_test.rs
+++ b/crates/cp-mac-sys/src/titlebar_test.rs
@@ -1,7 +1,4 @@
 use super::*;
-use objc2::MainThreadOnly;
-use objc2_app_kit::{NSBackingStoreType, NSWindowStyleMask};
-use objc2_foundation::{NSPoint, NSRect, NSSize};
 
 #[test]
 fn off_the_main_thread_it_refuses_before_it_looks_at_the_window() {
@@ -12,28 +9,9 @@ fn off_the_main_thread_it_refuses_before_it_looks_at_the_window() {
 }
 
 #[test]
-fn a_titled_window_keeps_close_and_minimise_but_loses_zoom() {
-    let Some(mtm) = MainThreadMarker::new() else {
+fn off_the_main_thread_the_probe_has_nothing_to_say() {
+    if MainThreadMarker::new().is_some() {
         return;
-    };
-    let window = unsafe {
-        NSWindow::initWithContentRect_styleMask_backing_defer(
-            NSWindow::alloc(mtm),
-            NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(200.0, 120.0)),
-            NSWindowStyleMask::Titled
-                | NSWindowStyleMask::Closable
-                | NSWindowStyleMask::Miniaturizable,
-            NSBackingStoreType::Buffered,
-            false,
-        )
-    };
-    assert!(without_zoom(NonNull::from(&*window).cast()));
-    let zoom = window
-        .standardWindowButton(NSWindowButton::ZoomButton)
-        .expect("a titled window has a zoom button");
-    assert!(zoom.isHidden());
-    let close = window
-        .standardWindowButton(NSWindowButton::CloseButton)
-        .expect("a titled window has a close button");
-    assert!(!close.isHidden());
+    }
+    assert_eq!(a_titled_window_would_lose_zoom(), None);
 }
diff --git a/crates/cp-mac/examples/mac_probe.rs b/crates/cp-mac/examples/mac_probe.rs
index a9c2b6ba..671a9e85 100644
--- a/crates/cp-mac/examples/mac_probe.rs
+++ b/crates/cp-mac/examples/mac_probe.rs
@@ -1,5 +1,8 @@
 #[cfg(target_os = "macos")]
 include!("probe/battery.rs");
 
+#[cfg(target_os = "macos")]
+include!("probe/panel.rs");
+
 #[cfg(not(target_os = "macos"))]
 fn main() {}
diff --git a/crates/cp-mac/examples/probe/battery.rs b/crates/cp-mac/examples/probe/battery.rs
index 2399e4f0..b76b22a3 100644
--- a/crates/cp-mac/examples/probe/battery.rs
+++ b/crates/cp-mac/examples/probe/battery.rs
@@ -1224,6 +1224,8 @@ fn main() -> std::process::ExitCode {
         },
     );
 
+    the_panel_and_its_windows(&mut b);
+
     println!();
     println!(
         "  {} pass · {} fail · {} skipped",
diff --git a/crates/cp-mac/examples/probe/panel.rs b/crates/cp-mac/examples/probe/panel.rs
new file mode 100644
index 00000000..4bfba319
--- /dev/null
+++ b/crates/cp-mac/examples/probe/panel.rs
@@ -0,0 +1,76 @@
+fn the_panel_and_its_windows(b: &mut Battery) {
+    b.group("S · The panel and the settings window");
+
+    let floated = cp_mac_sys::floating::a_panel_would_float();
+
+    b.case(
+        "S1",
+        "the panel becomes a panel that takes the keys without waking the app",
+        || {
+            let floated = floated.ok_or("this needs the main thread and a window of its own")?;
+            if !floated.became_a_panel {
+                return Err("the window never became a panel".into());
+            }
+            if !floated.never_activates {
+                return Err("the panel would bring the whole app forward".into());
+            }
+            Ok(())
+        },
+    );
+
+    b.case(
+        "S2",
+        "the panel shows up over an app in full screen and on the space in use",
+        || {
+            let floated = floated.ok_or("this needs the main thread and a window of its own")?;
+            if !floated.joins_full_screen {
+                return Err("over a full screen app the panel would open on another space".into());
+            }
+            if !floated.follows_the_space {
+                return Err("the panel would drag the user back to where it was last shown".into());
+            }
+            Ok(())
+        },
+    );
+
+    b.case(
+        "S3",
+        "the panel goes back to the window it was, so closing it with an observer on it does not abort",
+        || {
+            let floated = floated.ok_or("this needs the main thread and a window of its own")?;
+            if !floated.back_as_it_was {
+                return Err("the window kept the panel class, and AppKit aborts when it is let go".into());
+            }
+            Ok(())
+        },
+    );
+
+    b.case_or_skip("S4", "the panel takes the keys when it is put in front", || {
+        let floated = floated.ok_or("this needs the main thread and a window of its own")?;
+        if floated.took_the_keys {
+            if !floated.counts_as_ours {
+                return Err("the panel holds the keys yet the app does not count it as its own".into());
+            }
+            return Ok(());
+        }
+        Err(format!(
+            "{SKIPPED}no window can take the keys without a session on screen"
+        ))
+    });
+
+    b.case(
+        "S5",
+        "the settings window keeps close and minimise and loses zoom",
+        || {
+            let buttons = cp_mac_sys::titlebar::a_titled_window_would_lose_zoom()
+                .ok_or("this needs the main thread and a window with buttons")?;
+            if buttons.zoom_shown {
+                return Err("the green button is still there".into());
+            }
+            if !buttons.close_shown || !buttons.minimise_shown {
+                return Err(format!("the other buttons went with it: {buttons:?}"));
+            }
+            Ok(())
+        },
+    );
+}
diff --git a/crates/cp-mac/src/paste.rs b/crates/cp-mac/src/paste.rs
index 6f527e3a..1025cb8d 100644
--- a/crates/cp-mac/src/paste.rs
+++ b/crates/cp-mac/src/paste.rs
@@ -3,8 +3,12 @@ use cp_core::paste::{Attempt, Failure, Focus, Next, ORDER, Phase, Route, SETTLE,
 use cp_mac_sys::frontmost;
 use cp_mac_sys::keyboard::{self, QWERTY_V};
 use cp_mac_sys::keystroke::{self, Keystroke};
+use cp_mac_sys::menu;
 use cp_mac_sys::permissions::Readiness;
-use cp_mac_sys::{menu, runloop};
+use std::time::{Duration, Instant};
+
+pub const KEYS_LET_GO: Duration = Duration::from_millis(120);
+pub const KEYS_LOOKED_AT: Duration = Duration::from_millis(4);
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Outcome {
@@ -41,84 +45,145 @@ impl Paster {
         keyboard::keycode_with_command('v').unwrap_or(QWERTY_V)
     }
 
-    pub fn paste_into(&self, target: &Destination, hide_panel: impl FnOnce()) -> Outcome {
-        self.paste_via(route_of(&Readiness::probe()), target, hide_panel)
-    }
-
-    pub fn paste_via(
+    pub fn start_via(
         &self,
         route: Option<Route>,
-        target: &Destination,
+        target: Destination,
         hide_panel: impl FnOnce(),
-    ) -> Outcome {
-        let started = std::time::Instant::now();
-        let mut attempt = Attempt::default();
-
+    ) -> Result<Pasting, Outcome> {
         let Some(route) = route else {
-            return Outcome::Degraded(Failure::SendDenied);
+            return Err(Outcome::Degraded(Failure::SendDenied));
         };
-
         hide_panel();
+        Ok(Pasting::new(route, target, Instant::now()))
+    }
 
-        if !frontmost::is_alive(target.pid) {
-            return Outcome::Degraded(Failure::TargetGone);
-        }
-
-        if self.focus_of(target) != Focus::OnTarget {
-            frontmost::bring_to_front(target.pid);
-        }
-
-        while self.focus_of(target) != Focus::OnTarget {
-            if !frontmost::is_alive(target.pid) {
-                return Outcome::Degraded(Failure::TargetGone);
-            }
-            if attempt.on_failure(Failure::NotForeground) != Next::Retry {
-                return Outcome::Degraded(Failure::ForegroundTimeout);
+    pub fn advance(&self, pasting: &mut Pasting) -> Advance {
+        let pid = pasting.target.pid;
+        let front = frontmost::frontmost().map(|(front, _)| front);
+        let step = pasting.next(
+            frontmost::is_alive(pid),
+            focus_from(front, pid),
+            keystroke::modifiers_still_held(),
+            Instant::now(),
+        );
+        match step {
+            Step::Raise => {
+                frontmost::bring_to_front(pid);
+                Advance::After(SETTLE)
             }
-            frontmost::bring_to_front(target.pid);
-            self.wait(SETTLE.as_secs_f64());
+            Step::Wait(pause) => Advance::After(pause),
+            Step::Stop(why) => Advance::Done(Outcome::Degraded(why)),
+            Step::Send => Advance::Done(self.send(pasting)),
         }
+    }
 
-        let waiting = std::time::Instant::now();
-        while keystroke::modifiers_still_held() && waiting.elapsed().as_millis() < 120 {
-            self.wait(0.004);
+    pub fn paste_via(
+        &self,
+        route: Option<Route>,
+        target: &Destination,
+        hide_panel: impl FnOnce(),
+    ) -> Outcome {
+        let mut pasting = match self.start_via(route, target.clone(), hide_panel) {
+            Ok(pasting) => pasting,
+            Err(outcome) => return outcome,
+        };
+        loop {
+            match self.advance(&mut pasting) {
+                Advance::Done(outcome) => return outcome,
+                Advance::After(pause) => std::thread::sleep(pause),
+            }
         }
+    }
 
-        let now = Readiness::probe();
-        let route = if now.secure_input {
-            match around_protected_input(route, now.accessibility) {
-                Some(other) => other,
-                None => return Outcome::Degraded(Failure::InputProtected),
-            }
-        } else {
-            route
+    fn send(&self, pasting: &mut Pasting) -> Outcome {
+        let Some(route) = pasting.route_now(&Readiness::probe()) else {
+            return Outcome::Degraded(Failure::InputProtected);
         };
-
-        attempt.sending();
+        pasting.attempt.sending();
         let sent = match route {
             Route::Keystroke => self.keys.command(self.keycode()),
-            Route::Menu => menu::press_paste(target.pid).is_ok(),
+            Route::Menu => menu::press_paste(pasting.target.pid).is_ok(),
         };
         if sent {
             Outcome::Sent {
-                took: started.elapsed(),
+                took: pasting.started.elapsed(),
                 via: route,
             }
         } else {
             Outcome::Degraded(Failure::SendDenied)
         }
     }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Step {
+    Raise,
+    Wait(Duration),
+    Send,
+    Stop(Failure),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Advance {
+    After(Duration),
+    Done(Outcome),
+}
+
+#[derive(Debug)]
+pub struct Pasting {
+    route: Route,
+    target: Destination,
+    started: Instant,
+    attempt: Attempt,
+    raised: bool,
+    keys_since: Option<Instant>,
+}
 
-    fn wait(&self, seconds: f64) {
-        runloop::pump(seconds);
+impl Pasting {
+    pub fn new(route: Route, target: Destination, now: Instant) -> Self {
+        Self {
+            route,
+            target,
+            started: now,
+            attempt: Attempt::default(),
+            raised: false,
+            keys_since: None,
+        }
     }
 
-    fn focus_of(&self, target: &Destination) -> Focus {
-        match frontmost::frontmost() {
-            Some((pid, _)) if pid == target.pid => Focus::OnTarget,
-            Some(_) => Focus::Elsewhere,
-            None => Focus::Unknown,
+    pub fn next(&mut self, alive: bool, focus: Focus, keys_held: bool, now: Instant) -> Step {
+        if !alive {
+            return Step::Stop(Failure::TargetGone);
+        }
+        if focus != Focus::OnTarget {
+            if self.raised && self.attempt.on_failure(Failure::NotForeground) != Next::Retry {
+                return Step::Stop(Failure::ForegroundTimeout);
+            }
+            self.raised = true;
+            return Step::Raise;
         }
+        let since = *self.keys_since.get_or_insert(now);
+        if keys_held && now.duration_since(since) < KEYS_LET_GO {
+            return Step::Wait(KEYS_LOOKED_AT);
+        }
+        Step::Send
+    }
+
+    pub fn route_now(&self, ready: &Readiness) -> Option<Route> {
+        if ready.secure_input {
+            around_protected_input(self.route, ready.accessibility)
+        } else {
+            Some(self.route)
+        }
+    }
+}
+
+pub fn focus_from(front: Option<i32>, target: i32) -> Focus {
+    match front {
+        Some(pid) if pid == target => Focus::OnTarget,
+        Some(_) => Focus::Elsewhere,
+        None => Focus::Unknown,
     }
 }
 
diff --git a/crates/cp-mac/src/paste_test.rs b/crates/cp-mac/src/paste_test.rs
index 1d2e3400..317ab628 100644
--- a/crates/cp-mac/src/paste_test.rs
+++ b/crates/cp-mac/src/paste_test.rs
@@ -1,4 +1,5 @@
 use super::*;
+use std::time::{Duration, Instant};
 
 fn ready(can_post: bool, accessibility: bool, secure_input: bool) -> Readiness {
     Readiness {
@@ -54,3 +55,256 @@ fn protected_input_without_the_menu_is_no_way_at_all() {
 fn neither_way_is_no_way() {
     assert_eq!(route_of(&ready(false, false, false)), None);
 }
+
+fn somewhere() -> Destination {
+    Destination {
+        pid: 4242,
+        bundle_id: None,
+    }
+}
+
+fn fresh(route: Route) -> (Pasting, Instant) {
+    let now = Instant::now();
+    (Pasting::new(route, somewhere(), now), now)
+}
+
+#[test]
+fn a_target_already_in_front_with_no_keys_held_is_pasted_at_once() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(pasting.next(true, Focus::OnTarget, false, now), Step::Send);
+}
+
+#[test]
+fn a_target_that_is_gone_stops_the_paste_before_anything_else() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.next(false, Focus::OnTarget, false, now),
+        Step::Stop(Failure::TargetGone)
+    );
+}
+
+#[test]
+fn a_target_that_dies_while_being_raised_is_reported_as_gone() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.next(true, Focus::Elsewhere, false, now),
+        Step::Raise
+    );
+    assert_eq!(
+        pasting.next(false, Focus::Elsewhere, false, now),
+        Step::Stop(Failure::TargetGone)
+    );
+}
+
+#[test]
+fn a_target_behind_another_app_is_raised_first() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.next(true, Focus::Elsewhere, false, now),
+        Step::Raise
+    );
+}
+
+#[test]
+fn not_knowing_who_is_in_front_is_treated_as_not_being_there() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(pasting.next(true, Focus::Unknown, false, now), Step::Raise);
+}
+
+#[test]
+fn once_the_target_comes_forward_the_paste_goes_out() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.next(true, Focus::Elsewhere, false, now),
+        Step::Raise
+    );
+    assert_eq!(
+        pasting.next(true, Focus::Elsewhere, false, now),
+        Step::Raise
+    );
+    assert_eq!(pasting.next(true, Focus::OnTarget, false, now), Step::Send);
+}
+
+#[test]
+fn a_target_that_never_comes_forward_gives_up_after_every_retry() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    let mut raised = 0;
+    loop {
+        match pasting.next(true, Focus::Elsewhere, false, now) {
+            Step::Raise => raised += 1,
+            Step::Stop(why) => {
+                assert_eq!(why, Failure::ForegroundTimeout);
+                break;
+            }
+            other => panic!("it should only raise or stop, and it said {other:?}"),
+        }
+        assert!(raised <= 64, "it never gave up");
+    }
+    assert_eq!(raised, usize::from(cp_core::paste::RACE_RETRIES) + 1);
+}
+
+#[test]
+fn the_first_raise_is_free_and_does_not_spend_a_retry() {
+    let (mut once, now) = fresh(Route::Keystroke);
+    once.next(true, Focus::Elsewhere, false, now);
+    let (mut never, _) = fresh(Route::Keystroke);
+    let mut left_once = 0;
+    while once.next(true, Focus::Elsewhere, false, now) == Step::Raise {
+        left_once += 1;
+    }
+    let mut left_never = 0;
+    while never.next(true, Focus::Elsewhere, false, now) == Step::Raise {
+        left_never += 1;
+    }
+    assert_eq!(left_never, left_once + 1);
+}
+
+#[test]
+fn held_modifiers_are_waited_for_in_short_looks() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.next(true, Focus::OnTarget, true, now),
+        Step::Wait(KEYS_LOOKED_AT)
+    );
+    let later = now + KEYS_LOOKED_AT;
+    assert_eq!(
+        pasting.next(true, Focus::OnTarget, true, later),
+        Step::Wait(KEYS_LOOKED_AT)
+    );
+}
+
+#[test]
+fn letting_go_of_the_modifiers_sends_the_paste() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    pasting.next(true, Focus::OnTarget, true, now);
+    assert_eq!(
+        pasting.next(true, Focus::OnTarget, false, now + KEYS_LOOKED_AT),
+        Step::Send
+    );
+}
+
+#[test]
+fn modifiers_held_too_long_do_not_hold_the_paste_forever() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    pasting.next(true, Focus::OnTarget, true, now);
+    assert_eq!(
+        pasting.next(true, Focus::OnTarget, true, now + KEYS_LET_GO),
+        Step::Send
+    );
+}
+
+#[test]
+fn the_wait_for_the_keys_counts_from_when_the_target_came_forward() {
+    let (mut pasting, now) = fresh(Route::Keystroke);
+    pasting.next(true, Focus::Elsewhere, true, now);
+    let forward = now + KEYS_LET_GO * 2;
+    assert_eq!(
+        pasting.next(true, Focus::OnTarget, true, forward),
+        Step::Wait(KEYS_LOOKED_AT)
+    );
+}
+
+#[test]
+fn a_paste_through_the_menu_ignores_held_keys_only_after_the_same_wait() {
+    let (mut pasting, now) = fresh(Route::Menu);
+    assert_eq!(
+        pasting.next(true, Focus::OnTarget, true, now),
+        Step::Wait(KEYS_LOOKED_AT)
+    );
+}
+
+#[test]
+fn without_protected_input_the_chosen_way_stands() {
+    let (pasting, _) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.route_now(&ready(true, false, false)),
+        Some(Route::Keystroke)
+    );
+    let (menu, _) = fresh(Route::Menu);
+    assert_eq!(
+        menu.route_now(&ready(false, true, false)),
+        Some(Route::Menu)
+    );
+}
+
+#[test]
+fn protected_input_turns_a_keystroke_into_the_menu_when_it_can() {
+    let (pasting, _) = fresh(Route::Keystroke);
+    assert_eq!(
+        pasting.route_now(&ready(true, true, true)),
+        Some(Route::Menu)
+    );
+}
+
+#[test]
+fn protected_input_with_no_menu_leaves_no_way_to_paste() {
+    let (pasting, _) = fresh(Route::Keystroke);
+    assert_eq!(pasting.route_now(&ready(true, false, true)), None);
+}
+
+#[test]
+fn protected_input_leaves_the_menu_alone() {
+    let (pasting, _) = fresh(Route::Menu);
+    assert_eq!(
+        pasting.route_now(&ready(false, true, true)),
+        Some(Route::Menu)
+    );
+}
+
+#[test]
+fn the_app_in_front_is_told_apart_from_the_target() {
+    assert_eq!(focus_from(Some(7), 7), Focus::OnTarget);
+    assert_eq!(focus_from(Some(8), 7), Focus::Elsewhere);
+    assert_eq!(focus_from(None, 7), Focus::Unknown);
+}
+
+#[test]
+fn looking_at_the_keys_is_much_shorter_than_waiting_for_them() {
+    assert!(KEYS_LOOKED_AT * 10 <= KEYS_LET_GO);
+}
+
+#[test]
+fn the_longest_paste_still_ends_within_a_second() {
+    let raises = u32::from(cp_core::paste::RACE_RETRIES) + 1;
+    assert!(SETTLE * raises + KEYS_LET_GO < Duration::from_secs(1));
+}
+
+#[test]
+fn no_way_to_paste_is_refused_before_the_panel_is_hidden() {
+    let Some(paster) = Paster::new() else {
+        return;
+    };
+    let mut hidden = false;
+    let said = paster.start_via(None, somewhere(), || hidden = true);
+    assert_eq!(said.err(), Some(Outcome::Degraded(Failure::SendDenied)));
+    assert!(!hidden, "the panel stays up so the refusal can be told");
+}
+
+#[test]
+fn a_way_to_paste_hides_the_panel_before_anything_is_sent() {
+    let Some(paster) = Paster::new() else {
+        return;
+    };
+    let mut hidden = false;
+    let said = paster.start_via(Some(Route::Keystroke), somewhere(), || hidden = true);
+    assert!(said.is_ok());
+    assert!(hidden);
+}
+
+#[test]
+fn a_target_that_does_not_exist_is_given_up_on_without_raising_anything() {
+    let Some(paster) = Paster::new() else {
+        return;
+    };
+    let gone = Destination {
+        pid: i32::MAX,
+        bundle_id: None,
+    };
+    let mut pasting = paster
+        .start_via(Some(Route::Keystroke), gone, || {})
+        .expect("a way to paste was given");
+    assert_eq!(
+        paster.advance(&mut pasting),
+        Advance::Done(Outcome::Degraded(Failure::TargetGone))
+    );
+}
diff --git a/crates/cp-panel/src/app.rs b/crates/cp-panel/src/app.rs
index f39d0459..762d22a0 100644
--- a/crates/cp-panel/src/app.rs
+++ b/crates/cp-panel/src/app.rs
@@ -1319,28 +1319,34 @@ fn mark(engine: Option<&crate::engine::Engine>) {
 
 fn deliver(ui: &Panel, state: &Rc<RefCell<State>>) {
     let ahead = state.borrow().ahead.swap(0, Ordering::Relaxed);
-    let weak = ui.as_weak();
-    match here::paste_into(ahead, move || {
+    let (weak, later, state) = (ui.as_weak(), ui.as_weak(), state.clone());
+    let hide = move || {
         if let Some(ui) = weak.upgrade() {
             ui.set_sheet_open(false);
             let _ = ui.hide();
         }
-    }) {
-        here::Sent::Nobody => vanish(ui),
-        here::Sent::Done => {}
-        here::Sent::Degraded(why) => {
-            state.borrow().ahead.store(ahead, Ordering::Relaxed);
-            let said = crate::excuse::why_not(why, crate::say::in_english());
-            note(&format!(
-                "it stays on the clipboard, unpasted: {why:?}: {said}"
-            ));
-            if ui.show().is_ok() {
-                forward(ui);
-                appear(ui);
-                complain(ui, said);
+    };
+    here::paste_into(ahead, hide, move |sent| {
+        let Some(ui) = later.upgrade() else {
+            return;
+        };
+        match sent {
+            here::Sent::Nobody => vanish(&ui),
+            here::Sent::Done => {}
+            here::Sent::Degraded(why) => {
+                state.borrow().ahead.store(ahead, Ordering::Relaxed);
+                let said = crate::excuse::why_not(why, crate::say::in_english());
+                note(&format!(
+                    "it stays on the clipboard, unpasted: {why:?}: {said}"
+                ));
+                if ui.show().is_ok() {
+                    forward(&ui);
+                    appear(&ui);
+                    complain(&ui, said);
+                }
             }
         }
-    }
+    });
 }
 
 fn forward(panel: &Panel) {
@@ -1406,10 +1412,6 @@ fn watch_leaving(ui: &Panel, state: &Rc<RefCell<State>>) {
         });
 }
 
-fn ahead_now() -> isize {
-    here::ahead_now()
-}
-
 const ORDER_UP_TO: u64 = 64;
 
 fn listen(ui: slint::Weak<Panel>, ahead: Arc<AtomicIsize>, backdrop: String) {
@@ -1426,7 +1428,7 @@ fn listen(ui: slint::Weak<Panel>, ahead: Arc<AtomicIsize>, backdrop: String) {
             }
             match said.trim() {
                 "show" => {
-                    let in_front = ahead_now();
+                    let in_front = here::ahead_now();
                     if in_front != 0 {
                         ahead.store(in_front, Ordering::Relaxed);
                     }
@@ -1455,7 +1457,10 @@ fn listen(ui: slint::Weak<Panel>, ahead: Arc<AtomicIsize>, backdrop: String) {
                 _ => note("an order arrived that means nothing here"),
             }
         }
-        let _ = ui.upgrade_in_event_loop(|_| {
+        let _ = ui.upgrade_in_event_loop(|panel| {
+            if let Some(handle) = handle_of(&panel) {
+                here::ground(handle);
+            }
             let _ = slint::quit_event_loop();
         });
     });
diff --git a/crates/cp-panel/src/here.rs b/crates/cp-panel/src/here.rs
index 2a43cc0a..d8753cda 100644
--- a/crates/cp-panel/src/here.rs
+++ b/crates/cp-panel/src/here.rs
@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 
 pub use platform::{
     Dragged, THUMBNAILS_FILES, Watching, ahead_now, capture_insisting, content_of, data_dir,
-    drag_out, dress, forward, in_front, media_of, ocr_available, open_link, open_path,
+    drag_out, dress, forward, ground, in_front, media_of, ocr_available, open_link, open_path,
     ours_up_front, paste_into, read_stuck, stay_out_of_the_dock, system_is_light, text_in,
     thumb_of_file, thumbs_dir, to_clipboard, towards, utc_offset_at, watch_start,
 };
@@ -180,7 +180,11 @@ mod platform {
         cp_win_sys::dragging::from_window(win32.hwnd.get(), paths)
     }
 
-    pub fn paste_into(ahead: isize, hide: impl FnOnce()) -> Sent {
+    pub fn paste_into(ahead: isize, hide: impl FnOnce(), finished: impl FnOnce(Sent) + 'static) {
+        finished(pasted(ahead, hide));
+    }
+
+    fn pasted(ahead: isize, hide: impl FnOnce()) -> Sent {
         let Some(target) = cp_win_sys::frontmost::target_at(ahead) else {
             return Sent::Nobody;
         };
@@ -189,6 +193,8 @@ mod platform {
             cp_win::paste::Outcome::Degraded(why) => Sent::Degraded(why),
         }
     }
+
+    pub fn ground(_handle: RawWindowHandle) {}
 }
 
 #[cfg(target_os = "macos")]
@@ -196,6 +202,7 @@ mod platform {
     use super::*;
     use cp_core::destination::Destination;
     use cp_mac_sys::pasteboard::Pasteboard;
+    use std::time::Duration;
 
     pub use cp_core::thumbnail::THUMBNAILS_FILES;
     pub use cp_core::watching::Watching;
@@ -336,12 +343,12 @@ mod platform {
         cp_mac_sys::dragging::from_view(appkit.ns_view, paths)
     }
 
-    pub fn paste_into(ahead: isize, hide: impl FnOnce()) -> Sent {
+    pub fn paste_into(ahead: isize, hide: impl FnOnce(), finished: impl FnOnce(Sent) + 'static) {
         let Ok(pid) = i32::try_from(ahead) else {
-            return Sent::Nobody;
+            return finished(Sent::Nobody);
         };
         if pid == 0 || !cp_mac_sys::frontmost::is_alive(pid) {
-            return Sent::Nobody;
+            return finished(Sent::Nobody);
         }
         let target = Destination {
             pid,
@@ -349,13 +356,42 @@ mod platform {
         };
         let Some(paster) = cp_mac::paste::Paster::new() else {
             hide();
-            return Sent::Degraded(Failure::SendDenied);
+            return finished(Sent::Degraded(Failure::SendDenied));
         };
-        match paster.paste_into(&target, hide) {
+        let route = cp_mac::paste::route_of(&cp_mac_sys::permissions::Readiness::probe());
+        match paster.start_via(route, target, hide) {
+            Ok(mut pasting) => keep_pasting(
+                move || paster.advance(&mut pasting),
+                finished,
+                Duration::ZERO,
+            ),
+            Err(outcome) => finished(sent_of(outcome)),
+        }
+    }
+
+    pub fn keep_pasting(
+        mut advance: impl FnMut() -> cp_mac::paste::Advance + 'static,
+        finished: impl FnOnce(Sent) + 'static,
+        after: Duration,
+    ) {
+        slint::Timer::single_shot(after, move || match advance() {
+            cp_mac::paste::Advance::Done(outcome) => finished(sent_of(outcome)),
+            cp_mac::paste::Advance::After(next) => keep_pasting(advance, finished, next),
+        });
+    }
+
+    pub fn sent_of(outcome: cp_mac::paste::Outcome) -> Sent {
+        match outcome {
             cp_mac::paste::Outcome::Sent { .. } => Sent::Done,
             cp_mac::paste::Outcome::Degraded(why) => Sent::Degraded(why),
         }
     }
+
+    pub fn ground(handle: RawWindowHandle) {
+        if let RawWindowHandle::AppKit(appkit) = handle {
+            cp_mac_sys::floating::grounded(appkit.ns_view);
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/cp-panel/src/here_test.rs b/crates/cp-panel/src/here_test.rs
index 16d63774..1a9cf77f 100644
--- a/crates/cp-panel/src/here_test.rs
+++ b/crates/cp-panel/src/here_test.rs
@@ -25,7 +25,58 @@ fn asking_the_system_for_its_theme_answers_the_same_twice() {
 
 #[test]
 fn nobody_in_front_reads_as_zero_and_pasting_there_reaches_nobody() {
-    assert_eq!(paste_into(0, || {}), Sent::Nobody);
+    let said = std::rc::Rc::new(std::cell::Cell::new(None));
+    let heard = said.clone();
+    paste_into(0, || {}, move |sent| heard.set(Some(sent)));
+    assert_eq!(said.take(), Some(Sent::Nobody));
+}
+
+#[test]
+fn nobody_in_front_never_hides_the_panel() {
+    let mut hidden = false;
+    paste_into(0, || hidden = true, |_| {});
+    assert!(!hidden);
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn a_target_that_cannot_be_named_reaches_nobody() {
+    let said = std::rc::Rc::new(std::cell::Cell::new(None));
+    let heard = said.clone();
+    paste_into(-1, || {}, move |sent| heard.set(Some(sent)));
+    assert_eq!(said.take(), Some(Sent::Nobody));
+}
+
+#[test]
+fn a_handle_from_another_system_is_left_as_it_is_when_the_panel_goes() {
+    use raw_window_handle::XlibWindowHandle;
+    ground(RawWindowHandle::Xlib(XlibWindowHandle::new(1)));
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn what_the_paste_ends_in_is_what_the_panel_is_told() {
+    use cp_mac::paste::Outcome;
+    assert_eq!(
+        platform::sent_of(Outcome::Sent {
+            took: std::time::Duration::ZERO,
+            via: cp_core::paste::Route::Keystroke,
+        }),
+        Sent::Done
+    );
+    assert_eq!(
+        platform::sent_of(Outcome::Degraded(Failure::ForegroundTimeout)),
+        Sent::Degraded(Failure::ForegroundTimeout)
+    );
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn a_target_that_already_quit_reaches_nobody() {
+    let said = std::rc::Rc::new(std::cell::Cell::new(None));
+    let heard = said.clone();
+    paste_into(i32::MAX as isize, || {}, move |sent| heard.set(Some(sent)));
+    assert_eq!(said.take(), Some(Sent::Nobody));
 }
 
 #[test]
@@ -67,3 +118,94 @@ fn nobody_in_front_is_pasted_to_as_anywhere_else() {
     assert_eq!(towards(0), crate::landing::Towards::Elsewhere);
     assert_eq!(towards(-1), crate::landing::Towards::Elsewhere);
 }
+
+#[cfg(target_os = "macos")]
+fn heard() -> (
+    std::rc::Rc<std::cell::RefCell<Vec<Sent>>>,
+    impl FnOnce(Sent) + 'static,
+) {
+    let said = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+    let kept = said.clone();
+    (said, move |sent| kept.borrow_mut().push(sent))
+}
+
+#[cfg(target_os = "macos")]
+fn steps(
+    waits: u32,
+    then: cp_mac::paste::Outcome,
+) -> (
+    std::rc::Rc<std::cell::Cell<u32>>,
+    impl FnMut() -> cp_mac::paste::Advance + 'static,
+) {
+    let asked = std::rc::Rc::new(std::cell::Cell::new(0));
+    let counted = asked.clone();
+    let step = move || {
+        counted.set(counted.get() + 1);
+        if counted.get() <= waits {
+            cp_mac::paste::Advance::After(std::time::Duration::from_millis(10))
+        } else {
+            cp_mac::paste::Advance::Done(then.clone())
+        }
+    };
+    (asked, step)
+}
+
+#[cfg(target_os = "macos")]
+fn sent() -> cp_mac::paste::Outcome {
+    cp_mac::paste::Outcome::Sent {
+        took: std::time::Duration::ZERO,
+        via: cp_core::paste::Route::Keystroke,
+    }
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn the_paste_goes_on_between_turns_of_the_loop_until_it_is_done() {
+    let (said, finished) = heard();
+    let (asked, step) = steps(3, sent());
+    platform::keep_pasting(step, finished, std::time::Duration::ZERO);
+    for _ in 0..50 {
+        if !said.borrow().is_empty() {
+            break;
+        }
+        i_slint_backend_testing::mock_elapsed_time(std::time::Duration::from_millis(10));
+    }
+    assert_eq!(*said.borrow(), vec![Sent::Done]);
+    assert_eq!(asked.get(), 4);
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn nothing_is_tried_before_the_loop_has_turned_once() {
+    let (said, finished) = heard();
+    let (asked, step) = steps(0, sent());
+    platform::keep_pasting(step, finished, std::time::Duration::from_millis(30));
+    assert_eq!(asked.get(), 0);
+    assert!(said.borrow().is_empty());
+    for _ in 0..50 {
+        if !said.borrow().is_empty() {
+            break;
+        }
+        i_slint_backend_testing::mock_elapsed_time(std::time::Duration::from_millis(10));
+    }
+    assert_eq!(asked.get(), 1);
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn a_paste_that_fails_tells_the_panel_why_exactly_once() {
+    let (said, finished) = heard();
+    let (asked, step) = steps(
+        2,
+        cp_mac::paste::Outcome::Degraded(Failure::ForegroundTimeout),
+    );
+    platform::keep_pasting(step, finished, std::time::Duration::ZERO);
+    for _ in 0..80 {
+        i_slint_backend_testing::mock_elapsed_time(std::time::Duration::from_millis(10));
+    }
+    assert_eq!(
+        *said.borrow(),
+        vec![Sent::Degraded(Failure::ForegroundTimeout)]
+    );
+    assert_eq!(asked.get(), 3, "once it is done nothing is asked again");
+}

From 37cfa4206406681fe1fbcce99524a39edda0a00d Mon Sep 17 00:00:00 2001
From: rgdevment <mhidalgorg@gmail.com>
Date: Tue, 6 Oct 2026 03:57:29 -0300
Subject: [PATCH 3/3] fix(macos): a failed paste never overwrites a newer
 target, and the probe pumps between paste steps

---
 crates/cp-mac/examples/probe/battery.rs | 21 ++++++++++++++++++++-
 crates/cp-mac/src/paste.rs              | 18 ------------------
 crates/cp-panel/src/app.rs              |  7 ++++++-
 3 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/crates/cp-mac/examples/probe/battery.rs b/crates/cp-mac/examples/probe/battery.rs
index b76b22a3..d0229635 100644
--- a/crates/cp-mac/examples/probe/battery.rs
+++ b/crates/cp-mac/examples/probe/battery.rs
@@ -1344,7 +1344,7 @@ fn paste_round_trip(pb: &Pasteboard, paster: &Paster, route: Route) -> Result<()
     std::thread::sleep(Duration::from_millis(120));
 
     let started = Instant::now();
-    match paster.paste_via(Some(route), &target, || {}) {
+    match pasted_pumping(paster, route, &target)? {
         cp_mac::paste::Outcome::Degraded(why) => return Err(format!("it degraded: {why:?}")),
         cp_mac::paste::Outcome::Sent { via, .. } if via != route => {
             return Err(format!("it went by {via:?}"));
@@ -1375,6 +1375,25 @@ fn paste_round_trip(pb: &Pasteboard, paster: &Paster, route: Route) -> Result<()
     }
 }
 
+fn pasted_pumping(
+    paster: &Paster,
+    route: Route,
+    target: &cp_core::destination::Destination,
+) -> Result<cp_mac::paste::Outcome, String> {
+    let mut pasting = paster
+        .start_via(Some(route), target.clone(), || {})
+        .map_err(|outcome| format!("it never started: {outcome:?}"))?;
+    loop {
+        match paster.advance(&mut pasting) {
+            cp_mac::paste::Advance::Done(outcome) => return Ok(outcome),
+            cp_mac::paste::Advance::After(pause) => {
+                std::thread::sleep(pause);
+                cp_mac_sys::runloop::pump(0.0);
+            }
+        }
+    }
+}
+
 fn run_open(args: &[&str]) {
     let mut command = std::process::Command::new("/usr/bin/open");
     command.args(args);
diff --git a/crates/cp-mac/src/paste.rs b/crates/cp-mac/src/paste.rs
index 1025cb8d..180d4615 100644
--- a/crates/cp-mac/src/paste.rs
+++ b/crates/cp-mac/src/paste.rs
@@ -78,24 +78,6 @@ impl Paster {
         }
     }
 
-    pub fn paste_via(
-        &self,
-        route: Option<Route>,
-        target: &Destination,
-        hide_panel: impl FnOnce(),
-    ) -> Outcome {
-        let mut pasting = match self.start_via(route, target.clone(), hide_panel) {
-            Ok(pasting) => pasting,
-            Err(outcome) => return outcome,
-        };
-        loop {
-            match self.advance(&mut pasting) {
-                Advance::Done(outcome) => return outcome,
-                Advance::After(pause) => std::thread::sleep(pause),
-            }
-        }
-    }
-
     fn send(&self, pasting: &mut Pasting) -> Outcome {
         let Some(route) = pasting.route_now(&Readiness::probe()) else {
             return Outcome::Degraded(Failure::InputProtected);
diff --git a/crates/cp-panel/src/app.rs b/crates/cp-panel/src/app.rs
index 762d22a0..dd3ab16f 100644
--- a/crates/cp-panel/src/app.rs
+++ b/crates/cp-panel/src/app.rs
@@ -1334,7 +1334,12 @@ fn deliver(ui: &Panel, state: &Rc<RefCell<State>>) {
             here::Sent::Nobody => vanish(&ui),
             here::Sent::Done => {}
             here::Sent::Degraded(why) => {
-                state.borrow().ahead.store(ahead, Ordering::Relaxed);
+                let _ = state.borrow().ahead.compare_exchange(
+                    0,
+                    ahead,
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                );
                 let said = crate::excuse::why_not(why, crate::say::in_english());
                 note(&format!(
                     "it stays on the clipboard, unpasted: {why:?}: {said}"