chore(release): prepare irtt-rs 0.10.2

feat(client): filter output by selected event types
chore(release): prepare irtt-rs 0.10.1
2026-10-28 15:30:59 +07:00 · 2026-10-28 15:28:26 +07:00 · 2026-10-28 12:30:02 +07:00 · 2026-10-28 12:17:48 +07:00 · 2026-10-28 11:26:13 +07:00 · 2026-10-28 11:21:15 +07:00
13 changed files with 803 additions and 508 deletions
@@ -240,6 +240,20 @@ release. The format is loosely based on
 ## irtt-rs
 ### 0.10.2
 #### Added
 - Client `--events` filters output by event type, using comma-separated names or repeated options. For example, `--events echo_reply` prints only echo replies. Omitting the option preserves normal output behavior.
 - Explicitly selecting `echo_sent` with `--events` shows those events even with default table columns.
 ### 0.10.1
 #### Fixed
 - The client now responds to SIGINT and SIGTERM while stdout is blocked, so a stalled output reader no longer prevents shutdown.
 - Interrupted measurements preserve partial statistics summaries when output can be written. A shared 250 ms grace period bounds output flushing during shutdown.
 ### 0.10.0
 #### Added
@@ -890,7 +890,7 @@ dependencies = [
 [[package]]
 name = "irtt-rs"
-version = "0.10.0"
+version = "0.10.2"
 dependencies = [
 "chrono",
 "clap",
@@ -2142,9 +2142,9 @@ dependencies = [
 [[package]]
 name = "unicode-width"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+checksum = "ca718471876992059f251e33aafc334346ada08042b7661dd1fe313a9bced557"
 [[package]]
 name = "utf8parse"
@@ -1,97 +1,67 @@
 # irtt-rs
-`irtt-rs` is a Rust implementation of an IRTT-compatible client and server:
+`irtt-rs` is an IRTT-compatible client and server written in Rust. You can use
-finite or continuous UDP latency probing, plus the server side those probes
+it to measure UDP latency for a fixed duration or leave it running
-run against.
+continuously, and run your own server for the probes to talk to.
-This is not the upstream IRTT project. For the original implementation,
+The original IRTT implementation is [heistp/irtt](https://github.com/heistp/irtt),
-protocol background, and broader documentation, see
+which also has protocol background and more documentation. This project is
-[heistp/irtt](https://github.com/heistp/irtt). The installed dispatcher is
+independent, so the installed dispatcher is named `irtt-rs` to keep it from
-named `irtt-rs` rather than `irtt` to avoid conflicting with or being
+conflicting with or being mistaken for `irtt`.
 mistaken for it.
 ## Features
-* Finite and continuous probe sessions
+- Finite and continuous probe sessions
-* Concurrent probing of multiple targets, with staggered or burst pacing
+- Concurrent probing of multiple targets, with staggered or burst pacing
-* Reusable client library with a structured event stream (blocking, Tokio,
+- Reusable client library with a structured event stream (blocking, Tokio,
  or managed)
-* Human-readable table output, plus CSV, TSV, and JSON Lines for scripts and
+- Human-readable table output, plus CSV, TSV, and JSON Lines for scripts and
  monitoring systems, with selectable output columns
-* Optional terminal UI
+- Optional terminal UI
-* Reusable Tokio-native server library
+- Reusable Tokio-native server library
-* UDP server applet with sensible zero-argument defaults and explicit bind
+- UDP server applet you can run without arguments, with options for bind
-  and session-policy options
+  addresses and session policy when you need them
-* Router-friendly multi-applet binary layout
+- A single binary that can run several applets, useful on routers
 ## Comparison with upstream IRTT
-`irtt-rs` is an independent, compatible reimplementation, not a successor or
+`irtt-rs` is useful if you want to watch several targets at once, compare
-replacement for upstream IRTT — [heistp/irtt](https://github.com/heistp/irtt)
+them in a terminal dashboard, or feed selected measurements into a script.
-remains the original implementation. Interoperability is a project goal; see
+You can leave it running with statistics and automatic reconnection, use
-[`docs/INTEROP_COMPARISON.md`](docs/INTEROP_COMPARISON.md) and
+its Rust libraries in your own application, or deploy a single binary on
-[`docs/protocol/`](docs/protocol/) for the black-box interoperability
+a router.
 methodology and protocol baseline this project verifies against. Choose
 between them based on the capabilities and deployment model you need.
-The table below was checked against upstream release
+Upstream IRTT is much more mature, and if you don't need the features
-[v0.9.2](https://github.com/heistp/irtt/releases/tag/v0.9.2) (2026-07-17).
+specific to `irtt-rs`, you should probably use it. It also has more tools
-This project's own interop testing and protocol baseline are currently
+for working with saved results and controlling how probes run, including
-pinned to the prior release, v0.9.1; the wire protocol version number is
+replaying saved JSON reports, timer and clock diagnostics, and client
-unchanged between the two, but v0.9.2 has not itself been exercised against
+payload fill and timing algorithms.
 this project's interop harness.
-| Capability | irtt-rs | upstream IRTT (v0.9.2) |
+See the [detailed comparison](docs/INTEROP_COMPARISON.md) for individual
-| --- | --- | --- |
+features, version coverage, and black-box interoperability testing.
 | Wire protocol | Protocol version 1, verified against upstream v0.9.1 | Protocol version 1 (unchanged in v0.9.2) |
 | Finite probing | Supported, default 10s | Supported, default 1m |
 | Continuous/indefinite operation | Supported (`--continuous` or `--duration 0`), with optional per-target reconnection | Supported via streaming mode (`-s`, added in v0.9.2); computes no statistics at all in that mode |
 | Statistics in continuous mode | Optional running count/min/max/mean/variance per session; no exact medians; bounded IPDV tracking. Use `--no-stats` or omit the `stats` feature to disable collection | None in streaming mode — raw/event output only, by design, to avoid unbounded memory |
 | Multi-target probing (one invocation) | Supported, with labels and staggered/burst pacing | Not supported — one remote address per invocation |
 | Terminal UI | `irtt-tui`, a live graph/dashboard applet | Not present |
 | Output formats | table, csv, tsv, jsonl, with selectable columns | Text summary, JSON (optionally gzip to file), and a fixed-field raw mode; no CSV/TSV and no column selection |
 | Client/server library API | Separate, independently versioned Rust crates (`irtt-client`, `irtt-server`) | One combined Go package exposing both roles |
 | Server: multiple listeners | `ServerSet` supervises several listeners in one process | `ListenAndServe` also serves multiple requested addresses |
 | Server: wildcard reply-source | Default behavior on Linux/macOS/FreeBSD; refused elsewhere rather than served incorrectly | Opt-in via `--set-src-ip`, with a documented per-packet allocation cost |
 | Server: zero-argument bind | Binds the wildcard address on both families by default, gated by the platform check above | Binds the wildcard address on both families by default; no documented platform gate |
 | Prebuilt release binaries | Published for six target triples | None published; install via `go install` or manual build |
 Upstream has capabilities this project does not implement: a `report`
 subcommand for replaying saved JSON results, benchmarking and
 timer/clock-diagnostic subcommands, client-side payload fill and
 don't-fragment/wait-strategy/timer-algorithm controls, an operator-configurable
 server-side fill policy (this project's server always honors a session's
 negotiated fill request, with a fixed fallback pattern, but has no equivalent
 to upstream's flags for restricting or overriding it), syslog logging, and
 bundled systemd/OpenRC service files.
 This project has capabilities upstream does not implement: multi-target
 probing with labels, the terminal UI, CSV/TSV output with selectable
 columns, a quantified and actively-warned memory-retention model for
 long-running client sessions, and best-effort Linux kernel-timestamp
 preference for its own send/receive endpoint.
 ## Installation
-The build requires Rust 1.88 or newer.
+Prebuilt binaries for supported platforms are available on the
 [GitHub Releases](https://github.com/Lochnair/irtt-rs/releases) page.
-Install the latest release from crates.io:
+Alternatively, install from crates.io using Rust 1.88 or newer:
 ```sh
 cargo install irtt-rs --locked
 ```
-This installs the `irtt-rs` dispatcher plus dedicated `irtt-client`,
+This installs the `irtt-rs` dispatcher along with dedicated `irtt-client`,
-`irtt-tui`, and `irtt-server` binaries. Each applet can also be built in
+`irtt-tui`, and `irtt-server` binaries. If you only need the client, you can
-isolation with `--no-default-features` plus the applet's own feature, for
+disable the other applets and statistics:
 example a lightweight client-only install without statistics:
 ```sh
 cargo install irtt-rs --locked --no-default-features --features client
 ```
-Add `stats` (`--features client,stats`) to retain statistics in a client-only
+This installs `irtt-client` and the `irtt-rs` dispatcher. Add `stats`
-build. Statistics are enabled by default; the TUI always enables them.
+(`--features client,stats`) to retain statistics in a client-only build.
 Statistics are enabled by default; the TUI always enables them.
 For development, or to install directly from a checkout:
@@ -131,30 +101,56 @@ Watch the same session live in the terminal UI:
 irtt-tui netperf-eu.bufferbloat.net:2112
 ```
-Run a server with sensible defaults — no `--bind` needed:
+To run your own server, you can leave out `--bind` and use the defaults:
 ```sh
 irtt-server
 ```
 ### Dynamic targets from stdin
 If another application decides which servers to probe, `--targets-stdin`
 lets it change targets without restarting the client. It works in
 continuous mode:
 ```sh
 irtt-client --continuous --targets-stdin --reconnect --no-stats \
  --format csv --columns event,target,seq,rd_us,sd_us
 ```
 Send one comma-separated target set per line to stdin, for example:
 ```text
 ams=ams.example:2112,lhr=lhr.example:2112
 ams=ams.example:2112
 []
 ```
 Each line gives the complete desired target set. Unchanged targets keep
 running, removed targets stop, and new or changed targets start. Use `[]`
 to clear all targets without exiting.
 The CSV includes an `event` column so your script can distinguish
 `echo_reply` measurements from other events.
 Keep stdin open while controlling the client. Closing it sends EOF and stops the run gracefully.
 See [Dynamic target sets from standard input](docs/irtt-client.md#dynamic-target-sets-from-standard-input)
 for the full syntax and behavior.
 ## Documentation
-* [`docs/irtt-client.md`](docs/irtt-client.md) — target syntax, output
+- [`docs/irtt-client.md`](docs/irtt-client.md): target syntax, output
  formats and columns, measurement field definitions, finite/continuous
  memory behavior, kernel timestamps.
-* [`docs/irtt-tui.md`](docs/irtt-tui.md) — controls, continuous default,
+- [`docs/irtt-tui.md`](docs/irtt-tui.md): controls, continuous default,
  retained history.
-* [`docs/irtt-server.md`](docs/irtt-server.md) — bind defaults and
+- [`docs/irtt-server.md`](docs/irtt-server.md): bind defaults and
  overrides, wildcard listener behavior, session policy, HMAC.
-* [`docs/irtt-rs.md`](docs/irtt-rs.md) — the multicall dispatcher, applet
+- [`docs/irtt-rs.md`](docs/irtt-rs.md): the multicall dispatcher, applet
  binary names, feature-gated builds.
 * [docs.rs](https://docs.rs) for the library crates below.
 * [`docs/protocol/`](docs/protocol/) and
  [`docs/INTEROP_COMPARISON.md`](docs/INTEROP_COMPARISON.md) for the wire
  protocol specification and interoperability validation against upstream
  `irtt`.
-Every applet also documents its full option list with `--help`.
+You can also run any applet with `--help` for its full option list.
 ## Crates
@@ -166,9 +162,6 @@ Every applet also documents its full option list with `--help`.
 | [`irtt-stats`](crates/irtt-stats) | [crates.io](https://crates.io/crates/irtt-stats) | Statistics aggregation over `irtt-client` events ([docs.rs](https://docs.rs/irtt-stats)) |
 | [`irtt-proto`](crates/irtt-proto) | [crates.io](https://crates.io/crates/irtt-proto) | Low-level wire protocol encode/decode ([docs.rs](https://docs.rs/irtt-proto)) |
 Each library crate has its own crates.io README describing what it's for and
 when to use it instead of `irtt-client`/`irtt-server` directly.
 ## Binaries and features
 | Build | Binaries |
@@ -188,7 +181,3 @@ cargo test --workspace --locked
 cargo test --workspace --doc --all-features --locked
 cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
 ```
 See [`AGENTS.md`](AGENTS.md) for architecture, testing policy, and the
 clean-room provenance boundary this project maintains against upstream
 `irtt`.
@@ -1,6 +1,6 @@
 [package]
 name = "irtt-rs"
-version = "0.10.0"
+version = "0.10.2"
 description = "IRTT-compatible client, TUI, and server applications"
 edition.workspace = true
 license.workspace = true
@@ -101,12 +101,22 @@ pub struct ClientArgs {
    )]
    pub format: OutputFormat,
    /// Filter output by event type.
    #[arg(
        long,
        value_name = "EVENTS",
        value_delimiter = ',',
        value_enum,
        long_help = "Filter output by event type. Accepts comma-separated names or repeated options. If omitted, the normal output behavior is unchanged."
    )]
    pub events: Vec<EventKind>,
    /// Comma-separated event row columns, or default/all.
    #[arg(
        short = 'c',
        long,
        value_name = "COLUMNS",
-        long_help = "Comma-separated event row columns, or default/all.\n\nThe default table columns are compact and hide echo_sent rows. Custom table columns include all event rows. Run --list-columns to see valid names."
+        long_help = "Comma-separated event row columns, or default/all.\n\nThe default table columns are compact and hide echo_sent rows unless explicitly selected with --events. Custom table columns include all event rows. Run --list-columns to see valid names."
    )]
    pub columns: Option<String>,
@@ -189,6 +199,29 @@ impl std::ops::Deref for ClientArgs {
    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
 #[value(rename_all = "snake_case")]
 pub enum EventKind {
    SessionStarted,
    NoTestCompleted,
    SessionClosed,
    EchoSent,
    EchoReply,
    Loss,
    Duplicate,
    Late,
    Warning,
 }
 impl EventKind {
    pub(super) fn name(self) -> String {
        self.to_possible_value()
            .expect("all event kinds have a CLI value")
            .get_name()
            .to_owned()
    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
 pub enum OutputFormat {
    /// Readable terminal table output.
@@ -12,12 +12,13 @@ use irtt_client::{
 #[cfg(feature = "stats")]
 use irtt_stats::{EventStatsUpdate, IpdvPairUpdate};
-use super::args::{HeaderMode, OutputFormat};
+use super::args::{EventKind, HeaderMode, OutputFormat};
 use crate::cmd::format::{format_duration, format_signed_duration, ABSENT};
 #[derive(Debug, Clone)]
 pub(super) struct OutputConfig {
    format: OutputFormat,
    events: Vec<EventKind>,
    columns: Vec<Column>,
    header: HeaderMode,
    default_table_rows: bool,
@@ -30,6 +31,7 @@ impl OutputConfig {
        columns: Option<&str>,
        header: HeaderMode,
        verbose: bool,
        events: Vec<EventKind>,
    ) -> Result<Self, String> {
        let uses_default_columns = columns
            .map(|columns| columns.trim() == "default")
@@ -42,6 +44,7 @@ impl OutputConfig {
        Ok(Self {
            format,
            events,
            columns,
            header,
            default_table_rows,
@@ -102,7 +105,10 @@ impl OutputConfig {
        #[cfg(feature = "stats")] stats: Option<&EventStatsUpdate>,
    ) -> Option<String> {
        let row = OutputRow::from_event(event);
-        if self.default_table_rows && row.is_default_table_hidden() {
+        if !self.events.is_empty() && !self.events.contains(&row.event_kind()) {
            return None;
        }
        if self.events.is_empty() && self.default_table_rows && row.is_default_table_hidden() {
            return None;
        }
@@ -322,17 +328,17 @@ impl OutputRow {
        }
    }
-    fn event_name(&self) -> &'static str {
+    fn event_kind(&self) -> EventKind {
        match self {
-            Self::SessionStarted(_) => "session_started",
+            Self::SessionStarted(_) => EventKind::SessionStarted,
-            Self::NoTestCompleted(_) => "no_test_completed",
+            Self::NoTestCompleted(_) => EventKind::NoTestCompleted,
-            Self::SessionClosed { .. } => "session_closed",
+            Self::SessionClosed { .. } => EventKind::SessionClosed,
-            Self::EchoSent { .. } => "echo_sent",
+            Self::EchoSent { .. } => EventKind::EchoSent,
-            Self::EchoReply(_) => "echo_reply",
+            Self::EchoReply(_) => EventKind::EchoReply,
-            Self::Loss { .. } => "loss",
+            Self::Loss { .. } => EventKind::Loss,
-            Self::Duplicate { .. } => "duplicate",
+            Self::Duplicate { .. } => EventKind::Duplicate,
-            Self::Late { .. } => "late",
+            Self::Late { .. } => EventKind::Late,
-            Self::Warning { .. } => "warning",
+            Self::Warning { .. } => EventKind::Warning,
        }
    }
@@ -784,7 +790,7 @@ fn render_jsonl_row(row: &OutputRow, columns: &[Column], context: RenderContext<
 fn cell_for(row: &OutputRow, column: Column, context: RenderContext<'_>) -> Option<CellValue> {
    match column {
        Column::Target => context.target.map(CellValue::text),
-        Column::Event => Some(CellValue::text(row.event_name())),
+        Column::Event => Some(CellValue::text(row.event_kind().name())),
        Column::Seq => row.seq().map(|seq| CellValue::Unsigned(u128::from(seq))),
        Column::Remote => row
            .remote()
@@ -3,12 +3,13 @@ use std::{
    io::{self, BufRead, Write},
    sync::Arc,
    thread,
    time::Duration,
 };
 use irtt_client::{
    managed::{
        ManagedClient, ManagedCommandApplyError, ManagedEndReason, ManagedEvent,
-        ManagedTargetEndReason, ManagedTargetOutcome, TargetInstance,
+        ManagedEventTryRecvError, ManagedTargetEndReason, ManagedTargetOutcome, TargetInstance,
    },
    ClientEvent,
 };
@@ -18,8 +19,7 @@ use super::{args::ClientArgs, output::OutputConfig};
 use crate::shared::client::{
    parse_stdin_target_set,
    session::{
-        drain_final_events, peer_close_run_error, request_managed_stop_for_peer_close,
+        peer_close_run_error, request_managed_stop_for_peer_close, request_managed_stop_once,
        request_managed_stop_once,
    },
    worker::ManagedWorker,
    ManagedRunSetup, TargetSpec, STDIN_MAX_DESIRED_TARGETS, STDIN_OUTCOME_HISTORY_LIMIT,
@@ -36,6 +36,63 @@ use irtt_client::managed::ManagedStatus;
 use std::collections::{BTreeMap, BTreeSet};
 const MAX_STDIN_RECORD_BYTES: usize = 64 * 1024;
 const INTERRUPTED_OUTPUT_GRACE: Duration = Duration::from_millis(250);
 // The frontend only renders into memory. This thread is the sole stdout owner;
 // dropping its JoinHandle deliberately detaches a writer blocked in a pipe.
 struct StdoutWriter {
    sender: tokio::sync::mpsc::Sender<Vec<u8>>,
    shutdown: tokio::sync::watch::Receiver<bool>,
    grace_deadline: Option<tokio::time::Instant>,
 }
 impl StdoutWriter {
    // Measurement output stops waiting for capacity as soon as interrupted.
    async fn send(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
        let mut shutdown = self.shutdown.clone();
        tokio::select! {
            biased;
            _ = shutdown.wait_for(|requested| *requested) => {
                buffer.clear();
                Ok(())
            }
            result = self.enqueue(buffer) => result,
        }
    }
    // Summaries and writer completion share one grace period, regardless of
    // the number of targets. Normal output never has a delivery deadline.
    async fn send_summary(&mut self, buffer: &mut Vec<u8>) -> io::Result<()> {
        let mut shutdown = self.shutdown.clone();
        tokio::select! {
            biased;
            _ = shutdown.wait_for(|requested| *requested) => {
                let deadline = *self.grace_deadline.get_or_insert_with(|| {
                    tokio::time::Instant::now() + INTERRUPTED_OUTPUT_GRACE
                });
                match tokio::time::timeout_at(deadline, self.enqueue(buffer)).await {
                    Ok(result) => result,
                    Err(_) => { buffer.clear(); Ok(()) }
                }
            }
            result = self.enqueue(buffer) => result,
        }
    }
    async fn enqueue(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
        if !buffer.is_empty() {
            // Take ownership only once capacity is available. Normal operation
            // preserves ordering without dropping rendered chunks.
            let permit = self
                .sender
                .reserve()
                .await
                .map_err(|_| io::Error::other("stdout writer stopped accepting output"))?;
            permit.send(std::mem::take(buffer));
        }
        Ok(())
    }
 }
 pub async fn run_stream(
    args: ClientArgs,
@@ -45,6 +102,64 @@ pub async fn run_stream(
        print!("{}", OutputConfig::list_columns());
        return Ok(());
    }
    let (sender, mut receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(64);
    let (completed, mut completion) = tokio::sync::oneshot::channel();
    let writer = thread::Builder::new()
        .name("irtt-stdout".to_owned())
        .spawn(move || {
            let result = (|| {
                let mut stdout = io::LineWriter::new(io::stdout().lock());
                while let Some(chunk) = receiver.blocking_recv() {
                    stdout.write_all(&chunk)?;
                }
                stdout.flush()
            })();
            let _ = completed.send(result);
        })?;
    let mut output = StdoutWriter {
        sender,
        shutdown: shutdown.clone(),
        grace_deadline: None,
    };
    let run_shutdown = shutdown.clone();
    let result = tokio::select! {
        biased;
        result = &mut completion => {
            // Dropping the run future stops and joins its ManagedWorker first.
            writer.join().map_err(|_| io::Error::other("stdout writer thread panicked"))?;
            result.map_err(|_| io::Error::other("stdout writer completed without a result"))??;
            return Err(io::Error::other("stdout writer stopped unexpectedly").into());
        }
        result = run_stream_output(args, run_shutdown, &mut output) => result,
    };
    let grace_deadline = output.grace_deadline;
    drop(output);
    // An interrupt during normal flushing also starts the bounded grace period.
    let written = tokio::select! {
        biased;
        _ = shutdown.wait_for(|requested| *requested) => {
            let deadline = grace_deadline.unwrap_or_else(|| {
                tokio::time::Instant::now() + INTERRUPTED_OUTPUT_GRACE
            });
            match tokio::time::timeout_at(deadline, &mut completion).await {
                Ok(written) => written,
                Err(_) => return result,
            }
        }
        result = &mut completion => result,
    };
    writer
        .join()
        .map_err(|_| io::Error::other("stdout writer thread panicked"))?;
    written.map_err(|_| io::Error::other("stdout writer completed without a result"))??;
    result
 }
 async fn run_stream_output(
    args: ClientArgs,
    mut shutdown: tokio::sync::watch::Receiver<bool>,
    output: &mut StdoutWriter,
 ) -> Result<(), Box<dyn std::error::Error>> {
    let setup = tokio::select! {
        result = args.prepare() => result.map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?,
        _ = shutdown.wait_for(|requested| *requested) => return Ok(()),
@@ -56,6 +171,7 @@ pub async fn run_stream(
        args.columns.as_deref(),
        args.header,
        args.verbose,
        args.events.clone(),
    )
    .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
    #[cfg(feature = "stats")]
@@ -63,7 +179,7 @@ pub async fn run_stream(
        eprintln!("{warning}");
    }
    if setup.stdin_controlled {
-        return run_stdin_stream(setup, output_config, shutdown, &args).await;
+        return run_stdin_stream(setup, output_config, shutdown, &args, output).await;
    }
    let continuous = args.is_continuous();
@@ -87,7 +203,7 @@ pub async fn run_stream(
    let mut events = handle.subscribe()?;
    let mut status = handle.subscribe_status();
    let owner = ManagedWorker::start(task, handle.clone())?;
-    let mut stdout = io::LineWriter::new(io::stdout().lock());
+    let mut stdout = Vec::new();
    let mut stream_output = StreamOutput {
        #[cfg(feature = "stats")]
        continuous: args.is_continuous(),
@@ -134,14 +250,18 @@ pub async fn run_stream(
        ) {
            drop(handle.stop());
        }
-        if snapshot.final_outcome.is_some() {
+        if interrupted || snapshot.final_outcome.is_some() {
            break;
        }
        tokio::select! {
-            _ = shutdown.changed(), if !interrupted => {}
+            _ = shutdown.changed() => {}
            changed = status.changed() => { if changed.is_err() { break; } }
            event = events.recv() => match event {
-                Ok(event) => process_event(event, &mut stream_output, #[cfg(feature = "stats")] &mut stats, &mut terminal_targets)?,
+                Ok(event) => {
                    if *shutdown.borrow() { continue; }
                    process_event(event, &mut stream_output, #[cfg(feature = "stats")] &mut stats, &mut terminal_targets)?;
                    output.send(stream_output.out).await?;
                }
                Err(tokio::sync::broadcast::error::RecvError::Lagged(count)) => {
                    dropped_events = dropped_events.saturating_add(count);
                }
@@ -153,15 +273,24 @@ pub async fn run_stream(
        eprintln!("interrupted, closing managed run...");
    }
    let outcome = owner.join().await?;
-    drain_final_events(&mut events, &mut dropped_events, |event| {
+    while !*shutdown.borrow() {
        match events.try_recv() {
            Ok(event) => {
                process_event(
                    event,
                    &mut stream_output,
                    #[cfg(feature = "stats")]
                    &mut stats,
                    &mut terminal_targets,
-        )
+                )?;
-    })?;
+                output.send(stream_output.out).await?;
            }
            Err(ManagedEventTryRecvError::Lagged(count)) => {
                dropped_events = dropped_events.saturating_add(count);
            }
            Err(ManagedEventTryRecvError::Empty | ManagedEventTryRecvError::Closed) => break,
        }
    }
    if let Some(warning) = dropped_event_warning(dropped_events) {
        eprintln!("{warning}");
    }
@@ -212,9 +341,10 @@ pub async fn run_stream(
                writeln!(stream_output.out, "target: {}", target.label)?;
            }
            stream_output.print_summary(target_stats)?;
            output.send_summary(stream_output.out).await?;
        }
    }
-    stream_output.out.flush()?;
+    output.send_summary(stream_output.out).await?;
    if let Some(error) = terminal_error {
        return Err(error.into());
    }
@@ -476,6 +606,7 @@ async fn run_stdin_stream(
    output_config: OutputConfig,
    mut shutdown: tokio::sync::watch::Receiver<bool>,
    args: &ClientArgs,
    output: &mut StdoutWriter,
 ) -> Result<(), Box<dyn std::error::Error>> {
    if *shutdown.borrow() {
        return Ok(());
@@ -496,7 +627,7 @@ async fn run_stdin_stream(
    let (updates, mut stdin) = tokio::sync::watch::channel(StdinUpdate::Targets(Vec::new()));
    spawn_stdin_target_reader(updates)?;
-    let mut stdout = io::LineWriter::new(io::stdout().lock());
+    let mut stdout = Vec::new();
    let mut stream_output = StreamOutput {
        #[cfg(feature = "stats")]
        continuous: args.is_continuous(),
@@ -528,10 +659,19 @@ async fn run_stdin_stream(
    let mut summary_targets = None;
    loop {
        let snapshot = status.borrow_and_update().clone();
        if stop.is_none() {
        if *shutdown.borrow() {
            stop = Some(StdinStop::Interrupted);
-            } else if stdin_changed || stdin.has_changed().unwrap_or(true) {
+            #[cfg(feature = "stats")]
            {
                summary_targets = Some(stats.keys().cloned().collect());
            }
            if request_managed_stop_once(&mut stop_requested) {
                drop(handle.stop());
            }
            break;
        }
        if stop.is_none() {
            if stdin_changed || stdin.has_changed().unwrap_or(true) {
                stdin_changed = false;
                match stdin.borrow_and_update().clone() {
                    StdinUpdate::Targets(specs) => {
@@ -595,7 +735,7 @@ async fn run_stdin_stream(
            break;
        }
        tokio::select! {
-            _ = shutdown.changed(), if stop.is_none() => {}
+            _ = shutdown.changed() => {}
            _ = stdin.changed(), if stop.is_none() => { stdin_changed = true; }
            changed = status.changed() => { if changed.is_err() { break; } }
            result = async { preparing.as_mut().expect("guarded target preparation").await }, if preparing.is_some() && stop.is_none() => {
@@ -645,9 +785,11 @@ async fn run_stdin_stream(
            }
            event = events.recv() => match event {
                Ok(event) => {
                    if *shutdown.borrow() { continue; }
                    process_stdin_event(event, &mut stream_output, #[cfg(feature = "stats")] &mut stats, &mut terminal_targets)?;
                    #[cfg(feature = "stats")]
                    reconcile_stdin_stats(&mut stats, &status.borrow(), summary_targets.as_ref());
                    output.send(stream_output.out).await?;
                }
                Err(tokio::sync::broadcast::error::RecvError::Lagged(count)) => {
                    dropped_events = dropped_events.saturating_add(count);
@@ -658,15 +800,24 @@ async fn run_stdin_stream(
    }
    let outcome = owner.join().await?;
-    drain_final_events(&mut events, &mut dropped_events, |event| {
+    while !*shutdown.borrow() {
        match events.try_recv() {
            Ok(event) => {
                process_stdin_event(
                    event,
                    &mut stream_output,
                    #[cfg(feature = "stats")]
                    &mut stats,
                    &mut terminal_targets,
-        )
+                )?;
-    })?;
+                output.send(stream_output.out).await?;
            }
            Err(ManagedEventTryRecvError::Lagged(count)) => {
                dropped_events = dropped_events.saturating_add(count);
            }
            Err(ManagedEventTryRecvError::Empty | ManagedEventTryRecvError::Closed) => break,
        }
    }
    if let Some(warning) = dropped_event_warning(dropped_events) {
        eprintln!("{warning}");
    }
@@ -682,6 +833,13 @@ async fn run_stdin_stream(
        );
    }
    if *shutdown.borrow() && !matches!(stop, Some(StdinStop::Interrupted)) {
        stop = Some(StdinStop::Interrupted);
        #[cfg(feature = "stats")]
        {
            summary_targets = Some(stats.keys().cloned().collect());
        }
    }
    #[cfg(feature = "stats")]
    {
        let print_summary =
@@ -703,10 +861,11 @@ async fn run_stdin_stream(
                    )?;
                }
                stream_output.print_summary(stats)?;
                output.send_summary(stream_output.out).await?;
            }
        }
    }
-    stream_output.out.flush()?;
+    output.send_summary(stream_output.out).await?;
    match stop {
        Some(StdinStop::Fatal(error)) => Err(error.into()),
@@ -1,5 +1,7 @@
 #[cfg(feature = "tui")]
 use irtt_client::managed::{ManagedEvent, ManagedEventSubscription, ManagedEventTryRecvError};
 #[cfg(feature = "tui")]
 pub(crate) fn drain_final_events<E>(
    events: &mut ManagedEventSubscription,
    dropped_events: &mut u64,
@@ -1,4 +1,38 @@
-# Interop Comparison
+# Interop comparison
 ## Feature comparison
 This compares `irtt-rs` with the original [heistp/irtt](https://github.com/heistp/irtt)
 release [v0.9.2](https://github.com/heistp/irtt/releases/tag/v0.9.2) (2026-07-17).
 The aim is for the two implementations to interoperate, though the interop
 tests and verified protocol baseline still use upstream v0.9.1. Both
 upstream releases use wire protocol version 1, but v0.9.2 hasn't been run
 through this project's interop harness. See [`docs/protocol/`](protocol/)
 for the verified protocol baseline.
 | Capability | irtt-rs | Upstream IRTT (v0.9.2) |
 | --- | --- | --- |
 | Wire protocol | Version 1, verified against upstream v0.9.1 | Version 1, unchanged from v0.9.1 |
 | Finite probing | Default duration of 10s | Default duration of 1m |
 | Continuous probing | `--continuous` or `--duration 0`, with optional per-target reconnection | Streaming mode (`-s`, added in v0.9.2) |
 | Statistics in continuous mode | Optional count/min/max/mean/variance per session, with bounded IPDV tracking and no exact medians. Disable with `--no-stats` or omit the `stats` feature | No statistics; raw/event output only to avoid unbounded memory |
 | Multiple targets | Labels and staggered/burst pacing in one invocation | One remote address per invocation |
 | Terminal UI | Live graph and dashboard through `irtt-tui` | None |
 | Output formats | table, csv, tsv, jsonl, with selectable columns | Text summary, JSON (optionally gzip to file), and fixed-field raw output; no CSV/TSV or column selection |
 | Replay saved results | Not implemented | `report` subcommand for saved JSON results |
 | Benchmarking and clock diagnostics | Not implemented | Benchmarking and timer/clock-diagnostic subcommands |
 | Client payload and timing controls | No client-side payload fill or don't-fragment/wait-strategy/timer-algorithm controls | Client-side payload fill and controls for don't-fragment, wait strategy, and timer algorithm |
 | Kernel timestamps | Best-effort preference on Linux for its own send/receive endpoint | Not implemented |
 | Server listeners | Several listeners in one process, supervised by `ServerSet` | Multiple requested addresses through `ListenAndServe` |
 | Server wildcard reply-source selection | Default on Linux/macOS/FreeBSD; other platforms refuse wildcard binds | Opt-in through `--set-src-ip`, with a documented per-packet allocation cost |
 | Server default bind | Wildcard addresses for both families, subject to the platform restriction above | Wildcard addresses for both families; no documented platform restriction |
 | Server payload fill policy | Honors the session's negotiated request, with a fixed fallback pattern; no options to restrict or override it | Options to restrict or override client fill requests |
 | Syslog logging | Not implemented | Supported |
 | Bundled service files | None | systemd and OpenRC |
 | Client/server library API | Separate, independently versioned Rust crates (`irtt-client`, `irtt-server`) | One Go package exposing both roles |
 | Prebuilt release binaries | Published for six target triples | None published; install through `go install` or build manually |
 ## Black-box testing
 `scripts/compare_irtt_clients.py` is a black-box comparison harness for running
 upstream `irtt` and `irtt-rs` clients concurrently against the same server. It
@@ -8,7 +42,7 @@ summaries, and comparison JSON under `target/interop-comparisons` by default.
 The harness does not inspect upstream source or tests. It only invokes the
 upstream executable.
-## Remote or Existing Local Server
+### Remote or Existing Local Server
 Build `irtt-rs` and ensure an upstream `irtt` executable is available:
@@ -36,7 +70,7 @@ python3 scripts/compare_irtt_clients.py \
 Remote comparisons are useful for smoke coverage, but Internet paths are noisy
 and can make RTT/loss differences hard to interpret.
-## Linux Netem Interop
+### Linux Netem Interop
 `scripts/run_netem_interop_ci.py` provides deterministic Linux CI coverage using
 network namespaces, a veth pair, and `tc netem`. It is intended for GitHub
@@ -69,7 +103,7 @@ Netem qdiscs are applied on veth egress:
 Cleanup deletes qdiscs, stops the server process, and removes both namespaces in
 a `finally` path.
-### Scenarios
+#### Scenarios
 The CI harness implements:
@@ -86,7 +120,7 @@ both clients run in the same client namespace against the same server namespace,
 relative one-way shape is still useful for diagnostics, but the CI pass/fail
 policy is based on RTT and packet behavior.
-### Pass/Fail Policy
+#### Pass/Fail Policy
 Deterministic scenarios fail when:
@@ -113,7 +147,7 @@ python3 scripts/run_netem_interop_ci.py \
  --loss-rate-warning-pct 12
 ```
-### Manual Linux Usage
+#### Manual Linux Usage
 On Linux:
@@ -1,29 +1,31 @@
 # irtt-client
-## NAME
+## Name
 irtt-client - IRTT-compatible stream client
-## SYNOPSIS
+## Synopsis
 `irtt-client` [*OPTIONS*] [*[LABEL=]TARGET[@hmac=KEY]*]...
 `irtt-client` `--list-columns`
-## DESCRIPTION
+## Description
-`irtt-client` probes one or more IRTT-compatible servers over UDP and prints
+Use `irtt-client` to probe one or more IRTT-compatible servers over UDP.
-per-probe measurement events as they arrive, plus a final summary for
+It prints measurement events as they arrive, and a final summary when the
-eligible runs.
+run qualifies for one.
-## TARGETS
+## Targets
-Every target argument accepts `[LABEL=]TARGET[@hmac=KEY]`. An optional
+Write targets as `[LABEL=]TARGET[@hmac=KEY]`. You can add a `LABEL=` prefix
-`LABEL=` prefix assigns the logical target name used in output; without it,
+to choose the name shown in output. If you leave it out, the client uses
-the target string itself is used as the label. Labeled and unlabeled targets
+the target string as its label. You can mix labeled and unlabeled targets
-can be freely mixed in one argument list. Prefer explicit labels for
+in the same command.
-long-running dynamic target sets: the label is the stable target identity
+
-across replacements.
+If you're changing targets during a long run, give them explicit labels.
 The label identifies the same logical target when you replace its
 configuration.
 ```sh
 irtt-client host-a:2112
@@ -37,29 +39,31 @@ overrides it for that target, and `@hmac=` explicitly disables HMAC for that
 target. The modifier uses `@`, not a shell command separator; quote an argument
 if its key needs shell quoting.
-Global `--hmac KEY` and per-target `@hmac=KEY` accept plain-text keys or hexadecimal keys prefixed with `0x`. For example, `secret` and `0x736563726574` are equivalent.
+Both the global `--hmac KEY` and per-target `@hmac=KEY` accept plain-text
 keys or hexadecimal keys prefixed with `0x`. For example, `secret` and
 `0x736563726574` are equivalent.
 Target syntax supports these backslash escapes in labels, addresses, and HMAC
 values: `\\` for a literal backslash, `\@` for a literal `@`, `\=` for a
 literal `=`, and `\;` for a literal semicolon. Escaping `@` is necessary in a
 label or address when it would otherwise begin `@hmac=`; escaping the first
-`=` is how an unlabeled target or a label can contain that character. An `=` in an HMAC value does not need escaping. Positional
+`=` lets an unlabeled target or a label contain that character. An `=` in
-target arguments may contain a raw comma; stdin target sets have the additional
+an HMAC value does not need escaping. Positional target arguments may
-`\,` escape described below.
+contain a raw comma; stdin target sets have the additional `\,` escape
 described below.
 Shells process unquoted backslashes and characters such as semicolons before
 the client sees them. Single-quote a target when it contains parser escapes,
 for example `'west\=edge=host\@hmac=literal@hmac=a\;b\\c'`, so the
 backslashes reach `irtt-client` unchanged.
-Multiple targets are probed concurrently. By default, a multi-target session
+The client probes multiple targets concurrently. By default it staggers
-uses **staggered** pacing, spacing active targets across the probe interval;
+them across the probe interval. If you want to send one probe to every
-pass `--pacing burst` to send one probe to every active target back-to-back
+active target back-to-back once per interval, use `--pacing burst`.
-once per interval instead. Final per-target summaries print in the order
+Final summaries follow the command-line target order, regardless of which
-targets were supplied on the command line, not the order in which they
+target finished first or how their labels sort.
 finish or their labels sort alphabetically.
-## ADDRESS FAMILY
+## Address family
 By default, each target uses the first address returned by the system resolver,
 whether IPv4 or IPv6. Use `-4` / `--ipv4` to select IPv4 only, or
@@ -94,42 +98,58 @@ labels; choose another alias if one collides with an explicit label.
 ordinary multi-target pacing and each sends its own probes, so dual-stack can
 double the number of probes per interval compared with one target per hostname.
-## LOCAL SOCKET CONFIGURATION
+## Local socket configuration
-The client supports configuring its local UDP sockets using the following options:
+If you need to control where probes leave the machine, use these socket
 options:
- `--bind-addr IP[:PORT]` binds sockets to the specified local IP address and optional port. If no port is specified, or the port is `0`, the operating system assigns an ephemeral port. IPv6 addresses with an explicit port must use `[ADDR]:PORT` syntax. The address family must match the target's resolved address family.
+- `--bind-addr IP[:PORT]` binds sockets to a local IP address and optional
- `--bind-device DEVICE` (Linux, Android, Fuchsia) binds sockets to a network interface using `SO_BINDTODEVICE`.
+  port. Leave out the port or use `0` to let the OS assign an ephemeral port.
- `--mark MARK` (Linux, Android, Fuchsia) sets the socket's firewall mark using `SO_MARK`, allowing traffic to be selected by policy routing or firewall rules. Accepts a decimal or 0x-prefixed hexadecimal unsigned 32-bit integer.
+  IPv6 addresses with a port need `[ADDR]:PORT` syntax. The address family
- `--fib FIB` (FreeBSD) selects a routing table using `SO_SETFIB`. The FIB is specified as a decimal unsigned 32-bit integer.
+  must match the target's resolved address family.
 - `--bind-device DEVICE` (Linux, Android, Fuchsia) binds sockets to a
  network interface using `SO_BINDTODEVICE`.
 - `--mark MARK` (Linux, Android, Fuchsia) sets the socket's firewall mark
  using `SO_MARK`, so policy routing or firewall rules can select the
  traffic. It accepts a decimal or 0x-prefixed hexadecimal unsigned 32-bit
  integer.
 - `--fib FIB` (FreeBSD) selects a routing table using `SO_SETFIB`. Supply
  the FIB as a decimal unsigned 32-bit integer.
-For example, bind IPv4 probes to a specific source address and interface, with a firewall mark:
+For example, to bind IPv4 probes to a specific source address and interface
 with a firewall mark:
 ```sh
 irtt-client -4 --bind-addr 192.0.2.10 --bind-device wan0 --mark 1234 host.example
 ```
-Setting a firewall mark or binding to a network device may require elevated privileges or appropriate capabilities. If the operating system rejects a socket option, socket setup fails.
+Setting a firewall mark or binding to a network device may require elevated
 privileges or appropriate capabilities. If the OS rejects a socket option,
 socket setup fails.
-A fixed local port may cause binding conflicts when multiple target sockets are created. Use an ephemeral port unless a specific source port is required. A family-specific bind address is also incompatible with targets using the other address family.
+A fixed local port can cause bind conflicts when the client creates sockets
 for multiple targets. Unless you need a particular source port, let the OS
 assign one. A bind address for one family also cannot be used with targets
 in the other family.
-## DYNAMIC TARGET SETS FROM STANDARD INPUT
+## Dynamic target sets from standard input
-`--targets-stdin` is available only with continuous mode (`--continuous` or
+`--targets-stdin` only works in continuous mode (`--continuous` or
-`--duration 0`).
+`--duration 0`). Use it to change targets while the client is running.
-Positional targets remain an initial desired set, and may be omitted to
+Positional targets form the initial set. You can leave them out to start
-start empty:
+with none:
 ~~~sh
 irtt-client --duration 0 --targets-stdin
 irtt-client --duration 0 --targets-stdin ams=ams.example:2112
 ~~~
-Each non-empty stdin record declares the complete desired target set, rather
+Each non-empty stdin record gives the complete set of targets you want.
-than a delta. A later record replaces an earlier set: targets absent from it
+A new record replaces the previous set: the client retires targets you leave
-are retired, unchanged target configurations retain their generation, and a
+out, keeps the generation for unchanged configurations, and starts a fresh
-changed address or HMAC setting creates a fresh generation. Under transient
+generation when an address or HMAC setting changes. If live-generation
-live-generation backpressure, only the latest unapplied desired set is kept.
+capacity temporarily prevents an update, only the latest unapplied set is
 kept.
 The same address-family preparation applies to initial and stdin targets.
 With `--dual-stack`, unchanged labels and endpoints retain their discovered
@@ -138,11 +158,12 @@ and later adding it again performs fresh discovery. New declarations are
 prepared asynchronously while existing measurements continue. A preparation
 error stops the stream gracefully without applying a partial set.
-Commas frame targets in stdin records; escape a literal comma within one
+Separate targets in stdin records with commas, and escape a comma inside a
-target as `\,`. Target parsing inside each element is otherwise the same as
+target as `\,`. Each target otherwise uses the same syntax as positional
-for positional arguments, including the other escapes above, `@hmac=KEY`, and
+arguments, including the escapes above, `@hmac=KEY`, and `@hmac=`.
-`@hmac=`. Use a persistent producer or keep a pipe/FIFO writer open while the
+
-client is being controlled. For example, in one terminal:
+Keep the producer or pipe/FIFO writer open while controlling the client.
 For example, run this in one terminal:
 ~~~sh
 mkfifo /tmp/irtt-targets
@@ -150,8 +171,8 @@ irtt-client --duration 0 --targets-stdin --hmac default-secret \
  < /tmp/irtt-targets
 ~~~
-Then open the FIFO once from another terminal and keep that descriptor open
+Then, in another terminal, open the FIFO once and keep that descriptor open
-while publishing complete desired sets:
+while sending complete target sets:
 ~~~sh
 exec 3> /tmp/irtt-targets
@@ -161,19 +182,21 @@ printf '%s\n' 'sg=sg.example:2112@hmac=sg-secret,nyc=nyc.example:2112' >&3
 exec 3>&-
 ~~~
-The exact record `[]` selects an empty desired set. Empty records are
+Send exactly `[]` to select an empty target set. The client ignores empty
-ignored; whitespace is otherwise payload, not trimming. EOF is immediate loss
+records, but otherwise treats whitespace as part of the input without
-or closure of the control plane and requests a graceful stop. A desired-state
+trimming it.
-revision that was read but has not yet been acknowledged as applied may be
+
-discarded when EOF is observed; EOF does not wait for a capacity-rejected
+Closing stdin sends EOF and asks the client to stop gracefully. An update
-revision to become applicable.
+that has been read but not yet acknowledged as applied may be discarded
 at that point. EOF does not wait for an update blocked by capacity to
 become applicable.
 The maximum stdin record payload is 64 KiB. Stdin-controlled mode bounds each
 desired set to 128 targets and retains at most 256 live target generations
 while replacements drain. The 128-target limit applies after dual-stack
 expansion: a hostname producing both families consumes two target slots.
-## NEGOTIATION ONLY
+## Negotiation only
 `-n` / `--no-test` connects to each target, negotiates the requested parameters,
 and exits without sending measurement probes. For example:
@@ -182,17 +205,18 @@ and exits without sending measurement probes. For example:
 irtt-client --no-test host.example:2112 --duration 30s --interval 100ms
 ```
-The `no_test_completed` event reports successful negotiation, including the
+On successful negotiation, the `no_test_completed` event includes the
 negotiated duration, interval, and packet length. Output format and column
-selection work as usual; no measurement summary or statistics-memory warning
+selection work as usual. The client prints no measurement summary or
-is printed. Negotiation failures use the normal target diagnostics and exit
+statistics-memory warning. Negotiation failures use the normal target
-policy: an uninterrupted run exits nonzero if no target succeeds.
+diagnostics and exit policy: an uninterrupted run exits nonzero if no
 target succeeds.
 Duration options still specify the duration to negotiate; even with
 `--continuous` or `--duration 0`, the client exits after negotiation.
 `--no-test` cannot be combined with `--targets-stdin`.
-## FINITE VERSUS CONTINUOUS OPERATION
+## Finite versus continuous operation
 `--duration` and `--interval` accept fractional and composite durations, such as
 `2.5s`, `1m30s`, and `1h`, as well as `ms`, `us` (or `µs`), and `ns` units
@@ -208,24 +232,25 @@ Omitting the option preserves the library default schedule.
 `--duration` controls the run length:
- Any nonzero duration (default `10s`) is a **finite** run: probing stops
+- A nonzero duration (default `10s`) gives you a finite run. Probing stops
-  after that long, and a final summary is printed for table output when
+  after that long. If statistics are enabled and you're using table
-  statistics are enabled (see [OUTPUT](#output) below — CSV, TSV, and
+  [output](#output), the client prints a final summary. CSV, TSV, and
-  JSON Lines never print one).
+  JSON Lines never include a summary.
- `--continuous` (or `--duration 0`) is **continuous**: the client runs until
+- With `--continuous` (or `--duration 0`), the client runs until interrupted
-  interrupted (`Ctrl-C`). With statistics enabled and table output, a final
+  (`Ctrl-C`). With statistics and table output enabled, interrupting the run
-  summary is printed only if the run was interrupted. Stdin-controlled mode
+  prints a final summary. In stdin-controlled mode, EOF also stops the run
-  is the exception: EOF also requests a graceful stop and prints the final
+  gracefully and prints the retained summary. A continuous run that exits
-  retained summary. An uninterrupted
+  for another reason without being interrupted does not print one.
  continuous run that exits for another reason does not get one.
-See [MEASUREMENTS AND MEMORY](#measurements-and-memory) below for why this
+The choice also affects which statistics are available and how much memory
-distinction also determines what statistics can be computed and how much
+a long run retains. See [Measurements and memory](#measurements-and-memory).
 memory a long run retains.
 ### Optional recovery and event-only runs
-`--no-stats` disables statistics collection and final summaries while preserving individual measurement output. Statistics-dependent columns (such as IPDV) are unavailable. This runtime option does not remove the `irtt-stats` dependency.
+If you only need individual measurements, use `--no-stats` to disable
 statistics collection and final summaries. Columns that need statistics,
 such as IPDV, are unavailable. The runtime flag still leaves the
 `irtt-stats` dependency in the build.
 To omit statistics at compile time, build with:
@@ -240,15 +265,31 @@ warnings are disabled, and IPDV columns retain their names with absent values
 (`-` in tables, empty CSV/TSV fields, and JSON `null`). Measurement events and
 protocol-level received statistics remain available.
-`--reconnect` enables automatic recovery for individual targets in continuous mode (`--continuous` or `--duration 0`). Failed connections, closed sessions, and unresponsive servers are retried without interrupting other targets. Retries double the delay after each failed attempt, from 250 ms up to 10 seconds by default. A valid reply resets the delay to the initial value; each target backs off independently.
+Use `--reconnect` to recover individual targets in continuous mode
 (`--continuous` or `--duration 0`). The client retries failed connections,
 closed sessions, and unresponsive servers while the other targets keep
 running. By default, the delay doubles after each failed attempt, from
 250 ms up to 10 seconds. A valid reply resets it to the initial delay.
 Each target backs off independently.
-`--reconnect-initial-delay DURATION` (default: `250ms`) and `--reconnect-max-delay DURATION` (default: `10s`) configure these delays. Both require `--reconnect`, must be positive and schedulable, and the maximum must be at least twice the initial delay. For example, `--reconnect-initial-delay 1s --reconnect-max-delay 5s` retries after `1s`, `2s`, `4s`, `5s`, then `5s` thereafter.
+You can change the delays with `--reconnect-initial-delay DURATION`
 (default: `250ms`) and `--reconnect-max-delay DURATION` (default: `10s`).
 Both require `--reconnect` and must be positive and schedulable. The maximum
 must be at least twice the initial delay. For example,
 `--reconnect-initial-delay 1s --reconnect-max-delay 5s` retries after `1s`,
 `2s`, `4s`, `5s`, then `5s` from there on.
-`--reconnect-timeout DURATION` controls how long a session can go without valid replies before reconnection is attempted (default: `10s`). The timeout applies only while actively sending probes and should account for the probe interval and expected packet loss.
+`--reconnect-timeout DURATION` sets how long a session can go without valid
 replies before the client tries to reconnect (default: `10s`). It only
 applies while actively sending probes, so allow for your probe interval and
 expected packet loss.
-**Statistics reset on reconnection**, so final summaries only reflect the latest session per target. A warning is emitted when reconnection is enabled with statistics collection. Use `--no-stats` to disable collection and suppress the warning.
+Reconnecting resets statistics for that target, so its final summary only
 covers the latest session. The client warns about this when reconnection
 and statistics collection are both enabled. Use `--no-stats` to disable
 collection and suppress the warning.
-Example for continuous, multi-target CSV output without statistics:
+For continuous CSV output from multiple targets without statistics:
 ```sh
 irtt-client --continuous --reconnect --no-stats \
@@ -259,11 +300,11 @@ irtt-client --continuous --reconnect --no-stats \
  reflector1 reflector2
 ```
-## OUTPUT
+## Output
 ### `--format FORMAT`
-One of four event-row formats, default `table`:
+Choose one of four event-row formats. The default is `table`:
 - `table`: human-readable terminal output; the only format that prints a
  final summary.
@@ -271,23 +312,36 @@ One of four event-row formats, default `table`:
 - `tsv`: tab-separated output.
 - `jsonl`: one JSON object per event.
-CSV, TSV, and JSON Lines default to **all** columns for structured export;
+CSV, TSV, and JSON Lines include all columns by default for structured export;
-`table` defaults to a compact column set and hides `echo_sent` rows. An
+`table` defaults to a compact column set and hides `echo_sent` events.
-explicit `--columns` selection other than `default` shows all event rows,
+You can show those events by explicitly selecting them with `--events`
-including `echo_sent`; `--columns default` is equivalent to omitting the
+or by using custom columns.
-option and keeps `echo_sent` hidden for table output.
+
 ### `--events EVENTS`
 Choose which events to print with a comma-separated list, or repeat the
 option to select more events. The available names are `session_started`,
 `no_test_completed`, `session_closed`, `echo_sent`, `echo_reply`, `loss`,
 `duplicate`, `late`, and `warning`. Without this option, the client prints
 all events normally shown by the selected format.
 For CSV output containing only echo replies:
 ```sh
 irtt-client <server> --events echo_reply --format csv --header never --no-stats
 ```
 ### `--columns COLUMNS` / `-c COLUMNS`
-Comma-separated event row columns, or the special values `default` (the
+Choose event-row columns with a comma-separated list, or use `default`
-format's default set) or `all` (every column). List every available column,
+for the format's default set and `all` for every column. To see the
-its meaning, and its aliases with:
+available columns, their meanings, and aliases, run:
 ```sh
 irtt-client --list-columns
 ```
-(`--list-columns` does not require a target.)
+You don't need a target for `--list-columns`.
 ### `--header auto|always|never`
@@ -296,10 +350,9 @@ Lines never prints a header line.
 ### `--verbose`
-Includes extra fields in table output and final summaries. Has no effect on
+Include extra fields in table output and final summaries. CSV, TSV, and
-CSV, TSV, or JSON Lines output either way — those formats show their default
+JSON Lines keep their default all-column set or your explicit `--columns`
-all-column set or an explicit `--columns` selection exactly as given,
+selection regardless of `--verbose`.
 regardless of `--verbose`.
 ### Examples
@@ -309,13 +362,13 @@ irtt-client <server> --format jsonl
 irtt-client <server> --format csv --columns event,seq,remote,effective_rtt_us
 ```
-A stream containing only effective RTT values in microseconds:
+To print only effective RTT values in microseconds:
 ```sh
 irtt-client <server> --format tsv --columns effective_rtt_us --header never
 ```
-## MEASUREMENT FIELDS
+## Measurement fields
 Useful measurement columns:
@@ -336,95 +389,95 @@ Useful measurement columns:
 ### Kernel timestamps (Linux)
-On Linux, one-way delay estimates prefer a kernel-captured timestamp over
+On Linux, the client prefers kernel timestamps for its own send/receive
-userspace timing for this client's own send/receive endpoint, where the
+endpoint when calculating one-way delays, where the platform and socket
-platform and socket support it, reducing the effect of scheduling and
+support them. This reduces the effect of scheduling and queuing delay.
-queuing delay. The peer's reported endpoint gets the same preference when it
+The `irtt-server` applet makes the same choice for its endpoint on Linux.
-is the `irtt-server` applet running on Linux; against another
+With another IRTT-compatible server, the client uses the wall-clock value
-IRTT-compatible server, whatever wall-clock value it reports is used as-is.
+that server reports as-is.
 This is best-effort: an unsupported or implausible kernel timestamp falls
 back to userspace timing. `raw_rtt_us` is unaffected either way;
 `adjusted_rtt_us`/`effective_rtt_us` can still shift slightly, since server
 processing time is derived from the same server receive endpoint.
-## MEASUREMENTS AND MEMORY
+If a kernel timestamp is unsupported or implausible, timing falls back to
 userspace. This leaves `raw_rtt_us` unchanged. The
 `adjusted_rtt_us`/`effective_rtt_us` values can still shift slightly, since
 server processing time uses the same server receive endpoint.
-The statistics retention below applies only when the `stats` feature is compiled
+## Measurements and memory
 in and `--no-stats` is absent. Disabling collection keeps the client
 classification bounds but allocates no statistics collectors.
-Finite and continuous modes make a different tradeoff between exact
+If the `stats` feature is compiled in and you haven't used `--no-stats`,
-statistics and bounded memory.
+the client collects statistics as described here. Disabling collection
 allocates no statistics collectors, though the client still keeps its
 bounded reply-classification state.
-**Finite mode** retains exact timing samples (and adjacent-sequence IPDV
+In finite mode, the client keeps exact timing samples and adjacent-sequence
-state) so the final summary can report exact medians. Retained memory
+IPDV state so it can report exact medians in the final summary. Memory
-therefore grows with the number of probes sent, at a small constant cost per
+grows with the number of probes sent, at roughly a few hundred bytes per
-probe (on the order of a few hundred bytes of retained sample state per
+probe per target before allocator overhead. So if you're planning a long
-probe per target, before allocator overhead) — a very long finite run at a
+finite run with a short interval, allow for that growth.
 short interval is the case to plan capacity for. The client warns on stderr
 when its own estimate of this retained state crosses roughly 128 MiB, and
 again more strongly past roughly 512 MiB and 1 GiB; treat those numbers as
 practical guidance, not a promised RSS ceiling, since allocator and OS
 overhead sit outside the estimate.
-**Continuous mode** (`--duration 0`) does not retain a growing sample
+The client prints a warning on stderr when its estimate of retained state
-history: running statistics keep count/min/max/mean/variance only, so exact
+crosses roughly 128 MiB, with stronger warnings past roughly 512 MiB and
-medians are unavailable. It still keeps a bounded adjacent-sequence IPDV
+1 GiB. These are useful planning figures, but they don't promise an RSS
-store, capped at 4,096 sequences per target, so nearby replies can still
+ceiling: allocator and OS overhead are outside the estimate.
 form IPDV pairs. Retained statistics state therefore approaches a fixed
 per-target bound rather than growing with elapsed run time.
-Reply classification (independent of the statistics choice above) is also
+In continuous mode (`--duration 0`), running statistics keep only
-bounded per target: each of the pending, timed-out, and completed/duplicate
+count/min/max/mean/variance, so exact medians are unavailable. The client
-sequence stores has its own 4,096-entry limit — not one shared total across
+still keeps up to 4,096 sequences per target for adjacent-sequence IPDV
-the three. A full pending store makes the client fail and drain that target
+pairs. Statistics memory approaches a fixed limit per target as the run
-as resource-exhausted rather than wait for capacity to free. Timed-out and
+continues.
 completed state evict their oldest entries, so a sufficiently old late reply
 can still be seen and counted, but no longer has retained send state for
 measurements such as RTT.
-Overall, retained state scales with the **number of configured targets**
+Reply classification has its own bounds, regardless of whether you collect
-and these fixed per-target limits, not with total probes sent in continuous
+statistics. Each target has separate pending, timed-out, and
-mode. Output is written as events arrive rather than accumulated; the
+completed/duplicate sequence stores, each with a 4,096-entry limit. If the
-managed event stream feeding it is itself bounded and lossy (16,384 events),
+pending store fills, the client fails and drains that target as
-so a sufficiently slow consumer can miss events, in which case the client
+resource-exhausted. It does not wait for space to free up.
-reports that resulting output/statistics may be incomplete.
+
 The timed-out and completed stores evict their oldest entries. A very late
 reply can still be seen and counted after eviction, but without its retained
 send state the client cannot calculate measurements such as RTT.
 In continuous mode, retained state scales with the number of configured
 targets and these fixed limits per target. The client writes output as
 events arrive. The managed event stream has a 16,384-event capacity and can
 drop events if the consumer falls behind. If that happens, the client
 reports that output and statistics may be incomplete.
 For capacity planning on constrained devices (for example an OpenWrt
 router): a finite run's statistics memory is roughly proportional to
 `targets × probes_sent`, while a continuous run's statistics memory
 approaches a fixed multiple of `targets` regardless of how long it runs.
-## PEER CLOSE AND EXIT BEHAVIOR
+## Peer close and exit behavior
-A peer closing a finite run is accepted as a terminal, successful outcome.
+If a peer closes a finite run, the client treats that as successful
-Without `--reconnect`, in continuous mode, an uninterrupted peer closure is treated as an error —
+completion. In continuous mode without `--reconnect`, a peer closure ends
-the client exits nonzero — so a process supervisor can restart it; an
+an uninterrupted run with a nonzero exit status so a process supervisor
-interrupted run (`Ctrl-C`) never reports peer closure as an error, whichever
+can restart it. If you interrupted the run (`Ctrl-C`), peer closure is
-mode it was in.
+never reported as an error in either mode.
 With `--reconnect`, a desired target reopens automatically after peer closure.
 Without recovery, `--targets-stdin` makes peer closure target-local: other
 desired targets and the stdin controller continue running. Including that
 target in a later complete set starts a fresh generation.
-## EXIT STATUS
+## Exit status
-`0` on success (including a finite run's ordinary completion, and an
+The client exits `0` on success, including normal finite completion and
-interrupted run of either mode). Nonzero if the managed driver failed, if an
+interrupted runs in either mode. It exits nonzero if the managed driver
-uninterrupted continuous run ended by peer closure, or if the run was not
+fails, an uninterrupted continuous run ends by peer closure, or no target
-interrupted and no target completed successfully. An interrupted run never
+completes successfully in an uninterrupted run.
 fails on the last of these conditions — for example, interrupting a
 continuous run whose only target never opened still exits `0`.
-## SERVER FILL REQUEST
+Interrupting the run prevents the last condition from counting as a failure.
 For example, if you interrupt a continuous run whose only target never
 opened, it still exits `0`.
 ## Server fill request
 `--sfill DESCRIPTOR` requests the server's echo-reply payload fill: `none`
 (zero-filled), `rand` (random bytes), or `pattern:HEX` (a repeating
-hexadecimal pattern). See `irtt-server(1)` SERVER FILL for what the server
+hexadecimal pattern). See the Server fill section in `irtt-server(1)` for
-does with an unset or unparseable request.
+what the server does with an unset or unparseable request.
-## EXAMPLES
+## Examples
 ```sh
 irtt-client netperf-eu.bufferbloat.net:2112
@@ -433,7 +486,7 @@ irtt-client netperf-eu.bufferbloat.net:2112 --duration 0
 irtt-client host-a:2112 host-b:2112 --pacing burst
 ```
-## SEE ALSO
+## See also
 `irtt-tui(1)`, `irtt-server(1)`, `irtt-rs(1)`, and `irtt-client --help` for
 the full option list, including HMAC, clock/timestamp negotiation, DSCP, and
@@ -1,10 +1,10 @@
 # irtt-rs
-## NAME
+## Name
 irtt-rs - IRTT-compatible multi-applet dispatcher
-## SYNOPSIS
+## Synopsis
 `irtt-rs` `client` [*OPTIONS*] [*[LABEL=]TARGET*]...
@@ -12,41 +12,40 @@ irtt-rs - IRTT-compatible multi-applet dispatcher
 `irtt-rs` `server` [*OPTIONS*]
-## DESCRIPTION
+## Description
-`irtt-rs` is a multicall dispatcher: one binary that runs the client, TUI,
+`irtt-rs` lets you run the client, TUI, or server from one binary. You choose
-or server applet depending on the subcommand given, or on the name it was
+the applet with a subcommand, or by the name you invoke or copy the binary
-invoked/copied as. It exists for router-friendly single-binary deployment;
+as. This is useful on a router where you want a single binary to deploy.
-it does not add behavior beyond what `irtt-client(1)`, `irtt-tui(1)`, and
+The applets behave the same as `irtt-client(1)`, `irtt-tui(1)`, and
-`irtt-server(1)` already provide.
+`irtt-server(1)`.
-Each subcommand behaves exactly like its dedicated binary — `irtt-rs client
+For example, `irtt-rs client ...` does the same thing as running `irtt-client ...` directly. See the
-...` is equivalent to running `irtt-client ...` directly. See those manuals
+individual manuals for target syntax, options, output, and exit behavior.
 for target syntax, options, output, and exit behavior.
-## APPLET BINARY NAMES
+## Applet binary names
-The build also produces dedicated binaries: `irtt-client`, `irtt-tui`, and
+The build also produces dedicated `irtt-client`, `irtt-tui`, and
-`irtt-server`. A dedicated binary always runs its own role, regardless of
+`irtt-server` binaries. These always run their own applet, even if you copy
-what it is invoked or copied as — it does not consult argv0 dispatch logic.
+or invoke them under a different name. They do not use argv0 to choose an
 applet.
-`irtt-rs` itself inspects argv0 first: if invoked (or symlinked/copied) under
+The `irtt-rs` dispatcher checks argv0 first. If you invoke it through a
-one of the recognized applet names — `irtt-client`, `irtt-tui`, or
+symlink or copy named `irtt-client`, `irtt-tui`, or `irtt-server`, it runs
-`irtt-server` — it runs that applet directly, without needing a subcommand.
+that applet without a subcommand.
 Any other name starting with `irtt-` (other than `irtt-rs` itself) is
 rejected as an unknown applet name before subcommand parsing is even
 attempted — `irtt-custom server` is a hard error, not a fallthrough. Only
 `irtt-rs` itself, or a name that doesn't start with `irtt-` at all, falls
 through to ordinary `client`/`tui`/`server` subcommand parsing.
-## FEATURE-DEPENDENT APPLET AVAILABILITY
+Other names starting with `irtt-`, except `irtt-rs` itself, are rejected
 before subcommands are parsed. So `irtt-custom server` fails with an unknown
 applet error. If the name is `irtt-rs`, or doesn't start with `irtt-`, the
 dispatcher parses the usual `client`/`tui`/`server` subcommands.
-Each applet is gated by a Cargo feature on the `irtt-rs` package: `client`,
+## Feature-dependent applet availability
-`tui`, `server`. All three are in the default feature set. A build with a
+
-feature disabled still produces the `irtt-rs` binary, but that applet is
+Each applet has a Cargo feature on the `irtt-rs` package: `client`,
-unavailable at runtime — running it (by subcommand or by binary name)
+`tui`, `server`. All three are enabled by default. If you disable one, the
-reports which feature to rebuild with, and `irtt-rs --help` lists which
+build still produces `irtt-rs`, but you cannot run that applet. Trying it
-applets the current build actually contains.
+through either a subcommand or a binary name tells you which feature to
 rebuild with. Use `irtt-rs --help` to see which applets your build includes.
 ```sh
 cargo install irtt-rs --locked --no-default-features --features client,stats
@@ -55,13 +54,12 @@ cargo install irtt-rs --locked --no-default-features --features client,stats
 Use `--features client` to omit statistics. The default build includes the
 `stats` feature, and `tui` always enables it.
-## RELATIONSHIP TO irtt-client, irtt-tui, irtt-server
+## Relationship to irtt-client, irtt-tui, irtt-server
-`irtt-rs` is packaging and dispatch only. All probing, display, and server
+The `irtt-rs` dispatcher handles packaging and applet selection. For how to run
-behavior lives in `irtt-client(1)`, `irtt-tui(1)`, and `irtt-server(1)` —
+probes, use the dashboard, or serve requests, see `irtt-client(1)`,
-consult those manuals for anything observable about running a probe or
+`irtt-tui(1)`, and `irtt-server(1)`.
 serving one.
-## SEE ALSO
+## See also
 `irtt-client(1)`, `irtt-tui(1)`, `irtt-server(1)`.
@@ -1,22 +1,22 @@
 # irtt-server
-## NAME
+## Name
 irtt-server - IRTT-compatible UDP server
-## SYNOPSIS
+## Synopsis
 `irtt-server` [`--bind` *ADDR*]... [*OPTIONS*]
 `irtt-rs server` [`--bind` *ADDR*]... [*OPTIONS*]
-## DESCRIPTION
+## Description
-`irtt-server` answers IRTT echo requests over UDP. It is thin orchestration
+`irtt-server` answers IRTT echo requests over UDP. It uses the reusable
-over the reusable `irtt-server` library: one current-thread Tokio runtime,
+`irtt-server` library for sessions and policy, with one current-thread
-one or more listeners, and the library's own session/policy logic.
+Tokio runtime running one or more listeners.
-Run with no arguments for the ordinary case:
+To start a server with the defaults, run:
 ```sh
 irtt-server
@@ -28,34 +28,31 @@ wildcard address for both address families, in this fixed order:
 1. `[::]:2112`
 2. `0.0.0.0:2112`
-This is available wherever the platform supports safe wildcard reply-source
+The defaults work on platforms that support wildcard reply-source
-selection (see [Wildcard binds](#wildcard-binds) below). Any explicit
+selection (see [Wildcard binds](#wildcard-binds)). If you supply any
-`--bind` **replaces** this default pair entirely rather than adding to it —
+`--bind`, it replaces both defaults. For example,
-`irtt-server --bind 127.0.0.1:2112` binds only that one address.
+`irtt-server --bind 127.0.0.1:2112` listens only on that address.
-If one of the two default addresses cannot be bound because its address
+If the host has no support for one address family, for example because IPv6
-family itself has no local support at all — IPv6 disabled on an otherwise
+is disabled, the server uses the other default listener and tells you on
-IPv4-capable host, for example — the server falls back to serving just the
+startup. Other bind failures still stop startup. This includes a port
-other one instead of failing outright, and says so on startup. Any other
+already in use, permission denied, or a platform without safe wildcard
-reason a default listener fails — the port already in use, permission
+reply-source selection.
 denied, no safe wildcard reply-source path — is not a family-support
 problem and is not silently worked around; the invocation fails as it would
 for an explicit `--bind`. This fallback applies only to the implicit default
 pair: an explicit `--bind` list always keeps the ordinary all-or-nothing
 behavior described below.
-## OPTIONS
+The address-family fallback only applies to the default pair. An explicit
 `--bind` list always uses the all-or-nothing behavior described below.
 ## Options
 ### `--bind ADDR`
-Local UDP address to bind, as `ADDR:PORT`, for example `127.0.0.1:2112` or
+Use `ADDR:PORT` to choose a local UDP address, for example `127.0.0.1:2112`
-`[::1]:2112`. Host names are not resolved. Repeatable.
+or `[::1]:2112`. Hostnames are not resolved.
-Repeat the option to serve several addresses from one process, in the order
+Repeat `--bind` to serve several addresses from one process, in the order
-given. Every listener applies the same policy options, but each keeps its
+given. Every listener uses the same policy options, but keeps its own
-own sessions and tokens, so a session belongs to the address it was opened
+sessions and tokens. A session belongs to the address it was opened on.
-on. Binding is all-or-nothing: if any address cannot be bound, none are
+Binding is all-or-nothing: if any address cannot be bound, none are served.
 served.
 A port of `0` selects an unused port per listener, so two such binds get two
 different ports.
@@ -63,71 +60,75 @@ different ports.
 With no `--bind` at all, see [Description](#description) above for the
 default wildcard pair and the address-family fallback it allows.
-When reply DSCP/traffic-class marking for IPv4 peers matters, do not configure
+If you need DSCP/traffic-class marking on replies to IPv4 peers, use care
-one explicit dual-stack `[::]:PORT` listener by itself. On Linux, IPv4 peers
+with a lone dual-stack `[::]:PORT` listener. On Linux, those peers use
-served through that socket are IPv4-mapped and their replies cannot retain the
+IPv4-mapped addresses and their replies cannot retain the negotiated
-negotiated marking. Configure the ordinary paired `[::]:PORT` and
+marking. Use paired `[::]:PORT` and `0.0.0.0:PORT` listeners on the same
-`0.0.0.0:PORT` listeners instead; the IPv6 listener is made IPv6-only for that
+port. The server makes the IPv6 listener IPv6-only for that pair, so each
-same-port pair, so each family uses the correct socket option. This is a
+family gets the correct socket option. A lone IPv6 listener keeps its usual
-configuration workaround, not a reason to force `IPV6_V6ONLY` for every lone
+behavior; the server does not force `IPV6_V6ONLY` on it.
 IPv6 listener.
 ### `--hmac KEY`
-Accepts a plain-text key or a hexadecimal key prefixed with `0x`. For example, `secret` and `0x736563726574` are equivalent. The `IRTT_SERVER_HMAC` environment variable uses the same syntax.
+You can use a plain-text key or a hexadecimal key prefixed with `0x`.
 For example, `secret` and `0x736563726574` are equivalent. The
 `IRTT_SERVER_HMAC` environment variable accepts the same syntax.
-With a key configured, every request must carry a valid MAC and every reply is authenticated;
+With a key configured, every request must carry a valid MAC and the server
-without one, authenticated requests are dropped. The key is visible in the
+authenticates every reply. Without a key, the server drops authenticated
-process arguments.
+requests. A key passed on the command line is visible in the process
 arguments.
 ### `--max-sessions COUNT`
-Maximum number of simultaneously live sessions **per listener**, not per
+Set the maximum number of live sessions per listener. This limit applies
-process. Once a listener's table is full, a session-creating open to it is
+to each listener separately, so the process can have more sessions in total.
-dropped silently; nothing is evicted. Zero refuses every session-creating
+Once a listener's table is full, it silently drops opens that would create
-open.
+a session and keeps the existing sessions. Zero refuses every open that
 would create a session.
 ### `--max-packet-length BYTES`
-Maximum echo datagram size a session may negotiate, in bytes. A longer
+Set the maximum echo datagram size a session may negotiate, in bytes. The
-requested length is reduced during negotiation, an open whose mandatory
+server reduces longer requests during negotiation and refuses an open if
-field block would not fit is refused, and inbound echo requests are admitted
+its mandatory fields would not fit. Incoming echo requests must fit the
-against the same limit. This is a resource bound, not an MTU.
+same limit. Use this to bound resource use; it does not set the network MTU.
 ### `--min-interval DURATION`
-Floor on the send interval a session may negotiate. The negotiated interval
+Set the minimum send interval a session may negotiate. The server then caps
-is still capped at a quarter of the idle timeout afterwards, so a
+the negotiated interval at a quarter of the idle timeout, so a
-`--min-interval` above that cap is not the value actually negotiated.
+`--min-interval` above that cap will be reduced.
-A session's reply allowance refills at the shorter of this configured floor
+The session's reply allowance refills at the shorter of the configured
-and the interval it actually negotiated. Ordinarily that is the configured
+minimum and the negotiated interval. Usually this is the configured
-floor itself, since the negotiated interval is normally at least as long —
+minimum: a 10ms `--min-interval` with a 1s negotiated interval refills every
-a 10ms `--min-interval` against a 1s negotiated interval refills every
+10ms.
-10ms. The two differ only when the idle-timeout cap above pulled the
+
-negotiated interval below the configured floor, in which case the shorter,
+If the idle-timeout cap reduces the negotiated interval below the configured
-negotiated value is what the allowance actually refills at: a server must
+minimum, the allowance refills at that shorter interval too. This keeps the
-not enforce a cadence it did not advertise to the client. Use `0` for no
+server from enforcing a slower cadence than it told the client to use.
-time-based throttling.
+Use `0` for no time-based throttling.
 ### `--burst COUNT`
-Echo replies one session may have answered before its allowance has to
+Set how many echo replies a session can send before its allowance needs to
-refill. Use `0` for no allowance at all, which rate-limits every echo
+refill. Use `0` for no allowance, which rate-limits every
-request whatever the interval is.
+echo request regardless of the interval.
 ### `--idle-timeout DURATION`
 Release a session after this long without a served or rate-limited echo
-request. The deadline runs from the open, and release is silent. Use `0` to
+request. The timeout starts at open, and the server releases the session
-expire a session at the next evaluation; it is not a way to disable expiry.
+without sending a close. If you use `0`, the session expires at the next
 evaluation; zero does not disable expiry.
 ### `--max-duration DURATION`
-Maximum test duration a session may negotiate. A longer request is reduced
+Set the maximum test duration a session may negotiate. The server reduces
-to it, and a continuous request is answered with it. Omit this flag for no
+longer requests to this value and uses it for continuous requests too.
-maximum; a maximum of zero cannot be expressed, because a negotiated
+Leave the flag out if you don't want a maximum. You cannot set a maximum of
-duration of zero means continuous.
+zero, since a negotiated duration of zero means continuous.
 ### `--timestamp-allowance MODE`
@@ -147,13 +148,12 @@ and they are sent unmarked. The session is not refused.
 Durations everywhere in this command accept an integer followed by a unit:
 `ms`, `s`, or `m`.
-## ENVIRONMENT
+## Environment
-Every option above can also be supplied through an environment variable, for
+You can also set each option through an environment variable, which is
-deployments that configure by environment rather than by command line
+useful for containers, orchestrators, and unit files. A command-line flag
-(containers, orchestrators, unit files). A flag given on the command line
+overrides the corresponding variable entirely. If neither is set, the
-overrides the corresponding variable entirely; an unset variable leaves the
+server uses its built-in default.
 built-in default in place.
 | Variable | Option |
 | --- | --- |
@@ -176,10 +176,10 @@ more than one address needs repeated `--bind` options.
 an empty value leave traffic-class marking enabled; any other value disables
 it, and an unset variable leaves it enabled.
-## OUTPUT
+## Output
-Each bound endpoint is printed on startup, once every listener is up, which
+Once every listener is up, the server prints each bound endpoint. If you
-also resolves a port of `0`:
+requested port `0`, this shows which port was assigned:
 ```
 irtt-server: listening on [::]:2112
@@ -188,21 +188,22 @@ irtt-server: listening on 0.0.0.0:2112
 `Ctrl-C` stops the server gracefully.
-## MULTIPLE LISTENERS
+## Multiple listeners
-Every invocation runs through the same multi-listener path, so one address —
+The server manages listeners the same way whether you have one or several,
-whether from the default pair or a single explicit `--bind` — is an ordinary
+including when only one address from the default pair is available or you
-set of one rather than a separate mode. The policy options above apply to
+supply a single `--bind`. Each listener uses the same policy options, but
-every listener, but listeners are otherwise independent: each has its own
+keeps its own sessions and tokens. The `--max-sessions` limit applies to
-sessions and tokens, and `--max-sessions` bounds each listener rather than
+each listener separately.
-the process. If any listener fails while running, the others are shut down
+
-with it rather than leaving a service configured for two families answering
+If any listener fails while running, the server shuts down the others too.
-on one.
+So a service configured for both address families won't carry on answering
 on just one after a listener failure.
 Wildcard IPv4 and IPv6 listeners may share one port, as the default pair
 does.
-## SERVER FILL
+## Server fill
 Echo replies fill their payload according to the negotiated `ServerFill`
 mode, which a client requests with `irtt-client`'s `--sfill` (see
@@ -212,11 +213,11 @@ mode, which a client requests with `irtt-client`'s `--sfill` (see
 - `rand`: random bytes.
 - `pattern:HEX`: the given repeating hexadecimal pattern.
-Every valid descriptor is honored. A descriptor the server cannot parse, and
+The server honors every valid descriptor. If it cannot parse the descriptor,
-a client that expresses no fill preference at all, both get the default
+or the client sends no fill preference, it uses `pattern:69727474`: the
-`pattern:69727474`, i.e. the repeating bytes `69 72 74 74` (`irtt`).
+repeating bytes `69 72 74 74` (`irtt`).
-## WILDCARD BINDS
+## Wildcard binds
 An explicit interface address works on every supported system. A wildcard
 bind such as `0.0.0.0:2112` or `[::]:2112` reads each request's local
@@ -224,14 +225,13 @@ destination from packet metadata and sends that request's reply from the
 same address, so a client on a multi-homed host is answered from the
 endpoint it actually contacted.
-That reply-source selection is implemented on **Linux, macOS, and FreeBSD**.
+Reply-source selection is supported on Linux, macOS, and FreeBSD. On other
-Elsewhere, a wildcard bind is refused at construction rather than served
+platforms, the server refuses wildcard binds because the routing table
-from a routing-table-selected source address a client would discard — this
+could select a source address the client would discard. This also means
-also applies to the zero-argument default, which will fail with a clear
+running without arguments fails on those platforms, with an error asking
-error asking for an explicit `--bind` on such a platform. This correctness
+you to supply an explicit `--bind`.
 rule is deliberate and is not weakened by the zero-argument default.
-## EXAMPLES
+## Examples
 Run with the default wildcard listeners on the standard port:
@@ -283,19 +283,19 @@ Require authentication:
 irtt-server --bind 192.0.2.10:2112 --hmac secret
 ```
-## EXIT STATUS
+## Exit status
 `0` on a clean shutdown (`Ctrl-C`), nonzero if binding fails or a listener
 fails while running.
-## LIMITATIONS
+## Limitations
 - No hostname resolution, interface expansion, daemonization, or
-  configuration file — binds are explicit addresses only.
+  configuration file. Binds must use explicit addresses.
 - Wildcard reply-source selection is unavailable outside Linux, macOS, and
  FreeBSD; such platforms must bind explicit addresses.
-## SEE ALSO
+## See also
 `irtt-client(1)`, `irtt-tui(1)`, `irtt-rs(1)`, and `irtt-server --help` for
 the full option list.
@@ -1,25 +1,24 @@
 # irtt-tui
-## NAME
+## Name
 irtt-tui - IRTT-compatible terminal UI client
-## SYNOPSIS
+## Synopsis
 `irtt-tui` [*OPTIONS*] *[LABEL=]TARGET*...
-## DESCRIPTION
+## Description
-`irtt-tui` is a live dashboard over the same probing engine as
+`irtt-tui` gives you a live graph and status dashboard using the same probing
-`irtt-client(1)`: a graph and status view instead of a printed event stream.
+engine as `irtt-client(1)`. You need at least one target to start it.
 At least one target is required.
-Target syntax, multiple targets, and pacing are identical to
+Targets and pacing work the same as in `irtt-client(1)`. See that manual
-`irtt-client(1)` — see that manual for `[LABEL=]TARGET` syntax and the
+for `[LABEL=]TARGET` syntax, multiple targets, and the
-`--pacing staggered|burst` option. The client configuration flags
+`--pacing staggered|burst` option. The configuration flags
 (`--interval`, `--timeouts`, `--length`, `--hmac`, `--clock`, `--tstamp`,
-`--stats`, `--sfill`, `--dscp`, `--ttl`, `--loose`) are shared with `irtt-client` as
+`--stats`, `--sfill`, `--dscp`, `--ttl`, `--loose`) are also shared with
-well; consult that manual for their meaning.
+`irtt-client`, so the same descriptions apply.
 Address-family controls are shared too: `-4` / `--ipv4` uses IPv4 only,
 `-6` / `--ipv6` uses IPv6 only, and `--dual-stack` gives each available family
@@ -36,11 +35,12 @@ The second command creates `cov/v4` and/or `cov/v6` according to the system
 resolver's initial results, letting you compare the two paths directly.
 See the client manual's address-family section for discovery errors and labels.
-## CONTINUOUS DEFAULT
+## Continuous default
-Unlike `irtt-client`, **the TUI defaults to continuous mode**
+The TUI defaults to continuous mode (`--duration 0`) and runs until you
-(`--duration 0`): it runs until you quit. Pass an explicit `--duration` for
+quit. If you're used to `irtt-client`, which defaults to a finite run,
-a finite run. Both `--duration` and `--interval` use the
+keep that difference in mind. To set a finite run, pass an explicit
 `--duration`. Both `--duration` and `--interval` use the
 [client duration syntax](irtt-client.md#finite-versus-continuous-operation),
 including fractional values (`2.5s`), composite values (`1m30s`), and units
 from nanoseconds (`ns`) through hours (`h`):
@@ -49,26 +49,29 @@ from nanoseconds (`ns`) through hours (`h`):
 irtt-tui <server> --duration 30s
 ```
-Continuous runs reconnect after target-local failures, peer closure, or a
+In continuous mode, the TUI reconnects after a target fails, the peer closes
-session completing because the server restricted its duration. After a
+the session, or the session ends because the server limited its duration.
-1.5-second delay, one coalesced retry reopens completed targets while healthy
+After a 1.5-second delay, it groups completed targets into one retry while
-sessions continue undisturbed. Even if every target fails, the TUI stays alive
+healthy sessions keep running. Even if every target fails, the TUI stays
-until you quit. Explicit stops, removed or replaced targets, and no-test
+open until you quit.
-completion do not trigger retries. Quitting cancels pending retry work.
+
 Explicit stops, removed or replaced targets, and no-test completion do not
 trigger retries. Quitting cancels any pending retry work.
 With `--dual-stack`, a failed family reconnects independently while its healthy
 sibling continues. Reconnect resolves the original hostname again within the
 target's family. It does not discover additional families or pin the address
 returned by initial discovery.
-Each reconnect keeps the same logical target row. Statistics reset when a new
+Reconnecting keeps the target in the same row. Statistics reset when a new
 session generation is accepted, including attempts that fail before opening.
-Retained graph history and the age of the last actual reply remain; the graph
+The TUI keeps graph history and the age of the last actual reply, with a
-leaves a gap between generations instead of connecting their samples.
+gap in the graph between generations.
-## DASHBOARD
+## Dashboard
-One dashboard is used for every target count and terminal size. It shows:
+The dashboard uses the same layout for any target count and terminal size.
 It shows:
 - Run status, elapsed time, and finite duration or continuous mode.
 - The selected target's label and remote address, plus latest signed
@@ -78,30 +81,32 @@ One dashboard is used for every target count and terminal size. It shows:
 - A graph overlaying all targets, with matching target colors and a visible
  live/history indicator and window size.
-An active session with no primary replies shows `waiting`. Reply age makes a
+An active session shows `waiting` until it gets a primary reply. Check the
-stale RTT distinguishable from a fresh measurement. Loss follows the shared
+reply age to see how fresh the displayed RTT is. The loss estimate comes
-statistics collector: outstanding sends can temporarily contribute to the
+from the shared statistics collector, so outstanding sends can temporarily
-cumulative loss estimate. Jitter is `-` until an IPDV pair is available.
+count towards cumulative loss. Jitter stays `-` until an IPDV pair is
 available.
-`Tab` / `Shift-Tab` selects a target, bringing its row into view when necessary.
+Use `Tab` / `Shift-Tab` to select a target and bring its row into view.
-Up to six target rows are shown; smaller terminals show fewer. Selecting a target
+The dashboard shows up to six target rows, with fewer on smaller terminals.
-changes the identification, one-way summary and details; the graph continues to
+Selecting a target changes the identification, one-way summary, and details.
-compare every target.
+The graph still compares every target.
-`d` opens a details sheet in the graph's space. It contains the selected target's
+Press `d` to open details in the graph's space. You'll find the selected
-session and negotiation, packet counters, progress, latest timing sample, full
+target's session and negotiation, packet counters, progress, latest timing
-timing statistics, warnings, and recent events from all targets. Scroll it with
+sample, full timing statistics, and warnings, along with recent events
-the arrows or page keys. Long lines and timing columns can be read with horizontal
+from all targets.
 scrolling, including full labels and remote addresses that do not fit in the
 header. `d` or `Esc` returns to the graph, preserving its metric and viewport.
 The former large/compact Dashboard screens have been replaced by this sheet;
 `g` remains an alias for `d`.
-The minimum terminal size is 56 columns by 18 rows. Below that size the UI asks
+Scroll with the arrows or page keys. You can scroll horizontally to read
-for a resize and continues acquiring measurements. Resize and important status
+long lines and timing columns, including labels and remote addresses that
-redraws still work while the display is paused.
+don't fit in the header. Press `d` or `Esc` to return to the graph with its
 metric and viewport preserved. You can also use `g` as an alias for `d`.
-## CONTROLS
+You need a terminal at least 56 columns wide and 18 rows tall. Below that
 size, the TUI asks you to resize while continuing to collect measurements.
 Resizing and important status redraws still work when the display is paused.
 ## Controls
 | Key | Action |
 | --- | --- |
@@ -126,50 +131,52 @@ Signed effective/adjusted RTT and one-way values are preserved. Graph windows
 range from 5 seconds to 24 hours and default to one minute. The footer shows
 controls appropriate to the currently open graph or details sheet.
-## RETAINED HISTORY
+## Retained history
-The TUI keeps its own bounded presentation state on top of the statistics
+Along with the statistics described in `irtt-client(1)`, the TUI keeps
-retention described in `irtt-client(1)`:
+some history for the display:
 - Up to 500,000 graph samples per target.
 - Up to 80 recent status/log messages.
-At 500,000 replies per target, retention is approximately 13h53m20s at
+At 500,000 replies per target, you get approximately 13h53m20s of history
-100ms intervals, 27h46m40s at 200ms, or 5d18h53m20s at 1s. Retained graph
+with 100ms intervals, 27h46m40s at 200ms, or 5d18h53m20s at 1s. Each graph
-samples store both clocks, six graph-ready values, and a session-boundary
+sample stores both clocks, six values ready for graphing, and a flag marking
-flag; latest details keep the full typed timing values and sequence number.
+session boundaries. The latest details keep the full typed timing values
-On 64-bit macOS, an 88-byte retained sample gives about 42 MiB per target
+and sequence number.
 at the cap, excluding statistics and temporary rendering buffers. Histories
 grow on demand and reserve exactly to the cap on their final growth step;
 they do not preallocate the full history for every target at startup.
-`r` clears graph history for all targets and returns the viewport to
+On 64-bit macOS, each retained sample takes 88 bytes, giving about 42 MiB
-live; it does not change the 500,000-sample cap itself. These are
+per target at the cap. Statistics and temporary rendering buffers use
-presentation bounds on top of the client's own statistics retention (see
+additional memory. History grows as needed and reserves exactly to the
-`irtt-client(1)` MEASUREMENTS AND MEMORY) — a long continuous TUI session's
+cap on its final growth step, so you don't pay for the full history of
-total memory is dominated by whichever of the two is larger for your target
+every target at startup.
 count.
-A **finite** `--duration` TUI run retains exact statistics samples exactly as
+Press `r` to clear graph history for all targets and return to the live
-`irtt-client(1)` does in finite mode, so its retained state grows with the
+view. This leaves the 500,000-sample cap unchanged. Display history is kept
-probe count rather than approaching a bound. Unlike `irtt-client`, the TUI
+in addition to the client's statistics (see Measurements and memory in
-prints **no** memory warning when that estimate gets large: it owns the
+`irtt-client(1)`). During a long continuous TUI session, whichever uses more
-alternate screen, and a stderr warning there would be invisible or would
+memory for your target count will dominate the total.
 corrupt the display. Size a long finite TUI run from the figures in
 `irtt-client(1)` MEASUREMENTS AND MEMORY, or use the continuous default.
-## EXIT BEHAVIOR
+If you set a finite `--duration`, the TUI retains exact statistics samples
 just as `irtt-client(1)` does in finite mode. Memory then grows with the
 probe count. The TUI does not print the memory warnings you get from
 `irtt-client`, since a stderr warning on the alternate screen could be
 invisible or corrupt the display. For a long finite run, plan memory using
 the figures in `irtt-client(1)` under Measurements and memory, or use the
 continuous default.
-Quitting with `q` or `Ctrl-C` is an interrupted, successful exit. In continuous
+## Exit behavior
-mode, peer closure and target failures trigger reconnect rather than ending the
+
-run. A managed driver failure or an unexpected reconnect-update failure still
+Quitting with `q` or `Ctrl-C` counts as an interrupted, successful exit.
-ends the TUI with an error.
+In continuous mode, the TUI reconnects after peer closure and target failures.
 A managed driver failure or an unexpected reconnect-update failure still
 ends the run with an error.
 Finite runs do not reconnect. They complete after their target sessions end;
 a peer closure is a normal session ending, while a run whose targets all fail
 exits with an error.
-## EXAMPLES
+## Examples
 ```sh
 irtt-tui host.example
@@ -178,7 +185,7 @@ irtt-tui eu=host-a.example us=host-b.example --pacing burst
 irtt-tui host.example --duration 30s
 ```
-## SEE ALSO
+## See also
 `irtt-client(1)` for target syntax, pacing, negotiation flags, and
 finite/continuous memory behavior; `irtt-server(1)`; `irtt-rs(1)`.
Author	SHA1	Message	Date
Nils Andreas Svee	641f8e18c3	chore(release): prepare irtt-rs 0.10.2 Rust CI / cargo fmt (push) Successful in 11s Details Rust CI / cargo clippy (push) Successful in 27s Details Rust CI / cargo check (x86_64-unknown-linux-gnu) (push) Successful in 26s Details Rust CI / cargo check (x86_64-unknown-linux-musl) (push) Successful in 34s Details Rust CI / cargo test (x86_64-unknown-linux-gnu) (push) Successful in 1m12s Details Rust CI / cargo doc (push) Successful in 28s Details Rust CI / cargo test (x86_64-unknown-linux-musl) (push) Successful in 1m16s Details Netem Interop / netem interop (push) Successful in 1m18s Details Fuzz Smoke / cargo fuzz smoke (push) Successful in 1m38s Details Supply chain / cargo-deny advisories (push) Successful in 16s Details Supply chain / actionlint (push) Failing after 2s Details Supply chain / cargo-deny bans licenses sources (push) Successful in 15s Details Build binaries / Build (arm-musleabi) (push) Successful in 4m58s Details Build binaries / Build (aarch64-musl) (push) Successful in 5m8s Details Semver / cargo-semver-checks (push) Successful in 53s Details Publish irtt-server image / publish (push) Successful in 1m8s Details Build binaries / Build (arm-musleabihf) (push) Successful in 4m29s Details Build binaries / Build (armv7-musleabi) (push) Successful in 4m25s Details Build binaries / Build (armv7-musleabihf) (push) Successful in 4m36s Details Build binaries / Build (i686-musl) (push) Successful in 4m35s Details Build binaries / Build (mips-musl) (push) Successful in 4m24s Details Build binaries / Build (mips64-muslabi64) (push) Successful in 4m22s Details Build binaries / Build (mipsel-musl) (push) Successful in 4m39s Details Build binaries / Build (mips64el-muslabi64) (push) Successful in 4m41s Details Build binaries / Build (riscv64gc-musl) (push) Successful in 5m19s Details Build binaries / Build (x86_64-musl) (push) Successful in 5m19s Details	2026-10-28 15:30:59 +07:00
Nils Andreas Svee	d2d5f87e91	feat(client): filter output by selected event types Rust CI / cargo fmt (push) Successful in 16s Details Rust CI / cargo clippy (push) Successful in 31s Details Rust CI / cargo check (x86_64-unknown-linux-gnu) (push) Successful in 25s Details Rust CI / cargo check (x86_64-unknown-linux-musl) (push) Successful in 31s Details Rust CI / cargo test (x86_64-unknown-linux-gnu) (push) Successful in 1m11s Details Rust CI / cargo doc (push) Successful in 27s Details Rust CI / cargo test (x86_64-unknown-linux-musl) (push) Successful in 1m17s Details Fuzz Smoke / cargo fuzz smoke (push) Successful in 1m38s Details Netem Interop / netem interop (push) Successful in 1m19s Details Supply chain / cargo-deny advisories (push) Successful in 19s Details Supply chain / cargo-deny bans licenses sources (push) Successful in 18s Details Supply chain / actionlint (push) Failing after 3s Details Build binaries / Build (arm-musleabi) (push) Successful in 4m50s Details Build binaries / Build (aarch64-musl) (push) Successful in 5m5s Details Build binaries / Build (arm-musleabihf) (push) Successful in 4m45s Details Build binaries / Build (armv7-musleabi) (push) Successful in 4m38s Details Build binaries / Build (armv7-musleabihf) (push) Successful in 4m52s Details Build binaries / Build (i686-musl) (push) Successful in 4m54s Details Build binaries / Build (mips64-muslabi64) (push) Successful in 4m33s Details Build binaries / Build (mips-musl) (push) Successful in 4m35s Details Build binaries / Build (mips64el-muslabi64) (push) Successful in 4m44s Details Build binaries / Build (mipsel-musl) (push) Successful in 4m45s Details Build binaries / Build (riscv64gc-musl) (push) Successful in 4m47s Details Build binaries / Build (x86_64-musl) (push) Successful in 5m19s Details	2026-10-28 15:28:26 +07:00
Nils Andreas Svee	5b5e38a059	chore(release): prepare irtt-rs 0.10.1 Rust CI / cargo fmt (push) Successful in 14s Details Rust CI / cargo clippy (push) Successful in 27s Details Rust CI / cargo check (x86_64-unknown-linux-gnu) (push) Successful in 25s Details Rust CI / cargo check (x86_64-unknown-linux-musl) (push) Successful in 36s Details Rust CI / cargo test (x86_64-unknown-linux-gnu) (push) Successful in 1m13s Details Rust CI / cargo doc (push) Successful in 32s Details Build binaries / Build (arm-musleabi) (push) Successful in 4m54s Details Rust CI / cargo test (x86_64-unknown-linux-musl) (push) Successful in 1m17s Details Build binaries / Build (aarch64-musl) (push) Successful in 5m7s Details Supply chain / cargo-deny advisories (push) Successful in 22s Details Supply chain / cargo-deny bans licenses sources (push) Successful in 18s Details Supply chain / actionlint (push) Failing after 4s Details Netem Interop / netem interop (push) Successful in 1m20s Details Fuzz Smoke / cargo fuzz smoke (push) Successful in 1m38s Details Semver / cargo-semver-checks (push) Successful in 58s Details Publish irtt-server image / publish (push) Successful in 1m6s Details Build binaries / Build (arm-musleabihf) (push) Successful in 4m46s Details Build binaries / Build (armv7-musleabi) (push) Successful in 4m42s Details Build binaries / Build (armv7-musleabihf) (push) Successful in 4m58s Details Build binaries / Build (i686-musl) (push) Successful in 4m59s Details Build binaries / Build (mips-musl) (push) Successful in 4m37s Details Build binaries / Build (mips64-muslabi64) (push) Successful in 4m34s Details Build binaries / Build (mips64el-muslabi64) (push) Successful in 4m26s Details Build binaries / Build (mipsel-musl) (push) Successful in 4m21s Details Build binaries / Build (riscv64gc-musl) (push) Successful in 4m25s Details Build binaries / Build (x86_64-musl) (push) Successful in 4m25s Details	2026-10-28 12:30:02 +07:00
Nils Andreas Svee	97bd903769	chore: improve documentation and README Rust CI / cargo fmt (push) Successful in 17s Details Rust CI / cargo clippy (push) Successful in 33s Details Rust CI / cargo check (x86_64-unknown-linux-gnu) (push) Successful in 23s Details Rust CI / cargo check (x86_64-unknown-linux-musl) (push) Successful in 33s Details Rust CI / cargo test (x86_64-unknown-linux-gnu) (push) Successful in 1m7s Details Rust CI / cargo doc (push) Successful in 27s Details Rust CI / cargo test (x86_64-unknown-linux-musl) (push) Successful in 1m21s Details Fuzz Smoke / cargo fuzz smoke (push) Successful in 1m40s Details Netem Interop / netem interop (push) Successful in 1m18s Details Supply chain / cargo-deny advisories (push) Successful in 18s Details Supply chain / actionlint (push) Failing after 4s Details Supply chain / cargo-deny bans licenses sources (push) Successful in 17s Details Build binaries / Build (arm-musleabi) (push) Successful in 4m58s Details Build binaries / Build (aarch64-musl) (push) Successful in 5m6s Details Build binaries / Build (arm-musleabihf) (push) Successful in 4m38s Details Build binaries / Build (armv7-musleabi) (push) Successful in 4m33s Details Build binaries / Build (armv7-musleabihf) (push) Successful in 4m57s Details Build binaries / Build (i686-musl) (push) Successful in 5m1s Details Build binaries / Build (mips64-muslabi64) (push) Successful in 4m35s Details Build binaries / Build (mips-musl) (push) Successful in 4m42s Details Build binaries / Build (mips64el-muslabi64) (push) Successful in 4m54s Details Build binaries / Build (mipsel-musl) (push) Successful in 4m54s Details Build binaries / Build (riscv64gc-musl) (push) Successful in 4m36s Details Build binaries / Build (x86_64-musl) (push) Successful in 4m40s Details	2026-10-28 12:17:48 +07:00
Nils Andreas Svee	f02f9c0714	chore(deps): update unicode-width to 0.2.3 Rust CI / cargo fmt (push) Successful in 13s Details Rust CI / cargo clippy (push) Successful in 25s Details Rust CI / cargo check (x86_64-unknown-linux-gnu) (push) Successful in 26s Details Rust CI / cargo check (x86_64-unknown-linux-musl) (push) Successful in 30s Details Rust CI / cargo test (x86_64-unknown-linux-gnu) (push) Successful in 1m9s Details Rust CI / cargo doc (push) Successful in 31s Details Rust CI / cargo test (x86_64-unknown-linux-musl) (push) Successful in 1m21s Details Fuzz Smoke / cargo fuzz smoke (push) Successful in 1m40s Details Netem Interop / netem interop (push) Successful in 1m24s Details Supply chain / cargo-deny advisories (push) Successful in 18s Details Supply chain / cargo-deny bans licenses sources (push) Successful in 15s Details Supply chain / actionlint (push) Failing after 3s Details Build binaries / Build (arm-musleabi) (push) Successful in 4m57s Details Build binaries / Build (aarch64-musl) (push) Successful in 5m7s Details Build binaries / Build (arm-musleabihf) (push) Successful in 5m9s Details Build binaries / Build (armv7-musleabi) (push) Successful in 5m4s Details Build binaries / Build (armv7-musleabihf) (push) Successful in 5m33s Details Build binaries / Build (i686-musl) (push) Successful in 5m37s Details Build binaries / Build (mips64-muslabi64) (push) Successful in 5m15s Details Build binaries / Build (mips-musl) (push) Successful in 5m18s Details Build binaries / Build (mips64el-muslabi64) (push) Successful in 4m29s Details Build binaries / Build (mipsel-musl) (push) Successful in 4m47s Details Build binaries / Build (riscv64gc-musl) (push) Successful in 4m54s Details Build binaries / Build (x86_64-musl) (push) Successful in 5m7s Details	2026-10-28 11:26:13 +07:00
Nils Andreas Svee	5957e395a2	Merge branch 'fix/stdout-cancellation' Rust CI / cargo fmt (push) Successful in 43s Details Rust CI / cargo clippy (push) Successful in 58s Details Rust CI / cargo check (x86_64-unknown-linux-gnu) (push) Successful in 30s Details Rust CI / cargo check (x86_64-unknown-linux-musl) (push) Successful in 31s Details Rust CI / cargo test (x86_64-unknown-linux-gnu) (push) Successful in 1m6s Details Rust CI / cargo doc (push) Successful in 31s Details Rust CI / cargo test (x86_64-unknown-linux-musl) (push) Successful in 1m21s Details Fuzz Smoke / cargo fuzz smoke (push) Successful in 1m39s Details Netem Interop / netem interop (push) Successful in 1m23s Details Supply chain / cargo-deny advisories (push) Successful in 16s Details Supply chain / actionlint (push) Failing after 3s Details Supply chain / cargo-deny bans licenses sources (push) Successful in 19s Details Build binaries / Build (arm-musleabi) (push) Successful in 5m25s Details Build binaries / Build (aarch64-musl) (push) Successful in 5m30s Details Build binaries / Build (arm-musleabihf) (push) Successful in 5m19s Details Build binaries / Build (armv7-musleabi) (push) Successful in 5m21s Details Build binaries / Build (armv7-musleabihf) (push) Successful in 5m38s Details Build binaries / Build (i686-musl) (push) Successful in 5m36s Details Build binaries / Build (mips64-muslabi64) (push) Failing after 2m27s Details Build binaries / Build (mips-musl) (push) Successful in 5m16s Details Build binaries / Build (mips64el-muslabi64) (push) Successful in 4m48s Details Build binaries / Build (mipsel-musl) (push) Successful in 4m48s Details Build binaries / Build (riscv64gc-musl) (push) Successful in 5m6s Details Build binaries / Build (x86_64-musl) (push) Successful in 5m10s Details	2026-10-28 11:21:15 +07:00
Nils Andreas Svee	5b5f5b2609	fix(client): preserve partial summaries on graceful interruption	2026-10-28 11:10:18 +07:00
Nils Andreas Svee	c8a911297d	fix(client): allow cancellation while stdout is blocked	2026-10-28 00:32:52 +07:00