rigplane 2.7.2__tar.gz → 2.8.0__tar.gz

{rigplane-2.7.2 → rigplane-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigplane
-Version: 2.7.2
+Version: 2.8.0
 Summary: Multi-vendor radio control library and Web UI with native providers and planned Hamlib-backed CAT coverage
 Project-URL: Homepage, https://rigplane.dev/
 Project-URL: Documentation, https://rigplane.dev/

{rigplane-2.7.2 → rigplane-2.8.0}/docs/CHANGELOG.md

@@ -11,6 +11,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.8.0] — 2026-06-02
+
+### Added
+
+- Web transport: added a backend-neutral `Connection` protocol and retargeted
+  the control, scope, and audio handlers to depend on that transport seam rather
+  than the concrete WebSocket wrapper. This is a no-behaviour-change foundation
+  for alternate transports (MOR-274, #1701, 8f2b6c5b).
+- WebRTC transport foundation: added optional `WebRtcDataChannelConnection`
+  support behind the `[webrtc]` extra, including an ordered/reliable `control`
+  DataChannel that drives the unchanged control handler with the same wire frame
+  shape as the WebSocket path (MOR-312, #1707, 047dea74).
+- WebRTC multi-channel support: added `scope` and `audio` DataChannel helpers
+  on the same peer connection, configured unordered and lossy
+  (`maxRetransmits=0`) while reusing the same connection adapter and unchanged
+  handlers (MOR-306, #1710, f1dad721).
+- Discovery: `DiscoveryResponder` can now advertise a station fleet through an
+  additive `radios[]` array with per-radio ids, models, urls, status, and
+  connection state, while preserving the legacy single-radio top-level fields
+  for existing discovery clients (MOR-303, #1705, eb4e2a98).
+
+### Changed
+
+- Audio bus lifecycle: subscriptions now have an awaited close path and bridge
+  teardown waits for subscriber removal, reducing restart races and keeping
+  rapid start/stop diagnostics deterministic (#1568, #1708, dae97577).
+- Realtime TX queue policy: bridge TX overflow now evicts the oldest queued
+  audio frame and keeps the newest live capture frame, preserving bounded
+  latency while continuing to count overruns (#1565, #1708, dae97577).
+- Public docs now clarify WSJT-X loopback device direction, advisory
+  `/api/v1/audio` `frame_ms` semantics, validation workflow status, and command
+  catalog stability boundaries (#1567, #1708, dae97577).
+
+### Fixed
+
+- External CAT reconnect: a leaked external-CAT ownership flag is now reset on
+  radio reconnect, so rigctld and web pollers resume instead of serving stale
+  frequency/state after a managed runtime restart (MOR-301, #1703, c3cb411d).
+- Hamlib bridge startup: partial `open_transport()` failures after CAT session
+  acquisition now release ownership, preventing a failed listener/server setup
+  from leaving pollers paused (#1703, c3cb411d).
+- Web audio TX cleanup: active PCM/Opus TX is now stopped or safely released
+  when an audio websocket disconnects, is cancelled, or exits with an exception;
+  explicit `audio_stop` behavior is preserved (#1566, #1708, dae97577).
+
+## [2.7.3] — 2026-05-31
+
+### Fixed
+
+- Windows FT8 TX delivered no audio (Po=0 W): the callback/`blocksize=0` TX
+  capture emitted 960-byte (10 ms) frames while the PCM TX validator requires
+  1920-byte (20 ms) frames; capture now re-chunks the continuous callback stream
+  into fixed 20 ms frames (keeps the ~50 Hz comb fix; lossless) (MOR-256, #1699,
+  17492be6)
+
+### Changed
+
+- Build (packaging): build the web UI during packaging so source/git installs
+  bundle the SPA (#1698, 55a0f81f)
+
 ## [2.7.2] — 2026-05-30
 
 ### Fixed
@@ -1543,7 +1603,9 @@ These deprecation closures were announced in v0.19 and dropped on schedule.
 - Transport layer, authentication, CI-V commands, meters, PTT, keep-alive.
 - Clean-room Icom LAN UDP protocol implementation.
 
-[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.7.2...HEAD
+[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.8.0...HEAD
+[2.8.0]: https://github.com/rigplane/rigplane-core/compare/v2.7.3...v2.8.0
+[2.7.3]: https://github.com/rigplane/rigplane-core/compare/v2.7.2...v2.7.3
 [2.7.2]: https://github.com/rigplane/rigplane-core/compare/v2.7.1...v2.7.2
 [2.7.1]: https://github.com/rigplane/rigplane-core/compare/v2.7.0...v2.7.1
 [2.7.0]: https://github.com/rigplane/rigplane-core/compare/v2.6.0...v2.7.0

{rigplane-2.7.2 → rigplane-2.8.0}/docs/PROJECT.md

@@ -323,7 +323,7 @@ IC-7610 parity matrix (issue #139, 2026-03-06): 134 implemented, 0 partial, 0 mi
 
 ### Phase 12 — Dual VFO / Dual Receiver architecture overhaul (#708) 🚧 IN PROGRESS
 
-**Goal:** Public `Radio` protocol expresses `Transceiver → Receiver → VFO` unambiguously across IC-7610, IC-9700, IC-7300, IC-705 and FTX-1, with no model-specific branches at call sites. Audit: `.claude/workflow/dual-vfo-audit.md`; architecture: `.claude/architecture/protocol.md` "Receiver tier"; schema: `rigs/_schema_v2.md`. Landed foundation: #709 (`VfoSlotState` + per-receiver `active_slot` on `ReceiverState`), #710 (split TOML `swap_ab`/`equal_ab` vs `swap_main_sub`/`equal_main_sub` with legacy `swap`/`equal` deprecation), #711 (`ReceiverBankCapable` + `VfoSlotCapable` runtime-checkable Protocols), #713 (IC-9700 profile rewritten as `scheme = "main_sub"` with empty `cmd29.routes` per wfview `HasCommand29=false`). Pending: #712 `TransceiverBankCapable` for FTX-1, plus the phase 2–4 backend, frontend and rigctld wiring tracked under epic #708.
+**Goal:** Public `Radio` protocol expresses `Transceiver → Receiver → VFO` unambiguously across IC-7610, IC-9700, IC-7300, IC-705 and FTX-1, with no model-specific branches at call sites. Audit: `.claude/workflow/dual-vfo-audit.md`; architecture: `.claude/architecture/protocol.md` "Receiver tier"; schema: `rigs/_schema_v2.md`. Landed foundation: #709 (`VfoSlotState` + per-receiver `active_slot` on `ReceiverState`), #710 (split TOML `swap_ab`/`equal_ab` vs `swap_main_sub`/`equal_main_sub` with legacy `swap`/`equal` deprecation), #711 (`ReceiverBankCapable` + `VfoSlotCapable` runtime-checkable Protocols), #713 (IC-9700 profile rewritten as `scheme = "main_sub"` with empty `cmd29.routes` per wfview `HasCommand29=false`), #712 (FTX-1 `TransceiverBankCapable` foundation), #716 (backend/API split wiring), and #727 (cross-band split backend/API regression coverage). Cross-band split backend/API tests now cover the implemented foundation. Remaining work is frontend and hardware polish plus any incremental rigctld/user-experience follow-up tracked under epic #708.
 
 ### Reliability Test Expansion (2026-03-05)
 - Added extended integration coverage scaffolding for:

{rigplane-2.7.2 → rigplane-2.8.0}/docs/api/web.md

@@ -117,6 +117,10 @@ machine-readable HTTP/WS command catalog — every command name, parameter shape
 capability gate, and batch-eligibility flag — is published in
 [HTTP / WebSocket Command Catalog](command-catalog.md).
 
+The catalog documents the current command surface. A route or command is not a
+stable API contract solely because it appears there; stability still comes from
+explicit promotion into `rigplane.web.api_contract`.
+
 ### Internal And Diagnostic Surface
 
 Browser static files, `src/rigplane/web/static*`, handler class names, queue
@@ -952,6 +956,24 @@ and reports `scopeSource: "audio_fft"`.
 | `/api/v1/scope` | server -> client | Binary scope frames |
 | `/api/v1/audio` | bi-directional | JSON control + binary audio frames |
 
+Binary audio frames use an 8-byte header followed by codec-specific payload:
+
+| Offset | Size | Field | Notes |
+|--------|------|-------|-------|
+| `0` | 1 | `msg_type` | `0x10` RX, `0x11` TX |
+| `1` | 1 | `codec` | `0x01` Opus, `0x02` PCM16 |
+| `2` | 2 | `sequence` | uint16 little-endian |
+| `4` | 2 | `sample_rate` | encoded as Hz / 100, uint16 little-endian |
+| `6` | 1 | `channels` | `1` mono, `2` stereo |
+| `7` | 1 | `frame_ms` | advisory frame-duration label |
+| `8..` | variable | payload | codec-specific audio bytes |
+
+`frame_ms` is advisory. Consumers must derive actual audio length from the
+payload and metadata, not from a fixed frame-duration assumption. For PCM16,
+use `payload_bytes / (channels * 2)` to compute sample frames and use the
+header sample rate for playback timing; Opus consumers should decode the
+payload and use decoder output metadata.
+
 ### `/api/v1/ws` command envelope
 
 ```json

{rigplane-2.7.2 → rigplane-2.8.0}/docs/contracts/validation-matrix-v1.md

@@ -13,9 +13,9 @@ validation matrix for one radio) and validation **artifacts** (the recorded
 evidence of a run). It is the spec that `rigplane.validation` builds against and
 that any tooling consuming validation output should target.
 
-The current release ships the **dry-run** path only. The artifact shape is
-forward-compatible with hardware runs, but hardware execution is intentionally
-not implemented and is double-gated (see [Safety policy](#safety-policy)).
+The current release supports dry-run planning and gated hardware execution. The
+artifact shape covers both modes, and hardware execution is double-gated (see
+[Safety policy](#safety-policy)).
 
 ## Core boundary
 
@@ -140,9 +140,10 @@ skipped.
 
 Hardware execution is additionally double-gated at the CLI: `--hardware`
 requires both the `--allow-hardware` flag and the
-`RIGPLANE_VALIDATION_ALLOW_HARDWARE=1` environment variable. Even with both
-gates open, the current release refuses hardware runs (exit code `3`) because
-the hardware path is not implemented.
+`RIGPLANE_VALIDATION_ALLOW_HARDWARE=1` environment variable. With both gates
+open, the runner executes against hardware and emits a `mode: "hardware"`
+artifact. If either gate is missing, the CLI keeps the run in the safe planning
+path and does not touch a radio.
 
 ## Versioning
 

{rigplane-2.7.2 → rigplane-2.8.0}/docs/guide/audio-recipes.md

@@ -33,6 +33,12 @@ a diagnostic report includes `radio_native.requested`,
 `radio_native.effective`, and `web_rx` when those values are available or
 configured.
 
+For WebSocket audio frames, `frame_ms` is a timing label, not an allocation
+contract. Consumers should derive the actual buffer length from the payload and
+frame metadata: codec, sample rate, channel count, bytes per sample for PCM, and
+the binary payload size. Browser/client code must not assume every frame has a
+fixed duration or fixed payload length.
+
 `ICOM_AUDIO_SAMPLE_RATE` remains an operator override. Set it when you need to
 force the direct LAN conninfo sample rate for testing, hardware compatibility,
 or bandwidth-constrained tunnel paths:
@@ -347,17 +353,29 @@ Run Web UI + audio bridge + rigctld in a single command:
 ```bash
 # Install (audio-bridge deps ship with the core install since v0.19)
 pip install rigplane
-brew install blackhole-2ch  # macOS
+brew install blackhole-2ch blackhole-16ch  # macOS
 
 # Start everything
 rigplane --host 192.168.1.100 --user USER --pass PASS \
-    web --bridge "BlackHole 2ch"
+    web --bridge "BlackHole 2ch" --bridge-tx-device "BlackHole 16ch"
 
 # WSJT-X settings:
 #   Radio: Hamlib NET rigctl, localhost:4532
-#   Audio Input/Output: BlackHole 2ch
+#   Audio Input:  BlackHole 2ch
+#   Audio Output: BlackHole 16ch
 ```
 
+The direction matters:
+
+- `--bridge "BlackHole 2ch"` is the RX playback loopback:
+  **radio RX → rigplane → BlackHole 2ch → WSJT-X Input**.
+- `--bridge-tx-device "BlackHole 16ch"` is the TX capture loopback:
+  **WSJT-X Output → BlackHole 16ch → rigplane → radio TX**.
+
+Use two separate loopback devices for bidirectional operation. Reusing one
+device for both WSJT-X input and output can feed rigplane's RX audio back into
+its TX capture path.
+
 ---
 
 ## Heavy usage and deployment

rigplane-2.8.0/hatch_build.py

@@ -0,0 +1,68 @@
+"""Hatchling build hook that bundles the Svelte web UI into the package.
+
+The frontend lives in ``frontend/`` and its build output (``frontend/dist``)
+is gitignored. At runtime the SPA is served from ``src/rigplane/web/static``,
+so the package must ship the built assets at that location.
+
+This hook makes every build target (wheel *and* sdist) self-contained:
+
+* If ``frontend/dist/index.html`` is missing and a ``frontend/`` source tree is
+  present, it builds the SPA with ``npm`` (``npm ci``/``npm install`` then
+  ``npm run build``). If ``npm`` is unavailable and no prebuilt dist exists, it
+  raises a clear ``RuntimeError`` so the failure is actionable.
+* If ``frontend/dist/index.html`` already exists, the npm build is skipped — the
+  hook is idempotent, so the PyPI publish flow (which prebuilds the frontend)
+  does not rebuild it.
+* The built ``frontend/dist`` is force-included at ``src/rigplane/web/static``
+  for whichever target is building, centralizing the mapping in one place.
+
+Without this, ``pip install git+https://...`` (a direct wheel build) would not
+bundle the SPA and the desktop UI would 404.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+# Runtime location the installed package serves the SPA from. Must not change.
+_RUNTIME_STATIC = "src/rigplane/web/static"
+
+
+class FrontendBuildHook(BuildHookInterface):  # type: ignore[type-arg]
+    """Build the web UI (if needed) and bundle it into the package."""
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        root = Path(self.root)
+        frontend_dir = root / "frontend"
+        dist_index = frontend_dir / "dist" / "index.html"
+
+        if not dist_index.exists() and frontend_dir.is_dir():
+            self._build_frontend(frontend_dir)
+
+        # Inject the force-include so the SPA lands at the runtime location for
+        # whichever target (wheel or sdist) is building.
+        force_include = build_data.setdefault("force_include", {})
+        force_include["frontend/dist"] = _RUNTIME_STATIC
+
+    def _build_frontend(self, frontend_dir: Path) -> None:
+        npm = shutil.which("npm")
+        if npm is None:
+            raise RuntimeError(
+                "Building rigplane from source requires Node.js/npm to build "
+                "the web UI (frontend/dist is not present and could not be "
+                "built). Install Node.js/npm, or build a wheel/sdist on a "
+                "machine that has them (the resulting artifact is "
+                "self-contained and needs no Node.js to install)."
+            )
+
+        lockfile = frontend_dir / "package-lock.json"
+        install_cmd = [npm, "ci"] if lockfile.exists() else [npm, "install"]
+
+        self.app.display_info("Building rigplane web UI (npm)...")
+        subprocess.run(install_cmd, cwd=frontend_dir, check=True)
+        subprocess.run([npm, "run", "build"], cwd=frontend_dir, check=True)

{rigplane-2.7.2 → rigplane-2.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rigplane"
-version = "2.7.2"
+version = "2.8.0"
 description = "Multi-vendor radio control library and Web UI with native providers and planned Hamlib-backed CAT coverage"
 readme = "README.md"
 license = "MIT"
@@ -74,12 +74,22 @@ dev = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/rigplane", "src/icom_lan"]
+# The web UI is placed at src/rigplane/web/static exclusively via the custom
+# build hook's force-include (see hatch_build.py). When building a wheel from an
+# sdist (uv build's default sdist->wheel chain), the sdist has already
+# materialized src/rigplane/web/static on disk; exclude it from normal project
+# file selection so the force-include is the single source and the tree is not
+# bundled twice.
+exclude = ["src/rigplane/web/static"]
 
 [tool.hatch.build.targets.wheel.force-include]
 "rigs" = "rigplane/rigs"
 
-[tool.hatch.build.targets.sdist.force-include]
-"frontend/dist" = "src/rigplane/web/static"
+# Builds the Svelte web UI during packaging (if not prebuilt) and force-includes
+# the result at src/rigplane/web/static for BOTH wheel and sdist targets, so
+# source/git installs are self-contained. See hatch_build.py.
+[tool.hatch.build.hooks.custom]
+path = "hatch_build.py"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{rigplane-2.7.2 → rigplane-2.8.0}/src/rigplane/audio/backend.py

@@ -10,7 +10,6 @@ opening RX/TX audio streams, plus two concrete implementations:
 
 from __future__ import annotations
 
-import asyncio
 import logging
 import math
 import threading
@@ -228,7 +227,35 @@ def _ensure_portaudio_deps() -> tuple[Any, Any]:
 
 
 class _PortAudioRxStream:
-    """RxStream backed by a sounddevice InputStream."""
+    """RxStream backed by a callback-driven sounddevice InputStream.
+
+    Capture is clocked by PortAudio's own audio thread via an ``InputStream``
+    callback, mirroring the callback design of :class:`_PortAudioTxStream`.
+    This replaces the previous fixed-``blocksize=960`` blocking-read loop
+    (``stream.read(960)`` on a worker thread), whose 20 ms read straddled the
+    WASAPI shared-mode engine period (~10 ms) and dropped/duplicated a sample
+    run once per block, producing a ~50 Hz spectral comb on captured TX audio
+    on Windows. The stream is opened with ``blocksize=0`` (engine-native
+    period), mirroring a known-clean ``sd.rec`` capture. The earlier WDM-KS
+    capture face rejected ``blocksize=0`` (PortAudioError -9999), but companion
+    device selection now forces the WASAPI host-API face, on which
+    ``blocksize=0`` opens cleanly.
+
+    The PortAudio callback runs on the audio thread and must not block. It
+    copies the captured PCM (s16le) out of the engine-native, variable-size
+    block and *re-chunks* it into fixed ``frame_ms``-sized frames before
+    handing them to the consumer *callback*. The downstream PCM-TX contract
+    requires fixed-size frames (e.g. 20 ms = 960 samples = 1920 bytes s16le
+    mono @ 48 kHz); a managed core validator rejects any frame whose byte
+    length differs. Re-chunking a *continuous* callback stream is lossless and
+    introduces no scheduling seam (the ~50 Hz comb came from the old
+    blocking-read inter-read gap, not from re-chunking), so this preserves the
+    fixed-frame contract without re-introducing the comb. Sub-frame remainders
+    are buffered across callbacks; a trailing partial frame at stop is dropped.
+    The consumer contract (see :class:`RxStream`) is that the callback is cheap
+    and thread-safe to invoke from the audio thread; the companion bridge
+    marshals onto its event loop via ``call_soon_threadsafe``.
+    """
 
     def __init__(
         self,
@@ -237,24 +264,40 @@ class _PortAudioRxStream:
         sample_rate: int,
         channels: int,
         blocksize: int,
+        frame_ms: int,
     ) -> None:
         self._sd = sd
         self._device_index = device_index
         self._sample_rate = sample_rate
         self._channels = channels
+        # Capture is callback-driven with blocksize=0 (engine-native period),
+        # mirroring a clean sd.rec. blocksize=0 was previously rejected by the
+        # WDM-KS capture face (PortAudioError -9999), but companion device
+        # selection now forces the WASAPI face, on which blocksize=0 opens.
         self._blocksize = blocksize
+        # Fixed delivered-frame size: frame_ms worth of audio frames, each
+        # ``channels`` interleaved s16le samples (2 bytes/sample). The PortAudio
+        # stream stays blocksize=0; only the size handed to ``cb`` is fixed.
+        frame_samples = (sample_rate * frame_ms) // 1000
+        self._frame_bytes = max(1, frame_samples * channels * 2)
         self._stream: Any = None
-        self._task: asyncio.Task[None] | None = None
+        self._running = False
         self._callback: Callable[[bytes], None] | None = None
+        # Sub-frame remainder carried between audio-thread callbacks. The audio
+        # thread is the only writer, so no lock is needed.
+        self._accumulator = bytearray()
 
     @property
     def running(self) -> bool:
-        return self._task is not None and not self._task.done()
+        return self._running
 
     async def start(self, callback: Callable[[bytes], None]) -> None:
         if self.running:
             raise RuntimeError("RX stream already running.")
         self._callback = callback
+        self._accumulator = bytearray()
+        # blocksize=0 (engine-native period) mirrors a clean sd.rec on the
+        # WASAPI face. latency="low" matches the (clean) output stream.
         self._stream = self._sd.InputStream(
             samplerate=self._sample_rate,
             channels=self._channels,
@@ -262,17 +305,19 @@ class _PortAudioRxStream:
             device=self._device_index,
             blocksize=self._blocksize,
             latency="low",
+            callback=self._input_callback,
         )
         self._stream.start()
-        self._task = asyncio.create_task(self._loop(), name="portaudio-rx")
+        self._running = True
 
     async def stop(self) -> None:
         stream = self._stream
-        task = self._task
         self._stream = None
-        self._task = None
+        self._running = False
         self._callback = None
-        # Close stream FIRST — unblocks executor thread stuck in stream.read()
+        # Drop any sub-frame remainder: an incomplete trailing frame cannot
+        # satisfy the fixed-size contract and is discarded at teardown.
+        self._accumulator = bytearray()
         if stream is not None:
             try:
                 stream.stop()
@@ -282,30 +327,44 @@ class _PortAudioRxStream:
                 stream.close()
             except Exception:
                 logger.debug("portaudio-rx: stream close failed", exc_info=True)
-        # Now cancel the task (thread is already unblocked)
-        if task is not None and not task.done():
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
 
-    async def _loop(self) -> None:
-        stream = self._stream
+    def _input_callback(
+        self,
+        indata: Any,
+        _frames: int,
+        _time_info: Any,
+        _status: Any,
+    ) -> None:
+        # Runs on PortAudio's audio thread: keep it non-blocking. Copy the
+        # captured PCM (s16le) out of the (reused, variable-size) input buffer,
+        # append it to the running accumulator, then slice off whole fixed-size
+        # frames and deliver each to the consumer. Re-chunking a continuous
+        # callback stream is lossless (every sample reaches the consumer in
+        # order) and adds no scheduling seam, so it keeps the fixed-frame
+        # contract without re-introducing the comb. The consumer is
+        # contractually cheap/thread-safe.
+        cb = self._callback
+        if cb is None:
+            return
         try:
-            while True:
-                data, _overflowed = await asyncio.to_thread(
-                    stream.read, self._blocksize
-                )
-                cb = self._callback
-                if cb is None:
-                    continue
-                pcm = bytes(data.tobytes()) if hasattr(data, "tobytes") else bytes(data)
-                cb(pcm)
-        except asyncio.CancelledError:
-            pass
+            pcm = (
+                bytes(indata.tobytes()) if hasattr(indata, "tobytes") else bytes(indata)
+            )
+        except Exception:
+            logger.warning("portaudio-rx: capture copy failed", exc_info=True)
+            return
+        if not pcm:
+            return
+        acc = self._accumulator
+        acc.extend(pcm)
+        frame_bytes = self._frame_bytes
+        try:
+            while len(acc) >= frame_bytes:
+                frame = bytes(acc[:frame_bytes])
+                del acc[:frame_bytes]
+                cb(frame)
         except Exception:
-            logger.warning("portaudio-rx: loop failed", exc_info=True)
+            logger.warning("portaudio-rx: consumer callback failed", exc_info=True)
 
 
 class _PortAudioTxStream:
@@ -795,13 +854,19 @@ class PortAudioBackend:
         frame_ms: int = 20,
     ) -> RxStream:
         sd, _ = self._ensure_deps()
-        blocksize = (sample_rate * frame_ms) // 1000
+        # blocksize=0 lets PortAudio use the engine-native period, mirroring a
+        # clean ``sd.rec`` capture. This is safe now that companion device
+        # selection forces the WASAPI host-API face (the WDM-KS face that
+        # rejected blocksize=0 with PortAudioError -9999 is no longer chosen).
+        # The PortAudio capture period stays engine-native; frame_ms only sizes
+        # the fixed frames re-chunked out to the consumer callback.
         return _PortAudioRxStream(
             sd,
             device_index=int(device),
             sample_rate=sample_rate,
             channels=channels,
-            blocksize=blocksize,
+            blocksize=0,
+            frame_ms=frame_ms,
         )
 
     def open_tx(

{rigplane-2.7.2 → rigplane-2.8.0}/src/rigplane/audio/bridge.py

@@ -536,7 +536,7 @@ class AudioBridge:
         self._rx_task = None
 
         if self._subscription is not None:
-            self._subscription.stop()
+            await self._subscription.aclose()
             self._subscription = None
 
         if self._tx_task and not self._tx_task.done():
@@ -737,7 +737,11 @@ class AudioBridge:
         try:
             self._tx_queue.put_nowait(frame)
         except asyncio.QueueFull:
+            # Keep TX latency bounded: preserve live capture by evicting stale
+            # queued audio rather than dropping the newest frame.
+            self._tx_queue.get_nowait()
             self._tx_overruns += 1
+            self._tx_queue.put_nowait(frame)
 
     async def _rx_loop(self) -> None:
         """Read packets from AudioBus subscription, decode, write to device."""

{rigplane-2.7.2 → rigplane-2.8.0}/src/rigplane/audio/bus.py

@@ -47,6 +47,7 @@ logger = logging.getLogger(__name__)
 __all__ = ["AudioBus", "AudioSubscription"]
 
 _DEFAULT_QUEUE_SIZE = 64
+_DEFAULT_CLOSE_TIMEOUT = 2.0
 
 
 class AudioSubscription:
@@ -73,6 +74,7 @@ class AudioSubscription:
             maxsize=queue_size,
         )
         self._active = False
+        self._close_task: asyncio.Task[None] | None = None
         self._dropped = 0
         self._received = 0
 
@@ -94,16 +96,86 @@ class AudioSubscription:
         """Activate this subscription (registers with the bus)."""
         if self._active:
             return
+        if self._close_task is not None and not self._close_task.done():
+            await self._close_task
         self._active = True
         await self._bus._add_subscriber(self)
 
     def stop(self) -> None:
-        """Deactivate this subscription (unregisters from the bus)."""
+        """Deactivate this subscription and schedule bus removal.
+
+        This method is intentionally synchronous for backward compatibility.
+        Prefer :meth:`aclose` in async teardown paths when callers need to know
+        removal has completed.
+        """
         if not self._active:
             return
         self._active = False
-        # Schedule async removal; we can't await in sync context
-        asyncio.create_task(self._bus._remove_subscriber(self))
+        self._schedule_close()
+
+    async def aclose(self, timeout: float | None = _DEFAULT_CLOSE_TIMEOUT) -> None:
+        """Deactivate this subscription and await bus removal.
+
+        Args:
+            timeout: Maximum seconds to wait for teardown. ``None`` disables
+                the timeout for callers that intentionally want unbounded
+                cleanup.
+        """
+        if not self._active and self._close_task is None:
+            return
+        self._active = False
+
+        task = self._close_task
+        if task is None:
+            close_coro = self._bus._remove_subscriber(self)
+            if timeout is None:
+                await close_coro
+            else:
+                try:
+                    await asyncio.wait_for(close_coro, timeout=timeout)
+                except asyncio.TimeoutError:
+                    logger.warning(
+                        "audio-bus: timed out closing subscriber %r",
+                        self.name,
+                    )
+            return
+
+        try:
+            if timeout is None:
+                await task
+            else:
+                await asyncio.wait_for(asyncio.shield(task), timeout=timeout)
+        except asyncio.TimeoutError:
+            logger.warning(
+                "audio-bus: timed out closing subscriber %r",
+                self.name,
+            )
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+    def _schedule_close(self) -> None:
+        """Schedule async bus removal for synchronous ``stop()`` callers."""
+        if self._close_task is not None and not self._close_task.done():
+            return
+        task = asyncio.create_task(self._bus._remove_subscriber(self))
+        self._close_task = task
+        task.add_done_callback(self._on_close_done)
+
+    def _on_close_done(self, task: asyncio.Task[None]) -> None:
+        if self._close_task is task:
+            self._close_task = None
+        try:
+            task.result()
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.debug(
+                "audio-bus: subscriber close task failed",
+                exc_info=True,
+            )
 
     def deliver(self, packet: AudioPacket | None) -> None:
         """Called by the bus to deliver a packet (non-blocking)."""
@@ -155,7 +227,7 @@ class AudioSubscription:
         return self
 
     async def __aexit__(self, *exc: Any) -> None:
-        self.stop()
+        await self.aclose()
 
 
 class AudioBus:
@@ -260,6 +332,6 @@ class AudioBus:
     async def stop(self) -> None:
         """Stop the bus and all subscribers."""
         for sub in list(self._subscribers):
-            sub.stop()
+            await sub.aclose()
         if self._rx_active:
             await self._stop_rx()