Struct AsyncKeySender 

pub struct AsyncKeySender { /* private fields */ }

Non-blocking KeySender decorator — moves the blocking tmux round-trip off the caller’s thread. send/scroll enqueue onto an unbounded channel and return immediately (sub-microsecond); a single background thread drains the channel in FIFO order and replays each job against the wrapped sender.

Why (#386): the TUI forwards each keystroke inline on its render/event loop (app::run). A per-key tmux send-keys blocks that loop ~3ms, and a keystroke that lands while the loop is mid capture-pane / refresh waits behind it — perceptible input lag. Handing the send to a background thread frees the loop to observe the next key and redraw. The channel is FIFO and single-consumer, so the pane still receives keys in the exact order and form the inline path produced — no batching, no reordering, so the #374 forwarding contract (Esc / Ctrl+C / arrows) is untouched.

Inner-sender contract: the wrapped KeySender must signal failures by returning Err (which the worker swallows and moves on, matching the inline path’s best-effort let _ = send(...)), not by panicking. TmuxKeySender honours this — its tmux round-trip returns Err on any failure and never unwraps — so the worker thread is durable for the life of the app.

Implementations

impl AsyncKeySender

pub fn new<K: KeySender + 'static>(inner: K) -> Self

Wrap a blocking sender and spawn its drain thread. inner is moved onto the worker, which runs every job to completion in arrival order. The thread lives until this AsyncKeySender is dropped.

Trait Implementations

impl Drop for AsyncKeySender

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl KeySender for AsyncKeySender

fn send(&self, session: &str, key: &EncodedKey) -> Result<()>

fn scroll(&self, session: &str, direction: ScrollDirection) -> Result<()>

Forward one mouse-wheel tick to the named tmux session as a terminal-history scroll. Implementations target the pane’s copy-mode scroll commands, so the agent’s history surfaces the same way tmux attach + wheel does — wheel-up auto-enters copy-mode, subsequent ticks scroll the buffer. Wheel-down on a pane not in copy-mode is a no-op (tmux’s own behaviour).