Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In @.github/workflows/abi-check.yml:
- Around line 31-41: The baseline selection in the Determine baseline ref step
currently includes the tag that triggered the workflow, causing cargo
semver-checks to compare a release against itself. Update the PREV_TAG lookup so
it explicitly excludes the current refs/tags/v* ref from the git tag search
before setting skip/tag in the baseline step, using the existing baseline job
logic and GITHUB_OUTPUT values.
- Around line 16-18: The ABI check workflow is using the newest tag as its own
baseline on v* pushes, so update the workflow to select the previous release tag
instead of the latest one. Adjust the tag-selection logic in the abi-check job
so the step that feeds cargo semver-checks excludes the currently pushed tag and
resolves the prior version tag, keeping the existing checkout and semver-checks
flow intact.

In @.github/workflows/release.yml:
- Around line 80-85: The release packaging step is swallowing missing library
artifacts in the “Stage dist tree” script, which can allow an incomplete tarball
to be published. Update the dist staging logic to validate that both
`liblibrtmp2.so` and `liblibrtmp2.a` are present before continuing, and fail the
workflow with a clear error if either artifact is absent; use the existing
release job and the staging block around `DIST_DIR` as the place to enforce this
check.

In `@examples/ffmpeg_ingest.rs`:
- Around line 71-101: The failure path in ffmpeg_ingest’s main loop is using a
stale success flag; if server.poll(200) errors after the counters already
reached the thresholds, the test still reports a timeout. Recompute success from
the final VIDEO_FRAMES and AUDIO_FRAMES values right before the !success check,
and use that updated result when deciding whether to return ExitCode::from(2).
Keep the existing loop and diagnostics, but make the final decision in this
block reflect the latest counters rather than only the in-loop non-error path.

In `@examples/play_pull.rs`:
- Around line 59-82: The pass/fail logic in the pull example still depends on
the mutable success flag, which can miss a valid run if client.poll(200) returns
an error after the first audio/video frames arrive. Update the decision in the
main loop around client.poll, VIDEO_FRAMES, and AUDIO_FRAMES to evaluate the
final frame counters at the end instead of relying on success, and use those
counters to determine whether to print PASS or FAIL.

In `@src/client/mod.rs`:
- Around line 112-116: The `publish()` and `play()` flows in `Client` ignore the
result of `wait_for_command("onStatus")`, so they can return success and advance
`ClientState` even when the server rejects, times out, or disconnects. Update
both methods to check and propagate the `wait_for_command` result instead of
discarding it, and only set the state to `Publishing` or `Playing` after a
successful `onStatus` confirmation.
- Around line 364-368: The URL parsing in the client path split logic accepts
incomplete RTMP URLs, so update the parsing in the function that builds the
`(host, port, app, stream_key)` tuple to reject inputs missing either the app or
the stream key. After splitting the path, validate that both `app` and
`stream_key` are non-empty and return an error from this parser instead of
`Ok(...)` when the URL only contains `rtmp://host` or `rtmp://host/app`.
- Around line 320-323: The client-side blocking poll in
`recv_message()`/`read_exact()` currently waits forever with `libc::poll(...,
-1)`, which can hang `connect()`, `publish()`, or `play()` during handshake or
reads. Update the poll loop in `src/client/mod.rs` to use a finite timeout
instead of infinite blocking, and when the timeout expires return
`ErrorCode::Timeout`. Keep the change localized around the `again` retry path
and the `transport.fd()` poll handling so stalled peers fail cleanly.
- Around line 75-84: The connection setup in Client::connect leaks the socket if
do_handshake() fails because into_raw_fd() takes ownership before the handshake
succeeds and client_fd is only set afterward. Fix this by keeping the TcpStream
owned until the handshake completes, or by ensuring the raw fd is explicitly
closed on any error path in Client::connect while preserving the existing
Transport::new_plain and do_handshake flow. The nonblocking socket change is
unnecessary since the read path already uses MSG_DONTWAIT.

In `@src/server/mod.rs`:
- Around line 102-105: The accepted connection setup in Server::new / the
accept-path around Conn::new is always using Transport::new_plain(fd), which
silently ignores tls_ctx even when tls_enabled is set. Update this code to use a
TLS transport when Server::new initialized tls_ctx, wiring the accepted fd
through the TLS-capable Transport path; if that is not implemented yet,
explicitly reject TLS-enabled configurations instead of falling back to plain
TCP.
- Around line 97-106: Enforce the configured connection cap in the accept loop
inside `Server::run` before creating and pushing a new `Conn`. Check
`self.connections.len()` against `self.config.max_connections` immediately after
`listener.accept()` succeeds, and if the limit is reached, skip or reject the
peer without calling `into_raw_fd()` or `Transport::new_plain`. Keep the
existing connection setup path for accepted peers only when under the limit.
- Line 143: The flush in the connection handling path is currently ignored,
which can leave failed peers in self.connections after a write-side error.
Update the logic around conn.flush() to check its result and, on failure, treat
it as a broken connection by removing or closing that conn so it does not remain
tracked. Use the existing connection management flow in src/server/mod.rs around
the flush call and the self.connections collection to keep the cleanup
consistent.
- Around line 58-62: The address formatting in the server bind logic drops IPv6
brackets after split_host_port, so the addr built in the server module can
become invalid for TcpListener::bind. Update the bind address construction to
preserve or re-add brackets whenever the host from split_host_port contains a
colon, while keeping the existing behavior for empty and IPv4 host values.

In `@tests/interop/enhanced_rtmp_interop.sh`:
- Around line 42-58: In run_one, the ffmpeg publish step should be treated as
the primary test result instead of always waiting on the ingest server first.
Capture the ffmpeg exit status immediately after the timeout ffmpeg invocation,
and if it is non-zero, fail and return from run_one before calling wait on
"$srv"; keep the existing ingest exit handling only for the successful publish
path. Use the run_one workflow and the ffmpeg/ wait "$srv" sequence to locate
the change.

In `@tests/interop/ffmpeg_interop.sh`:
- Around line 38-50: The ffmpeg publish flow in ffmpeg_interop.sh does not fail
fast after recording FF_RC, so the script can hang waiting on SRV even when
publish never starts. Update the publish block around the ffmpeg invocation and
wait "$SRV" so that a nonzero FF_RC causes an immediate exit or explicit failure
path before waiting on the ingest server, while keeping the existing set -e
behavior intact for the rest of the script.

In `@tests/interop/play_interop.sh`:
- Around line 43-46: The startup flow in play_interop.sh currently relies on a
fixed sleep after launching mediamtx, which can let the script continue even if
the process died or never bound the RTMP port. Replace that sleep with an
explicit readiness check around the mediamtx launch: verify the MTX process is
still running and poll the RTMP port until it accepts connections before
starting ffmpeg or the play client. Keep the check close to the mediamtx startup
block so the downstream interop-play steps only run after readiness is
confirmed.

In `@tests/server_client_loopback.rs`:
- Around line 40-71: The client thread in server_client_loopback.rs does not
surface setup failures until join(), so failures in Client::connect, publish, or
send_frame can look like timeouts. Update the spawned client workflow to return
a Result through a channel or shared result so the main test can fail
immediately on the first error, and keep the existing poll loop only for waiting
on FRAMES_RECEIVED once client setup succeeds.

---

Nitpick comments:
In `@tests/server_client_loopback.rs`:
- Around line 16-20: The loopback test only increments FRAMES_RECEIVED for any
non-empty frame, so it can pass even when the server sends the wrong or
corrupted payload. Update on_frame to inspect the Frame contents via frame_type,
size, and data, capture the received bytes, and assert they match the expected
32-byte payload of [0xAB; 32]. Use the existing Frame fields in the callback and
tighten the test so it validates exact content rather than merely counting
bytes.