[feat](trx-frontend-http): draw APRS symbols from the sprite sheets

Resolve a table/code pair to a sprite cell in aprs-shared, and use it from both the packet lists and the map markers, which had each been printing the raw symbol character in a bordered box. A table identifier of / or \ selects the primary or alternate sheet directly. Anything else is an overlay character, which the APRS spec draws on top of the alternate symbol -- so those stack the overlay sheet over the alternate one rather than picking a sheet. Codes outside 0x21..0x7E have no cell and keep the old character box. The sheet URLs stay in the stylesheet so a min-resolution query can swap in the retina sheets; only the cell offset is computed and set inline. Map markers share the helper through the plugin chunk, so the map stays free of any remote symbol fetch. Verified in a browser against the real stylesheet and sheets: /> is a car, /_ a WX circle, /& an igate diamond, \n a red triangle, and the overlays S> and 7# carry their character on the alternate symbol. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018huL1ELyr86yVqfAabtioA Signed-off-by: Stan Grams <sjg@haxx.space>
[feat](trx-frontend-http): serve the vendored APRS symbol sprites
2026-08-03 19:36:53 +02:00 · 2026-08-03 19:36:36 +02:00
183 changed files with 6720 additions and 29719 deletions
@@ -27,7 +27,7 @@ env:
 jobs:
  lint:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
    container: git.haxx.space/sjg/trx-rs/sdk:latest
    steps:
      - uses: actions/checkout@v4
@@ -40,7 +40,7 @@ jobs:
        run: sccache --show-stats
  test:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
    container: git.haxx.space/sjg/trx-rs/sdk:latest
    steps:
      - uses: actions/checkout@v4
@@ -53,7 +53,7 @@ jobs:
        run: sccache --show-stats
  frontend:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
    container: git.haxx.space/sjg/trx-rs/sdk:latest
    defaults:
      run:
@@ -83,7 +83,7 @@ jobs:
        run: npm run verify-generated
  reuse:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: fsfe/reuse-action@v5
@@ -24,12 +24,6 @@ cargo test -p trx-core
 ./target/release/trx-server --print-config > trx-server.toml
 ./target/release/trx-client --print-config > trx-client.toml
 # Validate a config without starting anything (reports every problem)
 ./target/release/trx-server --check-config --config trx-rs.toml
 # Regenerate trx-rs.toml.example after changing a config struct
 cargo run -p trx-config --example generate_example
 # Run server
 ./target/release/trx-server --config trx-server.toml
 # or via CLI args:
@@ -47,8 +41,7 @@ This is a Cargo workspace. All crates live under `src/`:
 src/
  trx-core/           # Core types, traits, state machine, controller (~3,500 LOC)
  trx-protocol/       # Client↔server protocol DTOs, auth, codec, mapping (~1,100 LOC)
-  trx-app/            # Shared application helpers (logging init, name normalization)
+  trx-app/            # Shared application helpers (config paths, logging init)
  trx-config/         # Client + server config structs, loader, validators (~2,500 LOC)
  trx-reporting/      # PSKReporter UDP uplink + APRS-IS TCP uplink (~1,150 LOC)
  trx-server/         # Server binary: rig_task, audio pipeline, listener (~3,700 LOC)
    trx-backend/      # Backend abstraction trait + factory + dummy
@@ -56,7 +49,6 @@ src/
      trx-backend-ft450d/   # Yaesu FT-450D ASCII CAT
      trx-backend-soapysdr/ # SoapySDR RX with full DSP pipeline (~5,000+ LOC)
  trx-client/         # Client binary: remote connection, frontend spawning (~1,500 LOC)
    trx-logbook/      # Station log: QSO record, ADIF reader/writer, append-only store
    trx-frontend/     # Frontend trait (FrontendSpawner), runtime context
      trx-frontend-http/      # Web UI: REST API, SSE, WebSocket audio, session auth
      trx-frontend-http-json/ # JSON-over-TCP control frontend
@@ -316,18 +316,6 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 [[package]]
 name = "argon2"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072"
 dependencies = [
 "base64ct",
 "blake2",
 "cpufeatures 0.2.17",
 "password-hash",
 ]
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -357,12 +345,6 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 [[package]]
 name = "base64ct"
 version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 [[package]]
 name = "bindgen"
 version = "0.66.1"
@@ -413,24 +395,6 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 [[package]]
 name = "blake2"
 version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
 dependencies = [
 "digest 0.10.7",
 ]
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
 "generic-array",
 ]
 [[package]]
 name = "block-buffer"
 version = "0.12.0"
@@ -561,7 +525,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
 dependencies = [
 "cfg-if",
- "cpufeatures 0.3.0",
+ "cpufeatures",
 "rand_core 0.10.1",
 ]
@@ -757,15 +721,6 @@ dependencies = [
 "windows",
 ]
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "cpufeatures"
 version = "0.3.0"
@@ -784,16 +739,6 @@ dependencies = [
 "cfg-if",
 ]
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
 "generic-array",
 "typenum",
 ]
 [[package]]
 name = "crypto-common"
 version = "0.2.1"
@@ -854,26 +799,15 @@ dependencies = [
 "zeroize",
 ]
 [[package]]
 name = "digest"
 version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
 "block-buffer 0.10.4",
 "crypto-common 0.1.7",
 "subtle",
 ]
 [[package]]
 name = "digest"
 version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4850db49bf08e663084f7fb5c87d202ef91a3907271aff24a94eb97ff039153c"
 dependencies = [
- "block-buffer 0.12.0",
+ "block-buffer",
 "const-oid",
- "crypto-common 0.2.1",
+ "crypto-common",
 ]
 [[package]]
@@ -1085,16 +1019,6 @@ dependencies = [
 "slab",
 ]
 [[package]]
 name = "generic-array"
 version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
 "typenum",
 "version_check",
 ]
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -1966,17 +1890,6 @@ dependencies = [
 "windows-link",
 ]
 [[package]]
 name = "password-hash"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
 dependencies = [
 "base64ct",
 "rand_core 0.6.4",
 "subtle",
 ]
 [[package]]
 name = "peeking_take_while"
 version = "0.1.2"
@@ -2499,16 +2412,6 @@ dependencies = [
 "syn",
 ]
 [[package]]
 name = "serde_ignored"
 version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "115dffd5f3853e06e746965a20dcbae6ee747ae30b543d91b0e089668bb07798"
 dependencies = [
 "serde",
 "serde_core",
 ]
 [[package]]
 name = "serde_json"
 version = "1.0.149"
@@ -2579,8 +2482,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
 dependencies = [
 "cfg-if",
- "cpufeatures 0.3.0",
+ "cpufeatures",
- "digest 0.11.2",
+ "digest",
 ]
 [[package]]
@@ -3128,6 +3031,10 @@ dependencies = [
 name = "trx-app"
 version = "0.1.0"
 dependencies = [
 "dirs",
 "serde",
 "thiserror 2.0.18",
 "toml",
 "tracing",
 "tracing-subscriber",
 ]
@@ -3208,7 +3115,6 @@ dependencies = [
 "toml",
 "tracing",
 "trx-app",
 "trx-config",
 "trx-core",
 "trx-frontend",
 "trx-frontend-http",
@@ -3218,23 +3124,6 @@ dependencies = [
 "uuid",
 ]
 [[package]]
 name = "trx-config"
 version = "0.1.0"
 dependencies = [
 "dirs",
 "serde",
 "serde_ignored",
 "tempfile",
 "thiserror 2.0.18",
 "toml",
 "toml_edit 0.22.27",
 "tracing",
 "trx-core",
 "trx-decode-log",
 "trx-reporting",
 ]
 [[package]]
 name = "trx-configurator"
 version = "0.1.0"
@@ -3243,16 +3132,13 @@ dependencies = [
 "dialoguer",
 "tempfile",
 "tokio-serial",
 "toml",
 "toml_edit 0.22.27",
 "trx-config",
 ]
 [[package]]
 name = "trx-core"
 version = "0.1.0"
 dependencies = [
 "base64",
 "flate2",
 "reqwest",
 "serde",
@@ -3302,11 +3188,9 @@ version = "0.1.0"
 dependencies = [
 "actix-web",
 "actix-ws",
 "argon2",
 "base64",
 "brotli 7.0.0",
 "bytes",
 "chrono",
 "dirs",
 "flate2",
 "futures-util",
@@ -3315,13 +3199,11 @@ dependencies = [
 "rand 0.8.6",
 "serde",
 "serde_json",
 "tempfile",
 "tokio",
 "tokio-stream",
 "tracing",
 "trx-core",
 "trx-frontend",
 "trx-logbook",
 "trx-protocol",
 "ts-rs",
 "uuid",
@@ -3360,19 +3242,6 @@ dependencies = [
 "rustfft",
 ]
 [[package]]
 name = "trx-logbook"
 version = "0.1.0"
 dependencies = [
 "chrono",
 "dirs",
 "serde",
 "serde_json",
 "tempfile",
 "tracing",
 "uuid",
 ]
 [[package]]
 name = "trx-protocol"
 version = "0.1.0"
@@ -3425,14 +3294,12 @@ dependencies = [
 "trx-app",
 "trx-aprs",
 "trx-backend",
 "trx-config",
 "trx-core",
 "trx-cw",
 "trx-decode-log",
 "trx-ftx",
 "trx-protocol",
 "trx-reporting",
 "trx-sstv",
 "trx-vdes",
 "trx-wefax",
 "trx-wspr",
@@ -3440,16 +3307,6 @@ dependencies = [
 "uuid",
 ]
 [[package]]
 name = "trx-sstv"
 version = "0.1.0"
 dependencies = [
 "base64",
 "png",
 "tracing",
 "trx-core",
 ]
 [[package]]
 name = "trx-vdes"
 version = "0.1.0"
@@ -12,13 +12,11 @@ members = [
    "src/decoders/trx-ftx",
    "src/decoders/trx-rds",
    "src/decoders/trx-vdes",
    "src/decoders/trx-sstv",
    "src/decoders/trx-wefax",
    "src/decoders/trx-wspr",
    "src/trx-core",
    "src/trx-protocol",
    "src/trx-app",
    "src/trx-config",
    "src/trx-reporting",
    "src/trx-server",
    "src/trx-server/trx-backend",
@@ -26,7 +24,6 @@ members = [
    "src/trx-server/trx-backend/trx-backend-ft450d",
    "src/trx-server/trx-backend/trx-backend-soapysdr",
    "src/trx-client",
    "src/trx-client/trx-logbook",
    "src/trx-client/trx-frontend",
    "src/trx-client/trx-frontend/trx-frontend-http",
    "src/trx-client/trx-frontend/trx-frontend-http-json",
@@ -93,17 +93,13 @@ The wizard walks you through rig selection, serial port detection, audio
 settings, and frontend options, then writes `trx-server.toml` and
 `trx-client.toml`.
-Alternatively, copy `trx-rs.toml.example` — a commented example covering every
+Alternatively, generate example configs and edit them by hand:
 setting — and edit it by hand:
 ```bash
-cp trx-rs.toml.example trx-rs.toml
+./target/release/trx-server --print-config > trx-server.toml
-./target/release/trx-server --check-config --config trx-rs.toml
+./target/release/trx-client --print-config > trx-client.toml
 ```
 `--check-config` reports everything wrong with a config without starting
 anything. `--print-config` prints the same settings without comments.
 ### 4. Run
 ```bash
@@ -111,49 +107,8 @@ anything. `--print-config` prints the same settings without comments.
 ./target/release/trx-client --config trx-client.toml
 ```
 A single `trx-rs.toml` can configure both: the server reads its `[trx-server]`
 section and the client reads `[trx-client]`.
 Open the configured HTTP frontend address in a browser (default `http://localhost:8080`).
 ### 5. Install (optional, Linux + systemd)
 To build, install the binaries system-wide, and set up systemd **user** services
 that run the server and client in the background:
 ```bash
 script/install.sh
 ```
 This builds in release mode, installs `trx-server`, `trx-client`, and
 `trx-configurator` to `~/.local/bin`, seeds
 `~/.config/trx-rs/trx-rs.toml` from the example (existing config is never
 overwritten), and installs `~/.config/systemd/user/{trx-server,trx-client}.service`.
 ```bash
 script/install.sh --prefix /opt/trx-rs # choose another installation prefix
 script/install.sh --no-sdr            # build without SoapySDR support
 script/install.sh --enable-now        # also enable + start the services now
 script/install.sh --help              # all options
 ```
 After editing your config, manage the services with:
 ```bash
 systemctl --user enable --now trx-server trx-client   # start now + on login
 journalctl --user -u trx-server -u trx-client -f      # follow logs
 loginctl enable-linger "$USER"                        # keep running after logout
 ```
 Serial (`/dev/ttyUSB*`) and audio access require your user to be in the
 `dialout` and `audio` groups. Remove everything with `script/uninstall.sh`
 (add `--purge` to also delete the config).
 For an unattended or remotely accessible installation, follow the
 [safe deployment guide](docs/Deployment.md). It covers a dedicated service
 account, device permissions, authentication, firewall and reverse-proxy
 boundaries, verification, upgrades, and rollback.
 ## How It Works
 ```mermaid
@@ -925,14 +925,9 @@ main
 ### HTTP Frontend Auth
- Optional Argon2id-backed managed accounts with HttpOnly session cookies
+- Optional token or HTTP Basic Auth middleware
- An exclusive Guest role plus composable Read, Control, Transmit, Write, and Administrator roles, with policy shared by middleware and handlers
+- Configured in `[frontends.http.auth]`
- Guest sessions receive read-only station access but no account-control endpoints or panels
+- Rate limiting supported
 - Transmit separately gates PTT, TX audio frames, and TX power-limit changes
 - Atomic JSON persistence with migration from the legacy single-role schema
 - Account enable/disable, administrator CRUD, self-service password changes, and session revocation on security changes
 - A database invariant always preserves at least one enabled administrator
 - Per-IP login rate limiting; configured in `[frontends.http.auth]`
 ### Transport Security
@@ -1048,7 +1043,7 @@ The `FrontendRuntimeContext` struct in `trx-frontend/src/lib.rs` is decomposed i
 |-----------|---------|------------|
 | `AudioContext` | Audio streaming channels | `rx`, `tx`, `info`, `decode_rx`, `clients` |
 | `DecodeHistoryContext` | Decode history for all types | `ais`, `vdes`, `aprs`, `hf_aprs`, `cw`, `ft8`, `ft4`, `ft2`, `wspr` |
-| `HttpAuthConfig` | HTTP auth settings | `enabled`, `users_file`, bootstrap admin/read accounts, `session_ttl_secs`, `tokens` |
+| `HttpAuthConfig` | HTTP auth settings | `enabled`, `rx_passphrase`, `session_ttl_secs`, `tokens` |
 | `HttpUiConfig` | HTTP UI display config | `show_sdr_gain_control`, `initial_map_zoom`, `spectrum_*` |
 | `RigRoutingContext` | Remote rig state & routing | `active_rig_id`, `remote_rigs`, `rig_states`, `server_connected` |
 | `OwnerInfo` | Station metadata | `callsign`, `website_url`, `ais_vessel_url_base` |
@@ -1,287 +0,0 @@
 # Safe deployment
 This guide deploys trx-rs on Linux as a dedicated, unprivileged user with
 systemd user services. It keeps radio-device access, configuration, and runtime
 data separate from an administrator's account.
 The examples use `trx-rs` as the account name and `/opt/trx-rs/bin` for
 root-owned executables. Adapt group names and firewall commands to your Linux
 distribution.
 ## 1. Decide what must be reachable
 Only expose listeners that another machine actually needs:
 | Listener | Typical port | Recommended exposure |
 | --- | ---: | --- |
 | Server control | TCP 4530 | Loopback or trusted radio LAN only |
 | Server audio | TCP 4531 and per-rig ports | Trusted radio LAN only |
 | Client web UI | TCP 8080 or a chosen port | Loopback behind HTTPS proxy |
 | Client rigctl | Per-rig TCP ports | Loopback or trusted LAN only |
 | Client JSON | Configured TCP port | Loopback or trusted LAN only |
 `127.0.0.1` accepts connections only from the same host. Use a specific LAN
 address when possible, or `0.0.0.0` when the listener must accept connections
 on every IPv4 interface. Binding a socket does not configure the host firewall.
 Do not expose unauthenticated control, audio, rigctl, or JSON listeners to the
 public Internet. Prefer a VPN for links between radio sites. Put the web UI
 behind an HTTPS reverse proxy when it is remotely accessible.
 ## 2. Create the service account
 Create a non-login service account with a home directory:
 ```bash
 sudo useradd --create-home --shell /usr/sbin/nologin trx-rs
 sudo chmod 0750 /home/trx-rs
 ```
 Add only the hardware groups required on this host. Common group names are
 `dialout` for serial devices and `audio` for sound devices:
 ```bash
 sudo usermod -aG dialout,audio trx-rs
 ```
 SDR USB access is distribution- and device-specific. Install the vendor's udev
 rules or add a narrowly scoped rule for the device's USB vendor/product IDs.
 Avoid making all USB devices world-writable. After reconnecting the device,
 verify access as the service account:
 ```bash
 sudo -u trx-rs test -r /dev/ttyUSB0
 sudo -u trx-rs test -w /dev/ttyUSB0
 sudo -u trx-rs SoapySDRUtil --find
 ```
 Run only the checks relevant to the configured hardware. Group membership and
 udev-rule changes normally require reconnecting the device or restarting the
 service.
 ## 3. Build and install immutable binaries
 Build from a reviewed revision as a normal development user, not as root:
 ```bash
 git clone https://github.com/stanislawgrams/trx-rs.git
 cd trx-rs
 git switch --detach <reviewed-tag-or-commit>
 cargo build --release -p trx-server -p trx-client -p trx-configurator
 ```
 Install root-owned binaries into a directory the service user cannot modify:
 ```bash
 sudo install -d -o root -g root -m 0755 /opt/trx-rs/bin
 sudo install -o root -g root -m 0755 \
  target/release/trx-server \
  target/release/trx-client \
  target/release/trx-configurator \
  /opt/trx-rs/bin/
 ```
 If SDR support is not needed, build `trx-server` with
 `--no-default-features`. Keep the source revision and Rust toolchain used for
 the build in deployment records.
 ## 4. Install and validate configuration
 Create private configuration and state directories, then seed the example:
 ```bash
 sudo install -d -o trx-rs -g trx-rs -m 0700 \
  /home/trx-rs/.config/trx-rs \
  /home/trx-rs/.config/systemd/user
 sudo install -o trx-rs -g trx-rs -m 0600 \
  trx-rs.toml.example /home/trx-rs/.config/trx-rs/trx-rs.toml
 sudoedit /home/trx-rs/.config/trx-rs/trx-rs.toml
 ```
 At minimum:
 - remove unused example rigs and remotes;
 - select the correct serial, TCP, or SDR device;
 - give every enabled rig a unique ID and audio port;
 - use `127.0.0.1` for same-host connections;
 - use a LAN address or `0.0.0.0` only for deliberately remote listeners;
 - enable authentication before exposing server control or the web UI;
 - replace every example password and token;
 - keep credential files mode `0600` and owned by `trx-rs`;
 - set `cookie_secure = true` when the web UI is served through HTTPS.
 For a remote server, control and each per-rig audio listener need an explicit
 non-loopback address:
 ```toml
 [trx-server.listen]
 enabled = true
 listen = "0.0.0.0"
 port = 4530
 [trx-server.listen.auth]
 tokens_file = "/home/trx-rs/.config/trx-rs/server-tokens"
 [[trx-server.rigs]]
 id = "station-hf"
 [trx-server.rigs.audio]
 enabled = true
 listen = "0.0.0.0"
 port = 4531
 ```
 When using several `[[trx-server.rigs]]` entries, configure audio under each
 `[trx-server.rigs.audio]` section. Do not rely on the legacy flat
 `[trx-server.audio]` section.
 For a web UI behind a reverse proxy, keep the backend on loopback and choose an
 unused port. The proxy upstream must use the same address and port:
 ```toml
 [trx-client.frontends.http]
 enabled = true
 listen = "127.0.0.1"
 port = 7345
 [trx-client.frontends.http.auth]
 enabled = true
 users_file = "/home/trx-rs/.config/trx-rs/http-users.json"
 cookie_secure = true
 ```
 Validate the configuration before starting either daemon:
 ```bash
 sudo -u trx-rs /opt/trx-rs/bin/trx-server \
  --check-config --config /home/trx-rs/.config/trx-rs/trx-rs.toml
 sudo -u trx-rs /opt/trx-rs/bin/trx-client \
  --check-config --config /home/trx-rs/.config/trx-rs/trx-rs.toml
 ```
 Treat unknown-key and deprecated-section warnings as deployment errors. They
 often mean a setting is not applied where expected.
 ## 5. Install the systemd user services
 Render the packaged units with the immutable binary directory:
 ```bash
 sed 's|@BINDIR@|/opt/trx-rs/bin|g' packaging/systemd/trx-server.service \
  | sudo tee /home/trx-rs/.config/systemd/user/trx-server.service >/dev/null
 sed 's|@BINDIR@|/opt/trx-rs/bin|g' packaging/systemd/trx-client.service \
  | sudo tee /home/trx-rs/.config/systemd/user/trx-client.service >/dev/null
 sudo chown trx-rs:trx-rs \
  /home/trx-rs/.config/systemd/user/trx-server.service \
  /home/trx-rs/.config/systemd/user/trx-client.service
 sudo chmod 0644 \
  /home/trx-rs/.config/systemd/user/trx-server.service \
  /home/trx-rs/.config/systemd/user/trx-client.service
 ```
 Enable lingering so the user manager runs without an interactive login, then
 start it:
 ```bash
 sudo loginctl enable-linger trx-rs
 trx_uid=$(id -u trx-rs)
 sudo systemctl start "user@${trx_uid}.service"
 ```
 Manage the user services through that user's runtime directory:
 ```bash
 trx_uid=$(id -u trx-rs)
 sudo -u trx-rs XDG_RUNTIME_DIR="/run/user/${trx_uid}" \
  systemctl --user daemon-reload
 sudo -u trx-rs XDG_RUNTIME_DIR="/run/user/${trx_uid}" \
  systemctl --user enable --now trx-server.service trx-client.service
 ```
 The client unit has ordering, but not activation, on `trx-server.service`. If
 both are enabled locally, the client starts after the server process is
 started. If the local server is disabled because all remotes are external, the
 client does not start it. The client retries remote connections; systemd cannot
 order startup against a service on another host.
 ## 6. Firewall and reverse proxy
 Allow only required ports and sources. For example, permit server control and
 audio only from the trusted radio subnet, not from every interface. Exact
 commands differ between nftables, firewalld, and ufw.
 For the web UI, terminate TLS in a maintained reverse proxy and send traffic to
 the loopback backend. Preserve WebSocket upgrade headers if the proxy requires
 them. Example nginx location:
 ```nginx
 location / {
    proxy_pass http://127.0.0.1:7345;
    proxy_http_version 1.1;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
 }
 ```
 Test the backend directly before debugging a `502 Bad Gateway` response:
 ```bash
 curl --fail --show-error http://127.0.0.1:7345/
 ```
 A refused connection means nothing is listening at the proxy's configured
 address and port. Check for port conflicts with `ss -ltnp` and confirm the
 application log reports the same bind address as the proxy upstream.
 ## 7. Verify the deployment
 ```bash
 trx_uid=$(id -u trx-rs)
 sudo -u trx-rs XDG_RUNTIME_DIR="/run/user/${trx_uid}" \
  systemctl --user status trx-server.service trx-client.service
 sudo journalctl _UID="${trx_uid}" \
  -u trx-server.service -u trx-client.service --since today
 sudo ss -ltnp
 ```
 Verify all of the following:
 - both required services remain active without a restart loop;
 - radio hardware opens successfully;
 - logs show the intended control, audio, and frontend bind addresses;
 - the client connects to every configured control and audio endpoint;
 - only intended interfaces expose listeners;
 - authentication works and anonymous access is rejected where configured;
 - the HTTPS proxy returns the UI and supports live updates;
 - the service account cannot write `/opt/trx-rs/bin`.
 Do not rely only on `systemctl` reporting `active`: individual frontend tasks
 can fail after the main client process starts. Always inspect startup logs and
 probe each required endpoint.
 ## 8. Upgrade and roll back
 Build and validate a new revision before replacing the installed executables.
 Back up configuration and state first. Stop the services, install all binaries
 from the same build, and restart:
 ```bash
 trx_uid=$(id -u trx-rs)
 sudo -u trx-rs XDG_RUNTIME_DIR="/run/user/${trx_uid}" \
  systemctl --user stop trx-client.service trx-server.service
 sudo install -o root -g root -m 0755 \
  target/release/trx-server \
  target/release/trx-client \
  target/release/trx-configurator \
  /opt/trx-rs/bin/
 sudo -u trx-rs XDG_RUNTIME_DIR="/run/user/${trx_uid}" \
  systemctl --user start trx-server.service trx-client.service
 ```
 Keep the previous binaries or package revision available for rollback. If the
 new version fails, stop both services, restore the complete previous binary
 set, restore configuration only if its format changed, and start the services
 again.
@@ -322,269 +322,3 @@ trx-configurator
 | `trx-app` | Config types and validation | Yes |
 | `serialport` | Serial port enumeration | Yes (transitive) |
 | `soapysdr` | SDR device enumeration (optional) | Yes (feature-gated) |
 ---
 ## Logbook and Ham Radio Layout
 Two halves of one feature ([#54](https://git.haxx.space/sjg/trx-rs/issues/54)): a station
 logbook in a panel of its own, and an operator layout that puts a transceiver's controls
 around it.
 Nothing in the application records a QSO today. The map's "QSO summary" cards describe
 contacts *between other stations*, reconstructed from decoded traffic; bookmarks are
 frequencies, not contacts. Neither is the operator's own log.
 ### Requirements
 | ID | Description |
 |----|-------------|
 | REQ-LOG-001 | The system shall record QSOs the operator makes, each holding at minimum callsign, date, time, band, frequency, mode and both signal reports. |
 | REQ-LOG-002 | When starting a log entry, the system shall pre-fill exactly six fields: frequency, mode, rig name, time, callsign and locator. |
 | REQ-LOG-003 | The system shall leave every other field of a log entry empty for the operator to fill. |
 | REQ-LOG-004 | The system shall allow a logged QSO to be edited and deleted. |
 | REQ-LOG-005 | The system shall survive a crash without losing a QSO that was recorded before it. |
 | REQ-LOG-006 | The system shall list, search and filter the log by callsign, band, mode and date range. |
 | REQ-LOG-007 | Where a decoded station is on screen, the system shall offer to start a log entry from it, pre-filled, without logging it unattended. |
 | REQ-LOG-008 | The system shall show whether a callsign has been worked before, and on which bands. |
 | REQ-FMT-001 | The system shall export the log as an ADIF 3.1.x `.adi` file. |
 | REQ-FMT-002 | The system shall import ADIF `.adi` files produced by other logging software, preserving fields it does not itself use. |
 | REQ-FMT-003 | When importing, the system shall identify QSOs already held and shall not duplicate them. |
 | REQ-FMT-004 | The system shall export a filtered selection of the log as a Cabrillo 3.0 file for contest submission. |
 | REQ-LOG-009 | The system shall stamp QSO times from the server's clock in UTC, and shall tell the operator when the browser's clock disagrees with it by more than one second. |
 | REQ-LAY-001 | The system shall present the logbook in a panel of its own, reachable whatever layout is selected. |
 | REQ-LAY-002 | The system shall offer a "Ham radio" operator layout presenting the transceiver controls and that panel together. |
 | REQ-LAY-003 | Where the selected rig cannot transmit, the system shall not offer the ham layout. |
 ### A decode is not a QSO
 The decoders are receive-only: FT8, CW, APRS and the rest report what was *heard*. A heard
 callsign is the beginning of a log entry, not a contact, and the logbook must never write one
 by itself — REQ-LOG-007 says offer and pre-fill, never auto-log. Digital QSOs made in
 WSJT-X or similar arrive the way every other logger takes them: through ADIF import.
 ### What is pre-filled, and what is not
 Six fields, and no more (REQ-LOG-002, REQ-LOG-003):
 | Field | From | ADIF |
 |-------|------|------|
 | Frequency | the selected rig's dial | `FREQ`, with `BAND` derived from it |
 | Mode | the selected rig | `MODE`, and `SUBMODE` where the mode implies one |
 | Rig name | the rig's display name | `MY_RIG` |
 | Time | the server's clock, UTC, when the entry opens | `QSO_DATE`, `TIME_ON` |
 | Callsign | the decode row or map station the entry was started from, else empty | `CALL` |
 | Locator | that station's grid, where the decode carried one, else empty | `GRIDSQUARE` |
 Signal reports, power, name, QTH and the rest stay empty. A report in particular is the
 operator's to give: an FT8 SNR is not what was sent, and pre-filling one would put a number in
 the log that nobody exchanged.
 The station's own callsign and locator are not pre-filled per entry either — they are station
 identity, taken from configuration when the QSO is written (`STATION_CALLSIGN`, `OPERATOR`,
 `MY_GRIDSQUARE`), and shown once at the top of the panel rather than typed into every row.
 ### Architecture
 #### New crate: `trx-logbook`
 ```
 src/trx-client/
  trx-logbook/
    src/
      lib.rs        # LogbookHandle: open, add, edit, delete, query, import, export
      qso.rs        # Qso: the record, its ADIF field mapping, band/mode helpers
      adif.rs       # ADI reader and writer (pure Rust, no new dependencies)
      store.rs      # Append-only JSON Lines file, in-memory index, compaction
      dedupe.rs     # Worked-before and import-collision rules
 ```
 A library crate under `src/trx-client/`, beside `trx-frontend`, consumed by
 `trx-frontend-http`. The log belongs to the station rather than to a rig or a frontend, so it
 sits where any frontend can reach it.
 #### Storage: append-only, not a rewritten blob
 Bookmarks use `PickleDb` with `AutoDump`, which rewrites the whole file on every write. That
 is right for a few dozen bookmarks and wrong for a log: a station with 40 000 QSOs would
 rewrite several megabytes to log one contact, and lose the lot if the power went during the
 dump.
 The log is instead a JSON Lines file — the shape `trx-decode-log` already uses — appended one
 record per write and read into an in-memory index at startup. An edit or a delete appends a new revision of that record's id; the load
 keeps the last one, and a compaction pass rewrites the file when superseded records exceed a
 threshold. Appending is O(1) and atomic per line, so a crash costs at most the line being
 written.
 #### Two formats, for the two things a log is asked for
 The file formats were left open ("pick a well-known ham format"), so: **ADIF for interchange,
 Cabrillo for contest submission.** Both are implemented in-repo, in the way this project
 already implements its decoders, and neither adds a dependency.
 **ADIF has to stay.** It is not one option among several — it is the only thing the ecosystem
 reads. LoTW, eQSL, Club Log, QRZ.com and every other logger take ADIF and nothing else, so a
 log that cannot write `.adi` cannot be uploaded, confirmed, or moved to another program. That
 is a one-way door, and the interoperability is most of the point of keeping a log at all.
 Nothing on disk is ADI regardless: the store is JSON Lines, and ADIF is what comes out of an
 export.
 ADI is a tagged text format — `<FIELD:length>value`, records ended by `<EOR>`, a header ended
 by `<EOH>`, everything outside a tag ignored — small enough to implement exactly. The reader
 must be lenient in the ways real files are irregular (lowercase tags, CRLF, missing header,
 unknown fields, type indicators) and the writer strict. Unknown fields are carried through
 import to export unchanged, so a round trip through trx-rs does not quietly strip what another
 logger wrote. ADX, the XML serialisation of the same data model, is out of scope: it is part
 of the standard but almost nothing reads it.
 **Cabrillo is the second format, because ADIF cannot do its job.** Contest logs are submitted
 to sponsors in Cabrillo 3.0 and are rejected in anything else — a header of `CALLSIGN:`,
 `CONTEST:`, `CATEGORY-*` and `CLAIMED-SCORE:` lines, then one fixed-column `QSO:` line per
 contact carrying frequency in kHz, a mode code (`CW`, `PH`, `FM`, `RY`, `DG`), the UTC date and
 time, and both stations' calls, reports and exchanges. It is export-only and drops everything
 outside the contest's exchange, which is why it complements ADIF rather than replacing it.
 It arrives with the contest exchange fields in phase 5, since without a serial or a zone to
 put in the exchange there is nothing for it to write.
 #### Integration points
 | Source | What it gives the log | How |
 |--------|----------------------|-----|
 | `RigState` | `FREQ`, `BAND`, `MODE`/`SUBMODE`, and the rig id a QSO was made on | watch channel already in the frontend context |
 | Client config `general.callsign` | `STATION_CALLSIGN`, and the default `OPERATOR` | already surfaced as `owner_callsign` in frontend meta |
 | The QSO's own rig, and its position | `MY_GRIDSQUARE` | per-rig latitude and longitude already carried in the rig list |
 | Server clock | `QSO_DATE`, `TIME_ON` in UTC | new `GET /api/logbook/now`, which also feeds the browser-clock check |
 | Decoder panels and map | a pre-filled entry: callsign, grid, and the report to offer | existing decode history; no new plumbing |
 | `bandForHz` | `BAND` from a frequency | exists in `map-core.ts`; move to a shared module |
 #### HTTP API
 Under `/api/logbook`, as the recorder's endpoints are, because `/logbook` itself is the page:
 the `/bookmarks` API and the bookmarks page already share a path, and whichever is registered
 first wins.
 | Method | Path | Purpose |
 |--------|------|---------|
 | `GET` | `/api/logbook` | Query: filters, paging |
 | `POST` | `/api/logbook` | Add a QSO |
 | `PUT` | `/api/logbook/{id}` | Edit |
 | `DELETE` | `/api/logbook/{id}` | Delete |
 | `GET` | `/api/logbook/export.adi` | ADIF export, honouring the current filter |
 | `GET` | `/api/logbook/export.cbr` | Cabrillo export of a contest selection |
 | `POST` | `/api/logbook/import` | Import, answering with counts: added, duplicate, rejected |
 | `GET` | `/api/logbook/worked/{call}` | Worked-before: bands and modes |
 | `GET` | `/api/logbook/statistics` | Contacts, stations and confirmations, per band |
 | `GET` | `/api/logbook/now` | The server's UTC clock, for checking the browser's |
 | `GET` | `/api/logbook/prefill` | The six fields an entry opens with |
 Writes require the admin role, as the rig endpoints do.
 ### Frontend
 The logbook is **its own panel**, not a strip bolted to the radio page: a `logbook` entry in
 the tab order beside Bookmarks, holding the entry form, the table with the filters of
 REQ-LOG-006, and import and export. It stands on its own in every layout, so a log can be kept
 without adopting the ham layout, and read while another layout is selected (REQ-LAY-001).
 The panel is three parts: the station line at the top (own callsign, locator, the rig a QSO
 would be logged against), the entry form beneath it opening with the six pre-filled fields,
 and the log itself under that, filtered as REQ-LOG-006 asks. Worked-before shows against
 the callsign as it is typed.
 The **ham layout** is a fifth entry in the operator layouts (`compact`, `broadcast`, `digital`,
 `full`), which already gate on capability, seed the disclosure sections and persist per rig:
 ```ts
 ham: {
  label: "Ham radio",
  unavailable: "Ham radio needs a rig that can transmit",
  advanced: true, audio: true, scheduler: false,
  preferredTab: "logbook", capability: "ham",
 }
 ```
 with the `ham` capability set from `RigCapabilities.tx`. It keeps frequency, VFO, mode, filter,
 PTT, power and the meters, and hides the broadcast furniture. What it adds over `full` is where
 it starts: the logbook panel, with the radio controls a keystroke away rather than the other
 way round — the layout an operator working the bands wants, where logging the contact is the
 task and the rig is the instrument.
 ### Phases
 All five are implemented.
 | Phase | Lands |
 |-------|-------|
 | 1 | `trx-logbook`: `Qso`, the ADI reader and writer, round-trip tests against files from other loggers |
 | 2 | Store, dedupe, and the HTTP API behind the admin role |
 | 3 | Logbook tab: entry, table, filters, import, export |
 | 4 | Ham layout, pre-filled entry from a decode row or the map, worked-before |
 | 5 | Contest exchange fields and Cabrillo export; QSL and LoTW/eQSL fields; per-band worked/confirmed statistics |
 Two decisions phase 5 settled. The Cabrillo header cannot be derived from a log — how many
 operators, how much power, what the score is claimed to be — so it comes from the operator,
 with `SINGLE-OP`, `LOW`, `ALL` and `MIXED` behind it. And a confirmation counts from whichever
 bureau answered: an award wants one card or one electronic match, not one of each, so a log
 that counted them separately would tell the operator they were short of what they have.
 ### Decisions
 **One station log, not one per rig.** Awards and uploads are per station callsign — DXCC, WAS
 and LoTW all count the callsign, not the radio — and a station worked on the second rig is
 still worked. The rig is recorded on the QSO (`MY_RIG`) rather than dividing the log by it.
 The station *location* fields do follow the rig, though: trx-rs rigs can be in different
 places, so `MY_GRIDSQUARE` is taken from the rig that made the QSO rather than from one global
 setting, which is also what LoTW's station locations expect.
 **The operator is a per-QSO field, set once per session.** ADIF separates `STATION_CALLSIGN`
 (the call used on the air) from `OPERATOR` (the person at the key); multi-operator stations
 rotate operators through one station callsign, which is why contest loggers record it per QSO.
 It is stored per QSO, defaulted from the configured callsign so a single operator never touches
 it, and changed on the station line at the top of the panel where it sticks for the session.
 It cannot be inferred from the session's identity: an account username need not be an operator
 callsign, and operational accounts may be shared.
 **Server clock, and the log says so.** The server is the machine at the radio; the browser may
 be on a phone in another timezone with a clock nobody has checked. QSO times are UTC from the
 server, and when a browser's clock disagrees by more than a second the panel says so rather
 than silently logging a time the operator did not expect.
 **The log file is configurable, and defaults to the user's data directory.** Bookmarks live in
 the config directory because they are settings; decode logs live in the cache directory because
 they are disposable. A QSO log is neither — it is irreplaceable, and cache directories are
 swept by cleaners. `[logbook].path` in the client config, defaulting to
 `dirs::data_dir()/trx-rs/logbook.jsonl`, so a station that keeps its log on a synced or
 backed-up volume can say so.
 **Import collisions: callsign, band, mode and a two-minute window.** Two loggers rarely agree
 to the second on the same QSO — one records the time the contact started, another the time it
 was entered — so an exact-minute key duplicates half of what it is asked to merge. Two minutes
 absorbs that. It does not swallow legitimate re-works: contest rules forbid a second contact
 with the same station on the same band and mode, so a repeat inside two minutes is the same
 QSO. Times are compared as instants rather than date and time strings, so a QSO either side of
 midnight matches. Modes are normalised before comparison, or a log that stored `SSB` would fail
 to match ours that stored `USB`.
 ### Rig modes to ADIF modes
 The rig reports what it is demodulating; ADIF wants what the contact was made on, which is not
 always the same word:
 | Rig mode | ADIF `MODE` | ADIF `SUBMODE` |
 |----------|-------------|----------------|
 | `USB`, `LSB` | `SSB` | `USB` / `LSB` |
 | `CW`, `CWR` | `CW` | — |
 | `AM`, `SAM` | `AM` | — |
 | `FM`, `WFM` | `FM` | — |
 | `PKT` | `PKT` | — |
 | `DIG` | decided by the decoder in use, not by the rig | |
 | `AIS`, `VDES` | none — not amateur modes, and these rigs do not log | |
 | `Other(..)` | passed through when it names an ADIF mode, else left for the operator | |
 `DIG` is the one that cannot come from the rig: a rig in `DIG` is in FT8, FT4 or something else
 depending on which decoder is running, and an entry started from an FT8 row logs `FT8` rather
 than the rig's word for it. WSPR never opens an entry at all — it is a beacon mode, and hearing
 a beacon is not a contact.
 The table is data in `qso.rs`, checked against the ADIF enumeration when it is written, with
 anything unrecognised left to the operator rather than guessed into the log.
@@ -1,116 +0,0 @@
 # Spectrum Controls — Visual Rework
 The strip between the spectrum and the radio controls (`#spectrum-controls`)
 holds eight controls in two groups. This proposes how it should *look*.
 Every control stays, in its current order, with its current name and its
 current behaviour. Nothing here changes what a button does, what commits when,
 or what is stored. It is a styling and layout change.
 *Status: implemented. Kept as the record of what was changed and why.*
 ---
 ## What it looks like now
 ```
 Bandwidth [ 12 ] kHz  [Set] [Auto BW] [Sweet-spot]            Peak Hold [2 s] Floor [-115] dB Range [90] dB [Auto] Contrast [——●——] 1.0
 ```
 Four problems, all of them visual:
 **1. Four different control heights on one line.** The bare number inputs, the
 buttons, the `select` and the range slider are each sized by their own rule, so
 nothing shares a baseline and the row reads as a pile rather than a strip.
 **2. Units are loose text.** `kHz`, `dB`, `dB` and the contrast value `1.0` are
 text nodes sitting outside the control they belong to, separated from it by a
 gap the same size as the gap between unrelated controls. The eye has to work
 out which number owns which unit.
 **3. A quarter of the strip is a hole.** `justify-content: space-between` puts
 about 250 px of nothing in the middle at 1600 px, and the two groups read as
 two unrelated things because the only thing between them is emptiness.
 **4. The groups stagger between 1100 and 1400 px.** The bandwidth group wraps
 to two lines while the level group stays on one, so the level group floats at a
 height of its own, aligned with neither line of the group beside it. This is
 the worst of it, and it happens at a common window width.
 Two smaller things: 24 px controls are below any touch-target guideline, and
 the contrast readout has no fixed width, so the row twitches as the value
 changes between `1.0` and `0.9`.
 ## Proposed
 **One control height, units inside their field, and a rule where the clusters
 meet.**
 - **A field is one box.** Label, value and unit share a single bordered box —
  `Bandwidth │ 12.0 │ kHz` — so a number and its unit can never be read apart.
  Fields, buttons, the peak-hold select and the contrast slider are all 1.7 rem
  tall, on 44 px targets under a coarse pointer.
 - **A rule, not a hole.** The two clusters are separated by a thin vertical
  rule with normal spacing either side. The slack goes to a flexible spacer, so
  the strip is left-aligned rather than pushed apart.
 - **A cluster never splits.** Each cluster is `nowrap`; the container wraps. If
  a cluster does not fit on the line it drops whole to the next one,
  left-aligned with the one above. No staggering, at any width.
 - **Rules fall away at line starts.** A cluster that begins a line has no rule
  hanging off its left edge.
 - **The contrast readout gets a fixed, tabular slot**, so the row is still.
 Below the existing mobile breakpoint the strip already stacks; the same field
 component applies there, which is most of what makes it look deliberate.
 ## What this does not change
 `Set` stays. `Auto BW` and `Auto` keep their names, even though they mean
 different things — that is a naming question, not a styling one. Sweet-spot
 stays where it is and keeps its behaviour. Nothing gains or loses persistence.
 Nothing moves into a popover, and no control is hidden behind a click.
 Those are all worth arguing about separately; a note of them is at the end of
 this file so the arguments are not lost.
 ## Implementation
 One pass, no behaviour touched:
 1. `.spectrum-field` and `.spectrum-btn` in `style.css`, replacing the six
   per-id rules (`#spectrum-bw-input`, `#spectrum-floor-input`,
   `#spectrum-range-input`, `#spectrum-bw-label`, `#spectrum-floor-label`,
   `#spectrum-range-label`) that currently repeat the same declarations.
 2. Markup in `index.html`: the loose `kHz` / `dB` text nodes move inside their
   label, which keeps every id and every event handler exactly where it is.
 3. `#spectrum-controls` becomes a wrapping flex row with a spacer;
   `#spectrum-bw-row` and `#spectrum-level-row` become `nowrap` clusters with a
   left rule.
 4. The mobile block in the media query drops the rules it no longer needs.
 `app.ts` is not touched. Every id survives, so the existing handlers, the
 `spectrum-layout.mjs` geometry test and the broadcast-layout highlight all keep
 working.
 ### Tests
 Extend `spectrum-layout.mjs`, which already measures this area:
 - Every control in the strip shares one height, at 1600, 1200 and 900 px.
 - No two clusters sit at different vertical offsets on the same line — the
  staggering bug, asserted directly.
 - The strip never overflows its container and never overlaps the hint line.
 ---
 ## Noted for later, not proposed here
 Behavioural observations from reading the code, kept so they are not lost:
 - `Auto BW` (filter) and `Auto` (display scaling) are both called Auto, 600 px
  apart.
 - `Floor`, `Range` and `Contrast` are not persisted; `Peak Hold` is.
 - `Auto` and `Auto BW` are one-shot: no state, nothing to turn off.
 - `Sweet-spot` retunes the SDR and waits up to 1.4 s per candidate centre, with
  no busy indication.
 - Contrast resets on a double-click that nothing advertises.
@@ -121,14 +121,13 @@ The spectrum panel uses `<canvas>` elements (WebGL renderer optional) and offers
 When auth is enabled, an **auth gate** blocks the UI with:
 - Title: "Access Required"
- Subtitle: "Sign in to continue"
+- Subtitle: "Enter passphrase to continue"
- Username and password inputs + Login button (green accent, full-width)
+- Password input + Login button (green accent, full-width)
 - Optional "Continue as Guest" button (shown when RX passphrase is not set)
 - Error message area (red `#ff6b6b`)
 - Role badge display
-**Guest** provides read-only station access and is exclusive. Non-Guest accounts
+Two roles: **Rx** (read-only) and **Control** (full access including TX/PTT).
 may combine **Read**, **Control**, **Transmit**, **Write**, and **Administrator** roles.
 Administrator implies all permissions.
 Session cookie: `trx_http_sid`, HttpOnly, configurable Secure and SameSite attributes.
@@ -337,31 +336,25 @@ Logo and favicon are embedded at compile time via `include_bytes!`. The logo ima
 ### 7.1 Route Access Classification
-Routes are classified into access tiers:
+Routes are classified into three tiers:
 | Tier | Examples | Requirement |
 |---|---|---|
-| **Public** | `/`, `/index.html`, `/map`, login/session endpoints, static assets | None |
+| **Public** | `/`, `/index.html`, `/map`, `/auth/*`, static assets | None |
-| **Read** | `/status`, `/events`, `/audio`, `/decode`, `/spectrum`, `/bookmarks` | Guest, Read, Control, Transmit, or Administrator role |
+| **Read** | `/status`, `/events`, `/audio`, `/decode`, `/spectrum`, `/bookmarks` | Rx or Control role |
-| **Control** | `/set_freq`, `/set_mode`, `/toggle_power`, receive-side radio-control POST routes | Control or Administrator role |
+| **Control** | `/set_freq`, `/set_mode`, `/set_ptt`, `/toggle_power`, all other POST | Control role only |
 | **Transmit** | `/set_ptt`, `/set_tx_limit`, outbound `/audio` frames | Transmit or Administrator role |
 | **Write** | Logbook access and bookmark mutations | Write or Administrator role |
 ### 7.2 Session Management
 - Sessions are 128-bit random hex tokens stored in HttpOnly cookies
 - Configurable TTL (default from TOML config)
 - Expired sessions auto-pruned on access
- Passwords are verified against salted Argon2id hashes
+- Constant-time passphrase comparison to mitigate timing attacks
-### 7.3 User Management
+### 7.3 TX Access Control
-Every authenticated non-Guest account gets a Settings > Account tab for changing
+An additional `tx_access_control_enabled` flag can restrict transmit-related actions even
-its own password. Guest sees neither Account nor Users and both account-control
+for Control-role users, providing an extra safety layer.
 APIs deny Guest sessions. Only administrators get Settings > Users, where accounts can be
 created, enabled/disabled, assigned multiple roles, given a new password, or
 removed. The final enabled administrator cannot be disabled, removed, or
 demoted. Account security changes revoke every active session for that account.
 ---
@@ -17,60 +17,30 @@ frontends.
 ## Configuration
-Both `trx-server` and `trx-client` read TOML. The server takes its settings
+Both `trx-server` and `trx-client` use TOML configuration files. Use
-from the `[trx-server]` section and the client from `[trx-client]`, so one
+`--print-config` to generate a fully commented example.
 `trx-rs.toml` can configure both — or each may live in its own file with the
 section header left off.
 `trx-rs.toml.example` in the repository root is a complete, commented example
 generated from the config definitions themselves. `--print-config` prints the
 same settings without the comments.
 ### File Locations
-Both binaries use the same lookup order:
+**trx-server** lookup order:
 1. `--config <FILE>`
-2. `./trx-rs.toml`
+2. `./trx-server.toml`
-3. `~/.config/trx-rs/trx-rs.toml`
+3. `~/.trx-server.toml`
-4. `/etc/trx-rs/trx-rs.toml`
+4. `~/.config/trx-rs/server.toml`
 5. `/etc/trx-rs/server.toml`
 **trx-client** lookup order:
 1. `--config <FILE>`
 2. `./trx-client.toml`
 3. `~/.config/trx-rs/client.toml`
 4. `/etc/trx-rs/client.toml`
 CLI arguments override config file values.
-### Checking a Config
+### Environment Variables
-`--check-config` loads the file, reports every problem it finds — unknown keys,
+- `TRX_PLUGIN_DIRS`: additional plugin directories (path-separated), used by
-invalid values, listeners fighting over a port — and exits without starting
+  both server and client.
 anything:
 ```bash
 trx-server --check-config --config trx-rs.toml
 trx-client --check-config --config trx-rs.toml
 ```
 Unknown keys are warnings by default, so a config written for a newer version
 still runs on an older binary. `--strict-config` makes them fatal.
 `trx-configurator --check <FILE>` runs the same checks.
 ### Environment Variables and Secrets
 Any string in the config may reference an environment variable as `${VAR}`;
 an unset variable is an error rather than an empty value.
 Credentials can be kept out of the config entirely by pointing at a file
 instead. Every secret has a `*_file` sibling — set one or the other, never
 both:
 | Inline key | File key | Contents |
 |------------|----------|----------|
 | `[listen.auth].tokens` | `tokens_file` | one token per line |
 | `[[remotes]].auth.token` | `token_file` | the token |
 | `[frontends.http.auth].bootstrap_admin_password` | `bootstrap_admin_password_file` | the initial administrator password |
 | `[frontends.http_json.auth].tokens` | `tokens_file` | one token per line |
 Blank lines and `#` comments are ignored in the list files. A config that holds
 credentials inline and is readable by group or others is flagged at startup.
 ### Server Options
@@ -126,7 +96,6 @@ credentials inline and is readable by group or others is flagged at startup.
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `tokens` | string[] | `[]` | Allowed auth tokens (empty = no auth) |
 | `tokens_file` | string | — | Read tokens from this file, one per line |
 #### `[audio]`
@@ -152,13 +121,6 @@ When audio is enabled, at least one of `rx_enabled` or `tx_enabled` must be true
 | `sample_rate` | u32 | `1920000` | IQ capture rate in Hz |
 | `bandwidth` | u32 | `1500000` | Hardware IF filter bandwidth in Hz |
 | `center_offset_hz` | i64 | `100000` | Offset from dial to avoid DC spur |
 | `spectrum_fft_size` | usize | `1024` | Spectrum FFT bins; power of two, 128–8192 |
 | `spectrum_interval_ms` | u64 | `50` | How often a spectrum frame is pushed to subscribed clients |
 Spectrum is the largest thing on the client connection. On a slow or
 high-latency link, halving `spectrum_fft_size` halves the bytes per frame (at
 half the frequency resolution) and raising `spectrum_interval_ms` sends fewer of
 them; see [Spectrum over a slow link](#spectrum-over-a-slow-link).
 #### `[sdr.gain]`
@@ -235,29 +197,6 @@ Notes:
 Files are appended in JSON Lines format. Supported date tokens: `%YYYY%`,
 `%MM%`, `%DD%` (UTC).
 #### `[decoders]`
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `enabled` | string[] | all decoders | Decoders to run for this rig |
 | `output_dir` | string | `"$XDG_CACHE_HOME/trx-rs"` | Base directory for decoders that write images |
 Valid decoder names: `aprs`, `aprs_hf`, `ais`, `cw`, `ft2`, `ft4`, `ft8`,
 `lrpt`, `sstv`, `vdes`, `wefax`, `wspr` — the same names `[[sdr.channels]]`
 uses. An unrecognised name is a config error.
 Every decoder runs by default, which costs real CPU on a small machine. On a
 station that only works digital modes, listing just what you use is worth it:
 ```toml
 [decoders]
 enabled = ["ft8", "ft4", "wspr"]
 ```
 `sstv`, `wefax` and `lrpt` write images into a subdirectory of `output_dir`
 named after the decoder. `ais` and `vdes` additionally require an SDR channel
 configured to feed them.
 #### Multi-Rig Configuration
 Use `[[rigs]]` arrays instead of the flat `[rig]` section for multi-rig setups:
@@ -301,32 +240,12 @@ Rigs without an explicit `id` get auto-generated IDs like `ft817_0`, `soapysdr_1
 |-------|------|---------|-------------|
 | `url` | string | — | Server address (e.g. `localhost:4530`) |
 | `poll_interval_ms` | u64 | `750` | State poll interval |
 | `spectrum_interval_ms` | u64 | `50` | Spectrum frame interval; also settable per `[[remotes]]` entry |
 #### `[remote.auth]`
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `token` | string | — | Auth token (must not be empty if set) |
 | `token_file` | string | — | Read the token from this file instead |
 #### `[[remotes]]`
 Preferred over the single `[remote]` section: one entry per rig, each mapping a
 short name to a server and an optional server-side rig id.
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `name` | string | — | Short name used everywhere in the client |
 | `url` | string | — | Server address (`host:port`) |
 | `rig_id` | string | — | Rig id on a multi-rig server |
 | `auth.token` | string | — | Auth token |
 | `auth.token_file` | string | — | Read the token from this file instead |
 | `poll_interval_ms` | u64 | `750` | State poll interval |
 The `name` is the key used by `default_rig_name`, `rigctl.rig_ports`,
 `audio.rig_urls`, `audio.rig_ports` and `decode_history_retention_min_by_rig`.
 A name in any of those maps that no remote answers to is a config error.
 #### `[frontends.http]`
@@ -335,34 +254,6 @@ A name in any of those maps that no remote answers to is a config error.
 | `enabled` | bool | `true` | Enable web UI |
 | `listen` | ip | `127.0.0.1` | Bind address |
 | `port` | u16 | `8080` | Bind port |
 | `default_rig_name` | string | — | Remote selected on startup |
 | `initial_map_zoom` | u8 | `10` | Starting zoom for the APRS map |
 | `show_sdr_gain_control` | bool | `true` | Expose the RF gain control |
 | `bandplan_enabled` | bool | `true` | Show the bandplan strip |
 | `bandplan_region` | string | `"iaru_r1"` | `iaru_r1`, `iaru_r2`, or `iaru_r3` |
 | `decode_history_retention_min` | u64 | `1440` | Decode history retention |
 | `decode_history_retention_min_by_rig` | table | `{}` | Per-remote retention override |
 | `spectrum_coverage_margin_hz` | u32 | `50000` | Centre-retune guard margin |
 | `spectrum_usable_span_ratio` | f32 | `0.92` | Usable fraction of the sampled span |
 #### `[frontends.http.auth]`
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `enabled` | bool | `false` | Enable the user/password ACL |
 | `users_file` | string | `"trx-http-users.json"` | Persistent managed user database |
 | `bootstrap_admin_username` | string | — | First administrator, used only if the database is absent |
 | `bootstrap_admin_password` | string | — | First administrator password |
 | `bootstrap_admin_password_file` | string | — | Read the bootstrap password from this file instead |
 | `bootstrap_read_enabled` | bool | `true` | Create the default Guest account when the database is absent |
 | `bootstrap_read_username` | string | `"guest"` | Initial Guest username |
 | `bootstrap_read_password` | string | `"guest"` | Initial Guest password |
 | `session_ttl_min` | u64 | `480` | Session lifetime |
 | `cookie_secure` | bool | `false` | Set Secure on the session cookie (needs HTTPS) |
 | `cookie_same_site` | string | `"Lax"` | `Strict`, `Lax`, or `None` |
 When enabling ACL for the first time, configure both bootstrap fields. After
 the database exists, remove the bootstrap credentials from configuration.
 #### `[frontends.rigctl]`
@@ -370,11 +261,7 @@ the database exists, remove the bootstrap credentials from configuration.
 |-------|------|---------|-------------|
 | `enabled` | bool | `false` | Enable Hamlib rigctl |
 | `listen` | ip | `127.0.0.1` | Bind address |
-| `rig_ports` | table | `{}` | Remote name → local port; one listener each |
+| `port` | u16 | `4532` | Bind port |
 One listener is started per `rig_ports` entry, each routing to its rig, so
 `rig_ports` must name at least one remote when the frontend is enabled. The
 older single `port` key and `--rigctl-port` are ignored.
 #### `[frontends.http_json]`
@@ -384,17 +271,13 @@ older single `port` key and `--rigctl-port` are ignored.
 | `listen` | ip | `127.0.0.1` | Bind address |
 | `port` | u16 | `0` | Bind port (0 = ephemeral) |
 | `auth.tokens` | string[] | `[]` | Allowed auth tokens |
 | `auth.tokens_file` | string | — | Read tokens from this file, one per line |
 #### `[frontends.audio]`
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `enabled` | bool | `true` | Enable audio client |
-| `server_url` | string | — | Audio endpoint for every remote |
+| `server_port` | u16 | `4531` | Server audio port |
 | `rig_urls` | table | `{}` | Remote name → audio URL (wins over `server_url`) |
 | `server_port` | u16 | `4531` | Fallback port when no URL is configured |
 | `rig_ports` | table | `{}` | Remote name → port; superseded by `rig_urls` |
 | `bridge.enabled` | bool | `false` | Enable local CPAL audio bridge |
 | `bridge.rx_output_device` | string | — | Local playback device |
 | `bridge.tx_input_device` | string | — | Local capture device |
@@ -404,257 +287,68 @@ older single `port` key and `--rigctl-port` are ignored.
 The bridge is intended for WSJT-X integration via virtual audio devices (ALSA
 loopback on Linux, BlackHole on macOS).
 ### Spectrum over a slow link
 Spectrum dominates the server↔client connection: everything else is a few
 hundred bytes, a frame is a few kilobytes. Three things govern what it costs.
 **Frames are pushed, not polled.** The client subscribes and the server sends
 frames at `[sdr].spectrum_interval_ms`. Polling cost a round trip per frame, so
 the rate was capped at 1/RTT — on a 200 ms link you could not exceed 5 frames a
 second however often the client asked. Clients fall back to polling
 automatically against a server too old to stream.
 **Bins travel as whole dBFS.** They are base64-encoded `i8` on the wire, about
 an eighth of the JSON array of floats they used to be, at the resolution the
 display draws anyway.
 **Both ends have a rate, and the slower one wins.** The server pushes no faster
 than `[sdr].spectrum_interval_ms`; the client asks for no more than
 `[[remotes]].spectrum_interval_ms`.
 For a link that struggles, start here:
 ```toml
 [trx-server.sdr]
 spectrum_fft_size = 512      # half the bins, half the bytes
 spectrum_interval_ms = 200   # 5 frames/s instead of 20
 [[trx-client.remotes]]
 name = "remote-site"
 url = "radio.example.com:4530"
 spectrum_interval_ms = 200
 ```
 That is roughly 0.7 KB per frame at 5 frames/s — about 3.5 KB/s, against
 roughly 200 KB/s for 1024 float bins at 20 frames/s.
 ### CLI Override Summary
 **trx-server:**
-`--config`, `--print-config`, `--check-config`, `--strict-config`, `--rig`,
+`--config`, `--print-config`, `--rig`, `--access`, `--callsign`, `--listen`,
-`--access`, `--callsign`, `--listen`, `--port`. SDR options are file-only.
+`--port`. SDR options are file-only.
 **trx-client:**
-`--config`, `--print-config`, `--check-config`, `--strict-config`, `--url`,
+`--config`, `--print-config`, `--url`, `--token`, `--poll-interval`,
-`--token`, `--poll-interval`, `--rig-id`, `--frontend`, `--http-listen`,
+`--frontend`, `--http-listen`, `--http-port`, `--rigctl-listen`,
-`--http-port`, `--rigctl-listen`, `--http-json-listen`, `--http-json-port`,
+`--rigctl-port`, `--http-json-listen`, `--http-json-port`, `--callsign`.
 `--callsign`.
 `--listen` on the server overrides the bind address of both the control
 listener and every rig's audio listener.
 ---
 ## Multiple Rigs in the Web UI
 A client connected to several rigs decodes all of them at once, whichever one
 is on screen. The rig picker in the header decides which rig the UI is about,
 and each page answers that differently:
 | Page | Shows |
 |------|-------|
 | Radio | The selected rig: its spectrum, its audio, and the mini decode views over the waterfall. |
 | Digital Modes | The selected rig: every decoder panel, its counts and its status line. |
 | Map | The whole station — every rig's positions, with the map's own rig filter to narrow it. HF APRS is a source of its own there, filtered apart from VHF APRS. |
 | Statistics | The whole station, including the per-rig comparison. |
 Switching rigs repaints the radio and digital modes pages for the rig now
 selected. Nothing is lost by switching: the traffic other rigs heard is still
 held, and switching back brings it up again. The one exception is the CW pane,
 which is a single running stream of copied text rather than a list of frames,
 so it starts empty on the rig you switch to.
 Each browser tab keeps its own selection, so two tabs can watch two rigs.
 ---
 ## Logbook
 The **Logbook** tab keeps the station's contacts and speaks ADIF, so a log can
 be uploaded to LoTW, eQSL, Club Log or QRZ, or moved to another logger.
 An entry opens pre-filled with six fields and no more: the frequency, mode and
 name of the rig you are on, the time from the server's clock, and — when the
 entry was started from a decode or a map station — that station's callsign and
 locator. Signal reports, name, comment and the rest are yours to fill in; a
 report in particular is never guessed, because an FT8 SNR is not what was sent.
 Your own callsign and locator are not per-contact fields. They are station
 identity: the callsign comes from `[trx-client.general].callsign`, the locator
 from the rig's position, and both are shown once at the top of the panel. The
 operator defaults to the station callsign and can be changed for the session,
 which is what a multi-operator station needs.
 **Times are the server's**, in UTC — the server is the machine at the radio. If
 the browser's clock disagrees by more than a second the entry says so rather
 than logging a time you did not expect.
 **A decode is not a contact.** The decoders are receive-only, so a **Log**
 button on an FT8 or APRS row opens an entry with what was heard in it and logs
 nothing by itself. Digital QSOs made in WSJT-X come in through Import ADIF, the
 way every other logger takes them.
 | Action | What it does |
 |--------|--------------|
 | Log contact | Writes the entry and opens a fresh one |
 | Export ADIF | Downloads the log — filtered, if a filter is set |
 | Import ADIF | Reads a file, skipping contacts already held and reporting what could not be read |
 | Worked before | Shows, as you type a callsign, which bands and modes it has been worked on |
 Two contacts are treated as the same when the callsign, band and mode match and
 the times are within two minutes: two loggers rarely stamp a QSO to the same
 minute, one recording when it started and the other when it was typed.
 The log is a JSON Lines file, appended one contact at a time so a crash costs at
 most the contact being written. It lives in your data directory by default;
 `[trx-client.logbook].path` moves it, for a station that keeps its log on a
 backed-up volume.
 ### Contests
 The **Contest exchange** block on the entry holds the contest's name and the
 serials — sent and received. Both stay between contacts, because they belong to
 the session rather than to the contact just logged, and the serial sent counts
 on by itself so it is not retyped forty times an hour. An exchange that is a
 zone, a section or a name rather than a number is kept as written.
 **Contest entry (Cabrillo)** exports the entry sponsors accept. Only the
 contacts of the contest named there are included. The header — operator
 category, power, claimed score — cannot be worked out from a log, so it is
 yours to fill in; the defaults are single operator, low power, all bands, mixed
 mode.
 ### Confirmations
 The **QSL** column shows a tick when the other station has confirmed, and the
 **Confirm** button on a row records a card that has arrived. A confirmation
 counts from wherever it came: a paper card, LoTW or eQSL. An award wants one of
 them, not all three, so the log does not ask for all three.
 **Bands worked** counts, per band, the contacts made, the distinct stations
 worked, and how many of those contacts are confirmed.
 ### Ham radio layout
 The **Ham radio** operator layout opens on the logbook with the transceiver
 controls around it — the arrangement for working the bands, where logging the
 contact is the task and the radio is the instrument. It is offered only where
 the selected rig can transmit; a receiver has no contacts to log.
 ---
 ## Tune Links
 Every page of the web UI carries what the radio is doing in its address, so the
 URL in the address bar is always a link someone else can open:
 ```
 http://receiver.example:8080/?rig=sdr&f=14074000&mode=USB&bw=3000
 ```
 | Parameter | Meaning |
 |-----------|---------|
 | `f` | Frequency. Hz by default; `7074k` and `14.074M` also work. |
 | `mode` | Demodulation mode, e.g. `USB`, `CW`, `WFM`. |
 | `bw` | Filter bandwidth in Hz. Ignored by rigs without filter control. |
 | `rig` | Rig to select first, by id, on a multi-rig client. |
 Opening such a link selects the rig, sets the mode, tunes, and applies the
 bandwidth, in that order — a mode change carries its own default bandwidth, so
 an explicit `bw` is applied last. Anything the rig cannot do (an unknown mode,
 a frequency outside its range) is reported and the rest of the link still
 applies. All four parameters are optional.
 The link button in the top bar copies the current link to the clipboard. The
 address bar itself is updated as you tune, using `replaceState`, so sweeping
 the dial does not fill the browser's history.
 Applying a link changes the radio, so it needs the `Control` role; a `Read`
 session opens the page and says the link was not applied. Links describe the
 rig's own dial — while a tab is listening to a virtual channel the address is
 left as it was, rather than publishing a frequency the rig is not on.
 ---
 ## Authentication
-The HTTP frontend supports an optional user/password ACL:
+The HTTP frontend supports optional passphrase-based authentication with two
 roles:
- **Guest** — read-only station access with no Account or Users controls; Guest cannot be combined with another role
+- **rx** — read-only access (monitoring, audio, decode streams)
- **Read** — monitoring, audio, decode streams, and bookmark reads
+- **control** — full access (frequency, mode, PTT, and all settings)
 - **Control** — tuning, mode, power, and receive-side radio controls
 - **Transmit** — PTT, transmitted audio, and TX power-limit controls
 - **Write** — logbook access and bookmark changes
 - **Administrator** — user management and all other permissions
 ### Configuration
 ```toml
 [frontends.http.auth]
 enabled = false
-users_file = "trx-http-users.json"
+rx_passphrase = "rx-only-passphrase"
-bootstrap_admin_username = "admin"
+control_passphrase = "full-control-passphrase"
-bootstrap_admin_password = "change-this-password"
+tx_access_control_enabled = true
 bootstrap_read_enabled = true
 bootstrap_read_username = "guest"
 bootstrap_read_password = "guest"
 session_ttl_min = 480
 cookie_secure = false      # true if served via HTTPS
 cookie_same_site = "Lax"   # Strict|Lax|None
 ```
 When `enabled = false` (the default), all auth is bypassed and the UI behaves
-as before. When enabling it for the first time, bootstrap credentials create
+as before. When enabled, at least one passphrase must be set.
 the initial administrator (with every non-Guest role), the default `guest`/`guest` Guest
 account, and the Argon2id-hashed user database. Change or disable the guest
 credentials in configuration before first startup on an exposed deployment.
 ### Behaviour
 - On login, the server issues an `HttpOnly` session cookie.
 - Sessions are in-memory; a server restart invalidates all sessions.
 - Rate limiting is applied per IP to mitigate brute-force attempts.
- User records persist in `users_file`; passwords are stored as salted Argon2id hashes.
+- When `tx_access_control_enabled = true`, TX/PTT controls are hidden and
- Non-Guest roles are independent; for example, an account may have Read and Write without Control.
+  rejected for unauthenticated or `rx`-role users.
 - Guest accounts have no account-control panels and cannot call account-control endpoints.
 - Every non-Guest signed-in user can change their own password in Settings > Account. This signs out all of their sessions.
 - Administrators can add, enable/disable, or remove users and change roles/passwords in Settings > Users.
 - At least one enabled administrator must always remain and cannot be disabled, removed, or demoted.
 - Disabling/removing an account or changing its password/roles revokes all of its sessions.
 - Existing account files migrate automatically: legacy accounts are enabled by default and legacy `user`/`admin` roles become Read/all roles.
 ### Routes
 | Endpoint | Method | Description |
 |----------|--------|-------------|
-| `/auth/login` | POST | Submit `{ "username": "...", "password": "..." }` |
+| `/auth/login` | POST | Submit `{ "passphrase": "..." }` |
 | `/auth/logout` | POST | Clear session |
-| `/auth/session` | GET | Check current session/roles |
+| `/auth/session` | GET | Check current session/role |
 | `/auth/account/password` | PATCH | Change a non-Guest user's password after verifying the current password |
 | `/auth/users` | GET/POST | List or add users (admin only) |
 | `/auth/users/{username}` | PATCH/DELETE | Change enabled state/password/roles or remove user (administrator only) |
-Read routes accept Guest or require Read. Tuning and receive-side radio mutations
+Protected routes require at least `rx` role. Control routes (set frequency,
-require Control. PTT, transmitted audio, and TX limit changes require Transmit.
+mode, PTT, etc.) require `control` role.
 Logbook access and bookmark mutations require Write. Administrator grants every permission.
 ### Frontend Flow
 1. On load, the UI calls `/auth/session`.
 2. If unauthenticated, a login screen is shown.
 3. On successful login, the normal UI loads.
-4. The interface enables controls according to the account's roles.
+4. `rx` users see a read-only interface; `control` users get full controls.
 5. If a session expires mid-use, streams stop and the login screen returns.
 ### Transport Security
@@ -752,30 +446,9 @@ A dedicated tab with a clock icon provides:
 ## SDR Noise Blanker
 The noise blanker suppresses impulse noise (clicks, pops, ignition interference)
-on raw IQ samples before any mixing or filtering takes place — the only point in
+on raw IQ samples before any mixing or filtering takes place. It works by
-the chain where an impulse is still short in time, since the narrow channel
+tracking a running RMS level of the signal and replacing any sample whose
-filter downstream smears it into un-removable ringing.
+magnitude exceeds **threshold x RMS** with the last known clean sample.
 It combines four elements:
 - A **noise-floor tracker** — an exponential estimate of the background level,
  updated only from clean samples (and frozen during a blank) so a burst cannot
  drag the reference up and blind the detector.
 - **Detection** — a sample is flagged when its power exceeds
  **threshold² × noise-floor**.
 - **Look-ahead** — the stream is delayed a few microseconds so the gate can
  begin closing *before* the impulse reaches the output, catching its leading
  edge instead of letting it leak through.
 - A **tapered gate** — instead of a hard sample-and-hold (which splatters energy
  back across the passband and is what made the old blanker sound worse on
  SSB/CW/data), the gain ramps smoothly down and back up, so blanking costs only
  a short, quiet notch.
 The blank window, look-ahead, taper, and floor time constant are chosen by a
 **profile** matched to the interference source. The `threshold` control is
 orthogonal — it sets detection sensitivity within the chosen profile. All
 profile timings are specified in real time and converted to samples at the
 capture rate, so the blanker behaves consistently across SDR sample rates.
 ### Configuration (server-side)
@@ -792,7 +465,6 @@ type = "sdr"
 [rigs.sdr.noise_blanker]
 enabled = true
 threshold = 10.0     # 1 – 100; lower = more aggressive blanking
 profile = "spike"    # spike | ignition | powerline | broadband
 ```
 For the legacy single-rig (flat) config the path is `[sdr.noise_blanker]`:
@@ -801,30 +473,15 @@ For the legacy single-rig (flat) config the path is `[sdr.noise_blanker]`:
 [sdr.noise_blanker]
 enabled = true
 threshold = 10.0
 profile = "spike"
 ```
-| Field       | Type   | Default   | Range   | Description |
+| Field       | Type  | Default | Range   | Description |
-|-------------|--------|-----------|---------|-------------|
+|-------------|-------|---------|---------|-------------|
-| `enabled`   | bool   | false     | —       | Turn the noise blanker on or off. |
+| `enabled`   | bool  | false   | —       | Turn the noise blanker on or off. |
-| `threshold` | float  | 10.0      | 1 – 100 | Multiplier applied to the tracked noise floor. A sample whose magnitude exceeds this multiple is blanked. Lower values blank more aggressively; higher values only catch strong impulses. |
+| `threshold` | float | 10.0    | 1 – 100 | Multiplier applied to the running RMS. A sample whose magnitude exceeds this multiple is replaced. Lower values blank more aggressively; higher values only catch strong impulses. |
 | `profile`   | string | `"spike"` | see below | Tuning profile matched to the interference source. |
 The noise blanker is off by default.
 ### Profiles
 Each profile sets the blank-window width, look-ahead, gate taper, and
 noise-floor time constant. Pick the one that matches what you are hearing, then
 fine-tune with the threshold.
 | Profile      | Blank window | Best for |
 |--------------|--------------|----------|
 | `spike`      | Narrowest    | Sharp, sparse impulses — ignition sparks, static crashes, keyed relays. The safe default: minimal impact on the wanted signal, good for SSB/CW/digital. |
 | `ignition`   | Medium       | Automotive ignition, electric fences, PWM/LED drivers — clusters of medium-width pulses at a high repetition rate. |
 | `powerline`  | Wide         | Power-line and arcing noise — buzzy bursts locked to the 100/120 Hz mains cycle. Uses a slower floor tracker to ride out the burst. |
 | `broadband`  | Widest       | Dense, continuous impulse noise where suppression matters more than fidelity. Most aggressive gating; expect some softening of the wanted signal. |
 ### Choosing a threshold
 The threshold controls how aggressively the blanker suppresses impulses.
@@ -850,44 +507,39 @@ the running average signal level.
 ### Web UI
-When the server reports noise-blanker support, these controls appear in the
+When the server reports noise-blanker support, two controls appear in the
 **SDR Settings** row of the web interface:
 - **Noise Blanker** checkbox — enables or disables the blanker in real time.
  The **N** keyboard shortcut toggles it too.
 - **NB Threshold** number input (1–100) with a **Set** button — adjusts the
-  detection sensitivity. Press Enter or click Set to apply.
+  detection threshold. Press Enter or click Set to apply.
 - **NB profile** selector — chooses the profile (Spike / Ignition / Powerline /
  Broadband). Changing it applies immediately.
-The controls stay hidden until the server sends filter state containing NB
+Both controls stay hidden until the server sends filter state containing NB
 fields, so they only appear when connected to an SDR backend.
 ### HTTP API
 ```
-POST /set_sdr_noise_blanker?enabled=true&threshold=10&profile=spike
+POST /set_sdr_noise_blanker?enabled=true&threshold=10
 ```
 | Parameter   | Type   | Required | Description |
 |-------------|--------|----------|-------------|
 | `enabled`   | bool   | yes      | `true` or `false` |
 | `threshold` | float  | yes      | Value between 1 and 100 |
 | `profile`   | string | no       | `spike` (default), `ignition`, `powerline`, or `broadband` |
 ### How it works
-The blanker runs on every IQ block *before* the mixer stage in the DSP pipeline,
+The blanker runs on every IQ block (4096 samples) *before* the mixer stage in
-one sample at a time:
+the DSP pipeline:
-1. Emit the sample from the look-ahead delay line and ingest the fresh one.
+1. For each sample, compute magnitude² (`re² + im²`).
-2. Compute the fresh sample's power (`re² + im²`) and compare it against
+2. Compare against `threshold² × mean_sq` (the exponentially-smoothed running
-   `threshold² × noise_floor`.
+   mean of magnitude²).
-3. If it exceeds the threshold, hold the gate closed for the profile's blank
+3. If the sample exceeds the threshold, replace it with the previous clean
-   window; the fresh sample reaches the output a few samples later, by which
+   sample.
-   time the gate has fully ramped to zero — so the leading edge is removed.
+4. Otherwise, update the running mean with smoothing factor α = 1/128 and store
-4. Otherwise, update the noise-floor estimate (skipped while blanking) and let
+   the sample as the last clean value.
   the gate ramp back open.
 Because the blanker operates on raw IQ before frequency translation, it removes
 impulse noise across the entire captured bandwidth regardless of the tuned
@@ -1,38 +0,0 @@
 # SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 #
 # systemd *user* unit for the trx-rs radio client and web frontend.
 #
 # Install with `script/install.sh` (which substitutes @BINDIR@ and copies this
 # into ~/.config/systemd/user/), or by hand:
 #   sed "s|@BINDIR@|$HOME/.local/bin|" trx-client.service \
 #     > ~/.config/systemd/user/trx-client.service
 #   systemctl --user daemon-reload
 #   systemctl --user enable --now trx-client.service
 #
 # Reads the combined config at ~/.config/trx-rs/trx-rs.toml ([trx-client]
 # section) and connects to the server (default 127.0.0.1:4530). The web UI
 # defaults to http://127.0.0.1:8080.
 [Unit]
 Description=trx-rs radio client and web frontend
 Documentation=https://github.com/stanislawgrams/trx-rs
 # Wait for networking and, when it is enabled, the local server.  After= only
 # orders units already in the transaction: it deliberately does not start a
 # disabled trx-server, since the client may connect to a remote server instead.
 Wants=network-online.target
 After=network-online.target trx-server.service
 [Service]
 Type=simple
 ExecStart=@BINDIR@/trx-client --config %h/.config/trx-rs/trx-rs.toml
 Restart=on-failure
 RestartSec=2
 # Shuts down cleanly on SIGINT (see trx-server.service for the rationale).
 KillSignal=SIGINT
 TimeoutStopSec=15
 NoNewPrivileges=true
 [Install]
 WantedBy=default.target
@@ -1,38 +0,0 @@
 # SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 #
 # systemd *user* unit for the trx-rs radio server.
 #
 # Install with `script/install.sh` (which substitutes @BINDIR@ and copies this
 # into ~/.config/systemd/user/), or by hand:
 #   sed "s|@BINDIR@|$HOME/.local/bin|" trx-server.service \
 #     > ~/.config/systemd/user/trx-server.service
 #   systemctl --user daemon-reload
 #   systemctl --user enable --now trx-server.service
 #
 # Reads the combined config at ~/.config/trx-rs/trx-rs.toml ([trx-server]
 # section). Serial (/dev/ttyUSB*) and audio access require your user to be in
 # the `dialout` and `audio` groups — a user unit cannot grant them itself.
 [Unit]
 Description=trx-rs radio server (CAT/SDR backend)
 Documentation=https://github.com/stanislawgrams/trx-rs
 # The server binds its control/audio TCP listeners and may connect to networked
 # rigs and reporting services, so do not start it before networking is ready.
 Wants=network-online.target
 After=network-online.target
 [Service]
 Type=simple
 ExecStart=@BINDIR@/trx-server --config %h/.config/trx-rs/trx-rs.toml
 Restart=on-failure
 RestartSec=2
 # Both binaries shut down cleanly on SIGINT (the server drains audio and exits
 # 0); systemd's default SIGTERM is not handled, so signal SIGINT instead.
 KillSignal=SIGINT
 TimeoutStopSec=15
 NoNewPrivileges=true
 [Install]
 WantedBy=default.target
@@ -1,156 +0,0 @@
 #!/usr/bin/env bash
 # SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 #
 # Build trx-rs in release mode and install the binaries system-wide, seed a
 # per-user config, and install systemd *user* services to run the server and
 # client. Idempotent: existing config is never overwritten.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 BINARIES=(trx-server trx-client trx-configurator)
 # --- Defaults (override via flags or environment) ---------------------------
 PREFIX="${PREFIX:-$HOME/.local}"
 BINDIR="${BINDIR:-}"          # derived from PREFIX unless set explicitly
 NO_SDR=0
 DO_BUILD=1
 DO_SYSTEMD=1
 ENABLE_NOW=0
 CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/trx-rs"
 CONFIG_FILE="$CONFIG_DIR/trx-rs.toml"
 UNIT_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user"
 usage() {
    cat <<EOF
 Usage: script/install.sh [options]
 Build trx-rs (release) and install it.
 Options:
  --prefix DIR     Install prefix; binaries go to DIR/bin (default: \$HOME/.local)
  --bindir DIR     Install binaries directly to DIR (overrides --prefix)
  --no-sdr         Build without SoapySDR support (--no-default-features)
  --no-build       Skip cargo build; install existing target/release binaries
  --no-systemd     Do not install the systemd user services
  --enable-now     Enable and start the user services immediately after install
  -h, --help       Show this help
 Environment:
  PREFIX, BINDIR   Same as the matching flags.
 Installs:
  binaries  -> ${BINDIR:-$PREFIX/bin} (uses sudo if not writable)
  config    -> $CONFIG_FILE (from trx-rs.toml.example, only if absent)
  services  -> $UNIT_DIR/{trx-server,trx-client}.service
 EOF
 }
 # --- Parse args -------------------------------------------------------------
 while [ $# -gt 0 ]; do
    case "$1" in
        --prefix) PREFIX="$2"; shift 2 ;;
        --bindir) BINDIR="$2"; shift 2 ;;
        --no-sdr) NO_SDR=1; shift ;;
        --no-build) DO_BUILD=0; shift ;;
        --no-systemd) DO_SYSTEMD=0; shift ;;
        --enable-now) ENABLE_NOW=1; shift ;;
        -h|--help) usage; exit 0 ;;
        *) echo "error: unknown option '$1'" >&2; usage >&2; exit 2 ;;
    esac
 done
 [ -n "$BINDIR" ] || BINDIR="$PREFIX/bin"
 log() { printf '\033[1;32m==>\033[0m %s\n' "$*"; }
 warn() { printf '\033[1;33mwarning:\033[0m %s\n' "$*" >&2; }
 # Return 0 (true) if writing into $1 needs elevated privileges.
 need_sudo() {
    local dir="$1"
    while [ ! -e "$dir" ]; do dir="$(dirname "$dir")"; done
    [ -w "$dir" ] && return 1 || return 0
 }
 # --- Build ------------------------------------------------------------------
 if [ "$DO_BUILD" -eq 1 ]; then
    build_args=(build --release --manifest-path "$PROJECT_ROOT/Cargo.toml")
    for b in "${BINARIES[@]}"; do build_args+=(-p "$b"); done
    if [ "$NO_SDR" -eq 1 ]; then
        # --no-default-features only affects trx-server; harmless elsewhere.
        build_args+=(-p trx-server --no-default-features)
        log "Building (release, no SDR)…"
    else
        log "Building (release, with SDR)…"
    fi
    cargo "${build_args[@]}"
 fi
 # --- Install binaries -------------------------------------------------------
 SUDO=""
 if need_sudo "$BINDIR"; then
    SUDO="sudo"
    log "Installing binaries to $BINDIR (using sudo)…"
 else
    log "Installing binaries to $BINDIR…"
 fi
 for b in "${BINARIES[@]}"; do
    src="$PROJECT_ROOT/target/release/$b"
    if [ ! -x "$src" ]; then
        echo "error: $src not found (build failed or --no-build with no prior build?)" >&2
        exit 1
    fi
    $SUDO install -Dm755 "$src" "$BINDIR/$b"
    log "installed $BINDIR/$b"
 done
 # --- Seed per-user config ---------------------------------------------------
 if [ -e "$CONFIG_FILE" ]; then
    log "Config already present, leaving it untouched: $CONFIG_FILE"
 else
    mkdir -p "$CONFIG_DIR"
    install -m600 "$PROJECT_ROOT/trx-rs.toml.example" "$CONFIG_FILE"
    log "Seeded config from example: $CONFIG_FILE"
    warn "Edit $CONFIG_FILE for your rig before starting the services."
 fi
 # --- systemd user services --------------------------------------------------
 if [ "$DO_SYSTEMD" -eq 1 ]; then
    mkdir -p "$UNIT_DIR"
    for unit in trx-server trx-client; do
        sed "s|@BINDIR@|$BINDIR|g" \
            "$PROJECT_ROOT/packaging/systemd/$unit.service" \
            > "$UNIT_DIR/$unit.service"
        log "installed $UNIT_DIR/$unit.service"
    done
    if command -v systemctl >/dev/null 2>&1; then
        systemctl --user daemon-reload || warn "systemctl --user daemon-reload failed"
        if [ "$ENABLE_NOW" -eq 1 ]; then
            log "Enabling and starting user services…"
            systemctl --user enable --now trx-server.service trx-client.service
            warn "Run 'loginctl enable-linger $USER' to keep services running after logout."
        else
            cat <<EOF
 Next steps:
  1. Edit your config:   \$EDITOR $CONFIG_FILE
  2. Start the services: systemctl --user enable --now trx-server trx-client
  3. Watch the logs:     journalctl --user -u trx-server -u trx-client -f
  4. Run after logout:   loginctl enable-linger $USER
 Web UI (default): http://127.0.0.1:8080
 EOF
        fi
    else
        warn "systemctl not found; units copied but not reloaded."
    fi
 fi
 log "Done."
@@ -1,86 +0,0 @@
 #!/usr/bin/env bash
 # SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 #
 # Reverse script/install.sh: stop and remove the systemd user services and the
 # installed binaries. User config (~/.config/trx-rs) is left in place unless
 # --purge is given.
 set -euo pipefail
 BINARIES=(trx-server trx-client trx-configurator)
 PREFIX="${PREFIX:-$HOME/.local}"
 BINDIR="${BINDIR:-}"
 PURGE=0
 CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/trx-rs"
 UNIT_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user"
 usage() {
    cat <<EOF
 Usage: script/uninstall.sh [options]
 Options:
  --prefix DIR   Install prefix binaries were installed under (default: \$HOME/.local)
  --bindir DIR   Directory binaries were installed to (overrides --prefix)
  --purge        Also delete the user config directory ($CONFIG_DIR)
  -h, --help     Show this help
 EOF
 }
 while [ $# -gt 0 ]; do
    case "$1" in
        --prefix) PREFIX="$2"; shift 2 ;;
        --bindir) BINDIR="$2"; shift 2 ;;
        --purge) PURGE=1; shift ;;
        -h|--help) usage; exit 0 ;;
        *) echo "error: unknown option '$1'" >&2; usage >&2; exit 2 ;;
    esac
 done
 [ -n "$BINDIR" ] || BINDIR="$PREFIX/bin"
 log() { printf '\033[1;32m==>\033[0m %s\n' "$*"; }
 need_sudo() {
    local dir="$1"
    while [ ! -e "$dir" ]; do dir="$(dirname "$dir")"; done
    [ -w "$dir" ] && return 1 || return 0
 }
 # --- Stop and remove user services -----------------------------------------
 if command -v systemctl >/dev/null 2>&1; then
    log "Stopping and disabling user services…"
    systemctl --user disable --now trx-client.service trx-server.service 2>/dev/null || true
 fi
 for unit in trx-client trx-server; do
    if [ -e "$UNIT_DIR/$unit.service" ]; then
        rm -f "$UNIT_DIR/$unit.service"
        log "removed $UNIT_DIR/$unit.service"
    fi
 done
 if command -v systemctl >/dev/null 2>&1; then
    systemctl --user daemon-reload || true
 fi
 # --- Remove binaries --------------------------------------------------------
 SUDO=""
 if need_sudo "$BINDIR"; then SUDO="sudo"; fi
 for b in "${BINARIES[@]}"; do
    if [ -e "$BINDIR/$b" ]; then
        $SUDO rm -f "$BINDIR/$b"
        log "removed $BINDIR/$b"
    fi
 done
 # --- Optionally purge config ------------------------------------------------
 if [ "$PURGE" -eq 1 ]; then
    rm -rf "$CONFIG_DIR"
    log "purged $CONFIG_DIR"
 else
    log "Left config in place: $CONFIG_DIR (use --purge to delete)"
 fi
 log "Done."
@@ -1,14 +0,0 @@
 # SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 [package]
 name = "trx-sstv"
 version.workspace = true
 edition = "2021"
 [dependencies]
 trx-core = { path = "../../trx-core" }
 base64 = "0.22"
 png = "0.17"
 tracing = "0.1"
@@ -1,91 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! Encode a test card, decode it back, write both as PNGs to a directory.
 //!
 //! `cargo run -p trx-sstv --example round_trip_png -- /tmp/out`
 use trx_sstv::encode::{encode, Frame};
 use trx_sstv::mode::mode_for_vis;
 use trx_sstv::{ImageCanvas, SstvConfig, SstvDecoder, SstvEvent};
 fn main() {
    let dir = std::env::args().nth(1).unwrap_or_else(|| ".".into());
    for vis in [44u8, 60, 12, 8, 95] {
        let mode = mode_for_vis(vis).expect("mode in table");
        let (w, h) = (usize::from(mode.width), usize::from(mode.height));
        let mut rgb = vec![0u8; w * h * 3];
        for y in 0..h {
            for x in 0..w {
                let at = (y * w + x) * 3;
                let (r, g, b) = if y < h / 3 {
                    [
                        (255u8, 255u8, 255u8),
                        (255, 255, 0),
                        (0, 255, 255),
                        (0, 255, 0),
                        (255, 0, 255),
                        (255, 0, 0),
                        (0, 0, 255),
                        (0, 0, 0),
                    ][x * 8 / w]
                } else if y < 2 * h / 3 {
                    let t = (x * 255 / w) as u8;
                    (t, 255 - t, ((y * 255) / h) as u8)
                } else {
                    // Diagonal stripes: a line-timing error shows up as a kink.
                    if ((x + y) / 16) % 2 == 0 {
                        (240, 240, 40)
                    } else {
                        (20, 20, 90)
                    }
                };
                rgb[at] = r;
                rgb[at + 1] = g;
                rgb[at + 2] = b;
            }
        }
        let name = mode.name.replace(' ', "-");
        let mut sent = ImageCanvas::new(w, h);
        for y in 0..h {
            sent.put_row(y, &rgb[y * w * 3..(y + 1) * w * 3]);
        }
        std::fs::write(
            format!("{dir}/{name}-sent.png"),
            sent.to_png().expect("png"),
        )
        .expect("write");
        let frame = Frame {
            width: w,
            height: h,
            rgb: &rgb,
        };
        let mut audio = encode(mode, &frame, 48_000);
        audio.extend(std::iter::repeat_n(0.0, 4800));
        let mut decoder = SstvDecoder::new(48_000, SstvConfig::default());
        let mut got = None;
        for block in audio.chunks(1024) {
            for event in decoder.process_samples(block) {
                if let SstvEvent::Complete(image) = event {
                    got = Some(image);
                }
            }
        }
        let image = got.expect("no image decoded");
        let mut canvas = ImageCanvas::new(w, h);
        for y in 0..h {
            canvas.put_row(y, &image.rgb[y * w * 3..(y + 1) * w * 3]);
        }
        std::fs::write(
            format!("{dir}/{name}-decoded.png"),
            canvas.to_png().expect("png"),
        )
        .expect("write");
        println!(
            "{}: {} lines, complete={}",
            mode.name, image.lines, image.complete
        );
    }
 }
@@ -1,17 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! SSTV decoder configuration.
 /// Settings for [`crate::decoder::SstvDecoder`].
 #[derive(Debug, Clone, Default)]
 pub struct SstvConfig {
    /// VIS code of a mode to assume when no header is heard, so tuning in
    /// part-way through a transmission still produces a picture. `None` means
    /// wait for a header, which is the safe default: guessing wrong yields a
    /// convincing image of nothing.
    pub force_mode: Option<u8>,
    /// Directory for saved PNGs. `None` keeps images in memory only.
    pub output_dir: Option<String>,
 }
@@ -1,659 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! The decoder: audio in, pictures out.
 //!
 //! Reception is a small state machine. It listens for a VIS header, and once
 //! one names a mode it walks the transmission a line at a time, sampling each
 //! scan at the offsets the mode's segment list gives. Every line is looked for
 //! at the time the mode says it should arrive, then nudged into place by the
 //! sync pulse actually found near it — a transmitter's clock and a receiver's
 //! sound card never agree exactly, and over two minutes of Martin M1 an
 //! uncorrected error of a few parts per million visibly shears the picture.
 //!
 //! Rows are emitted as they are decoded so a picture can be watched arriving,
 //! which is most of the appeal of the mode.
 use crate::config::SstvConfig;
 use crate::demod::FreqDemod;
 use crate::image::ImageCanvas;
 use crate::mode::{level_from_hz, mode_for_vis, Channel, ColorModel, SstvMode};
 use crate::vis::find_vis;
 /// Anything below this is the sync pulse rather than picture: black is 1500 Hz
 /// and sync is 1200 Hz, so the line sits between them.
 const SYNC_THRESHOLD_HZ: f32 = 1350.0;
 /// How much of the signal to keep while hunting for a header. A header is 940
 /// ms; two seconds leaves room for one to straddle several blocks of audio.
 const SEARCH_HISTORY_MS: f64 = 2000.0;
 /// From the start bit to the end of the stop bit: ten 30 ms cells. A header
 /// search must never retire a stretch shorter than this, or a start bit split
 /// across two blocks of audio is dismissed on half a view of it.
 const HEADER_SPAN_MS: f64 = 330.0;
 /// How far from its predicted position a line's sync pulse is looked for.
 const SYNC_SEARCH_MS: f64 = 12.0;
 /// Fraction of the observed timing error applied to the next line. Damped,
 /// because a sync pulse found in noise is worth less than the prediction.
 const SYNC_CORRECTION: f64 = 0.45;
 /// Consecutive lines with no sync pulse anywhere near the prediction before
 /// the transmission is taken to have ended.
 const MISSING_SYNC_LIMIT: u32 = 8;
 /// What the decoder has to say.
 #[derive(Debug, Clone)]
 pub enum SstvEvent {
    /// A header was decoded and reception has begun.
    Started {
        vis: u8,
        mode: &'static str,
        width: u16,
        height: u16,
    },
    /// One image row is ready, as RGB triples.
    Row { line: u16, rgb: Vec<u8> },
    /// Reception finished — at the bottom of the frame, or because the signal
    /// went away. Carries the picture either way.
    Complete(SstvImage),
 }
 /// A received picture.
 #[derive(Debug, Clone)]
 pub struct SstvImage {
    pub vis: u8,
    pub mode: &'static str,
    pub width: u16,
    pub height: u16,
    /// Rows actually received, which is the height only if it ran to the end.
    pub lines: u16,
    /// Whether the whole frame arrived.
    pub complete: bool,
    /// RGB triples, `width * height * 3` bytes. Rows never received are grey.
    pub rgb: Vec<u8>,
    /// When reception started, in milliseconds since the epoch.
    pub started_ms: i64,
 }
 impl SstvImage {
    /// The picture as a canvas, for saving or encoding.
    pub fn canvas(&self) -> ImageCanvas {
        let width = usize::from(self.width);
        let mut canvas = ImageCanvas::new(width, usize::from(self.height));
        for (y, row) in self.rgb.chunks(width * 3).enumerate() {
            canvas.put_row(y, row);
        }
        canvas
    }
    /// The picture as PNG bytes.
    pub fn to_png(&self) -> Result<Vec<u8>, String> {
        self.canvas().to_png()
    }
    /// The picture as a base64 PNG, for the journey to a client.
    pub fn to_png_base64(&self) -> Result<String, String> {
        self.canvas().to_png_base64()
    }
    /// Write the picture into `dir`, named for when and where it arrived.
    pub fn save_png(
        &self,
        dir: &std::path::Path,
        freq_hz: u64,
    ) -> Result<std::path::PathBuf, String> {
        self.canvas()
            .save_png(dir, freq_hz, self.mode, &stamp(self.started_ms))
    }
 }
 /// `YYYYMMDDTHHMMSSZ` for a millisecond timestamp, for file names that sort.
 fn stamp(ms: i64) -> String {
    let secs = ms.div_euclid(1000);
    let (days, rest) = (secs.div_euclid(86_400), secs.rem_euclid(86_400));
    let (year, month, day) = civil_from_days(days);
    let (hour, minute, second) = (rest / 3600, (rest % 3600) / 60, rest % 60);
    format!("{year:04}{month:02}{day:02}T{hour:02}{minute:02}{second:02}Z")
 }
 /// Days since the Unix epoch to a calendar date (Howard Hinnant's algorithm).
 fn civil_from_days(days: i64) -> (i64, u32, u32) {
    let z = days + 719_468;
    let era = z.div_euclid(146_097);
    let doe = z.rem_euclid(146_097);
    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
    let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
    (if m <= 2 { y + 1 } else { y }, m, d)
 }
 enum State {
    /// Listening for a header.
    Searching,
    Receiving(Box<Reception>),
 }
 struct Reception {
    mode: &'static SstvMode,
    canvas: ImageCanvas,
    /// Absolute sample index at which the next transmitted line begins.
    next_line: f64,
    /// Next image row to write.
    row: u16,
    started_ms: i64,
    missing_syncs: u32,
    /// Set until the first line has been decoded. A VIS header ends exactly
    /// where the picture begins, so the first line is already aligned — and a
    /// search would find the header's own 30 ms stop bit, which is at the sync
    /// frequency and sits immediately before the picture.
    first_line: bool,
    /// Robot 36 sends one chroma channel per line and expects the decoder to
    /// carry the other over from the line before.
    last_chroma_r: Option<Vec<u8>>,
    last_chroma_b: Option<Vec<u8>>,
 }
 pub struct SstvDecoder {
    sample_rate: u32,
    config: SstvConfig,
    demod: FreqDemod,
    /// Instantaneous frequency, one entry per audio sample. Delayed by the
    /// demodulator's group delay, which is constant and so shifts the whole
    /// stream — header and lines alike — without disturbing their spacing.
    freqs: Vec<f32>,
    /// Absolute index of `freqs[0]`, so positions survive the buffer being
    /// trimmed.
    base: u64,
    /// Absolute index the header search has already covered.
    searched_to: u64,
    state: State,
 }
 impl SstvDecoder {
    pub fn new(sample_rate: u32, config: SstvConfig) -> Self {
        Self {
            sample_rate,
            config,
            demod: FreqDemod::new(sample_rate),
            freqs: Vec::new(),
            base: 0,
            searched_to: 0,
            state: State::Searching,
        }
    }
    /// Whether a picture is currently arriving.
    pub fn is_receiving(&self) -> bool {
        matches!(self.state, State::Receiving(_))
    }
    /// Feed a block of mono audio. Returns whatever it produced.
    pub fn process_samples(&mut self, samples: &[f32]) -> Vec<SstvEvent> {
        self.demod.process_into(samples, &mut self.freqs);
        let mut events = Vec::new();
        loop {
            let progressed = match self.state {
                State::Searching => self.try_start(&mut events),
                State::Receiving(_) => self.try_line(&mut events),
            };
            if !progressed {
                break;
            }
        }
        self.trim();
        events
    }
    /// Abandon a reception in progress, returning the picture so far.
    pub fn reset(&mut self) -> Vec<SstvEvent> {
        let mut events = Vec::new();
        if let State::Receiving(reception) = std::mem::replace(&mut self.state, State::Searching) {
            events.push(SstvEvent::Complete(finish(&reception)));
        }
        self.demod.reset();
        self.freqs.clear();
        self.base = 0;
        self.searched_to = 0;
        events
    }
    /// Look for a header, or for a bare sync pulse when the mode is forced.
    fn try_start(&mut self, events: &mut Vec<SstvEvent>) -> bool {
        let from = self.searched_to.saturating_sub(self.base) as usize;
        if from >= self.freqs.len() {
            return false;
        }
        if let Some(hit) = find_vis(&self.freqs, self.sample_rate, from) {
            if let Some(mode) = mode_for_vis(hit.code) {
                self.begin(mode, self.base + hit.image_start as u64, events);
                return true;
            }
            // A header that parses but names a mode this decoder does not know
            // is still a header: skip past it rather than finding it again.
            tracing::debug!(vis = hit.code, "SSTV: unsupported mode");
            self.searched_to = self.base + hit.image_start as u64;
            return true;
        }
        // Tuning in mid-transmission means no header to find. With a mode
        // named in the configuration, the first sync pulse is enough to start.
        if let Some(mode) = self.config.force_mode.and_then(mode_for_vis) {
            if let Some(sync) = self.find_sync(from, self.freqs.len(), mode) {
                let line_start = (self.base + sync as u64) as f64
                    - ms_to_samples(mode.sync_offset_ms, self.sample_rate);
                self.begin_at(mode, line_start.max(0.0), events);
                return true;
            }
        }
        // Nothing yet. Rewind the cursor by a header's worth of samples before
        // marking the buffer searched: audio arrives in blocks of a few
        // milliseconds, so the search regularly runs over a start bit that is
        // only half here. Advancing past it would retire the header for good
        // on the strength of a partial view of it.
        let unsearchable = ms_to_samples(HEADER_SPAN_MS, self.sample_rate) as u64;
        let end = self.base + self.freqs.len() as u64;
        self.searched_to = self.searched_to.max(end.saturating_sub(unsearchable));
        false
    }
    fn begin(&mut self, mode: &'static SstvMode, image_start: u64, events: &mut Vec<SstvEvent>) {
        self.begin_at(mode, image_start as f64, events);
    }
    fn begin_at(&mut self, mode: &'static SstvMode, line_start: f64, events: &mut Vec<SstvEvent>) {
        events.push(SstvEvent::Started {
            vis: mode.vis,
            mode: mode.name,
            width: mode.width,
            height: mode.height,
        });
        self.state = State::Receiving(Box::new(Reception {
            mode,
            canvas: ImageCanvas::new(usize::from(mode.width), usize::from(mode.height)),
            next_line: line_start,
            row: 0,
            started_ms: now_ms(),
            missing_syncs: 0,
            first_line: true,
            last_chroma_r: None,
            last_chroma_b: None,
        }));
    }
    /// Decode one transmitted line, if all of it has arrived.
    fn try_line(&mut self, events: &mut Vec<SstvEvent>) -> bool {
        let State::Receiving(reception) = &mut self.state else {
            return false;
        };
        let mode = reception.mode;
        let line_samples = ms_to_samples(mode.line_ms, self.sample_rate);
        let margin = ms_to_samples(SYNC_SEARCH_MS, self.sample_rate);
        let start = reception.next_line;
        // Enough for the line's own scans, and for the sync search to reach as
        // far ahead as it looks — no further. Demanding the search margin past
        // the end of every line would cost the last line of every picture,
        // which is exactly where the transmission stops.
        let sync_reach = start + ms_to_samples(mode.sync_offset_ms, self.sample_rate) + margin;
        let end = (start + line_samples).max(sync_reach);
        let available = (self.base + self.freqs.len() as u64) as f64;
        if end > available {
            return false;
        }
        // The line may begin before what is still buffered if the caller fed a
        // huge block; nothing can be done about that but skip forward.
        if start < self.base as f64 {
            reception.next_line = self.base as f64;
            return true;
        }
        // Line up on the sync pulse near where this line is predicted to be.
        let expected_sync = start + ms_to_samples(mode.sync_offset_ms, self.sample_rate);
        let from = (expected_sync - margin).max(self.base as f64) as u64;
        let to = (expected_sync + margin) as u64;
        let searching = !matches!(&self.state, State::Receiving(r) if r.first_line);
        let found = if searching {
            self.find_sync_between(from, to, mode)
        } else {
            None
        };
        let State::Receiving(reception) = &mut self.state else {
            return false;
        };
        let start = match found {
            Some(sync_at) => {
                reception.missing_syncs = 0;
                let error = sync_at as f64 - expected_sync;
                reception.next_line += error * SYNC_CORRECTION;
                reception.next_line
            }
            None if reception.first_line => start,
            None => {
                reception.missing_syncs += 1;
                start
            }
        };
        if reception.missing_syncs >= MISSING_SYNC_LIMIT {
            let image = finish(reception);
            self.state = State::Searching;
            self.searched_to = self.base + self.freqs.len() as u64;
            events.push(SstvEvent::Complete(image));
            return true;
        }
        // Sample every scan of the line, then colour the rows.
        let mut scans: Vec<(Channel, Vec<u8>)> = Vec::new();
        for (channel, offset_ms, ms) in mode.scans() {
            let pixels = mode.scan_pixels(channel);
            let at = start + ms_to_samples(offset_ms, self.sample_rate);
            let values = sample_scan(&self.freqs, self.base, at, ms, pixels, self.sample_rate);
            scans.push((channel, values));
        }
        let State::Receiving(reception) = &mut self.state else {
            return false;
        };
        let rows = compose_rows(reception, &scans);
        for (offset, row) in rows.into_iter().enumerate() {
            let line = reception.row + offset as u16;
            reception.canvas.put_row(usize::from(line), &row);
            events.push(SstvEvent::Row { line, rgb: row });
        }
        reception.first_line = false;
        reception.row += mode.lines_per_transmission;
        reception.next_line += line_samples;
        if reception.row >= mode.height {
            let image = finish(reception);
            self.state = State::Searching;
            self.searched_to = self.base + self.freqs.len() as u64;
            events.push(SstvEvent::Complete(image));
        }
        true
    }
    /// First sync pulse of about the right length in `freqs[from..to]`,
    /// as an index of its leading edge.
    ///
    /// Works on a smoothed copy of the window: a sync pulse is 1200 Hz, where
    /// the raw per-sample estimate swings by ±95 Hz, so single samples cross
    /// and re-cross the threshold throughout a pulse and no run is ever long
    /// enough. Pixels are sampled from the raw signal, where averaging over
    /// the pixel does the same job without blurring across its edges.
    fn find_sync(&self, from: usize, to: usize, mode: &SstvMode) -> Option<usize> {
        let want = sync_ms(mode);
        let min_run = (ms_to_samples(want, self.sample_rate) * 0.6) as usize;
        // A sync pulse ends. Silence and a dead carrier demodulate to near
        // zero, which is below the threshold too, and without an upper bound a
        // decoder left running on an empty channel finds sync everywhere and
        // fills the picture with noise it invented.
        let max_run = (ms_to_samples(want, self.sample_rate) * 3.0) as usize;
        let to = to.min(self.freqs.len());
        if from >= to {
            return None;
        }
        // Reach past the end of the search window by a whole pulse: a sync
        // starting at the last moment the window allows still has to be
        // measurable to its full length, or it is rejected for being short and
        // the line it belongs to goes unaligned.
        let pad = ms_to_samples(want + 2.0, self.sample_rate) as usize;
        let window_from = from.saturating_sub(pad);
        let window_to = (to + pad).min(self.freqs.len());
        let smoothed = crate::demod::smooth(
            &self.freqs[window_from..window_to],
            ms_to_samples(1.0, self.sample_rate) as usize,
        );
        let mut i = from - window_from;
        let scan_to = to - window_from;
        while i < scan_to {
            if smoothed[i] >= SYNC_THRESHOLD_HZ {
                i += 1;
                continue;
            }
            let mut run = 0;
            while i + run < smoothed.len() && smoothed[i + run] < SYNC_THRESHOLD_HZ {
                run += 1;
            }
            if run >= min_run && run <= max_run {
                return Some(window_from + i);
            }
            i += run.max(1);
        }
        None
    }
    /// As [`Self::find_sync`], over an absolute index range.
    fn find_sync_between(&self, from: u64, to: u64, mode: &SstvMode) -> Option<u64> {
        let from = from.saturating_sub(self.base) as usize;
        let to = to.saturating_sub(self.base) as usize;
        if from >= self.freqs.len() {
            return None;
        }
        self.find_sync(from, to, mode)
            .map(|at| self.base + at as u64)
    }
    /// Drop what is behind the decoder, so a long reception does not grow the
    /// buffer without bound.
    fn trim(&mut self) {
        let keep_from = match &self.state {
            State::Searching => {
                let history = ms_to_samples(SEARCH_HISTORY_MS, self.sample_rate) as u64;
                (self.base + self.freqs.len() as u64).saturating_sub(history)
            }
            State::Receiving(reception) => {
                let margin = ms_to_samples(SYNC_SEARCH_MS * 2.0, self.sample_rate) as u64;
                (reception.next_line as u64).saturating_sub(margin)
            }
        };
        if keep_from <= self.base {
            return;
        }
        let drop = (keep_from - self.base) as usize;
        if drop >= self.freqs.len() {
            self.freqs.clear();
        } else {
            self.freqs.drain(..drop);
        }
        self.base = keep_from;
        self.searched_to = self.searched_to.max(self.base);
    }
 }
 /// The sync pulse length of a mode, read out of its own segment list.
 fn sync_ms(mode: &SstvMode) -> f64 {
    mode.segments
        .iter()
        .find_map(|segment| match segment {
            crate::mode::Segment::Sync(ms) => Some(*ms),
            _ => None,
        })
        .unwrap_or(9.0)
 }
 /// Milliseconds since the epoch, for stamping a picture with when it arrived.
 fn now_ms() -> i64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_millis() as i64
 }
 fn ms_to_samples(ms: f64, sample_rate: u32) -> f64 {
    ms / 1000.0 * f64::from(sample_rate)
 }
 /// Average the frequency across each pixel's window and turn it into a level.
 ///
 /// The middle 60% of the window is used: a pixel's edges carry the
 /// demodulator's transition from the pixel before, and including them smears
 /// every edge in the picture.
 fn sample_scan(
    freqs: &[f32],
    base: u64,
    start: f64,
    ms: f64,
    pixels: usize,
    sample_rate: u32,
 ) -> Vec<u8> {
    let mut out = Vec::with_capacity(pixels);
    let width = ms_to_samples(ms, sample_rate) / pixels as f64;
    for x in 0..pixels {
        let pixel_start = start + width * x as f64;
        let from = (pixel_start + width * 0.2 - base as f64).max(0.0) as usize;
        let to = ((pixel_start + width * 0.8 - base as f64).max(0.0) as usize).min(freqs.len());
        // A pixel narrower than a sample still has to produce one.
        let (from, to) = if to > from {
            (from, to)
        } else {
            let at = (pixel_start - base as f64).max(0.0) as usize;
            (
                at.min(freqs.len().saturating_sub(1)),
                (at + 1).min(freqs.len()),
            )
        };
        if to <= from {
            out.push(0);
            continue;
        }
        let window = &freqs[from..to];
        let mean = window.iter().sum::<f32>() / window.len() as f32;
        out.push(level_from_hz(mean));
    }
    out
 }
 /// Turn one line's scans into image rows.
 fn compose_rows(reception: &mut Reception, scans: &[(Channel, Vec<u8>)]) -> Vec<Vec<u8>> {
    let mode = reception.mode;
    let width = usize::from(mode.width);
    let find = |channel: Channel| scans.iter().find(|(c, _)| *c == channel).map(|(_, v)| v);
    match mode.color {
        ColorModel::Rgb => {
            let red = find(Channel::Red);
            let green = find(Channel::Green);
            let blue = find(Channel::Blue);
            let mut row = vec![0u8; width * 3];
            for x in 0..width {
                row[x * 3] = red.and_then(|c| c.get(x).copied()).unwrap_or(0);
                row[x * 3 + 1] = green.and_then(|c| c.get(x).copied()).unwrap_or(0);
                row[x * 3 + 2] = blue.and_then(|c| c.get(x).copied()).unwrap_or(0);
            }
            vec![row]
        }
        ColorModel::YCrCb => {
            let luma = find(Channel::LumaOdd).cloned().unwrap_or_default();
            let cr = find(Channel::ChromaR).cloned().unwrap_or_default();
            let cb = find(Channel::ChromaB).cloned().unwrap_or_default();
            vec![ycrcb_row(&luma, &cr, &cb, width)]
        }
        ColorModel::YCrCbAlternating => {
            // This line carries one chroma channel; the other is the one from
            // the line before, which is what the mode expects a decoder to do.
            let luma = find(Channel::LumaOdd).cloned().unwrap_or_default();
            let chroma = find(Channel::ChromaAlternating)
                .cloned()
                .unwrap_or_default();
            if reception.row.is_multiple_of(2) {
                reception.last_chroma_r = Some(chroma);
            } else {
                reception.last_chroma_b = Some(chroma);
            }
            let neutral = vec![128u8; luma.len().max(1) / 2];
            let cr = reception
                .last_chroma_r
                .clone()
                .unwrap_or_else(|| neutral.clone());
            let cb = reception.last_chroma_b.clone().unwrap_or(neutral);
            vec![ycrcb_row(&luma, &cr, &cb, width)]
        }
        ColorModel::YCrCbPaired => {
            let odd = find(Channel::LumaOdd).cloned().unwrap_or_default();
            let even = find(Channel::LumaEven).cloned().unwrap_or_default();
            let cr = find(Channel::ChromaR).cloned().unwrap_or_default();
            let cb = find(Channel::ChromaB).cloned().unwrap_or_default();
            vec![
                ycrcb_row(&odd, &cr, &cb, width),
                ycrcb_row(&even, &cr, &cb, width),
            ]
        }
    }
 }
 /// One RGB row from luminance and chrominance, stretching the chroma scans
 /// across the width when they are narrower than it.
 fn ycrcb_row(luma: &[u8], cr: &[u8], cb: &[u8], width: usize) -> Vec<u8> {
    let mut row = vec![0u8; width * 3];
    let pick = |channel: &[u8], x: usize| -> f32 {
        if channel.is_empty() {
            return 128.0;
        }
        let at = x * channel.len() / width.max(1);
        f32::from(channel[at.min(channel.len() - 1)])
    };
    for x in 0..width {
        let y = if luma.is_empty() {
            0.0
        } else {
            let at = x * luma.len() / width.max(1);
            f32::from(luma[at.min(luma.len() - 1)])
        };
        let (r, g, b) = ycrcb_to_rgb(y, pick(cr, x), pick(cb, x));
        row[x * 3] = r;
        row[x * 3 + 1] = g;
        row[x * 3 + 2] = b;
    }
    row
 }
 /// The inverse of the studio-swing conversion SSTV encoders use.
 fn ycrcb_to_rgb(y: f32, cr: f32, cb: f32) -> (u8, u8, u8) {
    let r = 298.082 * y / 256.0 + 408.583 * cr / 256.0 - 222.921;
    let g = 298.082 * y / 256.0 - 100.291 * cb / 256.0 - 208.120 * cr / 256.0 + 135.576;
    let b = 298.082 * y / 256.0 + 516.412 * cb / 256.0 - 276.836;
    (
        r.clamp(0.0, 255.0) as u8,
        g.clamp(0.0, 255.0) as u8,
        b.clamp(0.0, 255.0) as u8,
    )
 }
 fn finish(reception: &Reception) -> SstvImage {
    SstvImage {
        vis: reception.mode.vis,
        mode: reception.mode.name,
        width: reception.mode.width,
        height: reception.mode.height,
        lines: reception.canvas.filled_rows() as u16,
        complete: reception.row >= reception.mode.height,
        rgb: reception.canvas.rgb().to_vec(),
        started_ms: reception.started_ms,
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn file_stamps_are_utc_and_sort_in_time_order() {
        // Known instants, checked against `date -u -r <secs>`.
        assert_eq!(stamp(0), "19700101T000000Z");
        assert_eq!(stamp(1_000_000_000_000), "20010909T014640Z");
        assert_eq!(stamp(1_770_000_000_000), "20260202T024000Z");
        // Sorting the names sorts the pictures.
        assert!(stamp(1_770_000_000_000) < stamp(1_770_000_001_000));
    }
 }
@@ -1,297 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! Instantaneous frequency estimation.
 //!
 //! SSTV carries every pixel as a frequency between 1500 and 2300 Hz, and every
 //! line boundary as a 1200 Hz pulse, so one measurement serves the whole
 //! decoder: the frequency of the signal at each sample. A Hilbert transform
 //! FIR forms the analytic signal and the phase difference between consecutive
 //! samples gives the frequency.
 //!
 //! The same approach drives the WEFAX decoder, which maps the result straight
 //! to luminance. Here the frequency itself is the output, because the VIS
 //! header and the sync detector read tones far outside the pixel band.
 //!
 //! Block-based linear processing, per `docs/Optimization-Guidelines.md`: the
 //! FIR runs over a contiguous `[tail | samples]` buffer so the inner loop is
 //! straight indexing the compiler can vectorise.
 use std::f32::consts::PI;
 /// Taps for the Hilbert transform FIR. Odd, so the delay is a whole sample.
 const HILBERT_TAPS: usize = 65;
 /// Group delay of the FIR, in samples.
 const HILBERT_DELAY: usize = HILBERT_TAPS / 2;
 /// Taps for the input band-pass. Long enough to be worth having, short enough
 /// that its delay is a couple of milliseconds.
 const BANDPASS_TAPS: usize = 127;
 /// The band SSTV lives in: sync at 1200 Hz, black at 1500, white at 2300.
 const BAND_LOW_HZ: f32 = 900.0;
 const BAND_HIGH_HZ: f32 = 2700.0;
 /// Produces instantaneous frequency in Hz from real audio samples.
 pub struct FreqDemod {
    /// Band-pass, applied first. A phase-difference frequency detector answers
    /// whatever is loudest, so hiss outside the SSTV band steers the estimate
    /// even when the signal is much stronger — the picture tears rather than
    /// grows grainy. Every real decoder filters to the band first.
    bandpass: Vec<f32>,
    bandpass_tail: Vec<f32>,
    coeffs: [f32; HILBERT_TAPS],
    /// The last `HILBERT_TAPS - 1` input samples, priming the next block.
    tail: Vec<f32>,
    prev_i: f32,
    prev_q: f32,
    /// `sample_rate / 2π`, the constant turning phase step into Hz.
    hz_per_radian: f32,
 }
 impl FreqDemod {
    pub fn new(sample_rate: u32) -> Self {
        Self {
            bandpass: design_bandpass_fir(sample_rate),
            bandpass_tail: vec![0.0; BANDPASS_TAPS - 1],
            coeffs: design_hilbert_fir(),
            tail: vec![0.0; HILBERT_TAPS - 1],
            prev_i: 0.0,
            prev_q: 0.0,
            hz_per_radian: sample_rate as f32 / (2.0 * PI),
        }
    }
    /// Band-pass a block, carrying the filter's state across the seam.
    fn filter(&mut self, samples: &[f32]) -> Vec<f32> {
        let taps = BANDPASS_TAPS;
        let tail_len = taps - 1;
        let mut work = Vec::with_capacity(tail_len + samples.len());
        work.extend_from_slice(&self.bandpass_tail);
        work.extend_from_slice(samples);
        let mut out = Vec::with_capacity(samples.len());
        for i in 0..samples.len() {
            let window = &work[i..i + taps];
            let mut acc = 0.0f32;
            for k in 0..taps {
                acc += self.bandpass[k] * window[taps - 1 - k];
            }
            out.push(acc);
        }
        let work_len = work.len();
        self.bandpass_tail
            .copy_from_slice(&work[work_len - tail_len..]);
        out
    }
    /// Frequency in Hz for each input sample, appended to `out`.
    ///
    /// Output is delayed by the FIR's group delay, which is constant and so
    /// affects only the absolute timing of the whole stream, not the spacing
    /// between the events in it.
    pub fn process_into(&mut self, samples: &[f32], out: &mut Vec<f32>) {
        if samples.is_empty() {
            return;
        }
        let samples = self.filter(samples);
        let samples = samples.as_slice();
        let taps = HILBERT_TAPS;
        let tail_len = taps - 1;
        let mut work = Vec::with_capacity(tail_len + samples.len());
        work.extend_from_slice(&self.tail);
        work.extend_from_slice(samples);
        out.reserve(samples.len());
        for i in 0..samples.len() {
            let window = &work[i..i + taps];
            let mut q = 0.0f32;
            for k in 0..taps {
                q += self.coeffs[k] * window[taps - 1 - k];
            }
            // In phase with the quadrature output: the input, delayed by the
            // FIR's own group delay.
            let i_val = window[HILBERT_DELAY];
            // f = |arg(z[n] · conj(z[n-1]))| · fs / 2π
            let di = i_val * self.prev_i + q * self.prev_q;
            let dq = q * self.prev_i - i_val * self.prev_q;
            out.push(dq.atan2(di).abs() * self.hz_per_radian);
            self.prev_i = i_val;
            self.prev_q = q;
        }
        let work_len = work.len();
        self.tail.copy_from_slice(&work[work_len - tail_len..]);
    }
    pub fn reset(&mut self) {
        self.bandpass_tail.fill(0.0);
        self.tail.fill(0.0);
        self.prev_i = 0.0;
        self.prev_q = 0.0;
    }
 }
 /// Boxcar mean over `window` samples, centred, returning one value per input.
 ///
 /// The per-sample estimate ripples — badly at the low end of the band, where
 /// the Hilbert approximation is weakest: a clean 1200 Hz tone reads anywhere
 /// between 1110 and 1300 Hz sample to sample, though its mean is exact. Pixels
 /// are averaged over their own window and so come out right regardless, but
 /// anything that classifies a single sample by frequency — the VIS bits, the
 /// sync pulses — has to look at a mean or it is reading the ripple.
 pub fn smooth(freqs: &[f32], window: usize) -> Vec<f32> {
    let window = window.max(1);
    if freqs.is_empty() {
        return Vec::new();
    }
    // Prefix sums in f64: a minute of audio is three million samples, and a
    // running f32 total drifts long before that.
    let mut prefix = Vec::with_capacity(freqs.len() + 1);
    prefix.push(0.0f64);
    for &freq in freqs {
        prefix.push(prefix[prefix.len() - 1] + f64::from(freq));
    }
    let half = window / 2;
    (0..freqs.len())
        .map(|i| {
            // Shrinks at the ends rather than reaching past them.
            let from = i.saturating_sub(half);
            let to = (i + window - half).min(freqs.len());
            ((prefix[to] - prefix[from]) / (to - from) as f64) as f32
        })
        .collect()
 }
 /// Windowed-sinc band-pass over the SSTV band, Hamming-windowed and
 /// linear-phase, so every frequency in the band is delayed alike.
 fn design_bandpass_fir(sample_rate: u32) -> Vec<f32> {
    let sr = sample_rate as f64;
    let low = f64::from(BAND_LOW_HZ) / sr;
    let high = (f64::from(BAND_HIGH_HZ) / sr).min(0.499);
    let m = (BANDPASS_TAPS - 1) as f64;
    let mid = m / 2.0;
    let sinc = |x: f64| {
        if x.abs() < 1e-9 {
            1.0
        } else {
            (std::f64::consts::PI * x).sin() / (std::f64::consts::PI * x)
        }
    };
    let mut coeffs = Vec::with_capacity(BANDPASS_TAPS);
    for i in 0..BANDPASS_TAPS {
        let n = i as f64 - mid;
        // Difference of two low-passes is a band-pass.
        let ideal = 2.0 * high * sinc(2.0 * high * n) - 2.0 * low * sinc(2.0 * low * n);
        let window = 0.54 - 0.46 * (2.0 * std::f64::consts::PI * i as f64 / m).cos();
        coeffs.push((ideal * window) as f32);
    }
    coeffs
 }
 /// Type III FIR approximating a 90° phase shift: h[n] = 2/(πn) for odd n,
 /// Blackman-windowed. Independent of sample rate, so the decoder can run at
 /// whatever rate the audio arrives in.
 fn design_hilbert_fir() -> [f32; HILBERT_TAPS] {
    let mut coeffs = [0.0f32; HILBERT_TAPS];
    let m = (HILBERT_TAPS - 1) as f64;
    let mid = m / 2.0;
    for (i, coeff) in coeffs.iter_mut().enumerate() {
        let n = i as f64 - mid;
        let ni = n.round() as i64;
        if ni != 0 && ni % 2 != 0 {
            let h = 2.0 / (std::f64::consts::PI * n);
            let w = 0.42 - 0.5 * (2.0 * std::f64::consts::PI * i as f64 / m).cos()
                + 0.08 * (4.0 * std::f64::consts::PI * i as f64 / m).cos();
            *coeff = (h * w) as f32;
        }
    }
    coeffs
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn tone(freq: f32, sample_rate: u32, samples: usize) -> Vec<f32> {
        (0..samples)
            .map(|n| (2.0 * PI * freq * n as f32 / sample_rate as f32).sin())
            .collect()
    }
    /// Measured on the settled part of the output: the first `HILBERT_TAPS`
    /// samples are the filter filling up.
    fn measure(freq: f32, sample_rate: u32) -> f32 {
        let mut demod = FreqDemod::new(sample_rate);
        let mut out = Vec::new();
        demod.process_into(
            &tone(freq, sample_rate, sample_rate as usize / 10),
            &mut out,
        );
        let settled = &out[HILBERT_TAPS * 2..];
        settled.iter().sum::<f32>() / settled.len() as f32
    }
    #[test]
    fn reads_the_tones_sstv_is_made_of() {
        for rate in [8000u32, 11025, 44100, 48000] {
            for freq in [1200.0f32, 1500.0, 1900.0, 2300.0] {
                let measured = measure(freq, rate);
                assert!(
                    (measured - freq).abs() < 5.0,
                    "{rate} Hz: {freq} Hz tone measured as {measured:.1} Hz",
                );
            }
        }
    }
    /// Blocks are whatever size the audio pipeline hands over, and a tone that
    /// straddles two of them must not produce a discontinuity at the seam.
    #[test]
    fn block_boundaries_do_not_disturb_the_estimate() {
        let rate = 48_000;
        let samples = tone(1900.0, rate, 9600);
        let mut whole = FreqDemod::new(rate);
        let mut expected = Vec::new();
        whole.process_into(&samples, &mut expected);
        let mut split = FreqDemod::new(rate);
        let mut actual = Vec::new();
        for chunk in samples.chunks(137) {
            split.process_into(chunk, &mut actual);
        }
        assert_eq!(actual.len(), expected.len());
        for (i, (a, b)) in actual.iter().zip(&expected).enumerate() {
            assert!((a - b).abs() < 0.01, "sample {i}: {a} vs {b}");
        }
    }
    #[test]
    fn follows_a_step_between_tones_within_a_pixel() {
        let rate = 48_000;
        let mut samples = tone(1500.0, rate, 4800);
        samples.extend(tone(2300.0, rate, 4800));
        let mut demod = FreqDemod::new(rate);
        let mut out = Vec::new();
        demod.process_into(&samples, &mut out);
        // Well before the step it reads black; well after it, white. The step
        // itself takes the filter's length to pass through.
        let before = out[4800 - 200..4800 - 100].iter().sum::<f32>() / 100.0;
        let after = out[4800 + 200..4800 + 300].iter().sum::<f32>() / 100.0;
        assert!(
            (before - 1500.0).abs() < 10.0,
            "before the step: {before:.1} Hz"
        );
        assert!(
            (after - 2300.0).abs() < 10.0,
            "after the step: {after:.1} Hz"
        );
    }
 }
@@ -1,238 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! Turning an image into an SSTV signal.
 //!
 //! This exists so the decoder can be held to a picture rather than to a
 //! description of one: the tests encode a known image, decode the audio back
 //! and compare. Nothing in the receive path uses it.
 //!
 //! It is written to the same mode table the decoder reads, which makes a
 //! round-trip a test of the decoder and not of the timings — the timings are
 //! checked separately, against the published line durations, in [`crate::mode`].
 use crate::mode::{Channel, Segment, SstvMode, BLACK_HZ, SYNC_HZ, WHITE_HZ};
 /// A stretch of constant tone.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Tone {
    pub hz: f32,
    pub ms: f64,
 }
 /// Frequency for an 8-bit level: the inverse of [`crate::mode::level_from_hz`].
 pub fn hz_from_level(level: u8) -> f32 {
    BLACK_HZ + (WHITE_HZ - BLACK_HZ) * f32::from(level) / 255.0
 }
 /// The tones of a VIS header announcing `vis`.
 pub fn vis_tones(vis: u8) -> Vec<Tone> {
    let mut tones = vec![
        Tone {
            hz: 1900.0,
            ms: 300.0,
        },
        Tone {
            hz: 1200.0,
            ms: 10.0,
        },
        Tone {
            hz: 1900.0,
            ms: 300.0,
        },
        Tone {
            hz: 1200.0,
            ms: 30.0,
        }, // start bit
    ];
    let mut ones = 0;
    for bit in 0..7 {
        let set = vis & (1 << bit) != 0;
        if set {
            ones += 1;
        }
        tones.push(Tone {
            hz: if set { 1100.0 } else { 1300.0 },
            ms: 30.0,
        });
    }
    // Even parity over the seven data bits.
    tones.push(Tone {
        hz: if ones % 2 == 1 { 1100.0 } else { 1300.0 },
        ms: 30.0,
    });
    tones.push(Tone {
        hz: 1200.0,
        ms: 30.0,
    }); // stop bit
    tones
 }
 /// RGB source for the encoder: `width * height * 3` bytes.
 pub struct Frame<'a> {
    pub width: usize,
    pub height: usize,
    pub rgb: &'a [u8],
 }
 impl Frame<'_> {
    fn pixel(&self, x: usize, y: usize) -> (u8, u8, u8) {
        let x = x.min(self.width.saturating_sub(1));
        let y = y.min(self.height.saturating_sub(1));
        let at = (y * self.width + x) * 3;
        (self.rgb[at], self.rgb[at + 1], self.rgb[at + 2])
    }
    /// The colour components SSTV actually sends, for a pixel.
    fn ycrcb(&self, x: usize, y: usize) -> (u8, u8, u8) {
        let (r, g, b) = self.pixel(x, y);
        let (r, g, b) = (f32::from(r), f32::from(g), f32::from(b));
        let y_val = 16.0 + (0.003_906 * ((65.738 * r) + (129.057 * g) + (25.064 * b)));
        let cr = 128.0 + (0.003_906 * ((112.439 * r) + (-94.154 * g) + (-18.285 * b)));
        let cb = 128.0 + (0.003_906 * ((-37.945 * r) + (-74.494 * g) + (112.439 * b)));
        (
            y_val.clamp(0.0, 255.0) as u8,
            cr.clamp(0.0, 255.0) as u8,
            cb.clamp(0.0, 255.0) as u8,
        )
    }
 }
 /// Encode `frame` in `mode`, returning the tones of the whole transmission.
 pub fn encode_tones(mode: &SstvMode, frame: &Frame<'_>) -> Vec<Tone> {
    let mut tones = vis_tones(mode.vis);
    let per_line = usize::from(mode.lines_per_transmission);
    let transmissions = usize::from(mode.height) / per_line;
    for transmission in 0..transmissions {
        let top = transmission * per_line;
        for segment in mode.segments {
            match *segment {
                Segment::Sync(ms) => tones.push(Tone { hz: SYNC_HZ, ms }),
                Segment::Gap(ms) => tones.push(Tone { hz: BLACK_HZ, ms }),
                Segment::Scan { channel, ms } => {
                    // A chroma scan carries fewer pixels than the image is
                    // wide, and takes proportionally less time per pixel.
                    let pixels = mode.scan_pixels(channel);
                    let pixel_ms = ms / pixels as f64;
                    for x in 0..pixels {
                        let level = channel_level(mode, frame, channel, x, top, transmission);
                        tones.push(Tone {
                            hz: hz_from_level(level),
                            ms: pixel_ms,
                        });
                    }
                }
            }
        }
    }
    tones
 }
 fn channel_level(
    mode: &SstvMode,
    frame: &Frame<'_>,
    channel: Channel,
    x: usize,
    top: usize,
    transmission: usize,
 ) -> u8 {
    match channel {
        Channel::Red => frame.pixel(x, top).0,
        Channel::Green => frame.pixel(x, top).1,
        Channel::Blue => frame.pixel(x, top).2,
        Channel::LumaOdd => frame.ycrcb(x, top).0,
        Channel::LumaEven => frame.ycrcb(x, top + 1).0,
        Channel::ChromaR => chroma(mode, frame, x, top, true),
        Channel::ChromaB => chroma(mode, frame, x, top, false),
        // Robot 36 sends R-Y on odd transmitted lines and B-Y on even ones.
        Channel::ChromaAlternating => chroma(mode, frame, x, top, transmission.is_multiple_of(2)),
    }
 }
 /// Chroma scans are half the width of the image in the Robot modes, so each
 /// value covers two pixels; PD averages the two image lines of the pair too.
 fn chroma(mode: &SstvMode, frame: &Frame<'_>, x: usize, top: usize, want_cr: bool) -> u8 {
    let scale = usize::from(mode.width) / mode.scan_pixels(Channel::ChromaR).max(1);
    let x0 = x * scale;
    let mut total = 0u32;
    let mut count = 0u32;
    let rows = usize::from(mode.lines_per_transmission);
    for row in 0..rows {
        for dx in 0..scale {
            let (_, cr, cb) = frame.ycrcb(x0 + dx, top + row);
            total += u32::from(if want_cr { cr } else { cb });
            count += 1;
        }
    }
    (total / count.max(1)) as u8
 }
 /// Render tones to audio at `sample_rate`, with continuous phase so the
 /// demodulator sees no step at a tone boundary that isn't in the signal.
 pub fn render(tones: &[Tone], sample_rate: u32) -> Vec<f32> {
    let sr = f64::from(sample_rate);
    let mut out =
        Vec::with_capacity((tones.iter().map(|t| t.ms).sum::<f64>() / 1000.0 * sr) as usize);
    let mut phase = 0.0f64;
    // Each tone's *end* is rounded to a sample, rather than its length: a
    // pixel of 25.5 samples rounded up on its own puts a whole line 600
    // samples late by the end of it, which is a timing error no receiver
    // should have to chase and no transmitter would produce.
    let mut elapsed_ms = 0.0f64;
    let mut emitted = 0usize;
    for tone in tones {
        elapsed_ms += tone.ms;
        let end = (elapsed_ms / 1000.0 * sr).round() as usize;
        let samples = end.saturating_sub(emitted);
        emitted = end;
        let step = 2.0 * std::f64::consts::PI * f64::from(tone.hz) / sr;
        for _ in 0..samples {
            out.push(phase.sin() as f32);
            phase += step;
            if phase > std::f64::consts::TAU {
                phase -= std::f64::consts::TAU;
            }
        }
    }
    out
 }
 /// Encode a frame straight to audio.
 pub fn encode(mode: &SstvMode, frame: &Frame<'_>, sample_rate: u32) -> Vec<f32> {
    render(&encode_tones(mode, frame), sample_rate)
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::mode::{level_from_hz, mode_for_vis};
    #[test]
    fn levels_survive_the_trip_through_frequency() {
        for level in [0u8, 1, 64, 128, 200, 255] {
            assert_eq!(level_from_hz(hz_from_level(level)), level);
        }
    }
    #[test]
    fn a_transmission_lasts_as_long_as_the_mode_says() {
        let mode = mode_for_vis(44).expect("Martin M1");
        let rgb = vec![128u8; 320 * 256 * 3];
        let frame = Frame {
            width: 320,
            height: 256,
            rgb: &rgb,
        };
        let audio = encode(mode, &frame, 48_000);
        // Header plus 256 lines, within a line of the published duration.
        let header_s = 0.94;
        let expected = header_s + mode.frame_secs();
        let actual = audio.len() as f64 / 48_000.0;
        assert!(
            (actual - expected).abs() < mode.line_ms / 1000.0,
            "encoded {actual:.2} s, expected {expected:.2} s",
        );
    }
 }
@@ -1,150 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! Assembling decoded lines into an image, and getting it out of the process.
 //!
 //! Rows arrive one at a time and the picture is worth looking at before it is
 //! finished, so the assembler holds a full-size RGB canvas from the start and
 //! fills it in. An unfinished frame is grey below the last decoded row rather
 //! than black, which reads as "not here yet" instead of "received as black".
 use std::path::{Path, PathBuf};
 use base64::Engine;
 /// Value the canvas starts at: mid-grey, for rows not yet received.
 const UNWRITTEN: u8 = 96;
 pub struct ImageCanvas {
    width: usize,
    height: usize,
    rgb: Vec<u8>,
    /// Highest row index written, plus one.
    filled_rows: usize,
 }
 impl ImageCanvas {
    pub fn new(width: usize, height: usize) -> Self {
        Self {
            width,
            height,
            rgb: vec![UNWRITTEN; width * height * 3],
            filled_rows: 0,
        }
    }
    pub fn width(&self) -> usize {
        self.width
    }
    pub fn height(&self) -> usize {
        self.height
    }
    /// Rows written so far.
    pub fn filled_rows(&self) -> usize {
        self.filled_rows
    }
    /// Write one row of RGB triples. Rows past the bottom of the image are
    /// dropped: a transmission that runs long is not a reason to grow.
    pub fn put_row(&mut self, y: usize, row: &[u8]) {
        if y >= self.height {
            return;
        }
        let at = y * self.width * 3;
        let take = row.len().min(self.width * 3);
        self.rgb[at..at + take].copy_from_slice(&row[..take]);
        self.filled_rows = self.filled_rows.max(y + 1);
    }
    pub fn row(&self, y: usize) -> Option<&[u8]> {
        if y >= self.height {
            return None;
        }
        let at = y * self.width * 3;
        Some(&self.rgb[at..at + self.width * 3])
    }
    pub fn rgb(&self) -> &[u8] {
        &self.rgb
    }
    /// Encode the canvas as a PNG.
    pub fn to_png(&self) -> Result<Vec<u8>, String> {
        let mut out = Vec::new();
        {
            let mut encoder = png::Encoder::new(&mut out, self.width as u32, self.height as u32);
            encoder.set_color(png::ColorType::Rgb);
            encoder.set_depth(png::BitDepth::Eight);
            let mut writer = encoder
                .write_header()
                .map_err(|e| format!("PNG header: {e}"))?;
            writer
                .write_image_data(&self.rgb)
                .map_err(|e| format!("PNG data: {e}"))?;
        }
        Ok(out)
    }
    /// The PNG, base64-encoded for the journey to a browser.
    pub fn to_png_base64(&self) -> Result<String, String> {
        Ok(base64::engine::general_purpose::STANDARD.encode(self.to_png()?))
    }
    /// Write the PNG into `dir`, named for when and where it was received.
    pub fn save_png(
        &self,
        dir: &Path,
        freq_hz: u64,
        mode_name: &str,
        stamp: &str,
    ) -> Result<PathBuf, String> {
        std::fs::create_dir_all(dir).map_err(|e| format!("create {}: {e}", dir.display()))?;
        let slug: String = mode_name
            .chars()
            .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
            .collect();
        let path = dir.join(format!("SSTV_{stamp}_{freq_hz}_{slug}.png"));
        std::fs::write(&path, self.to_png()?)
            .map_err(|e| format!("write {}: {e}", path.display()))?;
        Ok(path)
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn rows_land_where_they_are_put_and_the_rest_stays_unwritten() {
        let mut canvas = ImageCanvas::new(4, 3);
        canvas.put_row(1, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
        assert_eq!(canvas.row(1).unwrap()[0..3], [1, 2, 3]);
        assert_eq!(canvas.row(0).unwrap()[0], UNWRITTEN);
        assert_eq!(canvas.filled_rows(), 2);
    }
    #[test]
    fn a_row_past_the_bottom_is_dropped_rather_than_growing_the_image() {
        let mut canvas = ImageCanvas::new(2, 2);
        canvas.put_row(9, &[1, 2, 3, 4, 5, 6]);
        assert_eq!(canvas.filled_rows(), 0);
        assert_eq!(canvas.rgb().len(), 2 * 2 * 3);
    }
    #[test]
    fn encodes_a_png_a_decoder_can_read_back() {
        let mut canvas = ImageCanvas::new(2, 2);
        canvas.put_row(0, &[255, 0, 0, 0, 255, 0]);
        let png_bytes = canvas.to_png().expect("png");
        let decoder = png::Decoder::new(png_bytes.as_slice());
        let mut reader = decoder.read_info().expect("png info");
        let mut buf = vec![0; reader.output_buffer_size()];
        let info = reader.next_frame(&mut buf).expect("png frame");
        assert_eq!((info.width, info.height), (2, 2));
        assert_eq!(&buf[0..6], &[255, 0, 0, 0, 255, 0]);
        assert!(!canvas.to_png_base64().expect("base64").is_empty());
    }
 }
@@ -1,36 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! SSTV (Slow-Scan Television) decoder.
 //!
 //! Pure Rust, covering Martin, Scottie, Robot, PD and Wraase SC2-180, with the
 //! mode taken from the VIS header that precedes every transmission. Rows are
 //! emitted as they arrive so a picture can be watched building up.
 //!
 //! ```no_run
 //! use trx_sstv::{SstvConfig, SstvDecoder, SstvEvent};
 //!
 //! let mut decoder = SstvDecoder::new(48_000, SstvConfig::default());
 //! # let audio: Vec<f32> = Vec::new();
 //! for event in decoder.process_samples(&audio) {
 //!     match event {
 //!         SstvEvent::Started { mode, .. } => println!("receiving {mode}"),
 //!         SstvEvent::Row { line, .. } => println!("line {line}"),
 //!         SstvEvent::Complete(image) => println!("{} lines", image.lines),
 //!     }
 //! }
 //! ```
 pub mod config;
 pub mod decoder;
 pub mod demod;
 pub mod encode;
 pub mod image;
 pub mod mode;
 pub mod vis;
 pub use config::SstvConfig;
 pub use decoder::{SstvDecoder, SstvEvent, SstvImage};
 pub use image::ImageCanvas;
 pub use mode::{mode_for_vis, SstvMode, MODES};
@@ -1,615 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! SSTV mode table: what a VIS code means in timings, geometry and colour.
 //!
 //! Every mode transmits a line as a sequence of *segments* — a sync pulse, a
 //! porch or separator at a fixed tone, and one scan per colour channel. The
 //! decoder needs only the segment layout and the offset of each scan within
 //! the line, so that is what a [`SstvMode`] is: a list of segments plus the
 //! rules for turning the scans back into pixels.
 //!
 //! Timings follow the published mode specifications (JL Barber, N7CXI,
 //! "Proposal for SSTV Mode Specifications", 2000), which is the same table
 //! MMSSTV, QSSTV and slowrx work from.
 /// Tone that marks a line boundary, in Hz.
 pub const SYNC_HZ: f32 = 1200.0;
 /// Tone for black, in Hz.
 pub const BLACK_HZ: f32 = 1500.0;
 /// Tone for white, in Hz.
 pub const WHITE_HZ: f32 = 2300.0;
 /// What a scan segment carries.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Channel {
    Red,
    Green,
    Blue,
    /// Luminance for the odd (first) image line of the pair.
    LumaOdd,
    /// Luminance for the even (second) image line of a PD pair.
    LumaEven,
    /// R-Y chrominance.
    ChromaR,
    /// B-Y chrominance.
    ChromaB,
    /// Robot 36 alternates R-Y and B-Y between transmitted lines: odd lines
    /// carry R-Y, even lines B-Y, and each is held over both.
    ChromaAlternating,
 }
 /// One piece of a transmitted line.
 #[derive(Debug, Clone, Copy)]
 pub enum Segment {
    /// Sync pulse at [`SYNC_HZ`].
    Sync(f64),
    /// Porch, separator or gap at a fixed tone; the tone itself is not decoded.
    Gap(f64),
    /// A scan carrying pixels for one channel.
    Scan { channel: Channel, ms: f64 },
 }
 impl Segment {
    pub fn duration_ms(&self) -> f64 {
        match *self {
            Segment::Sync(ms) | Segment::Gap(ms) => ms,
            Segment::Scan { ms, .. } => ms,
        }
    }
 }
 /// How the scans of a line become pixels.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ColorModel {
    /// Scans are red, green and blue directly (Martin, Scottie, Wraase).
    Rgb,
    /// Y plus one alternating chroma channel per line (Robot 36).
    YCrCbAlternating,
    /// Y, R-Y and B-Y in every line (Robot 72).
    YCrCb,
    /// Two image lines per transmitted line: Y odd, R-Y, B-Y, Y even (PD).
    YCrCbPaired,
 }
 /// A decodable SSTV mode.
 #[derive(Debug, Clone)]
 pub struct SstvMode {
    /// VIS code as sent in the header.
    pub vis: u8,
    /// Human-readable name, e.g. "Martin M1".
    pub name: &'static str,
    /// Pixels across.
    pub width: u16,
    /// Image lines in a full frame.
    pub height: u16,
    /// Transmitted line duration in milliseconds.
    pub line_ms: f64,
    /// Segments in transmission order.
    pub segments: &'static [Segment],
    pub color: ColorModel,
    /// Image lines produced by one transmitted line (2 for PD, otherwise 1).
    pub lines_per_transmission: u16,
    /// Offset from the start of a line to the leading edge of its sync pulse.
    /// Zero for most modes; Scottie sends the sync in the middle of the line,
    /// so a line detected at its sync starts before it.
    pub sync_offset_ms: f64,
 }
 impl SstvMode {
    /// Total of every segment, which must equal [`SstvMode::line_ms`].
    pub fn segments_ms(&self) -> f64 {
        self.segments.iter().map(Segment::duration_ms).sum()
    }
    /// Start offset, in milliseconds from the line start, of each scan.
    pub fn scans(&self) -> Vec<(Channel, f64, f64)> {
        let mut out = Vec::new();
        let mut at = 0.0;
        for segment in self.segments {
            if let Segment::Scan { channel, ms } = *segment {
                out.push((channel, at, ms));
            }
            at += segment.duration_ms();
        }
        out
    }
    /// Pixels carried by a scan of this channel.
    ///
    /// Chroma is sent at half the width in the Robot modes — the eye takes
    /// colour more coarsely than brightness, and the saving is what makes 36
    /// seconds possible. PD sends chroma at full width and saves its time by
    /// sharing one pair of chroma scans between two image lines instead.
    pub fn scan_pixels(&self, channel: Channel) -> usize {
        let width = usize::from(self.width);
        match channel {
            Channel::ChromaR | Channel::ChromaB | Channel::ChromaAlternating
                if self.color != ColorModel::YCrCbPaired =>
            {
                width / 2
            }
            _ => width,
        }
    }
    /// Seconds a full frame takes to send.
    pub fn frame_secs(&self) -> f64 {
        self.line_ms * f64::from(self.height) / f64::from(self.lines_per_transmission) / 1000.0
    }
 }
 // ---------------------------------------------------------------------------
 // Martin — sync, porch, then green, blue, red, each followed by a separator.
 // ---------------------------------------------------------------------------
 const MARTIN_M1: &[Segment] = &[
    Segment::Sync(4.862),
    Segment::Gap(0.572),
    Segment::Scan {
        channel: Channel::Green,
        ms: 146.432,
    },
    Segment::Gap(0.572),
    Segment::Scan {
        channel: Channel::Blue,
        ms: 146.432,
    },
    Segment::Gap(0.572),
    Segment::Scan {
        channel: Channel::Red,
        ms: 146.432,
    },
    Segment::Gap(0.572),
 ];
 const MARTIN_M2: &[Segment] = &[
    Segment::Sync(4.862),
    Segment::Gap(0.572),
    Segment::Scan {
        channel: Channel::Green,
        ms: 73.216,
    },
    Segment::Gap(0.572),
    Segment::Scan {
        channel: Channel::Blue,
        ms: 73.216,
    },
    Segment::Gap(0.572),
    Segment::Scan {
        channel: Channel::Red,
        ms: 73.216,
    },
    Segment::Gap(0.572),
 ];
 // ---------------------------------------------------------------------------
 // Scottie — the sync pulse sits between the blue and red scans, so a line
 // starts one separator before the green scan and the sync of the *previous*
 // line is what marks it.
 // ---------------------------------------------------------------------------
 const SCOTTIE_S1: &[Segment] = &[
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Green,
        ms: 138.240,
    },
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Blue,
        ms: 138.240,
    },
    Segment::Sync(9.0),
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Red,
        ms: 138.240,
    },
 ];
 const SCOTTIE_S2: &[Segment] = &[
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Green,
        ms: 88.064,
    },
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Blue,
        ms: 88.064,
    },
    Segment::Sync(9.0),
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Red,
        ms: 88.064,
    },
 ];
 const SCOTTIE_DX: &[Segment] = &[
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Green,
        ms: 345.6,
    },
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Blue,
        ms: 345.6,
    },
    Segment::Sync(9.0),
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::Red,
        ms: 345.6,
    },
 ];
 /// Scottie's sync arrives after the green and blue scans: 1.5 + 138.24 + 1.5 +
 /// 138.24 for S1, and the equivalent for the others.
 const fn scottie_sync_offset(scan_ms: f64) -> f64 {
    1.5 + scan_ms + 1.5 + scan_ms
 }
 // ---------------------------------------------------------------------------
 // Robot — luminance plus chrominance, the chroma scans at half the width.
 // ---------------------------------------------------------------------------
 const ROBOT_36: &[Segment] = &[
    Segment::Sync(9.0),
    Segment::Gap(3.0),
    Segment::Scan {
        channel: Channel::LumaOdd,
        ms: 88.0,
    },
    Segment::Gap(4.5),
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::ChromaAlternating,
        ms: 44.0,
    },
 ];
 const ROBOT_72: &[Segment] = &[
    Segment::Sync(9.0),
    Segment::Gap(3.0),
    Segment::Scan {
        channel: Channel::LumaOdd,
        ms: 138.0,
    },
    Segment::Gap(4.5),
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::ChromaR,
        ms: 69.0,
    },
    Segment::Gap(4.5),
    Segment::Gap(1.5),
    Segment::Scan {
        channel: Channel::ChromaB,
        ms: 69.0,
    },
 ];
 // ---------------------------------------------------------------------------
 // PD — one transmitted line carries two image lines: the luminance of both,
 // with a single pair of chroma scans shared between them.
 // ---------------------------------------------------------------------------
 macro_rules! pd_segments {
    ($name:ident, $scan:expr) => {
        const $name: &[Segment] = &[
            Segment::Sync(20.0),
            Segment::Gap(2.08),
            Segment::Scan {
                channel: Channel::LumaOdd,
                ms: $scan,
            },
            Segment::Scan {
                channel: Channel::ChromaR,
                ms: $scan,
            },
            Segment::Scan {
                channel: Channel::ChromaB,
                ms: $scan,
            },
            Segment::Scan {
                channel: Channel::LumaEven,
                ms: $scan,
            },
        ];
    };
 }
 pd_segments!(PD_50, 91.520);
 pd_segments!(PD_90, 170.240);
 pd_segments!(PD_120, 121.600);
 pd_segments!(PD_160, 195.584);
 pd_segments!(PD_180, 183.040);
 pd_segments!(PD_240, 244.672);
 pd_segments!(PD_290, 228.800);
 // ---------------------------------------------------------------------------
 // Wraase SC2-180 — red, green, blue in that order after one porch.
 // ---------------------------------------------------------------------------
 const WRAASE_SC2_180: &[Segment] = &[
    Segment::Sync(5.5225),
    Segment::Gap(0.5),
    Segment::Scan {
        channel: Channel::Red,
        ms: 235.0,
    },
    Segment::Scan {
        channel: Channel::Green,
        ms: 235.0,
    },
    Segment::Scan {
        channel: Channel::Blue,
        ms: 235.0,
    },
 ];
 /// Every mode this decoder knows, in VIS order.
 pub static MODES: &[SstvMode] = &[
    SstvMode {
        vis: 8,
        name: "Robot 36",
        width: 320,
        height: 240,
        line_ms: 150.0,
        segments: ROBOT_36,
        color: ColorModel::YCrCbAlternating,
        lines_per_transmission: 1,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 12,
        name: "Robot 72",
        width: 320,
        height: 240,
        line_ms: 300.0,
        segments: ROBOT_72,
        color: ColorModel::YCrCb,
        lines_per_transmission: 1,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 40,
        name: "Martin M2",
        width: 320,
        height: 256,
        line_ms: 226.798,
        segments: MARTIN_M2,
        color: ColorModel::Rgb,
        lines_per_transmission: 1,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 44,
        name: "Martin M1",
        width: 320,
        height: 256,
        line_ms: 446.446,
        segments: MARTIN_M1,
        color: ColorModel::Rgb,
        lines_per_transmission: 1,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 55,
        name: "Wraase SC2-180",
        width: 320,
        height: 256,
        line_ms: 711.0225,
        segments: WRAASE_SC2_180,
        color: ColorModel::Rgb,
        lines_per_transmission: 1,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 56,
        name: "Scottie S2",
        width: 320,
        height: 256,
        line_ms: 277.692,
        segments: SCOTTIE_S2,
        color: ColorModel::Rgb,
        lines_per_transmission: 1,
        sync_offset_ms: scottie_sync_offset(88.064),
    },
    SstvMode {
        vis: 60,
        name: "Scottie S1",
        width: 320,
        height: 256,
        line_ms: 428.22,
        segments: SCOTTIE_S1,
        color: ColorModel::Rgb,
        lines_per_transmission: 1,
        sync_offset_ms: scottie_sync_offset(138.240),
    },
    SstvMode {
        vis: 76,
        name: "Scottie DX",
        width: 320,
        height: 256,
        line_ms: 1050.3,
        segments: SCOTTIE_DX,
        color: ColorModel::Rgb,
        lines_per_transmission: 1,
        sync_offset_ms: scottie_sync_offset(345.6),
    },
    SstvMode {
        vis: 93,
        name: "PD50",
        width: 320,
        height: 256,
        line_ms: 388.16,
        segments: PD_50,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 94,
        name: "PD290",
        width: 800,
        height: 616,
        line_ms: 937.28,
        segments: PD_290,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 95,
        name: "PD120",
        width: 640,
        height: 496,
        line_ms: 508.48,
        segments: PD_120,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 96,
        name: "PD180",
        width: 640,
        height: 496,
        line_ms: 754.24,
        segments: PD_180,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 97,
        name: "PD240",
        width: 640,
        height: 496,
        line_ms: 1000.768,
        segments: PD_240,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 98,
        name: "PD160",
        width: 512,
        height: 400,
        line_ms: 804.416,
        segments: PD_160,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
    SstvMode {
        vis: 99,
        name: "PD90",
        width: 320,
        height: 256,
        line_ms: 703.04,
        segments: PD_90,
        color: ColorModel::YCrCbPaired,
        lines_per_transmission: 2,
        sync_offset_ms: 0.0,
    },
 ];
 /// Look a mode up by the VIS code that announced it.
 pub fn mode_for_vis(vis: u8) -> Option<&'static SstvMode> {
    MODES.iter().find(|mode| mode.vis == vis)
 }
 /// Map an instantaneous frequency to an 8-bit level: 1500 Hz is black, 2300 Hz
 /// white. Frequencies outside the band clamp rather than wrap, so a sync pulse
 /// that lands inside a scan reads as black instead of as bright noise.
 pub fn level_from_hz(hz: f32) -> u8 {
    let level = (hz - BLACK_HZ) * (255.0 / (WHITE_HZ - BLACK_HZ));
    level.clamp(0.0, 255.0).round() as u8
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    // The segment list and the published line time are two statements of the
    // same fact, entered by hand from the specification. If a digit is wrong in
    // one it is unlikely to be wrong identically in the other.
    #[test]
    fn segments_add_up_to_the_published_line_time() {
        for mode in MODES {
            let sum = mode.segments_ms();
            assert!(
                (sum - mode.line_ms).abs() < 0.001,
                "{}: segments total {:.4} ms, line time says {:.4} ms",
                mode.name,
                sum,
                mode.line_ms,
            );
        }
    }
    #[test]
    fn vis_codes_are_unique_and_resolvable() {
        for mode in MODES {
            assert_eq!(mode_for_vis(mode.vis).map(|m| m.name), Some(mode.name));
        }
        let mut codes: Vec<u8> = MODES.iter().map(|m| m.vis).collect();
        codes.sort_unstable();
        let count = codes.len();
        codes.dedup();
        assert_eq!(codes.len(), count, "two modes claim the same VIS code");
    }
    #[test]
    fn every_mode_scans_enough_channels_for_its_colour_model() {
        for mode in MODES {
            let scans = mode.scans();
            let expected = match mode.color {
                ColorModel::Rgb => 3,
                ColorModel::YCrCbAlternating => 2,
                ColorModel::YCrCb => 3,
                ColorModel::YCrCbPaired => 4,
            };
            assert_eq!(
                scans.len(),
                expected,
                "{} has {} scans",
                mode.name,
                scans.len()
            );
        }
    }
    // Frame durations are what operators know these modes by — the number in
    // the name is the number of seconds.
    #[test]
    fn frame_durations_match_the_names() {
        for (vis, secs) in [(8u8, 36.0), (12, 72.0), (93, 50.0), (99, 90.0), (95, 126.0)] {
            let mode = mode_for_vis(vis).expect("mode in table");
            let actual = mode.frame_secs();
            assert!(
                (actual - secs).abs() < 1.5,
                "{} takes {:.1} s, expected about {:.0} s",
                mode.name,
                actual,
                secs,
            );
        }
    }
    #[test]
    fn levels_span_black_to_white_and_clamp_outside() {
        assert_eq!(level_from_hz(BLACK_HZ), 0);
        assert_eq!(level_from_hz(WHITE_HZ), 255);
        assert_eq!(level_from_hz(1900.0), 128);
        assert_eq!(level_from_hz(SYNC_HZ), 0, "a sync pulse must read as black");
        assert_eq!(level_from_hz(3000.0), 255);
    }
 }
@@ -1,236 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! VIS header detection.
 //!
 //! Every transmission announces its mode in a fixed preamble:
 //!
 //! | Part | Tone | Duration |
 //! |------|------|----------|
 //! | Leader | 1900 Hz | 300 ms |
 //! | Break | 1200 Hz | 10 ms |
 //! | Leader | 1900 Hz | 300 ms |
 //! | Start bit | 1200 Hz | 30 ms |
 //! | 7 data bits, LSB first | 1100 Hz = 1, 1300 Hz = 0 | 30 ms each |
 //! | Even parity | as above | 30 ms |
 //! | Stop bit | 1200 Hz | 30 ms |
 //!
 //! The detector looks for the start bit standing behind a leader, reads the
 //! eight bits that follow, and checks the parity. Parity is the only integrity
 //! check the header has, so a code that fails it is discarded rather than
 //! guessed at — decoding 114 seconds of Martin M1 as Scottie DX produces a
 //! convincing-looking image of nothing.
 /// Tone durations, in milliseconds.
 const BIT_MS: f64 = 30.0;
 const LEADER_MS: f64 = 300.0;
 /// How far a tone may sit from its nominal frequency and still be recognised.
 /// Wide enough for a rig tuned a little off, narrow enough that 1100, 1200,
 /// 1300 and 1900 Hz stay distinct.
 const TONE_TOLERANCE_HZ: f32 = 60.0;
 const LEADER_HZ: f32 = 1900.0;
 const START_HZ: f32 = 1200.0;
 const ONE_HZ: f32 = 1100.0;
 const ZERO_HZ: f32 = 1300.0;
 /// A VIS header found in the stream.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct VisHit {
    /// The code, which names the mode.
    pub code: u8,
    /// Index just past the stop bit: where the image itself begins.
    pub image_start: usize,
 }
 fn near(freq: f32, target: f32) -> bool {
    (freq - target).abs() <= TONE_TOLERANCE_HZ
 }
 /// Mean frequency over the middle 60% of a bit cell, which keeps the filter's
 /// transitions at either edge out of the measurement.
 fn bit_frequency(freqs: &[f32], start: f64, samples_per_bit: f64) -> Option<f32> {
    let from = (start + samples_per_bit * 0.2).round() as usize;
    let to = (start + samples_per_bit * 0.8).round() as usize;
    if to <= from || to > freqs.len() {
        return None;
    }
    let window = &freqs[from..to];
    Some(window.iter().sum::<f32>() / window.len() as f32)
 }
 /// Search `freqs` for a VIS header, starting at `from`.
 ///
 /// Returns the first header whose parity checks out. `freqs` is instantaneous
 /// frequency in Hz, one entry per audio sample.
 pub fn find_vis(freqs: &[f32], sample_rate: u32, from: usize) -> Option<VisHit> {
    let sr = f64::from(sample_rate);
    // Header tones are 10 ms at the shortest, so a millisecond of averaging
    // costs nothing and takes the demodulator's ripple — ±95 Hz at 1200 Hz —
    // out of tones that are 100 Hz apart.
    let smoothed = crate::demod::smooth(freqs, (sr / 1000.0).round() as usize);
    let freqs = smoothed.as_slice();
    let samples_per_bit = BIT_MS / 1000.0 * sr;
    let leader_samples = (LEADER_MS / 1000.0 * sr) as usize;
    // The start bit must be at least this long to be one.
    let min_start_run = (samples_per_bit * 0.7) as usize;
    // A leader has to precede the start bit. Half of one is enough evidence,
    // and asking for less than the full 300 ms means the search still works on
    // a buffer that begins part-way through the header.
    let leader_needed = leader_samples / 2;
    // The bits themselves may run to the very end of what has arrived so far;
    // reading them is what decides whether there is enough, not this bound.
    let mut i = from.max(leader_needed);
    while i < freqs.len() {
        if !near(freqs[i], START_HZ) {
            i += 1;
            continue;
        }
        // Measure the run of start tone.
        let mut run = 0usize;
        while i + run < freqs.len() && near(freqs[i + run], START_HZ) {
            run += 1;
        }
        if run < min_start_run {
            i += run.max(1);
            continue;
        }
        // What came before it: the leader. Sampled rather than scanned in
        // full, since only its identity matters, not its exact length.
        let leader_from = i - leader_needed;
        let leader_hits = freqs[leader_from..i]
            .iter()
            .step_by(16)
            .filter(|&&f| near(f, LEADER_HZ))
            .count();
        let leader_total = freqs[leader_from..i].iter().step_by(16).count();
        if leader_total == 0 || (leader_hits as f64) < 0.7 * leader_total as f64 {
            i += run;
            continue;
        }
        // Bits follow the start bit, which the run just measured. Use the run's
        // own end rather than a nominal offset, so a start bit stretched or
        // clipped by the filter does not shift every bit after it.
        let bits_start = (i + run) as f64;
        let mut bits = [false; 8];
        let mut readable = true;
        for (index, bit) in bits.iter_mut().enumerate() {
            let at = bits_start + samples_per_bit * index as f64;
            match bit_frequency(freqs, at, samples_per_bit) {
                Some(freq) if near(freq, ONE_HZ) => *bit = true,
                Some(freq) if near(freq, ZERO_HZ) => *bit = false,
                _ => {
                    readable = false;
                    break;
                }
            }
        }
        if !readable {
            i += run;
            continue;
        }
        // Seven data bits, LSB first, then even parity over them.
        let code = bits[..7]
            .iter()
            .enumerate()
            .fold(0u8, |acc, (index, &set)| acc | (u8::from(set) << index));
        let ones = bits[..7].iter().filter(|&&b| b).count() + usize::from(bits[7]);
        if ones % 2 != 0 {
            i += run;
            continue;
        }
        // Past the stop bit is the image.
        let image_start = (bits_start + samples_per_bit * 9.0).round() as usize;
        return Some(VisHit { code, image_start });
    }
    None
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::encode::{vis_tones, Tone};
    fn freqs_from_tones(tones: &[Tone], sample_rate: u32) -> Vec<f32> {
        let mut out = Vec::new();
        for tone in tones {
            let samples = (tone.ms / 1000.0 * f64::from(sample_rate)).round() as usize;
            out.extend(std::iter::repeat_n(tone.hz, samples));
        }
        out
    }
    #[test]
    fn reads_every_code_the_mode_table_knows() {
        for mode in crate::mode::MODES {
            let freqs = freqs_from_tones(&vis_tones(mode.vis), 48_000);
            let hit = find_vis(&freqs, 48_000, 0)
                .unwrap_or_else(|| panic!("{} header not found", mode.name));
            assert_eq!(
                hit.code, mode.vis,
                "{} decoded as VIS {}",
                mode.name, hit.code
            );
        }
    }
    #[test]
    fn the_image_starts_after_the_stop_bit() {
        let sample_rate = 48_000;
        let freqs = freqs_from_tones(&vis_tones(44), sample_rate);
        let hit = find_vis(&freqs, sample_rate, 0).expect("header");
        // Header is 300 + 10 + 300 ms of leader and break, then ten 30 ms bits.
        let expected = ((300.0 + 10.0 + 300.0 + 300.0) / 1000.0 * f64::from(sample_rate)) as usize;
        let slack = sample_rate as usize / 100; // 10 ms
        assert!(
            hit.image_start.abs_diff(expected) < slack,
            "image starts at {}, expected about {expected}",
            hit.image_start,
        );
    }
    #[test]
    fn a_header_with_broken_parity_is_not_a_header() {
        let sample_rate = 48_000;
        let mut tones = vis_tones(44);
        // Flip the parity bit alone: seven data bits still say Martin M1, but
        // nothing now vouches for them.
        let parity = tones.len() - 2;
        tones[parity].hz = if tones[parity].hz == ONE_HZ {
            ZERO_HZ
        } else {
            ONE_HZ
        };
        let freqs = freqs_from_tones(&tones, sample_rate);
        assert_eq!(find_vis(&freqs, sample_rate, 0), None);
    }
    #[test]
    fn tones_without_a_leader_are_not_a_header() {
        let sample_rate = 48_000;
        let mut tones = vis_tones(44);
        // Same bits, but the leader before them is a pixel-band tone — which is
        // what a passing image looks like.
        tones[0].hz = 2000.0;
        tones[2].hz = 2000.0;
        let freqs = freqs_from_tones(&tones, sample_rate);
        assert_eq!(find_vis(&freqs, sample_rate, 0), None);
    }
    #[test]
    fn a_header_part_way_into_the_buffer_is_still_found() {
        let sample_rate = 48_000;
        let mut freqs = vec![1750.0f32; sample_rate as usize]; // a second of picture
        freqs.extend(freqs_from_tones(&vis_tones(60), sample_rate));
        let hit = find_vis(&freqs, sample_rate, 0).expect("header");
        assert_eq!(hit.code, 60);
    }
 }
@@ -1,384 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 //! Decode what was encoded, and compare the pictures.
 //!
 //! A decoder for a picture format can only really be tested against a picture.
 //! These tests build a test card, transmit it in each mode through the
 //! encoder, and hold the decoder to what comes back — pixel by pixel, with a
 //! tolerance that accounts for the round trip through frequency and, for the
 //! colour modes, through a chroma channel at half the width.
 //!
 //! What this does not test is the timing table itself: the encoder reads the
 //! same numbers as the decoder, so a wrong line duration would cancel out.
 //! That is checked in `mode.rs` against the published line times instead.
 use trx_sstv::encode::{encode, Frame};
 use trx_sstv::mode::mode_for_vis;
 use trx_sstv::{SstvConfig, SstvDecoder, SstvEvent, SstvImage};
 const SAMPLE_RATE: u32 = 48_000;
 /// A test card with something for every part of the decoder to get wrong:
 /// vertical colour bars catch channels swapped or shifted, the horizontal
 /// gradient catches a line-timing drift, and the corner blocks catch a picture
 /// that arrives upside down or mirrored.
 fn test_card(width: usize, height: usize) -> Vec<u8> {
    let mut rgb = vec![0u8; width * height * 3];
    let bars: [(u8, u8, u8); 8] = [
        (255, 255, 255),
        (255, 255, 0),
        (0, 255, 255),
        (0, 255, 0),
        (255, 0, 255),
        (255, 0, 0),
        (0, 0, 255),
        (0, 0, 0),
    ];
    for y in 0..height {
        for x in 0..width {
            let at = (y * width + x) * 3;
            let (r, g, b) = if y < height / 2 {
                bars[x * bars.len() / width]
            } else {
                let ramp = (x * 255 / width.max(1)) as u8;
                let down = (y * 255 / height.max(1)) as u8;
                (ramp, down, 255 - ramp)
            };
            rgb[at] = r;
            rgb[at + 1] = g;
            rgb[at + 2] = b;
        }
    }
    // Corner marks: red top-left, blue bottom-right.
    for y in 0..height.min(8) {
        for x in 0..width.min(8) {
            let at = (y * width + x) * 3;
            rgb[at] = 255;
            rgb[at + 1] = 0;
            rgb[at + 2] = 0;
        }
    }
    for y in height.saturating_sub(8)..height {
        for x in width.saturating_sub(8)..width {
            let at = (y * width + x) * 3;
            rgb[at] = 0;
            rgb[at + 1] = 0;
            rgb[at + 2] = 255;
        }
    }
    rgb
 }
 /// Run audio through the decoder in blocks the size a sound card delivers.
 ///
 /// A little silence is fed after the signal, as a receiver that keeps
 /// listening supplies: the demodulator is a filter, so the last millisecond of
 /// any transmission needs the samples after it before it can be read.
 fn decode(audio: &[f32]) -> (Vec<SstvImage>, usize) {
    let mut tail = audio.to_vec();
    tail.extend(std::iter::repeat_n(0.0, SAMPLE_RATE as usize / 20));
    let audio = tail.as_slice();
    let mut decoder = SstvDecoder::new(SAMPLE_RATE, SstvConfig::default());
    let mut images = Vec::new();
    let mut rows = 0;
    for block in audio.chunks(1024) {
        for event in decoder.process_samples(block) {
            match event {
                SstvEvent::Row { .. } => rows += 1,
                SstvEvent::Complete(image) => images.push(image),
                SstvEvent::Started { .. } => {}
            }
        }
    }
    (images, rows)
 }
 /// Mean absolute error per colour channel between two same-sized images.
 fn mean_error(a: &[u8], b: &[u8]) -> f64 {
    assert_eq!(a.len(), b.len());
    let total: u64 = a
        .iter()
        .zip(b)
        .map(|(x, y)| u64::from(x.abs_diff(*y)))
        .sum();
    total as f64 / a.len() as f64
 }
 /// Error over the part of the picture away from channel edges, where a decoder
 /// that is a pixel out on a hard colour boundary would otherwise dominate.
 fn interior_error(mode_width: usize, height: usize, sent: &[u8], got: &[u8]) -> f64 {
    let mut total = 0u64;
    let mut count = 0u64;
    for y in 2..height.saturating_sub(2) {
        for x in 4..mode_width.saturating_sub(4) {
            // Skip the columns where the bars change, which is where a
            // half-pixel timing difference shows up as a whole-colour error.
            if x % (mode_width / 8) < 3 {
                continue;
            }
            let at = (y * mode_width + x) * 3;
            for channel in 0..3 {
                total += u64::from(sent[at + channel].abs_diff(got[at + channel]));
                count += 1;
            }
        }
    }
    total as f64 / count.max(1) as f64
 }
 fn round_trip(vis: u8, tolerance: f64) {
    let mode = mode_for_vis(vis).expect("mode in table");
    let width = usize::from(mode.width);
    let height = usize::from(mode.height);
    let sent = test_card(width, height);
    let frame = Frame {
        width,
        height,
        rgb: &sent,
    };
    let audio = encode(mode, &frame, SAMPLE_RATE);
    let (images, rows) = decode(&audio);
    assert_eq!(
        images.len(),
        1,
        "{}: expected one picture, got {}",
        mode.name,
        images.len()
    );
    let image = &images[0];
    assert!(
        image.complete,
        "{}: reception did not reach the bottom",
        mode.name
    );
    assert_eq!(image.mode, mode.name);
    assert_eq!(
        image.lines, mode.height,
        "{}: {} of {} lines",
        mode.name, image.lines, mode.height
    );
    assert_eq!(
        rows, height,
        "{}: emitted {rows} rows for {height} lines",
        mode.name
    );
    let error = interior_error(width, height, &sent, &image.rgb);
    assert!(
        error < tolerance,
        "{}: mean error {error:.1} levels, tolerance {tolerance:.1}",
        mode.name,
    );
 }
 #[test]
 fn martin_m1_round_trips() {
    round_trip(44, 6.0);
 }
 #[test]
 fn martin_m2_round_trips() {
    round_trip(40, 8.0);
 }
 #[test]
 fn scottie_s1_round_trips() {
    round_trip(60, 6.0);
 }
 #[test]
 fn scottie_s2_round_trips() {
    round_trip(56, 8.0);
 }
 #[test]
 fn wraase_sc2_180_round_trips() {
    round_trip(55, 6.0);
 }
 // The colour-difference modes lose chroma resolution by design, so the bars
 // bleed into one another at their edges; the tolerance is on the interior.
 #[test]
 fn robot_72_round_trips() {
    round_trip(12, 14.0);
 }
 #[test]
 fn robot_36_round_trips() {
    // One chroma channel per line, the other carried over from the line
    // before, so alternate lines are a line stale in one channel.
    round_trip(8, 26.0);
 }
 #[test]
 fn pd90_round_trips() {
    round_trip(99, 14.0);
 }
 #[test]
 fn pd120_round_trips() {
    round_trip(95, 14.0);
 }
 /// Silence before and after is the normal case — a receiver is not started at
 /// the instant the transmission does.
 #[test]
 fn survives_silence_around_the_transmission() {
    let mode = mode_for_vis(44).expect("Martin M1");
    let (width, height) = (usize::from(mode.width), usize::from(mode.height));
    let sent = test_card(width, height);
    let frame = Frame {
        width,
        height,
        rgb: &sent,
    };
    let mut audio = vec![0.0f32; SAMPLE_RATE as usize * 2];
    audio.extend(encode(mode, &frame, SAMPLE_RATE));
    audio.extend(std::iter::repeat_n(0.0, SAMPLE_RATE as usize));
    let (images, _) = decode(&audio);
    assert_eq!(
        images.len(),
        1,
        "expected one picture from a transmission in silence"
    );
    assert!(images[0].complete);
 }
 /// A transmission cut off part-way is what a fade or a shut-down transmitter
 /// produces. The lines that did arrive are worth keeping.
 #[test]
 fn a_truncated_transmission_still_yields_its_lines() {
    let mode = mode_for_vis(44).expect("Martin M1");
    let (width, height) = (usize::from(mode.width), usize::from(mode.height));
    let sent = test_card(width, height);
    let frame = Frame {
        width,
        height,
        rgb: &sent,
    };
    let full = encode(mode, &frame, SAMPLE_RATE);
    // Two thirds of the picture, then silence for long enough that the decoder
    // stops waiting for the rest.
    let mut audio = full[..full.len() * 2 / 3].to_vec();
    audio.extend(std::iter::repeat_n(0.0, SAMPLE_RATE as usize * 5));
    let (images, _) = decode(&audio);
    assert_eq!(
        images.len(),
        1,
        "a cut-off transmission produced no picture"
    );
    let image = &images[0];
    assert!(
        !image.complete,
        "a two-thirds transmission reported as complete"
    );
    assert!(
        image.lines > mode.height / 2 && image.lines < mode.height,
        "{} lines of {} arrived",
        image.lines,
        mode.height,
    );
    // What did arrive is the top of the picture, and it is right.
    let rows = usize::from(image.lines).saturating_sub(4);
    let error = mean_error(&sent[..width * rows * 3], &image.rgb[..width * rows * 3]);
    assert!(
        error < 12.0,
        "the lines that arrived are wrong: mean error {error:.1}"
    );
 }
 /// Two pictures back to back: the decoder has to finish the first and pick up
 /// the header of the second.
 #[test]
 fn decodes_a_second_transmission_after_the_first() {
    let mode = mode_for_vis(40).expect("Martin M2");
    let (width, height) = (usize::from(mode.width), usize::from(mode.height));
    let sent = test_card(width, height);
    let frame = Frame {
        width,
        height,
        rgb: &sent,
    };
    let one = encode(mode, &frame, SAMPLE_RATE);
    let mut audio = one.clone();
    audio.extend(std::iter::repeat_n(0.0, SAMPLE_RATE as usize / 2));
    audio.extend(one);
    let (images, _) = decode(&audio);
    assert_eq!(
        images.len(),
        2,
        "expected two pictures, got {}",
        images.len()
    );
    assert!(
        images.iter().all(|image| image.complete),
        "a picture did not finish"
    );
 }
 /// Noise on the signal is the normal condition on HF. The picture should
 /// degrade, not fall apart.
 #[test]
 fn decodes_through_noise() {
    let mode = mode_for_vis(44).expect("Martin M1");
    let (width, height) = (usize::from(mode.width), usize::from(mode.height));
    let sent = test_card(width, height);
    let frame = Frame {
        width,
        height,
        rgb: &sent,
    };
    let clean = encode(mode, &frame, SAMPLE_RATE);
    // Deterministic pseudo-noise at about 20 dB below the signal.
    let mut seed = 0x5eed_1234u32;
    let noisy: Vec<f32> = clean
        .iter()
        .map(|sample| {
            seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let noise = (seed >> 8) as f32 / f32::from(u16::MAX) / 256.0 - 0.5;
            sample + noise * 0.2
        })
        .collect();
    let (images, _) = decode(&noisy);
    assert_eq!(images.len(), 1, "noise cost the whole picture");
    let image = &images[0];
    assert!(image.complete, "noise cost the bottom of the picture");
    let error = interior_error(width, height, &sent, &image.rgb);
    assert!(error < 20.0, "mean error through noise {error:.1} levels");
 }
 /// The sound card that plays the signal and the one that records it never
 /// agree exactly. A part-per-thousand error is far worse than reality and the
 /// picture should still stand up.
 #[test]
 fn tolerates_a_transmitter_clock_that_runs_fast() {
    let mode = mode_for_vis(44).expect("Martin M1");
    let (width, height) = (usize::from(mode.width), usize::from(mode.height));
    let sent = test_card(width, height);
    let frame = Frame {
        width,
        height,
        rgb: &sent,
    };
    // Encoding at a slightly different rate and decoding at 48 kHz is exactly
    // a clock error: every duration is stretched by the same factor.
    let audio = encode(mode, &frame, 48_048);
    let (images, _) = decode(&audio);
    assert_eq!(images.len(), 1, "a 0.1% clock error cost the picture");
    let error = interior_error(width, height, &sent, &images[0].rgb);
    assert!(
        error < 12.0,
        "mean error with a fast clock {error:.1} levels"
    );
 }
@@ -45,20 +45,8 @@ impl WefaxConfig {
        60.0 / lpm as f32
    }
-    /// Samples per line at the internal sample rate (rounded to an integer;
+    /// Samples per line at the internal sample rate.
    /// use [`Self::samples_per_line_f64`] for drift-free line slicing).
    pub fn samples_per_line(lpm: u16, sample_rate: u32) -> usize {
        (Self::line_duration_s(lpm) * sample_rate as f32).round() as usize
    }
    /// Exact (fractional) samples per line at the internal sample rate.
    ///
    /// The line period rarely lands on an integer number of samples
    /// (e.g. 120 LPM at 11 025 Hz is 5512.5 samples). Slicing on the rounded
    /// integer accumulates a fractional-sample error every line, which shows
    /// up as a slow horizontal slant over a tall image. Line boundaries are
    /// instead computed from this exact value so the error never accumulates.
    pub fn samples_per_line_f64(lpm: u16, sample_rate: u32) -> f64 {
        60.0 / f64::from(lpm) * f64::from(sample_rate)
    }
 }
@@ -38,24 +38,10 @@ const SIGNAL_DETECT_WINDOWS: u32 = 6;
 /// Real WEFAX content typically shows r > 0.5 between adjacent lines.
 const LINE_CORR_NOISE_THRESHOLD: f32 = 0.2;
-/// Number of consecutive uncorrelated scan lines that mark the end of a
+/// Number of consecutive uncorrelated scan lines that trigger auto-finalize
-/// transmission (carrier truly gone) and trigger auto-finalize. This must be
+/// while receiving. At 120 LPM this is 15 s; at 60 LPM it's 30 s. Modelled on
-/// long enough to ride through ordinary HF fading (QSB), which routinely
+/// fldigi's line-to-line correlation check for automatic stop.
-/// decorrelates adjacent lines for several seconds without the transmission
+const LINE_CORR_NOISE_LINES: u32 = 30;
 /// having ended. At 120 LPM this is ~60 s; at 60 LPM ~120 s.
 ///
 /// A short window here is what previously chopped a single chart into many
 /// PNG "chunks": a 15 s fade tripped the watchdog, the image was finalized,
 /// and the still-present carrier immediately re-started a fresh image. Real
 /// WEFAX decoders (fldigi) keep one continuous image per APT cycle up to a
 /// large line cap and only stop on the APT stop tone or genuine signal loss.
 const LINE_CORR_NOISE_LINES: u32 = 120;
 /// Hard cap on lines in a single image. A 120 LPM chart runs ~10 min
 /// (~1200 lines); this cap (≈25 min at 120 LPM) only bounds memory if a
 /// session is left running on an open carrier. On reaching it the image is
 /// finalized and the decoder waits for a fresh APT start.
 const MAX_IMAGE_LINES: u32 = 3000;
 /// Maximum number of scan-line-equivalent sample windows to wait for phasing
 /// lock before falling through to Receiving. Typical WEFAX phasing lasts
@@ -121,12 +107,6 @@ pub struct WefaxDecoder {
    /// the decoder falls through to Receiving so a noisy or partial
    /// phasing signal doesn't wedge the state machine.
    phasing_samples: u64,
    /// Whether a reception has already been auto-started from bare signal
    /// variance during this session. After the first image, a new one is only
    /// started by an APT start tone — this stops the trailing noise / carrier
    /// that follows one chart from immediately auto-starting another image
    /// (the mechanism that fragmented a transmission into many chunks).
    auto_start_used: bool,
    /// Current rig dial frequency in Hz (for image filenames).
    freq_hz: u64,
    /// Current rig mode name (for image filenames).
@@ -155,7 +135,6 @@ impl WefaxDecoder {
            signal_detect_buf: Vec::with_capacity(INTERNAL_RATE as usize / 2),
            low_corr_lines: 0,
            phasing_samples: 0,
            auto_start_used: false,
            freq_hz: 0,
            mode: String::new(),
        }
@@ -225,13 +204,7 @@ impl WefaxDecoder {
                // Fallback: detect active WEFAX signal by luminance variance.
                // Like fldigi's "strong image signal" detection — if we see
                // sustained modulated signal, auto-start receiving with defaults.
-                //
+                if self.state == State::Idle {
                // Only ever taken once per session: it exists to catch a user
                // tuning in mid-image with no APT start. After the first image,
                // a new reception requires an APT start tone, so the residual
                // carrier / noise that trails a finished chart cannot silently
                // spawn a second image (which is what produced many chunks).
                if self.state == State::Idle && !self.auto_start_used {
                    self.signal_detect_buf.extend_from_slice(&luminance);
                    let window_size = INTERNAL_RATE as usize / 2;
                    while self.signal_detect_buf.len() >= window_size {
@@ -367,14 +340,6 @@ impl WefaxDecoder {
                                break;
                            }
                            // Bound memory on an open carrier: finalize and wait
                            // for a fresh APT start rather than growing forever.
                            if count >= MAX_IMAGE_LINES {
                                debug!(lines = count, "WEFAX: max image lines — finalizing");
                                carrier_lost = true;
                                break;
                            }
                            // Emit progress event.
                            if self.config.emit_progress && count % PROGRESS_INTERVAL == 0 {
                                let line_data =
@@ -437,7 +402,6 @@ impl WefaxDecoder {
        self.signal_detect_buf.clear();
        self.low_corr_lines = 0;
        self.phasing_samples = 0;
        self.auto_start_used = false;
        events
    }
@@ -470,7 +434,6 @@ impl WefaxDecoder {
    fn transition_to_start_detected(&mut self, ioc: u16) -> WefaxEvent {
        let ioc = self.config.ioc.unwrap_or(ioc);
        debug!(ioc, "WEFAX: APT start detected");
        self.auto_start_used = true;
        self.state = State::StartDetected { ioc };
        self.reception_start_ms = Some(
            std::time::SystemTime::now()
@@ -500,7 +463,6 @@ impl WefaxDecoder {
        self.image = Some(ImageAssembler::new(ppl));
        self.tone_detector.reset();
        self.low_corr_lines = 0;
        self.auto_start_used = true;
        self.state = State::Receiving { ioc, lpm };
        self.state_event("Receiving", ioc, lpm)
    }
@@ -634,47 +596,4 @@ mod tests {
        dec.reset();
        assert_eq!(dec.state, State::Idle);
    }
    /// Regression test for the over-chunking bug: once a session has produced
    /// an image, the trailing carrier / noise must not silently auto-start a
    /// second image. Only an APT start tone (or an explicit reset) may begin a
    /// new reception after the first.
    #[test]
    fn variance_auto_start_only_fires_once_per_session() {
        let mut dec = WefaxDecoder::new(11025, WefaxConfig::default());
        // A transition rate that matches no APT tone → drives the variance
        // based "strong signal" auto-start rather than a tone detection.
        let strong = generate_apt_start(100.0, 11025, 4.0);
        dec.process_samples(&strong);
        assert!(
            matches!(dec.state, State::Receiving { .. }),
            "strong signal should auto-start one image, got {:?}",
            dec.state
        );
        assert!(dec.auto_start_used);
        // Simulate the image ending on carrier loss / stop (finalize → idle)
        // WITHOUT an operator reset.
        dec.transition_to_idle();
        assert_eq!(dec.state, State::Idle);
        // The still-present carrier must NOT spawn a second image.
        dec.process_samples(&generate_apt_start(100.0, 11025, 4.0));
        assert_eq!(
            dec.state,
            State::Idle,
            "trailing signal must not re-auto-start a fresh image"
        );
        // An explicit reset re-arms mid-image auto-start.
        dec.reset();
        assert!(!dec.auto_start_used);
        dec.process_samples(&generate_apt_start(100.0, 11025, 4.0));
        assert!(
            matches!(dec.state, State::Receiving { .. }),
            "reset should re-arm variance auto-start, got {:?}",
            dec.state
        );
    }
 }
@@ -12,8 +12,8 @@ use crate::config::WefaxConfig;
 /// Line slicer for WEFAX image assembly.
 pub struct LineSlicer {
-    /// Exact (fractional) samples per line at the internal sample rate.
+    /// Samples per line at the internal sample rate.
-    samples_per_line: f64,
+    samples_per_line: usize,
    /// Pixels per line (IOC × π).
    pixels_per_line: usize,
    /// Phase offset in samples from the phasing detector.
@@ -22,37 +22,22 @@ pub struct LineSlicer {
    buffer: Vec<f32>,
    /// Whether we have aligned to the phase offset yet.
    aligned: bool,
    /// Index of the next line to emit. Boundaries are derived from this
    /// against the exact fractional line length so rounding never accumulates.
    line_index: u64,
 }
 impl LineSlicer {
    pub fn new(lpm: u16, ioc: u16, sample_rate: u32, phase_offset: usize) -> Self {
-        let samples_per_line = WefaxConfig::samples_per_line_f64(lpm, sample_rate);
+        let samples_per_line = WefaxConfig::samples_per_line(lpm, sample_rate);
        let pixels_per_line = WefaxConfig::pixels_per_line(ioc) as usize;
        Self {
            samples_per_line,
            pixels_per_line,
            phase_offset,
-            buffer: Vec::with_capacity(samples_per_line as usize * 2),
+            buffer: Vec::with_capacity(samples_per_line * 2),
            aligned: false,
            line_index: 0,
        }
    }
    /// Number of samples in line `n`, from the exact fractional line length.
    ///
    /// Boundaries are `round(n · spl)`; the per-line length is the difference
    /// of successive boundaries, so lengths alternate (e.g. 5513/5512 for
    /// 120 LPM at 11 025 Hz) with no cumulative drift.
    fn line_len(&self, n: u64) -> usize {
        let start = (n as f64 * self.samples_per_line).round() as u64;
        let end = ((n + 1) as f64 * self.samples_per_line).round() as u64;
        (end - start) as usize
    }
    /// Feed luminance samples and extract complete image lines.
    ///
    /// Returns a vector of completed lines, each as a `Vec<u8>` of
@@ -71,18 +56,12 @@ impl LineSlicer {
        }
        // Extract complete lines (single drain at the end to avoid O(n²)).
        // Line boundaries follow the exact fractional line length so the
        // sample clock stays locked over a tall image (no accumulating slant).
        let mut offset = 0;
-        loop {
+        while offset + self.samples_per_line <= self.buffer.len() {
-            let len = self.line_len(self.line_index);
+            let line_samples = &self.buffer[offset..offset + self.samples_per_line];
-            if offset + len > self.buffer.len() {
+            let pixels = self.resample_line(line_samples);
-                break;
+            lines.push(pixels);
-            }
+            offset += self.samples_per_line;
            let line_samples = &self.buffer[offset..offset + len];
            lines.push(self.resample_line(line_samples));
            offset += len;
            self.line_index += 1;
        }
        if offset > 0 {
            self.buffer.drain(..offset);
@@ -98,7 +77,6 @@ impl LineSlicer {
    pub fn reset(&mut self) {
        self.buffer.clear();
        self.aligned = false;
        self.line_index = 0;
    }
    /// Resample a line's worth of luminance samples to the target pixel count
@@ -151,29 +129,6 @@ mod tests {
        assert!(lines[0].iter().all(|&p| p == 255));
    }
    #[test]
    fn slicer_no_cumulative_drift() {
        // 120 LPM at 11 025 Hz is 5512.5 samples/line — not an integer. Slicing
        // on the rounded value (5513) would lose a line every ~11 000 lines and
        // slant the image; the fractional boundaries must not accumulate error.
        let lpm = 120;
        let ioc = 576;
        let sr = 11025;
        let spl = WefaxConfig::samples_per_line_f64(lpm, sr);
        assert_ne!(spl.fract(), 0.0, "test premise: spl is fractional");
        let mut slicer = LineSlicer::new(lpm, ioc, sr, 0);
        let total = (spl * 1000.0).round() as usize;
        let samples = vec![1.0f32; total];
        let lines = slicer.process(&samples);
        assert_eq!(
            lines.len(),
            1000,
            "exactly 1000 lines should fit in {} samples with no drift",
            total
        );
    }
    #[test]
    fn slicer_linear_interpolation() {
        let lpm = 120;
@@ -77,12 +77,8 @@ pub struct ToneDetector {
 impl ToneDetector {
    pub fn new(sample_rate: u32) -> Self {
        // APT start/stop tones are transmitted for ~5 s (WMO), so requiring a
        // 2 s sustain costs no real detection latency while sharply cutting
        // false positives from busy image content that momentarily produces a
        // 300/450/675-transitions-per-second rate.
        let window_size = (sample_rate / 2) as usize; // ~0.5 s window
-        let min_sustain_s = 2.0;
+        let min_sustain_s = 1.0; // fldigi uses 2 consecutive half-second windows
        let window_duration_s = window_size as f32 / sample_rate as f32;
        let min_sustain_windows = (min_sustain_s / window_duration_s).ceil() as u32;
@@ -9,5 +9,9 @@ edition = "2021"
 license = "GPL-2.0-or-later"
 [dependencies]
 serde = { workspace = true }
 toml = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 dirs = "6"
 thiserror = "2"
@@ -0,0 +1,88 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 use serde::de::DeserializeOwned;
 use std::path::{Path, PathBuf};
 use thiserror::Error;
 #[derive(Debug, Error)]
 pub enum ConfigError {
    #[error("Failed to read config file {0}: {1}")]
    ReadError(PathBuf, String),
    #[error("Failed to parse config file {0}: {1}")]
    ParseError(PathBuf, String),
 }
 /// Returns the default search paths for `trx-rs.toml`
 /// (current directory → XDG config → /etc).
 fn config_search_paths() -> Vec<PathBuf> {
    let mut paths = vec![PathBuf::from("trx-rs.toml")];
    if let Some(config_dir) = dirs::config_dir() {
        paths.push(config_dir.join("trx-rs").join("trx-rs.toml"));
    }
    paths.push(PathBuf::from("/etc/trx-rs/trx-rs.toml"));
    paths
 }
 /// Extract and deserialize a named section from a TOML file.
 ///
 /// Returns `Ok(Some(cfg))` when the section is present and parses cleanly,
 /// `Ok(None)` when the section is absent, or `Err` on I/O / parse failure.
 fn load_section_from_file<T: DeserializeOwned>(
    path: &Path,
    key: &str,
 ) -> Result<Option<T>, ConfigError> {
    let content = std::fs::read_to_string(path)
        .map_err(|e| ConfigError::ReadError(path.to_path_buf(), e.to_string()))?;
    let table: toml::Table = toml::from_str(&content)
        .map_err(|e| ConfigError::ParseError(path.to_path_buf(), e.to_string()))?;
    let Some(section) = table.get(key) else {
        return Ok(None);
    };
    // Re-serialize the section then parse as T so all serde defaults apply.
    let section_toml = toml::to_string(section)
        .map_err(|e| ConfigError::ParseError(path.to_path_buf(), e.to_string()))?;
    let cfg = toml::from_str::<T>(&section_toml)
        .map_err(|e| ConfigError::ParseError(path.to_path_buf(), e.to_string()))?;
    Ok(Some(cfg))
 }
 /// Trait for loading configuration from a `trx-rs.toml` section.
 pub trait ConfigFile: Sized + Default + DeserializeOwned {
    /// Section key in `trx-rs.toml` (e.g. `"trx-server"` or `"trx-client"`).
    fn section_key() -> &'static str;
    /// Load the section from a specific file path.
    ///
    /// Returns an error if the file cannot be read, is not valid TOML, or
    /// does not contain the expected `[<section_key>]` header.
    fn load_from_file(path: &Path) -> Result<Self, ConfigError> {
        load_section_from_file::<Self>(path, Self::section_key())?.ok_or_else(|| {
            ConfigError::ParseError(
                path.to_path_buf(),
                format!("missing [{}] section", Self::section_key()),
            )
        })
    }
    /// Search default paths (`trx-rs.toml` in CWD → XDG → /etc) and load
    /// the first file that contains the expected section.
    ///
    /// Returns `(config, path_where_found)` or `(Default::default(), None)`
    /// when no config file is found.
    fn load_from_default_paths() -> Result<(Self, Option<PathBuf>), ConfigError> {
        for path in config_search_paths() {
            if path.exists() {
                if let Some(cfg) = load_section_from_file::<Self>(&path, Self::section_key())? {
                    return Ok((cfg, Some(path)));
                }
            }
        }
        Ok((Self::default(), None))
    }
 }
@@ -2,12 +2,12 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
-//! Shared application helpers.
+pub mod config;
 //!
 //! Configuration types and their loader live in the `trx-config` crate.
 pub mod logging;
 pub mod shared_config;
 pub mod util;
 pub use config::{ConfigError, ConfigFile};
 pub use logging::init_logging;
 pub use shared_config::{validate_log_level, validate_tokens};
 pub use util::normalize_name;
@@ -19,52 +19,6 @@
 //! would either bloat both binaries with unused fields or require a trait
 //! abstraction that adds complexity without clear benefit.
 use std::net::IpAddr;
 /// A socket a component intends to bind, and what it is for.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BoundSocket {
    pub addr: IpAddr,
    pub port: u16,
    /// Human-readable owner, e.g. `[listen]` or `[frontends.http]`.
    pub label: String,
 }
 impl BoundSocket {
    pub fn new(addr: IpAddr, port: u16, label: impl Into<String>) -> Self {
        Self {
            addr,
            port,
            label: label.into(),
        }
    }
 }
 /// Reject two components trying to bind the same socket.
 ///
 /// A wildcard address (`0.0.0.0` / `::`) conflicts with any other address on
 /// the same port, since binding it claims every interface.  Port 0 means "pick
 /// an ephemeral port" and never conflicts.
 pub fn check_socket_conflicts(sockets: &[BoundSocket]) -> Result<(), String> {
    for (i, a) in sockets.iter().enumerate() {
        if a.port == 0 {
            continue;
        }
        for b in &sockets[i + 1..] {
            if b.port != a.port {
                continue;
            }
            if a.addr == b.addr || a.addr.is_unspecified() || b.addr.is_unspecified() {
                return Err(format!(
                    "{} and {} would both bind {}:{}",
                    a.label, b.label, a.addr, a.port
                ));
            }
        }
    }
    Ok(())
 }
 /// Validate that a log level string is one of the accepted values.
 ///
 /// Returns `Ok(())` when `level` is `None` (defaulting is handled elsewhere)
@@ -99,47 +53,6 @@ pub fn validate_tokens(path: &str, tokens: &[String]) -> Result<(), String> {
 mod tests {
    use super::*;
    fn sock(addr: &str, port: u16, label: &str) -> BoundSocket {
        BoundSocket::new(addr.parse().unwrap(), port, label)
    }
    #[test]
    fn test_socket_conflicts_detects_exact_duplicate() {
        let err = check_socket_conflicts(&[
            sock("127.0.0.1", 8080, "[frontends.http]"),
            sock("127.0.0.1", 8080, "[frontends.http_json]"),
        ])
        .unwrap_err();
        assert!(err.contains("127.0.0.1:8080"), "unexpected error: {err}");
    }
    #[test]
    fn test_socket_conflicts_detects_wildcard_overlap() {
        assert!(check_socket_conflicts(&[
            sock("0.0.0.0", 4530, "[listen]"),
            sock("127.0.0.1", 4530, "[audio]"),
        ])
        .is_err());
    }
    #[test]
    fn test_socket_conflicts_allows_distinct_addresses() {
        assert!(check_socket_conflicts(&[
            sock("127.0.0.1", 4530, "[listen]"),
            sock("192.168.1.5", 4530, "[audio]"),
        ])
        .is_ok());
    }
    #[test]
    fn test_socket_conflicts_ignores_ephemeral_ports() {
        assert!(check_socket_conflicts(&[
            sock("127.0.0.1", 0, "[frontends.http_json]"),
            sock("127.0.0.1", 0, "[frontends.http]"),
        ])
        .is_ok());
    }
    #[test]
    fn test_validate_log_level_none() {
        assert!(validate_log_level(None).is_ok());
@@ -21,7 +21,6 @@ uuid = { workspace = true }
 cpal = "0.15"
 opus = "0.3"
 trx-app = { path = "../trx-app" }
 trx-config = { path = "../trx-config" }
 trx-core = { path = "../trx-core" }
 trx-protocol = { path = "../trx-protocol" }
 trx-frontend = { path = "trx-frontend" }
@@ -27,11 +27,11 @@ use trx_core::audio::{
    write_vchan_uuid_msg, AudioStreamInfo, AUDIO_MSG_AIS_DECODE, AUDIO_MSG_APRS_DECODE,
    AUDIO_MSG_CW_DECODE, AUDIO_MSG_FT2_DECODE, AUDIO_MSG_FT4_DECODE, AUDIO_MSG_FT8_DECODE,
    AUDIO_MSG_HF_APRS_DECODE, AUDIO_MSG_HISTORY_COMPRESSED, AUDIO_MSG_LRPT_IMAGE,
-    AUDIO_MSG_LRPT_PROGRESS, AUDIO_MSG_RX_FRAME, AUDIO_MSG_RX_FRAME_CH, AUDIO_MSG_SSTV_DECODE,
+    AUDIO_MSG_LRPT_PROGRESS, AUDIO_MSG_RX_FRAME, AUDIO_MSG_RX_FRAME_CH, AUDIO_MSG_STREAM_INFO,
-    AUDIO_MSG_SSTV_PROGRESS, AUDIO_MSG_STREAM_INFO, AUDIO_MSG_TX_FRAME, AUDIO_MSG_VCHAN_ALLOCATED,
+    AUDIO_MSG_TX_FRAME, AUDIO_MSG_VCHAN_ALLOCATED, AUDIO_MSG_VCHAN_BW, AUDIO_MSG_VCHAN_DESTROYED,
-    AUDIO_MSG_VCHAN_BW, AUDIO_MSG_VCHAN_DESTROYED, AUDIO_MSG_VCHAN_FREQ, AUDIO_MSG_VCHAN_MODE,
+    AUDIO_MSG_VCHAN_FREQ, AUDIO_MSG_VCHAN_MODE, AUDIO_MSG_VCHAN_REMOVE, AUDIO_MSG_VCHAN_SUB,
-    AUDIO_MSG_VCHAN_REMOVE, AUDIO_MSG_VCHAN_SUB, AUDIO_MSG_VCHAN_UNSUB, AUDIO_MSG_VDES_DECODE,
+    AUDIO_MSG_VCHAN_UNSUB, AUDIO_MSG_VDES_DECODE, AUDIO_MSG_WEFAX_DECODE, AUDIO_MSG_WEFAX_PROGRESS,
-    AUDIO_MSG_WEFAX_DECODE, AUDIO_MSG_WEFAX_PROGRESS, AUDIO_MSG_WSPR_DECODE,
+    AUDIO_MSG_WSPR_DECODE,
 };
 use trx_core::decode::DecodedMessage;
 use trx_frontend::VChanAudioCmd;
@@ -533,9 +533,7 @@ async fn handle_single_rig_connection(
                    | AUDIO_MSG_LRPT_IMAGE
                    | AUDIO_MSG_LRPT_PROGRESS
                    | AUDIO_MSG_WEFAX_DECODE
-                    | AUDIO_MSG_WEFAX_PROGRESS
+                    | AUDIO_MSG_WEFAX_PROGRESS,
                    | AUDIO_MSG_SSTV_DECODE
                    | AUDIO_MSG_SSTV_PROGRESS,
                    payload,
                )) => {
                    if let Ok(mut msg) = serde_json::from_slice::<DecodedMessage>(&payload) {
@@ -20,7 +20,6 @@ use tokio::task::JoinHandle;
 use tracing::{error, info};
 use trx_app::{init_logging, normalize_name};
 use trx_config::ConfigFile;
 use trx_core::audio::AudioStreamInfo;
 use trx_core::decode::DecodedMessage;
@@ -51,12 +50,6 @@ struct Cli {
    /// Print example configuration and exit
    #[arg(long = "print-config")]
    print_config: bool,
    /// Treat unknown configuration keys as a fatal error
    #[arg(long = "strict-config")]
    strict_config: bool,
    /// Validate the configuration and exit without starting anything
    #[arg(long = "check-config")]
    check_config: bool,
    /// Remote server URL (host:port)
    #[arg(short = 'u', long = "url")]
    url: Option<String>,
@@ -81,7 +74,7 @@ struct Cli {
    /// rigctl frontend listen address
    #[arg(long = "rigctl-listen")]
    rigctl_listen: Option<IpAddr>,
-    /// Deprecated: ignored, use [frontends.rigctl].rig_ports
+    /// rigctl frontend listen port
    #[arg(long = "rigctl-port")]
    rigctl_port: Option<u16>,
    /// JSON TCP frontend listen address
@@ -116,65 +109,6 @@ async fn main() -> DynResult<()> {
    Ok(())
 }
 /// `--check-config`: report everything wrong with the configuration and exit.
 ///
 /// Unlike startup, this reports every problem it finds rather than stopping at
 /// the first, so a config can be fixed in one pass.  The file is checked as
 /// written, without CLI overrides.
 fn check_config(loaded: &trx_config::ConfigLoad<ClientConfig>) -> DynResult<()> {
    match &loaded.path {
        Some(path) => println!("{}", path.display()),
        None => println!("(no config file found; checking built-in defaults)"),
    }
    let mut warnings: Vec<String> = loaded.unknown_keys.iter().map(|k| k.to_string()).collect();
    warnings.extend(ClientConfig::deprecations(&loaded.present_keys));
    let mut cfg = loaded.config.clone();
    let mut errors = Vec::new();
    if let Err(e) = cfg.resolve_secrets(loaded.path.as_deref()) {
        errors.push(e);
    }
    let cfg = &cfg;
    let remotes = cfg.resolved_remotes();
    if remotes.is_empty() {
        warnings.push(
            "no remotes configured; --url will be required at startup (add [[remotes]] entries)"
                .to_string(),
        );
    }
    errors.extend(cfg.validate_all());
    if !remotes.is_empty() {
        errors.extend(cfg.validate_resolved_all(&remotes));
    }
    for w in &warnings {
        println!("  warning: {}", w);
    }
    for e in &errors {
        println!("  error: {}", e);
    }
    if errors.is_empty() {
        println!(
            "  OK: {} remote(s) configured: {}",
            remotes.len(),
            remotes
                .iter()
                .map(|r| r.name.as_str())
                .collect::<Vec<_>>()
                .join(", ")
        );
        if !warnings.is_empty() {
            println!("  {} warning(s)", warnings.len());
        }
        Ok(())
    } else {
        Err(format!("{} error(s), {} warning(s)", errors.len(), warnings.len()).into())
    }
 }
 /// Holds the state needed after async initialization completes.
 struct AppState {
    shutdown_tx: watch::Sender<bool>,
@@ -201,44 +135,20 @@ async fn async_init() -> DynResult<AppState> {
        std::process::exit(0);
    }
-    let loaded = if let Some(ref path) = cli.config {
+    let (cfg, config_path) = if let Some(ref path) = cli.config {
-        ClientConfig::load_from_file(path)?
+        let cfg = ClientConfig::load_from_file(path)?;
        (cfg, Some(path.clone()))
    } else {
        ClientConfig::load_from_default_paths()?
    };
-    let config_path = loaded.path.clone();
+    cfg.validate()
        .map_err(|e| format!("Invalid client configuration: {}", e))?;
-    if cli.check_config {
+    init_logging(cfg.general.log_level.as_deref());
        match check_config(&loaded) {
            Ok(()) => std::process::exit(0),
            Err(e) => {
                eprintln!("{}", e);
                std::process::exit(1);
            }
        }
    }
    // Logging comes up before any config complaint so the warnings are visible.
    init_logging(loaded.config.general.log_level.as_deref());
    if let Some(ref path) = config_path {
        info!("Loaded configuration from {}", path.display());
    }
    loaded.report_unknown_keys(cli.strict_config)?;
    loaded.report_deprecations();
    if cli.rigctl_port.is_some() {
        tracing::warn!(
            "--rigctl-port is ignored; give each rig its own listener via \
             [frontends.rigctl].rig_ports"
        );
    }
    let mut cfg = loaded.config;
    // Secrets configured as *_file are read before validation, so everything
    // downstream sees resolved values.
    cfg.resolve_secrets(config_path.as_deref())?;
    cfg.validate()
        .map_err(|e| format!("Invalid client configuration: {}", e))?;
    frontend_runtime.http_auth.tokens = cfg
        .frontends
@@ -252,17 +162,11 @@ async fn async_init() -> DynResult<AppState> {
    // Set HTTP frontend authentication config
    frontend_runtime.http_auth.enabled = cfg.frontends.http.auth.enabled;
-    frontend_runtime.http_auth.users_file = cfg.frontends.http.auth.users_file.clone();
+    frontend_runtime.http_auth.rx_passphrase = cfg.frontends.http.auth.rx_passphrase.clone();
-    frontend_runtime.http_auth.bootstrap_admin_username =
+    frontend_runtime.http_auth.control_passphrase =
-        cfg.frontends.http.auth.bootstrap_admin_username.clone();
+        cfg.frontends.http.auth.control_passphrase.clone();
-    frontend_runtime.http_auth.bootstrap_admin_password =
+    frontend_runtime.http_auth.tx_access_control_enabled =
-        cfg.frontends.http.auth.bootstrap_admin_password.clone();
+        cfg.frontends.http.auth.tx_access_control_enabled;
    frontend_runtime.http_auth.bootstrap_read_enabled =
        cfg.frontends.http.auth.bootstrap_read_enabled;
    frontend_runtime.http_auth.bootstrap_read_username =
        cfg.frontends.http.auth.bootstrap_read_username.clone();
    frontend_runtime.http_auth.bootstrap_read_password =
        cfg.frontends.http.auth.bootstrap_read_password.clone();
    frontend_runtime.http_auth.session_ttl_secs = cfg.frontends.http.auth.session_ttl().as_secs();
    frontend_runtime.http_auth.cookie_secure = cfg.frontends.http.auth.cookie_secure;
    frontend_runtime.http_auth.cookie_same_site = match cfg.frontends.http.auth.cookie_same_site {
@@ -285,10 +189,6 @@ async fn async_init() -> DynResult<AppState> {
        .http
        .decode_history_retention_min_by_rig
        .clone();
    frontend_runtime.http_ui.logbook_path = cfg.logbook.path.clone();
    // The callsign the station is on the air with, which every contact is
    // logged under and which the operator defaults to.
    frontend_runtime.http_ui.station_callsign = cfg.general.callsign.clone();
    // Resolve remote entries: CLI --url > [[remotes]] > legacy [remote] > error
    let resolved_remotes: Vec<RemoteEntry> = if let Some(ref url) = cli.url {
@@ -298,14 +198,10 @@ async fn async_init() -> DynResult<AppState> {
        let token = cli.token.clone().or_else(|| cfg.remote.auth.token.clone());
        let poll_interval_ms = cli.poll_interval_ms.unwrap_or(cfg.remote.poll_interval_ms);
        vec![RemoteEntry {
            spectrum_interval_ms: cfg.remote.spectrum_interval_ms,
            name,
            url: url.clone(),
            rig_id,
-            auth: config::RemoteAuthConfig {
+            auth: config::RemoteAuthConfig { token },
                token,
                token_file: None,
            },
            poll_interval_ms,
        }]
    } else {
@@ -366,30 +262,6 @@ async fn async_init() -> DynResult<AppState> {
        .http_json_listen
        .unwrap_or(cfg.frontends.http_json.listen);
    let http_json_port = cli.http_json_port.unwrap_or(cfg.frontends.http_json.port);
    // Fold the CLI overrides back into the config so validation and the
    // frontends agree on what is about to be bound.
    cfg.frontends.http.enabled = frontends.iter().any(|f| f == "http");
    cfg.frontends.rigctl.enabled = frontends.iter().any(|f| f == "rigctl");
    cfg.frontends.http_json.enabled = frontends.iter().any(|f| f == "httpjson");
    cfg.frontends.http.listen = http_listen;
    cfg.frontends.http.port = http_port;
    cfg.frontends.rigctl.listen = rigctl_listen;
    cfg.frontends.http_json.listen = http_json_listen;
    cfg.frontends.http_json.port = http_json_port;
    // Second validation phase: the per-rig maps are keyed by remote short name,
    // so they can only be checked once the remote list is final.
    if cli.url.is_none() {
        cfg.validate_resolved(&resolved_remotes)
            .map_err(|e| format!("Invalid client configuration: {}", e))?;
    } else {
        // --url replaces the configured remotes outright, so only the socket
        // checks still apply.
        trx_config::shared::check_socket_conflicts(&cfg.bound_sockets())
            .map_err(|e| format!("Invalid client configuration: {}", e))?;
    }
    let callsign = cli
        .callsign
        .clone()
@@ -494,13 +366,6 @@ async fn async_init() -> DynResult<AppState> {
            .map(|e| e.poll_interval_ms)
            .min()
            .unwrap_or(750);
        // Entries sharing a server share its connections, so the most frequent
        // request wins: whoever wants spectrum fastest sets the rate.
        let spectrum_interval = entries
            .iter()
            .map(|e| e.spectrum_interval_ms)
            .min()
            .unwrap_or_else(|| remote_client::DEFAULT_SPECTRUM_INTERVAL.as_millis() as u64);
        let (server_tx, server_rx) = mpsc::channel::<RigRequest>(RIG_TASK_CHANNEL_BUFFER);
        for entry in entries {
@@ -514,8 +379,6 @@ async fn async_init() -> DynResult<AppState> {
            known_rigs: frontend_runtime.routing.remote_rigs.clone(),
            rig_states: frontend_runtime.routing.rig_states.clone(),
            poll_interval: Duration::from_millis(poll_interval),
            spectrum_interval: Duration::from_millis(spectrum_interval),
            spectrum_stream_unsupported: Arc::new(std::sync::atomic::AtomicBool::new(false)),
            spectrum: frontend_runtime.spectrum.sender.clone(),
            rig_spectrums: frontend_runtime.spectrum.per_rig.clone(),
            server_connected: frontend_runtime.routing.server_connected.clone(),
@@ -664,9 +527,6 @@ async fn async_init() -> DynResult<AppState> {
                DecodedMessage::LrptProgress(_) => {}
                DecodedMessage::Wefax(_) => {}
                DecodedMessage::WefaxProgress(_) => {}
                // Pictures replay from their own history, not this one.
                DecodedMessage::Sstv(_) => {}
                DecodedMessage::SstvProgress(_) => {}
            }
        });
@@ -20,22 +20,35 @@ use trx_core::{RigError, RigResult};
 use trx_frontend::{RemoteRigEntry, SharedSpectrum};
 use trx_protocol::rig_command_to_client;
 use trx_protocol::types::RigEntry;
-use trx_protocol::{ClientCommand, ClientEnvelope, ClientResponse, MeterUpdate, SpectrumFrame};
+use trx_protocol::{ClientCommand, ClientEnvelope, ClientResponse, MeterUpdate};
 // Endpoint parsing lives in `trx-config` so config validation and the
 // connection code agree on what a URL means.
 pub use trx_config::url::{parse_audio_url, parse_remote_url, RemoteEndpoint};
 const DEFAULT_REMOTE_PORT: u16 = 4530;
 const DEFAULT_AUDIO_PORT: u16 = 4531;
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(5);
 const IO_TIMEOUT: Duration = Duration::from_secs(15);
 const SPECTRUM_IO_TIMEOUT: Duration = Duration::from_secs(3);
 const MAX_JSON_LINE_BYTES: usize = 256 * 1024;
 const MAX_CONSECUTIVE_POLL_FAILURES: u32 = 3;
-// Default spectrum cadence when a config does not specify one.  Both the push
+#[derive(Clone, Debug, PartialEq, Eq)]
-// stream and the poll fallback run at the configured rate; see
+pub struct RemoteEndpoint {
-// `[[remotes]].spectrum_interval_ms`.
+    pub host: String,
-pub const DEFAULT_SPECTRUM_INTERVAL: Duration = Duration::from_millis(50);
+    pub port: u16,
 }
 impl RemoteEndpoint {
    pub fn connect_addr(&self) -> String {
        if self.host.contains(':') && !self.host.starts_with('[') {
            format!("[{}]:{}", self.host, self.port)
        } else {
            format!("{}:{}", self.host, self.port)
        }
    }
 }
 // Keep remote spectrum reasonably responsive without returning to the old
 // timeout churn caused by a much tighter request cadence.
 const SPECTRUM_POLL_INTERVAL: Duration = Duration::from_millis(50);
 #[derive(Clone)]
 pub struct RemoteClientConfig {
@@ -44,12 +57,6 @@ pub struct RemoteClientConfig {
    pub selected_rig_id: Arc<Mutex<Option<String>>>,
    pub known_rigs: Arc<Mutex<Vec<RemoteRigEntry>>>,
    pub poll_interval: Duration,
    /// How often spectrum frames are wanted.  Drives the poll fallback and is
    /// the rate the client asks the server to push at.
    pub spectrum_interval: Duration,
    /// Set once a server has rejected `SubscribeSpectrum`, so later
    /// connections to it go straight to polling instead of asking again.
    pub spectrum_stream_unsupported: Arc<AtomicBool>,
    /// Spectrum watch sender; spectrum task publishes here, SSE clients subscribe.
    pub spectrum: Arc<watch::Sender<SharedSpectrum>>,
    /// Shared flag: `true` while a TCP connection to trx-server is active.
@@ -498,100 +505,6 @@ async fn send_get_sat_passes_on(
    ))
 }
 /// What ended a spectrum stream attempt.
 enum SpectrumStreamOutcome {
    /// The stream ran and is over; the connection is spent.
    Finished,
    /// The server rejected the subscription.  The connection is still usable,
    /// so the caller can poll on it.
    Unsupported,
 }
 /// Subscribe to the server's spectrum push for one rig and publish frames as
 /// they arrive.
 ///
 /// The server answers either with frames or, when it is too old to know the
 /// command, with an error response — which leaves the connection usable for
 /// polling, so falling back costs no reconnect.
 async fn run_spectrum_stream(
    config: &RemoteClientConfig,
    writer: &mut (impl AsyncWriteExt + Unpin),
    reader: &mut (impl AsyncBufRead + Unpin),
    short_name: &str,
    shutdown_rx: &mut watch::Receiver<bool>,
 ) -> RigResult<SpectrumStreamOutcome> {
    let envelope = build_envelope(
        config,
        ClientCommand::SubscribeSpectrum,
        Some(short_name.to_string()),
    );
    let mut payload = serde_json::to_string(&envelope)
        .map_err(|e| RigError::communication(format!("JSON serialize failed: {e}")))?;
    payload.push('\n');
    time::timeout(SPECTRUM_IO_TIMEOUT, writer.write_all(payload.as_bytes()))
        .await
        .map_err(|_| RigError::communication("spectrum subscribe write timed out".to_string()))?
        .map_err(|e| RigError::communication(format!("spectrum subscribe write failed: {e}")))?;
    time::timeout(SPECTRUM_IO_TIMEOUT, writer.flush())
        .await
        .map_err(|_| RigError::communication("spectrum subscribe flush timed out".to_string()))?
        .map_err(|e| RigError::communication(format!("spectrum subscribe flush failed: {e}")))?;
    // Re-check what the UI wants: switching rigs has to end this stream so the
    // connection can be rebuilt for the new one.
    let mut supervisor = time::interval(Duration::from_millis(500));
    supervisor.tick().await;
    loop {
        tokio::select! {
            changed = shutdown_rx.changed() => {
                match changed {
                    Ok(()) if *shutdown_rx.borrow() => return Ok(SpectrumStreamOutcome::Finished),
                    Ok(()) => {}
                    Err(_) => return Ok(SpectrumStreamOutcome::Finished),
                }
            }
            _ = supervisor.tick() => {
                let wanted = active_spectrum_rig_ids(config);
                if wanted.len() != 1 || wanted[0] != short_name {
                    return Ok(SpectrumStreamOutcome::Finished);
                }
            }
            line = read_limited_line(reader, MAX_JSON_LINE_BYTES) => {
                let line = line
                    .map_err(|e| RigError::communication(format!("spectrum read failed: {e}")))?
                    .ok_or_else(|| {
                        RigError::communication("spectrum connection closed".to_string())
                    })?;
                let trimmed = line.trim_end();
                if trimmed.is_empty() {
                    continue;
                }
                match serde_json::from_str::<SpectrumFrame>(trimmed) {
                    Ok(frame) => publish_spectrum_frame(config, short_name, frame),
                    // Anything that is not a frame means the server would rather
                    // answer than stream: an older build rejecting the command.
                    Err(_) => return Ok(SpectrumStreamOutcome::Unsupported),
                }
            }
        }
    }
 }
 /// Publish one pushed frame to the per-rig and selected-rig watch channels.
 fn publish_spectrum_frame(config: &RemoteClientConfig, short_name: &str, frame: SpectrumFrame) {
    if let Ok(map) = config.rig_spectrums.read() {
        if let Some(tx) = map.get(short_name) {
            tx.send_modify(|s| s.set(Some(frame.spectrum.clone()), frame.vchan_rds.clone()));
        }
    }
    if selected_rig_id(config).as_deref() == Some(short_name) {
        config
            .spectrum
            .send_modify(|s| s.set(Some(frame.spectrum), frame.vchan_rds));
    }
 }
 async fn handle_spectrum_connection(
    config: &RemoteClientConfig,
    stream: TcpStream,
@@ -599,33 +512,7 @@ async fn handle_spectrum_connection(
 ) -> RigResult<()> {
    let (reader, mut writer) = stream.into_split();
    let mut reader = BufReader::new(reader);
-
+    let mut interval = time::interval(SPECTRUM_POLL_INTERVAL);
    // Prefer the push stream: polling costs a round trip per frame, so on a
    // high-latency link the frame rate is 1/RTT no matter what interval is
    // configured.  It only works for one rig per connection, and only against
    // a server new enough to understand the command.
    let streamable = active_spectrum_rig_ids(config);
    if streamable.len() == 1 && !config.spectrum_stream_unsupported.load(Ordering::Relaxed) {
        match run_spectrum_stream(
            config,
            &mut writer,
            &mut reader,
            &streamable[0],
            shutdown_rx,
        )
        .await?
        {
            SpectrumStreamOutcome::Finished => return Ok(()),
            SpectrumStreamOutcome::Unsupported => {
                info!("Server does not support spectrum streaming; falling back to polling");
                config
                    .spectrum_stream_unsupported
                    .store(true, Ordering::Relaxed);
            }
        }
    }
    let mut interval = time::interval(config.spectrum_interval);
    // Cache the token outside the poll loop to avoid cloning it every 50ms.
    let cached_token = config.token.clone();
@@ -1308,13 +1195,92 @@ async fn read_limited_line<R: AsyncBufRead + Unpin>(
    }
 }
 pub fn parse_remote_url(url: &str) -> Result<RemoteEndpoint, String> {
    parse_endpoint_url(url, DEFAULT_REMOTE_PORT, "remote")
 }
 pub fn parse_audio_url(url: &str) -> Result<RemoteEndpoint, String> {
    parse_endpoint_url(url, DEFAULT_AUDIO_PORT, "audio")
 }
 fn parse_endpoint_url(url: &str, default_port: u16, kind: &str) -> Result<RemoteEndpoint, String> {
    let trimmed = url.trim();
    if trimmed.is_empty() {
        return Err(format!("{kind} url is empty"));
    }
    let addr = trimmed
        .strip_prefix("tcp://")
        .or_else(|| trimmed.strip_prefix("http-json://"))
        .or_else(|| trimmed.strip_prefix("audio://"))
        .unwrap_or(trimmed);
    parse_host_port(addr, default_port, kind)
 }
 fn parse_host_port(input: &str, default_port: u16, kind: &str) -> Result<RemoteEndpoint, String> {
    if let Some(rest) = input.strip_prefix('[') {
        let closing = rest
            .find(']')
            .ok_or_else(|| format!("invalid {kind} url: missing closing ']' for IPv6 host"))?;
        let host = &rest[..closing];
        let remainder = &rest[closing + 1..];
        if host.is_empty() {
            return Err(format!("invalid {kind} url: host is empty"));
        }
        let port = if remainder.is_empty() {
            default_port
        } else if let Some(port_str) = remainder.strip_prefix(':') {
            parse_port(port_str, kind)?
        } else {
            return Err(format!("invalid {kind} url: expected ':<port>' after ']'"));
        };
        return Ok(RemoteEndpoint {
            host: host.to_string(),
            port,
        });
    }
    if input.contains(':') {
        if input.matches(':').count() > 1 {
            return Err(format!(
                "invalid {kind} url: IPv6 host must be bracketed like [::1]:4532"
            ));
        }
        let (host, port_str) = input
            .rsplit_once(':')
            .ok_or_else(|| format!("invalid {kind} url: expected host:port"))?;
        if host.is_empty() {
            return Err(format!("invalid {kind} url: host is empty"));
        }
        return Ok(RemoteEndpoint {
            host: host.to_string(),
            port: parse_port(port_str, kind)?,
        });
    }
    Ok(RemoteEndpoint {
        host: input.to_string(),
        port: default_port,
    })
 }
 fn parse_port(port_str: &str, kind: &str) -> Result<u16, String> {
    let port: u16 = port_str
        .parse()
        .map_err(|_| format!("invalid {kind} port: '{port_str}'"))?;
    if port == 0 {
        return Err(format!("invalid {kind} port: 0"));
    }
    Ok(port)
 }
 #[cfg(test)]
 mod tests {
    #[allow(unused_imports)]
    use super::{has_short_names, resolve_server_rig_id, resolve_short_name};
    use super::{
        parse_audio_url, parse_remote_url, RemoteClientConfig, RemoteEndpoint, SharedSpectrum,
        DEFAULT_SPECTRUM_INTERVAL,
    };
    use std::collections::HashMap;
    use std::sync::atomic::AtomicBool;
@@ -1509,8 +1475,6 @@ mod tests {
                selected_rig_id: Arc::new(Mutex::new(None)),
                known_rigs: Arc::new(Mutex::new(Vec::new())),
                poll_interval: Duration::from_millis(100),
                spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
                spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
                spectrum: Arc::new(spectrum_tx),
                server_connected: Arc::new(AtomicBool::new(false)),
                rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -1556,8 +1520,6 @@ mod tests {
            selected_rig_id: Arc::new(Mutex::new(Some("sdr".to_string()))),
            known_rigs: Arc::new(Mutex::new(Vec::new())),
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -1573,130 +1535,6 @@ mod tests {
        assert_eq!(envelope.rig_id.as_deref(), Some("sdr"));
    }
    fn stream_test_config(spectrum_tx: watch::Sender<SharedSpectrum>) -> super::RemoteClientConfig {
        super::RemoteClientConfig {
            addr: "127.0.0.1:4530".to_string(),
            token: None,
            selected_rig_id: Arc::new(Mutex::new(Some("sdr".to_string()))),
            known_rigs: Arc::new(Mutex::new(Vec::new())),
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
            rig_states: Arc::new(RwLock::new(HashMap::new())),
            rig_spectrums: Arc::new(RwLock::new(HashMap::new())),
            rig_id_to_short_name: HashMap::new(),
            short_name_to_rig_id: Arc::new(RwLock::new(HashMap::new())),
            sat_passes: Arc::new(RwLock::new(None)),
            rig_meters: Arc::new(RwLock::new(HashMap::new())),
        }
    }
    /// A pushed frame reaches the watch channel the UI reads, with no request
    /// from the client beyond the initial subscribe.
    #[tokio::test]
    async fn spectrum_stream_publishes_pushed_frames() {
        use tokio::io::{AsyncBufReadExt, BufReader};
        let (spectrum_tx, mut spectrum_rx) = watch::channel(SharedSpectrum::default());
        let config = stream_test_config(spectrum_tx);
        let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
        let (client_io, mut server_io) = tokio::io::duplex(64 * 1024);
        let (client_read, mut client_write) = tokio::io::split(client_io);
        let mut client_read = BufReader::new(client_read);
        let task = tokio::spawn(async move {
            super::run_spectrum_stream(
                &config,
                &mut client_write,
                &mut client_read,
                "sdr",
                &mut shutdown_rx,
            )
            .await
        });
        // The server sees the subscribe, then pushes without being asked.
        let mut server = BufReader::new(&mut server_io);
        let mut subscribe = String::new();
        server.read_line(&mut subscribe).await.expect("subscribe");
        assert!(
            subscribe.contains("subscribe_spectrum"),
            "unexpected command: {subscribe}"
        );
        let frame = trx_protocol::SpectrumFrame {
            rig_id: "sdr".to_string(),
            spectrum: trx_core::rig::state::SpectrumData {
                bins: vec![-70.0, -30.0],
                center_hz: 14_200_000,
                sample_rate: 1_920_000,
                rds: None,
            },
            vchan_rds: None,
        };
        let mut line = serde_json::to_string(&frame).unwrap();
        line.push('\n');
        server_io.write_all(line.as_bytes()).await.expect("push");
        server_io.flush().await.expect("flush");
        spectrum_rx.changed().await.expect("spectrum published");
        let published = spectrum_rx.borrow().clone();
        let spectrum = published.frame.expect("spectrum present");
        assert_eq!(spectrum.center_hz, 14_200_000);
        assert_eq!(spectrum.bins, vec![-70.0, -30.0]);
        let _ = shutdown_tx.send(true);
        let _ = task.await;
    }
    /// An older server answers the unknown command with an error instead of
    /// frames.  That has to read as "poll instead", not as a dead connection.
    #[tokio::test]
    async fn spectrum_stream_falls_back_when_unsupported() {
        use tokio::io::{AsyncBufReadExt, BufReader};
        let (spectrum_tx, _spectrum_rx) = watch::channel(SharedSpectrum::default());
        let config = stream_test_config(spectrum_tx);
        let (_shutdown_tx, mut shutdown_rx) = watch::channel(false);
        let (client_io, mut server_io) = tokio::io::duplex(64 * 1024);
        let (client_read, mut client_write) = tokio::io::split(client_io);
        let mut client_read = BufReader::new(client_read);
        let task = tokio::spawn(async move {
            super::run_spectrum_stream(
                &config,
                &mut client_write,
                &mut client_read,
                "sdr",
                &mut shutdown_rx,
            )
            .await
        });
        let mut server = BufReader::new(&mut server_io);
        let mut subscribe = String::new();
        server.read_line(&mut subscribe).await.expect("subscribe");
        server_io
            .write_all(
                b"{\"success\":false,\"state\":null,\"error\":\"Invalid JSON: unknown variant\"}\n",
            )
            .await
            .expect("error response");
        server_io.flush().await.expect("flush");
        let outcome = task.await.expect("join").expect("stream result");
        assert!(
            matches!(outcome, super::SpectrumStreamOutcome::Unsupported),
            "an error response should fall back to polling"
        );
    }
    #[test]
    fn build_envelope_translates_short_name_to_server_rig_id() {
        let (spectrum_tx, _spectrum_rx) = watch::channel(SharedSpectrum::default());
@@ -1710,8 +1548,6 @@ mod tests {
            selected_rig_id: Arc::new(Mutex::new(Some("home-hf".to_string()))),
            known_rigs: Arc::new(Mutex::new(Vec::new())),
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -1744,8 +1580,6 @@ mod tests {
            selected_rig_id: Arc::new(Mutex::new(None)),
            known_rigs: Arc::new(Mutex::new(Vec::new())),
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -1770,8 +1604,6 @@ mod tests {
            selected_rig_id: Arc::new(Mutex::new(None)),
            known_rigs: Arc::new(Mutex::new(Vec::new())),
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -1812,8 +1644,6 @@ mod tests {
            selected_rig_id: Arc::new(Mutex::new(None)),
            known_rigs: known_rigs.clone(),
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -1887,8 +1717,6 @@ mod tests {
            selected_rig_id,
            known_rigs,
            poll_interval: Duration::from_millis(500),
            spectrum_interval: DEFAULT_SPECTRUM_INTERVAL,
            spectrum_stream_unsupported: Arc::new(AtomicBool::new(false)),
            spectrum: Arc::new(spectrum_tx),
            server_connected: Arc::new(AtomicBool::new(false)),
            rig_server_connected: Arc::new(RwLock::new(HashMap::new())),
@@ -17,8 +17,8 @@ use uuid::Uuid;
 use trx_core::audio::AudioStreamInfo;
 use trx_core::decode::{
-    AisMessage, AprsPacket, CwEvent, DecodedMessage, Ft8Message, SstvMessage, VdesMessage,
+    AisMessage, AprsPacket, CwEvent, DecodedMessage, Ft8Message, VdesMessage, WefaxMessage,
-    WefaxMessage, WsprMessage,
+    WsprMessage,
 };
 use trx_core::rig::state::{RigSnapshot, SpectrumData};
 use trx_core::{DynResult, RigRequest, RigState};
@@ -233,7 +233,6 @@ pub struct DecodeHistoryContext {
    pub ft2: DecodeHistory<Ft8Message>,
    pub wspr: DecodeHistory<WsprMessage>,
    pub wefax: DecodeHistory<WefaxMessage>,
    pub sstv: DecodeHistory<SstvMessage>,
 }
 impl Default for DecodeHistoryContext {
@@ -249,7 +248,6 @@ impl Default for DecodeHistoryContext {
            ft2: Arc::new(Mutex::new(VecDeque::new())),
            wspr: Arc::new(Mutex::new(VecDeque::new())),
            wefax: Arc::new(Mutex::new(VecDeque::new())),
            sstv: Arc::new(Mutex::new(VecDeque::new())),
        }
    }
 }
@@ -257,12 +255,9 @@ impl Default for DecodeHistoryContext {
 /// HTTP authentication configuration.
 pub struct HttpAuthConfig {
    pub enabled: bool,
-    pub users_file: String,
+    pub rx_passphrase: Option<String>,
-    pub bootstrap_admin_username: Option<String>,
+    pub control_passphrase: Option<String>,
-    pub bootstrap_admin_password: Option<String>,
+    pub tx_access_control_enabled: bool,
    pub bootstrap_read_enabled: bool,
    pub bootstrap_read_username: String,
    pub bootstrap_read_password: Option<String>,
    pub session_ttl_secs: u64,
    pub cookie_secure: bool,
    pub cookie_same_site: String,
@@ -274,12 +269,9 @@ impl Default for HttpAuthConfig {
    fn default() -> Self {
        Self {
            enabled: false,
-            users_file: "trx-http-users.json".to_string(),
+            rx_passphrase: None,
-            bootstrap_admin_username: None,
+            control_passphrase: None,
-            bootstrap_admin_password: None,
+            tx_access_control_enabled: true,
            bootstrap_read_enabled: true,
            bootstrap_read_username: "guest".to_string(),
            bootstrap_read_password: Some("guest".to_string()),
            session_ttl_secs: 480 * 60,
            cookie_secure: false,
            cookie_same_site: "Lax".to_string(),
@@ -298,10 +290,6 @@ pub struct HttpUiConfig {
    pub bandplan_region: String,
    pub decode_history_retention_min: u64,
    pub decode_history_retention_min_by_rig: HashMap<String, u64>,
    /// Where the station log is kept; `None` takes the default.
    pub logbook_path: Option<String>,
    /// The callsign contacts are logged under, and the operator by default.
    pub station_callsign: Option<String>,
 }
 impl Default for HttpUiConfig {
@@ -315,8 +303,6 @@ impl Default for HttpUiConfig {
            bandplan_region: "iaru_r1".to_string(),
            decode_history_retention_min: 24 * 60,
            decode_history_retention_min_by_rig: HashMap::new(),
            logbook_path: None,
            station_callsign: None,
        }
    }
 }
@@ -11,8 +11,6 @@ build = "build.rs"
 [dependencies]
 trx-core = { path = "../../../trx-core" }
 trx-frontend = { path = ".." }
 trx-logbook = { path = "../../trx-logbook" }
 chrono = { version = "0.4", default-features = false, features = ["clock", "serde"] }
 trx-protocol = { path = "../../../../src/trx-protocol" }
 tokio = { workspace = true, features = ["full"] }
 serde = { workspace = true, features = ["derive"] }
@@ -28,11 +26,7 @@ flate2 = { workspace = true }
 brotli = "7"
 rand = "0.8"
 hex = "0.4"
 argon2 = "0.5"
 pickledb = "0.5"
 dirs = "6"
 uuid = { workspace = true }
 ts-rs = "12.0.1"
 [dev-dependencies]
 tempfile = "3"
@@ -1,7 +1,3 @@
 import {
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore,
  hostState
@@ -144,22 +140,18 @@ function aisLatestByVessel(messages) {
  }
  return Array.from(byMmsi.values());
 }
 function aisRigMessages() {
  return forActiveRig(aisMessageHistory);
 }
 function updateAisSummary() {
  const plan = currentAisChannelPlan();
  if (aisChannelSummaryEl) {
    aisChannelSummaryEl.textContent = `A ${formatAisMhz(plan.aHz)} · B ${formatAisMhz(plan.bHz)}`;
  }
-  const rigMessages = aisRigMessages();
+  const vessels = aisLatestByVessel(aisMessageHistory);
  const vessels = aisLatestByVessel(rigMessages);
  if (aisVesselCountEl) {
    const count = vessels.length;
    aisVesselCountEl.textContent = `${count} vessel${count === 1 ? "" : "s"}`;
  }
  if (aisLatestSeenEl) {
-    const latest = rigMessages[0];
+    const latest = aisMessageHistory[0];
    if (!latest) {
      aisLatestSeenEl.textContent = "No traffic yet";
    } else {
@@ -168,18 +160,8 @@ function updateAisSummary() {
    }
  }
 }
 function aisSummaryText(msg) {
  const parts = [];
  if (msg.lat != null && msg.lon != null) parts.push(`${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}`);
  const motion = aisMotionText(msg);
  if (motion) parts.push(motion);
  const route = aisRouteText(msg);
  if (route && parts.length < 2) parts.push(route);
  if (!parts.length) return route || "no position reported";
  return parts.join(" · ");
 }
 function renderAisRow(msg) {
-  const row = document.createElement("details");
+  const row = document.createElement("div");
  row.className = "ais-message";
  const ts = msg._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], {
    hour: "2-digit",
@@ -192,8 +174,7 @@ function renderAisRow(msg) {
  const motion = aisMotionText(msg);
  const route = aisRouteText(msg);
  const distance = aisDistanceText(msg);
-  const pos = msg.lat != null && msg.lon != null ? `<a class="ais-pos-link" href="javascript:void(0)" data-ais-map="${msg.lat},${msg.lon}">${msg.lat.toFixed(5)}, ${msg.lon.toFixed(5)}</a>` : "";
+  const pos = msg.lat != null && msg.lon != null ? `<a class="ais-pos-link" href="javascript:void(0)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>` : "";
  const vesselUrl = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
  row.dataset.filterText = [
    name,
    msg.mmsi,
@@ -204,16 +185,7 @@ function renderAisRow(msg) {
    msg.destination,
    aisTypeLabel(msg.message_type)
  ].filter(Boolean).join(" ").toUpperCase();
-  row.innerHTML = `<summary class="decode-line"><span class="ais-time">${escapeAisHtml(ts)}</span><span class="ais-call">${nameHtml}</span><span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span><span class="decode-line-summary">${escapeAisHtml(aisSummaryText(msg))}</span><span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span>` + (distance ? `<span class="decode-line-distance">${escapeAisHtml(distance)}</span>` : "") + `</summary><div class="decode-expanded"><div class="decode-expanded-meta"><span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span><span>${escapeAisHtml(channel.freqText)}</span>` + (route ? `<span>${escapeAisHtml(route)}</span>` : "") + (motion ? `<span>${escapeAisHtml(motion)}</span>` : "") + `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span>` + (pos ? `<span>${pos}</span>` : "") + `</div><div class="aprs-row-actions">` + (msg.lat != null && msg.lon != null ? `<button class="aprs-inline-btn" type="button" data-ais-map="${msg.lat},${msg.lon}">Map</button>` : "") + (vesselUrl ? `<a class="aprs-inline-btn" href="${escapeAisHtml(vesselUrl)}" target="_blank" rel="noopener">Vessel</a>` : "") + `</div></div>`;
+  row.innerHTML = `<div class="ais-row-head"><span class="ais-time">${ts}</span><span class="ais-call">${nameHtml}</span><span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span><span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span></div><div class="ais-row-meta"><span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span>` + (route ? `<span class="ais-meta-text">${escapeAisHtml(route)}</span>` : "") + `<span class="ais-meta-text">${escapeAisHtml(channel.freqText)}</span></div><div class="ais-row-detail">` + (motion ? `<span>${escapeAisHtml(motion)}</span>` : `<span>No motion data</span>`) + (distance ? `<span>${escapeAisHtml(distance)}</span>` : "") + (pos ? `<span>${pos}</span>` : "") + `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span></div>`;
  row.querySelectorAll("[data-ais-map]").forEach((element) => {
    element.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const [lat, lon] = (element.dataset.aisMap ?? "").split(",").map(Number);
      if (lat == null || lon == null || !Number.isFinite(lat) || !Number.isFinite(lon)) return;
      aisWindow.navigateToAprsMap?.(lat, lon);
    });
  });
  applyAisFilterToRow(row);
  return row;
 }
@@ -230,9 +202,7 @@ function updateAisBar() {
  updateAisSummary();
  const isAis = (document.getElementById("mode")?.value || "").toUpperCase() === "AIS";
  const cutoffMs = Date.now() - AIS_BAR_WINDOW_MS;
-  const recent = aisMessageHistory.filter(
+  const recent = aisMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
    (msg) => (msg._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(msg.rig_id)
  );
  const messages = aisLatestByVessel(recent).slice(0, 8);
  if (!isAis || messages.length === 0) {
    aisBarOverlay.style.display = "none";
@@ -277,7 +247,7 @@ function renderAisHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of aisRigMessages()) {
+  for (const message of aisMessageHistory) {
    fragment.appendChild(renderAisRow(message));
  }
  aisMessagesEl.replaceChildren(fragment);
@@ -295,11 +265,9 @@ function addAisMessage(msg) {
  pruneAisMessageHistory();
  scheduleAisBarUpdate();
  scheduleAisHistoryRender();
-  plotAisMessage(msg);
+  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
-}
+    aisWindow.aisMapAddVessel(msg);
-function plotAisMessage(msg) {
+  }
  if (msg.lat == null || msg.lon == null || !aisWindow.aisMapAddVessel) return;
  aisWindow.aisMapAddVessel(msg);
 }
 function normalizeServerAisMessage(msg) {
  return {
@@ -309,10 +277,10 @@ function normalizeServerAisMessage(msg) {
 }
 function onServerAisBatch(messages) {
  if (!Array.isArray(messages) || messages.length === 0) return;
  if (aisStatus) aisStatus.textContent = "Receiving";
  const normalized = [];
  for (const msg of messages) {
    const next = normalizeServerAisMessage(msg);
    if (aisStatus && isActiveRigDecode(next.rig_id)) aisStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -320,7 +288,9 @@ function onServerAisBatch(messages) {
      minute: "2-digit",
      second: "2-digit"
    });
-    plotAisMessage(next);
+    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
      aisWindow.aisMapAddVessel(next);
    }
    normalized.push(next);
  }
  normalized.reverse();
@@ -352,9 +322,8 @@ if (aisFilterInput) {
  });
 }
 function onServerAis(msg) {
-  const message = normalizeServerAisMessage(msg);
+  if (aisStatus) aisStatus.textContent = "Receiving";
-  if (aisStatus && isActiveRigDecode(message.rig_id)) aisStatus.textContent = "Receiving";
+  addAisMessage(normalizeServerAisMessage(msg));
  addAisMessage(message);
 }
 updateAisSummary();
 window.trxPluginRuntime.registerDecoder({
@@ -363,13 +332,5 @@ window.trxPluginRuntime.registerDecoder({
  onBatch: onServerAisBatch,
  restore: onServerAisBatch,
  reset: resetAisHistoryView,
-  prune: pruneAisHistoryView,
+  prune: pruneAisHistoryView
  rerender: () => {
    updateAisBar();
    renderAisHistory();
  },
  // Oldest first, so vessel tracks are rebuilt in the order they happened.
  syncMap: () => {
    for (const entry of [...aisMessageHistory].reverse()) plotAisMessage(entry);
  }
 });
@@ -1,14 +1,13 @@
 import {
  aprsAgeText,
  aprsCategoryLabel,
  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsPacketRow
+  renderAprsInfo,
-} from "./chunk-REYSUJQ4.js";
+  renderLocalAprsSymbol
-import {
+} from "./chunk-ROTCLFXS.js";
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore,
  hostState
@@ -86,25 +85,20 @@ function aprsFilterMatch(pkt) {
  ].filter(Boolean).join(" ").toUpperCase();
  return haystack.includes(aprsFilterText);
 }
 function aprsRigPackets() {
  return forActiveRig(aprsPacketHistory);
 }
 function aprsVisiblePackets() {
-  const rigPackets = aprsRigPackets();
+  const packets = aprsCollapseDup ? collapseAprsDuplicates(aprsPacketHistory) : aprsPacketHistory;
  const packets = aprsCollapseDup ? collapseAprsDuplicates(rigPackets) : rigPackets;
  return packets.filter(aprsFilterMatch);
 }
 function updateAprsSummary() {
  const rigPackets = aprsRigPackets();
  const visible = aprsVisiblePackets();
  if (aprsTotalCountEl) {
-    aprsTotalCountEl.textContent = `${rigPackets.length} total`;
+    aprsTotalCountEl.textContent = `${aprsPacketHistory.length} total`;
  }
  if (aprsVisibleCountEl) {
    aprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (aprsLatestSeenEl) {
-    const latest = rigPackets[0];
+    const latest = aprsPacketHistory[0];
    if (!latest) {
      aprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -120,30 +114,51 @@ function updateAprsChipState() {
  aprsHideCrcBtn?.classList.toggle("active", aprsHideCrc);
  aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }
 async function copyAprsCoords(text) {
  try {
    const clipboard = Reflect.get(navigator, "clipboard");
    if (!clipboard) return;
    await clipboard.writeText(text);
    showAprsHint("Coordinates copied", 1200);
  } catch {
    showAprsHint("Copy failed", 1500);
  }
 }
 function renderAprsRow(pkt, isFresh) {
-  return renderAprsPacketRow(pkt, {
+  const row = document.createElement("div");
-    fresh: isFresh,
+  row.className = "aprs-packet";
-    distance: aprsDistanceText(pkt),
+  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-    onMap: (lat, lon) => {
+  if (isFresh) row.classList.add("aprs-packet-new");
-      aprsWindow.navigateToAprsMap?.(lat, lon);
+  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    },
+  const age = aprsAgeText(pkt._tsMs);
-    onCopy: (text) => {
+  const category = aprsPacketCategory(pkt);
-      void copyAprsCoords(text);
+  const categoryLabel = aprsCategoryLabel(category);
-    },
+  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-    onLog: (call, gridsquare) => {
+  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeAprsHtml(pkt.path)}</span>` : "";
-      aprsWindow.logContact?.({ call, gridsquare: gridsquare ?? void 0, decoder: "aprs" });
+  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-    }
+  const symbolHtml = renderLocalAprsSymbol(pkt, escapeAprsHtml);
  const posLink = pkt.lat != null && pkt.lon != null ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>` : "";
  const distance = aprsDistanceText(pkt);
  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
  row.innerHTML = `<div class="aprs-row-head"><span class="aprs-time">${ts}</span>` + symbolHtml + `<span class="aprs-call">${escapeAprsHtml(pkt.srcCall ?? "")}</span><span>&gt;${escapeAprsHtml(pkt.destCall || "")}</span><span class="${categoryClass}">${escapeAprsHtml(categoryLabel)}</span>` + pathBadge + crcBadge + `</div><div class="aprs-row-meta"><span class="aprs-meta-text">${escapeAprsHtml(age)}</span>` + (distance ? `<span class="aprs-meta-text">${escapeAprsHtml(distance)}</span>` : "") + `<span class="aprs-meta-text">${escapeAprsHtml(pkt.type || "--")}</span></div><div class="aprs-row-detail"><span title="${escapeAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` + (posLink ? `<span>${posLink}</span>` : "") + `</div><div class="aprs-row-actions">` + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div><details class="aprs-details"><summary>Details</summary><div class="aprs-details-grid"><span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.srcCall || "--")}</span><span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.destCall || "--")}</span><span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.type || "--")}</span><span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.path || "--")}</span><span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeAprsHtml(age)}</span><span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span><span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span><span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.info || "--")}</span><span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeAprsHtml(aprsHexBytes(pkt.info_bytes))}</span></div></details>`;
  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
    el.addEventListener("click", (evt) => {
      evt.preventDefault();
      const raw = el.dataset.aprsMap ?? "";
      const [lat, lon] = raw.split(",").map(Number);
      if (aprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
        aprsWindow.navigateToAprsMap(lat, lon);
      }
    });
  });
  const copyBtn = row.querySelector("[data-aprs-copy]");
  if (copyBtn) {
    copyBtn.addEventListener("click", () => {
      void (async () => {
        const raw = copyBtn.dataset.aprsCopy ?? "";
        try {
          const clipboard = Reflect.get(navigator, "clipboard");
          if (clipboard) {
            await clipboard.writeText(raw);
            showAprsHint("Coordinates copied", 1200);
          }
        } catch {
          showAprsHint("Copy failed", 1500);
        }
      })();
    });
  }
  return row;
 }
 function renderAprsHistory() {
  pruneAprsPacketHistory();
@@ -165,9 +180,7 @@ function updateAprsBar() {
  if (!aprsBarOverlay) return;
  const isPkt = (document.getElementById("mode")?.value || "").toUpperCase() === "PKT";
  const cutoffMs = Date.now() - APRS_BAR_WINDOW_MS;
-  const okFrames = aprsPacketHistory.filter(
+  const okFrames = aprsPacketHistory.filter((p) => p.crcOk && (p._tsMs ?? 0) >= cutoffMs);
    (p) => p.crcOk && (p._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(p.rig_id)
  );
  const frames = collapseAprsDuplicates(okFrames).slice(0, 8);
  const newestTsMs = frames.reduce((latest, pkt) => Math.max(latest, Number(pkt._tsMs) || 0), 0);
  if (!isPkt || frames.length === 0 || newestTsMs <= aprsBarDismissedAtMs) {
@@ -210,17 +223,15 @@ function pruneAprsHistoryView() {
  updateAprsBar();
  renderAprsHistory();
 }
 function plotAprsPacket(pkt) {
  if (pkt.lat == null || pkt.lon == null || !aprsWindow.aprsMapAddStation) return;
  aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
 }
 function addAprsPacket(pkt) {
  const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
  pkt._tsMs = tsMs;
  pkt._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
  aprsPacketHistory.unshift(pkt);
  pruneAprsPacketHistory();
-  plotAprsPacket(pkt);
+  if (pkt.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
  }
  if (pkt.crcOk) scheduleAprsBarUpdate();
  scheduleAprsHistoryRender();
 }
@@ -229,15 +240,17 @@ function normalizeServerAprsPacket(pkt) {
 }
 function onServerAprsBatch(packets) {
  if (!Array.isArray(packets) || packets.length === 0) return;
  if (aprsStatus) aprsStatus.textContent = "Receiving";
  const normalized = [];
  let hasCrcOk = false;
  for (const pkt of packets) {
    const next = normalizeServerAprsPacket(pkt);
    if (aprsStatus && isActiveRigDecode(next.rig_id)) aprsStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    plotAprsPacket(next);
+    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
    }
    if (next.crcOk) hasCrcOk = true;
    normalized.push(next);
  }
@@ -291,9 +304,8 @@ if (aprsFilterInput) {
  });
 }
 function onServerAprs(pkt) {
-  const packet = normalizeServerAprsPacket(pkt);
+  if (aprsStatus) aprsStatus.textContent = "Receiving";
-  if (aprsStatus && isActiveRigDecode(packet.rig_id)) aprsStatus.textContent = "Receiving";
+  addAprsPacket(normalizeServerAprsPacket(pkt));
  addAprsPacket(packet);
 }
 renderAprsHistory();
 window.trxPluginRuntime.registerDecoder({
@@ -302,13 +314,5 @@ window.trxPluginRuntime.registerDecoder({
  onBatch: onServerAprsBatch,
  restore: onServerAprsBatch,
  reset: resetAprsHistoryView,
-  prune: pruneAprsHistoryView,
+  prune: pruneAprsHistoryView
  rerender: () => {
    updateAprsBar();
    renderAprsHistory();
  },
  // Oldest first, so station tracks are rebuilt in the order they happened.
  syncMap: () => {
    for (const entry of [...aprsPacketHistory].reverse()) plotAprsPacket(entry);
  }
 });
@@ -1,6 +1,3 @@
 import {
  hasAuthRole
 } from "./chunk-PISLBJGN.js";
 import {
  hostState
 } from "./chunk-KL66PICH.js";
@@ -16,17 +13,15 @@ var bgdWindow = window;
      return d.id;
    });
  }
-  let backgroundDecodeRoles = [];
+  let backgroundDecodeRole = null;
  let currentRigId = null;
  let currentConfig = null;
  let bookmarkList = [];
  let statusInterval = null;
  let bgdDirty = false;
-  let statusByBookmark = /* @__PURE__ */ new Map();
+  function initBackgroundDecode(rigId, role) {
-  let lastStatus = null;
+    backgroundDecodeRole = role;
-  function initBackgroundDecode(rigId, roles) {
+    currentRigId = rigId || null;
    backgroundDecodeRoles = roles;
    currentRigId = rigId || hostState.lastActiveRigId || null;
    if (currentRigId) loadBackgroundDecode();
    startStatusPolling();
  }
@@ -113,7 +108,7 @@ var bgdWindow = window;
    }
    setCheckbox("background-decode-enabled", currentConfig.enabled);
    renderBookmarkChecklist();
-    const isControl = isControlRole();
+    const isControl = backgroundDecodeRole === "control" || hostState.authEnabled === false;
    const panel = document.getElementById("background-decode-panel");
    if (panel) {
      panel.querySelectorAll("input, select, button.sch-write").forEach(function(el) {
@@ -124,10 +119,6 @@ var bgdWindow = window;
    const resetBtn = document.getElementById("background-decode-reset-btn");
    if (saveBtn) saveBtn.style.display = isControl ? "" : "none";
    if (resetBtn) resetBtn.style.display = isControl ? "" : "none";
    syncSaveButton();
  }
  function currentFilterText() {
    return document.getElementById("bgd-bookmark-filter")?.value ?? "";
  }
  function renderBookmarkChecklist(filterText = "") {
    const container = document.getElementById("bgd-bookmark-checklist");
@@ -143,49 +134,20 @@ var bgdWindow = window;
      return text.indexOf(filter) >= 0;
    }) : all;
    if (filtered.length === 0) {
-      container.innerHTML = '<div class="bgd-checklist-empty">' + escHtml(emptyListText(all.length)) + "</div>";
+      container.innerHTML = '<div class="bgd-checklist-empty">' + (all.length === 0 ? "No supported bookmarks available." : "No bookmarks match filter.") + "</div>";
      renderSelectionSummary();
      return;
    }
    filtered.forEach(function(bookmark) {
      const row = document.createElement("label");
      row.className = "bgd-checklist-row";
      row.dataset.bmId = bookmark.id;
      const decoders = bookmarkDecoderKinds(bookmark);
-      const selected = selectedIds.has(bookmark.id);
+      const checked = selectedIds.has(bookmark.id) ? " checked" : "";
-      if (selected) row.classList.add("is-selected");
+      row.innerHTML = '<input type="checkbox"' + checked + ' data-bm-id="' + escHtml(bookmark.id) + '" /><span class="bgd-checklist-name">' + escHtml(bookmark.name) + '</span><span class="bgd-checklist-meta">' + escHtml(formatFreq(bookmark.freq_hz) + " " + bookmark.mode + " · " + decoders.join("/").toUpperCase()) + "</span>";
      row.innerHTML = '<input type="checkbox"' + (selected ? " checked" : "") + ' data-bm-id="' + escHtml(bookmark.id) + '" /><span class="bgd-checklist-name">' + escHtml(bookmark.name) + '</span><span class="bgd-checklist-meta">' + escHtml(formatFreq(bookmark.freq_hz)) + '<span class="bgd-checklist-mode">' + escHtml(bookmark.mode + " · " + decoders.join("/").toUpperCase()) + "</span></span>" + stateBadgeHtml(bookmark.id, selected);
      row.querySelector("input")?.addEventListener("change", function(e) {
        onChecklistToggle(bookmark.id, e.currentTarget.checked);
      });
      container.appendChild(row);
    });
    renderSelectionSummary();
  }
  function emptyListText(supportedCount) {
    if (supportedCount > 0) return "No bookmark matches that filter.";
    if (bookmarkList.length > 0) {
      return "None of your bookmarks name a decoder that can run in the background. Give one a decoder on the Bookmarks tab to list it here.";
    }
    return "No bookmarks yet. Save one on the Bookmarks tab and it can be decoded here.";
  }
  function stateBadgeHtml(bookmarkId, selected) {
    if (!selected) return '<span class="bgd-state" data-state="unselected"></span>';
    const entry = statusByBookmark.get(bookmarkId);
    const state = entry?.state ?? (currentConfig?.enabled ? "pending" : "disabled");
    return '<span class="bgd-state" data-state="' + escHtml(state) + '" title="' + escHtml(stateHelp(state)) + '"><span class="bgd-state-dot"></span>' + escHtml(prettyState(state)) + "</span>";
  }
  function renderSelectionSummary() {
    const el = document.getElementById("bgd-selection-summary");
    if (!el) return;
    const selected = currentConfig?.bookmark_ids.length ?? 0;
    if (selected === 0) {
      el.textContent = "Nothing selected — background decoding is idle.";
      return;
    }
    const active = [...statusByBookmark.values()].filter((entry) => entry.state === "active").length;
    const noun = `${String(selected)} bookmark${selected === 1 ? "" : "s"} selected`;
    el.textContent = currentConfig?.enabled ? `${noun}, ${String(active)} decoding now.` : `${noun}. Switch Enabled on to start decoding them.`;
  }
  function onChecklistToggle(bookmarkId, checked) {
    if (!currentConfig) {
@@ -220,7 +182,7 @@ var bgdWindow = window;
    }).catch(function(err) {
      showToast(`Save failed: ${errorMessage(err)}`, true);
    }).finally(function() {
-      syncSaveButton();
+      if (btn) btn.disabled = false;
    });
  }
  async function resetBackgroundDecode() {
@@ -248,83 +210,59 @@ var bgdWindow = window;
    });
  }
  function renderStatus(status) {
-    lastStatus = status;
+    const card = document.getElementById("background-decode-status-card");
-    statusByBookmark = new Map(
+    if (!card) return;
-      (status.entries ?? []).filter((entry) => typeof entry.bookmark_id === "string" && entry.bookmark_id.length > 0).map((entry) => [entry.bookmark_id, entry])
+    const entries = status.entries ?? [];
-    );
+    if (!entries.length) {
-    renderSpanSummary();
+      card.textContent = "No background decode bookmarks configured.";
    renderBookmarkChecklist(currentFilterText());
  }
  function renderSpanSummary() {
    const el = document.getElementById("bgd-span-summary");
    if (!el) return;
    const status = lastStatus;
    if (!status) {
      el.textContent = "";
      return;
    }
-    if (!status.active_rig) {
+    const summary = [];
-      el.textContent = "This rig is not the one playing audio.";
+    if (status.active_rig) {
-      el.dataset.tone = "warn";
+      if (typeof status.center_hz === "number" && Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
-      return;
+      if (typeof status.sample_rate === "number" && Number.isFinite(status.sample_rate) && status.sample_rate > 0) summary.push("Span ±" + formatFreq(status.sample_rate / 2));
-    }
+    } else {
-    const centre = typeof status.center_hz === "number" && Number.isFinite(status.center_hz) ? formatFreq(status.center_hz) : null;
+      summary.push("This rig is not currently selected for audio.");
    const half = typeof status.sample_rate === "number" && Number.isFinite(status.sample_rate) && status.sample_rate > 0 ? formatFreq(status.sample_rate / 2) : null;
    el.dataset.tone = "";
    el.textContent = centre && half ? `Span ${centre} ±${half}` : centre ? `Centre ${centre}` : "";
  }
  function stateHelp(state) {
    switch (state) {
      case "active":
        return "Decoding on a hidden channel.";
      case "out_of_span":
        return "Outside the span the rig is tuned across, so it cannot be heard from here.";
      case "waiting_for_spectrum":
        return "Waiting for the first spectrum frame from the rig.";
      case "waiting_for_user":
        return "Nobody is listening to this rig, so no audio is being pulled.";
      case "missing_bookmark":
        return "The bookmark this was selected from is gone.";
      case "no_supported_decoders":
        return "No decoder that runs in the background can decode this bookmark.";
      case "disabled":
        return "Background decoding is switched off.";
      case "handled_by_scheduler":
      case "scheduler_has_control":
        return "The scheduler is running this bookmark instead.";
      case "handled_by_virtual_channel":
        return "A virtual channel is already on this frequency.";
      case "pending":
        return "Selected, and not started yet — save to apply.";
      default:
        return "Selected, but not decoding.";
    }
    let html = summary.length ? '<div style="margin-bottom:0.8rem;color:var(--text-muted);">' + escHtml(summary.join(" · ")) + "</div>" : "";
    html += '<div class="bgd-status-list">';
    entries.forEach(function(entry) {
      const name = entry.bookmark_name || entry.bookmark_id || "Unknown bookmark";
      const parts = [];
      if (typeof entry.freq_hz === "number" && Number.isFinite(entry.freq_hz)) parts.push(formatFreq(entry.freq_hz));
      if (entry.mode) parts.push(entry.mode);
      if (Array.isArray(entry.decoder_kinds) && entry.decoder_kinds.length) {
        parts.push(entry.decoder_kinds.join("/").toUpperCase());
      }
      html += '<div class="bgd-status-row"><div><div class="bgd-status-name">' + escHtml(name) + '</div><div class="bgd-status-meta">' + escHtml(parts.join(" · ")) + '</div></div><div class="bgd-status-state" data-state="' + escHtml(entry.state || "inactive") + '"><svg class="bgd-state-dot" viewBox="0 0 8 8"><circle cx="4" cy="4" r="3.5"/></svg>' + escHtml(prettyState(entry.state)) + "</div></div>";
    });
    html += "</div>";
    card.innerHTML = html;
  }
  function prettyState(state) {
    switch (state) {
      case "active":
-        return "Decoding";
+        return "✓ Active";
      case "out_of_span":
-        return "Out of span";
+        return "△ Out of span";
      case "waiting_for_spectrum":
-        return "Waiting for spectrum";
+        return "△ Waiting";
      case "waiting_for_user":
-        return "Nobody listening";
+        return "△ No user";
      case "missing_bookmark":
-        return "Bookmark gone";
+        return "✗ Missing";
      case "no_supported_decoders":
-        return "No decoder";
+        return "✗ Unsupported";
      case "disabled":
-        return "Off";
+        return "△ Disabled";
      case "handled_by_scheduler":
        return "△ Scheduler";
      case "scheduler_has_control":
-        return "Scheduler has it";
+        return "△ Scheduler";
      case "handled_by_virtual_channel":
-        return "On a channel";
+        return "△ VChan";
      case "pending":
        return "Not saved";
      default:
-        return "Idle";
+        return "△ Inactive";
    }
  }
  function setCheckbox(id, value) {
@@ -347,21 +285,13 @@ var bgdWindow = window;
  function markBgdDirty() {
    if (bgdDirty) return;
    bgdDirty = true;
-    syncSaveButton();
+    const btn = document.getElementById("background-decode-save-btn");
    if (btn) btn.classList.add("sch-dirty");
  }
  function clearBgdDirty() {
    bgdDirty = false;
    syncSaveButton();
  }
  function syncSaveButton() {
    const btn = document.getElementById("background-decode-save-btn");
-    if (!btn) return;
+    if (btn) btn.classList.remove("sch-dirty");
    btn.classList.toggle("sch-dirty", bgdDirty);
    btn.disabled = !bgdDirty || !isControlRole();
    btn.title = bgdDirty ? "Apply these bookmarks to the background decoder" : "No changes to save";
  }
  function isControlRole() {
    return hasAuthRole(backgroundDecodeRoles, "control") || hostState.authEnabled === false;
  }
  function showToast(msg, isError) {
    const el = document.getElementById("background-decode-toast");
@@ -381,7 +311,7 @@ var bgdWindow = window;
      return bm.id;
    });
    currentConfig.bookmark_ids = ids;
-    renderBookmarkChecklist(currentFilterText());
+    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
    markBgdDirty();
  }
  function deselectAllBookmarks() {
@@ -389,7 +319,7 @@ var bgdWindow = window;
      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
    }
    currentConfig.bookmark_ids = [];
-    renderBookmarkChecklist(currentFilterText());
+    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
    markBgdDirty();
  }
  function wireBackgroundDecodeEvents() {
@@ -404,9 +334,7 @@ var bgdWindow = window;
    if (enabledCb && !enabledCb._wired) {
      enabledCb._wired = true;
      enabledCb.addEventListener("change", function() {
        if (currentConfig) currentConfig.enabled = enabledCb.checked;
        markBgdDirty();
        renderBookmarkChecklist(currentFilterText());
      });
    }
    const selectAllBtn = document.getElementById("bgd-select-all-btn");
@@ -1,6 +1,3 @@
 import {
  hasAuthRole
 } from "./chunk-PISLBJGN.js";
 import {
  hostCore,
  hostState
@@ -45,7 +42,7 @@ function bmEsc(str) {
  return d.innerHTML;
 }
 function bmCanControl() {
-  return !hostState.authEnabled || hasAuthRole(hostState.authRoles, "write");
+  return !hostState.authEnabled || hostState.authRole === "control";
 }
 function bmSyncAccess() {
  const canCtrl = bmCanControl();
@@ -214,12 +211,6 @@ function bmBuildDecoderCheckboxes() {
    container.appendChild(label);
  });
 }
 function bmSyncDigSidebandVisibility() {
  const label = bmOptionalEl("bm-dig-sideband-label");
  if (!label) return;
  const mode = (bmEl("bm-mode").value || "").trim().toUpperCase();
  label.style.display = mode === "DIG" ? "" : "none";
 }
 function bmOpenForm(bm) {
  const wrap = bmEl("bm-form-wrap");
  if (!wrap) return;
@@ -233,9 +224,7 @@ function bmOpenForm(bm) {
  bmEl("bm-locator").value = bm ? bm.locator || "" : "";
  bmEl("bm-category-input").value = bm ? bm.category || "" : "";
  bmEl("bm-comment").value = bm ? bm.comment || "" : "";
  bmEl("bm-dig-sideband").value = bm ? bm.dig_sideband || "" : "";
  bmWriteDecoders(bm?.decoders ?? []);
  bmSyncDigSidebandVisibility();
  bmEl("bm-form-title").textContent = bm ? "Edit Bookmark" : "Add Bookmark";
  wrap.style.display = "flex";
  bmEl("bm-name").focus();
@@ -271,7 +260,6 @@ async function bmSave(e) {
  const category = bmEl("bm-category-input").value.trim();
  const comment = bmEl("bm-comment").value.trim();
  const decoders = bmReadDecoders();
  const dig_sideband = mode.toUpperCase() === "DIG" ? bmEl("bm-dig-sideband").value || null : null;
  const formError = bmEl("bm-form-error");
  if (formError) formError.textContent = "";
  if (!name || !Number.isFinite(freq_hz) || !mode) {
@@ -288,8 +276,7 @@ async function bmSave(e) {
    locator: locator || null,
    category,
    comment,
-    decoders,
+    decoders
    dig_sideband
  };
  try {
    let resp;
@@ -341,7 +328,6 @@ function bmApply(bm) {
    const modeEl = document.getElementById("mode");
    if (modeEl) {
      modeEl.value = (bm.mode || "").toUpperCase();
      hostCore.syncModePicker();
    }
    if (bm.bandwidth_hz) {
      hostState.currentBandwidthHz = bm.bandwidth_hz;
@@ -354,12 +340,6 @@ function bmApply(bm) {
    }
    const tunePromise = (async () => {
      await bridge.trx.modules.vchan?.takeSchedulerControl();
      if ((bm.mode || "").toUpperCase() === "DIG" && bm.dig_sideband) {
        const p = bm.dig_sideband.toLowerCase();
        if (p === "auto" || p === "usb" || p === "lsb") {
          await hostCore.postPath("/set_sdr_dig_sideband?policy=" + encodeURIComponent(p));
        }
      }
      const onVirtual = await bridge.trx.modules.vchan?.interceptMode(bm.mode) ?? false;
      if (!onVirtual) {
        await hostCore.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
@@ -612,7 +592,6 @@ function bmPopulateScopePicker() {
  bmEl("bm-form").addEventListener("submit", (event) => {
    void bmSave(event);
  });
  bmEl("bm-mode").addEventListener("input", bmSyncDigSidebandVisibility);
  bmEl("bm-form-cancel").addEventListener("click", bmCloseForm);
  const formWrap = bmEl("bm-form-wrap");
  if (formWrap) {
@@ -1,7 +1,3 @@
 import {
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -152,33 +148,14 @@ function initializeFtxDecoder(config) {
      second: "2-digit"
    });
    row.innerHTML = `<span class="ft8-time">${time}</span><span class="ft8-snr">${snr?.toFixed(1) ?? "--"}</span><span class="ft8-dt">${delta?.toFixed(2) ?? "--"}</span><span class="ft8-freq">${frequency?.toFixed(0) ?? "--"}</span><span class="ft8-msg">${renderMessage(raw)}</span>`;
    const station = bridge.ft8ExtractLikelyCallsign?.(raw) ?? extractFtxCallsign(raw);
    if (station) {
      const log = document.createElement("button");
      log.type = "button";
      log.className = "ft8-log-btn";
      log.textContent = "Log";
      log.title = `Start a log entry for ${station}`;
      log.addEventListener("click", (event) => {
        event.stopPropagation();
        const details = bridge.ft8ExtractLocatorDetails?.(raw) ?? extractFtxLocatorDetails(raw);
        bridge.logContact?.({
          call: station,
          gridsquare: details.find((detail) => detail.station === station)?.grid,
          decoder: id
        });
      });
      row.appendChild(log);
    }
    return row;
  };
  const render = () => {
    prune();
    if (!messagesElement) return;
    const rigMessages = forActiveRig(history);
    const fragment = document.createDocumentFragment();
    let count = 0;
-    for (const message of rigMessages) {
+    for (const message of history) {
      if (count >= 200) break;
      if (filterText && !(message.message ?? "").toUpperCase().includes(filterText)) continue;
      fragment.appendChild(renderRow(message));
@@ -186,26 +163,20 @@ function initializeFtxDecoder(config) {
    }
    messagesElement.replaceChildren(fragment);
  };
-  const plotLocator = (message) => {
+  const normalize = (message) => {
    const raw = message.message ?? "";
    const locatorDetails = bridge.ft8ExtractLocatorDetails?.(raw) ?? extractFtxLocatorDetails(raw);
    const grids = locatorDetails.length > 0 ? locatorDetails.map(({ grid }) => grid) : bridge.ft8ExtractAllGrids?.(raw) ?? extractFtxGrids(raw);
    if (grids.length === 0) return;
    const station = bridge.ft8ExtractLikelyCallsign?.(raw) ?? extractFtxCallsign(raw);
    const frequency = displayFrequency(message.freq_hz);
-    bridge.mapAddLocator?.(raw, grids, id, station, {
+    if (grids.length > 0) {
-      ...message,
+      bridge.mapAddLocator?.(raw, grids, id, station, {
-      freq_hz: frequency ?? message.freq_hz,
+        ...message,
-      locator_details: locatorDetails
+        freq_hz: frequency ?? message.freq_hz,
-    });
+        locator_details: locatorDetails
-  };
+      });
-  const normalize = (message) => {
+    }
    const frequency = displayFrequency(message.freq_hz);
    plotLocator(message);
    return {
      // The rig that heard it, kept so the mini view can tell a decode of the
      // rig on screen from one a background rig made on another band.
      rig_id: message.rig_id ?? null,
      receiver: bridge.getDecodeRigMeta?.() ?? null,
      ts_ms: message.ts_ms,
      snr_db: message.snr_db,
@@ -217,9 +188,7 @@ function initializeFtxDecoder(config) {
  };
  const receiveBatch = (messages) => {
    if (messages.length === 0) return;
-    if (status && messages.some((message) => isActiveRigDecode(message.rig_id))) {
+    if (status) status.textContent = "Receiving";
      status.textContent = "Receiving";
    }
    history = messages.map(normalize).reverse().concat(history);
    prune();
    bridge.setFt8FamilyBarDecoder?.(id);
@@ -233,7 +202,7 @@ function initializeFtxDecoder(config) {
    bridge.clearMapMarkersByType?.(id);
  };
  const barFrames = () => {
-    const recent = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 9e5 && isActiveRigDecode(message.rig_id)).slice(0, 8);
+    const recent = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 9e5).slice(0, 8);
    let html = "";
    for (const message of recent) {
      const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
@@ -257,15 +226,7 @@ function initializeFtxDecoder(config) {
      prune();
      render();
    },
-    reset,
+    reset
    rerender: () => {
      bridge.updateFt8Bar?.();
      render();
    },
    // Oldest first, so the map builds the grids up in the order they were heard.
    syncMap: () => {
      for (const message of [...history].reverse()) plotLocator(message);
    }
  });
  bridge.registerFt8FamilyBarRenderer?.(id, barFrames);
  const updatePeriod = () => {
@@ -1,136 +0,0 @@
 // src/api/auth.ts
 var AUTH_ROLES = ["guest", "read", "control", "transmit", "write", "administrator"];
 var AUTH_ADMIN_ROLES = AUTH_ROLES.filter((role) => role !== "guest");
 var AUTH_ROLE_LABELS = {
  guest: "Guest",
  read: "Read",
  control: "Control",
  transmit: "Transmit",
  write: "Write",
  administrator: "Administrator"
 };
 function isAuthRole(value) {
  return typeof value === "string" && AUTH_ROLES.includes(value);
 }
 function normalizeAuthRoles(roles) {
  return AUTH_ROLES.filter((role) => roles.includes(role));
 }
 function hasAuthRole(roles, required) {
  return roles.includes("administrator") || roles.includes(required) || required === "read" && roles.includes("guest") || required === "read" && (roles.includes("control") || roles.includes("transmit"));
 }
 function hasAccountControls(roles) {
  return roles.length > 0 && !roles.includes("guest");
 }
 function decodeRoles(value, context) {
  if (!Array.isArray(value) || !value.every(isAuthRole)) {
    throw new TypeError(`${context} has invalid roles`);
  }
  return normalizeAuthRoles(value);
 }
 function decodeAuthSession(value) {
  if (typeof value !== "object" || value === null) {
    throw new TypeError("The authentication response is malformed");
  }
  const session = value;
  if (typeof session.authenticated !== "boolean") {
    throw new TypeError("The authentication response has no authenticated flag");
  }
  if (session.auth_disabled !== void 0 && typeof session.auth_disabled !== "boolean") {
    throw new TypeError("The authentication response has an invalid auth_disabled flag");
  }
  const decoded = {
    authenticated: session.authenticated,
    roles: decodeRoles(session.roles, "The authentication response")
  };
  if (session.username !== void 0) {
    if (typeof session.username !== "string") throw new TypeError("The authentication response has an invalid username");
    decoded.username = session.username;
  }
  if (session.auth_disabled !== void 0) decoded.auth_disabled = session.auth_disabled;
  return decoded;
 }
 var authDisabledSession = {
  authenticated: true,
  roles: [...AUTH_ADMIN_ROLES],
  auth_disabled: true
 };
 async function fetchAuthSession() {
  try {
    const response = await fetch("/auth/session");
    if (response.status === 404) return authDisabledSession;
    if (!response.ok) return { authenticated: false, roles: [] };
    return decodeAuthSession(await response.json());
  } catch (error) {
    console.error("Auth check failed:", error);
    return { authenticated: false, roles: [] };
  }
 }
 async function login(username, password) {
  const response = await fetch("/auth/login", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ username, password })
  });
  if (response.status === 404) return authDisabledSession;
  if (!response.ok) {
    const message = await response.text();
    throw new Error(message || "Login failed");
  }
  return decodeAuthSession(await response.json());
 }
 async function userRequest(path, init) {
  const response = await fetch(path, init);
  if (!response.ok) {
    const payload = await response.json().catch(() => ({}));
    throw new Error(payload.error || `User operation failed (${response.status})`);
  }
  return response;
 }
 async function listUsers() {
  const value = await userRequest("/auth/users").then((response) => response.json());
  if (!Array.isArray(value) || !value.every((user) => {
    if (typeof user !== "object" || user === null) return false;
    const record = user;
    return typeof record.username === "string" && typeof record.enabled === "boolean" && Array.isArray(record.roles) && record.roles.every(isAuthRole);
  })) {
    throw new TypeError("The user list response is malformed");
  }
  return value.map((user) => ({ ...user, roles: normalizeAuthRoles(user.roles) }));
 }
 async function createUser(username, password, roles, enabled = true) {
  await userRequest("/auth/users", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ username, password, roles, enabled }) });
 }
 async function updateUser(username, changes) {
  await userRequest(`/auth/users/${encodeURIComponent(username)}`, { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify(changes) });
 }
 async function changeOwnPassword(currentPassword, newPassword) {
  await userRequest("/auth/account/password", {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ current_password: currentPassword, new_password: newPassword })
  });
 }
 async function deleteUser(username) {
  await userRequest(`/auth/users/${encodeURIComponent(username)}`, { method: "DELETE" });
 }
 async function logout() {
  const response = await fetch("/auth/logout", { method: "POST" });
  if (response.status !== 404 && !response.ok) throw new Error("Logout failed");
 }
 export {
  AUTH_ROLES,
  AUTH_ADMIN_ROLES,
  AUTH_ROLE_LABELS,
  normalizeAuthRoles,
  hasAuthRole,
  hasAccountControls,
  fetchAuthSession,
  login,
  listUsers,
  createUser,
  updateUser,
  changeOwnPassword,
  deleteUser,
  logout
 };
@@ -1,273 +0,0 @@
 // src/plugins/aprs-shared.ts
 function escapeAprsHtml(value) {
  return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 function aprsPacketCategory(packet) {
  const type = (packet.type ?? "").toLowerCase();
  const info = (packet.info ?? "").toLowerCase();
  if (packet.lat != null && packet.lon != null || type.includes("position")) return "position";
  if (type.includes("message") || info.startsWith(":")) return "message";
  if (type.includes("weather") || info.startsWith("_")) return "weather";
  if (type.includes("telemetry") || info.startsWith("t#")) return "telemetry";
  return "other";
 }
 function aprsCategoryLabel(category) {
  switch (category) {
    case "position":
      return "Position";
    case "message":
      return "Message";
    case "weather":
      return "Weather";
    case "telemetry":
      return "Telemetry";
    default:
      return "Other";
  }
 }
 function aprsAgeText(timestampMs) {
  if (typeof timestampMs !== "number" || !Number.isFinite(timestampMs)) return "just now";
  const seconds = Math.round(Math.max(0, Date.now() - timestampMs) / 1e3);
  if (seconds < 5) return "just now";
  if (seconds < 60) return `${String(seconds)}s ago`;
  const minutes = Math.round(seconds / 60);
  if (minutes < 60) return `${String(minutes)}m ago`;
  return `${String(Math.round(minutes / 60))}h ago`;
 }
 function aprsPacketSignature(packet) {
  return [
    packet.srcCall ?? "",
    packet.destCall ?? "",
    packet.path ?? "",
    packet.info ?? "",
    packet.type ?? "",
    packet.lat?.toFixed(4) ?? "",
    packet.lon?.toFixed(4) ?? ""
  ].join("|");
 }
 function collapseAprsDuplicates(packets) {
  const seen = /* @__PURE__ */ new Set();
  return packets.filter((packet) => {
    const signature = aprsPacketSignature(packet);
    if (seen.has(signature)) return false;
    seen.add(signature);
    return true;
  });
 }
 function aprsHexBytes(bytes) {
  if (!bytes?.length) return "--";
  return bytes.map((byte) => byte.toString(16).toUpperCase().padStart(2, "0")).join(" ");
 }
 function renderAprsInfo(packet) {
  if (packet.info_bytes?.length) {
    return packet.info_bytes.map((byte) => renderAprsByte(byte)).join("");
  }
  return Array.from(packet.info ?? "", (character) => renderAprsCharacter(character)).join("");
 }
 function renderAprsByte(byte) {
  return byte >= 32 && byte <= 126 ? escapeAprsCharacter(String.fromCharCode(byte)) : `<span class="aprs-byte">0x${byte.toString(16).toUpperCase().padStart(2, "0")}</span>`;
 }
 function renderAprsCharacter(character) {
  const code = character.charCodeAt(0);
  return code >= 32 && code <= 126 ? escapeAprsCharacter(character) : `<span class="aprs-byte">0x${code.toString(16).toUpperCase().padStart(2, "0")}</span>`;
 }
 function escapeAprsCharacter(character) {
  if (character === "<") return "&lt;";
  if (character === ">") return "&gt;";
  if (character === "&") return "&amp;";
  if (character === '"') return "&quot;";
  return character;
 }
 var APRS_SPRITE_COLUMNS = 16;
 var APRS_SPRITE_CELL_PX = 24;
 var APRS_SPRITE_FIRST_CODE = 33;
 var APRS_SPRITE_LAST_CODE = 126;
 function aprsSpriteOffset(code) {
  if (code.length !== 1) return null;
  const point = code.charCodeAt(0);
  if (point < APRS_SPRITE_FIRST_CODE || point > APRS_SPRITE_LAST_CODE) return null;
  const index = point - APRS_SPRITE_FIRST_CODE;
  const column = index % APRS_SPRITE_COLUMNS;
  const row = Math.floor(index / APRS_SPRITE_COLUMNS);
  return `${String(-column * APRS_SPRITE_CELL_PX)}px ${String(-row * APRS_SPRITE_CELL_PX)}px`;
 }
 function aprsSymbolSprite(symbolTable, symbolCode) {
  if (!symbolTable || !symbolCode) return null;
  const symbolOffset = aprsSpriteOffset(symbolCode);
  if (!symbolOffset) return null;
  if (symbolTable === "/") {
    return {
      className: "aprs-symbol-primary",
      backgroundPosition: symbolOffset,
      label: `Primary APRS symbol ${symbolTable}${symbolCode}`
    };
  }
  if (symbolTable === "\\") {
    return {
      className: "aprs-symbol-alternate",
      backgroundPosition: symbolOffset,
      label: `Alternate APRS symbol ${symbolTable}${symbolCode}`
    };
  }
  const overlayOffset = aprsSpriteOffset(symbolTable);
  if (!overlayOffset) return null;
  return {
    className: "aprs-symbol-overlaid",
    backgroundPosition: `${overlayOffset}, ${symbolOffset}`,
    label: `Alternate APRS symbol \\${symbolCode} with overlay ${symbolTable}`
  };
 }
 function renderAprsSymbolSlot(packet, escapeHtml) {
  return renderLocalAprsSymbol(packet, escapeHtml) || '<span class="aprs-symbol aprs-symbol-empty" aria-hidden="true"></span>';
 }
 function renderLocalAprsSymbol(packet, escapeHtml) {
  if (!packet.symbolTable || !packet.symbolCode) return "";
  const sprite = aprsSymbolSprite(packet.symbolTable, packet.symbolCode);
  if (sprite) {
    return `<span class="aprs-symbol ${sprite.className}" role="img" style="background-position:${sprite.backgroundPosition}" title="${escapeHtml(sprite.label)}" aria-label="${escapeHtml(sprite.label)}"></span>`;
  }
  const symbol = escapeHtml(packet.symbolCode);
  const table = packet.symbolTable === "/" ? "Primary" : "Alternate";
  return `<span class="aprs-symbol aprs-symbol-local" title="${table} APRS symbol ${symbol}">${symbol}</span>`;
 }
 function normalizeAprsPacket(packet, receiver) {
  return {
    rig_id: packet.rig_id || null,
    receiver,
    srcCall: packet.src_call ?? "",
    destCall: packet.dest_call ?? "",
    path: packet.path ?? "",
    info: packet.info ?? "",
    info_bytes: packet.info_bytes ?? [],
    type: packet.packet_type ?? "",
    crcOk: packet.crc_ok ?? false,
    ts_ms: packet.ts_ms ?? null,
    lat: packet.lat ?? null,
    lon: packet.lon ?? null,
    symbolTable: packet.symbol_table ?? null,
    symbolCode: packet.symbol_code ?? null
  };
 }
 function fahrenheitToCelsius(fahrenheit) {
  return Math.round((fahrenheit - 32) * 5 / 9 * 10) / 10;
 }
 function summarizeAprsWeather(info) {
  const parts = [];
  const temperature = /t(-?\d{2,3})/.exec(info);
  if (temperature) parts.push(`${fahrenheitToCelsius(Number(temperature[1]))} °C`);
  const wind = /(\d{3})\/(\d{3})/.exec(info) ?? /c(\d{3}).*?s(\d{3})/.exec(info);
  if (wind) {
    const gust = /g(\d{3})/.exec(info);
    const knots = Number(wind[2]);
    parts.push(`wind ${Number(wind[1])}° ${knots} kt${gust ? ` gust ${Number(gust[1])}` : ""}`);
  }
  const humidity = /h(\d{2})/.exec(info);
  if (humidity) {
    const value = Number(humidity[1]);
    parts.push(`${value === 0 ? 100 : value}% RH`);
  }
  const pressure = /b(\d{5})/.exec(info);
  if (pressure) parts.push(`${(Number(pressure[1]) / 10).toFixed(1)} hPa`);
  const rain = /r(\d{3})/.exec(info);
  if (rain && Number(rain[1]) > 0) parts.push(`rain ${(Number(rain[1]) / 100).toFixed(2)}"`);
  return parts.length ? parts.join(" · ") : null;
 }
 function summarizeAprsTelemetry(info) {
  const match = /^T#(\d+|MIC)((?:,-?[\d.]*)+)(?:,([01]{8}))?/.exec(info.trim());
  if (!match?.[2]) return null;
  const channels = match[2].split(",").filter((value) => value.length > 0);
  const bits = match[3] ? ` · bits ${match[3]}` : "";
  return `#${match[1]} · ${channels.join(" ")}${bits}`;
 }
 function summarizeAprsMessage(info) {
  const match = /^:([^:]{9}):(.*)$/.exec(info);
  if (!match?.[1] || match[2] == null) return null;
  const addressee = match[1].trim();
  const text = match[2].replace(/\{\d+\s*$/, "").trim();
  return `→ ${addressee}: ${text}`;
 }
 function summarizeAprsCourseSpeed(info) {
  const match = /(\d{3})\/(\d{3})/.exec(info);
  if (!match) return null;
  const knots = Number(match[2]);
  if (knots === 0) return null;
  return `${Number(match[1])}° ${knots} kt`;
 }
 function summarizeAprsPayload(packet) {
  const info = packet.info ?? "";
  if (!info) return null;
  const category = aprsPacketCategory(packet);
  if (category === "message") return summarizeAprsMessage(info);
  if (category === "weather") return summarizeAprsWeather(info);
  if (category === "telemetry") return summarizeAprsTelemetry(info);
  if (category === "position") {
    const parts = [];
    if (packet.lat != null && packet.lon != null) {
      parts.push(`${packet.lat.toFixed(4)}, ${packet.lon.toFixed(4)}`);
    }
    const courseSpeed = summarizeAprsCourseSpeed(info);
    if (courseSpeed) parts.push(courseSpeed);
    const comment = info.replace(/^[!=@/][^>]*[>_]?/, "").replace(/\d{3}\/\d{3}/, "").trim();
    if (comment && comment.length <= 60) parts.push(comment);
    return parts.length ? parts.join(" · ") : null;
  }
  const text = info.replace(/^[>;<?]/, "").trim();
  return text.length ? text : null;
 }
 function maidenheadForLatLon(lat, lon) {
  const adjustedLon = lon + 180;
  const adjustedLat = lat + 90;
  const field = String.fromCharCode(65 + Math.floor(adjustedLon / 20)) + String.fromCharCode(65 + Math.floor(adjustedLat / 10));
  const square = String(Math.floor(adjustedLon % 20 / 2)) + String(Math.floor(adjustedLat % 10));
  const subLon = adjustedLon % 2 * 60 / 5;
  const subLat = adjustedLat % 1 * 60 / 2.5;
  const sub = String.fromCharCode(97 + Math.floor(subLon)) + String.fromCharCode(97 + Math.floor(subLat));
  return `${field}${square}${sub}`.toUpperCase();
 }
 function renderAprsPacketRow(packet, options = {}) {
  const row = document.createElement("details");
  row.className = "aprs-packet";
  if (!packet.crcOk) row.classList.add("aprs-packet-crc");
  if (options.fresh) row.classList.add("aprs-packet-new");
  const time = packet._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
  const category = aprsPacketCategory(packet);
  const summary = summarizeAprsPayload(packet);
  const hasPosition = packet.lat != null && packet.lon != null;
  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(packet.srcCall || "")}`;
  row.innerHTML = `<summary class="decode-line"><span class="aprs-time">${escapeAprsHtml(time)}</span>` + (options.badge ? `<span class="aprs-badge aprs-badge-band">${escapeAprsHtml(options.badge)}</span>` : "") + renderAprsSymbolSlot(packet, escapeAprsHtml) + `<span class="aprs-call">${escapeAprsHtml(packet.srcCall ?? "")}</span><span class="aprs-badge aprs-badge-type aprs-badge-type-${category}">${escapeAprsHtml(aprsCategoryLabel(category))}</span><span class="decode-line-summary">${summary ? escapeAprsHtml(summary) : renderAprsInfo(packet)}</span>` + (packet.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC</span>') + (options.distance ? `<span class="decode-line-distance">${escapeAprsHtml(options.distance)}</span>` : "") + `</summary><div class="decode-expanded"><div class="decode-expanded-meta"><span>&gt;${escapeAprsHtml(packet.destCall || "--")}</span><span>${escapeAprsHtml(packet.path || "no path")}</span><span>${escapeAprsHtml(aprsAgeText(packet._tsMs))}</span><span>CRC ${packet.crcOk ? "ok" : "failed"}</span>` + (hasPosition ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${packet.lat},${packet.lon}">${packet.lat?.toFixed(5)}, ${packet.lon?.toFixed(5)}</a>` : "") + `</div><div class="decode-expanded-raw">${renderAprsInfo(packet)}</div>` + (packet.info_bytes?.length ? `<div class="decode-expanded-bytes">${escapeAprsHtml(aprsHexBytes(packet.info_bytes))}</div>` : "") + `<div class="aprs-row-actions">` + (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${packet.lat},${packet.lon}">Map</button>` : "") + (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${packet.lat},${packet.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` + (options.onLog && packet.srcCall ? '<button class="aprs-inline-btn" type="button" data-aprs-log="1">Log</button>' : "") + `</div></div>`;
  row.querySelectorAll("[data-aprs-map]").forEach((element) => {
    element.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const [lat, lon] = (element.dataset.aprsMap ?? "").split(",").map(Number);
      if (Number.isFinite(lat) && Number.isFinite(lon)) options.onMap?.(lat, lon);
    });
  });
  const logButton = row.querySelector("[data-aprs-log]");
  if (logButton) {
    logButton.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const grid = packet.lat != null && packet.lon != null ? maidenheadForLatLon(packet.lat, packet.lon) : null;
      options.onLog?.(packet.srcCall ?? "", grid);
    });
  }
  const copyButton = row.querySelector("[data-aprs-copy]");
  if (copyButton) {
    copyButton.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      options.onCopy?.(copyButton.dataset.aprsCopy ?? "", copyButton);
    });
  }
  return row;
 }
 export {
  aprsPacketCategory,
  aprsAgeText,
  collapseAprsDuplicates,
  aprsSymbolSprite,
  normalizeAprsPacket,
  renderAprsPacketRow
 };
@@ -0,0 +1,156 @@
 // src/plugins/aprs-shared.ts
 function aprsPacketCategory(packet) {
  const type = (packet.type ?? "").toLowerCase();
  const info = (packet.info ?? "").toLowerCase();
  if (packet.lat != null && packet.lon != null || type.includes("position")) return "position";
  if (type.includes("message") || info.startsWith(":")) return "message";
  if (type.includes("weather") || info.startsWith("_")) return "weather";
  if (type.includes("telemetry") || info.startsWith("t#")) return "telemetry";
  return "other";
 }
 function aprsCategoryLabel(category) {
  switch (category) {
    case "position":
      return "Position";
    case "message":
      return "Message";
    case "weather":
      return "Weather";
    case "telemetry":
      return "Telemetry";
    default:
      return "Other";
  }
 }
 function aprsAgeText(timestampMs) {
  if (typeof timestampMs !== "number" || !Number.isFinite(timestampMs)) return "just now";
  const seconds = Math.round(Math.max(0, Date.now() - timestampMs) / 1e3);
  if (seconds < 5) return "just now";
  if (seconds < 60) return `${String(seconds)}s ago`;
  const minutes = Math.round(seconds / 60);
  if (minutes < 60) return `${String(minutes)}m ago`;
  return `${String(Math.round(minutes / 60))}h ago`;
 }
 function aprsPacketSignature(packet) {
  return [
    packet.srcCall ?? "",
    packet.destCall ?? "",
    packet.path ?? "",
    packet.info ?? "",
    packet.type ?? "",
    packet.lat?.toFixed(4) ?? "",
    packet.lon?.toFixed(4) ?? ""
  ].join("|");
 }
 function collapseAprsDuplicates(packets) {
  const seen = /* @__PURE__ */ new Set();
  return packets.filter((packet) => {
    const signature = aprsPacketSignature(packet);
    if (seen.has(signature)) return false;
    seen.add(signature);
    return true;
  });
 }
 function aprsHexBytes(bytes) {
  if (!bytes?.length) return "--";
  return bytes.map((byte) => byte.toString(16).toUpperCase().padStart(2, "0")).join(" ");
 }
 function renderAprsInfo(packet) {
  if (packet.info_bytes?.length) {
    return packet.info_bytes.map((byte) => renderAprsByte(byte)).join("");
  }
  return Array.from(packet.info ?? "", (character) => renderAprsCharacter(character)).join("");
 }
 function renderAprsByte(byte) {
  return byte >= 32 && byte <= 126 ? escapeAprsCharacter(String.fromCharCode(byte)) : `<span class="aprs-byte">0x${byte.toString(16).toUpperCase().padStart(2, "0")}</span>`;
 }
 function renderAprsCharacter(character) {
  const code = character.charCodeAt(0);
  return code >= 32 && code <= 126 ? escapeAprsCharacter(character) : `<span class="aprs-byte">0x${code.toString(16).toUpperCase().padStart(2, "0")}</span>`;
 }
 function escapeAprsCharacter(character) {
  if (character === "<") return "&lt;";
  if (character === ">") return "&gt;";
  if (character === "&") return "&amp;";
  if (character === '"') return "&quot;";
  return character;
 }
 var APRS_SPRITE_COLUMNS = 16;
 var APRS_SPRITE_CELL_PX = 24;
 var APRS_SPRITE_FIRST_CODE = 33;
 var APRS_SPRITE_LAST_CODE = 126;
 function aprsSpriteOffset(code) {
  if (code.length !== 1) return null;
  const point = code.charCodeAt(0);
  if (point < APRS_SPRITE_FIRST_CODE || point > APRS_SPRITE_LAST_CODE) return null;
  const index = point - APRS_SPRITE_FIRST_CODE;
  const column = index % APRS_SPRITE_COLUMNS;
  const row = Math.floor(index / APRS_SPRITE_COLUMNS);
  return `${String(-column * APRS_SPRITE_CELL_PX)}px ${String(-row * APRS_SPRITE_CELL_PX)}px`;
 }
 function aprsSymbolSprite(symbolTable, symbolCode) {
  if (!symbolTable || !symbolCode) return null;
  const symbolOffset = aprsSpriteOffset(symbolCode);
  if (!symbolOffset) return null;
  if (symbolTable === "/") {
    return {
      className: "aprs-symbol-primary",
      backgroundPosition: symbolOffset,
      label: `Primary APRS symbol ${symbolTable}${symbolCode}`
    };
  }
  if (symbolTable === "\\") {
    return {
      className: "aprs-symbol-alternate",
      backgroundPosition: symbolOffset,
      label: `Alternate APRS symbol ${symbolTable}${symbolCode}`
    };
  }
  const overlayOffset = aprsSpriteOffset(symbolTable);
  if (!overlayOffset) return null;
  return {
    className: "aprs-symbol-overlaid",
    backgroundPosition: `${overlayOffset}, ${symbolOffset}`,
    label: `Alternate APRS symbol \\${symbolCode} with overlay ${symbolTable}`
  };
 }
 function renderLocalAprsSymbol(packet, escapeHtml) {
  if (!packet.symbolTable || !packet.symbolCode) return "";
  const sprite = aprsSymbolSprite(packet.symbolTable, packet.symbolCode);
  if (sprite) {
    return `<span class="aprs-symbol ${sprite.className}" role="img" style="background-position:${sprite.backgroundPosition}" title="${escapeHtml(sprite.label)}" aria-label="${escapeHtml(sprite.label)}"></span>`;
  }
  const symbol = escapeHtml(packet.symbolCode);
  const table = packet.symbolTable === "/" ? "Primary" : "Alternate";
  return `<span class="aprs-symbol aprs-symbol-local" title="${table} APRS symbol ${symbol}">${symbol}</span>`;
 }
 function normalizeAprsPacket(packet, receiver) {
  return {
    rig_id: packet.rig_id || null,
    receiver,
    srcCall: packet.src_call ?? "",
    destCall: packet.dest_call ?? "",
    path: packet.path ?? "",
    info: packet.info ?? "",
    info_bytes: packet.info_bytes ?? [],
    type: packet.packet_type ?? "",
    crcOk: packet.crc_ok ?? false,
    ts_ms: packet.ts_ms ?? null,
    lat: packet.lat ?? null,
    lon: packet.lon ?? null,
    symbolTable: packet.symbol_table ?? null,
    symbolCode: packet.symbol_code ?? null
  };
 }
 export {
  aprsPacketCategory,
  aprsCategoryLabel,
  aprsAgeText,
  collapseAprsDuplicates,
  aprsHexBytes,
  renderAprsInfo,
  aprsSymbolSprite,
  renderLocalAprsSymbol,
  normalizeAprsPacket
 };
@@ -1,18 +0,0 @@
 import {
  hostState
 } from "./chunk-KL66PICH.js";
 // src/plugins/active-rig.ts
 function isActiveRigDecode(rigId) {
  const activeRigId = hostState.lastActiveRigId;
  if (!activeRigId || !rigId) return true;
  return rigId === activeRigId;
 }
 function forActiveRig(items) {
  return items.filter((item) => isActiveRigDecode(item.rig_id));
 }
 export {
  isActiveRigDecode,
  forActiveRig
 };
@@ -1,6 +1,3 @@
 import {
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -28,7 +25,7 @@ var CW_BAR_LINE_GAP_MS = 5e3;
 var cwLastAppendTime = 0;
 var cwTonePickerRaf = null;
 var cwBarHistory = [];
-var cwBarCurrentLines = /* @__PURE__ */ new Map();
+var cwBarCurrentLine = null;
 var cwBarDismissedAtMs = 0;
 var cwAutoLocalOverride = null;
 function escapeCwHtml(input) {
@@ -53,22 +50,20 @@ cwWindow.applyCwAutoUiFromServer = function(enabled) {
  if (cwAutoLocalOverride !== null) return;
  applyCwAutoUi(enabled);
 };
-function cwBarFlushCurrentLine(key) {
+function cwBarFlushCurrentLine() {
-  const line = cwBarCurrentLines.get(key);
+  if (cwBarCurrentLine && cwBarCurrentLine.text.trim()) {
-  cwBarCurrentLines.delete(key);
+    cwBarHistory.unshift(cwBarCurrentLine);
  if (line?.text.trim()) {
    cwBarHistory.unshift(line);
    if (cwBarHistory.length > 50) cwBarHistory.length = 50;
  }
  cwBarCurrentLine = null;
 }
 function updateCwBar() {
  if (!cwBarOverlay) return;
  const mode = (document.getElementById("mode")?.value || "").toUpperCase();
  const isCw = mode === "CW" || mode === "CWR";
  const cutoffMs = Date.now() - CW_BAR_WINDOW_MS;
-  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs && isActiveRigDecode(l.rigId));
+  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs);
-  const inProgress = [...cwBarCurrentLines.values()].filter((l) => l.text && isActiveRigDecode(l.rigId)).sort((a, b) => b.tsMs - a.tsMs);
+  const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
  const liveLines = [...inProgress, ...recent];
  const newestTsMs = liveLines.reduce((latest, line) => Math.max(latest, line.tsMs || 0), 0);
  if (!isCw || liveLines.length === 0 || newestTsMs <= cwBarDismissedAtMs) {
    cwBarOverlay.style.display = "none";
@@ -313,7 +308,7 @@ function resetCwHistoryView() {
  if (cwOutputEl) cwOutputEl.innerHTML = "";
  cwLastAppendTime = 0;
  cwBarHistory = [];
-  cwBarCurrentLines.clear();
+  cwBarCurrentLine = null;
  updateCwBar();
  drawCwTonePicker();
 }
@@ -329,9 +324,8 @@ document.getElementById("settings-clear-cw-history")?.addEventListener("click",
  })();
 });
 function onServerCw(evt) {
-  const forSelectedRig = isActiveRigDecode(evt.rig_id ?? null);
+  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
-  if (cwStatusEl && forSelectedRig) cwStatusEl.textContent = "Receiving";
+  if (evt.text && cwOutputEl) {
  if (evt.text && cwOutputEl && forSelectedRig) {
    const now = Date.now();
    if (!cwOutputEl.lastElementChild || now - cwLastAppendTime > 1e4 || evt.text === "\n") {
      const line = document.createElement("div");
@@ -352,29 +346,25 @@ function onServerCw(evt) {
  }
  if (evt.text) {
    const now = Date.now();
    const rigId = evt.rig_id ?? null;
    const key = rigId ?? "";
    if (evt.text === "\n") {
-      cwBarFlushCurrentLine(key);
+      cwBarFlushCurrentLine();
    } else {
-      let line = cwBarCurrentLines.get(key);
+      if (!cwBarCurrentLine || now - cwBarCurrentLine.lastMs > CW_BAR_LINE_GAP_MS) {
-      if (!line || now - line.lastMs > CW_BAR_LINE_GAP_MS) {
+        cwBarFlushCurrentLine();
        cwBarFlushCurrentLine(key);
        const ts = new Date(now).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-        line = { rigId, tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
+        cwBarCurrentLine = { tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
        cwBarCurrentLines.set(key, line);
      }
-      line.text += evt.text;
+      cwBarCurrentLine.text += evt.text;
-      line.lastMs = now;
+      cwBarCurrentLine.lastMs = now;
-      if (Number.isFinite(Number(evt.wpm))) line.wpm = clampCwWpm(evt.wpm);
+      if (Number.isFinite(Number(evt.wpm))) cwBarCurrentLine.wpm = clampCwWpm(evt.wpm);
-      if (Number.isFinite(Number(evt.tone_hz))) line.tone_hz = Math.round(Number(evt.tone_hz));
+      if (Number.isFinite(Number(evt.tone_hz))) cwBarCurrentLine.tone_hz = Math.round(Number(evt.tone_hz));
    }
    updateCwBar();
  }
-  if (cwSignalIndicator && forSelectedRig) {
+  if (cwSignalIndicator) {
    cwSignalIndicator.className = evt.signal_on ? "cw-signal-on" : "cw-signal-off";
  }
-  if (forSelectedRig && (!cwAutoInput || cwAutoInput.checked)) {
+  if (!cwAutoInput || cwAutoInput.checked) {
    if (cwWpmInput && Number.isFinite(Number(evt.wpm))) {
      cwWpmInput.value = String(clampCwWpm(evt.wpm));
    }
@@ -399,14 +389,7 @@ cwWindow.trxPluginRuntime.registerDecoder({
  id: "cw",
  onMessage: onServerCw,
  restore: restoreCwHistory,
-  reset: resetCwHistoryView,
+  reset: resetCwHistoryView
  // The copied text of a rig that is no longer on screen cannot be unpicked
  // from the pane, so the switch starts the new rig's stream from empty.
  rerender: () => {
    if (cwOutputEl) cwOutputEl.innerHTML = "";
    cwLastAppendTime = 0;
    updateCwBar();
  }
 });
 cwWindow.refreshCwTonePicker = function refreshCwTonePicker() {
  ensureCwToneCanvasResolution();
@@ -2,7 +2,7 @@
 (() => {
  // src/decode-history-worker.ts
  var textDecoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
-  var HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax", "sstv"];
+  var HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax"];
  var workerScope = self;
  function decodeCborUint(view, bytes, state, additional) {
    const offset = state.offset;
@@ -1,7 +1,6 @@
 import {
  initializeFtxDecoder
-} from "./chunk-WU5EWJX4.js";
+} from "./chunk-O2Y7YEVQ.js";
 import "./chunk-S57W63QN.js";
 import "./chunk-KL66PICH.js";
 // src/plugins/ft2.ts
@@ -1,7 +1,6 @@
 import {
  initializeFtxDecoder
-} from "./chunk-WU5EWJX4.js";
+} from "./chunk-O2Y7YEVQ.js";
 import "./chunk-S57W63QN.js";
 import "./chunk-KL66PICH.js";
 // src/plugins/ft4.ts
@@ -2,8 +2,7 @@ import {
  initializeFt8FamilyBar,
  initializeFtxDecoder,
  installFtxCompatibilityHelpers
-} from "./chunk-WU5EWJX4.js";
+} from "./chunk-O2Y7YEVQ.js";
 import "./chunk-S57W63QN.js";
 import "./chunk-KL66PICH.js";
 // src/plugins/ft8.ts
@@ -1,14 +1,13 @@
 import {
  aprsAgeText,
  aprsCategoryLabel,
  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsPacketRow
+  renderAprsInfo,
-} from "./chunk-REYSUJQ4.js";
+  renderLocalAprsSymbol
-import {
+} from "./chunk-ROTCLFXS.js";
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore,
  hostState
@@ -16,6 +15,7 @@ import {
 // src/plugins/hf-aprs.ts
 var hfAprsWindow = window;
 var escapeHfAprsHtml = (input) => hostCore.escapeMapHtml(input);
 var hfAprsStatus = document.getElementById("hf-aprs-status");
 var hfAprsPacketsEl = document.getElementById("hf-aprs-packets");
 var hfAprsFilterInput = document.getElementById("hf-aprs-filter");
@@ -71,26 +71,21 @@ function hfAprsFilterMatch(pkt) {
  ].filter(Boolean).join(" ").toUpperCase();
  return haystack.includes(hfAprsFilterText);
 }
 function hfAprsRigPackets() {
  return forActiveRig(hfAprsPacketHistory);
 }
 function hfAprsVisiblePackets() {
-  const rigPackets = hfAprsRigPackets();
+  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(hfAprsPacketHistory) : hfAprsPacketHistory;
  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(rigPackets) : rigPackets;
  return packets.filter(hfAprsFilterMatch);
 }
 var collapseHfAprsDuplicates = collapseAprsDuplicates;
 function updateHfAprsSummary() {
  const rigPackets = hfAprsRigPackets();
  const visible = hfAprsVisiblePackets();
  if (hfAprsTotalCountEl) {
-    hfAprsTotalCountEl.textContent = `${rigPackets.length} total`;
+    hfAprsTotalCountEl.textContent = `${hfAprsPacketHistory.length} total`;
  }
  if (hfAprsVisibleCountEl) {
    hfAprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (hfAprsLatestSeenEl) {
-    const latest = rigPackets[0];
+    const latest = hfAprsPacketHistory[0];
    if (!latest) {
      hfAprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -107,27 +102,51 @@ function updateHfAprsChipState() {
  hfAprsCollapseDupBtn?.classList.toggle("active", hfAprsCollapseDup);
 }
 function renderHfAprsRow(pkt, isFresh) {
-  return renderAprsPacketRow(pkt, {
+  const row = document.createElement("div");
-    fresh: isFresh,
+  row.className = "aprs-packet";
-    badge: "HF",
+  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-    distance: hfAprsDistanceText(pkt),
+  if (isFresh) row.classList.add("aprs-packet-new");
-    onMap: (lat, lon) => {
+  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-      hfAprsWindow.navigateToAprsMap?.(lat, lon);
+  const age = aprsAgeText(pkt._tsMs);
-    },
+  const category = aprsPacketCategory(pkt);
-    onCopy: (text) => {
+  const categoryLabel = aprsCategoryLabel(category);
-      void copyHfAprsCoords(text);
+  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-    }
+  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeHfAprsHtml(pkt.path)}</span>` : "";
  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
  const hfBadge = '<span class="aprs-badge" style="background:var(--accent-alt,#f59e0b);color:#000">HF</span>';
  const symbolHtml = renderLocalAprsSymbol(pkt, escapeHfAprsHtml);
  const posLink = pkt.lat != null && pkt.lon != null ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>` : "";
  const distance = hfAprsDistanceText(pkt);
  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
  row.innerHTML = `<div class="aprs-row-head"><span class="aprs-time">${ts}</span>` + hfBadge + symbolHtml + `<span class="aprs-call">${escapeHfAprsHtml(pkt.srcCall ?? "")}</span><span>&gt;${escapeHfAprsHtml(pkt.destCall || "")}</span><span class="${categoryClass}">${escapeHfAprsHtml(categoryLabel)}</span>` + pathBadge + crcBadge + `</div><div class="aprs-row-meta"><span class="aprs-meta-text">${escapeHfAprsHtml(age)}</span>` + (distance ? `<span class="aprs-meta-text">${escapeHfAprsHtml(distance)}</span>` : "") + `<span class="aprs-meta-text">${escapeHfAprsHtml(pkt.type || "--")}</span></div><div class="aprs-row-detail"><span title="${escapeHfAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` + (posLink ? `<span>${posLink}</span>` : "") + `</div><div class="aprs-row-actions">` + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div><details class="aprs-details"><summary>Details</summary><div class="aprs-details-grid"><span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.srcCall || "--")}</span><span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.destCall || "--")}</span><span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.type || "--")}</span><span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.path || "--")}</span><span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeHfAprsHtml(age)}</span><span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span><span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span><span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.info || "--")}</span><span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeHfAprsHtml(aprsHexBytes(pkt.info_bytes))}</span></div></details>`;
  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
    el.addEventListener("click", (evt) => {
      evt.preventDefault();
      const raw = el.dataset.aprsMap ?? "";
      const [lat, lon] = raw.split(",").map(Number);
      if (hfAprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
        hfAprsWindow.navigateToAprsMap(lat, lon);
      }
    });
  });
-}
+  const copyBtn = row.querySelector("[data-aprs-copy]");
-async function copyHfAprsCoords(text) {
+  if (copyBtn) {
-  try {
+    copyBtn.addEventListener("click", () => {
-    const clipboard = Reflect.get(navigator, "clipboard");
+      void (async () => {
-    if (!clipboard) return;
+        const raw = copyBtn.dataset.aprsCopy ?? "";
-    await clipboard.writeText(text);
+        try {
-    hostCore.showHint("Coordinates copied", 1200);
+          const clipboard = Reflect.get(navigator, "clipboard");
-  } catch {
+          if (clipboard) {
-    hostCore.showHint("Copy failed", 1500);
+            await clipboard.writeText(raw);
            hostCore.showHint("Coordinates copied", 1200);
          }
        } catch {
          hostCore.showHint("Copy failed", 1500);
        }
      })();
    });
  }
  return row;
 }
 function renderHfAprsHistory() {
  pruneHfAprsPacketHistory();
@@ -149,32 +168,17 @@ function resetHfAprsHistoryView() {
  if (hfAprsPacketsEl) hfAprsPacketsEl.innerHTML = "";
  hfAprsPacketHistory = [];
  renderHfAprsHistory();
  hfAprsWindow.clearMapMarkersByType?.("hf_aprs");
 }
 function pruneHfAprsHistoryView() {
  pruneHfAprsPacketHistory();
  renderHfAprsHistory();
 }
 function plotHfAprsPacket(pkt) {
  if (pkt.lat == null || pkt.lon == null || !hfAprsWindow.aprsMapAddStation) return;
  hfAprsWindow.aprsMapAddStation(
    pkt.srcCall ?? "",
    pkt.lat,
    pkt.lon,
    pkt.info ?? "",
    pkt.symbolTable,
    pkt.symbolCode,
    pkt,
    "hf_aprs"
  );
 }
 function addHfAprsPacket(pkt) {
  const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
  pkt._tsMs = tsMs;
  pkt._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
  hfAprsPacketHistory.unshift(pkt);
  pruneHfAprsPacketHistory();
  plotHfAprsPacket(pkt);
  scheduleHfAprsHistoryRender();
 }
 function normalizeServerHfAprsPacket(pkt) {
@@ -182,14 +186,13 @@ function normalizeServerHfAprsPacket(pkt) {
 }
 function onServerHfAprsBatch(packets) {
  if (!Array.isArray(packets) || packets.length === 0) return;
  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
  const normalized = [];
  for (const pkt of packets) {
    const next = normalizeServerHfAprsPacket(pkt);
    if (hfAprsStatus && isActiveRigDecode(next.rig_id)) hfAprsStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
    plotHfAprsPacket(next);
    normalized.push(next);
  }
  normalized.reverse();
@@ -252,9 +255,8 @@ if (hfAprsFilterInput) {
  });
 }
 function onServerHfAprs(pkt) {
-  const packet = normalizeServerHfAprsPacket(pkt);
+  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  if (hfAprsStatus && isActiveRigDecode(packet.rig_id)) hfAprsStatus.textContent = "Receiving";
+  addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
  addHfAprsPacket(packet);
 }
 renderHfAprsHistory();
 window.trxPluginRuntime.registerDecoder({
@@ -263,10 +265,5 @@ window.trxPluginRuntime.registerDecoder({
  onBatch: onServerHfAprsBatch,
  restore: onServerHfAprsBatch,
  reset: resetHfAprsHistoryView,
-  prune: pruneHfAprsHistoryView,
+  prune: pruneHfAprsHistoryView
  rerender: renderHfAprsHistory,
  // Oldest first, so station tracks are rebuilt in the order they happened.
  syncMap: () => {
    for (const entry of [...hfAprsPacketHistory].reverse()) plotHfAprsPacket(entry);
  }
 });
@@ -1,449 +0,0 @@
 import {
  hasAuthRole
 } from "./chunk-PISLBJGN.js";
 import {
  hostCore,
  hostState
 } from "./chunk-KL66PICH.js";
 // src/plugins/logbook.ts
 var bridge = window;
 var el = (id) => document.getElementById(id);
 var form = el("log-entry-form");
 var callInput = el("log-call");
 var freqInput = el("log-freq");
 var modeInput = el("log-mode");
 var rstSentInput = el("log-rst-sent");
 var rstRcvdInput = el("log-rst-rcvd");
 var gridInput = el("log-grid");
 var nameInput = el("log-name");
 var commentInput = el("log-comment");
 var operatorInput = el("log-operator");
 var rowsBody = el("log-rows");
 var summaryEl = el("log-summary");
 var workedEl = el("log-worked-before");
 var clockEl = el("log-clock");
 var stationCallEl = el("log-station-callsign");
 var stationRigEl = el("log-station-rig-name");
 var stationGridEl = el("log-station-grid");
 var filterCall = el("log-filter-call");
 var filterBand = el("log-filter-band");
 var filterMode = el("log-filter-mode");
 var importBtn = el("log-import-btn");
 var importFile = el("log-import-file");
 var exportLink = el("log-export-btn");
 var clearBtn = el("log-clear-btn");
 var saveBtn = el("log-save-btn");
 var contestIdInput = el("log-contest-id");
 var stxInput = el("log-stx");
 var srxInput = el("log-srx");
 var statisticsRows = el("log-statistics-rows");
 var cabrilloContest = el("log-cbr-contest");
 var cabrilloCallsign = el("log-cbr-callsign");
 var cabrilloOperator = el("log-cbr-operator");
 var cabrilloPower = el("log-cbr-power");
 var cabrilloScore = el("log-cbr-score");
 var cabrilloExport = el("log-cbr-export");
 var entryStartedAt = null;
 var entryRigId = null;
 var entryRigName = null;
 var entryGrid = null;
 var qsos = [];
 var workedRequest = 0;
 function canWriteLogbook() {
  return !hostState.authEnabled || hasAuthRole(hostState.authRoles, "write");
 }
 function notify(message, kind) {
  if (bridge.trxUi.notify) bridge.trxUi.notify(message, kind ? { kind } : void 0);
  else hostCore.showHint(message, 2e3);
 }
 async function getJson(path) {
  const response = await fetch(path);
  if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
  return await response.json();
 }
 function formatFreq(hz) {
  if (!Number.isFinite(hz) || hz <= 0) return "";
  return String(Number((hz / 1e6).toFixed(6)));
 }
 function parseFreq(text) {
  const value = Number(text.trim().replace(/\s+/g, "").replace(",", "."));
  if (!Number.isFinite(value) || value <= 0) return null;
  return value < 1e5 ? Math.round(value * 1e6) : Math.round(value);
 }
 function numberOrNull(text) {
  const trimmed = (text ?? "").trim();
  if (!trimmed || !/^\d+$/.test(trimmed)) return null;
  const value = Number(trimmed);
  return Number.isSafeInteger(value) ? value : null;
 }
 function utcDate(iso) {
  const date = new Date(iso);
  return Number.isNaN(date.getTime()) ? "" : date.toISOString().slice(0, 10);
 }
 function utcTime(iso) {
  const date = new Date(iso);
  return Number.isNaN(date.getTime()) ? "" : date.toISOString().slice(11, 19);
 }
 async function openEntry(seed = {}) {
  const params = new URLSearchParams();
  if (hostState.lastActiveRigId) params.set("remote", hostState.lastActiveRigId);
  if (seed.decoder) params.set("decoder", seed.decoder);
  if (seed.call) params.set("call", seed.call);
  if (seed.gridsquare) params.set("gridsquare", seed.gridsquare);
  try {
    const prefill = await getJson(`/api/logbook/prefill?${params.toString()}`);
    applyPrefill(prefill);
  } catch (error) {
    console.error("logbook prefill failed", error);
  }
 }
 function applyPrefill(prefill) {
  entryStartedAt = prefill.started_at;
  entryRigId = prefill.rig_id;
  entryRigName = prefill.my_rig;
  if (freqInput) freqInput.value = formatFreq(prefill.freq_hz);
  if (modeInput) modeInput.value = prefill.submode ?? prefill.mode;
  if (callInput && prefill.call) callInput.value = prefill.call;
  if (gridInput && prefill.gridsquare) gridInput.value = prefill.gridsquare;
  if (stationRigEl) stationRigEl.textContent = prefill.my_rig ?? "no rig";
  showClock(prefill);
  updateWorkedBefore();
 }
 function showClock(prefill) {
  if (!clockEl) return;
  const time = utcTime(prefill.started_at);
  const drift = Math.abs(Date.now() - prefill.epoch_ms);
  clockEl.textContent = drift > 1e3 ? `${time}Z · your clock is ${(drift / 1e3).toFixed(0)}s out` : `${time}Z`;
  clockEl.classList.toggle("is-adrift", drift > 1e3);
 }
 function resetEntry() {
  for (const input of [callInput, rstSentInput, rstRcvdInput, gridInput, nameInput, commentInput, srxInput]) {
    if (input) input.value = "";
  }
  if (workedEl) workedEl.textContent = "";
  void openEntry();
 }
 async function submitEntry(event) {
  event.preventDefault();
  const call = callInput?.value.trim() ?? "";
  if (!call) {
    notify("A contact needs a callsign", "error");
    callInput?.focus();
    return;
  }
  const freqHz = parseFreq(freqInput?.value ?? "");
  if (freqHz == null) {
    notify("A contact needs a frequency", "error");
    freqInput?.focus();
    return;
  }
  const typedMode = (modeInput?.value ?? "").trim().toUpperCase();
  const isSideband = typedMode === "USB" || typedMode === "LSB";
  const body = {
    // The server stamps the time; this is the one it gave when the entry
    // opened, so a contact logged five minutes later keeps the time it started.
    started_at: entryStartedAt,
    call,
    freq_hz: freqHz,
    mode: isSideband ? "SSB" : typedMode,
    submode: isSideband ? typedMode : null,
    rst_sent: rstSentInput?.value ?? null,
    rst_rcvd: rstRcvdInput?.value ?? null,
    gridsquare: gridInput?.value ?? null,
    name: nameInput?.value ?? null,
    comment: commentInput?.value ?? null,
    contest_id: contestIdInput?.value ?? null,
    // The exchange is a number when it is a serial and a word when it is a
    // zone or a section; both are kept, and the log writes whichever it has.
    stx: numberOrNull(stxInput?.value),
    stx_string: numberOrNull(stxInput?.value) == null ? stxInput?.value ?? null : null,
    srx: numberOrNull(srxInput?.value),
    srx_string: numberOrNull(srxInput?.value) == null ? srxInput?.value ?? null : null,
    station_callsign: stationCallEl?.textContent?.trim() ?? null,
    operator: operatorInput?.value ?? null,
    my_gridsquare: entryGrid,
    my_rig: entryRigName,
    rig_id: entryRigId
  };
  if (saveBtn) saveBtn.disabled = true;
  try {
    const response = await fetch("/api/logbook", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body)
    });
    if (!response.ok) {
      const detail = await response.json().catch(() => ({}));
      throw new Error(detail.error ?? `HTTP ${String(response.status)}`);
    }
    notify(`${call} logged`);
    const sent = numberOrNull(stxInput?.value);
    resetEntry();
    if (stxInput && sent != null) stxInput.value = String(sent + 1);
    await refreshLog();
  } catch (error) {
    notify(`Could not log: ${error instanceof Error ? error.message : String(error)}`, "error");
  } finally {
    if (saveBtn) saveBtn.disabled = false;
  }
 }
 function updateWorkedBefore() {
  if (!workedEl) return;
  const call = callInput?.value.trim() ?? "";
  if (call.length < 3) {
    workedEl.textContent = "";
    return;
  }
  const request = ++workedRequest;
  void getJson(
    `/api/logbook/worked/${encodeURIComponent(call)}`
  ).then((answer) => {
    if (request !== workedRequest || !workedEl) return;
    if (answer.worked.length === 0) {
      workedEl.textContent = "Not worked before";
      workedEl.classList.remove("is-worked");
      return;
    }
    const where = answer.worked.map((entry) => `${entry.band} ${entry.mode}`).join(", ");
    workedEl.textContent = `Worked before: ${where}`;
    workedEl.classList.add("is-worked");
  }).catch(() => {
  });
 }
 function currentQuery() {
  const params = new URLSearchParams();
  const call = filterCall?.value.trim();
  if (call) params.set("call", call);
  if (filterBand?.value) params.set("band", filterBand.value);
  if (filterMode?.value) params.set("mode", filterMode.value);
  return params.toString();
 }
 async function refreshLog() {
  try {
    const query = currentQuery();
    const answer = await getJson(
      `/api/logbook${query ? `?${query}` : ""}`
    );
    qsos = answer.qsos;
    renderRows();
    renderFilterOptions();
    if (summaryEl) {
      summaryEl.textContent = query ? `${String(qsos.length)} of ${String(answer.total)} contacts` : `${String(answer.total)} contact${answer.total === 1 ? "" : "s"}`;
    }
    if (exportLink) exportLink.href = `/api/logbook/export.adi${query ? `?${query}` : ""}`;
    await refreshStatistics();
  } catch (error) {
    console.error("logbook read failed", error);
  }
 }
 async function refreshStatistics() {
  if (!statisticsRows) return;
  try {
    const answer = await getJson("/api/logbook/statistics");
    if (answer.bands.length === 0) {
      statisticsRows.innerHTML = '<tr><td colspan="4" class="log-empty">Nothing worked yet.</td></tr>';
      return;
    }
    const fragment = document.createDocumentFragment();
    for (const band of answer.bands) {
      const row = document.createElement("tr");
      for (const value of [band.band, band.contacts, band.stations, band.confirmed]) {
        const cell = document.createElement("td");
        cell.textContent = String(value);
        row.appendChild(cell);
      }
      fragment.appendChild(row);
    }
    statisticsRows.replaceChildren(fragment);
  } catch (error) {
    console.error("logbook statistics failed", error);
  }
 }
 function syncCabrilloLink() {
  if (!cabrilloExport) return;
  const params = new URLSearchParams();
  const contest = cabrilloContest?.value.trim();
  if (contest) {
    params.set("contest", contest);
  }
  const callsign = cabrilloCallsign?.value.trim() || (stationCallEl?.textContent?.trim() ?? "");
  if (callsign) params.set("callsign", callsign);
  if (cabrilloOperator?.value) params.set("category_operator", cabrilloOperator.value);
  if (cabrilloPower?.value) params.set("category_power", cabrilloPower.value);
  const score = numberOrNull(cabrilloScore?.value);
  if (score != null) params.set("claimed_score", String(score));
  const operator = operatorInput?.value.trim();
  if (operator) params.set("operators", operator);
  cabrilloExport.href = `/api/logbook/export.cbr?${params.toString()}`;
 }
 function renderRows() {
  if (!rowsBody) return;
  if (qsos.length === 0) {
    rowsBody.innerHTML = '<tr><td colspan="10" class="log-empty">No contacts yet. Work someone and log them here, or bring a log in with Import ADIF.</td></tr>';
    return;
  }
  const fragment = document.createDocumentFragment();
  for (const qso of qsos) {
    const row = document.createElement("tr");
    row.dataset.qsoId = qso.id;
    const cells = [
      utcDate(qso.started_at),
      utcTime(qso.started_at),
      qso.call,
      qso.band ?? "",
      qso.submode ?? qso.mode,
      qso.rst_sent ?? "",
      qso.rst_rcvd ?? "",
      qso.gridsquare ?? "",
      qso.my_rig ?? "",
      qso.confirmed ? "✓" : ""
    ];
    for (const [index, value] of cells.entries()) {
      const cell = document.createElement("td");
      cell.textContent = value ?? "";
      if (index === 2) cell.className = "log-cell-call";
      row.appendChild(cell);
    }
    const actions = document.createElement("td");
    if (!canWriteLogbook()) {
      row.appendChild(actions);
      fragment.appendChild(row);
      continue;
    }
    const confirm = document.createElement("button");
    confirm.type = "button";
    confirm.className = "log-row-btn";
    confirm.textContent = qso.confirmed ? "Unconfirm" : "Confirm";
    confirm.title = qso.confirmed ? "Mark this contact as not confirmed" : "Mark this contact confirmed by QSL";
    confirm.addEventListener("click", () => {
      void setConfirmed(qso, !qso.confirmed);
    });
    actions.appendChild(confirm);
    const remove = document.createElement("button");
    remove.type = "button";
    remove.className = "log-row-btn";
    remove.textContent = "Delete";
    remove.setAttribute("aria-label", `Delete the contact with ${qso.call}`);
    remove.addEventListener("click", () => {
      void deleteQso(qso);
    });
    actions.appendChild(remove);
    row.appendChild(actions);
    fragment.appendChild(row);
  }
  rowsBody.replaceChildren(fragment);
 }
 function renderFilterOptions() {
  for (const [select, values] of [
    [filterBand, [...new Set(qsos.map((q) => q.band).filter((b) => !!b))]],
    [filterMode, [...new Set(qsos.map((q) => q.submode ?? q.mode).filter(Boolean))]]
  ]) {
    if (!select) continue;
    const chosen = select.value;
    const known = new Set([...select.options].map((option) => option.value));
    for (const value of [...values].sort()) {
      if (known.has(value)) continue;
      select.add(new Option(value, value));
    }
    select.value = chosen;
  }
 }
 async function setConfirmed(qso, confirmed) {
  try {
    const response = await fetch(`/api/logbook/${encodeURIComponent(qso.id)}`, {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        ...qso,
        // A card is a card: this is the paper one, and an electronic
        // confirmation the log already holds is left where it is.
        qsl_rcvd: confirmed ? "Y" : "N"
      })
    });
    if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
    await refreshLog();
  } catch (error) {
    notify(`Could not update: ${error instanceof Error ? error.message : String(error)}`, "error");
  }
 }
 async function deleteQso(qso) {
  const confirmed = await bridge.trxUi.confirm({
    title: "Delete this contact?",
    message: `${qso.call} on ${qso.band ?? formatFreq(qso.freq_hz)} will be removed from the log.`,
    confirmLabel: "Delete"
  });
  if (!confirmed) return;
  try {
    const response = await fetch(`/api/logbook/${encodeURIComponent(qso.id)}`, { method: "DELETE" });
    if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
    await refreshLog();
  } catch (error) {
    notify(`Could not delete: ${error instanceof Error ? error.message : String(error)}`, "error");
  }
 }
 async function importAdif(file) {
  try {
    const response = await fetch("/api/logbook/import", { method: "POST", body: await file.arrayBuffer() });
    if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
    const outcome = await response.json();
    const parts = [`${String(outcome.added)} added`];
    if (outcome.duplicate > 0) parts.push(`${String(outcome.duplicate)} already held`);
    if (outcome.rejected.length > 0) parts.push(`${String(outcome.rejected.length)} not readable`);
    notify(parts.join(", "));
    await refreshLog();
  } catch (error) {
    notify(`Import failed: ${error instanceof Error ? error.message : String(error)}`, "error");
  }
 }
 function renderStation() {
  const callsign = hostState.ownerCallsign ?? "";
  if (stationCallEl) stationCallEl.textContent = callsign || "no callsign set";
  if (operatorInput && !operatorInput.value) operatorInput.value = callsign;
  if (stationGridEl) {
    const grid = hostState.serverLat != null && hostState.serverLon != null ? hostCore.latLonToMaidenhead(hostState.serverLat, hostState.serverLon) : "";
    entryGrid = grid || null;
    stationGridEl.textContent = grid;
  }
 }
 form?.addEventListener("submit", (event) => {
  void submitEntry(event);
 });
 clearBtn?.addEventListener("click", resetEntry);
 callInput?.addEventListener("input", updateWorkedBefore);
 for (const control of [filterCall, filterBand, filterMode]) {
  control?.addEventListener("input", () => {
    void refreshLog();
  });
  control?.addEventListener("change", () => {
    void refreshLog();
  });
 }
 for (const control of [cabrilloContest, cabrilloCallsign, cabrilloOperator, cabrilloPower, cabrilloScore]) {
  control?.addEventListener("input", syncCabrilloLink);
  control?.addEventListener("change", syncCabrilloLink);
 }
 importBtn?.addEventListener("click", () => {
  importFile?.click();
 });
 importFile?.addEventListener("change", () => {
  const file = importFile.files?.[0];
  if (file) void importAdif(file);
  importFile.value = "";
 });
 if (canWriteLogbook()) {
  bridge.logContact = (seed) => {
    bridge.navigateToTab?.("logbook");
    void openEntry(seed).then(() => callInput?.focus());
  };
 } else {
  if (form) form.style.display = "none";
  if (importBtn) importBtn.style.display = "none";
 }
 renderStation();
 if (cabrilloCallsign && !cabrilloCallsign.value) {
  cabrilloCallsign.value = stationCallEl?.textContent?.trim() ?? "";
 }
 syncCabrilloLink();
 if (canWriteLogbook()) void openEntry();
 void refreshLog();
@@ -1,6 +1,6 @@
 import {
  aprsSymbolSprite
-} from "./chunk-REYSUJQ4.js";
+} from "./chunk-ROTCLFXS.js";
 // src/map-core.ts
 function mapEl(id) {
@@ -60,9 +60,8 @@ var mapWindow = window;
  const decodeContactPaths = /* @__PURE__ */ new Map();
  let selectedMapQsoKey = null;
  const mapMarkers = /* @__PURE__ */ new Set();
-  const DEFAULT_MAP_SOURCE_FILTER = { ais: true, vdes: true, aprs: true, hf_aprs: true, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
+  const DEFAULT_MAP_SOURCE_FILTER = { ais: true, vdes: true, aprs: true, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
  const mapFilter = { ...DEFAULT_MAP_SOURCE_FILTER };
  const MAP_FILTER_ALL_KEY = "__all";
  const mapLocatorFilter = { phase: "band", bands: /* @__PURE__ */ new Set() };
  let mapSearchFilter = "";
  let mapRigFilter = "";
@@ -128,12 +127,6 @@ var mapWindow = window;
    }
    return trimmed;
  }
  function aprsEntrySource(entry) {
    return entry?.type === "hf_aprs" ? "hf_aprs" : "aprs";
  }
  function aprsStationKey(call, source) {
    return source === "aprs" ? call : `${source}:${call}`;
  }
  function refreshAprsTrack(call, entry) {
    if (!entry) return;
    if (!Array.isArray(entry.trackPoints) || entry.trackPoints.length < 2) {
@@ -155,7 +148,7 @@ var mapWindow = window;
      lineJoin: "round",
      interactive: false
    });
-    track.__trxType = aprsEntrySource(entry);
+    track.__trxType = "aprs";
    track._aprsCall = call;
    entry.track = track;
  }
@@ -387,7 +380,6 @@ var mapWindow = window;
  }
  function mapSourceLabel(type) {
    if (type === "bookmark") return "Bookmarks";
    if (type === "hf_aprs") return "HF APRS";
    return String(type || "").toUpperCase();
  }
  function locatorFilterColor(type) {
@@ -403,7 +395,6 @@ var mapWindow = window;
    if (type === "vdes") return "#a78bfa";
    if (type === "sat") return "#f59e0b";
    if (type === "aprs") return "#00d17f";
    if (type === "hf_aprs") return "#fb7185";
    return locatorFilterColor(type);
  }
  function bandForHz(hz) {
@@ -847,36 +838,38 @@ var mapWindow = window;
      container.innerHTML = `<span class="map-locator-empty">No ${kind === "band" ? "bands" : "sources"} available</span>`;
      return;
    }
-    const noun = kind === "band" ? "bands" : "sources";
+    let helperText = "";
    const sourceKeys = kind === "source" ? Object.keys(DEFAULT_MAP_SOURCE_FILTER) : [];
-    const showingAll = kind === "source" ? sourceKeys.every((k) => !mapFilter[k]) : !(selectedSet instanceof Set) || selectedSet.size === 0;
+    const noneSelected = kind === "source" && sourceKeys.every((k) => !mapFilter[k]);
-    const allChip = document.createElement("button");
+    if (kind === "source") {
-    allChip.type = "button";
+      if (noneSelected) {
-    allChip.className = "map-locator-chip map-locator-chip-all";
+        helperText = "All sources visible — click to filter";
-    if (showingAll) allChip.classList.add("is-active");
+      }
-    allChip.dataset.filterKind = kind;
+    } else if (!(selectedSet instanceof Set) || selectedSet.size === 0) {
-    allChip.dataset.filterKey = MAP_FILTER_ALL_KEY;
+      helperText = `All ${kind === "band" ? "bands" : "sources"} visible by default`;
-    allChip.setAttribute("aria-pressed", showingAll ? "true" : "false");
+    }
    allChip.title = showingAll ? `All ${noun} shown` : `Show all ${noun}`;
    allChip.innerHTML = `<span class="map-locator-chip-text">All</span>`;
    container.appendChild(allChip);
    for (const item of items) {
      const btn = document.createElement("button");
      btn.type = "button";
      btn.className = "map-locator-chip";
      const isActive = kind === "source" ? !!mapFilter[item.key] : !!selectedSet?.has(item.key);
-      if (showingAll) {
+      if (kind === "source" && noneSelected) {
        btn.classList.add("is-default");
      } else if (!isActive) {
        btn.classList.add("is-inactive");
      }
      btn.setAttribute("aria-pressed", !showingAll && isActive ? "true" : "false");
      btn.dataset.filterKind = kind;
      btn.dataset.filterKey = item.key;
      btn.style.setProperty("--chip-color", item.color);
      btn.innerHTML = `<span class="map-locator-chip-text">${escapeMapHtml(item.label)}</span>`;
      container.appendChild(btn);
    }
    if (helperText) {
      const hint = document.createElement("span");
      hint.className = "map-locator-empty";
      hint.textContent = helperText;
      container.appendChild(hint);
    }
  }
  function renderMapLocatorPhaseRow(container, phase) {
    if (!container) return;
@@ -939,8 +932,10 @@ var mapWindow = window;
      }
    }
    for (const entry of stationMarkers.values()) {
-      if (!entry?.visibleInHistoryWindow) continue;
+      if (entry?.type === "aprs" && entry?.visibleInHistoryWindow) {
-      availableSources.add(aprsEntrySource(entry));
+        availableSources.add("aprs");
        break;
      }
    }
    const bandMap = /* @__PURE__ */ new Map();
    for (const entry of locatorMarkers.values()) {
@@ -972,7 +967,7 @@ var mapWindow = window;
    for (const key of Array.from(mapLocatorFilter.bands)) {
      if (!bandMap.has(key)) mapLocatorFilter.bands.delete(key);
    }
-    const sourceItems = ["ais", "vdes", "aprs", "hf_aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"].filter((key) => availableSources.has(key)).map((key) => ({
+    const sourceItems = ["ais", "vdes", "aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"].filter((key) => availableSources.has(key)).map((key) => ({
      key,
      label: mapSourceLabel(key),
      color: mapSourceColor(key),
@@ -982,10 +977,11 @@ var mapWindow = window;
    renderMapLocatorLegend(mapLocatorFilter.phase, sourceItems, bandItems);
    if (!phaseEl || !choiceEl || !choiceLabelEl) return;
    renderMapLocatorPhaseRow(phaseEl, mapLocatorFilter.phase);
    choiceLabelEl.textContent = "Show";
    if (mapLocatorFilter.phase === "band") {
      choiceLabelEl.textContent = "Visible Bands";
      renderMapLocatorChipRow(choiceEl, bandItems, mapLocatorFilter.bands, "band");
    } else {
      choiceLabelEl.textContent = "Visible Sources";
      renderMapLocatorChipRow(choiceEl, sourceItems, null, "source");
    }
    syncLocatorMarkerStyles();
@@ -1034,10 +1030,9 @@ var mapWindow = window;
      }
      return parts.join(" ").toLowerCase();
    }
-    if (type === "aprs" || type === "hf_aprs") {
+    if (type === "aprs") {
-      const key = marker?._aprsCall ? String(marker._aprsCall) : "";
+      const call = marker?._aprsCall ? String(marker._aprsCall) : "";
-      const entry = stationMarkers.get(key);
+      const entry = stationMarkers.get(call);
      const call = entry?.call ?? key;
      const info = entry?.info ? String(entry.info) : "";
      const pktRaw = entry?.pkt?.raw ? String(entry.pkt.raw) : "";
      return `${call} ${info} ${pktRaw}`.toLowerCase();
@@ -1207,10 +1202,9 @@ var mapWindow = window;
    }
  };
  mapWindow.clearMapMarkersByType = function(type) {
-    if (type === "aprs" || type === "hf_aprs") {
+    if (type === "aprs") {
      selectedAprsTrackCall = null;
-      stationMarkers.forEach((entry, key) => {
+      stationMarkers.forEach((entry) => {
        if (aprsEntrySource(entry) !== type) return;
        if (entry && entry.marker) {
          if (aprsMap && aprsMap.hasLayer(entry.marker)) entry.marker.removeFrom(aprsMap);
          mapMarkers.delete(entry.marker);
@@ -1219,8 +1213,8 @@ var mapWindow = window;
          if (aprsMap && aprsMap.hasLayer(entry.track)) entry.track.removeFrom(aprsMap);
          mapMarkers.delete(entry.track);
        }
        stationMarkers.delete(key);
      });
      stationMarkers.clear();
      return;
    }
    if (type === "ais") {
@@ -1341,8 +1335,7 @@ var mapWindow = window;
  function applyMapOverlayPanelVisibility() {
    const panel = document.querySelector("#map-stage .map-overlay-panel");
    if (!panel) return;
-    panel.classList.toggle("filters-hidden", !mapOverlayPanelVisible);
+    panel.classList.toggle("is-hidden", !mapOverlayPanelVisible);
    panel.querySelector(".map-overlay-filters")?.classList.toggle("is-hidden", !mapOverlayPanelVisible);
  }
  function updateMapOverlayToggleButton() {
    const btn = mapEl("map-overlay-toggle-btn");
@@ -1456,15 +1449,13 @@ var mapWindow = window;
        if (!ll) return;
        const entry = stationMarkers.get(marker._aprsCall);
        if (!entry) return;
-        const source = aprsEntrySource(entry);
+        e.popup.setContent(buildAprsPopupHtml(marker._aprsCall, ll.lat, ll.lng, entry.info || "", entry.pkt));
        const call = entry.call ?? String(marker._aprsCall);
        e.popup.setContent(buildAprsPopupHtml(call, ll.lat, ll.lng, entry.info || "", entry.pkt));
        refreshAprsTrack(String(marker._aprsCall), entry);
-        if (entry.track && aprsMap && mapFilter[source] && !aprsMap.hasLayer(entry.track)) {
+        if (entry.track && aprsMap && mapFilter.aprs && !aprsMap.hasLayer(entry.track)) {
          entry.track.addTo(aprsMap);
        }
        selectedAprsTrackCall = String(marker._aprsCall);
-        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor(source), "aprs-radio-path", marker.__trxRigIds);
+        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor("aprs"), "aprs-radio-path", marker.__trxRigIds);
        return;
      }
      if (marker._aisMmsi) {
@@ -1541,13 +1532,7 @@ var mapWindow = window;
        const kind = String(chip.dataset.filterKind || "");
        const key = String(chip.dataset.filterKey || "");
        if (!key) return;
-        if (key === MAP_FILTER_ALL_KEY) {
+        if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
          if (kind === "source") {
            for (const srcKey of Object.keys(DEFAULT_MAP_SOURCE_FILTER)) mapFilter[srcKey] = false;
          } else {
            mapLocatorFilter.bands.clear();
          }
        } else if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
          const sourceKey = key;
          mapFilter[sourceKey] = !mapFilter[sourceKey];
          const srcKeys = Object.keys(DEFAULT_MAP_SOURCE_FILTER);
@@ -1662,13 +1647,18 @@ var mapWindow = window;
      return;
    }
    const mapRect = mapContainer.getBoundingClientRect();
    const width = mapContainer.clientWidth || mapRect.width;
    const footer = document.querySelector(".footer");
-    let bottom = window.innerHeight;
+    let bottom = mapIsFullscreen() && stage ? stage.getBoundingClientRect().bottom : window.innerHeight;
-    if (footer) {
+    if (!mapIsFullscreen() && footer) {
      const fr = footer.getBoundingClientRect();
-      if (fr.top > mapRect.top + 50) bottom = Math.min(fr.top, bottom);
+      if (fr.top > mapRect.top + 50) bottom = fr.top;
    }
-    const target = Math.max(0, Math.floor(bottom - mapRect.top - 8));
+    const available = Math.max(0, Math.floor(bottom - mapRect.top - 8));
    const widthDriven = width > 0 ? Math.floor(width / 1.55) : available;
    const viewportCap = mapIsFullscreen() ? Math.floor(window.innerHeight * 0.9) : Math.floor(window.innerHeight * 0.75);
    const minHeight = Math.min(260, available);
    const target = Math.max(minHeight, Math.min(available, viewportCap, widthDriven));
    mapContainer.style.height = `${target}px`;
    if (aprsMap) aprsMap.invalidateSize();
  }
@@ -1684,7 +1674,16 @@ var mapWindow = window;
      popupAnchor: [0, -12]
    });
  }
-  function focusMapPosition(lat, lon) {
+  mapWindow.navigateToAprsMap = function(lat, lon) {
    T._activeTab = "map";
    document.querySelectorAll(".tab-bar .tab").forEach((t) => {
      t.classList.remove("active");
    });
    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
    if (mapTabBtn) mapTabBtn.classList.add("active");
    document.querySelectorAll(".tab-panel").forEach((p) => p.style.display = "none");
    const mapPanel = mapEl("tab-map");
    if (mapPanel) mapPanel.style.display = "";
    initAprsMap();
    sizeAprsMapToViewport();
    if (aprsMap) {
@@ -1696,10 +1695,19 @@ var mapWindow = window;
        });
      });
    }
-  }
+  };
-  function focusMapLocator(grid, preferredType = null) {
+  mapWindow.navigateToMapLocator = function(grid, preferredType = null) {
    const normalizedGrid = String(grid || "").trim().toUpperCase();
    if (!/^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalizedGrid)) return false;
    T._activeTab = "map";
    document.querySelectorAll(".tab-bar .tab").forEach((t) => {
      t.classList.remove("active");
    });
    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
    if (mapTabBtn) mapTabBtn.classList.add("active");
    document.querySelectorAll(".tab-panel").forEach((p) => p.style.display = "none");
    const mapPanel = mapEl("tab-map");
    if (mapPanel) mapPanel.style.display = "";
    initAprsMap();
    sizeAprsMapToViewport();
    if (!aprsMap) return false;
@@ -1744,7 +1752,7 @@ var mapWindow = window;
      requestAnimationFrame(focusMarker);
    });
    return true;
-  }
+  };
  function buildReceiverPopupHtml(rigIds) {
    const call = T.serverCallsign || T.ownerCallsign || "Receiver";
    let meta = "";
@@ -1858,33 +1866,28 @@ var mapWindow = window;
    }
    return null;
  }
-  function _aprsAddMarkerToMap(key, entry) {
+  function _aprsAddMarkerToMap(call, entry) {
    if (!aprsMap || entry.lat == null || entry.lon == null) return;
-    refreshAprsTrack(key, entry);
+    refreshAprsTrack(call, entry);
    const source = aprsEntrySource(entry);
    const call = entry.call ?? key;
    const icon = aprsSymbolIcon(entry.symbolTable ?? "", entry.symbolCode ?? "");
    const popupContent = buildAprsPopupHtml(call, entry.lat, entry.lon, entry.info || "", entry.pkt);
    const color = mapSourceColor(source);
    const marker = icon ? L.marker([entry.lat, entry.lon], { icon }).addTo(aprsMap).bindPopup(popupContent) : L.circleMarker([entry.lat, entry.lon], {
      radius: 6,
-      color,
+      color: "#00d17f",
-      fillColor: color,
+      fillColor: "#00d17f",
      fillOpacity: 0.8
    }).addTo(aprsMap).bindPopup(popupContent);
-    marker.__trxType = source;
+    marker.__trxType = "aprs";
    marker.__trxRigIds = entry.rigIds || /* @__PURE__ */ new Set();
-    marker._aprsCall = key;
+    marker._aprsCall = call;
    entry.marker = marker;
    mapMarkers.add(marker);
  }
-  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt, source) {
+  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt) {
    const nextPoint = [lat, lon];
    const tsMs = Number.isFinite(pkt?._tsMs) ? Number(pkt._tsMs) : Date.now();
    const msgRigId = pkt?.rig_id || T.lastActiveRigId;
-    const stationSource = source === "hf_aprs" ? "hf_aprs" : "aprs";
+    const existing = stationMarkers.get(call);
    const key = aprsStationKey(call, stationSource);
    const existing = stationMarkers.get(key);
    if (existing) {
      existing.pkt = pkt;
      existing.lat = lat;
@@ -1903,8 +1906,7 @@ var mapWindow = window;
      } else if (prevPoint) {
        prevPoint.tsMs = tsMs;
      }
-      existing.call = call;
+      pruneAprsEntry(call, existing, mapHistoryCutoffMs());
      pruneAprsEntry(key, existing, mapHistoryCutoffMs());
      if (aprsMap && existing.marker && !T.decodeHistoryReplayActive) {
        existing.marker.setLatLng([lat, lon]);
        existing.marker.setPopupContent(buildAprsPopupHtml(call, lat, lon, info, pkt));
@@ -1915,8 +1917,7 @@ var mapWindow = window;
        track: null,
        trackHistory: [{ lat, lon, tsMs }],
        trackPoints: [nextPoint],
-        type: stationSource,
+        type: "aprs",
        call,
        pkt,
        lat,
        lon,
@@ -1925,9 +1926,9 @@ var mapWindow = window;
        symbolCode,
        rigIds: new Set(msgRigId ? [msgRigId] : [])
      };
-      stationMarkers.set(key, entry);
+      stationMarkers.set(call, entry);
-      pruneAprsEntry(key, entry, mapHistoryCutoffMs());
+      pruneAprsEntry(call, entry, mapHistoryCutoffMs());
-      if (entry.visibleInHistoryWindow) ensureAprsMarker(key, entry);
+      if (entry.visibleInHistoryWindow) ensureAprsMarker(call, entry);
      if (aprsMap) scheduleDecodeMapMaintenance();
    }
  };
@@ -2169,16 +2170,14 @@ var mapWindow = window;
  function updateMapContactPathsToggle() {
    const btn = mapEl("map-contact-paths-toggle");
    if (!btn) return;
    btn.textContent = mapDecodeContactPathsEnabled ? "Contact Paths On" : "Contact Paths Off";
    btn.classList.toggle("is-active", mapDecodeContactPathsEnabled);
    btn.setAttribute("aria-pressed", mapDecodeContactPathsEnabled ? "true" : "false");
    btn.title = mapDecodeContactPathsEnabled ? "Directed decode paths are drawn when the target locator is known" : "Directed decode paths are hidden";
  }
  function updateMapP2pPathsToggle() {
    const btn = mapEl("map-p2p-paths-toggle");
    if (!btn) return;
    btn.textContent = mapP2pRadioPathsEnabled ? "TRX Paths On" : "TRX Paths Off";
    btn.classList.toggle("is-active", mapP2pRadioPathsEnabled);
    btn.setAttribute("aria-pressed", mapP2pRadioPathsEnabled ? "true" : "false");
    btn.title = mapP2pRadioPathsEnabled ? "TRX paths are drawn from a station popup" : "TRX paths are hidden";
  }
  function scheduleDecodeMapMaintenance() {
    if (C.decodeHistoryMapRenderingDeferred()) {
@@ -2338,7 +2337,7 @@ var mapWindow = window;
        selectedMapQsoKey = selectedMapQsoKey === entry.pathKey ? null : entry.pathKey ?? null;
        syncDecodeContactPathVisibility();
        if (selectedMapQsoKey && entry.sourceGrid) {
-          focusMapLocator(entry.sourceGrid, entry.sourceType);
+          mapWindow.navigateToMapLocator?.(entry.sourceGrid, entry.sourceType);
        }
      });
      const head = document.createElement("div");
@@ -2444,7 +2443,7 @@ var mapWindow = window;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          focusMapLocator(entry.grid ?? "", entry.sourceType);
+          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
        });
      }
      const head = document.createElement("div");
@@ -2550,7 +2549,7 @@ var mapWindow = window;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          focusMapLocator(entry.grid ?? "", entry.sourceType);
+          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
        });
      }
      const head = document.createElement("div");
@@ -3055,8 +3054,6 @@ var mapWindow = window;
  }
  modules.map = {
    initAprsMap,
    focusMapPosition,
    focusMapLocator,
    sizeAprsMapToViewport,
    syncAprsReceiverMarker,
    updateMapRigFilter,
@@ -3117,6 +3114,5 @@ var mapWindow = window;
    bandForHz,
    reverseGeocodeLocation
  };
  window.trxPluginRuntime.syncMapAll();
  autoInitIfVisible();
 })();
@@ -8,6 +8,7 @@ var satDom = {
  status: document.getElementById("sat-status"),
  liveView: document.getElementById("sat-live-view"),
  historyView: document.getElementById("sat-history-view"),
  predictionsView: document.getElementById("sat-predictions-view"),
  liveLatest: document.getElementById("sat-live-latest"),
  historyList: document.getElementById("sat-history-list"),
  historyCount: document.getElementById("sat-history-count"),
@@ -16,12 +17,29 @@ var satDom = {
  typeFilter: document.getElementById("sat-type-filter"),
  lrptState: document.getElementById("sat-lrpt-state"),
  viewLiveBtn: document.getElementById("sat-view-live"),
-  viewHistoryBtn: document.getElementById("sat-view-history")
+  viewHistoryBtn: document.getElementById("sat-view-history"),
  viewPredBtn: document.getElementById("sat-view-predictions"),
  predFilter: document.getElementById("sat-pred-filter"),
  predMinEl: document.getElementById("sat-pred-min-el"),
  predCategory: document.getElementById("sat-pred-category"),
  predCurrentList: document.getElementById("sat-pred-current-list"),
  predUpcomingList: document.getElementById("sat-pred-list"),
  predCurrentSec: document.getElementById("sat-pred-current-section"),
  predUpcomingSec: document.getElementById("sat-pred-upcoming-section"),
  predStatus: document.getElementById("sat-pred-status")
 };
 var satImageHistory = [];
 var SAT_MAX_IMAGES = 100;
 var SAT_PRED_PAGE_SIZE = 50;
 var satPredShowAll = false;
 var satFilterText = "";
 var satActiveView = "live";
 var satPredData = [];
 var satPredFilterText = "";
 var satPredMinEl = 0;
 var satPredCategory = "all";
 var satPredSatCount = 0;
 var satPredCountdownTimer = null;
 function scheduleSatUi(key, job) {
  if (typeof satWindow.trxScheduleUiFrameJob === "function") {
    satWindow.trxScheduleUiFrameJob(key, job);
@@ -30,19 +48,37 @@ function scheduleSatUi(key, job) {
  job();
 }
 function switchSatView(view) {
  const leavingPredictions = satActiveView === "predictions" && view !== "predictions";
  satActiveView = view;
  if (satDom.liveView) satDom.liveView.style.display = view === "live" ? "" : "none";
  if (satDom.historyView) satDom.historyView.style.display = view === "history" ? "" : "none";
  if (satDom.predictionsView) satDom.predictionsView.style.display = view === "predictions" ? "" : "none";
  if (satDom.viewLiveBtn) satDom.viewLiveBtn.classList.toggle("sat-view-active", view === "live");
  if (satDom.viewHistoryBtn) satDom.viewHistoryBtn.classList.toggle("sat-view-active", view === "history");
-  if (view === "history") renderSatHistoryTable();
+  if (satDom.viewPredBtn) satDom.viewPredBtn.classList.toggle("sat-view-active", view === "predictions");
  if (leavingPredictions) clearPredictionDom();
  if (view === "history") {
    renderSatHistoryTable();
  } else if (view === "predictions") {
    satPredShowAll = false;
    void loadSatPredictions();
  }
 }
 function clearPredictionDom() {
  stopCountdownTimer();
  if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
 }
 satWindow.clearSatPredictionDom = clearPredictionDom;
 satDom.viewLiveBtn?.addEventListener("click", () => {
  switchSatView("live");
 });
 satDom.viewHistoryBtn?.addEventListener("click", () => {
  switchSatView("history");
 });
 satDom.viewPredBtn?.addEventListener("click", () => {
  switchSatView("predictions");
 });
 var lastSatLrptOn = null;
 satWindow.updateSatLiveState = function(update) {
  if (!satDom.lrptState) return;
@@ -239,6 +275,200 @@ document.getElementById("settings-clear-sat-history")?.addEventListener("click",
    }
  })();
 });
 function azToCardinal(deg) {
  const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
  return dirs[Math.round(deg / 45) % 8] ?? "N";
 }
 function formatPredTime(ms) {
  const d = new Date(ms);
  const now = /* @__PURE__ */ new Date();
  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
  const day = d.getUTCDay() !== now.getUTCDay() ? `${dayNames[d.getUTCDay()] ?? ""} ` : "";
  const hh = String(d.getUTCHours()).padStart(2, "0");
  const mm = String(d.getUTCMinutes()).padStart(2, "0");
  return `${day}${hh}:${mm}`;
 }
 function formatPredDuration(s) {
  if (s >= 60) return `${Math.round(s / 60)} min`;
  return `${s}s`;
 }
 function formatCountdown(ms) {
  const totalSec = Math.max(0, Math.floor(ms / 1e3));
  const m = Math.floor(totalSec / 60);
  const s = totalSec % 60;
  return `${m}:${String(s).padStart(2, "0")}`;
 }
 function elevationClass(deg) {
  if (deg >= 45) return "sat-pred-el-high";
  if (deg >= 10) return "sat-pred-el-mid";
  return "sat-pred-el-low";
 }
 function stopCountdownTimer() {
  if (satPredCountdownTimer) {
    clearInterval(satPredCountdownTimer);
    satPredCountdownTimer = null;
  }
 }
 function startCountdownTimer(container) {
  const countdownEls = container?.querySelectorAll(".sat-pred-col-countdown") ?? [];
  if (countdownEls.length === 0) return;
  satPredCountdownTimer = setInterval(() => {
    if (satActiveView !== "predictions") {
      stopCountdownTimer();
      return;
    }
    const n = Date.now();
    let anyActive = false;
    for (const el of countdownEls) {
      const los = Number.parseInt(el.dataset.los ?? "0", 10);
      const rem = los - n;
      if (rem > 0) {
        el.textContent = formatCountdown(rem);
        anyActive = true;
      } else {
        el.textContent = "0:00";
      }
    }
    if (!anyActive) {
      stopCountdownTimer();
      renderSatPredictions(getFilteredPredictions());
    }
  }, 1e3);
 }
 function buildCurrentPassRow(pass, now) {
  const row = document.createElement("div");
  row.className = "sat-pred-row-current";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} → ${azToCardinal(pass.azimuth_los_deg)}`;
  const remaining = Math.max(0, pass.los_ms - now);
  row.innerHTML = [
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}°</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.los_ms)}</span>`,
    `<span class="sat-pred-col-countdown" data-los="${pass.los_ms}">${formatCountdown(remaining)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`
  ].join("");
  return row;
 }
 function buildUpcomingPassRow(pass) {
  const row = document.createElement("div");
  row.className = "sat-pred-row";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} → ${azToCardinal(pass.azimuth_los_deg)}`;
  row.innerHTML = [
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}°</span>`,
    `<span class="sat-pred-col-dur">${formatPredDuration(pass.duration_s)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`
  ].join("");
  return row;
 }
 function getFilteredPredictions() {
  let items = satPredData;
  if (satPredCategory !== "all") items = items.filter((p) => p.category === satPredCategory);
  if (satPredMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= satPredMinEl);
  if (satPredFilterText) items = items.filter((p) => p.satellite.toUpperCase().includes(satPredFilterText));
  return items;
 }
 function applyPredFilters() {
  renderSatPredictions(getFilteredPredictions());
 }
 var satPredictionFilter = satDom.predFilter;
 satPredictionFilter?.addEventListener("input", () => {
  satPredFilterText = satPredictionFilter.value.trim().toUpperCase();
  applyPredFilters();
 });
 var satPredictionMinElevation = satDom.predMinEl;
 satPredictionMinElevation?.addEventListener("change", () => {
  satPredMinEl = Number.parseInt(satPredictionMinElevation.value, 10) || 0;
  applyPredFilters();
 });
 var satPredictionCategory = satDom.predCategory;
 satPredictionCategory?.addEventListener("change", () => {
  satPredCategory = satPredictionCategory.value;
  applyPredFilters();
 });
 function renderSatPredictions(passes, error) {
  stopCountdownTimer();
  if (error) {
    if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
    if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = "none";
    if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = "none";
    if (satDom.predStatus) satDom.predStatus.textContent = error;
    return;
  }
  if (!Array.isArray(passes) || passes.length === 0) {
    if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
    if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = "none";
    if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = "none";
    if (satDom.predStatus) satDom.predStatus.textContent = "No passes found in the next 24 hours.";
    return;
  }
  const now = Date.now();
  const current = passes.filter((p) => p.aos_ms <= now && p.los_ms > now);
  const upcoming = passes.filter((p) => p.aos_ms > now);
  if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = current.length > 0 ? "" : "none";
  if (satDom.predCurrentList) {
    if (current.length === 0) {
      satDom.predCurrentList.innerHTML = "";
    } else {
      const frag = document.createDocumentFragment();
      for (const pass of current) frag.appendChild(buildCurrentPassRow(pass, now));
      satDom.predCurrentList.replaceChildren(frag);
    }
  }
  const upcomingLimit = satPredShowAll ? upcoming.length : SAT_PRED_PAGE_SIZE;
  const visibleUpcoming = upcoming.slice(0, upcomingLimit);
  const hiddenCount = upcoming.length - visibleUpcoming.length;
  if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = upcoming.length > 0 ? "" : "none";
  if (satDom.predUpcomingList) {
    const frag = document.createDocumentFragment();
    for (const pass of visibleUpcoming) frag.appendChild(buildUpcomingPassRow(pass));
    if (hiddenCount > 0) {
      const moreRow = document.createElement("div");
      moreRow.className = "sat-pred-row";
      moreRow.style.cursor = "pointer";
      moreRow.style.textAlign = "center";
      moreRow.innerHTML = `<span style="grid-column:1/-1;color:var(--accent);font-size:0.82rem;">Show ${hiddenCount} more passes…</span>`;
      moreRow.addEventListener("click", () => {
        satPredShowAll = true;
        renderSatPredictions(getFilteredPredictions());
      });
      frag.appendChild(moreRow);
    }
    satDom.predUpcomingList.replaceChildren(frag);
  }
  if (satDom.predStatus) {
    let text = `${current.length} active · ${upcoming.length} upcoming · times in UTC`;
    if (satPredSatCount > 0) text += ` · ${satPredSatCount} satellites tracked`;
    satDom.predStatus.textContent = text;
  }
  if (current.length > 0 && satActiveView === "predictions") {
    startCountdownTimer(satDom.predCurrentList);
  }
 }
 async function loadSatPredictions() {
  if (satDom.predStatus) satDom.predStatus.textContent = "Loading predictions…";
  if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
  try {
    const resp = await fetch("/sat_passes");
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json();
    satPredSatCount = data.satellite_count || 0;
    if (data.error) {
      satPredData = [];
      renderSatPredictions([], data.error);
    } else {
      satPredData = data.passes || [];
      renderSatPredictions(getFilteredPredictions());
    }
  } catch (error) {
    renderSatPredictions([], `Failed to load predictions: ${error instanceof Error ? error.message : String(error)}`);
  }
 }
 satWindow.satShowOnMap = function(south, west, north, east) {
  if (typeof satWindow.enableMapSourceFilter === "function") {
    satWindow.enableMapSourceFilter("sat");
@@ -1,228 +0,0 @@
 // src/plugins/satellite-predictions.ts
 var predWindow = window;
 var dom = {
  page: document.getElementById("tab-satellites"),
  filter: document.getElementById("sat-pred-filter"),
  minElevation: document.getElementById("sat-pred-min-el"),
  category: document.getElementById("sat-pred-category"),
  currentList: document.getElementById("sat-pred-current-list"),
  upcomingList: document.getElementById("sat-pred-list"),
  currentSection: document.getElementById("sat-pred-current-section"),
  upcomingSection: document.getElementById("sat-pred-upcoming-section"),
  status: document.getElementById("sat-pred-status")
 };
 var PAGE_SIZE = 50;
 var predShowAll = false;
 var predData = [];
 var predFilterText = "";
 var predMinEl = 0;
 var predCategory = "all";
 var predSatCount = 0;
 var predCountdownTimer = null;
 function isPageVisible() {
  return !!dom.page && dom.page.style.display !== "none";
 }
 function azToCardinal(deg) {
  const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
  return dirs[Math.round(deg / 45) % 8] ?? "N";
 }
 function formatPredTime(ms) {
  const d = new Date(ms);
  const now = /* @__PURE__ */ new Date();
  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
  const day = d.getUTCDay() !== now.getUTCDay() ? `${dayNames[d.getUTCDay()] ?? ""} ` : "";
  const hh = String(d.getUTCHours()).padStart(2, "0");
  const mm = String(d.getUTCMinutes()).padStart(2, "0");
  return `${day}${hh}:${mm}`;
 }
 function formatPredDuration(s) {
  if (s >= 60) return `${Math.round(s / 60)} min`;
  return `${s}s`;
 }
 function formatCountdown(ms) {
  const totalSec = Math.max(0, Math.floor(ms / 1e3));
  const m = Math.floor(totalSec / 60);
  const s = totalSec % 60;
  return `${m}:${String(s).padStart(2, "0")}`;
 }
 function elevationClass(deg) {
  if (deg >= 45) return "sat-pred-el-high";
  if (deg >= 10) return "sat-pred-el-mid";
  return "sat-pred-el-low";
 }
 function stopCountdownTimer() {
  if (predCountdownTimer) {
    clearInterval(predCountdownTimer);
    predCountdownTimer = null;
  }
 }
 function startCountdownTimer(container) {
  const countdownEls = container?.querySelectorAll(".sat-pred-col-countdown") ?? [];
  if (countdownEls.length === 0) return;
  predCountdownTimer = setInterval(() => {
    if (!isPageVisible()) {
      stopCountdownTimer();
      return;
    }
    const n = Date.now();
    let anyActive = false;
    for (const el of countdownEls) {
      const los = Number.parseInt(el.dataset.los ?? "0", 10);
      const rem = los - n;
      if (rem > 0) {
        el.textContent = formatCountdown(rem);
        anyActive = true;
      } else {
        el.textContent = "0:00";
      }
    }
    if (!anyActive) {
      stopCountdownTimer();
      render(filtered());
    }
  }, 1e3);
 }
 function buildCurrentPassRow(pass, now) {
  const row = document.createElement("div");
  row.className = "sat-pred-row-current";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} → ${azToCardinal(pass.azimuth_los_deg)}`;
  const remaining = Math.max(0, pass.los_ms - now);
  row.innerHTML = [
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}°</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.los_ms)}</span>`,
    `<span class="sat-pred-col-countdown" data-los="${pass.los_ms}">${formatCountdown(remaining)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`
  ].join("");
  return row;
 }
 function buildUpcomingPassRow(pass) {
  const row = document.createElement("div");
  row.className = "sat-pred-row";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} → ${azToCardinal(pass.azimuth_los_deg)}`;
  row.innerHTML = [
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}°</span>`,
    `<span class="sat-pred-col-dur">${formatPredDuration(pass.duration_s)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`
  ].join("");
  return row;
 }
 function filtered() {
  let items = predData;
  if (predCategory !== "all") items = items.filter((p) => p.category === predCategory);
  if (predMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= predMinEl);
  if (predFilterText) items = items.filter((p) => p.satellite.toUpperCase().includes(predFilterText));
  return items;
 }
 function applyFilters() {
  render(filtered());
 }
 var filterInput = dom.filter;
 filterInput?.addEventListener("input", () => {
  predFilterText = filterInput.value.trim().toUpperCase();
  applyFilters();
 });
 var minElevationSelect = dom.minElevation;
 minElevationSelect?.addEventListener("change", () => {
  predMinEl = Number.parseInt(minElevationSelect.value, 10) || 0;
  applyFilters();
 });
 var categorySelect = dom.category;
 categorySelect?.addEventListener("change", () => {
  predCategory = categorySelect.value;
  applyFilters();
 });
 function render(passes, error) {
  stopCountdownTimer();
  if (error) {
    if (dom.currentList) dom.currentList.innerHTML = "";
    if (dom.upcomingList) dom.upcomingList.innerHTML = "";
    if (dom.currentSection) dom.currentSection.style.display = "none";
    if (dom.upcomingSection) dom.upcomingSection.style.display = "none";
    if (dom.status) dom.status.textContent = error;
    return;
  }
  if (!Array.isArray(passes) || passes.length === 0) {
    if (dom.currentList) dom.currentList.innerHTML = "";
    if (dom.upcomingList) dom.upcomingList.innerHTML = "";
    if (dom.currentSection) dom.currentSection.style.display = "none";
    if (dom.upcomingSection) dom.upcomingSection.style.display = "none";
    if (dom.status) dom.status.textContent = "No passes found in the next 24 hours.";
    return;
  }
  const now = Date.now();
  const current = passes.filter((p) => p.aos_ms <= now && p.los_ms > now);
  const upcoming = passes.filter((p) => p.aos_ms > now);
  if (dom.currentSection) dom.currentSection.style.display = current.length > 0 ? "" : "none";
  if (dom.currentList) {
    if (current.length === 0) {
      dom.currentList.innerHTML = "";
    } else {
      const frag = document.createDocumentFragment();
      for (const pass of current) frag.appendChild(buildCurrentPassRow(pass, now));
      dom.currentList.replaceChildren(frag);
    }
  }
  const upcomingLimit = predShowAll ? upcoming.length : PAGE_SIZE;
  const visibleUpcoming = upcoming.slice(0, upcomingLimit);
  const hiddenCount = upcoming.length - visibleUpcoming.length;
  if (dom.upcomingSection) dom.upcomingSection.style.display = upcoming.length > 0 ? "" : "none";
  if (dom.upcomingList) {
    const frag = document.createDocumentFragment();
    for (const pass of visibleUpcoming) frag.appendChild(buildUpcomingPassRow(pass));
    if (hiddenCount > 0) {
      const moreRow = document.createElement("div");
      moreRow.className = "sat-pred-row";
      moreRow.style.cursor = "pointer";
      moreRow.style.textAlign = "center";
      moreRow.innerHTML = `<span style="grid-column:1/-1;color:var(--accent);font-size:0.82rem;">Show ${hiddenCount} more passes…</span>`;
      moreRow.addEventListener("click", () => {
        predShowAll = true;
        render(filtered());
      });
      frag.appendChild(moreRow);
    }
    dom.upcomingList.replaceChildren(frag);
  }
  if (dom.status) {
    let text = `${current.length} active · ${upcoming.length} upcoming · times in UTC`;
    if (predSatCount > 0) text += ` · ${predSatCount} satellites tracked`;
    dom.status.textContent = text;
  }
  if (current.length > 0 && isPageVisible()) {
    startCountdownTimer(dom.currentList);
  }
 }
 async function load() {
  if (dom.status) dom.status.textContent = "Loading predictions…";
  if (dom.currentList) dom.currentList.innerHTML = "";
  if (dom.upcomingList) dom.upcomingList.innerHTML = "";
  try {
    const resp = await fetch("/sat_passes");
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json();
    predSatCount = data.satellite_count || 0;
    if (data.error) {
      predData = [];
      render([], data.error);
    } else {
      predData = data.passes || [];
      render(filtered());
    }
  } catch (error) {
    render([], `Failed to load predictions: ${error instanceof Error ? error.message : String(error)}`);
  }
 }
 function clearPredictionDom() {
  stopCountdownTimer();
  if (dom.currentList) dom.currentList.innerHTML = "";
  if (dom.upcomingList) dom.upcomingList.innerHTML = "";
 }
 predWindow.clearSatPredictionDom = clearPredictionDom;
 predWindow.refreshSatPredictions = function() {
  predShowAll = false;
  void load();
 };
@@ -1,6 +1,3 @@
 import {
  hasAuthRole
 } from "./chunk-PISLBJGN.js";
 import {
  hostState
 } from "./chunk-KL66PICH.js";
@@ -18,7 +15,7 @@ function schedulerOptionalEl(id) {
 }
 (function() {
  "use strict";
-  let schedulerRoles = [];
+  let schedulerRole = null;
  let currentRigId = null;
  let currentConfig = null;
  let currentSchedulerStatus = null;
@@ -28,8 +25,8 @@ function schedulerOptionalEl(id) {
  let schedulerStepPending = false;
  let schEntryEditIdx = null;
  let schedulerDirty = false;
-  function initScheduler(rigId, roles) {
+  function initScheduler(rigId, role) {
-    schedulerRoles = roles;
+    schedulerRole = role;
    currentRigId = rigId || null;
    if (currentRigId) loadScheduler();
    startStatusPolling();
@@ -275,7 +272,7 @@ function schedulerOptionalEl(id) {
    const nextBtn = schedulerEl("scheduler-next-btn");
    if (!prevBtn || !nextBtn) return;
    const state = schedulerInterleaveState(currentConfig);
-    const enabled = hasAuthRole(schedulerRoles, "control") && !!currentRigId && !schedulerStepPending && state.activeEntries.length > 1;
+    const enabled = schedulerRole === "control" && !!currentRigId && !schedulerStepPending && state.activeEntries.length > 1;
    prevBtn.disabled = !enabled;
    nextBtn.disabled = !enabled;
    const hint = enabled ? "Select a different active scheduler entry" : "Available only when multiple scheduler entries are active";
@@ -357,7 +354,7 @@ function schedulerOptionalEl(id) {
    const panel = schedulerEl("scheduler-panel");
    if (!panel) return;
    const mode = currentConfig && currentConfig.mode || "disabled";
-    const isControl = hasAuthRole(schedulerRoles, "control");
+    const isControl = schedulerRole === "control";
    setSelected("scheduler-mode-select", mode);
    const satEnabled = currentConfig && currentConfig.satellites && currentConfig.satellites.enabled;
    const controlRow = document.querySelector(".scheduler-control-row");
@@ -1223,8 +1220,8 @@ function schedulerOptionalEl(id) {
    markDirty: markSchedulerDirty
  };
  schedulerWindow.trx.modules.scheduler = schedulerService;
-  if (!hostState.authEnabled || hostState.authRoles.length > 0) {
+  if (hostState.authRole != null) {
-    initScheduler(hostState.lastActiveRigId, hostState.authRoles);
+    initScheduler(hostState.lastActiveRigId, hostState.authRole);
    wireSchedulerEvents();
  }
 })();
@@ -1,264 +0,0 @@
 import {
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
 // src/plugins/sstv.ts
 var sstvWindow = window;
 var sstvDom = {
  status: document.getElementById("sstv-status"),
  liveView: document.getElementById("sstv-live-view"),
  historyView: document.getElementById("sstv-history-view"),
  liveContainer: document.getElementById("sstv-live-container"),
  liveInfo: document.getElementById("sstv-live-info"),
  liveCanvas: document.getElementById("sstv-live-canvas"),
  liveLatest: document.getElementById("sstv-live-latest"),
  historyList: document.getElementById("sstv-history-list"),
  historyCount: document.getElementById("sstv-history-count"),
  filterInput: document.getElementById("sstv-filter"),
  sortSelect: document.getElementById("sstv-sort"),
  toggleBtn: document.getElementById("sstv-decode-toggle-btn"),
  clearBtn: document.getElementById("sstv-clear-btn"),
  viewLiveBtn: document.getElementById("sstv-view-live"),
  viewHistoryBtn: document.getElementById("sstv-view-history")
 };
 var SSTV_MAX_IMAGES = 100;
 var sstvHistory = [];
 var liveCtx = null;
 var liveMode = "";
 var liveHeight = 0;
 var liveRows = 0;
 var activeView = "live";
 var filterText = "";
 function retentionMs() {
  return sstvWindow.getDecodeHistoryRetentionMs?.() ?? 24 * 60 * 60 * 1e3;
 }
 function pruneHistory() {
  const cutoff = Date.now() - retentionMs();
  sstvHistory = sstvHistory.filter((image) => (image._tsMs || 0) > cutoff);
 }
 function escapeHtml(value) {
  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function scheduleUi(key, job) {
  if (typeof sstvWindow.trxScheduleUiFrameJob === "function") {
    sstvWindow.trxScheduleUiFrameJob(key, job);
    return;
  }
  job();
 }
 function imageUrl(image) {
  if (!image.path) return null;
  const filename = image.path.split(/[\\/]/).pop();
  return filename ? `/sstv-images/${encodeURIComponent(filename)}` : null;
 }
 function decodeBase64(data) {
  const binary = atob(data);
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
  return bytes;
 }
 function switchView(view) {
  activeView = view;
  if (sstvDom.liveView) sstvDom.liveView.style.display = view === "live" ? "" : "none";
  if (sstvDom.historyView) sstvDom.historyView.style.display = view === "history" ? "" : "none";
  for (const button of [sstvDom.viewLiveBtn, sstvDom.viewHistoryBtn]) {
    button?.classList.remove("sat-view-active");
  }
  if (view === "live") sstvDom.viewLiveBtn?.classList.add("sat-view-active");
  else sstvDom.viewHistoryBtn?.classList.add("sat-view-active");
  if (view === "history") renderHistoryTable();
 }
 sstvDom.viewLiveBtn?.addEventListener("click", () => {
  switchView("live");
 });
 sstvDom.viewHistoryBtn?.addEventListener("click", () => {
  switchView("history");
 });
 function beginPicture(mode, width, height) {
  const canvas = sstvDom.liveCanvas;
  if (!canvas || width <= 0 || height <= 0) return;
  liveMode = mode;
  liveHeight = height;
  liveRows = 0;
  canvas.width = width;
  canvas.height = height;
  liveCtx = canvas.getContext("2d");
  if (!liveCtx) return;
  liveCtx.fillStyle = "#606060";
  liveCtx.fillRect(0, 0, width, height);
  if (sstvDom.liveContainer) sstvDom.liveContainer.style.display = "";
  updateLiveInfo();
 }
 function updateLiveInfo() {
  if (!sstvDom.liveInfo) return;
  const canvas = sstvDom.liveCanvas;
  const size = canvas ? `${canvas.width}×${canvas.height}` : "";
  sstvDom.liveInfo.textContent = liveMode ? `${liveMode} · ${size} · line ${liveRows}${liveHeight ? ` of ${liveHeight}` : ""}` : "";
 }
 function paintRow(line, rgb) {
  const canvas = sstvDom.liveCanvas;
  if (!liveCtx || !canvas) return;
  const width = canvas.width;
  if (line < 0 || line >= canvas.height || rgb.length < width * 3) return;
  const row = liveCtx.createImageData(width, 1);
  for (let x = 0; x < width; x += 1) {
    row.data[x * 4] = rgb[x * 3] ?? 0;
    row.data[x * 4 + 1] = rgb[x * 3 + 1] ?? 0;
    row.data[x * 4 + 2] = rgb[x * 3 + 2] ?? 0;
    row.data[x * 4 + 3] = 255;
  }
  liveCtx.putImageData(row, 0, line);
  liveRows = Math.max(liveRows, line + 1);
 }
 function onProgress(msg) {
  if (!isActiveRigDecode(msg.rig_id)) return;
  if (msg.state) {
    if (sstvDom.status) sstvDom.status.textContent = msg.state;
    beginPicture(msg.mode || "", msg.width || 0, msg.height || 0);
    return;
  }
  if (typeof msg.line !== "number" || !msg.line_data) return;
  const line = msg.line;
  const rgb = decodeBase64(msg.line_data);
  scheduleUi(`sstv-row-${line}`, () => {
    paintRow(line, rgb);
    updateLiveInfo();
  });
 }
 function onImage(msg) {
  const image = { ...msg };
  image._tsMs = typeof msg.ts_ms === "number" ? msg.ts_ms : Date.now();
  image._ts = new Date(image._tsMs).toLocaleTimeString();
  sstvHistory.push(image);
  if (sstvHistory.length > SSTV_MAX_IMAGES) sstvHistory.shift();
  pruneHistory();
  if (!isActiveRigDecode(image.rig_id)) return;
  if (sstvDom.status) {
    sstvDom.status.textContent = image.complete ? `Received ${image.mode ?? "picture"}` : `Partial ${image.mode ?? "picture"} — ${image.lines ?? 0} lines`;
  }
  scheduleUi("sstv-latest", renderLatestCard);
  if (activeView === "history") scheduleUi("sstv-history", renderHistoryTable);
 }
 function sstvRigImages() {
  return forActiveRig(sstvHistory);
 }
 function renderLatestCard() {
  if (!sstvDom.liveLatest) return;
  const rigImages = sstvRigImages();
  const latest = rigImages[rigImages.length - 1];
  if (!latest) {
    sstvDom.liveLatest.innerHTML = "";
    return;
  }
  const url = imageUrl(latest);
  const lines = `${latest.lines ?? 0}${latest.height ? ` of ${latest.height}` : ""} lines`;
  const state = latest.complete ? "complete" : "partial";
  sstvDom.liveLatest.innerHTML = `
    <div class="sat-latest-card">
      <div style="display:flex; align-items:baseline; gap:0.5rem; flex-wrap:wrap;">
        <strong>${escapeHtml(latest.mode ?? "SSTV")}</strong>
        <small style="color:var(--text-muted);">${escapeHtml(latest._ts ?? "")} · ${lines} · ${state}</small>
      </div>
      ${url ? `<a href="${escapeHtml(url)}" target="_blank" rel="noopener">
             <img src="${escapeHtml(url)}" alt="Received ${escapeHtml(latest.mode ?? "SSTV")} picture"
                  style="margin-top:0.4rem; width:100%; max-width:640px; image-rendering:pixelated;" />
           </a>` : ""}
    </div>`;
 }
 function filteredHistory() {
  const rigImages = sstvRigImages();
  const text = filterText.trim().toLowerCase();
  const matching = text ? rigImages.filter((image) => (image.mode ?? "").toLowerCase().includes(text)) : rigImages;
  const newestFirst = (sstvDom.sortSelect?.value ?? "newest") === "newest";
  matching.sort((a, b) => (newestFirst ? 1 : -1) * ((b._tsMs ?? 0) - (a._tsMs ?? 0)));
  return matching;
 }
 function renderHistoryTable() {
  if (!sstvDom.historyList) return;
  pruneHistory();
  const rows = filteredHistory();
  sstvDom.historyList.innerHTML = rows.map((image) => {
    const url = imageUrl(image);
    const size = image.width && image.height ? `${image.width}×${image.height}` : "--";
    const lines = image.complete ? String(image.lines ?? 0) : `${image.lines ?? 0} (partial)`;
    return `<div class="sat-history-row">
        <span class="sat-col-time">${escapeHtml(image._ts ?? "")}</span>
        <span class="sat-col-type">${escapeHtml(image.mode ?? "--")}</span>
        <span class="sat-col-sat">${escapeHtml(size)}</span>
        <span class="sat-col-lines">${escapeHtml(lines)}</span>
        <span class="sat-col-link">${url ? `<a href="${escapeHtml(url)}" target="_blank" rel="noopener">View</a>` : "--"}</span>
      </div>`;
  }).join("");
  if (sstvDom.historyCount) {
    sstvDom.historyCount.textContent = rows.length ? `${rows.length} picture${rows.length === 1 ? "" : "s"}` : "No pictures yet";
  }
 }
 sstvDom.filterInput?.addEventListener("input", () => {
  filterText = sstvDom.filterInput?.value ?? "";
  renderHistoryTable();
 });
 sstvDom.sortSelect?.addEventListener("change", () => {
  renderHistoryTable();
 });
 function restoreHistory(entries) {
  if (!Array.isArray(entries)) return;
  for (const entry of entries) onImage(entry);
 }
 function resetHistoryView() {
  sstvHistory = [];
  liveRows = 0;
  liveMode = "";
  if (sstvDom.liveContainer) sstvDom.liveContainer.style.display = "none";
  if (sstvDom.status) sstvDom.status.textContent = "Idle";
  renderLatestCard();
  renderHistoryTable();
 }
 sstvWindow.syncSstvToggle = function syncSstvToggle(enabled) {
  const button = sstvDom.toggleBtn;
  if (!button) return;
  button.textContent = enabled ? "Disable SSTV" : "Enable SSTV";
  button.setAttribute("aria-pressed", String(enabled));
  button.classList.toggle("is-active", enabled);
 };
 sstvDom.toggleBtn?.addEventListener("click", () => {
  void (async () => {
    try {
      if (sstvDom.toggleBtn) {
        await sstvWindow.takeSchedulerControlForDecoderDisable?.(sstvDom.toggleBtn);
      }
      await hostCore.postPath("/toggle_sstv_decode");
    } catch (e) {
      console.error("SSTV toggle failed", e);
    }
  })();
 });
 sstvDom.clearBtn?.addEventListener("click", () => {
  void (async () => {
    try {
      await hostCore.postPath("/clear_sstv_decode");
      resetHistoryView();
    } catch (e) {
      console.error("SSTV clear failed", e);
    }
  })();
 });
 renderLatestCard();
 sstvWindow.trxPluginRuntime.registerDecoder({
  id: "sstv",
  onMessage: onImage,
  restore: restoreHistory,
  prune: renderHistoryTable,
  reset: resetHistoryView,
  rerender: () => {
    renderLatestCard();
    renderHistoryTable();
  }
 });
 sstvWindow.trxPluginRuntime.registerDecoder({
  id: "sstv_progress",
  onMessage: onProgress
 });
@@ -286,10 +286,7 @@ function vchanSyncModeDisplay() {
  if (!modeEl) return;
  if (vchanIsOnVirtual()) {
    const ch = vchanActiveChannel();
-    if (ch && ch.mode) {
+    if (ch && ch.mode) modeEl.value = ch.mode.toUpperCase();
      modeEl.value = ch.mode.toUpperCase();
      hostCore.syncModePicker();
    }
  }
  const modeUpper = (modeEl.value || "").toUpperCase();
  if (typeof hostState.lastModeName === "string") {
@@ -1,7 +1,3 @@
 import {
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -64,21 +60,17 @@ function vdesHexPreview(rawBytes) {
  if (!Array.isArray(rawBytes) || rawBytes.length === 0) return "--";
  return rawBytes.slice(0, 20).map((value) => value.toString(16).padStart(2, "0")).join(" ").toUpperCase();
 }
 function vdesRigMessages() {
  return forActiveRig(vdesMessageHistory);
 }
 function updateVdesSummary() {
  pruneVdesMessageHistory();
  if (vdesChannelSummaryEl) {
    vdesChannelSummaryEl.textContent = currentVdesCenterText();
  }
  const rigMessages = vdesRigMessages();
  if (vdesFrameCountEl) {
-    const count = rigMessages.length;
+    const count = vdesMessageHistory.length;
    vdesFrameCountEl.textContent = `${count} burst${count === 1 ? "" : "s"}`;
  }
  if (vdesLatestSeenEl) {
-    const latest = rigMessages[0];
+    const latest = vdesMessageHistory[0];
    vdesLatestSeenEl.textContent = latest ? vdesAgeText(latest._tsMs) : "No traffic yet";
  }
 }
@@ -145,7 +137,7 @@ function updateVdesBar() {
  updateVdesSummary();
  const isVdes = (document.getElementById("mode")?.value || "").toUpperCase() === "VDES";
  const cutoffMs = Date.now() - VDES_BAR_WINDOW_MS;
-  const messages = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(msg.rig_id)).slice(0, 6);
+  const messages = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs).slice(0, 6);
  if (!isVdes || messages.length === 0) {
    vdesBarOverlay.style.display = "none";
    vdesBarOverlay.innerHTML = "";
@@ -190,7 +182,7 @@ function renderVdesHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of vdesRigMessages()) {
+  for (const message of vdesMessageHistory) {
    fragment.appendChild(renderVdesRow(message));
  }
  vdesMessagesEl.replaceChildren(fragment);
@@ -217,10 +209,10 @@ function normalizeServerVdesMessage(msg) {
 }
 function onServerVdesBatch(messages) {
  if (!Array.isArray(messages) || messages.length === 0) return;
  if (vdesStatus) vdesStatus.textContent = "Receiving";
  const normalized = [];
  for (const msg of messages) {
    const next = normalizeServerVdesMessage(msg);
    if (vdesStatus && isActiveRigDecode(next.rig_id)) vdesStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -228,7 +220,9 @@ function onServerVdesBatch(messages) {
      minute: "2-digit",
      second: "2-digit"
    });
-    plotVdesMessage(next);
+    if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
      vdesWindow.vdesMapAddPoint(next);
    }
    normalized.push(next);
  }
  normalized.reverse();
@@ -254,15 +248,13 @@ if (vdesFilterInput) {
    renderVdesHistory();
  });
 }
 function plotVdesMessage(msg) {
  if (msg.lat == null || msg.lon == null || !vdesWindow.vdesMapAddPoint) return;
  vdesWindow.vdesMapAddPoint(msg);
 }
 function onServerVdes(msg) {
  if (vdesStatus) vdesStatus.textContent = "Receiving";
  const next = normalizeServerVdesMessage(msg);
  if (vdesStatus && isActiveRigDecode(next.rig_id)) vdesStatus.textContent = "Receiving";
  addVdesMessage(next);
-  plotVdesMessage(next);
+  if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
    vdesWindow.vdesMapAddPoint(next);
  }
 }
 function pruneVdesHistoryView() {
  pruneVdesMessageHistory();
@@ -276,13 +268,5 @@ window.trxPluginRuntime.registerDecoder({
  onBatch: onServerVdesBatch,
  restore: onServerVdesBatch,
  reset: resetVdesHistoryView,
-  prune: pruneVdesHistoryView,
+  prune: pruneVdesHistoryView
  rerender: () => {
    updateVdesBar();
    renderVdesHistory();
  },
  // Oldest first, so tracks are rebuilt in the order they happened.
  syncMap: () => {
    for (const entry of [...vdesMessageHistory].reverse()) plotVdesMessage(entry);
  }
 });
@@ -1,7 +1,3 @@
 import {
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -106,17 +102,13 @@ function paintLine(lineBytes) {
  wefaxLiveCtx.putImageData(imgData, 0, y);
  wefaxLiveLineCount++;
 }
 function wefaxRigImages() {
  return forActiveRig(wefaxImageHistory);
 }
 function renderWefaxLatestCard() {
  if (!wefaxDom.liveLatest) return;
-  const rigImages = wefaxRigImages();
+  if (wefaxImageHistory.length === 0) {
  if (rigImages.length === 0) {
    wefaxDom.liveLatest.innerHTML = '<div style="color:var(--text-muted);font-size:0.82rem;">No images decoded yet. Enable the decoder and tune to a WEFAX station.</div>';
    return;
  }
-  const img = rigImages[0];
+  const img = wefaxImageHistory[0];
  if (!img) return;
  const ts = img._ts || "--";
  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : "";
@@ -137,7 +129,7 @@ function renderWefaxLatestCard() {
  wefaxDom.liveLatest.innerHTML = html;
 }
 function getWefaxFilteredHistory() {
-  let items = wefaxRigImages();
+  let items = wefaxImageHistory;
  if (wefaxFilterText) {
    items = items.filter(function(i) {
      const haystack = [
@@ -181,7 +173,7 @@ function renderWefaxHistoryTable() {
  }
  wefaxDom.historyList.replaceChildren(fragment);
  if (wefaxDom.historyCount) {
-    const total = wefaxRigImages().length;
+    const total = wefaxImageHistory.length;
    const shown = items.length;
    wefaxDom.historyCount.textContent = total === 0 ? "No images yet" : shown === total ? `${String(total)} image${total === 1 ? "" : "s"}` : `${String(shown)} of ${String(total)} images`;
  }
@@ -216,7 +208,6 @@ function addWefaxImage(msg) {
  }
 }
 function onServerWefaxProgress(msg) {
  if (!isActiveRigDecode(msg.rig_id)) return;
  if (msg.state && !msg.line_data) {
    if (wefaxDom.status) {
      wefaxDom.status.textContent = msg.state;
@@ -243,7 +234,6 @@ function onServerWefaxProgress(msg) {
 }
 function onServerWefax(msg) {
  addWefaxImage(msg);
  if (!isActiveRigDecode(msg.rig_id)) return;
  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = "none";
  if (wefaxDom.status) {
    wefaxDom.status.textContent = `Complete — ${String(msg.line_count ?? 0)} lines`;
@@ -338,11 +328,7 @@ wefaxWindow.trxPluginRuntime.registerDecoder({
  onMessage: onServerWefax,
  restore: restoreWefaxHistory,
  prune: pruneWefaxHistoryView,
-  reset: resetWefaxHistoryView,
+  reset: resetWefaxHistoryView
  rerender: () => {
    renderWefaxLatestCard();
    renderWefaxHistoryTable();
  }
 });
 wefaxWindow.trxPluginRuntime.registerDecoder({
  id: "wefax_progress",
@@ -1,7 +1,3 @@
 import {
  forActiveRig,
  isActiveRigDecode
 } from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -68,10 +64,10 @@ function renderWsprRow(msg) {
 function renderWsprHistory() {
  pruneWsprMessageHistory();
  if (!wsprMessagesEl) return;
  const rigMessages = forActiveRig(wsprMessageHistory);
  const fragment = document.createDocumentFragment();
-  for (const message of rigMessages) {
+  for (let i = 0; i < wsprMessageHistory.length; i += 1) {
-    fragment.appendChild(renderWsprRow(message));
+    const message = wsprMessageHistory[i];
    if (message) fragment.appendChild(renderWsprRow(message));
  }
  wsprMessagesEl.replaceChildren(fragment);
 }
@@ -94,8 +90,6 @@ function normalizeServerWsprMessage(msg) {
    station,
    rfHz,
    history: {
      rig_id: msg.rig_id ?? null,
      _rfHz: rfHz,
      receiver: wsprWindow.getDecodeRigMeta ? wsprWindow.getDecodeRigMeta() : null,
      ts_ms: msg.ts_ms,
      snr_db: msg.snr_db,
@@ -107,11 +101,16 @@ function normalizeServerWsprMessage(msg) {
 }
 function onServerWsprBatch(messages) {
  if (!Array.isArray(messages) || messages.length === 0) return;
  if (wsprStatus) wsprStatus.textContent = "Receiving";
  const normalized = [];
  for (const msg of messages) {
    const next = normalizeServerWsprMessage(msg);
-    if (wsprStatus && isActiveRigDecode(msg.rig_id)) wsprStatus.textContent = "Receiving";
+    if (next.grids.length > 0 && wsprWindow.mapAddLocator) {
-    plotWsprLocator(msg);
+      wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
        ...msg,
        ...next.rfHz === null ? {} : { freq_hz: next.rfHz }
      });
    }
    next.history._tsMs = Number.isFinite(next.history.ts_ms) ? Number(next.history.ts_ms) : Date.now();
    normalized.push(next.history);
  }
@@ -251,19 +250,15 @@ document.getElementById("settings-clear-wspr-history")?.addEventListener("click"
    }
  })();
 });
 function plotWsprLocator(msg) {
  const next = normalizeServerWsprMessage(msg);
  if (next.grids.length === 0 || !wsprWindow.mapAddLocator) return;
  const rfHz = finiteNumber(msg._rfHz) ?? next.rfHz;
  wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
    ...msg,
    ...rfHz === null ? {} : { freq_hz: rfHz }
  });
 }
 function onServerWspr(msg) {
-  if (wsprStatus && isActiveRigDecode(msg.rig_id)) wsprStatus.textContent = "Receiving";
+  if (wsprStatus) wsprStatus.textContent = "Receiving";
  const next = normalizeServerWsprMessage(msg);
-  plotWsprLocator(msg);
+  if (next.grids.length > 0 && wsprWindow.mapAddLocator) {
    wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
      ...msg,
      ...next.rfHz === null ? {} : { freq_hz: next.rfHz }
    });
  }
  addWsprMessage(next.history);
 }
 wsprWindow.trxPluginRuntime.registerDecoder({
@@ -272,10 +267,5 @@ wsprWindow.trxPluginRuntime.registerDecoder({
  onBatch: onServerWsprBatch,
  restore: onServerWsprBatch,
  prune: pruneWsprHistoryView,
-  reset: resetWsprHistoryView,
+  reset: resetWsprHistoryView
  rerender: renderWsprHistory,
  // Oldest first, so the map builds the grids up in the order they were heard.
  syncMap: () => {
    for (const message of [...wsprMessageHistory].reverse()) plotWsprLocator(message);
  }
 });
@@ -12,13 +12,9 @@ use trx_core::rig::{
    RigAccessMethod, RigCapabilities, RigInfo, RigRxStatus, RigStatus, RigTxStatus, RigVfo,
    RigVfoEntry,
 };
-use trx_core::{
+use trx_core::{DecoderConfig, RdsData, RigFilterState, RigMode, RigSnapshot, WfmDenoiseLevel};
    DecoderConfig, DigSidebandPolicy, NoiseBlankerProfile, RdsData, RigFilterState, RigMode,
    RigSnapshot, WfmDenoiseLevel,
 };
 use trx_frontend_http::server::api::rig::{RigListItem, RigListResponse};
 use trx_frontend_http::server::api::FrontendMeta;
 use trx_frontend_http::server::auth::AuthRole;
 use trx_protocol::{DecoderActivation, DecoderDescriptor};
 use ts_rs::{Config, TS};
@@ -52,8 +48,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    export!(RigStatus);
    export!(DecoderConfig);
    export!(WfmDenoiseLevel);
    export!(DigSidebandPolicy);
    export!(NoiseBlankerProfile);
    export!(RigFilterState);
    export!(RdsData);
    export!(SpectrumData);
@@ -62,7 +56,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    export!(RigListItem);
    export!(RigListResponse);
    export!(FrontendMeta);
    export!(AuthRole);
    export!(DecoderActivation);
    export!(DecoderDescriptor);
@@ -23,17 +23,14 @@ await build({
    ft8: path.join(sourceDir, "plugins", "ft8.ts"),
    vdes: path.join(sourceDir, "plugins", "vdes.ts"),
    wefax: path.join(sourceDir, "plugins", "wefax.ts"),
    sstv: path.join(sourceDir, "plugins", "sstv.ts"),
    "background-decode": path.join(sourceDir, "plugins", "background-decode.ts"),
    ais: path.join(sourceDir, "plugins", "ais.ts"),
    aprs: path.join(sourceDir, "plugins", "aprs.ts"),
    "hf-aprs": path.join(sourceDir, "plugins", "hf-aprs.ts"),
    sat: path.join(sourceDir, "plugins", "sat.ts"),
    "sat-scheduler": path.join(sourceDir, "plugins", "sat-scheduler.ts"),
    "satellite-predictions": path.join(sourceDir, "plugins", "satellite-predictions.ts"),
    vchan: path.join(sourceDir, "plugins", "vchan.ts"),
    bookmarks: path.join(sourceDir, "plugins", "bookmarks.ts"),
    logbook: path.join(sourceDir, "plugins", "logbook.ts"),
    scheduler: path.join(sourceDir, "plugins", "scheduler.ts"),
    "map-core": path.join(sourceDir, "map-core.ts"),
    screenshot: path.join(sourceDir, "screenshot.ts"),
@@ -12,7 +12,7 @@
    "typecheck": "tsc --project tsconfig.json && tsc --project tsconfig.worker.json",
    "lint": "eslint \"src/**/*.ts\" \"tests/**/*.mjs\" build.mjs --no-error-on-unmatched-pattern",
    "test": "node --test tests/*.test.mjs",
-    "test:browser": "node tests/browser-smoke.mjs && node tests/spectrum-layout.mjs && node tests/decode-flow.mjs && node tests/tune-links.mjs && node tests/mobile-layout.mjs && node tests/satellite-predictions.mjs && node tests/background-decode.mjs && node tests/logbook.mjs && node tests/account-management.mjs && node tests/transmit-role.mjs",
+    "test:browser": "node tests/browser-smoke.mjs",
    "verify-generated": "npm run generate-types && npm run build && git diff --exit-code -- ../assets/web/generated src/api/generated.ts"
  },
  "devDependencies": {
@@ -2,51 +2,11 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
-import type { AuthRole } from "./generated.js";
+export type AuthRole = "rx" | "control";
 export type { AuthRole };
 export const AUTH_ROLES: readonly AuthRole[] = ["guest", "read", "control", "transmit", "write", "administrator"];
 export const AUTH_ADMIN_ROLES: readonly AuthRole[] = AUTH_ROLES.filter(role => role !== "guest");
 export const AUTH_ROLE_LABELS: Readonly<Record<AuthRole, string>> = {
  guest: "Guest",
  read: "Read",
  control: "Control",
  transmit: "Transmit",
  write: "Write",
  administrator: "Administrator",
 };
 export function isAuthRole(value: unknown): value is AuthRole {
  return typeof value === "string" && (AUTH_ROLES as readonly string[]).includes(value);
 }
 export function normalizeAuthRoles(roles: readonly AuthRole[]): AuthRole[] {
  return AUTH_ROLES.filter(role => roles.includes(role));
 }
 export function hasAuthRole(roles: readonly AuthRole[], required: AuthRole): boolean {
  return roles.includes("administrator")
    || roles.includes(required)
    || required === "read" && roles.includes("guest")
    || required === "read" && (roles.includes("control") || roles.includes("transmit"));
 }
 export function hasAccountControls(roles: readonly AuthRole[]): boolean {
  return roles.length > 0 && !roles.includes("guest");
 }
 function decodeRoles(value: unknown, context: string): AuthRole[] {
  if (!Array.isArray(value) || !value.every(isAuthRole)) {
    throw new TypeError(`${context} has invalid roles`);
  }
  return normalizeAuthRoles(value);
 }
 export interface AuthSession {
  authenticated: boolean;
-  roles: AuthRole[];
+  role?: AuthRole;
  username?: string;
  auth_disabled?: boolean;
 }
@@ -58,24 +18,21 @@ function decodeAuthSession(value: unknown): AuthSession {
  if (typeof session.authenticated !== "boolean") {
    throw new TypeError("The authentication response has no authenticated flag");
  }
  if (session.role !== undefined && session.role !== "rx" && session.role !== "control") {
    throw new TypeError("The authentication response has an invalid role");
  }
  if (session.auth_disabled !== undefined && typeof session.auth_disabled !== "boolean") {
    throw new TypeError("The authentication response has an invalid auth_disabled flag");
  }
-  const decoded: AuthSession = {
+  const decoded: AuthSession = { authenticated: session.authenticated };
-    authenticated: session.authenticated,
+  if (session.role !== undefined) decoded.role = session.role;
    roles: decodeRoles(session.roles, "The authentication response"),
  };
  if (session.username !== undefined) {
    if (typeof session.username !== "string") throw new TypeError("The authentication response has an invalid username");
    decoded.username = session.username;
  }
  if (session.auth_disabled !== undefined) decoded.auth_disabled = session.auth_disabled;
  return decoded;
 }
 const authDisabledSession: AuthSession = {
  authenticated: true,
-  roles: [...AUTH_ADMIN_ROLES],
+  role: "control",
  auth_disabled: true,
 };
@@ -83,19 +40,19 @@ export async function fetchAuthSession(): Promise<AuthSession> {
  try {
    const response = await fetch("/auth/session");
    if (response.status === 404) return authDisabledSession;
-    if (!response.ok) return { authenticated: false, roles: [] };
+    if (!response.ok) return { authenticated: false };
    return decodeAuthSession(await response.json());
  } catch (error: unknown) {
    console.error("Auth check failed:", error);
-    return { authenticated: false, roles: [] };
+    return { authenticated: false };
  }
 }
-export async function login(username: string, password: string): Promise<AuthSession> {
+export async function login(passphrase: string): Promise<AuthSession> {
  const response = await fetch("/auth/login", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ username, password }),
+    body: JSON.stringify({ passphrase }),
  });
  if (response.status === 404) return authDisabledSession;
  if (!response.ok) {
@@ -105,52 +62,6 @@ export async function login(username: string, password: string): Promise<AuthSes
  return decodeAuthSession(await response.json());
 }
 export interface ManagedUser { username: string; roles: AuthRole[]; enabled: boolean }
 async function userRequest(path: string, init?: RequestInit): Promise<Response> {
  const response = await fetch(path, init);
  if (!response.ok) {
    const payload = await response.json().catch(() => ({})) as { error?: string };
    throw new Error(payload.error || `User operation failed (${response.status})`);
  }
  return response;
 }
 export async function listUsers(): Promise<ManagedUser[]> {
  const value: unknown = await userRequest("/auth/users").then(response => response.json());
  if (!Array.isArray(value) || !value.every((user: unknown) => {
    if (typeof user !== "object" || user === null) return false;
    const record = user as Record<string, unknown>;
    return typeof record.username === "string"
      && typeof record.enabled === "boolean"
      && Array.isArray(record.roles)
      && record.roles.every(isAuthRole);
  })) {
    throw new TypeError("The user list response is malformed");
  }
  return (value as ManagedUser[]).map(user => ({ ...user, roles: normalizeAuthRoles(user.roles) }));
 }
 export async function createUser(username: string, password: string, roles: AuthRole[], enabled = true): Promise<void> {
  await userRequest("/auth/users", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ username, password, roles, enabled }) });
 }
 export async function updateUser(username: string, changes: { password?: string; roles?: AuthRole[]; enabled?: boolean }): Promise<void> {
  await userRequest(`/auth/users/${encodeURIComponent(username)}`, { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify(changes) });
 }
 export async function changeOwnPassword(currentPassword: string, newPassword: string): Promise<void> {
  await userRequest("/auth/account/password", {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ current_password: currentPassword, new_password: newPassword }),
  });
 }
 export async function deleteUser(username: string): Promise<void> {
  await userRequest(`/auth/users/${encodeURIComponent(username)}`, { method: "DELETE" });
 }
 export async function logout(): Promise<void> {
  const response = await fetch("/auth/logout", { method: "POST" });
  if (response.status !== 404 && !response.ok) throw new Error("Logout failed");
@@ -51,25 +51,11 @@ export type RigRxStatus = { sig: number | null, };
 export type RigStatus = { freq: Freq, mode: RigMode, tx_en: boolean, vfo: RigVfo | null, tx: RigTxStatus | null, rx: RigRxStatus | null, lock: boolean | null, };
-export type DecoderConfig = { aprs_decode_enabled: boolean, hf_aprs_decode_enabled: boolean, cw_decode_enabled: boolean, ft8_decode_enabled: boolean, ft4_decode_enabled: boolean, ft2_decode_enabled: boolean, wspr_decode_enabled: boolean, lrpt_decode_enabled: boolean, wefax_decode_enabled: boolean, sstv_decode_enabled: boolean, recorder_enabled: boolean, };
+export type DecoderConfig = { aprs_decode_enabled: boolean, hf_aprs_decode_enabled: boolean, cw_decode_enabled: boolean, ft8_decode_enabled: boolean, ft4_decode_enabled: boolean, ft2_decode_enabled: boolean, wspr_decode_enabled: boolean, lrpt_decode_enabled: boolean, wefax_decode_enabled: boolean, recorder_enabled: boolean, };
 export type WfmDenoiseLevel = "off" | "auto" | "low" | "medium" | "high";
-export type DigSidebandPolicy = "auto" | "usb" | "lsb";
+export type RigFilterState = { bandwidth_hz: number, cw_center_hz: number, sdr_gain_db?: number | null, sdr_lna_gain_db?: number | null, sdr_agc_enabled?: boolean | null, sdr_squelch_enabled?: boolean | null, sdr_squelch_threshold_db?: number | null, sdr_nb_enabled?: boolean | null, sdr_nb_threshold?: number | null, wfm_deemphasis_us: number, wfm_stereo: boolean, wfm_stereo_detected: boolean, wfm_denoise: WfmDenoiseLevel, 
 export type NoiseBlankerProfile = "spike" | "ignition" | "powerline" | "broadband";
 export type RigFilterState = { bandwidth_hz: number, cw_center_hz: number, sdr_gain_db?: number | null, sdr_lna_gain_db?: number | null, sdr_agc_enabled?: boolean | null, sdr_squelch_enabled?: boolean | null, sdr_squelch_threshold_db?: number | null, sdr_nb_enabled?: boolean | null, sdr_nb_threshold?: number | null, 
 /**
 * Current noise-blanker tuning profile (SDR backends only). Surfaces in the
 * UI as the advanced-controls "NB profile" selector.
 */
 sdr_nb_profile?: NoiseBlankerProfile | null, 
 /**
 * Current DIG sideband policy (SDR backends only). Surfaces in the UI as
 * the advanced-controls "DIG sideband" selector.
 */
 sdr_dig_sideband?: DigSidebandPolicy | null, wfm_deemphasis_us: number, wfm_stereo: boolean, wfm_stereo_detected: boolean, wfm_denoise: WfmDenoiseLevel, 
 /**
 * Co-Channel Interference level (0–100 scale).
 */
@@ -92,10 +78,6 @@ export type RdsData = { pi?: number | null, program_service?: string | null, rad
 export type SpectrumData = { 
 /**
 * FFT magnitude bins in dBFS, FFT-shifted so DC (centre frequency) is at index N/2.
 *
 * On the wire these are base64-encoded `i8` whole dBFS (see
 * `spectrum_wire`), which is what the display draws anyway; the TypeScript
 * type describes the decoded array the browser receives over SSE.
 */
 bins: Array<number>, 
 /**
@@ -129,7 +111,7 @@ export type RigSnapshot = { info: RigInfo, status: RigStatus, band: string | nul
 /**
 * Per-virtual-channel RDS snapshots, when available.
 */
-vchan_rds?: Array<VchanRdsEntry> | null, aprs_decode_enabled: boolean, hf_aprs_decode_enabled: boolean, cw_decode_enabled: boolean, ft8_decode_enabled: boolean, ft4_decode_enabled: boolean, ft2_decode_enabled: boolean, wspr_decode_enabled: boolean, lrpt_decode_enabled: boolean, wefax_decode_enabled: boolean, sstv_decode_enabled: boolean, recorder_enabled: boolean, };
+vchan_rds?: Array<VchanRdsEntry> | null, aprs_decode_enabled: boolean, hf_aprs_decode_enabled: boolean, cw_decode_enabled: boolean, ft8_decode_enabled: boolean, ft4_decode_enabled: boolean, ft2_decode_enabled: boolean, wspr_decode_enabled: boolean, lrpt_decode_enabled: boolean, wefax_decode_enabled: boolean, recorder_enabled: boolean, };
 export type RigListItem = { remote: string, display_name: string | null, manufacturer: string, model: string, supported_modes: Array<RigMode>, tx: boolean, filter_controls: boolean, initialized: boolean, latitude: number | null, longitude: number | null, };
@@ -137,8 +119,6 @@ export type RigListResponse = { active_remote: string | null, rigs: Array<RigLis
 export type FrontendMeta = { clients: number, rigctl_clients: number, audio_clients: number, rigctl_addr: string | null, active_remote: string | null, remotes: Array<string>, owner_callsign: string | null, owner_website_url: string | null, owner_website_name: string | null, ais_vessel_url_base: string | null, show_sdr_gain_control: boolean, initial_map_zoom: number, spectrum_coverage_margin_hz: number, spectrum_usable_span_ratio: number, bandplan_enabled: boolean, bandplan_region: string, decode_history_retention_min: bigint, server_connected: boolean, };
 export type AuthRole = "guest" | "read" | "control" | "transmit" | "write" | "administrator";
 export type DecoderActivation = "mode_bound" | "toggle";
 export type DecoderDescriptor = { 
@@ -5,7 +5,7 @@
 export {};
 const textDecoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
-const HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax", "sstv"] as const;
+const HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax"] as const;
 type HistoryGroup = (typeof HISTORY_GROUP_KEYS)[number];
 type CborValue = number | string | boolean | null | undefined | CborValue[] | { [key: string]: CborValue };
 interface DecodeState { offset: number }
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 export const TAB_ORDER = [
-  "main", "bookmarks", "logbook", "digital-modes", "map", "satellites", "statistics", "recorder", "settings", "about",
+  "main", "bookmarks", "digital-modes", "map", "statistics", "recorder", "settings", "about",
 ] as const;
 export type TabName = typeof TAB_ORDER[number];
@@ -11,10 +11,8 @@ export type TabName = typeof TAB_ORDER[number];
 export const TAB_PATHS: Readonly<Record<TabName, string>> = {
  main: "/",
  bookmarks: "/bookmarks",
  logbook: "/logbook",
  "digital-modes": "/digital-modes",
  map: "/map",
  satellites: "/satellites",
  statistics: "/statistics",
  recorder: "/recorder",
  settings: "/settings",
@@ -39,66 +37,3 @@ export function updateTabHistory(name: TabName, replace = false): void {
  if (replace) window.history.replaceState({}, "", nextUrl);
  else window.history.pushState({}, "", nextUrl);
 }
 /** What a shared link says to listen to: `?rig=sdr&f=14074000&mode=USB&bw=3000`. */
 export interface TuneLink {
  rig: string | null;
  freqHz: number | null;
  mode: string | null;
  bandwidthHz: number | null;
 }
 const FREQ_MULTIPLIER: Readonly<Record<string, number>> = { k: 1e3, m: 1e6, g: 1e9 };
 /**
 * Read a frequency written for a person: bare Hz as the canonical form, but
 * `7074k` and `14.074M` are what someone typing a link by hand reaches for.
 * Returns Hz, or null for anything that is not a positive frequency.
 */
 export function parseFrequencyParam(raw: string | null | undefined): number | null {
  if (typeof raw !== "string") return null;
  const text = raw.trim().toLowerCase().replace(/hz$/, "").trim();
  const match = /^(\d+(?:\.\d+)?)\s*([kmg]?)$/.exec(text);
  if (!match) return null;
  const value = Number(match[1]) * (FREQ_MULTIPLIER[match[2] ?? ""] ?? 1);
  if (!Number.isFinite(value) || value <= 0) return null;
  return Math.round(value);
 }
 /** Mode names run from FM to VDES; anything else in the URL is not one. */
 function parseModeParam(raw: string | null | undefined): string | null {
  const mode = typeof raw === "string" ? raw.trim().toUpperCase() : "";
  return /^[A-Z]{2,4}$/.test(mode) ? mode : null;
 }
 export function parseTuneLink(search: string): TuneLink {
  const params = new URLSearchParams(search);
  const rig = (params.get("rig") || "").trim();
  return {
    rig: rig || null,
    freqHz: parseFrequencyParam(params.get("f")),
    mode: parseModeParam(params.get("mode")),
    bandwidthHz: parseFrequencyParam(params.get("bw")),
  };
 }
 /**
 * Rewrite the tune parameters of a query string, leaving anything else in it
 * alone — the address bar is the share link, so it has to keep up with the
 * dial without discarding whatever else a page put there.
 */
 export function tuneLinkSearch(search: string, link: TuneLink): string {
  const params = new URLSearchParams(search);
  const set = (key: string, value: string | null) => {
    if (value == null || value === "") params.delete(key);
    else params.set(key, value);
  };
  const hz = (value: number | null) =>
    (typeof value === "number" && Number.isFinite(value) && value > 0 ? String(Math.round(value)) : null);
  set("rig", link.rig);
  set("f", hz(link.freqHz));
  set("mode", parseModeParam(link.mode));
  set("bw", hz(link.bandwidthHz));
  const text = params.toString();
  return text ? `?${text}` : "";
 }
@@ -4,7 +4,6 @@
 import type * as Leaflet from "leaflet";
 import { aprsSymbolSprite } from "./plugins/aprs-shared";
 import type { PluginRuntimeWindow } from "./plugins/runtime-contract";
 export {};
@@ -31,7 +30,7 @@ function mapEl(id: string): MapElement {
  return element as MapElement;
 }
-type DecoderSource = "ais" | "vdes" | "aprs" | "hf_aprs" | "bookmark" | "ft8" | "ft4" | "ft2" | "wspr" | "sat";
+type DecoderSource = "ais" | "vdes" | "aprs" | "bookmark" | "ft8" | "ft4" | "ft2" | "wspr" | "sat";
 interface TrackPoint { lat: number; lon: number; tsMs: number }
 interface DecodeDetail {
  station?: string | null; source?: string | null; target?: string | null;
@@ -83,9 +82,6 @@ interface MapEntry {
  bookmarks?: Array<Record<string, unknown>>;
  bounds?: Leaflet.LatLngBoundsExpression;
  symbolTable?: string; symbolCode?: string; bandLabel?: string | null;
  /** Callsign as heard.  The map key qualifies it with the source, so that a
   *  station worked on both 144 MHz and 30 m keeps one marker per band. */
  call?: string;
  overlay?: TrxLayer | null; line?: TrxLayer | null; labelMarker?: TrxLayer | null;
  pathKey?: string; sourceGrid?: string; targetGrid?: string;
  from?: LatLon; to?: LatLon;
@@ -174,7 +170,7 @@ interface MapWindow {
  clearMapMarkersByType?(type: DecoderSource): void;
  navigateToAprsMap?(lat: number, lon: number): void;
  navigateToMapLocator?(grid: string, preferredType?: string | null): void;
-  aprsMapAddStation?(call: string, lat: number, lon: number, info: string, symbolTable: string, symbolCode: string, packet: MapMessage, source?: "aprs" | "hf_aprs"): void;
+  aprsMapAddStation?(call: string, lat: number, lon: number, info: string, symbolTable: string, symbolCode: string, packet: MapMessage): void;
  aisMapAddVessel?(message: MapMessage): void;
  vdesMapAddPoint?(message: MapMessage): void;
  syncBookmarkMapLocators?(bookmarks: Array<Record<string, unknown>>): void;
@@ -231,10 +227,8 @@ const mapWindow = window as unknown as MapWindow;
  const decodeContactPaths = new Map<string, MapEntry>();
  let selectedMapQsoKey: string | null = null;
  const mapMarkers = new Set<TrxLayer>();
-  const DEFAULT_MAP_SOURCE_FILTER: Record<MapFilterKey, boolean> = { ais: true, vdes: true, aprs: true, hf_aprs: true, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
+  const DEFAULT_MAP_SOURCE_FILTER: Record<MapFilterKey, boolean> = { ais: true, vdes: true, aprs: true, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
  const mapFilter: Record<MapFilterKey, boolean> = { ...DEFAULT_MAP_SOURCE_FILTER };
  /** Chip key that clears a selection rather than naming a band or a source. */
  const MAP_FILTER_ALL_KEY = "__all";
  const mapLocatorFilter: { phase: "band" | "type"; bands: Set<string> } = { phase: "band", bands: new Set() };
  let mapSearchFilter = "";
  let mapRigFilter = ""; // "" = all rigs
@@ -305,18 +299,6 @@ const mapWindow = window as unknown as MapWindow;
    return trimmed;
  }
  /** The source a station marker belongs to, defaulting to VHF APRS for
   *  entries stored before HF APRS had a source of its own. */
  function aprsEntrySource(entry: MapEntry | null | undefined): DecoderSource {
    return entry?.type === "hf_aprs" ? "hf_aprs" : "aprs";
  }
  /** Map key for a station: the callsign alone on VHF, source-qualified on HF,
   *  so one station heard on both bands keeps a marker for each. */
  function aprsStationKey(call: string, source: DecoderSource): string {
    return source === "aprs" ? call : `${source}:${call}`;
  }
  function refreshAprsTrack(call: string, entry: MapEntry): void {
    if (!entry) return;
    if (!Array.isArray(entry.trackPoints) || entry.trackPoints.length < 2) {
@@ -338,7 +320,7 @@ const mapWindow = window as unknown as MapWindow;
      lineJoin: "round",
      interactive: false,
    }) as unknown as TrxLayer;
-    track.__trxType = aprsEntrySource(entry);
+    track.__trxType = "aprs";
    track._aprsCall = call;
    entry.track = track;
  }
@@ -590,7 +572,6 @@ const mapWindow = window as unknown as MapWindow;
  function mapSourceLabel(type: DecoderSource): string {
    if (type === "bookmark") return "Bookmarks";
    if (type === "hf_aprs") return "HF APRS";
    return String(type || "").toUpperCase();
  }
@@ -610,8 +591,6 @@ const mapWindow = window as unknown as MapWindow;
    if (type === "vdes") return "#a78bfa";
    if (type === "sat") return "#f59e0b";
    if (type === "aprs") return "#00d17f";
    // Far enough from the VHF green to tell the two apart at a glance.
    if (type === "hf_aprs") return "#fb7185";
    return locatorFilterColor(type);
  }
@@ -1099,42 +1078,38 @@ const mapWindow = window as unknown as MapWindow;
      container.innerHTML = `<span class="map-locator-empty">No ${kind === "band" ? "bands" : "sources"} available</span>`;
      return;
    }
-    const noun = kind === "band" ? "bands" : "sources";
+    let helperText = "";
    const sourceKeys = kind === "source" ? Object.keys(DEFAULT_MAP_SOURCE_FILTER) as MapFilterKey[] : [];
-    // Selecting nothing selects everything, for both kinds.
+    const noneSelected = kind === "source" && sourceKeys.every((k) => !mapFilter[k]);
-    const showingAll = kind === "source"
+    if (kind === "source") {
-      ? sourceKeys.every((k) => !mapFilter[k])
+      if (noneSelected) {
-      : !(selectedSet instanceof Set) || selectedSet.size === 0;
+        helperText = "All sources visible \u2014 click to filter";
-    // An "All" chip carries what a sentence of helper text used to say, in a
+      }
-    // width the bar can afford, and gives the selection somewhere to be undone.
+    } else if (!(selectedSet instanceof Set) || selectedSet.size === 0) {
-    const allChip = document.createElement("button");
+      helperText = `All ${kind === "band" ? "bands" : "sources"} visible by default`;
-    allChip.type = "button";
+    }
    allChip.className = "map-locator-chip map-locator-chip-all";
    if (showingAll) allChip.classList.add("is-active");
    allChip.dataset.filterKind = kind;
    allChip.dataset.filterKey = MAP_FILTER_ALL_KEY;
    allChip.setAttribute("aria-pressed", showingAll ? "true" : "false");
    allChip.title = showingAll ? `All ${noun} shown` : `Show all ${noun}`;
    allChip.innerHTML = `<span class="map-locator-chip-text">All</span>`;
    container.appendChild(allChip);
    for (const item of items) {
      const btn = document.createElement("button");
      btn.type = "button";
      btn.className = "map-locator-chip";
      const isActive = kind === "source" ? !!mapFilter[item.key as MapFilterKey] : !!selectedSet?.has(item.key);
-      // Nothing is filtered out yet, so no chip is dimmed as if it were.
+      if (kind === "source" && noneSelected) {
      if (showingAll) {
        btn.classList.add("is-default");
      } else if (!isActive) {
        btn.classList.add("is-inactive");
      }
      btn.setAttribute("aria-pressed", !showingAll && isActive ? "true" : "false");
      btn.dataset.filterKind = kind;
      btn.dataset.filterKey = item.key;
      btn.style.setProperty("--chip-color", item.color);
      btn.innerHTML = `<span class="map-locator-chip-text">${escapeMapHtml(item.label)}</span>`;
      container.appendChild(btn);
    }
    if (helperText) {
      const hint = document.createElement("span");
      hint.className = "map-locator-empty";
      hint.textContent = helperText;
      container.appendChild(hint);
    }
  }
  function renderMapLocatorPhaseRow(container: HTMLElement, phase: "band" | "type"): void {
@@ -1206,8 +1181,10 @@ const mapWindow = window as unknown as MapWindow;
      }
    }
    for (const entry of stationMarkers.values()) {
-      if (!entry?.visibleInHistoryWindow) continue;
+      if (entry?.type === "aprs" && entry?.visibleInHistoryWindow) {
-      availableSources.add(aprsEntrySource(entry));
+        availableSources.add("aprs");
        break;
      }
    }
    const bandMap = new Map<string, FilterChip>();
    for (const entry of locatorMarkers.values()) {
@@ -1241,7 +1218,7 @@ const mapWindow = window as unknown as MapWindow;
      if (!bandMap.has(key)) mapLocatorFilter.bands.delete(key);
    }
-    const sourceItems: FilterChip[] = (["ais", "vdes", "aprs", "hf_aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"] as DecoderSource[])
+    const sourceItems: FilterChip[] = (["ais", "vdes", "aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"] as DecoderSource[])
      .filter((key) => availableSources.has(key))
      .map((key) => ({
        key,
@@ -1256,12 +1233,11 @@ const mapWindow = window as unknown as MapWindow;
    if (!phaseEl || !choiceEl || !choiceLabelEl) return;
    renderMapLocatorPhaseRow(phaseEl, mapLocatorFilter.phase);
    // The phase buttons next door already name the dimension; "Show" is the
    // rest of the sentence, and it keeps the bar's labels a uniform width.
    choiceLabelEl.textContent = "Show";
    if (mapLocatorFilter.phase === "band") {
      choiceLabelEl.textContent = "Visible Bands";
      renderMapLocatorChipRow(choiceEl, bandItems, mapLocatorFilter.bands, "band");
    } else {
      choiceLabelEl.textContent = "Visible Sources";
      renderMapLocatorChipRow(choiceEl, sourceItems, null, "source");
    }
    syncLocatorMarkerStyles();
@@ -1312,10 +1288,9 @@ const mapWindow = window as unknown as MapWindow;
      }
      return parts.join(" ").toLowerCase();
    }
-    if (type === "aprs" || type === "hf_aprs") {
+    if (type === "aprs") {
-      const key = marker?._aprsCall ? String(marker._aprsCall) : "";
+      const call = marker?._aprsCall ? String(marker._aprsCall) : "";
-      const entry = stationMarkers.get(key);
+      const entry = stationMarkers.get(call);
      const call = entry?.call ?? key;
      const info = entry?.info ? String(entry.info) : "";
      const pktRaw = entry?.pkt?.raw ? String(entry.pkt.raw) : "";
      return `${call} ${info} ${pktRaw}`.toLowerCase();
@@ -1513,10 +1488,9 @@ const mapWindow = window as unknown as MapWindow;
  };
  mapWindow.clearMapMarkersByType = function(type) {
-    if (type === "aprs" || type === "hf_aprs") {
+    if (type === "aprs") {
      selectedAprsTrackCall = null;
-      stationMarkers.forEach((entry, key) => {
+      stationMarkers.forEach((entry) => {
        if (aprsEntrySource(entry) !== type) return;
        if (entry && entry.marker) {
          if (aprsMap && aprsMap.hasLayer(entry.marker)) entry.marker.removeFrom(aprsMap);
          mapMarkers.delete(entry.marker);
@@ -1525,8 +1499,8 @@ const mapWindow = window as unknown as MapWindow;
          if (aprsMap && aprsMap.hasLayer(entry.track)) entry.track.removeFrom(aprsMap);
          mapMarkers.delete(entry.track);
        }
        stationMarkers.delete(key);
      });
      stationMarkers.clear();
      return;
    }
@@ -1662,10 +1636,7 @@ const mapWindow = window as unknown as MapWindow;
  function applyMapOverlayPanelVisibility() {
    const panel = document.querySelector("#map-stage .map-overlay-panel");
    if (!panel) return;
-    // Only the filters collapse. The bar itself stays, because it carries the
+    panel.classList.toggle("is-hidden", !mapOverlayPanelVisible);
    // button that brings them back.
    panel.classList.toggle("filters-hidden", !mapOverlayPanelVisible);
    panel.querySelector(".map-overlay-filters")?.classList.toggle("is-hidden", !mapOverlayPanelVisible);
  }
  function updateMapOverlayToggleButton() {
@@ -1799,15 +1770,13 @@ const mapWindow = window as unknown as MapWindow;
        if (!ll) return;
        const entry = stationMarkers.get(marker._aprsCall);
        if (!entry) return;
-        const source = aprsEntrySource(entry);
+        e.popup.setContent(buildAprsPopupHtml(marker._aprsCall, ll.lat, ll.lng, entry.info || "", entry.pkt));
        const call = entry.call ?? String(marker._aprsCall);
        e.popup.setContent(buildAprsPopupHtml(call, ll.lat, ll.lng, entry.info || "", entry.pkt));
        refreshAprsTrack(String(marker._aprsCall), entry);
-        if (entry.track && aprsMap && mapFilter[source] && !aprsMap.hasLayer(entry.track)) {
+        if (entry.track && aprsMap && mapFilter.aprs && !aprsMap.hasLayer(entry.track)) {
          entry.track.addTo(aprsMap);
        }
        selectedAprsTrackCall = String(marker._aprsCall);
-        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor(source), "aprs-radio-path", marker.__trxRigIds);
+        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor("aprs"), "aprs-radio-path", marker.__trxRigIds);
        return;
      }
@@ -1890,14 +1859,7 @@ const mapWindow = window as unknown as MapWindow;
        const kind = String(chip.dataset.filterKind || "");
        const key = String(chip.dataset.filterKey || "");
        if (!key) return;
-        if (key === MAP_FILTER_ALL_KEY) {
+        if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
          // Back to no selection at all, which is what shows everything.
          if (kind === "source") {
            for (const srcKey of Object.keys(DEFAULT_MAP_SOURCE_FILTER) as MapFilterKey[]) mapFilter[srcKey] = false;
          } else {
            mapLocatorFilter.bands.clear();
          }
        } else if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
          // toggle the clicked source; when none are selected everything is shown
          const sourceKey = key as MapFilterKey;
          mapFilter[sourceKey] = !mapFilter[sourceKey];
@@ -2018,21 +1980,23 @@ const mapWindow = window as unknown as MapWindow;
      if (aprsMap) aprsMap.invalidateSize();
      return;
    }
    // Everything below is the windowed path — the fullscreen branch returned.
    // The map tab is a whole page, so the stage fills the column down to the
    // footer.  Capping it at a fraction of the viewport, or at a width-derived
    // aspect ratio, left a dead band under the map that grew with the window
    // (and on narrow screens made the map barely a third of the page).
    const mapRect = mapContainer.getBoundingClientRect();
    const width = mapContainer.clientWidth || mapRect.width;
    const footer = document.querySelector(".footer");
-    let bottom = window.innerHeight;
+    let bottom = mapIsFullscreen() && stage
-    if (footer) {
+      ? stage.getBoundingClientRect().bottom
      : window.innerHeight;
    if (!mapIsFullscreen() && footer) {
      const fr = footer.getBoundingClientRect();
-      // Clamped to the viewport: once the column is tall enough to push the
+      if (fr.top > mapRect.top + 50) bottom = fr.top;
      // footer below the fold, growing into it would push it further still.
      if (fr.top > mapRect.top + 50) bottom = Math.min(fr.top, bottom);
    }
-    const target = Math.max(0, Math.floor(bottom - mapRect.top - 8));
+    const available = Math.max(0, Math.floor(bottom - mapRect.top - 8));
    const widthDriven = width > 0 ? Math.floor(width / 1.55) : available;
    const viewportCap = mapIsFullscreen()
      ? Math.floor(window.innerHeight * 0.9)
      : Math.floor(window.innerHeight * 0.75);
    const minHeight = Math.min(260, available);
    const target = Math.max(minHeight, Math.min(available, viewportCap, widthDriven));
    mapContainer.style.height = `${target}px`;
    if (aprsMap) aprsMap.invalidateSize();
  }
@@ -2054,7 +2018,15 @@ const mapWindow = window as unknown as MapWindow;
    });
  }
-  function focusMapPosition(lat: number, lon: number) {
+  mapWindow.navigateToAprsMap = function(lat, lon) {
    // Activate the map tab
    T._activeTab = "map";
    document.querySelectorAll(".tab-bar .tab").forEach((t) => { t.classList.remove("active"); });
    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
    if (mapTabBtn) mapTabBtn.classList.add("active");
    document.querySelectorAll<HTMLElement>(".tab-panel").forEach((p) => (p.style.display = "none"));
    const mapPanel = mapEl("tab-map");
    if (mapPanel) mapPanel.style.display = "";
    initAprsMap();
    sizeAprsMapToViewport();
    if (aprsMap) {
@@ -2066,12 +2038,20 @@ const mapWindow = window as unknown as MapWindow;
        });
      });
    }
-  }
+  };
-  function focusMapLocator(grid: string, preferredType: string | null = null) {
+  mapWindow.navigateToMapLocator = function(grid, preferredType = null) {
    const normalizedGrid = String(grid || "").trim().toUpperCase();
    if (!/^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalizedGrid)) return false;
    T._activeTab = "map";
    document.querySelectorAll(".tab-bar .tab").forEach((t) => { t.classList.remove("active"); });
    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
    if (mapTabBtn) mapTabBtn.classList.add("active");
    document.querySelectorAll<HTMLElement>(".tab-panel").forEach((p) => (p.style.display = "none"));
    const mapPanel = mapEl("tab-map");
    if (mapPanel) mapPanel.style.display = "";
    initAprsMap();
    sizeAprsMapToViewport();
    if (!aprsMap) return false;
@@ -2121,7 +2101,7 @@ const mapWindow = window as unknown as MapWindow;
      requestAnimationFrame(focusMarker);
    });
    return true;
-  }
+  };
@@ -2290,33 +2270,28 @@ const mapWindow = window as unknown as MapWindow;
    return null;
  }
-  function _aprsAddMarkerToMap(key: string, entry: MapEntry): void {
+  function _aprsAddMarkerToMap(call: string, entry: MapEntry): void {
    if (!aprsMap || entry.lat == null || entry.lon == null) return;
-    refreshAprsTrack(key, entry);
+    refreshAprsTrack(call, entry);
    const source = aprsEntrySource(entry);
    const call = entry.call ?? key;
    const icon = aprsSymbolIcon(entry.symbolTable ?? "", entry.symbolCode ?? "");
    const popupContent = buildAprsPopupHtml(call, entry.lat, entry.lon, entry.info || "", entry.pkt);
    const color = mapSourceColor(source);
    const marker = (icon
      ? L.marker([entry.lat, entry.lon], { icon }).addTo(aprsMap).bindPopup(popupContent)
      : L.circleMarker([entry.lat, entry.lon], {
-          radius: 6, color, fillColor: color, fillOpacity: 0.8
+          radius: 6, color: "#00d17f", fillColor: "#00d17f", fillOpacity: 0.8
        }).addTo(aprsMap).bindPopup(popupContent)) as unknown as TrxLayer;
-    marker.__trxType = source;
+    marker.__trxType = "aprs";
    marker.__trxRigIds = entry.rigIds || new Set();
-    marker._aprsCall = key;
+    marker._aprsCall = call;
    entry.marker = marker;
    mapMarkers.add(marker);
  }
-  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt, source) {
+  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt) {
    const nextPoint: Leaflet.LatLngTuple = [lat, lon];
    const tsMs = Number.isFinite(pkt?._tsMs) ? Number(pkt._tsMs) : Date.now();
    const msgRigId = pkt?.rig_id || T.lastActiveRigId;
-    const stationSource: DecoderSource = source === "hf_aprs" ? "hf_aprs" : "aprs";
+    const existing = stationMarkers.get(call);
    const key = aprsStationKey(call, stationSource);
    const existing = stationMarkers.get(key);
    if (existing) {
      existing.pkt = pkt;
      existing.lat = lat;
@@ -2335,8 +2310,7 @@ const mapWindow = window as unknown as MapWindow;
      } else if (prevPoint) {
        prevPoint.tsMs = tsMs;
      }
-      existing.call = call;
+      pruneAprsEntry(call, existing, mapHistoryCutoffMs());
      pruneAprsEntry(key, existing, mapHistoryCutoffMs());
      if (aprsMap && existing.marker && !T.decodeHistoryReplayActive) {
        existing.marker.setLatLng([lat, lon]);
        existing.marker.setPopupContent(buildAprsPopupHtml(call, lat, lon, info, pkt));
@@ -2347,8 +2321,7 @@ const mapWindow = window as unknown as MapWindow;
        track: null,
        trackHistory: [{ lat, lon, tsMs }],
        trackPoints: [nextPoint],
-        type: stationSource,
+        type: "aprs",
        call,
        pkt,
        lat,
        lon,
@@ -2357,9 +2330,9 @@ const mapWindow = window as unknown as MapWindow;
        symbolCode,
        rigIds: new Set(msgRigId ? [msgRigId] : []),
      };
-      stationMarkers.set(key, entry);
+      stationMarkers.set(call, entry);
-      pruneAprsEntry(key, entry, mapHistoryCutoffMs());
+      pruneAprsEntry(call, entry, mapHistoryCutoffMs());
-      if (entry.visibleInHistoryWindow) ensureAprsMarker(key, entry);
+      if (entry.visibleInHistoryWindow) ensureAprsMarker(call, entry);
      if (aprsMap) scheduleDecodeMapMaintenance();
    }
  };
@@ -2625,26 +2598,18 @@ const mapWindow = window as unknown as MapWindow;
    syncDecodeContactPathVisibility();
  }
  // The buttons light up when they are on, so the label need not repeat it —
  // an "On"/"Off" suffix on each cost the bar most of a row.
  function updateMapContactPathsToggle() {
    const btn = mapEl("map-contact-paths-toggle");
    if (!btn) return;
    btn.textContent = mapDecodeContactPathsEnabled ? "Contact Paths On" : "Contact Paths Off";
    btn.classList.toggle("is-active", mapDecodeContactPathsEnabled);
    btn.setAttribute("aria-pressed", mapDecodeContactPathsEnabled ? "true" : "false");
    btn.title = mapDecodeContactPathsEnabled
      ? "Directed decode paths are drawn when the target locator is known"
      : "Directed decode paths are hidden";
  }
  function updateMapP2pPathsToggle() {
    const btn = mapEl("map-p2p-paths-toggle");
    if (!btn) return;
    btn.textContent = mapP2pRadioPathsEnabled ? "TRX Paths On" : "TRX Paths Off";
    btn.classList.toggle("is-active", mapP2pRadioPathsEnabled);
    btn.setAttribute("aria-pressed", mapP2pRadioPathsEnabled ? "true" : "false");
    btn.title = mapP2pRadioPathsEnabled
      ? "TRX paths are drawn from a station popup"
      : "TRX paths are hidden";
  }
  function scheduleDecodeMapMaintenance() {
@@ -2847,7 +2812,7 @@ const mapWindow = window as unknown as MapWindow;
        selectedMapQsoKey = selectedMapQsoKey === entry.pathKey ? null : entry.pathKey ?? null;
        syncDecodeContactPathVisibility();
        if (selectedMapQsoKey && entry.sourceGrid) {
-          focusMapLocator(entry.sourceGrid, entry.sourceType);
+          mapWindow.navigateToMapLocator?.(entry.sourceGrid, entry.sourceType);
        }
      });
@@ -2974,7 +2939,7 @@ const mapWindow = window as unknown as MapWindow;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          focusMapLocator(entry.grid ?? "", entry.sourceType);
+          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
        });
      }
@@ -3100,7 +3065,7 @@ const mapWindow = window as unknown as MapWindow;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          focusMapLocator(entry.grid ?? "", entry.sourceType);
+          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
        });
      }
@@ -3664,8 +3629,6 @@ const mapWindow = window as unknown as MapWindow;
  // Register module API for core to call
  modules.map = {
    initAprsMap,
    focusMapPosition,
    focusMapLocator,
    sizeAprsMapToViewport,
    syncAprsReceiverMarker,
    updateMapRigFilter,
@@ -3715,18 +3678,6 @@ const mapWindow = window as unknown as MapWindow;
    reverseGeocodeLocation,
  };
  // Everything the decoders already hold goes onto the map now. This module is
  // lazy -- it arrives when the Map tab is first opened, long after startup
  // restored the decode history -- and until it does, aprsMapAddStation and
  // friends are undefined, so every restored position was dropped on the floor.
  // The map then showed only what arrived live after it loaded, which is why it
  // took a second reload (with the module cached, and so loaded early enough to
  // win the race against the history fetch) for the stations to appear.
  //
  // The add functions are keyed by callsign/MMSI/point, so replaying costs
  // nothing on a second call and cannot duplicate a marker.
  (window as unknown as PluginRuntimeWindow).trxPluginRuntime.syncMapAll();
  // If the map tab is already visible (direct /map URL), init immediately.
  autoInitIfVisible();
 })();
@@ -2,25 +2,14 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
-type PluginGroup =
+type PluginGroup = "digital-modes" | "map-data" | "map" | "statistics" | "bookmarks" | "recorder" | "settings";
  | "digital-modes" | "map-data" | "map" | "satellites" | "statistics"
  | "bookmarks" | "logbook" | "recorder" | "settings";
 const pluginGroups: Readonly<Record<PluginGroup, readonly string[]>> = {
-  // AIS, VDES and the two APRS decoders have panels on this tab, so they load
+  "digital-modes": ["/ft8.js", "/ft4.js", "/ft2.js", "/wspr.js", "/cw.js", "/background-decode.js", "/sat.js", "/wefax.js"],
  // with it. They used to come only with the map group, which left their
  // sub-tabs empty — decodes queueing in the runtime — until something opened
  // the Map tab. Their map calls are optional, so map-core stays lazy.
  "digital-modes": [
    "/ft8.js", "/ft4.js", "/ft2.js", "/wspr.js", "/cw.js", "/background-decode.js",
    "/sat.js", "/wefax.js", "/sstv.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js",
  ],
  "map-data": ["/map-core.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js"],
  map: ["/map-core.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js", "/sat.js", "/sat-scheduler.js"],
  satellites: ["/satellite-predictions.js"],
  statistics: ["/map-core.js"],
  bookmarks: ["/bookmarks.js"],
  logbook: ["/logbook.js"],
  recorder: [],
  settings: ["/vchan.js", "/scheduler.js"],
 };
@@ -48,7 +37,7 @@ async function loadPlugins(group: string): Promise<void> {
 }
 export async function loadEagerPlugins(): Promise<void> {
-  await Promise.all(["digital-modes", "bookmarks", "logbook", "settings"].map(loadPlugins));
+  await Promise.all(["digital-modes", "bookmarks", "settings"].map(loadPlugins));
 }
 export async function loadPluginsForTab(tab: string): Promise<void> {
@@ -81,8 +81,6 @@ const runtime: TrxPluginRuntime = {
    plugin.prune();
    return true;
  },
  rerenderAll() { for (const plugin of decoders.values()) plugin.rerender?.(); },
  syncMapAll() { for (const plugin of decoders.values()) plugin.syncMap?.(); },
  clearQueued() { queued.clear(); },
  hasDecoder: (id) => decoders.has(id),
 };
@@ -1,26 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 import { hostState } from "./host.js";
 // The decode stream is not rig-scoped: every rig a client is connected to sends
 // its decodes to every browser, each frame naming the rig that heard it (the
 // client stamps `rig_id` as it leaves the audio connection).  The map wants all
 // of them — it has its own filter, and plotting only one rig would empty it —
 // but the radio page and the decoder panels describe one rig at a time: the one
 // the operator selected, whose spectrum is on screen and whose audio is
 // playing.  A frame a background rig copied on another band belongs to neither
 // picture, so both filter on this.
 export function isActiveRigDecode(rigId: string | null | undefined): boolean {
  const activeRigId = hostState.lastActiveRigId;
  // Before the rig list has arrived, and for a decode that reached the browser
  // without a rig of its own, there is nothing to disagree with.
  if (!activeRigId || !rigId) return true;
  return rigId === activeRigId;
 }
 /** The decodes of `items` that the selected rig heard, in their original order. */
 export function forActiveRig<T extends { rig_id?: string | null | undefined }>(items: T[]): T[] {
  return items.filter((item) => isActiveRigDecode(item.rig_id));
 }
@@ -6,7 +6,6 @@ import { hostCore, hostState } from "./host.js";
 export {};
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract";
 interface AisMessage {
@@ -28,7 +27,6 @@ interface AisMessage {
 }
 interface AisChannelInfo { label: string; badgeClass: string; freqText: string }
 interface AisBridge {
  navigateToAprsMap?: (lat: number, lon: number) => void;
  getDecodeHistoryRetentionMs?: () => number;
  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
  buildAisVesselUrl?: (mmsi: number | null | undefined) => string | null;
@@ -191,27 +189,20 @@ function aisLatestByVessel(messages: AisMessage[]): AisMessage[] {
  return Array.from(byMmsi.values());
 }
 /** What the selected rig heard.  The history holds every rig's traffic, for
 *  the map; the panel is about the rig the operator is working. */
 function aisRigMessages(): AisMessage[] {
  return forActiveRig(aisMessageHistory);
 }
 function updateAisSummary() {
  const plan = currentAisChannelPlan();
  if (aisChannelSummaryEl) {
    aisChannelSummaryEl.textContent = `A ${formatAisMhz(plan.aHz)} · B ${formatAisMhz(plan.bHz)}`;
  }
-  const rigMessages = aisRigMessages();
+  const vessels = aisLatestByVessel(aisMessageHistory);
  const vessels = aisLatestByVessel(rigMessages);
  if (aisVesselCountEl) {
    const count = vessels.length;
    aisVesselCountEl.textContent = `${count} vessel${count === 1 ? "" : "s"}`;
  }
  if (aisLatestSeenEl) {
-    const latest = rigMessages[0];
+    const latest = aisMessageHistory[0];
    if (!latest) {
      aisLatestSeenEl.textContent = "No traffic yet";
    } else {
@@ -221,21 +212,8 @@ function updateAisSummary() {
  }
 }
 /** What the message says, in one line: where the vessel is and what it is
 *  doing, or — for the static reports that carry no fix — where it is going. */
 function aisSummaryText(msg: AisMessage): string {
  const parts: string[] = [];
  if (msg.lat != null && msg.lon != null) parts.push(`${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}`);
  const motion = aisMotionText(msg);
  if (motion) parts.push(motion);
  const route = aisRouteText(msg);
  if (route && parts.length < 2) parts.push(route);
  if (!parts.length) return route || "no position reported";
  return parts.join(" · ");
 }
 function renderAisRow(msg: AisMessage): HTMLElement {
-  const row = document.createElement("details");
+  const row = document.createElement("div");
  row.className = "ais-message";
  const ts = msg._ts || new Date().toLocaleTimeString([], {
    hour: "2-digit",
@@ -249,9 +227,8 @@ function renderAisRow(msg: AisMessage): HTMLElement {
  const route = aisRouteText(msg);
  const distance = aisDistanceText(msg);
  const pos = msg.lat != null && msg.lon != null
-    ? `<a class="ais-pos-link" href="javascript:void(0)" data-ais-map="${msg.lat},${msg.lon}">${msg.lat.toFixed(5)}, ${msg.lon.toFixed(5)}</a>`
+    ? `<a class="ais-pos-link" href="javascript:void(0)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>`
    : "";
  const vesselUrl = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
  row.dataset.filterText = [
    name,
    msg.mmsi,
@@ -266,43 +243,23 @@ function renderAisRow(msg: AisMessage): HTMLElement {
    .join(" ")
    .toUpperCase();
  row.innerHTML =
-    `<summary class="decode-line">` +
+    `<div class="ais-row-head">` +
-      `<span class="ais-time">${escapeAisHtml(ts)}</span>` +
+      `<span class="ais-time">${ts}</span>` +
      `<span class="ais-call">${nameHtml}</span>` +
      `<span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span>` +
      `<span class="decode-line-summary">${escapeAisHtml(aisSummaryText(msg))}</span>` +
      `<span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span>` +
-      (distance ? `<span class="decode-line-distance">${escapeAisHtml(distance)}</span>` : "") +
+      `<span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span>` +
-    `</summary>` +
+    `</div>` +
-    `<div class="decode-expanded">` +
+    `<div class="ais-row-meta">` +
-      `<div class="decode-expanded-meta">` +
+      `<span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span>` +
-        `<span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span>` +
+      (route ? `<span class="ais-meta-text">${escapeAisHtml(route)}</span>` : "") +
-        `<span>${escapeAisHtml(channel.freqText)}</span>` +
+      `<span class="ais-meta-text">${escapeAisHtml(channel.freqText)}</span>` +
-        (route ? `<span>${escapeAisHtml(route)}</span>` : "") +
+    `</div>` +
-        (motion ? `<span>${escapeAisHtml(motion)}</span>` : "") +
+    `<div class="ais-row-detail">` +
-        `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span>` +
+      (motion ? `<span>${escapeAisHtml(motion)}</span>` : `<span>No motion data</span>`) +
-        (pos ? `<span>${pos}</span>` : "") +
+      (distance ? `<span>${escapeAisHtml(distance)}</span>` : "") +
-      `</div>` +
+      (pos ? `<span>${pos}</span>` : "") +
-      `<div class="aprs-row-actions">` +
+      `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span>` +
        (msg.lat != null && msg.lon != null
          ? `<button class="aprs-inline-btn" type="button" data-ais-map="${msg.lat},${msg.lon}">Map</button>`
          : "") +
        (vesselUrl
          ? `<a class="aprs-inline-btn" href="${escapeAisHtml(vesselUrl)}" target="_blank" rel="noopener">Vessel</a>`
          : "") +
      `</div>` +
    `</div>`;
  row.querySelectorAll<HTMLElement>("[data-ais-map]").forEach((element) => {
    element.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const [lat, lon] = (element.dataset.aisMap ?? "").split(",").map(Number);
      if (lat == null || lon == null || !Number.isFinite(lat) || !Number.isFinite(lon)) return;
      aisWindow.navigateToAprsMap?.(lat, lon);
    });
  });
  applyAisFilterToRow(row);
  return row;
 }
@@ -322,9 +279,7 @@ function updateAisBar() {
  const isAis = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase() === "AIS";
  const cutoffMs = Date.now() - AIS_BAR_WINDOW_MS;
-  const recent = aisMessageHistory.filter(
+  const recent = aisMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
    (msg) => (msg._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(msg.rig_id),
  );
  const messages = aisLatestByVessel(recent).slice(0, 8);
  if (!isAis || messages.length === 0) {
    aisBarOverlay.style.display = "none";
@@ -378,7 +333,7 @@ function renderAisHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of aisRigMessages()) {
+  for (const message of aisMessageHistory) {
    fragment.appendChild(renderAisRow(message));
  }
  aisMessagesEl.replaceChildren(fragment);
@@ -399,13 +354,9 @@ function addAisMessage(msg: AisMessage): void {
  scheduleAisBarUpdate();
  scheduleAisHistoryRender();
-  plotAisMessage(msg);
+  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
-}
+    aisWindow.aisMapAddVessel(msg);
-
+  }
 /** Hands a positioned message to the map, if the map module is loaded yet. */
 function plotAisMessage(msg: AisMessage): void {
  if (msg.lat == null || msg.lon == null || !aisWindow.aisMapAddVessel) return;
  aisWindow.aisMapAddVessel(msg);
 }
 function normalizeServerAisMessage(msg: AisMessage): AisMessage {
@@ -417,11 +368,10 @@ function normalizeServerAisMessage(msg: AisMessage): AisMessage {
 function onServerAisBatch(messages: AisMessage[]): void {
  if (!Array.isArray(messages) || messages.length === 0) return;
  if (aisStatus) aisStatus.textContent = "Receiving";
  const normalized: AisMessage[] = [];
  for (const msg of messages) {
    const next = normalizeServerAisMessage(msg);
    // "Receiving" is the panel's own status, and the panel is the rig's.
    if (aisStatus && isActiveRigDecode(next.rig_id)) aisStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -429,7 +379,9 @@ function onServerAisBatch(messages: AisMessage[]): void {
      minute: "2-digit",
      second: "2-digit",
    });
-    plotAisMessage(next);
+    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
      aisWindow.aisMapAddVessel(next);
    }
    normalized.push(next);
  }
  normalized.reverse();
@@ -463,9 +415,8 @@ if (aisFilterInput) {
 }
 function onServerAis(msg: AisMessage): void {
-  const message = normalizeServerAisMessage(msg);
+  if (aisStatus) aisStatus.textContent = "Receiving";
-  if (aisStatus && isActiveRigDecode(message.rig_id)) aisStatus.textContent = "Receiving";
+  addAisMessage(normalizeServerAisMessage(msg));
  addAisMessage(message);
 }
 updateAisSummary();
@@ -476,7 +427,4 @@ updateAisSummary();
  restore: onServerAisBatch,
  reset: resetAisHistoryView,
  prune: pruneAisHistoryView,
  rerender: () => { updateAisBar(); renderAisHistory(); },
  // Oldest first, so vessel tracks are rebuilt in the order they happened.
  syncMap: () => { for (const entry of [...aisMessageHistory].reverse()) plotAisMessage(entry); },
 });
@@ -30,14 +30,6 @@ export interface AprsPacket {
  symbol_code?: string | null;
 }
 function escapeAprsHtml(value: string): string {
  return String(value ?? "")
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;");
 }
 export function aprsPacketCategory(packet: AprsPacket): AprsCategory {
  const type = (packet.type ?? "").toLowerCase();
  const info = (packet.info ?? "").toLowerCase();
@@ -182,13 +174,6 @@ export function aprsSymbolSprite(
  };
 }
 /** An empty slot of the symbol's size, so a frame without one still lines up
 *  with the frames around it in the list. */
 export function renderAprsSymbolSlot(packet: AprsPacket, escapeHtml: (value: string) => string): string {
  return renderLocalAprsSymbol(packet, escapeHtml)
    || '<span class="aprs-symbol aprs-symbol-empty" aria-hidden="true"></span>';
 }
 export function renderLocalAprsSymbol(packet: AprsPacket, escapeHtml: (value: string) => string): string {
  if (!packet.symbolTable || !packet.symbolCode) return "";
  const sprite = aprsSymbolSprite(packet.symbolTable, packet.symbolCode);
@@ -220,201 +205,3 @@ export function normalizeAprsPacket(packet: AprsPacket, receiver: unknown): Aprs
    symbolCode: packet.symbol_code ?? null,
  };
 }
 // ── Payload summaries ──────────────────────────────────────────────────────
 // APRS packs its meaning into the information field with a set of one-character
 // type identifiers and fixed-width encodings (APRS 1.0.1, chapters 6-15).  The
 // list showed that field as it arrives on the air, so reading a weather report
 // meant decoding "_10090556c220s004g005t077..." by eye.  These produce a line
 // of plain text for the common types and leave the raw field to the expanded
 // view, which is still the authority when a summary cannot be made.
 /** `t077` → 25.0 °C. APRS carries temperature in whole degrees Fahrenheit. */
 function fahrenheitToCelsius(fahrenheit: number): number {
  return Math.round(((fahrenheit - 32) * 5 / 9) * 10) / 10;
 }
 /** Weather report fields: wind, gust, temperature, rain, humidity, pressure. */
 function summarizeAprsWeather(info: string): string | null {
  const parts: string[] = [];
  const temperature = /t(-?\d{2,3})/.exec(info);
  if (temperature) parts.push(`${fahrenheitToCelsius(Number(temperature[1]))} °C`);
  const wind = /(\d{3})\/(\d{3})/.exec(info) ?? /c(\d{3}).*?s(\d{3})/.exec(info);
  if (wind) {
    const gust = /g(\d{3})/.exec(info);
    const knots = Number(wind[2]);
    parts.push(`wind ${Number(wind[1])}° ${knots} kt${gust ? ` gust ${Number(gust[1])}` : ""}`);
  }
  const humidity = /h(\d{2})/.exec(info);
  if (humidity) {
    const value = Number(humidity[1]);
    parts.push(`${value === 0 ? 100 : value}% RH`);
  }
  const pressure = /b(\d{5})/.exec(info);
  if (pressure) parts.push(`${(Number(pressure[1]) / 10).toFixed(1)} hPa`);
  const rain = /r(\d{3})/.exec(info);
  if (rain && Number(rain[1]) > 0) parts.push(`rain ${(Number(rain[1]) / 100).toFixed(2)}"`);
  return parts.length ? parts.join(" · ") : null;
 }
 /** `T#005,199,000,255,073,123,01101001` → sequence, five channels, eight bits. */
 function summarizeAprsTelemetry(info: string): string | null {
  const match = /^T#(\d+|MIC)((?:,-?[\d.]*)+)(?:,([01]{8}))?/.exec(info.trim());
  if (!match?.[2]) return null;
  const channels = match[2].split(",").filter((value) => value.length > 0);
  const bits = match[3] ? ` · bits ${match[3]}` : "";
  return `#${match[1]} · ${channels.join(" ")}${bits}`;
 }
 /** `:DEST     :text{01` → addressed message text. */
 function summarizeAprsMessage(info: string): string | null {
  const match = /^:([^:]{9}):(.*)$/.exec(info);
  if (!match?.[1] || match[2] == null) return null;
  const addressee = match[1].trim();
  const text = match[2].replace(/\{\d+\s*$/, "").trim();
  return `→ ${addressee}: ${text}`;
 }
 /** Course/speed appended to a position, as `088/036`. */
 function summarizeAprsCourseSpeed(info: string): string | null {
  const match = /(\d{3})\/(\d{3})/.exec(info);
  if (!match) return null;
  const knots = Number(match[2]);
  if (knots === 0) return null;
  return `${Number(match[1])}° ${knots} kt`;
 }
 /** Whatever a frame is worth saying in one line, or null to fall back to raw. */
 export function summarizeAprsPayload(packet: AprsPacket): string | null {
  const info = packet.info ?? "";
  if (!info) return null;
  const category = aprsPacketCategory(packet);
  if (category === "message") return summarizeAprsMessage(info);
  if (category === "weather") return summarizeAprsWeather(info);
  if (category === "telemetry") return summarizeAprsTelemetry(info);
  if (category === "position") {
    const parts: string[] = [];
    if (packet.lat != null && packet.lon != null) {
      parts.push(`${packet.lat.toFixed(4)}, ${packet.lon.toFixed(4)}`);
    }
    const courseSpeed = summarizeAprsCourseSpeed(info);
    if (courseSpeed) parts.push(courseSpeed);
    // Whatever the station wrote after the position report.
    const comment = info.replace(/^[!=@/][^>]*[>_]?/, "").replace(/\d{3}\/\d{3}/, "").trim();
    if (comment && comment.length <= 60) parts.push(comment);
    return parts.length ? parts.join(" · ") : null;
  }
  // Status and anything else: the text it carries, minus its type character.
  const text = info.replace(/^[>;<?]/, "").trim();
  return text.length ? text : null;
 }
 // ── Frame row ──────────────────────────────────────────────────────────────
 // Shared by the APRS and HF APRS lists, which had a copy each of the same
 // forty lines of markup and drifted only by one badge.
 export interface AprsRowOptions {
  /** Marks the newest frame so it can flash on arrival. */
  fresh?: boolean;
  /** Leading badge, e.g. the band a copy of this list is dedicated to. */
  badge?: string;
  /** Distance from the receiver, already formatted, or "" to leave it out. */
  distance?: string;
  /** Opens the map on a frame's position. */
  onMap?: (lat: number, lon: number) => void;
  /** Puts a frame's coordinates on the clipboard. */
  onCopy?: (text: string, button: HTMLElement) => void;
  /** Opens a log entry for the station that sent the frame. */
  onLog?: (call: string, gridsquare: string | null) => void;
 }
 /** A position as a six-character locator, which is what a log wants. */
 function maidenheadForLatLon(lat: number, lon: number): string {
  const adjustedLon = lon + 180;
  const adjustedLat = lat + 90;
  const field = String.fromCharCode(65 + Math.floor(adjustedLon / 20))
    + String.fromCharCode(65 + Math.floor(adjustedLat / 10));
  const square = String(Math.floor((adjustedLon % 20) / 2)) + String(Math.floor(adjustedLat % 10));
  const subLon = ((adjustedLon % 2) * 60) / 5;
  const subLat = ((adjustedLat % 1) * 60) / 2.5;
  const sub = String.fromCharCode(97 + Math.floor(subLon)) + String.fromCharCode(97 + Math.floor(subLat));
  return `${field}${square}${sub}`.toUpperCase();
 }
 export function renderAprsPacketRow(packet: AprsPacket, options: AprsRowOptions = {}): HTMLElement {
  const row = document.createElement("details");
  row.className = "aprs-packet";
  if (!packet.crcOk) row.classList.add("aprs-packet-crc");
  if (options.fresh) row.classList.add("aprs-packet-new");
  const time = packet._ts
    || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
  const category = aprsPacketCategory(packet);
  const summary = summarizeAprsPayload(packet);
  const hasPosition = packet.lat != null && packet.lon != null;
  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(packet.srcCall || "")}`;
  row.innerHTML =
    `<summary class="decode-line">` +
      `<span class="aprs-time">${escapeAprsHtml(time)}</span>` +
      (options.badge ? `<span class="aprs-badge aprs-badge-band">${escapeAprsHtml(options.badge)}</span>` : "") +
      renderAprsSymbolSlot(packet, escapeAprsHtml) +
      `<span class="aprs-call">${escapeAprsHtml(packet.srcCall ?? "")}</span>` +
      `<span class="aprs-badge aprs-badge-type aprs-badge-type-${category}">` +
        `${escapeAprsHtml(aprsCategoryLabel(category))}</span>` +
      `<span class="decode-line-summary">${summary ? escapeAprsHtml(summary) : renderAprsInfo(packet)}</span>` +
      (packet.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC</span>') +
      (options.distance ? `<span class="decode-line-distance">${escapeAprsHtml(options.distance)}</span>` : "") +
    `</summary>` +
    `<div class="decode-expanded">` +
      `<div class="decode-expanded-meta">` +
        `<span>&gt;${escapeAprsHtml(packet.destCall || "--")}</span>` +
        `<span>${escapeAprsHtml(packet.path || "no path")}</span>` +
        `<span>${escapeAprsHtml(aprsAgeText(packet._tsMs))}</span>` +
        `<span>CRC ${packet.crcOk ? "ok" : "failed"}</span>` +
        (hasPosition
          ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${packet.lat},${packet.lon}">`
            + `${packet.lat?.toFixed(5)}, ${packet.lon?.toFixed(5)}</a>`
          : "") +
      `</div>` +
      `<div class="decode-expanded-raw">${renderAprsInfo(packet)}</div>` +
      (packet.info_bytes?.length
        ? `<div class="decode-expanded-bytes">${escapeAprsHtml(aprsHexBytes(packet.info_bytes))}</div>`
        : "") +
      `<div class="aprs-row-actions">` +
        (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${packet.lat},${packet.lon}">Map</button>` : "") +
        (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${packet.lat},${packet.lon}">Copy Coords</button>` : "") +
        `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
        (options.onLog && packet.srcCall ? '<button class="aprs-inline-btn" type="button" data-aprs-log="1">Log</button>' : "") +
      `</div>` +
    `</div>`;
  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((element) => {
    element.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const [lat, lon] = (element.dataset.aprsMap ?? "").split(",").map(Number);
      if (Number.isFinite(lat) && Number.isFinite(lon)) options.onMap?.(lat as number, lon as number);
    });
  });
  const logButton = row.querySelector<HTMLElement>("[data-aprs-log]");
  if (logButton) {
    logButton.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const grid = packet.lat != null && packet.lon != null
        ? maidenheadForLatLon(packet.lat, packet.lon)
        : null;
      options.onLog?.(packet.srcCall ?? "", grid);
    });
  }
  const copyButton = row.querySelector<HTMLElement>("[data-aprs-copy]");
  if (copyButton) {
    copyButton.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      options.onCopy?.(copyButton.dataset.aprsCopy ?? "", copyButton);
    });
  }
  return row;
 }
@@ -4,13 +4,15 @@
 import { hostCore, hostState } from "./host.js";
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import {
  aprsAgeText,
  aprsCategoryLabel,
  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsPacketRow,
+  renderAprsInfo,
  renderLocalAprsSymbol,
  type AprsPacket,
  type AprsTypeFilter,
 } from "./aprs-shared";
@@ -23,7 +25,6 @@ interface AprsBridge {
  aprsMapAddStation?: (call: string, lat: number, lon: number, info: string, symbolTable: string | null | undefined, symbolCode: string | null | undefined, packet: AprsPacket) => void;
  getDecodeRigMeta?: () => unknown;
  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
  logContact?: (seed: { call?: string; gridsquare?: string | undefined; decoder?: string }) => void;
  updateAprsBar?: () => void;
  clearAprsBar?: () => void;
  closeAprsBar?: () => void;
@@ -108,29 +109,21 @@ function aprsFilterMatch(pkt: AprsPacket): boolean {
  return haystack.includes(aprsFilterText);
 }
 /** What the selected rig heard.  The history holds every rig's traffic, for
 *  the map; the panel is about the rig the operator is working. */
 function aprsRigPackets(): AprsPacket[] {
  return forActiveRig(aprsPacketHistory);
 }
 function aprsVisiblePackets(): AprsPacket[] {
-  const rigPackets = aprsRigPackets();
+  const packets = aprsCollapseDup ? collapseAprsDuplicates(aprsPacketHistory) : aprsPacketHistory;
  const packets = aprsCollapseDup ? collapseAprsDuplicates(rigPackets) : rigPackets;
  return packets.filter(aprsFilterMatch);
 }
 function updateAprsSummary() {
  const rigPackets = aprsRigPackets();
  const visible = aprsVisiblePackets();
  if (aprsTotalCountEl) {
-    aprsTotalCountEl.textContent = `${rigPackets.length} total`;
+    aprsTotalCountEl.textContent = `${aprsPacketHistory.length} total`;
  }
  if (aprsVisibleCountEl) {
    aprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (aprsLatestSeenEl) {
-    const latest = rigPackets[0];
+    const latest = aprsPacketHistory[0];
    if (!latest) {
      aprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -148,27 +141,93 @@ function updateAprsChipState() {
  aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }
 async function copyAprsCoords(text: string): Promise<void> {
  try {
    const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
    if (!clipboard) return;
    await clipboard.writeText(text);
    showAprsHint("Coordinates copied", 1200);
  } catch {
    showAprsHint("Copy failed", 1500);
  }
 }
 function renderAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
-  return renderAprsPacketRow(pkt, {
+  const row = document.createElement("div");
-    fresh: isFresh,
+  row.className = "aprs-packet";
-    distance: aprsDistanceText(pkt),
+  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-    onMap: (lat, lon) => { aprsWindow.navigateToAprsMap?.(lat, lon); },
+  if (isFresh) row.classList.add("aprs-packet-new");
-    onCopy: (text) => { void copyAprsCoords(text); },
+
-    onLog: (call, gridsquare) => {
+  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-      aprsWindow.logContact?.({ call, gridsquare: gridsquare ?? undefined, decoder: "aprs" });
+  const age = aprsAgeText(pkt._tsMs);
-    },
+  const category = aprsPacketCategory(pkt);
  const categoryLabel = aprsCategoryLabel(category);
  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeAprsHtml(pkt.path)}</span>` : "";
  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
  const symbolHtml = renderLocalAprsSymbol(pkt, escapeAprsHtml);
  const posLink = pkt.lat != null && pkt.lon != null
    ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>`
    : "";
  const distance = aprsDistanceText(pkt);
  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
  row.innerHTML =
    `<div class="aprs-row-head">` +
      `<span class="aprs-time">${ts}</span>` +
      symbolHtml +
      `<span class="aprs-call">${escapeAprsHtml(pkt.srcCall ?? "")}</span>` +
      `<span>&gt;${escapeAprsHtml(pkt.destCall || "")}</span>` +
      `<span class="${categoryClass}">${escapeAprsHtml(categoryLabel)}</span>` +
      pathBadge +
      crcBadge +
    `</div>` +
    `<div class="aprs-row-meta">` +
      `<span class="aprs-meta-text">${escapeAprsHtml(age)}</span>` +
      (distance ? `<span class="aprs-meta-text">${escapeAprsHtml(distance)}</span>` : "") +
      `<span class="aprs-meta-text">${escapeAprsHtml(pkt.type || "--")}</span>` +
    `</div>` +
    `<div class="aprs-row-detail">` +
      `<span title="${escapeAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
      (posLink ? `<span>${posLink}</span>` : "") +
    `</div>` +
    `<div class="aprs-row-actions">` +
      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") +
      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") +
      `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
    `</div>` +
    `<details class="aprs-details">` +
      `<summary>Details</summary>` +
      `<div class="aprs-details-grid">` +
        `<span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.srcCall || "--")}</span>` +
        `<span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.destCall || "--")}</span>` +
        `<span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.type || "--")}</span>` +
        `<span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.path || "--")}</span>` +
        `<span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeAprsHtml(age)}</span>` +
        `<span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span>` +
        `<span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span>` +
        `<span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.info || "--")}</span>` +
        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeAprsHtml(aprsHexBytes(pkt.info_bytes))}</span>` +
      `</div>` +
    `</details>`;
  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((el) => {
    el.addEventListener("click", (evt) => {
      evt.preventDefault();
      const raw = el.dataset.aprsMap ?? "";
      const [lat, lon] = raw.split(",").map(Number);
      if (aprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
        aprsWindow.navigateToAprsMap(lat, lon);
      }
    });
  });
  const copyBtn = row.querySelector<HTMLElement>("[data-aprs-copy]");
  if (copyBtn) {
    copyBtn.addEventListener("click", () => { void (async () => {
      const raw = copyBtn.dataset.aprsCopy ?? "";
      try {
        const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
        if (clipboard) {
          await clipboard.writeText(raw);
          showAprsHint("Coordinates copied", 1200);
        }
      } catch {
        showAprsHint("Copy failed", 1500);
      }
    })(); });
  }
  return row;
 }
 function renderAprsHistory() {
@@ -192,9 +251,7 @@ function updateAprsBar() {
  if (!aprsBarOverlay) return;
  const isPkt = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase() === "PKT";
  const cutoffMs = Date.now() - APRS_BAR_WINDOW_MS;
-  const okFrames = aprsPacketHistory.filter(
+  const okFrames = aprsPacketHistory.filter((p) => p.crcOk && (p._tsMs ?? 0) >= cutoffMs);
    (p) => p.crcOk && (p._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(p.rig_id),
  );
  const frames = collapseAprsDuplicates(okFrames).slice(0, 8);
  const newestTsMs = frames.reduce((latest, pkt) => Math.max(latest, Number(pkt._tsMs) || 0), 0);
  if (!isPkt || frames.length === 0 || newestTsMs <= aprsBarDismissedAtMs) {
@@ -244,12 +301,6 @@ function pruneAprsHistoryView(): void {
  renderAprsHistory();
 }
 /** Hands a positioned packet to the map, if the map module is loaded yet. */
 function plotAprsPacket(pkt: AprsPacket): void {
  if (pkt.lat == null || pkt.lon == null || !aprsWindow.aprsMapAddStation) return;
  aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
 }
 function addAprsPacket(pkt: AprsPacket): void {
  const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
  pkt._tsMs = tsMs;
@@ -258,7 +309,9 @@ function addAprsPacket(pkt: AprsPacket): void {
  aprsPacketHistory.unshift(pkt);
  pruneAprsPacketHistory();
-  plotAprsPacket(pkt);
+  if (pkt.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
  }
  if (pkt.crcOk) scheduleAprsBarUpdate();
@@ -271,16 +324,17 @@ function normalizeServerAprsPacket(pkt: AprsPacket): AprsPacket {
 function onServerAprsBatch(packets: AprsPacket[]): void {
  if (!Array.isArray(packets) || packets.length === 0) return;
  if (aprsStatus) aprsStatus.textContent = "Receiving";
  const normalized: AprsPacket[] = [];
  let hasCrcOk = false;
  for (const pkt of packets) {
    const next = normalizeServerAprsPacket(pkt);
    // "Receiving" is the panel's own status, and the panel is the rig's.
    if (aprsStatus && isActiveRigDecode(next.rig_id)) aprsStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    plotAprsPacket(next);
+    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
    }
    if (next.crcOk) hasCrcOk = true;
    normalized.push(next);
  }
@@ -340,9 +394,8 @@ if (aprsFilterInput) {
 // --- Server-side APRS decode handler ---
 function onServerAprs(pkt: AprsPacket): void {
-  const packet = normalizeServerAprsPacket(pkt);
+  if (aprsStatus) aprsStatus.textContent = "Receiving";
-  if (aprsStatus && isActiveRigDecode(packet.rig_id)) aprsStatus.textContent = "Receiving";
+  addAprsPacket(normalizeServerAprsPacket(pkt));
  addAprsPacket(packet);
 }
 renderAprsHistory();
@@ -353,7 +406,4 @@ renderAprsHistory();
  restore: onServerAprsBatch,
  reset: resetAprsHistoryView,
  prune: pruneAprsHistoryView,
  rerender: () => { updateAprsBar(); renderAprsHistory(); },
  // Oldest first, so station tracks are rebuilt in the order they happened.
  syncMap: () => { for (const entry of [...aprsPacketHistory].reverse()) plotAprsPacket(entry); },
 });
@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 import { hostState } from "./host.js";
 import { hasAuthRole, type AuthRole } from "../api/auth.js";
 export {};
@@ -45,7 +44,7 @@ interface BackgroundBridge {
  trx?: { modules?: { backgroundDecode?: BackgroundDecodeService } };
 }
 interface BackgroundDecodeService {
-  initialize(rigId: string | null, roles: readonly AuthRole[]): void;
+  initialize(rigId: string | null, role: string | null): void;
  wireEvents(): void;
  setRig(rigId: string | null): void;
 }
@@ -61,23 +60,16 @@ const bgdWindow = window as unknown as BackgroundBridge;
      .map(function (d) { return d.id; });
  }
-  let backgroundDecodeRoles: readonly AuthRole[] = [];
+  let backgroundDecodeRole: string | null = null;
  let currentRigId: string | null = null;
  let currentConfig: BackgroundDecodeConfig | null = null;
  let bookmarkList: Bookmark[] = [];
  let statusInterval: ReturnType<typeof setInterval> | null = null;
  let bgdDirty = false;
  /** Last polled state per bookmark, so a row can say what it is doing. */
  let statusByBookmark = new Map<string, BackgroundStatusEntry>();
  let lastStatus: BackgroundDecodeStatus | null = null;
-  function initBackgroundDecode(rigId: string | null, roles: readonly AuthRole[]): void {
+  function initBackgroundDecode(rigId: string | null, role: string | null): void {
-    backgroundDecodeRoles = roles;
+    backgroundDecodeRole = role;
-    // The panel used to take whatever rig it was handed at load and wait to be
+    currentRigId = rigId || null;
    // told again.  Loading before the rig list arrives handed it null, and the
    // next telling only came when the operator switched rigs, so the panel sat
    // empty and silent.  The host knows the rig; ask it.
    currentRigId = rigId || hostState.lastActiveRigId || null;
    if (currentRigId) loadBackgroundDecode();
    startStatusPolling();
  }
@@ -179,7 +171,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
    setCheckbox("background-decode-enabled", currentConfig.enabled);
    renderBookmarkChecklist();
-    const isControl = isControlRole();
+    const isControl = backgroundDecodeRole === "control" || hostState.authEnabled === false;
    const panel = document.getElementById("background-decode-panel");
    if (panel) {
        panel.querySelectorAll<HTMLInputElement | HTMLSelectElement | HTMLButtonElement>("input, select, button.sch-write").forEach(function (el) {
@@ -190,11 +182,6 @@ const bgdWindow = window as unknown as BackgroundBridge;
    const resetBtn = document.getElementById("background-decode-reset-btn");
    if (saveBtn) saveBtn.style.display = isControl ? "" : "none";
    if (resetBtn) resetBtn.style.display = isControl ? "" : "none";
    syncSaveButton();
  }
  function currentFilterText(): string {
    return (document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value ?? "";
  }
  function renderBookmarkChecklist(filterText = ""): void {
@@ -216,65 +203,26 @@ const bgdWindow = window as unknown as BackgroundBridge;
      : all;
    if (filtered.length === 0) {
-      container.innerHTML = '<div class="bgd-checklist-empty">' + escHtml(emptyListText(all.length)) + "</div>";
+      container.innerHTML = '<div class="bgd-checklist-empty">' +
-      renderSelectionSummary();
+        (all.length === 0 ? "No supported bookmarks available." : "No bookmarks match filter.") +
        '</div>';
      return;
    }
    filtered.forEach(function (bookmark) {
      const row = document.createElement("label");
      row.className = "bgd-checklist-row";
      row.dataset.bmId = bookmark.id;
      const decoders = bookmarkDecoderKinds(bookmark);
-      const selected = selectedIds.has(bookmark.id);
+      const checked = selectedIds.has(bookmark.id) ? " checked" : "";
      if (selected) row.classList.add("is-selected");
      row.innerHTML =
-        '<input type="checkbox"' + (selected ? " checked" : "") + ' data-bm-id="' + escHtml(bookmark.id) + '" />' +
+        '<input type="checkbox"' + checked + ' data-bm-id="' + escHtml(bookmark.id) + '" />' +
        '<span class="bgd-checklist-name">' + escHtml(bookmark.name) + '</span>' +
-        '<span class="bgd-checklist-meta">'
+        '<span class="bgd-checklist-meta">' + escHtml(formatFreq(bookmark.freq_hz) + " " + bookmark.mode + " · " + decoders.join("/").toUpperCase()) + '</span>';
          + escHtml(formatFreq(bookmark.freq_hz)) + '<span class="bgd-checklist-mode">'
          + escHtml(bookmark.mode + " · " + decoders.join("/").toUpperCase()) + '</span></span>'
        + stateBadgeHtml(bookmark.id, selected);
      row.querySelector<HTMLInputElement>("input")?.addEventListener("change", function (e) {
        onChecklistToggle(bookmark.id, (e.currentTarget as HTMLInputElement).checked);
      });
      container.appendChild(row);
    });
    renderSelectionSummary();
  }
  /** Why the list is empty, in the terms the operator can act on. */
  function emptyListText(supportedCount: number): string {
    if (supportedCount > 0) return "No bookmark matches that filter.";
    if (bookmarkList.length > 0) {
      return "None of your bookmarks name a decoder that can run in the background."
        + " Give one a decoder on the Bookmarks tab to list it here.";
    }
    return "No bookmarks yet. Save one on the Bookmarks tab and it can be decoded here.";
  }
  /** The live state of a selected bookmark, as the row's own badge. */
  function stateBadgeHtml(bookmarkId: string, selected: boolean): string {
    if (!selected) return '<span class="bgd-state" data-state="unselected"></span>';
    const entry = statusByBookmark.get(bookmarkId);
    const state = entry?.state ?? (currentConfig?.enabled ? "pending" : "disabled");
    return '<span class="bgd-state" data-state="' + escHtml(state) + '" title="' + escHtml(stateHelp(state)) + '">'
      + '<span class="bgd-state-dot"></span>' + escHtml(prettyState(state)) + "</span>";
  }
  function renderSelectionSummary(): void {
    const el = document.getElementById("bgd-selection-summary");
    if (!el) return;
    const selected = currentConfig?.bookmark_ids.length ?? 0;
    if (selected === 0) {
      el.textContent = "Nothing selected — background decoding is idle.";
      return;
    }
    const active = [...statusByBookmark.values()].filter((entry) => entry.state === "active").length;
    const noun = `${String(selected)} bookmark${selected === 1 ? "" : "s"} selected`;
    el.textContent = currentConfig?.enabled
      ? `${noun}, ${String(active)} decoding now.`
      : `${noun}. Switch Enabled on to start decoding them.`;
  }
  function onChecklistToggle(bookmarkId: string, checked: boolean): void {
@@ -312,7 +260,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
        showToast(`Save failed: ${errorMessage(err)}`, true);
      })
      .finally(function () {
-        syncSaveButton();
+        if (btn) btn.disabled = false;
      });
  }
@@ -347,77 +295,58 @@ const bgdWindow = window as unknown as BackgroundBridge;
  }
  function renderStatus(status: BackgroundDecodeStatus): void {
-    lastStatus = status;
+    const card = document.getElementById("background-decode-status-card");
-    statusByBookmark = new Map(
+    if (!card) return;
-      (status.entries ?? [])
+    const entries = status.entries ?? [];
-        .filter((entry) => typeof entry.bookmark_id === "string" && entry.bookmark_id.length > 0)
+    if (!entries.length) {
-        .map((entry) => [entry.bookmark_id as string, entry]),
+      card.textContent = "No background decode bookmarks configured.";
    );
    renderSpanSummary();
    // Rows carry the state, so the list repaints — keeping the filter the
    // operator typed and the selection they have not saved yet.
    renderBookmarkChecklist(currentFilterText());
  }
  /** What the rig is listening across, which is what decides whether a
   *  selected bookmark can be decoded at all. */
  function renderSpanSummary(): void {
    const el = document.getElementById("bgd-span-summary");
    if (!el) return;
    const status = lastStatus;
    if (!status) {
      el.textContent = "";
      return;
    }
-    if (!status.active_rig) {
+    const summary = [];
-      el.textContent = "This rig is not the one playing audio.";
+    if (status.active_rig) {
-      el.dataset.tone = "warn";
+      if (typeof status.center_hz === "number" && Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
-      return;
+      if (typeof status.sample_rate === "number" && Number.isFinite(status.sample_rate) && status.sample_rate > 0) summary.push("Span ±" + formatFreq(status.sample_rate / 2));
    } else {
      summary.push("This rig is not currently selected for audio.");
    }
-    const centre = typeof status.center_hz === "number" && Number.isFinite(status.center_hz)
+    let html = summary.length ? '<div style="margin-bottom:0.8rem;color:var(--text-muted);">' + escHtml(summary.join(" · ")) + "</div>" : "";
-      ? formatFreq(status.center_hz)
+    html += '<div class="bgd-status-list">';
-      : null;
+    entries.forEach(function (entry) {
-    const half = typeof status.sample_rate === "number" && Number.isFinite(status.sample_rate) && status.sample_rate > 0
+      const name = entry.bookmark_name || entry.bookmark_id || "Unknown bookmark";
-      ? formatFreq(status.sample_rate / 2)
+      const parts = [];
-      : null;
+      if (typeof entry.freq_hz === "number" && Number.isFinite(entry.freq_hz)) parts.push(formatFreq(entry.freq_hz));
-    el.dataset.tone = "";
+      if (entry.mode) parts.push(entry.mode);
-    el.textContent = centre && half ? `Span ${centre} ±${half}` : centre ? `Centre ${centre}` : "";
+      if (Array.isArray(entry.decoder_kinds) && entry.decoder_kinds.length) {
        parts.push(entry.decoder_kinds.join("/").toUpperCase());
      }
      html +=
        '<div class="bgd-status-row">' +
          '<div>' +
            '<div class="bgd-status-name">' + escHtml(name) + '</div>' +
            '<div class="bgd-status-meta">' + escHtml(parts.join(" · ")) + '</div>' +
          '</div>' +
          '<div class="bgd-status-state" data-state="' + escHtml(entry.state || "inactive") + '">' +
            '<svg class="bgd-state-dot" viewBox="0 0 8 8"><circle cx="4" cy="4" r="3.5"/></svg>' +
            escHtml(prettyState(entry.state)) + '</div>' +
        '</div>';
    });
    html += "</div>";
    card.innerHTML = html;
  }
  /** The one-line reason behind a state, for the row's tooltip. */
  function stateHelp(state: string | undefined): string {
    switch (state) {
      case "active": return "Decoding on a hidden channel.";
      case "out_of_span": return "Outside the span the rig is tuned across, so it cannot be heard from here.";
      case "waiting_for_spectrum": return "Waiting for the first spectrum frame from the rig.";
      case "waiting_for_user": return "Nobody is listening to this rig, so no audio is being pulled.";
      case "missing_bookmark": return "The bookmark this was selected from is gone.";
      case "no_supported_decoders": return "No decoder that runs in the background can decode this bookmark.";
      case "disabled": return "Background decoding is switched off.";
      case "handled_by_scheduler":
      case "scheduler_has_control": return "The scheduler is running this bookmark instead.";
      case "handled_by_virtual_channel": return "A virtual channel is already on this frequency.";
      case "pending": return "Selected, and not started yet — save to apply.";
      default: return "Selected, but not decoding.";
    }
  }
  // The dot beside the word already says whether this is running, so the
  // words no longer carry a tick or a triangle of their own.
  function prettyState(state: string | undefined): string {
    switch (state) {
-      case "active": return "Decoding";
+      case "active": return "\u2713 Active";
-      case "out_of_span": return "Out of span";
+      case "out_of_span": return "\u25B3 Out of span";
-      case "waiting_for_spectrum": return "Waiting for spectrum";
+      case "waiting_for_spectrum": return "\u25B3 Waiting";
-      case "waiting_for_user": return "Nobody listening";
+      case "waiting_for_user": return "\u25B3 No user";
-      case "missing_bookmark": return "Bookmark gone";
+      case "missing_bookmark": return "\u2717 Missing";
-      case "no_supported_decoders": return "No decoder";
+      case "no_supported_decoders": return "\u2717 Unsupported";
-      case "disabled": return "Off";
+      case "disabled": return "\u25B3 Disabled";
-      case "handled_by_scheduler":
+      case "handled_by_scheduler": return "\u25B3 Scheduler";
-      case "scheduler_has_control": return "Scheduler has it";
+      case "scheduler_has_control": return "\u25B3 Scheduler";
-      case "handled_by_virtual_channel": return "On a channel";
+      case "handled_by_virtual_channel": return "\u25B3 VChan";
-      case "pending": return "Not saved";
+      default: return "\u25B3 Inactive";
      default: return "Idle";
    }
  }
@@ -451,25 +380,14 @@ const bgdWindow = window as unknown as BackgroundBridge;
  function markBgdDirty() {
    if (bgdDirty) return;
    bgdDirty = true;
-    syncSaveButton();
+    const btn = document.getElementById("background-decode-save-btn");
    if (btn) btn.classList.add("sch-dirty");
  }
  function clearBgdDirty() {
    bgdDirty = false;
-    syncSaveButton();
+    const btn = document.getElementById("background-decode-save-btn");
-  }
+    if (btn) btn.classList.remove("sch-dirty");
  /** Save offers itself only when there is something to save. */
  function syncSaveButton() {
    const btn = document.getElementById("background-decode-save-btn") as HTMLButtonElement | null;
    if (!btn) return;
    btn.classList.toggle("sch-dirty", bgdDirty);
    btn.disabled = !bgdDirty || !isControlRole();
    btn.title = bgdDirty ? "Apply these bookmarks to the background decoder" : "No changes to save";
  }
  function isControlRole(): boolean {
    return hasAuthRole(backgroundDecodeRoles, "control") || hostState.authEnabled === false;
  }
  function showToast(msg: string, isError: boolean): void {
@@ -489,7 +407,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
    }
    const ids = supportedBookmarks().map(function (bm) { return bm.id; });
    currentConfig.bookmark_ids = ids;
-    renderBookmarkChecklist(currentFilterText());
+    renderBookmarkChecklist((document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value);
    markBgdDirty();
  }
@@ -498,7 +416,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
    }
    currentConfig.bookmark_ids = [];
-    renderBookmarkChecklist(currentFilterText());
+    renderBookmarkChecklist((document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value);
    markBgdDirty();
  }
@@ -514,11 +432,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
    const enabledCb = document.getElementById("background-decode-enabled") as (HTMLInputElement & WiredElement) | null;
    if (enabledCb && !enabledCb._wired) {
      enabledCb._wired = true;
-      enabledCb.addEventListener("change", function () {
+      enabledCb.addEventListener("change", function () { markBgdDirty(); });
        if (currentConfig) currentConfig.enabled = enabledCb.checked;
        markBgdDirty();
        renderBookmarkChecklist(currentFilterText());
      });
    }
    const selectAllBtn = document.getElementById("bgd-select-all-btn") as WiredElement | null;
@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 import { hostCore, hostState } from "./host.js";
 import { hasAuthRole } from "../api/auth.js";
 export {};
@@ -19,8 +18,6 @@ interface Bookmark {
  category?: string | null;
  comment?: string | null;
  decoders?: string[];
  /** DIG sideband override: "auto" | "usb" | "lsb". Empty/absent = global. */
  dig_sideband?: string | null;
  scope?: string;
 }
@@ -103,8 +100,7 @@ function bmEsc(str: unknown): string {
 }
 function bmCanControl() {
-  return !hostState.authEnabled
+  return !hostState.authEnabled || hostState.authRole === "control";
    || hasAuthRole(hostState.authRoles, "write");
 }
 // Show/hide the Add Bookmark / Select All buttons based on the current auth role.
@@ -323,14 +319,6 @@ function bmBuildDecoderCheckboxes() {
    });
 }
 /** Show the DIG-sideband override selector only when the mode field is DIG. */
 function bmSyncDigSidebandVisibility(): void {
  const label = bmOptionalEl("bm-dig-sideband-label");
  if (!label) return;
  const mode = (bmEl("bm-mode").value || "").trim().toUpperCase();
  label.style.display = mode === "DIG" ? "" : "none";
 }
 function bmOpenForm(bm: Bookmark | null): void {
  const wrap = bmEl("bm-form-wrap");
  if (!wrap) return;
@@ -348,9 +336,7 @@ function bmOpenForm(bm: Bookmark | null): void {
  bmEl("bm-locator").value = bm ? (bm.locator || "") : "";
  bmEl("bm-category-input").value = bm ? (bm.category || "") : "";
  bmEl("bm-comment").value = bm ? (bm.comment || "") : "";
  bmEl("bm-dig-sideband").value = bm ? (bm.dig_sideband || "") : "";
  bmWriteDecoders(bm?.decoders ?? []);
  bmSyncDigSidebandVisibility();
  bmEl("bm-form-title").textContent = bm ? "Edit Bookmark" : "Add Bookmark";
  wrap.style.display = "flex";
@@ -395,9 +381,6 @@ async function bmSave(e: Event): Promise<void> {
  const category = bmEl("bm-category-input").value.trim();
  const comment = bmEl("bm-comment").value.trim();
  const decoders = bmReadDecoders();
  // Only meaningful for DIG; stored empty otherwise so it never overrides.
  const dig_sideband =
    mode.toUpperCase() === "DIG" ? (bmEl("bm-dig-sideband").value || null) : null;
  const formError = bmEl("bm-form-error");
  if (formError) formError.textContent = "";
@@ -418,7 +401,6 @@ async function bmSave(e: Event): Promise<void> {
    category,
    comment,
    decoders,
    dig_sideband,
  };
  try {
@@ -474,7 +456,6 @@ function bmApply(bm: Bookmark): void {
    const modeEl = document.getElementById("mode") as HTMLSelectElement | null;
    if (modeEl) {
      modeEl.value = (bm.mode || "").toUpperCase();
      hostCore.syncModePicker();
    }
    if (bm.bandwidth_hz) {
      hostState.currentBandwidthHz = bm.bandwidth_hz;
@@ -493,16 +474,6 @@ function bmApply(bm: Bookmark): void {
    const tunePromise = (async () => {
      await bridge.trx.modules.vchan?.takeSchedulerControl();
      // For a DIG bookmark carrying a sideband override, set the global DIG
      // policy first so the backend resolves the intended sideband when DIG is
      // applied. "auto" is honoured explicitly; an empty override is left alone.
      if ((bm.mode || "").toUpperCase() === "DIG" && bm.dig_sideband) {
        const p = bm.dig_sideband.toLowerCase();
        if (p === "auto" || p === "usb" || p === "lsb") {
          await hostCore.postPath("/set_sdr_dig_sideband?policy=" + encodeURIComponent(p));
        }
      }
      const onVirtual = await bridge.trx.modules.vchan?.interceptMode(bm.mode) ?? false;
      if (!onVirtual) {
        await hostCore.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
@@ -796,9 +767,6 @@ function bmPopulateScopePicker() {
  // Form submit
  bmEl("bm-form").addEventListener("submit", (event) => { void bmSave(event); });
  // Reveal the DIG-sideband override only while the mode field reads DIG.
  bmEl("bm-mode").addEventListener("input", bmSyncDigSidebandVisibility);
  // Form cancel
  bmEl("bm-form-cancel").addEventListener("click", bmCloseForm);
@@ -4,7 +4,6 @@
 import { hostCore } from "./host.js";
 import { isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
 export {};
@@ -21,11 +20,8 @@ interface CwRenderer {
  drawPoints(points: number[], size: number, color: Rgba): void;
 }
 interface CwSpectrum { bins: number[]; sample_rate: number; center_hz: number }
-interface CwEvent { rig_id?: string | null; text?: string; wpm?: number; tone_hz?: number; signal_on?: boolean }
+interface CwEvent { text?: string; wpm?: number; tone_hz?: number; signal_on?: boolean }
-interface CwLine {
+interface CwLine { tsMs: number; ts: string; text: string; wpm: number | null; tone_hz: number | null; lastMs: number }
  rigId: string | null; tsMs: number; ts: string; text: string;
  wpm: number | null; tone_hz: number | null; lastMs: number;
 }
 interface CwToneRange {
  tunedHz: number; bandwidthHz: number; toneMinHz: number; toneMaxHz: number;
  toneSpanHz: number; lowerSideband: boolean; mode: string;
@@ -70,10 +66,7 @@ const CW_BAR_LINE_GAP_MS = 5000;
 let cwLastAppendTime = 0;
 let cwTonePickerRaf: number | null = null;
 let cwBarHistory: CwLine[] = [];
-// One line in progress per rig, keyed by rig id ("" for a decode that names no
+let cwBarCurrentLine: CwLine | null = null;
 // rig).  Two rigs copying at the same time each fill their own line instead of
 // braiding their characters into one.
 const cwBarCurrentLines = new Map<string, CwLine>();
 let cwBarDismissedAtMs = 0;
 // Tracks a user-initiated auto toggle that is in-flight (POST not yet
 // acknowledged).  While set, server-state updates must not override the
@@ -108,13 +101,12 @@ cwWindow.applyCwAutoUiFromServer = function(enabled: boolean) {
  applyCwAutoUi(enabled);
 };
-function cwBarFlushCurrentLine(key: string): void {
+function cwBarFlushCurrentLine(): void {
-  const line = cwBarCurrentLines.get(key);
+  if (cwBarCurrentLine && cwBarCurrentLine.text.trim()) {
-  cwBarCurrentLines.delete(key);
+    cwBarHistory.unshift(cwBarCurrentLine);
  if (line?.text.trim()) {
    cwBarHistory.unshift(line);
    if (cwBarHistory.length > 50) cwBarHistory.length = 50;
  }
  cwBarCurrentLine = null;
 }
 function updateCwBar(): void {
@@ -122,12 +114,9 @@ function updateCwBar(): void {
  const mode = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase();
  const isCw = mode === "CW" || mode === "CWR";
  const cutoffMs = Date.now() - CW_BAR_WINDOW_MS;
-  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs && isActiveRigDecode(l.rigId));
+  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs);
-  // Prepend the in-progress lines so characters appear immediately
+  // Prepend the in-progress line so characters appear immediately
-  const inProgress = [...cwBarCurrentLines.values()]
+  const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
    .filter((l) => l.text && isActiveRigDecode(l.rigId))
    .sort((a, b) => b.tsMs - a.tsMs);
  const liveLines = [...inProgress, ...recent];
  const newestTsMs = liveLines.reduce((latest, line) => Math.max(latest, line.tsMs || 0), 0);
  if (!isCw || liveLines.length === 0 || newestTsMs <= cwBarDismissedAtMs) {
    cwBarOverlay.style.display = "none";
@@ -413,7 +402,7 @@ function resetCwHistoryView(): void {
  if (cwOutputEl) cwOutputEl.innerHTML = "";
  cwLastAppendTime = 0;
  cwBarHistory = [];
-  cwBarCurrentLines.clear();
+  cwBarCurrentLine = null;
  updateCwBar();
  drawCwTonePicker();
 }
@@ -432,13 +421,8 @@ document.getElementById("settings-clear-cw-history")?.addEventListener("click",
 // --- Server-side CW decode handler ---
 function onServerCw(evt: CwEvent): void {
-  // The panel is a single stream of copied text: characters from a background
+  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
-  // rig do not belong in it at all, and interleaving them would make both
+  if (evt.text && cwOutputEl) {
  // rigs unreadable.  The bar histories below keep every rig, each on its own
  // line, and pick out the selected rig when they paint.
  const forSelectedRig = isActiveRigDecode(evt.rig_id ?? null);
  if (cwStatusEl && forSelectedRig) cwStatusEl.textContent = "Receiving";
  if (evt.text && cwOutputEl && forSelectedRig) {
    // Append decoded text to output
    const now = Date.now();
    if (!cwOutputEl.lastElementChild || now - cwLastAppendTime > 10000 || evt.text === "\n") {
@@ -461,29 +445,25 @@ function onServerCw(evt: CwEvent): void {
  // Bar history accumulation (regardless of pause state)
  if (evt.text) {
    const now = Date.now();
    const rigId = evt.rig_id ?? null;
    const key = rigId ?? "";
    if (evt.text === "\n") {
-      cwBarFlushCurrentLine(key);
+      cwBarFlushCurrentLine();
    } else {
-      let line = cwBarCurrentLines.get(key);
+      if (!cwBarCurrentLine || now - cwBarCurrentLine.lastMs > CW_BAR_LINE_GAP_MS) {
-      if (!line || now - line.lastMs > CW_BAR_LINE_GAP_MS) {
+        cwBarFlushCurrentLine();
        cwBarFlushCurrentLine(key);
        const ts = new Date(now).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-        line = { rigId, tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
+        cwBarCurrentLine = { tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
        cwBarCurrentLines.set(key, line);
      }
-      line.text += evt.text;
+      cwBarCurrentLine.text += evt.text;
-      line.lastMs = now;
+      cwBarCurrentLine.lastMs = now;
-      if (Number.isFinite(Number(evt.wpm))) line.wpm = clampCwWpm(evt.wpm);
+      if (Number.isFinite(Number(evt.wpm))) cwBarCurrentLine.wpm = clampCwWpm(evt.wpm);
-      if (Number.isFinite(Number(evt.tone_hz))) line.tone_hz = Math.round(Number(evt.tone_hz));
+      if (Number.isFinite(Number(evt.tone_hz))) cwBarCurrentLine.tone_hz = Math.round(Number(evt.tone_hz));
    }
    updateCwBar();
  }
-  if (cwSignalIndicator && forSelectedRig) {
+  if (cwSignalIndicator) {
    cwSignalIndicator.className = evt.signal_on ? "cw-signal-on" : "cw-signal-off";
  }
-  if (forSelectedRig && (!cwAutoInput || cwAutoInput.checked)) {
+  if (!cwAutoInput || cwAutoInput.checked) {
    if (cwWpmInput && Number.isFinite(Number(evt.wpm))) {
      cwWpmInput.value = String(clampCwWpm(evt.wpm));
    }
@@ -511,13 +491,6 @@ cwWindow.trxPluginRuntime.registerDecoder({
  onMessage: onServerCw,
  restore: restoreCwHistory,
  reset: resetCwHistoryView,
  // The copied text of a rig that is no longer on screen cannot be unpicked
  // from the pane, so the switch starts the new rig's stream from empty.
  rerender: () => {
    if (cwOutputEl) cwOutputEl.innerHTML = "";
    cwLastAppendTime = 0;
    updateCwBar();
  },
 });
 cwWindow.refreshCwTonePicker = function refreshCwTonePicker() {
@@ -4,7 +4,6 @@
 import { hostCore } from "./host.js";
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
 export type FtxDecoderId = "ft2" | "ft4" | "ft8";
@@ -16,7 +15,6 @@ export interface FtxMessage {
  snr_db?: number | undefined;
  dt_s?: number | undefined;
  freq_hz?: number | undefined;
  rig_id?: string | null | undefined;
  receiver?: unknown;
  [key: string]: unknown;
 }
@@ -49,8 +47,6 @@ interface FtxBridge {
  updateFt8Bar?: () => void;
  registerFt8FamilyBarRenderer?: (decoder: FtxDecoderId, renderer: () => BarFrames) => void;
  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<void>;
  /** Opens a log entry from a decode. Pre-fills it; never logs by itself. */
  logContact?: (seed: { call?: string; gridsquare?: string | undefined; decoder?: string }) => void;
  trxUi: ConfirmApi;
  clearFt8Bar?: () => void;
  closeFt8Bar?: () => void;
@@ -226,37 +222,14 @@ export function initializeFtxDecoder(config: FtxConfig): void {
      hour: "2-digit", minute: "2-digit", second: "2-digit",
    });
    row.innerHTML = `<span class="ft8-time">${time}</span><span class="ft8-snr">${snr?.toFixed(1) ?? "--"}</span><span class="ft8-dt">${delta?.toFixed(2) ?? "--"}</span><span class="ft8-freq">${frequency?.toFixed(0) ?? "--"}</span><span class="ft8-msg">${renderMessage(raw)}</span>`;
    // A decode is not a contact: this opens an entry with what was heard in it
    // and leaves the logging to the operator.
    const station = bridge.ft8ExtractLikelyCallsign?.(raw) ?? extractFtxCallsign(raw);
    if (station) {
      const log = document.createElement("button");
      log.type = "button";
      log.className = "ft8-log-btn";
      log.textContent = "Log";
      log.title = `Start a log entry for ${station}`;
      log.addEventListener("click", (event) => {
        event.stopPropagation();
        const details = bridge.ft8ExtractLocatorDetails?.(raw) ?? extractFtxLocatorDetails(raw);
        bridge.logContact?.({
          call: station,
          gridsquare: details.find((detail) => detail.station === station)?.grid,
          decoder: id,
        });
      });
      row.appendChild(log);
    }
    return row;
  };
  const render = (): void => {
    prune();
    if (!messagesElement) return;
    // The history holds every rig's decodes, for the map; the panel is about
    // the rig the operator is working.
    const rigMessages = forActiveRig(history);
    const fragment = document.createDocumentFragment();
    let count = 0;
-    for (const message of rigMessages) {
+    for (const message of history) {
      if (count >= 200) break;
      if (filterText && !(message.message ?? "").toUpperCase().includes(filterText)) continue;
      fragment.appendChild(renderRow(message));
@@ -264,32 +237,20 @@ export function initializeFtxDecoder(config: FtxConfig): void {
    }
    messagesElement.replaceChildren(fragment);
  };
-  /** Hands a decode's grid squares to the map, if the map module is loaded yet.
+  const normalize = (message: FtxMessage): FtxMessage => {
   *  Split out of normalize so a decode can be replayed onto a map that
   *  arrived later: the module is lazy, and everything decoded before it
   *  loaded had nowhere to go. */
  const plotLocator = (message: FtxMessage): void => {
    const raw = message.message ?? "";
    const locatorDetails = bridge.ft8ExtractLocatorDetails?.(raw) ?? extractFtxLocatorDetails(raw);
    const grids = locatorDetails.length > 0
      ? locatorDetails.map(({ grid }) => grid)
      : bridge.ft8ExtractAllGrids?.(raw) ?? extractFtxGrids(raw);
    if (grids.length === 0) return;
    const station = bridge.ft8ExtractLikelyCallsign?.(raw) ?? extractFtxCallsign(raw);
    // Already an RF frequency on a replay, an audio offset on arrival; the
    // conversion only fires below 100 kHz, so it is right either way.
    const frequency = displayFrequency(message.freq_hz);
-    bridge.mapAddLocator?.(raw, grids, id, station, {
+    if (grids.length > 0) {
-      ...message, freq_hz: frequency ?? message.freq_hz, locator_details: locatorDetails,
+      bridge.mapAddLocator?.(raw, grids, id, station, {
-    });
+        ...message, freq_hz: frequency ?? message.freq_hz, locator_details: locatorDetails,
-  };
+      });
-  const normalize = (message: FtxMessage): FtxMessage => {
+    }
    const frequency = displayFrequency(message.freq_hz);
    plotLocator(message);
    return {
      // The rig that heard it, kept so the mini view can tell a decode of the
      // rig on screen from one a background rig made on another band.
      rig_id: message.rig_id ?? null,
      receiver: bridge.getDecodeRigMeta?.() ?? null,
      ts_ms: message.ts_ms,
      snr_db: message.snr_db,
@@ -301,10 +262,7 @@ export function initializeFtxDecoder(config: FtxConfig): void {
  };
  const receiveBatch = (messages: FtxMessage[]): void => {
    if (messages.length === 0) return;
-    // "Receiving" is the panel's own status, and the panel is the rig's.
+    if (status) status.textContent = "Receiving";
    if (status && messages.some((message) => isActiveRigDecode(message.rig_id))) {
      status.textContent = "Receiving";
    }
    history = messages.map(normalize).reverse().concat(history);
    prune();
    bridge.setFt8FamilyBarDecoder?.(id);
@@ -319,8 +277,7 @@ export function initializeFtxDecoder(config: FtxConfig): void {
  };
  const barFrames = (): BarFrames => {
    const recent = history
-      .filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 900_000
+      .filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 900_000)
        && isActiveRigDecode(message.rig_id))
      .slice(0, 8);
    let html = "";
    for (const message of recent) {
@@ -342,9 +299,6 @@ export function initializeFtxDecoder(config: FtxConfig): void {
    restore: receiveBatch,
    prune: () => { prune(); render(); },
    reset,
    rerender: () => { bridge.updateFt8Bar?.(); render(); },
    // Oldest first, so the map builds the grids up in the order they were heard.
    syncMap: () => { for (const message of [...history].reverse()) plotLocator(message); },
  });
  bridge.registerFt8FamilyBarRenderer?.(id, barFrames);
@@ -4,13 +4,15 @@
 import { hostCore, hostState } from "./host.js";
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import {
  aprsAgeText,
  aprsCategoryLabel,
  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsPacketRow,
+  renderAprsInfo,
  renderLocalAprsSymbol,
  type AprsPacket,
  type AprsTypeFilter,
 } from "./aprs-shared";
@@ -20,17 +22,12 @@ interface HfAprsBridge {
  getDecodeHistoryRetentionMs?: () => number;
  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
  navigateToAprsMap?: (lat: number, lon: number) => void;
  aprsMapAddStation?: (
    call: string, lat: number, lon: number, info: string,
    symbolTable: string | null | undefined, symbolCode: string | null | undefined,
    packet: AprsPacket, source: "aprs" | "hf_aprs",
  ) => void;
  clearMapMarkersByType?: (type: string) => void;
  getDecodeRigMeta?: () => unknown;
  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<unknown>;
  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
 }
 const hfAprsWindow = window as unknown as HfAprsBridge;
 const escapeHfAprsHtml = (input: string): string => hostCore.escapeMapHtml(input);
 // --- HF APRS Decoder Plugin (server-side decode, 300 baud) ---
 const hfAprsStatus = document.getElementById("hf-aprs-status");
@@ -97,31 +94,23 @@ function hfAprsFilterMatch(pkt: AprsPacket): boolean {
  return haystack.includes(hfAprsFilterText);
 }
 /** What the selected rig heard.  The history holds every rig's traffic, for
 *  the map; the panel is about the rig the operator is working. */
 function hfAprsRigPackets(): AprsPacket[] {
  return forActiveRig(hfAprsPacketHistory);
 }
 function hfAprsVisiblePackets(): AprsPacket[] {
-  const rigPackets = hfAprsRigPackets();
+  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(hfAprsPacketHistory) : hfAprsPacketHistory;
  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(rigPackets) : rigPackets;
  return packets.filter(hfAprsFilterMatch);
 }
 const collapseHfAprsDuplicates = collapseAprsDuplicates;
 function updateHfAprsSummary() {
  const rigPackets = hfAprsRigPackets();
  const visible = hfAprsVisiblePackets();
  if (hfAprsTotalCountEl) {
-    hfAprsTotalCountEl.textContent = `${rigPackets.length} total`;
+    hfAprsTotalCountEl.textContent = `${hfAprsPacketHistory.length} total`;
  }
  if (hfAprsVisibleCountEl) {
    hfAprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (hfAprsLatestSeenEl) {
-    const latest = rigPackets[0];
+    const latest = hfAprsPacketHistory[0];
    if (!latest) {
      hfAprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -139,27 +128,95 @@ function updateHfAprsChipState() {
  hfAprsCollapseDupBtn?.classList.toggle("active", hfAprsCollapseDup);
 }
 // HF traffic goes in the same row as VHF, marked with the band it came in on.
 // This was a second copy of the same forty lines of markup.
 function renderHfAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
-  return renderAprsPacketRow(pkt, {
+  const row = document.createElement("div");
-    fresh: isFresh,
+  row.className = "aprs-packet";
-    badge: "HF",
+  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-    distance: hfAprsDistanceText(pkt),
+  if (isFresh) row.classList.add("aprs-packet-new");
    onMap: (lat: number, lon: number) => { hfAprsWindow.navigateToAprsMap?.(lat, lon); },
    onCopy: (text: string) => { void copyHfAprsCoords(text); },
  });
 }
-async function copyHfAprsCoords(text: string): Promise<void> {
+  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  try {
+  const age = aprsAgeText(pkt._tsMs);
-    const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
+  const category = aprsPacketCategory(pkt);
-    if (!clipboard) return;
+  const categoryLabel = aprsCategoryLabel(category);
-    await clipboard.writeText(text);
+  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-    hostCore.showHint("Coordinates copied", 1200);
+  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeHfAprsHtml(pkt.path)}</span>` : "";
-  } catch {
+  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-    hostCore.showHint("Copy failed", 1500);
+  const hfBadge = '<span class="aprs-badge" style="background:var(--accent-alt,#f59e0b);color:#000">HF</span>';
  const symbolHtml = renderLocalAprsSymbol(pkt, escapeHfAprsHtml);
  const posLink = pkt.lat != null && pkt.lon != null
    ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>`
    : "";
  const distance = hfAprsDistanceText(pkt);
  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
  row.innerHTML =
    `<div class="aprs-row-head">` +
      `<span class="aprs-time">${ts}</span>` +
      hfBadge +
      symbolHtml +
      `<span class="aprs-call">${escapeHfAprsHtml(pkt.srcCall ?? "")}</span>` +
      `<span>&gt;${escapeHfAprsHtml(pkt.destCall || "")}</span>` +
      `<span class="${categoryClass}">${escapeHfAprsHtml(categoryLabel)}</span>` +
      pathBadge +
      crcBadge +
    `</div>` +
    `<div class="aprs-row-meta">` +
      `<span class="aprs-meta-text">${escapeHfAprsHtml(age)}</span>` +
      (distance ? `<span class="aprs-meta-text">${escapeHfAprsHtml(distance)}</span>` : "") +
      `<span class="aprs-meta-text">${escapeHfAprsHtml(pkt.type || "--")}</span>` +
    `</div>` +
    `<div class="aprs-row-detail">` +
      `<span title="${escapeHfAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
      (posLink ? `<span>${posLink}</span>` : "") +
    `</div>` +
    `<div class="aprs-row-actions">` +
      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") +
      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") +
      `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
    `</div>` +
    `<details class="aprs-details">` +
      `<summary>Details</summary>` +
      `<div class="aprs-details-grid">` +
        `<span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.srcCall || "--")}</span>` +
        `<span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.destCall || "--")}</span>` +
        `<span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.type || "--")}</span>` +
        `<span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.path || "--")}</span>` +
        `<span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeHfAprsHtml(age)}</span>` +
        `<span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span>` +
        `<span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span>` +
        `<span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.info || "--")}</span>` +
        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeHfAprsHtml(aprsHexBytes(pkt.info_bytes))}</span>` +
      `</div>` +
    `</details>`;
  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((el) => {
    el.addEventListener("click", (evt) => {
      evt.preventDefault();
      const raw = el.dataset.aprsMap ?? "";
      const [lat, lon] = raw.split(",").map(Number);
      if (hfAprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
        hfAprsWindow.navigateToAprsMap(lat, lon);
      }
    });
  });
  const copyBtn = row.querySelector<HTMLElement>("[data-aprs-copy]");
  if (copyBtn) {
    copyBtn.addEventListener("click", () => { void (async () => {
      const raw = copyBtn.dataset.aprsCopy ?? "";
      try {
        const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
        if (clipboard) {
          await clipboard.writeText(raw);
          hostCore.showHint("Coordinates copied", 1200);
        }
      } catch {
        hostCore.showHint("Copy failed", 1500);
      }
    })(); });
  }
  return row;
 }
 function renderHfAprsHistory() {
@@ -183,7 +240,6 @@ function resetHfAprsHistoryView(): void {
  if (hfAprsPacketsEl) hfAprsPacketsEl.innerHTML = "";
  hfAprsPacketHistory = [];
  renderHfAprsHistory();
  hfAprsWindow.clearMapMarkersByType?.("hf_aprs");
 }
 function pruneHfAprsHistoryView(): void {
@@ -191,17 +247,6 @@ function pruneHfAprsHistoryView(): void {
  renderHfAprsHistory();
 }
 /** Hands a positioned packet to the map, if the map module is loaded yet.
 *  HF traffic goes on as its own source: it is a different band and a
 *  different path, and the map filter offers it separately. */
 function plotHfAprsPacket(pkt: AprsPacket): void {
  if (pkt.lat == null || pkt.lon == null || !hfAprsWindow.aprsMapAddStation) return;
  hfAprsWindow.aprsMapAddStation(
    pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "",
    pkt.symbolTable, pkt.symbolCode, pkt, "hf_aprs",
  );
 }
 function addHfAprsPacket(pkt: AprsPacket): void {
  const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
  pkt._tsMs = tsMs;
@@ -210,8 +255,6 @@ function addHfAprsPacket(pkt: AprsPacket): void {
  hfAprsPacketHistory.unshift(pkt);
  pruneHfAprsPacketHistory();
  plotHfAprsPacket(pkt);
  scheduleHfAprsHistoryRender();
 }
@@ -221,15 +264,13 @@ function normalizeServerHfAprsPacket(pkt: AprsPacket): AprsPacket {
 function onServerHfAprsBatch(packets: AprsPacket[]): void {
  if (!Array.isArray(packets) || packets.length === 0) return;
  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
  const normalized: AprsPacket[] = [];
  for (const pkt of packets) {
    const next = normalizeServerHfAprsPacket(pkt);
    // "Receiving" is the panel's own status, and the panel is the rig's.
    if (hfAprsStatus && isActiveRigDecode(next.rig_id)) hfAprsStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
    plotHfAprsPacket(next);
    normalized.push(next);
  }
  normalized.reverse();
@@ -297,9 +338,8 @@ if (hfAprsFilterInput) {
 // --- Server-side HF APRS decode handler ---
 function onServerHfAprs(pkt: AprsPacket): void {
-  const packet = normalizeServerHfAprsPacket(pkt);
+  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  if (hfAprsStatus && isActiveRigDecode(packet.rig_id)) hfAprsStatus.textContent = "Receiving";
+  addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
  addHfAprsPacket(packet);
 }
 renderHfAprsHistory();
@@ -310,7 +350,4 @@ renderHfAprsHistory();
  restore: onServerHfAprsBatch,
  reset: resetHfAprsHistoryView,
  prune: pruneHfAprsHistoryView,
  rerender: renderHfAprsHistory,
  // Oldest first, so station tracks are rebuilt in the order they happened.
  syncMap: () => { for (const entry of [...hfAprsPacketHistory].reverse()) plotHfAprsPacket(entry); },
 });
@@ -11,8 +11,6 @@
 // feature bundles from re-deriving it — and from drifting back to bare `window`
 // properties, which the module graph no longer publishes.
 import type { AuthRole } from "../api/auth.js";
 export interface HostDecoderDescriptor {
  id: string;
  label: string;
@@ -24,10 +22,8 @@ export interface HostDecoderDescriptor {
 export interface HostState {
  readonly serverLat: number | null;
  readonly serverLon: number | null;
  /** The callsign this station is on the air with, from the client config. */
  readonly ownerCallsign: string | null;
  readonly authEnabled: boolean;
-  readonly authRoles: readonly AuthRole[];
+  readonly authRole: string | null;
  readonly lastActiveRigId: string | null;
  readonly lastRigIds: string[];
  readonly lastRigDisplayNames: Record<string, string>;
@@ -47,7 +43,6 @@ export interface HostCore {
  armOptimisticFrequency(frequencyHz: number): void;
  escapeMapHtml(value: string): string;
  haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number;
  latLonToMaidenhead(lat: number, lon: number): string;
  showHint(message: string, durationMs?: number): void;
  formatFreqForStep(frequencyHz: number, stepHz: number): string;
  refreshFreqDisplay(): void;
@@ -64,8 +59,6 @@ export interface HostCore {
  setRigFrequency(frequencyHz: number): void;
  syncBandwidthInput(bandwidthHz: number): void;
  scheduleSpectrumDraw(): void;
  /** Repaints the mode buttons from #mode after writing to it. */
  syncModePicker(): void;
  onDecoderRegistryReady(callback: () => void): void;
 }
@@ -1,577 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 // The station log: one panel that opens an entry, keeps the log, and takes
 // ADIF in and out.
 //
 // Times come from the server, never from here. The browser may be a phone in
 // another timezone with a clock nobody has checked, and a log is only worth
 // keeping if the times in it are the radio's.
 import { hostCore, hostState } from "./host.js";
 import { hasAuthRole } from "../api/auth.js";
 export {};
 interface Qso {
  id: string;
  started_at: string;
  call: string;
  freq_hz: number;
  band?: string | null;
  mode: string;
  submode?: string | null;
  rst_sent?: string | null;
  rst_rcvd?: string | null;
  gridsquare?: string | null;
  name?: string | null;
  qth?: string | null;
  comment?: string | null;
  station_callsign?: string | null;
  operator?: string | null;
  my_gridsquare?: string | null;
  my_rig?: string | null;
  rig_id?: string | null;
  contest_id?: string | null;
  stx?: number | null;
  srx?: number | null;
  srx_string?: string | null;
  qsl_rcvd?: string | null;
  lotw_qsl_rcvd?: string | null;
  confirmed?: boolean;
 }
 interface BandStatistics {
  band: string;
  contacts: number;
  stations: number;
  confirmed: number;
 }
 interface Prefill {
  started_at: string;
  epoch_ms: number;
  freq_hz: number;
  band: string | null;
  mode: string;
  submode: string | null;
  rig_id: string | null;
  my_rig: string | null;
  call: string | null;
  gridsquare: string | null;
 }
 interface LogbookBridge {
  trxUi: {
    confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean>;
    notify?(message: string, options?: { kind?: string }): void;
  };
  navigateToTab?: (name: string) => void;
  /** Opens the panel with an entry started from a decode. */
  logContact?: (seed: { call?: string; gridsquare?: string | undefined; decoder?: string }) => void;
 }
 const bridge = window as unknown as LogbookBridge;
 const el = <T extends HTMLElement>(id: string): T | null => document.getElementById(id) as T | null;
 const form = el<HTMLFormElement>("log-entry-form");
 const callInput = el<HTMLInputElement>("log-call");
 const freqInput = el<HTMLInputElement>("log-freq");
 const modeInput = el<HTMLInputElement>("log-mode");
 const rstSentInput = el<HTMLInputElement>("log-rst-sent");
 const rstRcvdInput = el<HTMLInputElement>("log-rst-rcvd");
 const gridInput = el<HTMLInputElement>("log-grid");
 const nameInput = el<HTMLInputElement>("log-name");
 const commentInput = el<HTMLInputElement>("log-comment");
 const operatorInput = el<HTMLInputElement>("log-operator");
 const rowsBody = el<HTMLTableSectionElement>("log-rows");
 const summaryEl = el("log-summary");
 const workedEl = el("log-worked-before");
 const clockEl = el("log-clock");
 const stationCallEl = el("log-station-callsign");
 const stationRigEl = el("log-station-rig-name");
 const stationGridEl = el("log-station-grid");
 const filterCall = el<HTMLInputElement>("log-filter-call");
 const filterBand = el<HTMLSelectElement>("log-filter-band");
 const filterMode = el<HTMLSelectElement>("log-filter-mode");
 const importBtn = el<HTMLButtonElement>("log-import-btn");
 const importFile = el<HTMLInputElement>("log-import-file");
 const exportLink = el<HTMLAnchorElement>("log-export-btn");
 const clearBtn = el<HTMLButtonElement>("log-clear-btn");
 const saveBtn = el<HTMLButtonElement>("log-save-btn");
 const contestIdInput = el<HTMLInputElement>("log-contest-id");
 const stxInput = el<HTMLInputElement>("log-stx");
 const srxInput = el<HTMLInputElement>("log-srx");
 const statisticsRows = el<HTMLTableSectionElement>("log-statistics-rows");
 const cabrilloContest = el<HTMLInputElement>("log-cbr-contest");
 const cabrilloCallsign = el<HTMLInputElement>("log-cbr-callsign");
 const cabrilloOperator = el<HTMLSelectElement>("log-cbr-operator");
 const cabrilloPower = el<HTMLSelectElement>("log-cbr-power");
 const cabrilloScore = el<HTMLInputElement>("log-cbr-score");
 const cabrilloExport = el<HTMLAnchorElement>("log-cbr-export");
 /** The time the open entry was started, as the server gave it. */
 let entryStartedAt: string | null = null;
 /** The rig the open entry belongs to, likewise. */
 let entryRigId: string | null = null;
 let entryRigName: string | null = null;
 let entryGrid: string | null = null;
 let qsos: Qso[] = [];
 let workedRequest = 0;
 function canWriteLogbook(): boolean {
  return !hostState.authEnabled
    || hasAuthRole(hostState.authRoles, "write");
 }
 function notify(message: string, kind?: string): void {
  if (bridge.trxUi.notify) bridge.trxUi.notify(message, kind ? { kind } : undefined);
  else hostCore.showHint(message, 2000);
 }
 async function getJson<T>(path: string): Promise<T> {
  const response = await fetch(path);
  if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
  return await response.json() as T;
 }
 function formatFreq(hz: number): string {
  if (!Number.isFinite(hz) || hz <= 0) return "";
  // Through Number, not a trailing-zero trim: trimming "20.000000" as a string
  // walks back through the point and leaves "2".
  return String(Number((hz / 1e6).toFixed(6)));
 }
 /** What the operator typed, in Hz: MHz unless it is plainly already Hz. */
 function parseFreq(text: string): number | null {
  const value = Number(text.trim().replace(/\s+/g, "").replace(",", "."));
  if (!Number.isFinite(value) || value <= 0) return null;
  return value < 100_000 ? Math.round(value * 1e6) : Math.round(value);
 }
 /** A serial, or null when the exchange is a word rather than a number. */
 function numberOrNull(text: string | undefined): number | null {
  const trimmed = (text ?? "").trim();
  if (!trimmed || !/^\d+$/.test(trimmed)) return null;
  const value = Number(trimmed);
  return Number.isSafeInteger(value) ? value : null;
 }
 function utcDate(iso: string): string {
  const date = new Date(iso);
  return Number.isNaN(date.getTime()) ? "" : date.toISOString().slice(0, 10);
 }
 function utcTime(iso: string): string {
  const date = new Date(iso);
  return Number.isNaN(date.getTime()) ? "" : date.toISOString().slice(11, 19);
 }
 // ── The entry ───────────────────────────────────────────────────────────────
 /** Open an entry, pre-filled with the six fields the radio and clock answer. */
 async function openEntry(
  seed: { call?: string; gridsquare?: string | undefined; decoder?: string } = {},
 ): Promise<void> {
  const params = new URLSearchParams();
  if (hostState.lastActiveRigId) params.set("remote", hostState.lastActiveRigId);
  if (seed.decoder) params.set("decoder", seed.decoder);
  if (seed.call) params.set("call", seed.call);
  if (seed.gridsquare) params.set("gridsquare", seed.gridsquare);
  try {
    const prefill = await getJson<Prefill>(`/api/logbook/prefill?${params.toString()}`);
    applyPrefill(prefill);
  } catch (error: unknown) {
    console.error("logbook prefill failed", error);
  }
 }
 function applyPrefill(prefill: Prefill): void {
  entryStartedAt = prefill.started_at;
  entryRigId = prefill.rig_id;
  entryRigName = prefill.my_rig;
  if (freqInput) freqInput.value = formatFreq(prefill.freq_hz);
  if (modeInput) modeInput.value = prefill.submode ?? prefill.mode;
  if (callInput && prefill.call) callInput.value = prefill.call;
  if (gridInput && prefill.gridsquare) gridInput.value = prefill.gridsquare;
  if (stationRigEl) stationRigEl.textContent = prefill.my_rig ?? "no rig";
  showClock(prefill);
  updateWorkedBefore();
 }
 /** The entry's time, and whether this browser agrees with it. */
 function showClock(prefill: Prefill): void {
  if (!clockEl) return;
  const time = utcTime(prefill.started_at);
  const drift = Math.abs(Date.now() - prefill.epoch_ms);
  clockEl.textContent = drift > 1000
    ? `${time}Z · your clock is ${(drift / 1000).toFixed(0)}s out`
    : `${time}Z`;
  clockEl.classList.toggle("is-adrift", drift > 1000);
 }
 /** Clear the entry and open a fresh one. */
 function resetEntry(): void {
  // The contest and the serial sent stay: they belong to the session, not to
  // the contact just logged.
  for (const input of [callInput, rstSentInput, rstRcvdInput, gridInput, nameInput, commentInput, srxInput]) {
    if (input) input.value = "";
  }
  if (workedEl) workedEl.textContent = "";
  void openEntry();
 }
 async function submitEntry(event: Event): Promise<void> {
  event.preventDefault();
  const call = callInput?.value.trim() ?? "";
  if (!call) {
    notify("A contact needs a callsign", "error");
    callInput?.focus();
    return;
  }
  const freqHz = parseFreq(freqInput?.value ?? "");
  if (freqHz == null) {
    notify("A contact needs a frequency", "error");
    freqInput?.focus();
    return;
  }
  const typedMode = (modeInput?.value ?? "").trim().toUpperCase();
  // USB and LSB are how a rig says SSB; the log wants the mode with the
  // sideband beside it, which is what other loggers read.
  const isSideband = typedMode === "USB" || typedMode === "LSB";
  const body = {
    // The server stamps the time; this is the one it gave when the entry
    // opened, so a contact logged five minutes later keeps the time it started.
    started_at: entryStartedAt,
    call,
    freq_hz: freqHz,
    mode: isSideband ? "SSB" : typedMode,
    submode: isSideband ? typedMode : null,
    rst_sent: rstSentInput?.value ?? null,
    rst_rcvd: rstRcvdInput?.value ?? null,
    gridsquare: gridInput?.value ?? null,
    name: nameInput?.value ?? null,
    comment: commentInput?.value ?? null,
    contest_id: contestIdInput?.value ?? null,
    // The exchange is a number when it is a serial and a word when it is a
    // zone or a section; both are kept, and the log writes whichever it has.
    stx: numberOrNull(stxInput?.value),
    stx_string: numberOrNull(stxInput?.value) == null ? stxInput?.value ?? null : null,
    srx: numberOrNull(srxInput?.value),
    srx_string: numberOrNull(srxInput?.value) == null ? srxInput?.value ?? null : null,
    station_callsign: stationCallEl?.textContent?.trim() ?? null,
    operator: operatorInput?.value ?? null,
    my_gridsquare: entryGrid,
    my_rig: entryRigName,
    rig_id: entryRigId,
  };
  if (saveBtn) saveBtn.disabled = true;
  try {
    const response = await fetch("/api/logbook", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    });
    if (!response.ok) {
      const detail = await response.json().catch(() => ({})) as { error?: string };
      throw new Error(detail.error ?? `HTTP ${String(response.status)}`);
    }
    notify(`${call} logged`);
    // A contest runs on serials: the next one is this one plus one, so it is
    // not retyped forty times an hour.
    const sent = numberOrNull(stxInput?.value);
    resetEntry();
    if (stxInput && sent != null) stxInput.value = String(sent + 1);
    await refreshLog();
  } catch (error: unknown) {
    notify(`Could not log: ${error instanceof Error ? error.message : String(error)}`, "error");
  } finally {
    if (saveBtn) saveBtn.disabled = false;
  }
 }
 /** Whether this station has been worked, and on what. */
 function updateWorkedBefore(): void {
  if (!workedEl) return;
  const call = callInput?.value.trim() ?? "";
  if (call.length < 3) {
    workedEl.textContent = "";
    return;
  }
  const request = ++workedRequest;
  void getJson<{ worked: { band: string; mode: string }[] }>(
    `/api/logbook/worked/${encodeURIComponent(call)}`,
  ).then((answer) => {
    // A slower answer to an earlier callsign must not overwrite a later one.
    if (request !== workedRequest || !workedEl) return;
    if (answer.worked.length === 0) {
      workedEl.textContent = "Not worked before";
      workedEl.classList.remove("is-worked");
      return;
    }
    const where = answer.worked.map((entry) => `${entry.band} ${entry.mode}`).join(", ");
    workedEl.textContent = `Worked before: ${where}`;
    workedEl.classList.add("is-worked");
  }).catch(() => { /* the log will still take the contact */ });
 }
 // ── The log ─────────────────────────────────────────────────────────────────
 function currentQuery(): string {
  const params = new URLSearchParams();
  const call = filterCall?.value.trim();
  if (call) params.set("call", call);
  if (filterBand?.value) params.set("band", filterBand.value);
  if (filterMode?.value) params.set("mode", filterMode.value);
  return params.toString();
 }
 async function refreshLog(): Promise<void> {
  try {
    const query = currentQuery();
    const answer = await getJson<{ total: number; qsos: Qso[] }>(
      `/api/logbook${query ? `?${query}` : ""}`,
    );
    qsos = answer.qsos;
    renderRows();
    renderFilterOptions();
    if (summaryEl) {
      summaryEl.textContent = query
        ? `${String(qsos.length)} of ${String(answer.total)} contacts`
        : `${String(answer.total)} contact${answer.total === 1 ? "" : "s"}`;
    }
    if (exportLink) exportLink.href = `/api/logbook/export.adi${query ? `?${query}` : ""}`;
    await refreshStatistics();
  } catch (error: unknown) {
    console.error("logbook read failed", error);
  }
 }
 /** What has been worked and confirmed, band by band. */
 async function refreshStatistics(): Promise<void> {
  if (!statisticsRows) return;
  try {
    const answer = await getJson<{ bands: BandStatistics[] }>("/api/logbook/statistics");
    if (answer.bands.length === 0) {
      statisticsRows.innerHTML = '<tr><td colspan="4" class="log-empty">Nothing worked yet.</td></tr>';
      return;
    }
    const fragment = document.createDocumentFragment();
    for (const band of answer.bands) {
      const row = document.createElement("tr");
      for (const value of [band.band, band.contacts, band.stations, band.confirmed]) {
        const cell = document.createElement("td");
        cell.textContent = String(value);
        row.appendChild(cell);
      }
      fragment.appendChild(row);
    }
    statisticsRows.replaceChildren(fragment);
  } catch (error: unknown) {
    console.error("logbook statistics failed", error);
  }
 }
 /** The Cabrillo link, carrying the header the operator filled in. */
 function syncCabrilloLink(): void {
  if (!cabrilloExport) return;
  const params = new URLSearchParams();
  const contest = cabrilloContest?.value.trim();
  if (contest) {
    // Only that contest's contacts belong in the entry.
    params.set("contest", contest);
  }
  const callsign = cabrilloCallsign?.value.trim() || (stationCallEl?.textContent?.trim() ?? "");
  if (callsign) params.set("callsign", callsign);
  if (cabrilloOperator?.value) params.set("category_operator", cabrilloOperator.value);
  if (cabrilloPower?.value) params.set("category_power", cabrilloPower.value);
  const score = numberOrNull(cabrilloScore?.value);
  if (score != null) params.set("claimed_score", String(score));
  const operator = operatorInput?.value.trim();
  if (operator) params.set("operators", operator);
  cabrilloExport.href = `/api/logbook/export.cbr?${params.toString()}`;
 }
 function renderRows(): void {
  if (!rowsBody) return;
  if (qsos.length === 0) {
    rowsBody.innerHTML =
      '<tr><td colspan="10" class="log-empty">No contacts yet. Work someone and log them here,'
      + " or bring a log in with Import ADIF.</td></tr>";
    return;
  }
  const fragment = document.createDocumentFragment();
  for (const qso of qsos) {
    const row = document.createElement("tr");
    row.dataset.qsoId = qso.id;
    const cells: (string | null | undefined)[] = [
      utcDate(qso.started_at),
      utcTime(qso.started_at),
      qso.call,
      qso.band ?? "",
      qso.submode ?? qso.mode,
      qso.rst_sent ?? "",
      qso.rst_rcvd ?? "",
      qso.gridsquare ?? "",
      qso.my_rig ?? "",
      qso.confirmed ? "✓" : "",
    ];
    for (const [index, value] of cells.entries()) {
      const cell = document.createElement("td");
      cell.textContent = value ?? "";
      if (index === 2) cell.className = "log-cell-call";
      row.appendChild(cell);
    }
    const actions = document.createElement("td");
    if (!canWriteLogbook()) {
      row.appendChild(actions);
      fragment.appendChild(row);
      continue;
    }
    // Confirming is the commonest edit a log gets, so it is a button rather
    // than a form: a card arrives, and the contact counts towards an award.
    const confirm = document.createElement("button");
    confirm.type = "button";
    confirm.className = "log-row-btn";
    confirm.textContent = qso.confirmed ? "Unconfirm" : "Confirm";
    confirm.title = qso.confirmed
      ? "Mark this contact as not confirmed"
      : "Mark this contact confirmed by QSL";
    confirm.addEventListener("click", () => { void setConfirmed(qso, !qso.confirmed); });
    actions.appendChild(confirm);
    const remove = document.createElement("button");
    remove.type = "button";
    remove.className = "log-row-btn";
    remove.textContent = "Delete";
    remove.setAttribute("aria-label", `Delete the contact with ${qso.call}`);
    remove.addEventListener("click", () => { void deleteQso(qso); });
    actions.appendChild(remove);
    row.appendChild(actions);
    fragment.appendChild(row);
  }
  rowsBody.replaceChildren(fragment);
 }
 /** Bands and modes the log actually holds, so the filters offer only those. */
 function renderFilterOptions(): void {
  for (const [select, values] of [
    [filterBand, [...new Set(qsos.map((q) => q.band).filter((b): b is string => !!b))]],
    [filterMode, [...new Set(qsos.map((q) => q.submode ?? q.mode).filter(Boolean))]],
  ] as const) {
    if (!select) continue;
    const chosen = select.value;
    const known = new Set([...select.options].map((option) => option.value));
    for (const value of [...values].sort()) {
      if (known.has(value)) continue;
      select.add(new Option(value, value));
    }
    select.value = chosen;
  }
 }
 /** Record, or withdraw, the other station's confirmation. */
 async function setConfirmed(qso: Qso, confirmed: boolean): Promise<void> {
  try {
    const response = await fetch(`/api/logbook/${encodeURIComponent(qso.id)}`, {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        ...qso,
        // A card is a card: this is the paper one, and an electronic
        // confirmation the log already holds is left where it is.
        qsl_rcvd: confirmed ? "Y" : "N",
      }),
    });
    if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
    await refreshLog();
  } catch (error: unknown) {
    notify(`Could not update: ${error instanceof Error ? error.message : String(error)}`, "error");
  }
 }
 async function deleteQso(qso: Qso): Promise<void> {
  const confirmed = await bridge.trxUi.confirm({
    title: "Delete this contact?",
    message: `${qso.call} on ${qso.band ?? formatFreq(qso.freq_hz)} will be removed from the log.`,
    confirmLabel: "Delete",
  });
  if (!confirmed) return;
  try {
    const response = await fetch(`/api/logbook/${encodeURIComponent(qso.id)}`, { method: "DELETE" });
    if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
    await refreshLog();
  } catch (error: unknown) {
    notify(`Could not delete: ${error instanceof Error ? error.message : String(error)}`, "error");
  }
 }
 async function importAdif(file: File): Promise<void> {
  try {
    const response = await fetch("/api/logbook/import", { method: "POST", body: await file.arrayBuffer() });
    if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
    const outcome = await response.json() as { added: number; duplicate: number; rejected: string[] };
    const parts = [`${String(outcome.added)} added`];
    if (outcome.duplicate > 0) parts.push(`${String(outcome.duplicate)} already held`);
    if (outcome.rejected.length > 0) parts.push(`${String(outcome.rejected.length)} not readable`);
    notify(parts.join(", "));
    await refreshLog();
  } catch (error: unknown) {
    notify(`Import failed: ${error instanceof Error ? error.message : String(error)}`, "error");
  }
 }
 // ── Station line ────────────────────────────────────────────────────────────
 function renderStation(): void {
  const callsign = hostState.ownerCallsign ?? "";
  if (stationCallEl) stationCallEl.textContent = callsign || "no callsign set";
  if (operatorInput && !operatorInput.value) operatorInput.value = callsign;
  if (stationGridEl) {
    const grid = hostState.serverLat != null && hostState.serverLon != null
      ? hostCore.latLonToMaidenhead(hostState.serverLat, hostState.serverLon)
      : "";
    entryGrid = grid || null;
    stationGridEl.textContent = grid;
  }
 }
 // ── Wiring ──────────────────────────────────────────────────────────────────
 form?.addEventListener("submit", (event) => { void submitEntry(event); });
 clearBtn?.addEventListener("click", resetEntry);
 callInput?.addEventListener("input", updateWorkedBefore);
 for (const control of [filterCall, filterBand, filterMode]) {
  control?.addEventListener("input", () => { void refreshLog(); });
  control?.addEventListener("change", () => { void refreshLog(); });
 }
 for (const control of [cabrilloContest, cabrilloCallsign, cabrilloOperator, cabrilloPower, cabrilloScore]) {
  control?.addEventListener("input", syncCabrilloLink);
  control?.addEventListener("change", syncCabrilloLink);
 }
 importBtn?.addEventListener("click", () => { importFile?.click(); });
 importFile?.addEventListener("change", () => {
  const file = importFile.files?.[0];
  if (file) void importAdif(file);
  importFile.value = "";
 });
 /** Start an entry from a decode, and show the operator where it went. */
 if (canWriteLogbook()) {
  bridge.logContact = (seed) => {
    bridge.navigateToTab?.("logbook");
    void openEntry(seed).then(() => callInput?.focus());
  };
 } else {
  if (form) form.style.display = "none";
  if (importBtn) importBtn.style.display = "none";
 }
 renderStation();
 if (cabrilloCallsign && !cabrilloCallsign.value) {
  cabrilloCallsign.value = stationCallEl?.textContent?.trim() ?? "";
 }
 syncCabrilloLink();
 if (canWriteLogbook()) void openEntry();
 void refreshLog();
@@ -9,13 +9,6 @@ export interface DecoderPlugin<TMessage = unknown> {
  restore?(messages: TMessage[]): void;
  reset?(): void;
  prune?(): void;
  /** Repaint the plugin's panel from what it already holds. Called when the
   *  selected rig changes: the panels show one rig's traffic, and the decodes
   *  behind them arrived long before the switch. */
  rerender?(): void;
  /** Replay everything the plugin is holding onto the map. Called when the map
   *  module attaches, which can happen long after the decodes arrived. */
  syncMap?(): void;
 }
 export interface TrxPluginRuntime {
@@ -26,8 +19,6 @@ export interface TrxPluginRuntime {
  reset(id: string): boolean;
  resetAll(): void;
  prune(id: string): boolean;
  rerenderAll(): void;
  syncMapAll(): void;
  clearQueued(): void;
  hasDecoder(id: string): boolean;
 }
@@ -4,12 +4,13 @@
 import { hostCore } from "./host.js";
-import type { LrptProgress, SatelliteImage, SatelliteLiveUpdate } from "./satellite-types";
+import type { LrptProgress, SatelliteImage, SatelliteLiveUpdate, SatellitePass, SatellitePassResponse } from "./satellite-types";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
-type SatelliteView = "live" | "history";
+type SatelliteView = "live" | "history" | "predictions";
 interface SatelliteBridge {
  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
  clearSatPredictionDom?: () => void;
  updateSatLiveState?: (update: SatelliteLiveUpdate) => void;
  addSatMapOverlay?: (image: SatelliteImage) => void;
  clearSatMapOverlays?: () => void;
@@ -24,14 +25,14 @@ const satWindow = window as unknown as SatelliteBridge & PluginRuntimeWindow;
 // --- SAT Plugin ---
 // Live view: decoder state, latest image card
 // History view: filterable table of all decoded images
-//
+// Predictions view: next 24 h passes for ham satellites
 // Pass predictions live on their own page; see satellite-predictions.ts.
 // ── DOM references (cached once) ───────────────────────────────────
 const satDom = {
  status:           document.getElementById("sat-status"),
  liveView:         document.getElementById("sat-live-view"),
  historyView:      document.getElementById("sat-history-view"),
  predictionsView:  document.getElementById("sat-predictions-view"),
  liveLatest:       document.getElementById("sat-live-latest"),
  historyList:      document.getElementById("sat-history-list"),
  historyCount:     document.getElementById("sat-history-count"),
@@ -41,13 +42,30 @@ const satDom = {
  lrptState:        document.getElementById("sat-lrpt-state"),
  viewLiveBtn:      document.getElementById("sat-view-live"),
  viewHistoryBtn:   document.getElementById("sat-view-history"),
  viewPredBtn:      document.getElementById("sat-view-predictions"),
  predFilter:       document.getElementById("sat-pred-filter") as HTMLInputElement | null,
  predMinEl:        document.getElementById("sat-pred-min-el") as HTMLSelectElement | null,
  predCategory:     document.getElementById("sat-pred-category") as HTMLSelectElement | null,
  predCurrentList:  document.getElementById("sat-pred-current-list"),
  predUpcomingList: document.getElementById("sat-pred-list"),
  predCurrentSec:   document.getElementById("sat-pred-current-section"),
  predUpcomingSec:  document.getElementById("sat-pred-upcoming-section"),
  predStatus:       document.getElementById("sat-pred-status"),
 };
 // ── State ───────────────────────────────────────────────────────────
 let satImageHistory: SatelliteImage[] = [];
 const SAT_MAX_IMAGES = 100;
 const SAT_PRED_PAGE_SIZE = 50;
 let satPredShowAll = false;
 let satFilterText = "";
 let satActiveView: SatelliteView = "live";
 let satPredData: SatellitePass[] = [];
 let satPredFilterText = "";
 let satPredMinEl = 0;
 let satPredCategory = "all";
 let satPredSatCount = 0;
 let satPredCountdownTimer: ReturnType<typeof setInterval> | null = null;
 // ── UI scheduler helper ─────────────────────────────────────────────
 function scheduleSatUi(key: string, job: () => void): void {
@@ -60,16 +78,33 @@ function scheduleSatUi(key: string, job: () => void): void {
 // ── View switching ──────────────────────────────────────────────────
 function switchSatView(view: SatelliteView): void {
  const leavingPredictions = satActiveView === "predictions" && view !== "predictions";
  satActiveView = view;
-  if (satDom.liveView)       satDom.liveView.style.display = view === "live" ? "" : "none";
+  if (satDom.liveView)        satDom.liveView.style.display = view === "live" ? "" : "none";
-  if (satDom.historyView)    satDom.historyView.style.display = view === "history" ? "" : "none";
+  if (satDom.historyView)     satDom.historyView.style.display = view === "history" ? "" : "none";
-  if (satDom.viewLiveBtn)    satDom.viewLiveBtn.classList.toggle("sat-view-active", view === "live");
+  if (satDom.predictionsView) satDom.predictionsView.style.display = view === "predictions" ? "" : "none";
-  if (satDom.viewHistoryBtn) satDom.viewHistoryBtn.classList.toggle("sat-view-active", view === "history");
+  if (satDom.viewLiveBtn)     satDom.viewLiveBtn.classList.toggle("sat-view-active", view === "live");
-  if (view === "history") renderSatHistoryTable();
+  if (satDom.viewHistoryBtn)  satDom.viewHistoryBtn.classList.toggle("sat-view-active", view === "history");
  if (satDom.viewPredBtn)     satDom.viewPredBtn.classList.toggle("sat-view-active", view === "predictions");
  if (leavingPredictions) clearPredictionDom();
  if (view === "history") {
    renderSatHistoryTable();
  } else if (view === "predictions") {
    satPredShowAll = false;
    void loadSatPredictions();
  }
 }
 function clearPredictionDom() {
  stopCountdownTimer();
  if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
 }
 satWindow.clearSatPredictionDom = clearPredictionDom;
 satDom.viewLiveBtn?.addEventListener("click", () => { switchSatView("live"); });
 satDom.viewHistoryBtn?.addEventListener("click", () => { switchSatView("history"); });
 satDom.viewPredBtn?.addEventListener("click", () => { switchSatView("predictions"); });
 // ── Live view: decoder state ────────────────────────────────────────
 let lastSatLrptOn: boolean | null = null;
@@ -300,6 +335,234 @@ document
    }
  })(); });
 // ── Predictions: helpers ────────────────────────────────────────────
 function azToCardinal(deg: number): string {
  const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
  return dirs[Math.round(deg / 45) % 8] ?? "N";
 }
 function formatPredTime(ms: number): string {
  const d = new Date(ms);
  const now = new Date();
  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
  const day = d.getUTCDay() !== now.getUTCDay() ? `${dayNames[d.getUTCDay()] ?? ""} ` : "";
  const hh = String(d.getUTCHours()).padStart(2, "0");
  const mm = String(d.getUTCMinutes()).padStart(2, "0");
  return `${day}${hh}:${mm}`;
 }
 function formatPredDuration(s: number): string {
  if (s >= 60) return `${Math.round(s / 60)} min`;
  return `${s}s`;
 }
 function formatCountdown(ms: number): string {
  const totalSec = Math.max(0, Math.floor(ms / 1000));
  const m = Math.floor(totalSec / 60);
  const s = totalSec % 60;
  return `${m}:${String(s).padStart(2, "0")}`;
 }
 function elevationClass(deg: number): string {
  if (deg >= 45) return "sat-pred-el-high";
  if (deg >= 10) return "sat-pred-el-mid";
  return "sat-pred-el-low";
 }
 // ── Predictions: countdown timer management ─────────────────────────
 function stopCountdownTimer() {
  if (satPredCountdownTimer) {
    clearInterval(satPredCountdownTimer);
    satPredCountdownTimer = null;
  }
 }
 function startCountdownTimer(container: HTMLElement | null): void {
  const countdownEls = container?.querySelectorAll<HTMLElement>(".sat-pred-col-countdown") ?? [];
  if (countdownEls.length === 0) return;
  satPredCountdownTimer = setInterval(() => {
    if (satActiveView !== "predictions") {
      stopCountdownTimer();
      return;
    }
    const n = Date.now();
    let anyActive = false;
    for (const el of countdownEls) {
      const los = Number.parseInt(el.dataset.los ?? "0", 10);
      const rem = los - n;
      if (rem > 0) {
        el.textContent = formatCountdown(rem);
        anyActive = true;
      } else {
        el.textContent = "0:00";
      }
    }
    if (!anyActive) {
      stopCountdownTimer();
      renderSatPredictions(getFilteredPredictions());
    }
  }, 1000);
 }
 // ── Predictions: row builders ───────────────────────────────────────
 function buildCurrentPassRow(pass: SatellitePass, now: number): HTMLElement {
  const row = document.createElement("div");
  row.className = "sat-pred-row-current";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
  const remaining = Math.max(0, pass.los_ms - now);
  row.innerHTML = [
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}\u00B0</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.los_ms)}</span>`,
    `<span class="sat-pred-col-countdown" data-los="${pass.los_ms}">${formatCountdown(remaining)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`,
  ].join("");
  return row;
 }
 function buildUpcomingPassRow(pass: SatellitePass): HTMLElement {
  const row = document.createElement("div");
  row.className = "sat-pred-row";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
  row.innerHTML = [
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}\u00B0</span>`,
    `<span class="sat-pred-col-dur">${formatPredDuration(pass.duration_s)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`,
  ].join("");
  return row;
 }
 // ── Predictions: filter state ───────────────────────────────────────
 function getFilteredPredictions(): SatellitePass[] {
  let items = satPredData;
  if (satPredCategory !== "all") items = items.filter((p) => p.category === satPredCategory);
  if (satPredMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= satPredMinEl);
  if (satPredFilterText) items = items.filter((p) => p.satellite.toUpperCase().includes(satPredFilterText));
  return items;
 }
 function applyPredFilters() {
  renderSatPredictions(getFilteredPredictions());
 }
 const satPredictionFilter = satDom.predFilter;
 satPredictionFilter?.addEventListener("input", () => {
  satPredFilterText = satPredictionFilter.value.trim().toUpperCase();
  applyPredFilters();
 });
 const satPredictionMinElevation = satDom.predMinEl;
 satPredictionMinElevation?.addEventListener("change", () => {
  satPredMinEl = Number.parseInt(satPredictionMinElevation.value, 10) || 0;
  applyPredFilters();
 });
 const satPredictionCategory = satDom.predCategory;
 satPredictionCategory?.addEventListener("change", () => {
  satPredCategory = satPredictionCategory.value;
  applyPredFilters();
 });
 // ── Predictions: main render ────────────────────────────────────────
 function renderSatPredictions(passes: SatellitePass[], error?: string): void {
  stopCountdownTimer();
  if (error) {
    if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
    if (satDom.predCurrentSec)   satDom.predCurrentSec.style.display = "none";
    if (satDom.predUpcomingSec)  satDom.predUpcomingSec.style.display = "none";
    if (satDom.predStatus)       satDom.predStatus.textContent = error;
    return;
  }
  if (!Array.isArray(passes) || passes.length === 0) {
    if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
    if (satDom.predCurrentSec)   satDom.predCurrentSec.style.display = "none";
    if (satDom.predUpcomingSec)  satDom.predUpcomingSec.style.display = "none";
    if (satDom.predStatus)       satDom.predStatus.textContent = "No passes found in the next 24 hours.";
    return;
  }
  const now = Date.now();
  const current = passes.filter((p) => p.aos_ms <= now && p.los_ms > now);
  const upcoming = passes.filter((p) => p.aos_ms > now);
  // ── Current passes ──
  if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = current.length > 0 ? "" : "none";
  if (satDom.predCurrentList) {
    if (current.length === 0) {
      satDom.predCurrentList.innerHTML = "";
    } else {
      const frag = document.createDocumentFragment();
      for (const pass of current) frag.appendChild(buildCurrentPassRow(pass, now));
      satDom.predCurrentList.replaceChildren(frag);
    }
  }
  // ── Upcoming passes ──
  const upcomingLimit = satPredShowAll ? upcoming.length : SAT_PRED_PAGE_SIZE;
  const visibleUpcoming = upcoming.slice(0, upcomingLimit);
  const hiddenCount = upcoming.length - visibleUpcoming.length;
  if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = upcoming.length > 0 ? "" : "none";
  if (satDom.predUpcomingList) {
    const frag = document.createDocumentFragment();
    for (const pass of visibleUpcoming) frag.appendChild(buildUpcomingPassRow(pass));
    if (hiddenCount > 0) {
      const moreRow = document.createElement("div");
      moreRow.className = "sat-pred-row";
      moreRow.style.cursor = "pointer";
      moreRow.style.textAlign = "center";
      moreRow.innerHTML = `<span style="grid-column:1/-1;color:var(--accent);font-size:0.82rem;">Show ${hiddenCount} more passes\u2026</span>`;
      moreRow.addEventListener("click", () => {
        satPredShowAll = true;
        renderSatPredictions(getFilteredPredictions());
      });
      frag.appendChild(moreRow);
    }
    satDom.predUpcomingList.replaceChildren(frag);
  }
  // ── Status ──
  if (satDom.predStatus) {
    let text = `${current.length} active \u00B7 ${upcoming.length} upcoming \u00B7 times in UTC`;
    if (satPredSatCount > 0) text += ` \u00B7 ${satPredSatCount} satellites tracked`;
    satDom.predStatus.textContent = text;
  }
  // ── Countdown timer ──
  if (current.length > 0 && satActiveView === "predictions") {
    startCountdownTimer(satDom.predCurrentList);
  }
 }
 // ── Predictions: data loading ───────────────────────────────────────
 async function loadSatPredictions(): Promise<void> {
  if (satDom.predStatus)       satDom.predStatus.textContent = "Loading predictions\u2026";
  if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
  try {
    const resp = await fetch("/sat_passes");
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json() as SatellitePassResponse;
    satPredSatCount = data.satellite_count || 0;
    if (data.error) {
      satPredData = [];
      renderSatPredictions([], data.error);
    } else {
      satPredData = data.passes || [];
      renderSatPredictions(getFilteredPredictions());
    }
  } catch (error: unknown) {
    renderSatPredictions([], `Failed to load predictions: ${error instanceof Error ? error.message : String(error)}`);
  }
 }
 // ── Navigate to map centered on satellite image bounds ──────────────
 satWindow.satShowOnMap = function (south: number, west: number, north: number, east: number) {
  if (typeof satWindow.enableMapSourceFilter === "function") {
@@ -1,290 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 import type { SatellitePass, SatellitePassResponse } from "./satellite-types";
 // --- Satellite pass predictions ---
 //
 // Its own page rather than a third view inside the weather-satellite decoder:
 // when a bird comes over is a planning question, and it was buried under
 // Digital modes beside decoders it has nothing to do with.
 interface PredictionsBridge {
  clearSatPredictionDom?: () => void;
  refreshSatPredictions?: () => void;
 }
 const predWindow = window as unknown as PredictionsBridge;
 // ── DOM references (cached once) ───────────────────────────────────
 const dom = {
  page:            document.getElementById("tab-satellites"),
  filter:          document.getElementById("sat-pred-filter") as HTMLInputElement | null,
  minElevation:    document.getElementById("sat-pred-min-el") as HTMLSelectElement | null,
  category:        document.getElementById("sat-pred-category") as HTMLSelectElement | null,
  currentList:     document.getElementById("sat-pred-current-list"),
  upcomingList:    document.getElementById("sat-pred-list"),
  currentSection:  document.getElementById("sat-pred-current-section"),
  upcomingSection: document.getElementById("sat-pred-upcoming-section"),
  status:          document.getElementById("sat-pred-status"),
 };
 // ── State ───────────────────────────────────────────────────────────
 const PAGE_SIZE = 50;
 let predShowAll = false;
 let predData: SatellitePass[] = [];
 let predFilterText = "";
 let predMinEl = 0;
 let predCategory = "all";
 let predSatCount = 0;
 let predCountdownTimer: ReturnType<typeof setInterval> | null = null;
 /** The countdowns tick once a second, so they stop when nobody is looking. */
 function isPageVisible(): boolean {
  return !!dom.page && dom.page.style.display !== "none";
 }
 // ── Predictions: helpers ────────────────────────────────────────────
 function azToCardinal(deg: number): string {
  const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
  return dirs[Math.round(deg / 45) % 8] ?? "N";
 }
 function formatPredTime(ms: number): string {
  const d = new Date(ms);
  const now = new Date();
  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
  const day = d.getUTCDay() !== now.getUTCDay() ? `${dayNames[d.getUTCDay()] ?? ""} ` : "";
  const hh = String(d.getUTCHours()).padStart(2, "0");
  const mm = String(d.getUTCMinutes()).padStart(2, "0");
  return `${day}${hh}:${mm}`;
 }
 function formatPredDuration(s: number): string {
  if (s >= 60) return `${Math.round(s / 60)} min`;
  return `${s}s`;
 }
 function formatCountdown(ms: number): string {
  const totalSec = Math.max(0, Math.floor(ms / 1000));
  const m = Math.floor(totalSec / 60);
  const s = totalSec % 60;
  return `${m}:${String(s).padStart(2, "0")}`;
 }
 function elevationClass(deg: number): string {
  if (deg >= 45) return "sat-pred-el-high";
  if (deg >= 10) return "sat-pred-el-mid";
  return "sat-pred-el-low";
 }
 // ── Predictions: countdown timer management ─────────────────────────
 function stopCountdownTimer() {
  if (predCountdownTimer) {
    clearInterval(predCountdownTimer);
    predCountdownTimer = null;
  }
 }
 function startCountdownTimer(container: HTMLElement | null): void {
  const countdownEls = container?.querySelectorAll<HTMLElement>(".sat-pred-col-countdown") ?? [];
  if (countdownEls.length === 0) return;
  predCountdownTimer = setInterval(() => {
    if (!isPageVisible()) {
      stopCountdownTimer();
      return;
    }
    const n = Date.now();
    let anyActive = false;
    for (const el of countdownEls) {
      const los = Number.parseInt(el.dataset.los ?? "0", 10);
      const rem = los - n;
      if (rem > 0) {
        el.textContent = formatCountdown(rem);
        anyActive = true;
      } else {
        el.textContent = "0:00";
      }
    }
    if (!anyActive) {
      stopCountdownTimer();
      render(filtered());
    }
  }, 1000);
 }
 // ── Predictions: row builders ───────────────────────────────────────
 function buildCurrentPassRow(pass: SatellitePass, now: number): HTMLElement {
  const row = document.createElement("div");
  row.className = "sat-pred-row-current";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
  const remaining = Math.max(0, pass.los_ms - now);
  row.innerHTML = [
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}\u00B0</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-time">${formatPredTime(pass.los_ms)}</span>`,
    `<span class="sat-pred-col-countdown" data-los="${pass.los_ms}">${formatCountdown(remaining)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`,
  ].join("");
  return row;
 }
 function buildUpcomingPassRow(pass: SatellitePass): HTMLElement {
  const row = document.createElement("div");
  row.className = "sat-pred-row";
  const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
  row.innerHTML = [
    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}\u00B0</span>`,
    `<span class="sat-pred-col-dur">${formatPredDuration(pass.duration_s)}</span>`,
    `<span class="sat-pred-col-dir">${dir}</span>`,
  ].join("");
  return row;
 }
 // ── Predictions: filter state ───────────────────────────────────────
 function filtered(): SatellitePass[] {
  let items = predData;
  if (predCategory !== "all") items = items.filter((p) => p.category === predCategory);
  if (predMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= predMinEl);
  if (predFilterText) items = items.filter((p) => p.satellite.toUpperCase().includes(predFilterText));
  return items;
 }
 function applyFilters() {
  render(filtered());
 }
 const filterInput = dom.filter;
 filterInput?.addEventListener("input", () => {
  predFilterText = filterInput.value.trim().toUpperCase();
  applyFilters();
 });
 const minElevationSelect = dom.minElevation;
 minElevationSelect?.addEventListener("change", () => {
  predMinEl = Number.parseInt(minElevationSelect.value, 10) || 0;
  applyFilters();
 });
 const categorySelect = dom.category;
 categorySelect?.addEventListener("change", () => {
  predCategory = categorySelect.value;
  applyFilters();
 });
 // ── Predictions: main render ────────────────────────────────────────
 function render(passes: SatellitePass[], error?: string): void {
  stopCountdownTimer();
  if (error) {
    if (dom.currentList)  dom.currentList.innerHTML = "";
    if (dom.upcomingList) dom.upcomingList.innerHTML = "";
    if (dom.currentSection)   dom.currentSection.style.display = "none";
    if (dom.upcomingSection)  dom.upcomingSection.style.display = "none";
    if (dom.status)       dom.status.textContent = error;
    return;
  }
  if (!Array.isArray(passes) || passes.length === 0) {
    if (dom.currentList)  dom.currentList.innerHTML = "";
    if (dom.upcomingList) dom.upcomingList.innerHTML = "";
    if (dom.currentSection)   dom.currentSection.style.display = "none";
    if (dom.upcomingSection)  dom.upcomingSection.style.display = "none";
    if (dom.status)       dom.status.textContent = "No passes found in the next 24 hours.";
    return;
  }
  const now = Date.now();
  const current = passes.filter((p) => p.aos_ms <= now && p.los_ms > now);
  const upcoming = passes.filter((p) => p.aos_ms > now);
  // ── Current passes ──
  if (dom.currentSection) dom.currentSection.style.display = current.length > 0 ? "" : "none";
  if (dom.currentList) {
    if (current.length === 0) {
      dom.currentList.innerHTML = "";
    } else {
      const frag = document.createDocumentFragment();
      for (const pass of current) frag.appendChild(buildCurrentPassRow(pass, now));
      dom.currentList.replaceChildren(frag);
    }
  }
  // ── Upcoming passes ──
  const upcomingLimit = predShowAll ? upcoming.length : PAGE_SIZE;
  const visibleUpcoming = upcoming.slice(0, upcomingLimit);
  const hiddenCount = upcoming.length - visibleUpcoming.length;
  if (dom.upcomingSection) dom.upcomingSection.style.display = upcoming.length > 0 ? "" : "none";
  if (dom.upcomingList) {
    const frag = document.createDocumentFragment();
    for (const pass of visibleUpcoming) frag.appendChild(buildUpcomingPassRow(pass));
    if (hiddenCount > 0) {
      const moreRow = document.createElement("div");
      moreRow.className = "sat-pred-row";
      moreRow.style.cursor = "pointer";
      moreRow.style.textAlign = "center";
      moreRow.innerHTML = `<span style="grid-column:1/-1;color:var(--accent);font-size:0.82rem;">Show ${hiddenCount} more passes\u2026</span>`;
      moreRow.addEventListener("click", () => {
        predShowAll = true;
        render(filtered());
      });
      frag.appendChild(moreRow);
    }
    dom.upcomingList.replaceChildren(frag);
  }
  // ── Status ──
  if (dom.status) {
    let text = `${current.length} active \u00B7 ${upcoming.length} upcoming \u00B7 times in UTC`;
    if (predSatCount > 0) text += ` \u00B7 ${predSatCount} satellites tracked`;
    dom.status.textContent = text;
  }
  // ── Countdown timer ──
  if (current.length > 0 && isPageVisible()) {
    startCountdownTimer(dom.currentList);
  }
 }
 // ── Predictions: data loading ───────────────────────────────────────
 async function load(): Promise<void> {
  if (dom.status)       dom.status.textContent = "Loading predictions\u2026";
  if (dom.currentList)  dom.currentList.innerHTML = "";
  if (dom.upcomingList) dom.upcomingList.innerHTML = "";
  try {
    const resp = await fetch("/sat_passes");
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json() as SatellitePassResponse;
    predSatCount = data.satellite_count || 0;
    if (data.error) {
      predData = [];
      render([], data.error);
    } else {
      predData = data.passes || [];
      render(filtered());
    }
  } catch (error: unknown) {
    render([], `Failed to load predictions: ${error instanceof Error ? error.message : String(error)}`);
  }
 }
 // ── Page lifecycle ──────────────────────────────────────────────────
 function clearPredictionDom(): void {
  stopCountdownTimer();
  if (dom.currentList)  dom.currentList.innerHTML = "";
  if (dom.upcomingList) dom.upcomingList.innerHTML = "";
 }
 predWindow.clearSatPredictionDom = clearPredictionDom;
 /**
 * Called by the router each time the Satellites page is opened, including the
 * visit that imports this module — so loading is driven from one place only.
 */
 predWindow.refreshSatPredictions = function () {
  predShowAll = false;
  void load();
 };
@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 import type { SatelliteScheduleConfig, SatelliteSchedulerApi } from "./satellite-types.js";
 import type { AuthRole } from "../api/auth.js";
 export type SchedulerMode = "disabled" | "grayline" | "time_span";
@@ -61,7 +60,7 @@ export interface SchedulerStatus {
 }
 export interface SchedulerService {
-  initialize(rigId: string | null, roles: readonly AuthRole[]): void;
+  initialize(rigId: string | null, role: string | null): void;
  destroy(): void;
  setRig(rigId: string | null): void;
  wireEvents(): void;
@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 import { hostState } from "./host.js";
 import { hasAuthRole, type AuthRole } from "../api/auth.js";
 import type {
  ScheduleEntry,
@@ -44,7 +43,7 @@ function schedulerOptionalEl(id: string): SchedulerElement | null {
  // -------------------------------------------------------------------------
  // State
  // -------------------------------------------------------------------------
-  let schedulerRoles: readonly AuthRole[] = [];
+  let schedulerRole: string | null = null;
  let currentRigId: string | null = null;
  let currentConfig: SchedulerConfig | null = null;
  let currentSchedulerStatus: SchedulerStatus | null = null;
@@ -59,8 +58,8 @@ function schedulerOptionalEl(id: string): SchedulerElement | null {
  // -------------------------------------------------------------------------
  // Init
  // -------------------------------------------------------------------------
-  function initScheduler(rigId: string | null, roles: readonly AuthRole[]): void {
+  function initScheduler(rigId: string | null, role: string | null): void {
-    schedulerRoles = roles;
+    schedulerRole = role;
    currentRigId = rigId || null;
    if (currentRigId) loadScheduler();
    startStatusPolling();
@@ -357,7 +356,7 @@ function schedulerOptionalEl(id: string): SchedulerElement | null {
    if (!prevBtn || !nextBtn) return;
    const state = schedulerInterleaveState(currentConfig);
    const enabled =
-      hasAuthRole(schedulerRoles, "control") &&
+      schedulerRole === "control" &&
      !!currentRigId &&
      !schedulerStepPending &&
      state.activeEntries.length > 1;
@@ -467,7 +466,7 @@ function schedulerOptionalEl(id: string): SchedulerElement | null {
    if (!panel) return;
    const mode = (currentConfig && currentConfig.mode) || "disabled";
-    const isControl = hasAuthRole(schedulerRoles, "control");
+    const isControl = schedulerRole === "control";
    // Mode selector
    setSelected("scheduler-mode-select", mode);
@@ -1575,8 +1574,8 @@ function schedulerOptionalEl(id: string): SchedulerElement | null {
  // When loaded eagerly, initSettingsUI() in app.js calls initScheduler();
  // when loaded lazily (e.g. settings tab click after boot), the app has
  // already passed that point, so we must self-initialize here.
-  if (!hostState.authEnabled || hostState.authRoles.length > 0) {
+  if (hostState.authRole != null) {
-    initScheduler(hostState.lastActiveRigId, hostState.authRoles);
+    initScheduler(hostState.lastActiveRigId, hostState.authRole);
    wireSchedulerEvents();
  }
 })();
@@ -1,373 +0,0 @@
 // SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 // sstv.ts — SSTV decoder panel.
 //
 // Live view: decoder state, a canvas the picture fills row by row as it
 // arrives, and a card for the last one received. History view: a filterable
 // table of received pictures with thumbnails.
 //
 // Watching a picture build up is most of the appeal of the mode, so rows are
 // painted as they arrive rather than waiting for the frame to finish — a
 // transmission takes between 36 seconds and two minutes.
 import { hostCore } from "./host.js";
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
 export {};
 interface SstvImage {
  rig_id?: string | null;
  ts_ms?: number;
  vis?: number;
  mode?: string;
  width?: number;
  height?: number;
  lines?: number;
  complete?: boolean;
  path?: string;
  _tsMs?: number;
  _ts?: string;
 }
 interface SstvProgress {
  rig_id?: string | null;
  state?: string;
  mode?: string;
  width?: number;
  height?: number;
  line?: number;
  line_data?: string;
 }
 interface SstvBridge {
  getDecodeHistoryRetentionMs?: () => number;
  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<unknown>;
  syncSstvToggle?: (enabled: boolean) => void;
 }
 const sstvWindow = window as unknown as SstvBridge & PluginRuntimeWindow;
 const sstvDom = {
  status: document.getElementById("sstv-status"),
  liveView: document.getElementById("sstv-live-view"),
  historyView: document.getElementById("sstv-history-view"),
  liveContainer: document.getElementById("sstv-live-container"),
  liveInfo: document.getElementById("sstv-live-info"),
  liveCanvas: document.getElementById("sstv-live-canvas") as HTMLCanvasElement | null,
  liveLatest: document.getElementById("sstv-live-latest"),
  historyList: document.getElementById("sstv-history-list"),
  historyCount: document.getElementById("sstv-history-count"),
  filterInput: document.getElementById("sstv-filter") as HTMLInputElement | null,
  sortSelect: document.getElementById("sstv-sort") as HTMLSelectElement | null,
  toggleBtn: document.getElementById("sstv-decode-toggle-btn"),
  clearBtn: document.getElementById("sstv-clear-btn"),
  viewLiveBtn: document.getElementById("sstv-view-live"),
  viewHistoryBtn: document.getElementById("sstv-view-history"),
 };
 const SSTV_MAX_IMAGES = 100;
 let sstvHistory: SstvImage[] = [];
 let liveCtx: CanvasRenderingContext2D | null = null;
 let liveMode = "";
 let liveHeight = 0;
 let liveRows = 0;
 let activeView: "live" | "history" = "live";
 let filterText = "";
 // ── Helpers ─────────────────────────────────────────────────────────
 function retentionMs(): number {
  return sstvWindow.getDecodeHistoryRetentionMs?.() ?? 24 * 60 * 60 * 1000;
 }
 function pruneHistory() {
  const cutoff = Date.now() - retentionMs();
  sstvHistory = sstvHistory.filter((image) => (image._tsMs || 0) > cutoff);
 }
 function escapeHtml(value: unknown): string {
  return String(value)
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;");
 }
 function scheduleUi(key: string, job: () => void): void {
  if (typeof sstvWindow.trxScheduleUiFrameJob === "function") {
    sstvWindow.trxScheduleUiFrameJob(key, job);
    return;
  }
  job();
 }
 /** The URL the server serves a saved picture from, given its stored path. */
 function imageUrl(image: SstvImage): string | null {
  if (!image.path) return null;
  const filename = image.path.split(/[\\/]/).pop();
  return filename ? `/sstv-images/${encodeURIComponent(filename)}` : null;
 }
 function decodeBase64(data: string): Uint8Array {
  const binary = atob(data);
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
  return bytes;
 }
 // ── View switching ──────────────────────────────────────────────────
 function switchView(view: "live" | "history"): void {
  activeView = view;
  if (sstvDom.liveView) sstvDom.liveView.style.display = view === "live" ? "" : "none";
  if (sstvDom.historyView) sstvDom.historyView.style.display = view === "history" ? "" : "none";
  for (const button of [sstvDom.viewLiveBtn, sstvDom.viewHistoryBtn]) {
    button?.classList.remove("sat-view-active");
  }
  if (view === "live") sstvDom.viewLiveBtn?.classList.add("sat-view-active");
  else sstvDom.viewHistoryBtn?.classList.add("sat-view-active");
  if (view === "history") renderHistoryTable();
 }
 sstvDom.viewLiveBtn?.addEventListener("click", () => { switchView("live"); });
 sstvDom.viewHistoryBtn?.addEventListener("click", () => { switchView("history"); });
 // ── Live canvas ─────────────────────────────────────────────────────
 /** Start a new picture: size the canvas to the mode and clear it. */
 function beginPicture(mode: string, width: number, height: number): void {
  const canvas = sstvDom.liveCanvas;
  if (!canvas || width <= 0 || height <= 0) return;
  liveMode = mode;
  liveHeight = height;
  liveRows = 0;
  canvas.width = width;
  canvas.height = height;
  liveCtx = canvas.getContext("2d");
  if (!liveCtx) return;
  // Mid-grey, not black: the rows below the one arriving have not been
  // received, which is a different thing from having been received as black.
  liveCtx.fillStyle = "#606060";
  liveCtx.fillRect(0, 0, width, height);
  if (sstvDom.liveContainer) sstvDom.liveContainer.style.display = "";
  updateLiveInfo();
 }
 function updateLiveInfo(): void {
  if (!sstvDom.liveInfo) return;
  const canvas = sstvDom.liveCanvas;
  const size = canvas ? `${canvas.width}×${canvas.height}` : "";
  sstvDom.liveInfo.textContent = liveMode
    ? `${liveMode} · ${size} · line ${liveRows}${liveHeight ? ` of ${liveHeight}` : ""}`
    : "";
 }
 /** Paint one row of RGB triples at its own line number. */
 function paintRow(line: number, rgb: Uint8Array): void {
  const canvas = sstvDom.liveCanvas;
  if (!liveCtx || !canvas) return;
  const width = canvas.width;
  if (line < 0 || line >= canvas.height || rgb.length < width * 3) return;
  const row = liveCtx.createImageData(width, 1);
  for (let x = 0; x < width; x += 1) {
    row.data[x * 4] = rgb[x * 3] ?? 0;
    row.data[x * 4 + 1] = rgb[x * 3 + 1] ?? 0;
    row.data[x * 4 + 2] = rgb[x * 3 + 2] ?? 0;
    row.data[x * 4 + 3] = 255;
  }
  liveCtx.putImageData(row, 0, line);
  liveRows = Math.max(liveRows, line + 1);
 }
 // ── Server messages ─────────────────────────────────────────────────
 function onProgress(msg: SstvProgress): void {
  // The live canvas draws one picture at a time: a background rig's rows would
  // paint straight over the one being watched.
  if (!isActiveRigDecode(msg.rig_id)) return;
  if (msg.state) {
    if (sstvDom.status) sstvDom.status.textContent = msg.state;
    // A state update carries the geometry; a row update carries only the row.
    beginPicture(msg.mode || "", msg.width || 0, msg.height || 0);
    return;
  }
  if (typeof msg.line !== "number" || !msg.line_data) return;
  const line = msg.line;
  const rgb = decodeBase64(msg.line_data);
  scheduleUi(`sstv-row-${line}`, () => {
    paintRow(line, rgb);
    updateLiveInfo();
  });
 }
 function onImage(msg: SstvImage): void {
  const image: SstvImage = { ...msg };
  image._tsMs = typeof msg.ts_ms === "number" ? msg.ts_ms : Date.now();
  image._ts = new Date(image._tsMs).toLocaleTimeString();
  sstvHistory.push(image);
  if (sstvHistory.length > SSTV_MAX_IMAGES) sstvHistory.shift();
  pruneHistory();
  // Kept in the history either way, so switching to that rig finds it there.
  if (!isActiveRigDecode(image.rig_id)) return;
  if (sstvDom.status) {
    sstvDom.status.textContent = image.complete
      ? `Received ${image.mode ?? "picture"}`
      : `Partial ${image.mode ?? "picture"} — ${image.lines ?? 0} lines`;
  }
  scheduleUi("sstv-latest", renderLatestCard);
  if (activeView === "history") scheduleUi("sstv-history", renderHistoryTable);
 }
 // ── Rendering ───────────────────────────────────────────────────────
 /** The pictures the selected rig decoded, oldest first, as the history is kept. */
 function sstvRigImages(): SstvImage[] {
  return forActiveRig(sstvHistory);
 }
 function renderLatestCard(): void {
  if (!sstvDom.liveLatest) return;
  const rigImages = sstvRigImages();
  const latest = rigImages[rigImages.length - 1];
  if (!latest) {
    sstvDom.liveLatest.innerHTML = "";
    return;
  }
  const url = imageUrl(latest);
  const lines = `${latest.lines ?? 0}${latest.height ? ` of ${latest.height}` : ""} lines`;
  const state = latest.complete ? "complete" : "partial";
  sstvDom.liveLatest.innerHTML = `
    <div class="sat-latest-card">
      <div style="display:flex; align-items:baseline; gap:0.5rem; flex-wrap:wrap;">
        <strong>${escapeHtml(latest.mode ?? "SSTV")}</strong>
        <small style="color:var(--text-muted);">${escapeHtml(latest._ts ?? "")} · ${lines} · ${state}</small>
      </div>
      ${url
        ? `<a href="${escapeHtml(url)}" target="_blank" rel="noopener">
             <img src="${escapeHtml(url)}" alt="Received ${escapeHtml(latest.mode ?? "SSTV")} picture"
                  style="margin-top:0.4rem; width:100%; max-width:640px; image-rendering:pixelated;" />
           </a>`
        : ""}
    </div>`;
 }
 function filteredHistory(): SstvImage[] {
  // Every rig's pictures are kept; the panel shows the selected rig's.
  const rigImages = sstvRigImages();
  const text = filterText.trim().toLowerCase();
  const matching = text
    ? rigImages.filter((image) => (image.mode ?? "").toLowerCase().includes(text))
    : rigImages;
  const newestFirst = (sstvDom.sortSelect?.value ?? "newest") === "newest";
  matching.sort((a, b) => (newestFirst ? 1 : -1) * ((b._tsMs ?? 0) - (a._tsMs ?? 0)));
  return matching;
 }
 function renderHistoryTable(): void {
  if (!sstvDom.historyList) return;
  pruneHistory();
  const rows = filteredHistory();
  sstvDom.historyList.innerHTML = rows
    .map((image) => {
      const url = imageUrl(image);
      const size = image.width && image.height ? `${image.width}×${image.height}` : "--";
      const lines = image.complete
        ? String(image.lines ?? 0)
        : `${image.lines ?? 0} (partial)`;
      return `<div class="sat-history-row">
        <span class="sat-col-time">${escapeHtml(image._ts ?? "")}</span>
        <span class="sat-col-type">${escapeHtml(image.mode ?? "--")}</span>
        <span class="sat-col-sat">${escapeHtml(size)}</span>
        <span class="sat-col-lines">${escapeHtml(lines)}</span>
        <span class="sat-col-link">${url
          ? `<a href="${escapeHtml(url)}" target="_blank" rel="noopener">View</a>`
          : "--"}</span>
      </div>`;
    })
    .join("");
  if (sstvDom.historyCount) {
    sstvDom.historyCount.textContent = rows.length
      ? `${rows.length} picture${rows.length === 1 ? "" : "s"}`
      : "No pictures yet";
  }
 }
 sstvDom.filterInput?.addEventListener("input", () => {
  filterText = sstvDom.filterInput?.value ?? "";
  renderHistoryTable();
 });
 sstvDom.sortSelect?.addEventListener("change", () => { renderHistoryTable(); });
 // ── Decoder history plumbing ────────────────────────────────────────
 function restoreHistory(entries: unknown[]): void {
  if (!Array.isArray(entries)) return;
  for (const entry of entries) onImage(entry as SstvImage);
 }
 function resetHistoryView(): void {
  sstvHistory = [];
  liveRows = 0;
  liveMode = "";
  if (sstvDom.liveContainer) sstvDom.liveContainer.style.display = "none";
  if (sstvDom.status) sstvDom.status.textContent = "Idle";
  renderLatestCard();
  renderHistoryTable();
 }
 // ── Controls ────────────────────────────────────────────────────────
 sstvWindow.syncSstvToggle = function syncSstvToggle(enabled: boolean) {
  const button = sstvDom.toggleBtn as HTMLButtonElement | null;
  if (!button) return;
  button.textContent = enabled ? "Disable SSTV" : "Enable SSTV";
  button.setAttribute("aria-pressed", String(enabled));
  button.classList.toggle("is-active", enabled);
 };
 sstvDom.toggleBtn?.addEventListener("click", () => {
  void (async () => {
    try {
      if (sstvDom.toggleBtn) {
        await sstvWindow.takeSchedulerControlForDecoderDisable?.(sstvDom.toggleBtn);
      }
      await hostCore.postPath("/toggle_sstv_decode");
    } catch (e) {
      console.error("SSTV toggle failed", e);
    }
  })();
 });
 sstvDom.clearBtn?.addEventListener("click", () => {
  void (async () => {
    try {
      await hostCore.postPath("/clear_sstv_decode");
      resetHistoryView();
    } catch (e) {
      console.error("SSTV clear failed", e);
    }
  })();
 });
 renderLatestCard();
 sstvWindow.trxPluginRuntime.registerDecoder({
  id: "sstv",
  onMessage: onImage as (msg: unknown) => void,
  restore: restoreHistory,
  prune: renderHistoryTable,
  reset: resetHistoryView,
  rerender: () => { renderLatestCard(); renderHistoryTable(); },
 });
 sstvWindow.trxPluginRuntime.registerDecoder({
  id: "sstv_progress",
  onMessage: onProgress as (msg: unknown) => void,
 });
@@ -403,10 +403,7 @@ function vchanSyncModeDisplay() {
  if (!modeEl) return;
  if (vchanIsOnVirtual()) {
    const ch = vchanActiveChannel();
-    if (ch && ch.mode) {
+    if (ch && ch.mode) modeEl.value = ch.mode.toUpperCase();
      modeEl.value = ch.mode.toUpperCase();
      hostCore.syncModePicker();
    }
  }
  // When on primary channel, app.js rig-state updates handle the picker.
  const modeUpper = (modeEl.value || "").toUpperCase();
@@ -6,7 +6,6 @@ import { hostCore } from "./host.js";
 export {};
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract";
 interface VdesMessage {
@@ -117,24 +116,17 @@ function vdesHexPreview(rawBytes: number[] | undefined): string {
    .toUpperCase();
 }
 /** What the selected rig heard.  The history holds every rig's traffic, for
 *  the map; the panel is about the rig the operator is working. */
 function vdesRigMessages(): VdesMessage[] {
  return forActiveRig(vdesMessageHistory);
 }
 function updateVdesSummary() {
  pruneVdesMessageHistory();
  if (vdesChannelSummaryEl) {
    vdesChannelSummaryEl.textContent = currentVdesCenterText();
  }
  const rigMessages = vdesRigMessages();
  if (vdesFrameCountEl) {
-    const count = rigMessages.length;
+    const count = vdesMessageHistory.length;
    vdesFrameCountEl.textContent = `${count} burst${count === 1 ? "" : "s"}`;
  }
  if (vdesLatestSeenEl) {
-    const latest = rigMessages[0];
+    const latest = vdesMessageHistory[0];
    vdesLatestSeenEl.textContent = latest ? vdesAgeText(latest._tsMs) : "No traffic yet";
  }
 }
@@ -236,9 +228,7 @@ function updateVdesBar() {
  updateVdesSummary();
  const isVdes = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase() === "VDES";
  const cutoffMs = Date.now() - VDES_BAR_WINDOW_MS;
-  const messages = vdesMessageHistory
+  const messages = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs).slice(0, 6);
    .filter((msg) => (msg._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(msg.rig_id))
    .slice(0, 6);
  if (!isVdes || messages.length === 0) {
    vdesBarOverlay.style.display = "none";
    vdesBarOverlay.innerHTML = "";
@@ -288,7 +278,7 @@ function renderVdesHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of vdesRigMessages()) {
+  for (const message of vdesMessageHistory) {
    fragment.appendChild(renderVdesRow(message));
  }
  vdesMessagesEl.replaceChildren(fragment);
@@ -319,11 +309,10 @@ function normalizeServerVdesMessage(msg: VdesMessage): VdesMessage {
 function onServerVdesBatch(messages: VdesMessage[]): void {
  if (!Array.isArray(messages) || messages.length === 0) return;
  if (vdesStatus) vdesStatus.textContent = "Receiving";
  const normalized: VdesMessage[] = [];
  for (const msg of messages) {
    const next = normalizeServerVdesMessage(msg);
    // "Receiving" is the panel's own status, and the panel is the rig's.
    if (vdesStatus && isActiveRigDecode(next.rig_id)) vdesStatus.textContent = "Receiving";
    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
    next._tsMs = tsMs;
    next._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -331,7 +320,9 @@ function onServerVdesBatch(messages: VdesMessage[]): void {
      minute: "2-digit",
      second: "2-digit",
    });
-    plotVdesMessage(next);
+    if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
      vdesWindow.vdesMapAddPoint(next);
    }
    normalized.push(next);
  }
  normalized.reverse();
@@ -358,17 +349,13 @@ if (vdesFilterInput) {
  });
 }
 /** Hands a positioned message to the map, if the map module is loaded yet. */
 function plotVdesMessage(msg: VdesMessage): void {
  if (msg.lat == null || msg.lon == null || !vdesWindow.vdesMapAddPoint) return;
  vdesWindow.vdesMapAddPoint(msg);
 }
 function onServerVdes(msg: VdesMessage): void {
  if (vdesStatus) vdesStatus.textContent = "Receiving";
  const next = normalizeServerVdesMessage(msg);
  if (vdesStatus && isActiveRigDecode(next.rig_id)) vdesStatus.textContent = "Receiving";
  addVdesMessage(next);
-  plotVdesMessage(next);
+  if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
    vdesWindow.vdesMapAddPoint(next);
  }
 }
 function pruneVdesHistoryView(): void {
@@ -385,7 +372,4 @@ updateVdesSummary();
  restore: onServerVdesBatch,
  reset: resetVdesHistoryView,
  prune: pruneVdesHistoryView,
  rerender: () => { updateVdesBar(); renderVdesHistory(); },
  // Oldest first, so tracks are rebuilt in the order they happened.
  syncMap: () => { for (const entry of [...vdesMessageHistory].reverse()) plotVdesMessage(entry); },
 });
@@ -4,13 +4,11 @@
 import { hostCore } from "./host.js";
 import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
 export {};
 interface WefaxImage {
  rig_id?: string | null;
  ts_ms?: number;
  ioc?: number;
  lpm?: number;
@@ -22,7 +20,6 @@ interface WefaxImage {
 }
 interface WefaxProgress {
  rig_id?: string | null;
  state?: string;
  line_data?: string;
  line_count?: number;
@@ -159,21 +156,15 @@ function paintLine(lineBytes: Uint8Array): void {
 }
 // ── Live view: latest image card ────────────────────────────────────
 /** The pictures the selected rig decoded, newest first. */
 function wefaxRigImages(): WefaxImage[] {
  return forActiveRig(wefaxImageHistory);
 }
 function renderWefaxLatestCard() {
  if (!wefaxDom.liveLatest) return;
-  const rigImages = wefaxRigImages();
+  if (wefaxImageHistory.length === 0) {
  if (rigImages.length === 0) {
    wefaxDom.liveLatest.innerHTML =
      '<div style="color:var(--text-muted);font-size:0.82rem;">No images decoded yet. Enable the decoder and tune to a WEFAX station.</div>';
    return;
  }
-  const img = rigImages[0];
+  const img = wefaxImageHistory[0];
  if (!img) return;
  const ts = img._ts || '--';
  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : '';
@@ -202,8 +193,7 @@ function renderWefaxLatestCard() {
 // ── History view: table ─────────────────────────────────────────────
 function getWefaxFilteredHistory() {
-  // Every rig's pictures are kept; the panel shows the selected rig's.
+  let items = wefaxImageHistory;
  let items = wefaxRigImages();
  if (wefaxFilterText) {
    items = items.filter(function (i) {
@@ -263,7 +253,7 @@ function renderWefaxHistoryTable() {
  wefaxDom.historyList.replaceChildren(fragment);
  if (wefaxDom.historyCount) {
-    const total = wefaxRigImages().length;
+    const total = wefaxImageHistory.length;
    const shown = items.length;
    wefaxDom.historyCount.textContent =
      total === 0
@@ -308,9 +298,6 @@ function addWefaxImage(msg: WefaxImage): void {
 // ── SSE event handlers (public API) ─────────────────────────────────
 function onServerWefaxProgress(msg: WefaxProgress): void {
  // The live canvas draws one picture at a time: a background rig's lines
  // would paint straight over the one being watched.
  if (!isActiveRigDecode(msg.rig_id)) return;
  // State-only update (no image data): show decoder state in status.
  if (msg.state && !msg.line_data) {
    if (wefaxDom.status) {
@@ -344,8 +331,6 @@ function onServerWefaxProgress(msg: WefaxProgress): void {
 function onServerWefax(msg: WefaxImage): void {
  addWefaxImage(msg);
  // Kept in the history either way, so switching to that rig finds it there.
  if (!isActiveRigDecode(msg.rig_id)) return;
  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = 'none';
  if (wefaxDom.status) {
@@ -453,7 +438,6 @@ wefaxWindow.trxPluginRuntime.registerDecoder({
  restore: restoreWefaxHistory,
  prune: pruneWefaxHistoryView,
  reset: resetWefaxHistoryView,
  rerender: () => { renderWefaxLatestCard(); renderWefaxHistoryTable(); },
 });
 wefaxWindow.trxPluginRuntime.registerDecoder({
  id: "wefax_progress",
--- a/Show More
+++ b/Show More