Swift API reference

Every call in this library throws TmuxError and says so, which lets a program write throws(TmuxError) from top to bottom. The scoped forms — Server/using(_:_:), Server/connected(attachingTo:_:) and Server/withControlMode(attachingTo:_:) — are the exception: they take a closure, and a closure's thrown type cannot be carried out of one.

That is a property of the language rather than a choice made here. Swift 6.2 does not infer a closure literal's thrown type from its body, so a throws(TmuxError) overload of those scopes is unreachable without spelling the closure's own signature at every call site — and even with the type inferred, a scope that can fail on its own behalf has no way to rethrow that failure as the body's error, because there is no union of the two.

So the narrowing happens at the boundary instead of inside the scope:

One wrapper per scope, rather than an annotation per closure.

• Important: This is for work that only fails with TmuxError . Anything else body throws is flattened into TmuxError/invocationFailed(reason:) with its description as the reason, which keeps the signature honest but loses the original type. A body that throws errors of its own should stay untyped and be caught as itself.
• Parameter body: the work to run, typically a scoped call.
• Returns: whatever body returned.
• Throws: TmuxError , either as thrown or as a flattened foreign error.

Arm it in the same invocation that creates the server's first session, and give it the directory holding the socket. Public because the benchmark provisions its own servers — with a counting shim standing in for tmux — and a second copy of this reasoning is a second copy to get wrong.

defer and kill-server both run *in the process that started the server*, which makes them useless in the one case that actually leaks: the run is killed outright by a harness timeout or an impatient operator, and every tmux server it started survives with no owner and no way to reach it. Cleanup that depends on the cleaner surviving is not deterministic.

So the reaper lives inside the tmux server instead, as a background job. It watches the owning process and, once that is gone, removes the directory and kills the server. Three details carry the design:

• The directory goes first. kill ends the server, and tmux kills its jobs when it exits, so anything sequenced after it would not run.
• The server is addressed by pid, not by socket, because the socket is inside the directory just removed.
• #{pid} is left for tmux to expand rather than asked for first, which is what lets arming ride in the same invocation that creates the session. Sent separately, a run killed in the gap between the two leaves a server no reaper ever covered — measurably, under load, about one server in six.
• The interval is whole seconds. Fractions are a GNU and BSD extension that POSIX does not require, and a sleep that rejects its argument turns this into a busy loop per server rather than a slower one. Reaping a second later costs nothing here.

Keys sent before that are echoed with no prompt in front of them, which leaves the prompt to land on the row the command's own output wants. A case looking for a row equal to what it printed is then waiting for something that cannot arrive, and reports it as a timeout naming nothing. One capture settles it for every case that follows.

What the prompt *says* is not portable — sh is dash on Linux and bash on macOS, which prints sh-3.2$ — so readiness is that the pane has drawn anything at all. Until the shell starts it has drawn nothing.

This reads the pane directly rather than through the wait machinery: a fixture that bootstrapped itself with the code under test would make every unrelated case depend on it.

Bounded in wall-clock rather than in attempts. What makes one of these polls slow is the tmux call inside it, so a count of attempts says nothing about how long the loop can run: on a contended machine a generous-looking budget outlives the case's time limit, and the failure reads as a timeout instead of naming the thing that never became true.

The same guarantees as withTmuxServer(_:) — its own server, killed on the way out and reaped if this process is killed outright — for the half of Endpoint that a path-addressed fixture never exercises.

Each case gets its own socket, so cases never see each other's sessions and teardown never touches a server it did not start. The server is bootstrapped with one session named bootstrap: a tmux server exits as soon as its last session goes away, so without one there is nothing to hold it open. Scope assertions to the objects the case created rather than to the server being otherwise empty.