Struct Session 

pub struct Session { /* private fields */ }

A single detached RMUX session.

Implementations

impl Session

pub const fn name(&self) -> &SessionName

Returns the stable validated session name.

pub const fn group_name(&self) -> Option<&SessionName>

Returns the named session group when the session is grouped.

pub const fn id(&self) -> SessionId

Returns the store-assigned session identity used by $N targets.

pub const fn created_at(&self) -> i64

Returns the session creation timestamp as Unix seconds.

pub const fn activity_at(&self) -> i64

Returns the last session activity timestamp as Unix seconds.

pub const fn last_attached_at(&self) -> Option<i64>

Returns the last attached timestamp as Unix seconds.

pub fn cwd(&self) -> Option<&Path>

Returns the session working directory when one has been assigned.

pub const fn terminal_size(&self) -> TerminalSize

Returns the terminal size last applied to the session as a whole.

pub fn rename(&mut self, new_name: SessionName)

Renames the session without rewriting any other session state.

pub fn set_group_name(&mut self, group_name: Option<SessionName>)

Assigns or clears the session group name without mutating any other session state.

pub fn set_cwd(&mut self, cwd: Option<PathBuf>)

Updates the session working directory.

pub fn touch_attached(&mut self)

Records that a client attached to the session at the current time.

pub fn clone_as_group_member( &self, name: SessionName, group_name: SessionName, session_id: SessionId, ) -> Self

Clones the session as a grouped peer with a fresh identity and timestamps.

pub fn synchronize_group_from(&mut self, source: &Session)

Synchronizes shared grouped-session window state from the source session while preserving the local current window when possible.

pub fn synchronize_group_from_with_winlink_alert_map( &mut self, source: &Session, winlink_alert_map: &BTreeMap<u32, u32>, )

Synchronizes grouped windows by identity while applying an authoritative permutation to peer-local winlink alert flags.

pub fn synchronize_group_from_with_window_selection_map( &mut self, source: &Session, index_map: &BTreeMap<u32, u32>, )

Synchronizes grouped window state while remapping selected source slots explicitly.

pub fn synchronize_group_from_with_window_selection_and_winlink_alert_maps( &mut self, source: &Session, window_selection_map: &BTreeMap<u32, u32>, winlink_alert_map: &BTreeMap<u32, u32>, )

Synchronizes grouped windows with independent maps for peer selection and peer-local winlink alert flags.

pub fn window(&self) -> &Window

Returns the session’s active window.

pub fn window_at(&self, window_index: u32) -> Option<&Window>

Returns the explicitly addressed window when it exists.

pub const fn windows(&self) -> &BTreeMap<u32, Window>

Returns all windows keyed by window index.

pub fn window_at_mut(&mut self, window_index: u32) -> Option<&mut Window>

Returns the addressed window as a mutable reference when it exists.

pub fn winlink_alert_flags(&self, window_index: u32) -> AlertFlags

Returns the persistent alert flags for the addressed window slot.

pub fn session_alert_flags(&self) -> AlertFlags

Returns the combined session alert flags across all alerted windows.

pub fn alerted_window_indexes(&self) -> Vec<u32>

Returns the alerted window indexes in display order.

pub fn has_alerts(&self) -> bool

Returns whether any window in the session currently carries an alert.

pub fn add_winlink_alert_flags( &mut self, window_index: u32, flags: AlertFlags, ) -> bool

Adds persistent alert flags to the addressed session winlink.

pub fn clear_winlink_alert_flags( &mut self, window_index: u32, flags: AlertFlags, ) -> bool

Clears the selected persistent alert flags from the addressed session winlink.

pub fn clear_all_winlink_alert_flags(&mut self, window_index: u32) -> bool

Clears all persistent alert flags from the addressed session winlink.

pub const fn active_window_index(&self) -> u32

Returns the active window index.

pub const fn last_window_index(&self) -> Option<u32>

Returns the previously active window index when one exists.

pub fn active_pane_index(&self) -> u32

Returns the active pane index owned by the session.

pub fn active_pane_id(&self) -> Option<PaneId>

Returns the stable internal identity for the active pane.

pub fn active_pane(&self) -> Option<&Pane>

Returns the active pane when the session invariant is satisfied.

pub fn pane_id(&self, pane_index: u32) -> Option<PaneId>

Returns the stable internal identity for a pane in the active window.

pub fn pane_id_in_window( &self, window_index: u32, pane_index: u32, ) -> Option<PaneId>

Returns the stable internal identity for a pane in the addressed window.

impl Session

pub fn select_layout(&mut self, layout: LayoutName)

Applies a layout to the session’s active window.

pub fn select_layout_in_window( &mut self, window_index: u32, layout: LayoutName, ) -> Result<(), RmuxError>

Applies a layout to the addressed window.

pub fn select_layout_in_window_with_main_pane_size( &mut self, window_index: u32, layout: LayoutName, main_width: Option<u16>, main_height: Option<u16>, ) -> Result<(), RmuxError>

Applies a layout to the addressed window using tmux main-pane-* option values.

pub fn select_custom_layout_in_window( &mut self, window_index: u32, layout: &str, ) -> Result<(), RmuxError>

Applies a tmux custom layout string to the addressed window.

pub fn reapply_old_layout_in_window( &mut self, window_index: u32, ) -> Result<bool, RmuxError>

Reapplies the previously saved tmux old layout to the addressed window.

pub fn save_old_layout_in_window( &mut self, window_index: u32, ) -> Result<(), RmuxError>

Saves the current serialized layout as the window old layout.

pub fn spread_layout_in_window( &mut self, window_index: u32, ) -> Result<bool, RmuxError>

Spreads the addressed window around its active pane, matching tmux select-layout -E.

pub fn next_layout_in_window( &mut self, window_index: u32, ) -> Result<LayoutName, RmuxError>

Selects the next tmux-standard layout for the addressed window.

pub fn next_layout_in_window_with_main_pane_size( &mut self, window_index: u32, main_width: Option<u16>, main_height: Option<u16>, ) -> Result<LayoutName, RmuxError>

Selects the next tmux-standard layout using tmux main-pane-* option values.

pub fn previous_layout_in_window( &mut self, window_index: u32, ) -> Result<LayoutName, RmuxError>

Selects the previous tmux-standard layout for the addressed window.

pub fn previous_layout_in_window_with_main_pane_size( &mut self, window_index: u32, main_width: Option<u16>, main_height: Option<u16>, ) -> Result<LayoutName, RmuxError>

Selects the previous tmux-standard layout using tmux main-pane-* option values.

impl Session

pub fn break_pane( &mut self, source: SessionPaneTarget, options: BreakPaneOptions, ) -> Result<u32, RmuxError>

Breaks one pane out into another window in the same session.

impl Session

pub fn last_pane_in_window( &mut self, window_index: u32, ) -> Result<u32, RmuxError>

Selects the previously active pane in the addressed window.

pub fn last_pane_in_window_with_zoom( &mut self, window_index: u32, preserve_zoom: bool, ) -> Result<u32, RmuxError>

Selects the previously active pane in the addressed window, preserving zoom when requested.

pub fn swap_panes( &mut self, source: SessionPaneTarget, target: SessionPaneTarget, options: PaneSwapOptions, ) -> Result<(), RmuxError>

Swaps two panes within the same session without renumbering either pane.

pub fn join_pane( &mut self, source: SessionPaneTarget, target: SessionPaneTarget, options: PaneJoinOptions, ) -> Result<(), RmuxError>

Moves one pane next to another pane in the same session.

impl Session

pub fn swap_panes_with_session( &mut self, source: SessionPaneTarget, target_session: &mut Session, target: SessionPaneTarget, options: PaneSwapOptions, ) -> Result<(), RmuxError>

Swaps one pane in this session with one pane in another session.

pub fn join_pane_from_session( &mut self, target: SessionPaneTarget, source_session: &mut Session, source: SessionPaneTarget, options: PaneJoinOptions, ) -> Result<(), RmuxError>

Moves one pane from another session into this session.

pub fn break_pane_to_session( &mut self, source: SessionPaneTarget, destination_session: &mut Session, options: BreakPaneOptions, ) -> Result<u32, RmuxError>

Breaks one pane out into another session as its own window.

impl Session

pub fn resize_pane( &mut self, pane_index: u32, adjustment: ResizePaneAdjustment, ) -> Result<(), RmuxError>

Applies the supported resize adjustment to the session layout.

pub fn resize_pane_in_window( &mut self, window_index: u32, pane_index: u32, adjustment: ResizePaneAdjustment, ) -> Result<(), RmuxError>

Applies the supported resize adjustment to the addressed window.

pub fn resize_pane_to_in_window( &mut self, window_index: u32, pane_index: u32, direction: SplitDirection, size: u32, ) -> Result<(), RmuxError>

Resizes the addressed pane to an exact size along the split axis.

pub fn resize_new_split_pane_to_in_window( &mut self, window_index: u32, new_pane_index: u32, direction: SplitDirection, size: u32, inserted_before_target: bool, ) -> Result<(), RmuxError>

Resizes the newly split pane while keeping the adjustment inside the original target pane cell. Plain resize_pane_to follows tmux’s normal border-selection rules and may borrow size from the next sibling when a pane is not last. For split-window -l, tmux instead sizes the new pane against the pane it just split, leaving unrelated neighbours untouched.

pub fn toggle_zoom_in_window( &mut self, window_index: u32, pane_index: u32, ) -> Result<(), RmuxError>

Toggles zoom for the addressed pane’s window.

impl Session

pub fn select_window(&mut self, window_index: u32) -> Result<(), RmuxError>

Selects the active window by index.

pub fn next_window(&mut self) -> Result<u32, RmuxError>

Selects the next window in sparse index order, wrapping to the lowest index.

pub fn next_window_with_alerts(&mut self) -> Result<u32, RmuxError>

Selects the next alerted window in sparse index order.

pub fn previous_window(&mut self) -> Result<u32, RmuxError>

Selects the previous window in sparse index order, wrapping to the highest index.

pub fn previous_window_with_alerts(&mut self) -> Result<u32, RmuxError>

Selects the previous alerted window in sparse index order.

pub fn last_window(&mut self) -> Result<u32, RmuxError>

Selects the most recently active window.

pub fn restore_last_window_after_active_unlink(&mut self)

Restores tmux’s winlink stack fallback after unlinking an active linked slot.

impl Session

pub fn create_window( &mut self, size: TerminalSize, ) -> Result<(u32, PaneId), RmuxError>

Creates a new window at the lowest available index and returns its window index together with the initial pane ID.

pub fn create_window_at_or_above( &mut self, size: TerminalSize, minimum_index: u32, ) -> Result<(u32, PaneId), RmuxError>

Creates a new window at the lowest available index at or above minimum_index.

pub fn create_window_at_or_above_with_pane_id( &mut self, size: TerminalSize, minimum_index: u32, pane_id: PaneId, ) -> Result<(u32, PaneId), RmuxError>

Creates a new window at the lowest available index at or above minimum_index using the provided initial pane identity.

pub fn insert_window_with_initial_pane( &mut self, window_index: u32, size: TerminalSize, ) -> Result<(), RmuxError>

Inserts a window with its initial pane at the provided window index.

pub fn insert_window_with_initial_pane_with_id( &mut self, window_index: u32, size: TerminalSize, pane_id: PaneId, ) -> Result<(), RmuxError>

Inserts a window with its initial pane at the provided window index using the supplied pane identity.

pub fn insert_existing_window( &mut self, window_index: u32, window: Window, ) -> Result<(), RmuxError>

Inserts an existing window at the provided window index without rewriting its identities.

pub fn make_room_for_window( &mut self, window_index: u32, ) -> Result<BTreeMap<u32, u32>, RmuxError>

Opens a destination slot for insertion and returns every shifted old-to-new winlink index.

pub fn link_window( &mut self, window_index: u32, window: Window, kill_destination: bool, select_destination: bool, ) -> Result<Option<Window>, RmuxError>

Inserts a linked copy of an existing window at the destination slot.

pub fn replace_window( &mut self, window_index: u32, window: Window, ) -> Result<Window, RmuxError>

Replaces an existing window at the provided index and returns the removed window.

pub fn remove_window(&mut self, window_index: u32) -> Result<Window, RmuxError>

Removes the addressed window and returns it, using tmux’s last-then-previous-then-next active fallback when needed.

pub fn remove_window_allowing_empty( &mut self, window_index: u32, ) -> Result<Window, RmuxError>

Removes a window even when it is the final window in the session.

Callers must destroy the now-empty session in the same transaction.

pub fn rename_window( &mut self, window_index: u32, name: String, ) -> Result<(), RmuxError>

Renames the addressed window and disables automatic renaming for it.

pub fn set_automatic_window_name( &mut self, window_index: u32, name: String, ) -> Result<(), RmuxError>

Updates the addressed window name while preserving automatic renaming.

pub fn reindex_windows(&mut self) -> Result<BTreeMap<u32, u32>, RmuxError>

Reindexes sparse window slots into a contiguous 0..n range without rewriting the windows themselves.

pub fn reindex_windows_from( &mut self, first_index: u32, ) -> Result<BTreeMap<u32, u32>, RmuxError>

Reindexes sparse window slots into a contiguous range starting at first_index.

pub fn move_window( &mut self, source_index: u32, destination_index: u32, kill_destination: bool, select_destination: bool, ) -> Result<Option<Window>, RmuxError>

Moves one window to another slot within the same session, optionally removing an occupied destination.

When select_destination is true, the destination slot becomes active using tmux’s winlink-based selection semantics instead of following the moved window by identity.

pub fn swap_windows( &mut self, source_index: u32, destination_index: u32, ) -> Result<(), RmuxError>

Swaps two window slots within the same session while preserving the underlying windows.

pub fn rotate_window( &mut self, window_index: u32, direction: RotateWindowDirection, ) -> Result<(), RmuxError>

Rotates pane positions in the addressed window without renumbering the panes themselves.

pub fn rotate_window_with_zoom( &mut self, window_index: u32, direction: RotateWindowDirection, restore_zoom: bool, ) -> Result<(), RmuxError>

Rotates pane positions with zoom save/restore via -Z.

pub fn resize_window( &mut self, window_index: u32, size: TerminalSize, ) -> Result<(), RmuxError>

Sets the explicit size of the addressed window.

pub fn respawn_window(&mut self, window_index: u32) -> Result<PaneId, RmuxError>

Respawns the addressed window, replacing it with a single pane. Returns the pane ID retained for the respawned pane.

pub fn respawn_window_with_pane_id( &mut self, window_index: u32, pane_id: PaneId, ) -> Result<PaneId, RmuxError>

Respawns the addressed window with an explicitly provided pane identity.

impl Session

pub fn new(name: SessionName, size: TerminalSize) -> Self

Creates a new session with its initial pane active.

pub fn split_active_pane(&mut self) -> Result<u32, RmuxError>

Splits the current active pane and returns the new pane index, making the new pane active.

pub fn split_active_pane_with_direction( &mut self, direction: SplitDirection, ) -> Result<u32, RmuxError>

Splits the current active pane in the requested direction.

pub fn split_pane(&mut self, pane_index: u32) -> Result<u32, RmuxError>

Splits the addressed pane, inserting the new pane immediately after the split target in window order.

pub fn split_pane_with_direction( &mut self, pane_index: u32, direction: SplitDirection, ) -> Result<u32, RmuxError>

Splits the addressed pane in the active window using the requested direction.

pub fn split_pane_in_window( &mut self, window_index: u32, pane_index: u32, ) -> Result<u32, RmuxError>

Splits the addressed pane in the addressed window and returns the new pane index.

pub fn split_pane_in_window_with_direction( &mut self, window_index: u32, pane_index: u32, direction: SplitDirection, ) -> Result<u32, RmuxError>

Splits the addressed pane in the addressed window using the requested direction.

pub fn split_pane_in_window_with_direction_before( &mut self, window_index: u32, pane_index: u32, direction: SplitDirection, before: bool, ) -> Result<u32, RmuxError>

Splits the addressed pane in the addressed window using the requested direction, controlling whether the new pane is inserted before the target on the chosen axis (tmux -b).

pub fn split_pane_in_window_with_id_and_direction( &mut self, window_index: u32, pane_index: u32, pane_id: PaneId, direction: SplitDirection, ) -> Result<u32, RmuxError>

Splits the addressed pane in the addressed window using the provided pane identity.

The new pane is inserted after the target on the chosen axis. Callers that need tmux -b semantics (insert before) should use Session::split_pane_in_window_with_id_and_direction_before.

pub fn split_pane_in_window_with_id_and_direction_before( &mut self, window_index: u32, pane_index: u32, pane_id: PaneId, direction: SplitDirection, before: bool, ) -> Result<u32, RmuxError>

Splits the addressed pane, controlling whether the new pane lands before (-b) or after the target on the chosen axis.

pub fn split_pane_in_window_with_id_and_direction_before_detached( &mut self, window_index: u32, pane_index: u32, pane_id: PaneId, direction: SplitDirection, before: bool, detached: bool, ) -> Result<u32, RmuxError>

Splits like Self::split_pane_in_window_with_id_and_direction_before but honors tmux -d: a detached spawn leaves the active pane, the last pane, and the active_point counters untouched.

pub fn split_pane_full_size_in_window_with_id_and_direction_before( &mut self, window_index: u32, pane_index: u32, pane_id: PaneId, direction: SplitDirection, before: bool, ) -> Result<u32, RmuxError>

Splits the full addressed window root and returns the new pane index.

pub fn split_pane_full_size_in_window_with_id_and_direction_before_detached( &mut self, window_index: u32, pane_index: u32, pane_id: PaneId, direction: SplitDirection, before: bool, detached: bool, ) -> Result<u32, RmuxError>

Full-size split honoring tmux -d like Self::split_pane_in_window_with_id_and_direction_before_detached.

pub fn kill_pane( &mut self, pane_index: u32, ) -> Result<KillPaneOutcome, RmuxError>

Removes the addressed pane in the active window.

pub fn kill_pane_in_window( &mut self, window_index: u32, pane_index: u32, ) -> Result<KillPaneOutcome, RmuxError>

Removes the addressed pane or destroys its window when it is the last pane there.

pub fn kill_other_panes_in_window( &mut self, window_index: u32, pane_index: u32, ) -> Result<KillPaneOutcome, RmuxError>

Removes every pane except the addressed pane, matching kill-pane -a.

pub fn select_pane(&mut self, pane_index: u32) -> Result<(), RmuxError>

Selects the active pane for the session.

pub fn select_pane_in_window( &mut self, window_index: u32, pane_index: u32, ) -> Result<(), RmuxError>

Selects the active pane for the addressed window.

pub fn select_pane_in_window_with_zoom( &mut self, window_index: u32, pane_index: u32, preserve_zoom: bool, ) -> Result<(), RmuxError>

Selects the active pane for the addressed window, preserving zoom when requested.

pub fn select_adjacent_pane_in_window( &mut self, window_index: u32, pane_index: u32, direction: SelectPaneDirection, ) -> Result<u32, RmuxError>

Selects the pane adjacent to the addressed pane in the requested direction.

pub fn select_adjacent_pane_in_window_with_zoom( &mut self, window_index: u32, pane_index: u32, direction: SelectPaneDirection, preserve_zoom: bool, ) -> Result<u32, RmuxError>

Selects an adjacent pane, preserving zoom when requested.

pub fn resize_terminal(&mut self, size: TerminalSize)

Updates the backing terminal size and recalculates pane geometry for all windows.

pub fn resize_active_window_terminal(&mut self, size: TerminalSize)

Updates the backing terminal size and recalculates only the active window geometry.

Attached clients drive the size of the window they are currently viewing. Inactive windows can have independent policies and may share a runtime with another session, so resizing every window here would leak the active window’s size into unrelated runtimes.

pub fn window_index_for_pane_id(&self, pane_id: PaneId) -> Option<u32>

Resolves the owning window index for the given pane identity when present.

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Session

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Session

impl PartialEq for Session

fn eq(&self, other: &Session) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Session