1099 symbols, extracted from source. Every type name in a signature links to its own entry; every cross-reference in a doc comment resolves against the same table.
Server 4 types, 3 functions and constants
One tmux server, addressed by the socket it listens on.
Which server answered: tmux, a compatible reimplementation, or not yet determined.
Coarse-grained promises callers choose around.
What this server is known to support, decided without asking it.
- socket_name_arguments ( name : std::string_view ) expected< std::vector< std::string >, SocketError >
-
-L name: a single component resolved under the socket directory.
- socket_path_arguments ( path : std::string_view ) expected< std::vector< std::string >, SocketError >
-
-S path: used verbatim, so the address limit applies to it directly.
Session 3 types, 12 functions and constants
One session, as one listing saw it.
Hashing an entity uses exactly what its equality compares, so values from separate listings key an unordered container consistently.
- attached : BoolFieldHandle< Session >
- client_count : NumberFieldHandle< Session >
- created : NumberFieldHandle< Session >
- group : StringFieldHandle< Session >
- grouped : BoolFieldHandle< Session >
- id : StringFieldHandle< Session >
- name : StringFieldHandle< Session >
- path : StringFieldHandle< Session >
- window_count : NumberFieldHandle< Session >
- is_session_id ( value : std::string_view ) bool
- session_target ( session : std::string_view ) expected< std::string, TargetError >
-
A session target is its id, or its validated name.
Window 4 types, 17 functions and constants
One window, as one listing saw it.
Hashing a window, on the same terms as its equality.
- active : BoolFieldHandle< Window >
- activity : BoolFieldHandle< Window >
- bell : BoolFieldHandle< Window >
- height : NumberFieldHandle< Window >
- id : StringFieldHandle< Window >
- index : NumberFieldHandle< Window >
- layout : StringFieldHandle< Window >
- linked_sessions : NumberFieldHandle< Window >
- name : StringFieldHandle< Window >
- pane_count : NumberFieldHandle< Window >
- session_id : StringFieldHandle< Window >
- session_name : StringFieldHandle< Window >
- width : NumberFieldHandle< Window >
- zoomed : BoolFieldHandle< Window >
- is_window_id ( value : std::string_view ) bool
- window_target ( session : std::string_view , window : std::string_view ) expected< std::string, TargetError >
-
A window target is its id, which needs no session, or
session:window.
Pane 4 types, 26 functions and constants
One pane, as one listing saw it.
Hashing a pane, on the same terms as its equality.
- active : BoolFieldHandle< Pane >
- at_bottom : BoolFieldHandle< Pane >
- at_left : BoolFieldHandle< Pane >
- at_right : BoolFieldHandle< Pane >
- at_top : BoolFieldHandle< Pane >
- command : StringFieldHandle< Pane >
- dead : BoolFieldHandle< Pane >
- exit_status : NumberFieldHandle< Pane >
- height : NumberFieldHandle< Pane >
- id : StringFieldHandle< Pane >
- in_mode : BoolFieldHandle< Pane >
- index : NumberFieldHandle< Pane >
- left : NumberFieldHandle< Pane >
- path : StringFieldHandle< Pane >
- pid : NumberFieldHandle< Pane >
- piping : BoolFieldHandle< Pane >
- session_id : StringFieldHandle< Pane >
- session_name : StringFieldHandle< Pane >
- title : StringFieldHandle< Pane >
- top : NumberFieldHandle< Pane >
- tty : StringFieldHandle< Pane >
- width : NumberFieldHandle< Pane >
- window_id : StringFieldHandle< Pane >
- is_pane_id ( value : std::string_view ) bool
-
Whether a value is written as an id, which is what decides that it needs no separator validation below — not whether tmux would resolve it.
xis an id by this test and no pane by tmux's, and both are right: it carries no separator, so composing it can only produce the caller's own mistake back.
- pane_target ( session : std::string_view , window : std::string_view , pane : std::string_view ) expected< std::string, TargetError >
-
A pane target is its id, or
session:window.pane.
Client 3 types, 10 functions and constants
One attached client, as one listing saw it.
Hashing a client, on the same terms as its equality.
- control_mode : BoolFieldHandle< Client >
- created : NumberFieldHandle< Client >
- height : NumberFieldHandle< Client >
- last_activity : NumberFieldHandle< Client >
- name : StringFieldHandle< Client >
- read_only : BoolFieldHandle< Client >
- session_name : StringFieldHandle< Client >
- terminal : StringFieldHandle< Client >
- tty : StringFieldHandle< Client >
- width : NumberFieldHandle< Client >
Options 2 types
One option as tmux reports it: its name, its value, and the array index it sits at when it is an array option.
Options — Functions 3 functions and constants
- parse_option ( line : std::string_view ) std::optional< OptionEntry >
-
Parse one line.
Returns nullopt for a blank line so callers can feed raw output straight in.
- parse_options ( output : std::string_view ) std::vector< OptionEntry >
- unquote ( value : std::string_view ) std::string
-
Undo the quoting tmux applies when it prints a value.
tmux picks one of four forms, and a reader that knows only one corrupts the rest:
''for an empty value; double quotes when the value contains any of /#';${}; single quotes when it contains a double quote; and otherwise no / quotes at all. Inside any of them the body is escaped the wayvisdoes it / —\t,\n,\\,\ooofor a byte with no printable form — and a / leading tilde is escaped whether or not anything else is. / / This is the inverse of tmux's ownargs_escape, so a value read here and written back is the value that was there.
Keys and bindings 4 functions and constants
-
Named keys tmux accepts, taken from the table in its own key-string.c at the oldest supported release.
Function keys are generated rather than listed, and a single character is handled separately.
- is_function_key ( name : std::string_view ) bool
- is_key_name ( key : std::string_view ) bool
-
Accept a key with any number of C-, M-, or S- modifiers.
- literal_arguments ( text : std::string_view ) expected< std::vector< std::string >, KeyError >
-
Send text exactly as written: the flag, the end of flags, and the text.
--is part of the fragment rather than something a caller appends, because text beginning with a dash is read as anothersend-keysoption without it and that is not a mistake worth making twice. It was made twice: this returned the flag and the text alone,Pane::send_textinserted the separator afterwards, andChain::send_textdid not — so the same text through the two spellings reached tmux as two different commands.
Buffers 1 type, 4 functions and constants
A named piece of text the server holds, outliving the pane it came from.
- created : NumberFieldHandle< Buffer >
- name : StringFieldHandle< Buffer >
- sample : StringFieldHandle< Buffer >
- size : NumberFieldHandle< Buffer >
Terminal capabilities 1 function or constant
- to_string ( implementation : ServerImplementation ) std::string_view ( backend : BackendKind ) std::string_view ( feature : ServerFeature ) std::string_view ( error : CardinalityError ) std::string_view ( kind : FailureKind ) std::string_view ( failure : const CommandFailure & ) std::string ( status : DeliveryStatus ) std::string_view ( session : const Session & ) std::string ( window : const Window & ) std::string ( pane : const Pane & ) std::string ( client : const Client & ) std::string ( error : KeyError ) std::string_view ( kind : NotificationKind ) std::string_view ( error : SocketError ) std::string_view ( error : TargetError ) std::string_view ( error : VersionError ) std::string_view
Versions 1 type, 8 functions and constants
A tmux version, ordered so a feature gate can compare against a literal.
-
The oldest release this library supports, matching the Python package.
- library_version ( ) std::string_view
-
This package's own version, not tmux's.
- parse_version ( output : std::string_view ) expected< Version, VersionError >
-
Parse the first line of
tmux -V, with or without its trailing newline.
Commands 17 types, 5 functions and constants
An attach argv and the private route selecting this server incarnation.
One command this tmux understands.
One argument, carrying whether any part of it is a secret.
The argv a chain becomes: commands joined by tmux's separator.
Move-only result handle for one admitted command; its methods are not concurrent.
Move-only owner of the transport threads, admission bound, and observations.
Whether an argument may appear in a diagnostic, a log, or an error message.
A command that did not produce an answer, and how far it got.
Told about every command, as it finishes.
The maximum number of accepted commands retaining any lifecycle leg.
The first successful close report; every later call returns this value.
What a call waits and holds when the caller did not say.
- CommandObserver : std::function< void(const CommandReport &)>
-
Every member expires on return; a caller keeping any of it copies it.
- alias : StringFieldHandle< Command >
- kCommandSeparator : std::string_view
- name : StringFieldHandle< Command >
- usage : StringFieldHandle< Command >
Control mode 10 types, 4 functions and constants
One held-open control client.
Everything tmux says, until the deadline, as one loop.
Single-pass, and the value it yields is borrowed: advancing invalidates the notification the previous dereference viewed.
One independent view of outside-block events emitted after opening.
The control-mode wire format, decoded into whole events.
How tmux closed a reply block: normally, or reporting a failure.
One reply block, framed between tmux's begin and its terminator.
One command as argv, before it is joined into a control-mode line.
One control event tmux sent unprompted, still as bytes.
A notification's arguments, as views into the notification it was read from.
-
How much of one reply a decoder holds, and how long a single line may grow before the stream is called broken.
A subprocess ends and gives its memory back; a connection does not, so the bound has to be in the decoder rather than in whatever reads it afterwards. The reply bound is the subprocess transport's capture limit, so the same call costs the same memory over either transport. The line bound has no subprocess equivalent: it is the point past which an unterminated line is evidence of a broken stream rather than a large answer.
- layout_contains_pane ( layout_change_text : std::string_view , pane_id : std::string_view ) std::optional< bool >
- parse ( notification : const Notification & ) ParsedNotification ( Notification && ) ParsedNotification
Formats 2 types, 4 functions and constants
Build a format from alternating literal and variable pieces so a caller never hand-concatenates and forgets to escape one of them.
Where a tmux subcommand wants its format string.
- kFormatEscape : std::string_view
-
A separator absent from every format name is not absent from every format value, which is the whole difficulty.
tmux rename-window 'a␞b` is accepted, and one such name used to make every window and pane listing on that server fail to split — data the caller never chose breaking reads of everything else.
So tmux escapes the separator before it can be mistaken for one. U+241B pairs with it and is escaped in turn, which is what makes the transform reversible:
␛Sis a separator that was in the value and␛Eis an escape marker that was, and neither has a second reading.
- kFormatSeparator : std::string_view
-
tmux joins requested formats with a separator that cannot appear in a format name.
U+241E matches the Python implementation's default so both can read the same recorded output.
It is multi-byte, so every tmux this library starts is passed
-u: a tmux that believes the terminal is not UTF-8 substitutes an underscore and no row splits at all.
- escape_literal ( text : std::string_view ) std::string
-
Escape literal text for inclusion in a format string.
- variable ( name : std::string_view ) std::string
-
Wrap a variable name as a substitution.
The name is not escaped: a name is chosen by the caller from tmux's format vocabulary, not built from data.
Queries 1 type, 21 functions and constants
Several expressions combined, all of them or any of them.
-
A borrowed element of a range, rather than a copy of it.
These lookups reference an element of the range they were given, so the range has to outlive the result. That is why they take an lvalue.
-
The related entity is whatever the accessor yields, so a bare flag field can stand in for a predicate here exactly as it does in
matching.
-
The entity on the far side of a to-one link, with the accessor's indirection and qualifiers stripped away.
- all_of ( typename Entity , name : std::string , read : auto , predicate : auto ) typename Entity
- any_of ( typename Entity , name : std::string , read : auto , predicate : auto ) typename Entity
- children_of ( typename Parent , typename Child , rows : const std::vector< Child > & , foreign_key : StringFieldHandle< Child > , key : StringFieldHandle< Parent > ) typename Parent ( typename Parent , typename Child , const std::vector< Child > && , StringFieldHandle< Child > , StringFieldHandle< Parent > ) typename Parent
-
Join two listings on the id one of them carries.
A relation predicate has to reach the related rows without running tmux, so the caller lists both kinds once and links them here. The result borrows the rows it was given, exactly as a filtered view does, so it must not outlive the listing it reads.
-
exactly_onestates that several is a caller error, and says which one.Discussed in Filtering and querying, in practice
- exactly_one_owned ( Range : std::ranges::input_range , range : Range && ) std::ranges::input_range
-
firststates that a caller tolerates extras; it never reports several.
- first_owned ( Range : std::ranges::input_range , range : Range && ) std::ranges::input_range
- is ( typename Entity , name : std::string , read : auto , predicate : auto ) typename Entity
-
An absent to-one link never satisfies
is: a window with no active pane is not a window whose active pane runs an editor.
- lookup_of ( name : std::string_view ) expected< StringOp, LookupParseError >
-
eqis the implicit lookup, matching Python's barefield=value.An empty name reaches here only from a key that carried no separator at all; a key ending in one is refused before this is asked.
- lower ( typename Entity , typename Sink , expr : const FilterExpr< Entity > & , sink : Sink & ) typename Entity
-
A sink receives one call per node in prefix order.
Groups and negations are bracketed by begin/end so a sink never has to count operands itself.
- matching ( typename Entity , expr : FilterExpr< Entity > ) typename Entity
-
matching(expr)is a range adaptor closure so it composes with std views.
- matching ( typename Entity , expr : FilterExpr< Entity > ) typename Entity ( typename Entity , field : BoolFieldHandle< Entity > ) typename Entity
-
matching(expr)is a range adaptor closure so it composes with std views.
- name_of ( op : StringOp ) std::string_view ( op : NumberOp ) std::string_view
- none_of ( typename Entity , name : std::string , read : auto , predicate : auto ) typename Entity
- parent_of ( typename Child , typename Parent , rows : const std::vector< Parent > & , foreign_key : StringFieldHandle< Child > , key : StringFieldHandle< Parent > ) typename Child ( typename Child , typename Parent , const std::vector< Parent > && , StringFieldHandle< Child > , StringFieldHandle< Parent > ) typename Child
-
The same join read the other way: the one row a child points at, or none.
- parse_lookup ( typename Entity , term : std::string_view , fields : std::span< const StringFieldHandle< Entity > > ) typename Entity
-
Parse one
field[__lookup]=valueterm against a caller-supplied field table.The value is taken verbatim after the first
=, so a value containing=or__survives unchanged; only the key is split.
- quantified ( typename Entity , name : std::string , quantifier : Quantifier , read : auto , predicate : auto ) typename Entity
-
To-many and to-one links take different accessors, so they get different builders rather than one that has to compile both shapes.
- replay ( typename Sink , nodes : const LoweredExpression & , sink : Sink & ) typename Sink
-
Replay an already-lowered child into a sink.
Queries — Fields 6 types
A flag on an entity, named for the expression and read through a function pointer rather than a member pointer so the same descriptor works for a field computed from several tmux tokens.
The value a flag's name resolves to in an expression.
A numeric field on an entity, read as a number rather than as the text tmux sends, so 9 orders before 10.
The value a numeric field name resolves to in an expression, whose comparison operators build the node rather than comparing anything.
A field is a named accessor: the name is what a future tmux-format lowering needs, the accessor is what in-memory evaluation needs.
A typed field handle.
Queries — Operators 5 types
How a text field is compared. iequals folds case; the rest do not.
tmux renders a count, a size and an index as text.
Whether a group's operands must all hold or any one of them.
How a filter applies across a relation.
One expression inverted.
Queries — Expressions 2 types, 1 function or constant
A filter over one entity type, as a value.
One node of a filter after it has been reduced to what tmux's -f format language can express.
- LoweredExpression : std::vector< LoweredNode >
-
A whole lowered filter, flat: children are referenced by index rather than owned, so the vector can be walked without recursion.
Snapshots 2 types, 6 functions and constants
Owning row storage, shared by every entity taken from it.
A lock-consistent instant; values may change immediately after it is read.
- capture_lines ( typename Text , Text && ) typename Text ( output : std::string_view ) std::vector< std::string_view >
-
The lines are views into the text, so text that dies at the semicolon takes them with it — and
pane.capture()returns its output by value, which makescapture_lines(*pane.capture())the natural thing to write and a use-after-free to run.Deleted for an rvalue string only: an lvalue string converts as before, and so does a literal.
-
Undo that escaping, in place.
Escaping only ever lengthens, so the decoded bytes fit where the encoded ones were: the write cursor never overtakes the read cursor, nothing moves, and nothing is allocated. Answers the decoded length.
An escape marker followed by anything else is left as written. Output this library asked for contains no such sequence, and failing on one would mean a recording could not carry a literal
␛.
- format_request ( fields : std::span< const std::string_view > ) std::string
-
Build the format argument for one entity's fields, terminating every field so a trailing empty value is still a value rather than a missing column.
The two substitutions nest rather than run in sequence, because tmux applies the inner one to the raw value and the outer one to its result. In that order a value already holding the escape marker is neutralised before the separator pass can produce one; reversed, the two become indistinguishable.
#{s/…/…/:…}predates every tmux this library supports, and neither character is a regular-expression metacharacter.Unconditional, rather than applied only to the fields that could carry a separator. Expanding the substitutions costs about 0.32us per row — a 61-row listing pays 19us, against a process launch of some milliseconds — and a per-field exemption list is a thing to get wrong later, once, silently.
- output_confirms ( captured : std::string_view , wanted : std::string_view , sent : const std::vector< std::string > & = {} ) bool
- split_row ( line : std::string_view , fields : std::size_t , values : std::vector< std::string_view > & ) bool
-
Split one tmux output line into its field values.
The trailing separator emitted by
format_requestproduces one empty tail element, which is dropped; a short or long row is reported rather than padded so a format-name typo cannot masquerade as an empty field.
- without_trailing_blanks ( lines : std::vector< std::string_view > ) std::vector< std::string_view >
-
Drop the blank rows a pane pads its height with, keeping blank lines that have content below them.
Requests 2 types
One tmux command as argv, with no shell between it and tmux.
The commands sent as one group, which tmux runs until one fails.
Errors 9 types, 9 functions and constants
Why a lookup that required exactly one match did not get one.
Why a key name could not be resolved to something tmux accepts.
Why a legacy lookup string could not be read.
Why a socket name or path was rejected before any server was contacted.
Why a target could not be built from a name.
Why a tmux version string could not be read.
Why a control operation stopped.
- as_command_failure ( error : ProtocolError ) CommandFailure ( typename Reason , reason : Reason ) typename Reason
- as_protocol_error ( failure : CommandFailure ) ProtocolError
Constants and enums 11 types, 1 function or constant
How commands reach the server: by spawning a process, or through a backend the caller supplied.
Why a command did not produce an answer, in the order a caller would diagnose them: bad before it left, then how it left, then what came back.
What a notification is, once its name and arguments have been read.
Which part of a pane's screen and scrollback a capture reads.
How to start a control-mode connection, and what it is allowed to buffer.
What one request produced: its reply blocks, and the connection error that ended the exchange if one did.
What a creation command can be told.
- Event : std::variant< ControlBlock, Notification >
-
Anything the parser produces: a reply to something asked, or something tmux said on its own.
The two arrive interleaved on one stream.
Constants and enums — Session 1 type
What a new session is created as, including its first window.
Constants and enums — Window 1 type
What a new window is created as, and where it lands.
Testing utilities 10 types, 8 functions and constants
Environment variables set for the lifetime of this value and restored on destruction, including the ones that were previously unset.
A tmux server that exists for the lifetime of this value.
Whether the test server is addressed by tmux -L name or tmux -S path.
A flag compared against an expected value.
A numeric field compared against a number.
A relation crosses to another entity type, so its child expression cannot live in this variant.
A text field compared against an operand this node owns.
How the test server is started and how long teardown may take.
Names the private tree, the socket and the tmux -L name, so concurrent suites cannot collide and a leftover directory identifies its owner.
What teardown could not clean up, so a suite can fail loudly rather than leave a server behind quietly.
-
Skip unless tmux is at least
major.minor, naming what is missing below it.
-
Skip while tmux is inside a closed range of releases with a known defect.
Both ends are inclusive, and
lastis the newest release still affected — so a fix in 3.6 is written as a window ending at 3.5.
- current_environment ( ) std::vector< std::string >
-
Build and edit a
NAME=VALUEblock for a child process.current_environmentcopies this process's;set_environmentreplaces any existing entry rather than appending;erase_environmentremoves every entry for the name.
- describe_running_tmux ( tmux_binary : const std::filesystem::path & = "tmux" ) std::string
-
What
tmux -Vprinted, verbatim, or "unknown".
- erase_environment ( environment : std::vector< std::string > & , name : std::string_view ) void
-
Resolved once per distinct binary and cached.
A tmux that cannot be run or whose version cannot be parsed reports as the newest possible version, so version-gated tests run and fail rather than silently skipping.
- same_socket_inode ( left : const std::filesystem::path & , right : const std::filesystem::path & ) libtmux::expected< bool, std::string >
- set_environment ( environment : std::vector< std::string > & , name : std::string_view , value : std::string_view ) void
Internal 14 functions and constants
-
What
value()throws when there is none.Named here so a caller who wants an exception at a boundary can catch it in either standard's build.
-
A value or the reason there is not one.
std::expectedwhere the standard library has it, and a drop-in otherwise, so a caller writes the same code either way. Nothing in this library throws to report a tmux failure.
-
The error side of
expected, named for the rare declaration that has to spell it.Returning one is how a function reports a failure.
- mask_whole_occurrences ( text : std::string_view , echo : std::string_view ) std::string
- same_entity_id ( scoped_by_session : bool , left_id : std::string_view , left_session_id : std::string_view , right_id : std::string_view , right_session_id : std::string_view ) bool
- server_over ( backend : std::shared_ptr< const Backend > ) Server
-
Declared so the private constructor has exactly one way in.
Defined in a header this package does not install.
- to_flag ( text : std::string_view ) bool
-
tmux renders flag formats as "1" or "0"; anything else is not the flag.
- to_number ( text : std::string_view ) long long
-
tmux renders every value as text.
These read the three shapes it uses, and answer zero, false or the epoch for a value it did not render — which within the supported version range means tmux had nothing to say, not that the token was unknown.
- to_time ( text : std::string_view ) std::chrono::sys_seconds
-
A factory rather than an alias: an alias template cannot deduce its argument, so
unexpected(error)would stop compiling at every call site.
Other 5 types, 1 function or constant
Several commands built up and sent as one tmux invocation.
Collects a lowered expression.
The storage every entity has, in one place: the snapshot that owns the bytes and which of its rows this entity is.
How far a command is known to have got before something stopped it.
- path_component ( name : std::string_view ) expected< std::string, TargetError >
-
Validate one path component.
Ids skip validation because they contain no separator by construction.
By module 20 modules
-
libtmux 154
- Attach
Command - Buffer
- Chain
- Client
- Command
- Command
Argument - Command
Batch - Command
Executor - Command
Operation - Command
Request - Command
Runtime - Connection
- Entity
Id - Filter
Expr - Format
Builder - Node
Collector - Notification
Range - Notification
Watch - Pane
- Parser
- Server
- Session
- Snapshot
- Window
- Argument
Sensitivity - Backend
Kind - Cardinality
Error - Combine
- Control
Terminal - Delivery
Status - Failure
Kind - Format
Argument - Key
Error - Lookup
Parse Error - Notification
Kind - Number
Op - Quantifier
- Ready
Status - Server
Feature - Server
Implementation - Socket
Error - String
Op - Target
Error - Version
Error - Wait
Path - Bool
Field - Bool
Field Handle - Capture
Options - Command
Failure - Command
Report - Command
Runtime Config - Command
Runtime Shutdown - Command
Runtime Snapshot - Connection
Options - Control
Block - Control
Command - Control
Request - Control
Request Result - Environment
Entry - Execution
Policy - Executor
Options - Lowered
Node - New
Session Options - New
Window Options - Notification
- Number
Field - Number
Field Handle - Option
Entry - Parsed
Notification - Protocol
Error - Respawn
Options - Server
Capabilities - Split
Options - String
Field - String
Field Handle - Version
- Wait
Options - Wait
Result - is
_validation _reason - is
_validation _reason<Cardinality Error> - is
_validation _reason<Key Error> - is
_validation _reason<Lookup Parse Error> - is
_validation _reason<Socket Error> - is
_validation _reason<Target Error> - is
_validation _reason<Version Error> - k
Command Separator - k
Default Line Bytes - k
Default Retained Reply Bytes - k
Format Escape - k
Format Separator - k
Minimum Supported - k
Named Keys - k
Socket Path Limit - all
_of - any
_of - as
_command _failure - as
_protocol _error - capture
_lines - children
_of - decode
_value - escape
_literal - exactly
_one - exactly
_one _owned - first
- first
_owned - format
_request - is
- is
_function _key - is
_key _name - is
_pane _id - is
_session _id - is
_supported - is
_window _id - layout
_contains _pane - library
_version - literal
_arguments - lookup
_of - lower
- matching
- name
_of - none
_of - output
_confirms - pane
_target - parent
_of - parse
- parse
_lookup - parse
_option - parse
_options - parse
_version - path
_component - quantified
- replay
- session
_target - socket
_name _arguments - socket
_path _arguments - split
_row - to
_string - unexpected
- unquote
- variable
- window
_target - without
_trailing _blanks - bad
_expected _access - Command
Observer - Event
- expected
- Lowered
Expression - Pane
Id - Referenced
- Related
Many - Related
One - Session
Id - unexpected
_t - Window
Id
- Attach
-
capabilities.hpp 2
-
libtmux::client 10
-
libtmux::detail 8
-
libtmux::FilterExpr 6
-
libtmux::json_wire 6
-
libtmux::mcp 31
- Tool
Registry - Argument
Type - Effect
- Input
Control - Input
Sink - Nested
Authority - Output
Class - Output
Shape - Process
Reach - Toolset
- Arguments
- Call
Context - Flat
Arguments - Parameter
- Read
Tool Call - Sink
- Structured
Value - Tool
Annotations - Tool
Authority - Tool
Definition - Tool
Error - Tool
Output - Tool
Schema - Tool
Selection - k
Conservative Annotations - configured
_tools - default
_tools - parse
_tool _selection - Argument
Map - Handler
- Tool
Result
- Tool
-
libtmux::NotificationRange 1
-
libtmux::session 9
-
libtmux::tmuxq 1
-
libtmux::window 14
-
libtmux::workspace 8