[docs](trx-rs): add safe deployment guide

Document deployment with a dedicated service account, restricted device access, authenticated network listeners, systemd user services, reverse proxying, verification, upgrades, and rollback. Assisted-By: OpenAI Codex (GPT-5) Signed-off-by: Stan Grams <sjg@haxx.space>
[fix](trx-server): honor per-rig audio bind addresses
2026-08-18 22:53:00 +02:00 · 2026-08-18 22:45:33 +02:00 · 2026-08-18 22:44:58 +02:00 · 2026-08-18 22:35:54 +02:00 · 2026-08-16 23:01:45 +02:00 · 2026-08-16 21:42:14 +02:00
193 changed files with 30472 additions and 6695 deletions
@@ -27,7 +27,7 @@ env:

 jobs:
  lint:
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
    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: ubuntu-latest
+    runs-on: self-hosted
    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: ubuntu-latest
+    runs-on: self-hosted
    container: git.haxx.space/sjg/trx-rs/sdk:latest
    defaults:
      run:
@@ -83,7 +83,7 @@ jobs:
        run: npm run verify-generated

  reuse:
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
    steps:
      - uses: actions/checkout@v4
      - uses: fsfe/reuse-action@v5
@@ -24,6 +24,12 @@ 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:
@@ -41,7 +47,8 @@ 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 (config paths, logging init)
+  trx-app/            # Shared application helpers (logging init, name normalization)
+  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
@@ -49,6 +56,7 @@ 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,6 +316,18 @@ 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"
@@ -345,6 +357,12 @@ 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"
@@ -395,6 +413,24 @@ 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"
@@ -525,7 +561,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
 dependencies = [
 "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.3.0",
 "rand_core 0.10.1",
 ]

@@ -721,6 +757,15 @@ 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"
@@ -739,6 +784,16 @@ 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"
@@ -799,15 +854,26 @@ 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",
+ "block-buffer 0.12.0",
 "const-oid",
- "crypto-common",
+ "crypto-common 0.2.1",
 ]

 [[package]]
@@ -1019,6 +1085,16 @@ 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"
@@ -1890,6 +1966,17 @@ 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"
@@ -2412,6 +2499,16 @@ 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"
@@ -2482,8 +2579,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
 dependencies = [
 "cfg-if",
- "cpufeatures",
- "digest",
+ "cpufeatures 0.3.0",
+ "digest 0.11.2",
 ]

 [[package]]
@@ -3031,10 +3128,6 @@ dependencies = [
 name = "trx-app"
 version = "0.1.0"
 dependencies = [
- "dirs",
- "serde",
- "thiserror 2.0.18",
- "toml",
 "tracing",
 "tracing-subscriber",
 ]
@@ -3115,6 +3208,7 @@ dependencies = [
 "toml",
 "tracing",
 "trx-app",
+ "trx-config",
 "trx-core",
 "trx-frontend",
 "trx-frontend-http",
@@ -3124,6 +3218,23 @@ 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"
@@ -3132,13 +3243,16 @@ 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",
@@ -3188,9 +3302,11 @@ version = "0.1.0"
 dependencies = [
 "actix-web",
 "actix-ws",
+ "argon2",
 "base64",
 "brotli 7.0.0",
 "bytes",
+ "chrono",
 "dirs",
 "flate2",
 "futures-util",
@@ -3199,11 +3315,13 @@ dependencies = [
 "rand 0.8.6",
 "serde",
 "serde_json",
+ "tempfile",
 "tokio",
 "tokio-stream",
 "tracing",
 "trx-core",
 "trx-frontend",
+ "trx-logbook",
 "trx-protocol",
 "ts-rs",
 "uuid",
@@ -3242,6 +3360,19 @@ 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"
@@ -3294,12 +3425,14 @@ 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",
@@ -3307,6 +3440,16 @@ 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,11 +12,13 @@ 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",
@@ -24,6 +26,7 @@ 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",
@@ -0,0 +1,434 @@
+APRS symbol set (https://github.com/hessu/aprs-symbols)
+=========================================================
+
+Verbatim copy of the upstream COPYRIGHT.md, retrieved 2026-08-03 from
+https://github.com/hessu/aprs-symbols.  The set has no single SPDX license:
+individual symbols carry different terms, summarized below.  Attribution
+requirement from the upstream README: "If you use this symbol set, please
+provide a pointer to the source (http://github.com/hessu/aprs-symbols/)."
+
+---
+
+
+Copyright and licensing information
+======================================
+
+This is a collection of vectorized symbols for use on the APRS system.
+
+The copyright status of this collection is a bit complicated, since the
+symbols come from various sources, each having different copyright owners.
+
+Most of the vectorized symbols are loosely based on the low-resolution
+"standard" bitmap symbol set as distributed by Stephen Smith, WA8LMF.  That
+set is used by most APRS software around the world.  The low resolution of
+those symbols does not allow direct vector conversion, so I've drawn new
+symbols in a similar layout.  The vector versions try to mimic the original
+appearance and colours, with the intention of keeping the set recognizable
+and familiar to existing users.  In some cases the vector versions are
+probably similar enough to the originals, so that they cannot be considered
+"original work" by myself.  In some of these cases, the originals are
+probably also mimicking someone else's design.
+
+The original symbols do not come with any information on their licensing.
+They've been distributed with a lot of APRS software over time, but I don't
+know who designed which symbol originally. Most likely all of them are
+drawn by one of:
+
+  * Roger Barker, G4IDE, "original set provided with UI-View" (SK)
+  * Steve Dimse, KH4G, "U.S. customary set"
+  * Stephen Smith, WA8LMF
+
+The Adobe Illustrator (.ai) file contains a copy of the original bitmaps
+as a hidden layer, just for reference.
+
+Some symbols I obtained from other sources, such as Wikipedia. In those
+cases I picked SVG versions which allow commercial reuse (source known, and
+the work is placed on public domain, or with a CC license which allows
+adaptation and commercial reuse).
+
+Some symbols are vectorized versions of product or brand logos. The
+copyright of those is owned by the respective companies (Apple, Microsoft,
+Kenwood), and each of those may have some opinions on how the logos are
+used.  Please check for yourself if you can use them or not.
+
+In the list below I try to summarize the licensing status for each symbol.
+
+
+Shorthand notation for common licensing status
+-------------------------------------------------
+
+* *VEC-OH7LZB* - Vectorized by OH7LZB, based on original APRS symbol set
+  * Source of original bitmap: http://wa8lmf.net/aprs/APRS_symbols.htm
+  * Original designer of individual symbol unknown at this time, but one of:
+    * Roger Barker, G4IDE
+    * Steve Dimse, KH4G
+    * Stephen Smith, WA8LMF
+  * Vectorized versions are designed to look similar
+  * Licensing: Unknown
+* *OH7LZB* - Original vector design by Heikki Hannikainen, OH7LZB
+  * Different enough (by author's opinion) to make it a new original work,
+    instead of a copy of the old symbol
+  * License: CC BY-SA 2.0
+  * https://creativecommons.org/licenses/by-sa/2.0/
+
+
+Primary table
+----------------
+
+* /! - Police station
+  * VEC-OH7LZB
+* /# - Digipeater / Green star with D in middle
+  * VEC-OH7LZB
+* /$ - Telephone
+  * VEC-OH7LZB
+* /% - DX cluster
+  * VEC-OH7LZB
+* /& - HF gateway
+  * VEC-OH7LZB
+* /' - Small aircraft
+  * https://openclipart.org/detail/27182/topdown-airplane-view
+  * Author: Wirelizard (Brian Burger)
+  * With color and some other small tuning added by OH7LZB
+  * PD: https://openclipart.org/share
+* /( - Mobile satellite station
+  * OH7LZB
+* /) - Wheelchair, handicapped
+  * PD wheelchair symbol
+  * Vectorized from bitmap by OH7LZB
+* /* - Snowmobile
+  * https://openclipart.org/detail/15849/snowmobile
+  * Author: Mystica (https://openclipart.org/user-detail/mystica)
+  * PD: https://openclipart.org/share
+* /+ - Red Cross
+  * VEC-OH7LZB
+* /, - Boy Scouts
+  * VEC-OH7LZB
+* /- - House
+  * VEC-OH7LZB
+* /. - Red X
+  * VEC-OH7LZB
+* // - Red dot
+  * VEC-OH7LZB
+* /0 to /9 - Numbered circles
+  * VEC-OH7LZB
+* Fire
+  * http://commons.wikimedia.org/wiki/File:FireIcon.svg
+  * Author: Piotr Jaworski
+  * PD: I, the copyright holder of this work, release this work into the public domain. This applies worldwide.
+* Tent
+  * https://openclipart.org/detail/174933/green-tent-by-stamps-174933
+  * Author: stamps
+  * PD: https://openclipart.org/share
+* Motorcycle
+  * http://commons.wikimedia.org/wiki/File:MUTCD_W8-15P.svg
+  * This file is in the public domain because it comes from the Manual on
+    Uniform Traffic Control Devices, sign number W8-15P, which states
+    specifically on page I-1 that: Any traffic control device design or
+    application provision contained in this Manual shall be considered to
+    be in the public domain. Traffic control devices contained in this
+    Manual shall not be protected by a patent, trademark, or copyright,
+    except for the Interstate Shield and any other items owned by FHWA.
+  * Colour version by OH7LZB
+* /= - Railroad engine
+  * http://commons.wikimedia.org/wiki/File:Icon_train.svg
+  * Author: http://en.wikipedia.org/wiki/User:Richtom80
+  * CC-BY-SA-2.5,2.0,1.0
+* /> - Car
+  * OH7LZB
+* /? - File server
+  * https://openclipart.org/detail/163717/file-server-by-lyte
+  * Author: lyte
+  * PD: https://openclipart.org/share
+* /@ - Hurricane predicted path
+  * VEC-OH7LZB
+* /A - Aid station
+  * VEC-OH7LZB
+* Mail (BBS)
+  * https://openclipart.org/detail/29268/yellow-mail-by-rg1024-29268
+  * Author: rg1024
+  * PD: https://openclipart.org/share
+* /C - Canoe
+  * https://openclipart.org/detail/179047/red-canoe-by-rambo-tribble-179047
+  * https://openclipart.org/detail/179041/canoe-paddle-by-rambo-tribble-179041
+  * Author: Rambo Tribble
+  * PD: I, the copyright holder of this work, release this work into the public domain. This applies worldwide.
+* /E - Eyeball
+  * http://commons.wikimedia.org/wiki/File:Blue_eye.svg
+  * PD: "This file is from the Open Clip Art Library, which released it explicitly into the public domain"
+  * PD: https://openclipart.org/share
+* /F - Tractor
+  * https://openclipart.org/detail/191654/farm-tractor-by-tmjbeary-191654
+  * Author: tmjbeary
+  * PD: https://openclipart.org/share
+* /G - Grid square, 3 by 3
+  * VEC-OH7LZB
+* /H - Hotel
+  * VEC-OH7LZB
+* /I - TCP/IP
+  * VEC-OH7LZB
+* /K - School
+  * OH7LZB
+* /L - PC user
+  * OH7LZB
+* /M - Mac apple
+  * Apple
+* /N - NTS
+  * VEC-OH7LZB
+* /O - Hot air balloon
+  * OH7LZB
+* /P - Police
+  * OH7LZB
+* /R - RV
+  * OH7LZB
+* /S - Space Shuttle
+  * https://openclipart.org/detail/814/space-shuttle-by-johnny_automatic
+  * PD: Published by the NASA, in "The Brain in Space"
+* /T - SSTV
+  * https://openclipart.org/detail/48997/flat-screen-by-rg1024
+  * Author: rg1024
+  * Adjusted by OH7LZB
+  * PD: https://openclipart.org/share
+* /U - Bus
+  * OH7LZB
+* /V - ATV, amateur television
+  * https://openclipart.org/detail/48997/flat-screen-by-rg1024
+  * Author: rg1024
+  * Adjusted by OH7LZB
+  * PD: https://openclipart.org/share
+* /W - Wx, Weather service site
+  * VEC-OH7LZB
+* /X - Helicopter
+  * OH7LZB
+* /Y - Sailboat
+  * OH7LZB
+* /Z - Windows flag
+  * Microsoft
+* /[ - Human
+  * VEC-OH7LZB
+* /\ - DF triangle
+  * VEC-OH7LZB
+* /] - Mailbox, post office, letter
+* /^ - Large aircraft
+  * https://openclipart.org/detail/183204/plane-red-by-sketchartist-183204
+  * Author: SketchArtist
+  * PD: https://openclipart.org/share
+* /_ - Weather station
+  * VEC-OH7LZB
+* /` - Satellite dish
+  * OH7LZB
+* /a - Ambulance
+  * OH7LZB
+* /b - Bicycle
+  * http://commons.wikimedia.org/wiki/File:Bicycle_evolution-numbers.svg
+  * Author: Wikipedia user: Al2
+  * CC BY 3.0
+* /c - Incident command post
+  * VEC-OH7LZB
+* /d - Fire station
+  * VEC-OH7LZB
+* /e - Horse, equestrian	
+  * https://openclipart.org/detail/142627/horse-riding-lesson-by-olku
+  * Author: OlKu
+  * PD: https://openclipart.org/share
+* /f - Fire truck
+  * OH7LZB
+* /g - Hang glider
+  * OH7LZB
+* /h - Hospital
+  * VEC-OH7LZB
+* /i - IOTA, islands on the air
+  * http://commons.wikimedia.org/wiki/File:Palm_Island_R.svg
+  * PI
+* /j - Jeep
+  * OH7LZB
+* /k - Truck
+  * OH7LZB
+* /l - Laptop
+  * OH7LZB
+* /m - Mic-E repeater
+  * VEC-OH7LZB
+* /n - Node, black bulls-eye
+  * VEC-OH7LZB
+* /o - Emergency operations center
+  * VEC-OH7LZB
+* /p - Dog(e)
+  * OH7LZB
+* /q - Grid square, 2 by 2
+  * VEC-OH7LZB
+* /r - Repeater tower
+  * OH7LZB
+* /s - Ship, power boat
+  * OH7LZB
+* /t - Truck stop
+  * VEC-OH7LZB
+* /u - Semi-trailer truck, 18-wheeler
+  * OH7LZB
+* /v - Van
+  * OH7LZB
+* /w - Water station
+  * VEC-OH7LZB
+* /x - X / Unix
+  * https://commons.wikimedia.org/wiki/File:X11.svg
+  * PD
+* /y - House, yagi antenna
+  * VEC-OH7LZB
+* /z - Shelter
+  * VEC-OH7LZB
+
+
+Secondary table
+------------------
+
+* Emergency
+  * VEC-OH7LZB
+* Numbered digipeater / Green star
+  * VEC-OH7LZB
+* Bank
+  * VEC-OH7LZB
+* Numbered gateway / Black diamond
+  * VEC-OH7LZB
+* Crash site
+  * OH7LZB
+* Cloudy
+  * OH7LZB
+* MEO
+  * VEC-OH7LZB
+* Snowflake
+  * http://commons.wikimedia.org/wiki/File:Snowflake_01.svg
+  * Author: Wikipedia user: Amada44
+  * Public Domain
+* Church
+  * VEC-OH7LZB
+* Girl Scout
+  * VEC-OH7LZB
+  * Looks slightly like the common USA girl scouts logos. Should be different
+    enough to not infringe on "Girl Scouts of the USA" copyrights.
+* Home (HF antenna)
+  * VEC-OH7LZB
+* Unknown position
+  * VEC-OH7LZB
+* Destination
+  * VEC-OH7LZB
+* Numbered circle
+  * VEC-OH7LZB
+
+* Petrol Station
+  * OH7LZB
+* Hail
+  * VEC-OH7LZB
+* Park
+  * VEC-OH7LZB
+* Gale Flag
+  * VEC-OH7LZB
+* Red car from above
+  * OH7LZB
+* Info Kiosk
+  * VEC-OH7LZB
+* Hurricane
+  * OH7LZB
+
+* Numbered white box
+  * VEC-OH7LZB
+* Snow blowing
+  * VEC-OH7LZB
+* Coast Guard
+  * VEC-OH7LZB
+* Drizzle
+  * VEC-OH7LZB
+* Smoke / Chimney
+  * VEC-OH7LZB
+* Freezing rain
+  * VEC-OH7LZB
+* Snow Shwr
+  * VEC-OH7LZB
+* Haze
+  * VEC-OH7LZB
+* Rain Shower
+  * VEC-OH7LZB
+* Lightning
+  * OH7LZB
+* "Kenwood radio"
+  * Kenwood logo, vectorized
+* "Lighthouse"
+  * CC BY-SA 2.0
+  * http://wiki.openstreetmap.org/wiki/File:Lighthouse.svg
+* Nav Buoy
+  * OH7LZB
+* Rocket
+  * http://www.clker.com/clipart-gglkuglug.html
+  * PD according to clker.com license
+* Parking
+  * VEC-OH7LZB
+
+* Earthquake, Restaurant
+  * VEC-OH7LZB
+* Satellite
+  * OH7LZB
+* Thunderstorm
+  * OH7LZB
+* Sunny
+  * OH7LZB
+* VORTAC, Numbered WXS
+  * VEC-OH7LZB
+* Pharmacy Rx
+  * OH7LZB
+* Wall Cloud
+  * OH7LZB
+* Numbered plane
+  * https://openclipart.org/detail/183204/plane-red-by-sketchartist-183204
+  * Author: SketchArtist
+  * PD: https://openclipart.org/share
+* Numbered WX Station
+  * VEC-OH7LZB
+* Rain
+  * Source: http://commons.wikimedia.org/wiki/File:Heavy-rain-shower-transparent.svg
+  * Author: Wikipedia user: Peepo
+  * Public Domain
+  * With modifications by OH7LZB
+
+* Numbered diamond
+  * VEC-OH7LZB
+* Dust blowing
+  * NA
+* Numbered civil defence
+  * VEC-OH7LZB
+* DX spot
+  * VEC-OH7LZB
+* Sleet
+  * NA
+* Funnel Cloud
+  * NA
+* Gale
+  * VEC-OH7LZB
+* Store
+  * https://openclipart.org/detail/89299/cart-medium-by-martins.bruvelis
+  * Author: martins.bruvelis
+  * Public Domain
+  * Adjustments by OH7LZB
+* Numbered black box
+  * VEC-OH7LZB
+* Work zone / Excavator
+  * Based on http://www.clker.com/clipart-292480.html PNG version
+  * Vectorized and colors adjusted by OH7LZB
+  * PD according to clker.com documentation, uploader KURSVEIAL
+* SUV
+  * OH7LZB
+* Milepost, Numbered triangle, Circle sm
+  * VEC-OH7LZB
+* Partly cloudy
+  * OH7LZB
+
+* Restrooms, Numbered boat
+ * VEC-OH7LZB
+* Tornado (also used in Funnel cloud, Skywarn)
+  * https://openclipart.org/detail/104887/tornado-by-laabadon
+  * Author: Laabadon
+  * Public Domain
+* Numbered truck
+  * OH7LZB
+* Numbered van
+  * OH7LZB
+* Flooding
+  * NA
+* Sky warn, Numbered shelter, fog
+  * VEC-OH7LZB
@@ -93,13 +93,17 @@ 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, generate example configs and edit them by hand:
+Alternatively, copy `trx-rs.toml.example` — a commented example covering every
+setting — and edit it by hand:

 ```bash
-./target/release/trx-server --print-config > trx-server.toml
-./target/release/trx-client --print-config > trx-client.toml
+cp trx-rs.toml.example trx-rs.toml
+./target/release/trx-server --check-config --config trx-rs.toml
 ```

+`--check-config` reports everything wrong with a config without starting
+anything. `--print-config` prints the same settings without comments.
+
 ### 4. Run

 ```bash
@@ -107,8 +111,49 @@ Alternatively, generate example configs and edit them by hand:
 ./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 `/usr/local/bin` (using `sudo` only if needed), 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 ~/.local   # install to ~/.local/bin instead
+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
@@ -144,4 +189,7 @@ a unified set of frontends.
 GPL-2.0-or-later. See [`LICENSES`](LICENSES) for the full license text and
 bundled third-party license files. Bundled third-party components retain their
 original licenses: Leaflet is BSD-2-Clause, DSEG is OFL-1.1, and opus-decoder
-is MIT.
+is MIT. The APRS symbol sprites come from
+[hessu/aprs-symbols](https://github.com/hessu/aprs-symbols); their per-symbol
+copyright status is catalogued in
+[`LICENSES/LicenseRef-APRS-Symbols.txt`](LICENSES/LicenseRef-APRS-Symbols.txt).
@@ -56,3 +56,19 @@ SPDX-License-Identifier = "OFL-1.1"
 path = ["src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/opus-decoder-0.7.11.min.js"]
 SPDX-FileCopyrightText = "2021-2025 Ethan Halsall"
 SPDX-License-Identifier = "MIT"
+
+# Vendored APRS symbol sprites (https://github.com/hessu/aprs-symbols), rev H.
+# The set has no single upstream license -- individual symbols carry different
+# terms, catalogued in LICENSES/LicenseRef-APRS-Symbols.txt.  Upstream asks that
+# users point back to https://github.com/hessu/aprs-symbols/.
+[[annotations]]
+path = [
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/aprs-symbols-24-0.png",
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/aprs-symbols-24-1.png",
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/aprs-symbols-24-2.png",
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/aprs-symbols-24-0-2x.png",
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/aprs-symbols-24-1-2x.png",
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/aprs-symbols-24-2-2x.png",
+]
+SPDX-FileCopyrightText = "Heikki Hannikainen OH7LZB and the APRS symbol set authors (https://github.com/hessu/aprs-symbols)"
+SPDX-License-Identifier = "LicenseRef-APRS-Symbols"
@@ -925,9 +925,14 @@ main

 ### HTTP Frontend Auth

- Optional token or HTTP Basic Auth middleware
- Configured in `[frontends.http.auth]`
- Rate limiting supported
+- Optional Argon2id-backed managed accounts with HttpOnly session cookies
+- An exclusive Guest role plus composable Read, Control, Transmit, Write, and Administrator roles, with policy shared by middleware and handlers
+- Guest sessions receive read-only station access but no account-control endpoints or panels
+- 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

@@ -1043,7 +1048,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`, `rx_passphrase`, `session_ttl_secs`, `tokens` |
+| `HttpAuthConfig` | HTTP auth settings | `enabled`, `users_file`, bootstrap admin/read accounts, `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` |
@@ -0,0 +1,287 @@
+# 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,3 +322,269 @@ 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.
@@ -0,0 +1,116 @@
+# 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,13 +121,14 @@ 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: "Enter passphrase to continue"
- Password input + Login button (green accent, full-width)
- Optional "Continue as Guest" button (shown when RX passphrase is not set)
+- Subtitle: "Sign in to continue"
+- Username and password inputs + Login button (green accent, full-width)
 - Error message area (red `#ff6b6b`)
 - Role badge display

-Two roles: **Rx** (read-only) and **Control** (full access including TX/PTT).
+**Guest** provides read-only station access and is exclusive. Non-Guest accounts
+may combine **Read**, **Control**, **Transmit**, **Write**, and **Administrator** roles.
+Administrator implies all permissions.

 Session cookie: `trx_http_sid`, HttpOnly, configurable Secure and SameSite attributes.

@@ -336,25 +337,31 @@ Logo and favicon are embedded at compile time via `include_bytes!`. The logo ima

 ### 7.1 Route Access Classification

-Routes are classified into three tiers:
+Routes are classified into access tiers:

 | Tier | Examples | Requirement |
 |---|---|---|
-| **Public** | `/`, `/index.html`, `/map`, `/auth/*`, static assets | None |
-| **Read** | `/status`, `/events`, `/audio`, `/decode`, `/spectrum`, `/bookmarks` | Rx or Control role |
-| **Control** | `/set_freq`, `/set_mode`, `/set_ptt`, `/toggle_power`, all other POST | Control role only |
+| **Public** | `/`, `/index.html`, `/map`, login/session endpoints, static assets | None |
+| **Read** | `/status`, `/events`, `/audio`, `/decode`, `/spectrum`, `/bookmarks` | Guest, Read, Control, Transmit, or Administrator role |
+| **Control** | `/set_freq`, `/set_mode`, `/toggle_power`, receive-side radio-control POST routes | Control or Administrator role |
+| **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
- Constant-time passphrase comparison to mitigate timing attacks
+- Passwords are verified against salted Argon2id hashes

-### 7.3 TX Access Control
+### 7.3 User Management

-An additional `tx_access_control_enabled` flag can restrict transmit-related actions even
-for Control-role users, providing an extra safety layer.
+Every authenticated non-Guest account gets a Settings > Account tab for changing
+its own password. Guest sees neither Account nor Users and both account-control
+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,30 +17,60 @@ frontends.

 ## Configuration

-Both `trx-server` and `trx-client` use TOML configuration files. Use
-`--print-config` to generate a fully commented example.
+Both `trx-server` and `trx-client` read TOML. The server takes its settings
+from the `[trx-server]` section and the client from `[trx-client]`, so one
+`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

-**trx-server** lookup order:
-1. `--config <FILE>`
-2. `./trx-server.toml`
-3. `~/.trx-server.toml`
-4. `~/.config/trx-rs/server.toml`
-5. `/etc/trx-rs/server.toml`
+Both binaries use the same lookup order:

-**trx-client** lookup order:
 1. `--config <FILE>`
-2. `./trx-client.toml`
-3. `~/.config/trx-rs/client.toml`
-4. `/etc/trx-rs/client.toml`
+2. `./trx-rs.toml`
+3. `~/.config/trx-rs/trx-rs.toml`
+4. `/etc/trx-rs/trx-rs.toml`

 CLI arguments override config file values.

-### Environment Variables
+### Checking a Config

- `TRX_PLUGIN_DIRS`: additional plugin directories (path-separated), used by
-  both server and client.
+`--check-config` loads the file, reports every problem it finds — unknown keys,
+invalid values, listeners fighting over a port — and exits without starting
+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

@@ -96,6 +126,7 @@ CLI arguments override config file values.
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
 | `tokens` | string[] | `[]` | Allowed auth tokens (empty = no auth) |
+| `tokens_file` | string | — | Read tokens from this file, one per line |

 #### `[audio]`

@@ -121,6 +152,13 @@ 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]`

@@ -197,6 +235,29 @@ 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:
@@ -240,12 +301,32 @@ 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]`

@@ -254,6 +335,34 @@ Rigs without an explicit `id` get auto-generated IDs like `ft817_0`, `soapysdr_1
 | `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]`

@@ -261,7 +370,11 @@ Rigs without an explicit `id` get auto-generated IDs like `ft817_0`, `soapysdr_1
 |-------|------|---------|-------------|
 | `enabled` | bool | `false` | Enable Hamlib rigctl |
 | `listen` | ip | `127.0.0.1` | Bind address |
-| `port` | u16 | `4532` | Bind port |
+| `rig_ports` | table | `{}` | Remote name → local port; one listener each |
+
+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]`

@@ -271,13 +384,17 @@ Rigs without an explicit `id` get auto-generated IDs like `ft817_0`, `soapysdr_1
 | `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_port` | u16 | `4531` | Server audio port |
+| `server_url` | string | — | Audio endpoint for every remote |
+| `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 |
@@ -287,68 +404,257 @@ Rigs without an explicit `id` get auto-generated IDs like `ft817_0`, `soapysdr_1
 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`, `--rig`, `--access`, `--callsign`, `--listen`,
-`--port`. SDR options are file-only.
+`--config`, `--print-config`, `--check-config`, `--strict-config`, `--rig`,
+`--access`, `--callsign`, `--listen`, `--port`. SDR options are file-only.

 **trx-client:**
-`--config`, `--print-config`, `--url`, `--token`, `--poll-interval`,
-`--frontend`, `--http-listen`, `--http-port`, `--rigctl-listen`,
-`--rigctl-port`, `--http-json-listen`, `--http-json-port`, `--callsign`.
+`--config`, `--print-config`, `--check-config`, `--strict-config`, `--url`,
+`--token`, `--poll-interval`, `--rig-id`, `--frontend`, `--http-listen`,
+`--http-port`, `--rigctl-listen`, `--http-json-listen`, `--http-json-port`,
+`--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 optional passphrase-based authentication with two
-roles:
+The HTTP frontend supports an optional user/password ACL:

- **rx** — read-only access (monitoring, audio, decode streams)
- **control** — full access (frequency, mode, PTT, and all settings)
+- **Guest** — read-only station access with no Account or Users controls; Guest cannot be combined with another role
+- **Read** — monitoring, audio, decode streams, and bookmark reads
+- **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
-rx_passphrase = "rx-only-passphrase"
-control_passphrase = "full-control-passphrase"
-tx_access_control_enabled = true
+users_file = "trx-http-users.json"
+bootstrap_admin_username = "admin"
+bootstrap_admin_password = "change-this-password"
+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 enabled, at least one passphrase must be set.
+as before. When enabling it for the first time, bootstrap credentials create
+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.
- When `tx_access_control_enabled = true`, TX/PTT controls are hidden and
-  rejected for unauthenticated or `rx`-role users.
+- User records persist in `users_file`; passwords are stored as salted Argon2id hashes.
+- Non-Guest roles are independent; for example, an account may have Read and Write without Control.
+- 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 `{ "passphrase": "..." }` |
+| `/auth/login` | POST | Submit `{ "username": "...", "password": "..." }` |
 | `/auth/logout` | POST | Clear session |
-| `/auth/session` | GET | Check current session/role |
+| `/auth/session` | GET | Check current session/roles |
+| `/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) |

-Protected routes require at least `rx` role. Control routes (set frequency,
-mode, PTT, etc.) require `control` role.
+Read routes accept Guest or require Read. Tuning and receive-side radio mutations
+require Control. PTT, transmitted audio, and TX limit changes require Transmit.
+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. `rx` users see a read-only interface; `control` users get full controls.
+4. The interface enables controls according to the account's roles.
 5. If a session expires mid-use, streams stop and the login screen returns.

 ### Transport Security
@@ -446,9 +752,30 @@ 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. It works by
-tracking a running RMS level of the signal and replacing any sample whose
-magnitude exceeds **threshold x RMS** with the last known clean sample.
+on raw IQ samples before any mixing or filtering takes place — the only point in
+the chain where an impulse is still short in time, since the narrow channel
+filter downstream smears it into un-removable ringing.
+
+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)

@@ -465,6 +792,7 @@ 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]`:
@@ -473,15 +801,30 @@ 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 |
-|-------------|-------|---------|---------|-------------|
-| `enabled`   | bool  | false   | —       | Turn the noise blanker on or off. |
-| `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. |
+| Field       | Type   | Default   | Range   | Description |
+|-------------|--------|-----------|---------|-------------|
+| `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. |
+| `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.
@@ -507,39 +850,44 @@ the running average signal level.

 ### Web UI

-When the server reports noise-blanker support, two controls appear in the
+When the server reports noise-blanker support, these 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 threshold. Press Enter or click Set to apply.
+  detection sensitivity. Press Enter or click Set to apply.
+- **NB profile** selector — chooses the profile (Spike / Ignition / Powerline /
+  Broadband). Changing it applies immediately.

-Both controls stay hidden until the server sends filter state containing NB
+The 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
+POST /set_sdr_noise_blanker?enabled=true&threshold=10&profile=spike
 ```

 | 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 (4096 samples) *before* the mixer stage in
-the DSP pipeline:
+The blanker runs on every IQ block *before* the mixer stage in the DSP pipeline,
+one sample at a time:

-1. For each sample, compute magnitude² (`re² + im²`).
-2. Compare against `threshold² × mean_sq` (the exponentially-smoothed running
-   mean of magnitude²).
-3. If the sample exceeds the threshold, replace it with the previous clean
-   sample.
-4. Otherwise, update the running mean with smoothing factor α = 1/128 and store
-   the sample as the last clean value.
+1. Emit the sample from the look-ahead delay line and ingest the fresh one.
+2. Compute the fresh sample's power (`re² + im²`) and compare it against
+   `threshold² × noise_floor`.
+3. If it exceeds the threshold, hold the gate closed for the profile's blank
+   window; the fresh sample reaches the output a few samples later, by which
+   time the gate has fully ramped to zero — so the leading edge is removed.
+4. Otherwise, update the noise-floor estimate (skipped while blanking) and let
+   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
@@ -0,0 +1,38 @@
+# 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@|/usr/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
@@ -0,0 +1,38 @@
+# 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@|/usr/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
@@ -0,0 +1,156 @@
+#!/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:-/usr/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: /usr/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."
@@ -0,0 +1,86 @@
+#!/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:-/usr/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: /usr/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."
@@ -0,0 +1,14 @@
+# 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"
@@ -0,0 +1,91 @@
+// 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
+        );
+    }
+}
@@ -0,0 +1,17 @@
+// 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>,
+}
@@ -0,0 +1,659 @@
+// 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));
+    }
+}
@@ -0,0 +1,297 @@
+// 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"
+        );
+    }
+}
@@ -0,0 +1,238 @@
+// 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",
+        );
+    }
+}
@@ -0,0 +1,150 @@
+// 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());
+    }
+}
@@ -0,0 +1,36 @@
+// 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};
@@ -0,0 +1,615 @@
+// 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);
+    }
+}
@@ -0,0 +1,236 @@
+// 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);
+    }
+}
@@ -0,0 +1,384 @@
+// 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,8 +45,20 @@ impl WefaxConfig {
        60.0 / lpm as f32
    }

-    /// Samples per line at the internal sample rate.
+    /// Samples per line at the internal sample rate (rounded to an integer;
+    /// 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,10 +38,24 @@ 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 trigger auto-finalize
-/// while receiving. At 120 LPM this is 15 s; at 60 LPM it's 30 s. Modelled on
-/// fldigi's line-to-line correlation check for automatic stop.
-const LINE_CORR_NOISE_LINES: u32 = 30;
+/// Number of consecutive uncorrelated scan lines that mark the end of a
+/// transmission (carrier truly gone) and trigger auto-finalize. This must be
+/// long enough to ride through ordinary HF fading (QSB), which routinely
+/// decorrelates adjacent lines for several seconds without the transmission
+/// 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
@@ -107,6 +121,12 @@ 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).
@@ -135,6 +155,7 @@ 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(),
        }
@@ -204,7 +225,13 @@ 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 {
@@ -340,6 +367,14 @@ 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 =
@@ -402,6 +437,7 @@ impl WefaxDecoder {
        self.signal_detect_buf.clear();
        self.low_corr_lines = 0;
        self.phasing_samples = 0;
+        self.auto_start_used = false;
        events
    }

@@ -434,6 +470,7 @@ 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()
@@ -463,6 +500,7 @@ 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)
    }
@@ -596,4 +634,47 @@ 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 {
-    /// Samples per line at the internal sample rate.
-    samples_per_line: usize,
+    /// Exact (fractional) samples per line at the internal sample rate.
+    samples_per_line: f64,
    /// Pixels per line (IOC × π).
    pixels_per_line: usize,
    /// Phase offset in samples from the phasing detector.
@@ -22,22 +22,37 @@ 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(lpm, sample_rate);
+        let samples_per_line = WefaxConfig::samples_per_line_f64(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 * 2),
+            buffer: Vec::with_capacity(samples_per_line as usize * 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
@@ -56,12 +71,18 @@ 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;
-        while offset + self.samples_per_line <= self.buffer.len() {
-            let line_samples = &self.buffer[offset..offset + self.samples_per_line];
-            let pixels = self.resample_line(line_samples);
-            lines.push(pixels);
-            offset += self.samples_per_line;
+        loop {
+            let len = self.line_len(self.line_index);
+            if offset + len > self.buffer.len() {
+                break;
+            }
+            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);
@@ -77,6 +98,7 @@ 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
@@ -129,6 +151,29 @@ 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,8 +77,12 @@ 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 = 1.0; // fldigi uses 2 consecutive half-second windows
+        let min_sustain_s = 2.0;
        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,9 +9,5 @@ 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"
@@ -1,88 +0,0 @@
-// 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

-pub mod config;
+//! Shared application helpers.
+//!
+//! 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;
@@ -21,6 +21,7 @@ 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_STREAM_INFO,
-    AUDIO_MSG_TX_FRAME, AUDIO_MSG_VCHAN_ALLOCATED, AUDIO_MSG_VCHAN_BW, AUDIO_MSG_VCHAN_DESTROYED,
-    AUDIO_MSG_VCHAN_FREQ, AUDIO_MSG_VCHAN_MODE, AUDIO_MSG_VCHAN_REMOVE, AUDIO_MSG_VCHAN_SUB,
-    AUDIO_MSG_VCHAN_UNSUB, AUDIO_MSG_VDES_DECODE, AUDIO_MSG_WEFAX_DECODE, AUDIO_MSG_WEFAX_PROGRESS,
-    AUDIO_MSG_WSPR_DECODE,
+    AUDIO_MSG_LRPT_PROGRESS, AUDIO_MSG_RX_FRAME, AUDIO_MSG_RX_FRAME_CH, AUDIO_MSG_SSTV_DECODE,
+    AUDIO_MSG_SSTV_PROGRESS, AUDIO_MSG_STREAM_INFO, AUDIO_MSG_TX_FRAME, AUDIO_MSG_VCHAN_ALLOCATED,
+    AUDIO_MSG_VCHAN_BW, AUDIO_MSG_VCHAN_DESTROYED, AUDIO_MSG_VCHAN_FREQ, AUDIO_MSG_VCHAN_MODE,
+    AUDIO_MSG_VCHAN_REMOVE, AUDIO_MSG_VCHAN_SUB, AUDIO_MSG_VCHAN_UNSUB, AUDIO_MSG_VDES_DECODE,
+    AUDIO_MSG_WEFAX_DECODE, AUDIO_MSG_WEFAX_PROGRESS, AUDIO_MSG_WSPR_DECODE,
 };
 use trx_core::decode::DecodedMessage;
 use trx_frontend::VChanAudioCmd;
@@ -533,7 +533,9 @@ 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,6 +20,7 @@ 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;
@@ -50,6 +51,12 @@ 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>,
@@ -74,7 +81,7 @@ struct Cli {
    /// rigctl frontend listen address
    #[arg(long = "rigctl-listen")]
    rigctl_listen: Option<IpAddr>,
-    /// rigctl frontend listen port
+    /// Deprecated: ignored, use [frontends.rigctl].rig_ports
    #[arg(long = "rigctl-port")]
    rigctl_port: Option<u16>,
    /// JSON TCP frontend listen address
@@ -109,6 +116,65 @@ 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>,
@@ -135,20 +201,44 @@ async fn async_init() -> DynResult<AppState> {
        std::process::exit(0);
    }

-    let (cfg, config_path) = if let Some(ref path) = cli.config {
-        let cfg = ClientConfig::load_from_file(path)?;
-        (cfg, Some(path.clone()))
+    let loaded = if let Some(ref path) = cli.config {
+        ClientConfig::load_from_file(path)?
    } else {
        ClientConfig::load_from_default_paths()?
    };
-    cfg.validate()
-        .map_err(|e| format!("Invalid client configuration: {}", e))?;
+    let config_path = loaded.path.clone();

-    init_logging(cfg.general.log_level.as_deref());
+    if cli.check_config {
+        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
@@ -162,11 +252,17 @@ 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.rx_passphrase = cfg.frontends.http.auth.rx_passphrase.clone();
-    frontend_runtime.http_auth.control_passphrase =
-        cfg.frontends.http.auth.control_passphrase.clone();
-    frontend_runtime.http_auth.tx_access_control_enabled =
-        cfg.frontends.http.auth.tx_access_control_enabled;
+    frontend_runtime.http_auth.users_file = cfg.frontends.http.auth.users_file.clone();
+    frontend_runtime.http_auth.bootstrap_admin_username =
+        cfg.frontends.http.auth.bootstrap_admin_username.clone();
+    frontend_runtime.http_auth.bootstrap_admin_password =
+        cfg.frontends.http.auth.bootstrap_admin_password.clone();
+    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 {
@@ -189,6 +285,10 @@ 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 {
@@ -198,10 +298,14 @@ 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 { token },
+            auth: config::RemoteAuthConfig {
+                token,
+                token_file: None,
+            },
            poll_interval_ms,
        }]
    } else {
@@ -262,6 +366,30 @@ 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()
@@ -366,6 +494,13 @@ 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 {
@@ -379,6 +514,8 @@ 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(),
@@ -527,6 +664,9 @@ 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,35 +20,22 @@ 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};
+use trx_protocol::{ClientCommand, ClientEnvelope, ClientResponse, MeterUpdate, SpectrumFrame};
+
+// 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;

-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct RemoteEndpoint {
-    pub host: String,
-    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);
+// Default spectrum cadence when a config does not specify one.  Both the push
+// stream and the poll fallback run at the configured rate; see
+// `[[remotes]].spectrum_interval_ms`.
+pub const DEFAULT_SPECTRUM_INTERVAL: Duration = Duration::from_millis(50);

 #[derive(Clone)]
 pub struct RemoteClientConfig {
@@ -57,6 +44,12 @@ 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.
@@ -505,6 +498,100 @@ 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,
@@ -512,7 +599,33 @@ 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();

@@ -1195,92 +1308,13 @@ 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;
@@ -1475,6 +1509,8 @@ 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())),
@@ -1520,6 +1556,8 @@ 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())),
@@ -1535,6 +1573,130 @@ 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());
@@ -1548,6 +1710,8 @@ 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())),
@@ -1580,6 +1744,8 @@ 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())),
@@ -1604,6 +1770,8 @@ 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())),
@@ -1644,6 +1812,8 @@ 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())),
@@ -1717,6 +1887,8 @@ 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, VdesMessage, WefaxMessage,
-    WsprMessage,
+    AisMessage, AprsPacket, CwEvent, DecodedMessage, Ft8Message, SstvMessage, VdesMessage,
+    WefaxMessage, WsprMessage,
 };
 use trx_core::rig::state::{RigSnapshot, SpectrumData};
 use trx_core::{DynResult, RigRequest, RigState};
@@ -233,6 +233,7 @@ pub struct DecodeHistoryContext {
    pub ft2: DecodeHistory<Ft8Message>,
    pub wspr: DecodeHistory<WsprMessage>,
    pub wefax: DecodeHistory<WefaxMessage>,
+    pub sstv: DecodeHistory<SstvMessage>,
 }

 impl Default for DecodeHistoryContext {
@@ -248,6 +249,7 @@ 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())),
        }
    }
 }
@@ -255,9 +257,12 @@ impl Default for DecodeHistoryContext {
 /// HTTP authentication configuration.
 pub struct HttpAuthConfig {
    pub enabled: bool,
-    pub rx_passphrase: Option<String>,
-    pub control_passphrase: Option<String>,
-    pub tx_access_control_enabled: bool,
+    pub users_file: String,
+    pub bootstrap_admin_username: Option<String>,
+    pub bootstrap_admin_password: Option<String>,
+    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,
@@ -269,9 +274,12 @@ impl Default for HttpAuthConfig {
    fn default() -> Self {
        Self {
            enabled: false,
-            rx_passphrase: None,
-            control_passphrase: None,
-            tx_access_control_enabled: true,
+            users_file: "trx-http-users.json".to_string(),
+            bootstrap_admin_username: None,
+            bootstrap_admin_password: None,
+            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(),
@@ -290,6 +298,10 @@ 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 {
@@ -303,6 +315,8 @@ 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,6 +11,8 @@ 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"] }
@@ -26,7 +28,11 @@ 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,3 +1,7 @@
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore,
  hostState
@@ -140,18 +144,22 @@ 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 vessels = aisLatestByVessel(aisMessageHistory);
+  const rigMessages = aisRigMessages();
+  const vessels = aisLatestByVessel(rigMessages);
  if (aisVesselCountEl) {
    const count = vessels.length;
    aisVesselCountEl.textContent = `${count} vessel${count === 1 ? "" : "s"}`;
  }
  if (aisLatestSeenEl) {
-    const latest = aisMessageHistory[0];
+    const latest = rigMessages[0];
    if (!latest) {
      aisLatestSeenEl.textContent = "No traffic yet";
    } else {
@@ -160,8 +168,18 @@ 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("div");
+  const row = document.createElement("details");
  row.className = "ais-message";
  const ts = msg._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], {
    hour: "2-digit",
@@ -174,7 +192,8 @@ 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)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>` : "";
+  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 vesselUrl = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
  row.dataset.filterText = [
    name,
    msg.mmsi,
@@ -185,7 +204,16 @@ function renderAisRow(msg) {
    msg.destination,
    aisTypeLabel(msg.message_type)
  ].filter(Boolean).join(" ").toUpperCase();
-  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.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.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;
 }
@@ -202,7 +230,9 @@ function updateAisBar() {
  updateAisSummary();
  const isAis = (document.getElementById("mode")?.value || "").toUpperCase() === "AIS";
  const cutoffMs = Date.now() - AIS_BAR_WINDOW_MS;
-  const recent = aisMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
+  const recent = aisMessageHistory.filter(
+    (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";
@@ -247,7 +277,7 @@ function renderAisHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of aisMessageHistory) {
+  for (const message of aisRigMessages()) {
    fragment.appendChild(renderAisRow(message));
  }
  aisMessagesEl.replaceChildren(fragment);
@@ -265,9 +295,11 @@ function addAisMessage(msg) {
  pruneAisMessageHistory();
  scheduleAisBarUpdate();
  scheduleAisHistoryRender();
-  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
-    aisWindow.aisMapAddVessel(msg);
-  }
+  plotAisMessage(msg);
+}
+function plotAisMessage(msg) {
+  if (msg.lat == null || msg.lon == null || !aisWindow.aisMapAddVessel) return;
+  aisWindow.aisMapAddVessel(msg);
 }
 function normalizeServerAisMessage(msg) {
  return {
@@ -277,10 +309,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([], {
@@ -288,9 +320,7 @@ function onServerAisBatch(messages) {
      minute: "2-digit",
      second: "2-digit"
    });
-    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
-      aisWindow.aisMapAddVessel(next);
-    }
+    plotAisMessage(next);
    normalized.push(next);
  }
  normalized.reverse();
@@ -322,8 +352,9 @@ if (aisFilterInput) {
  });
 }
 function onServerAis(msg) {
-  if (aisStatus) aisStatus.textContent = "Receiving";
-  addAisMessage(normalizeServerAisMessage(msg));
+  const message = normalizeServerAisMessage(msg);
+  if (aisStatus && isActiveRigDecode(message.rig_id)) aisStatus.textContent = "Receiving";
+  addAisMessage(message);
 }
 updateAisSummary();
 window.trxPluginRuntime.registerDecoder({
@@ -332,5 +363,13 @@ 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,13 +1,14 @@
 import {
  aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsInfo,
-  renderLocalAprsSymbol
-} from "./chunk-M2I6DH4X.js";
+  renderAprsPacketRow
+} from "./chunk-REYSUJQ4.js";
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore,
  hostState
@@ -85,20 +86,25 @@ function aprsFilterMatch(pkt) {
  ].filter(Boolean).join(" ").toUpperCase();
  return haystack.includes(aprsFilterText);
 }
+function aprsRigPackets() {
+  return forActiveRig(aprsPacketHistory);
+}
 function aprsVisiblePackets() {
-  const packets = aprsCollapseDup ? collapseAprsDuplicates(aprsPacketHistory) : aprsPacketHistory;
+  const rigPackets = aprsRigPackets();
+  const packets = aprsCollapseDup ? collapseAprsDuplicates(rigPackets) : rigPackets;
  return packets.filter(aprsFilterMatch);
 }
 function updateAprsSummary() {
+  const rigPackets = aprsRigPackets();
  const visible = aprsVisiblePackets();
  if (aprsTotalCountEl) {
-    aprsTotalCountEl.textContent = `${aprsPacketHistory.length} total`;
+    aprsTotalCountEl.textContent = `${rigPackets.length} total`;
  }
  if (aprsVisibleCountEl) {
    aprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (aprsLatestSeenEl) {
-    const latest = aprsPacketHistory[0];
+    const latest = rigPackets[0];
    if (!latest) {
      aprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -114,51 +120,30 @@ function updateAprsChipState() {
  aprsHideCrcBtn?.classList.toggle("active", aprsHideCrc);
  aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }
-function renderAprsRow(pkt, isFresh) {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  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("[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);
-        }
-      })();
-    });
+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);
  }
-  return row;
+}
+function renderAprsRow(pkt, isFresh) {
+  return renderAprsPacketRow(pkt, {
+    fresh: isFresh,
+    distance: aprsDistanceText(pkt),
+    onMap: (lat, lon) => {
+      aprsWindow.navigateToAprsMap?.(lat, lon);
+    },
+    onCopy: (text) => {
+      void copyAprsCoords(text);
+    },
+    onLog: (call, gridsquare) => {
+      aprsWindow.logContact?.({ call, gridsquare: gridsquare ?? void 0, decoder: "aprs" });
+    }
+  });
 }
 function renderAprsHistory() {
  pruneAprsPacketHistory();
@@ -180,7 +165,9 @@ 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((p) => p.crcOk && (p._tsMs ?? 0) >= cutoffMs);
+  const okFrames = aprsPacketHistory.filter(
+    (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) {
@@ -223,15 +210,17 @@ 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();
-  if (pkt.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
-    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
-  }
+  plotAprsPacket(pkt);
  if (pkt.crcOk) scheduleAprsBarUpdate();
  scheduleAprsHistoryRender();
 }
@@ -240,17 +229,15 @@ 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" });
-    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
-      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
-    }
+    plotAprsPacket(next);
    if (next.crcOk) hasCrcOk = true;
    normalized.push(next);
  }
@@ -304,8 +291,9 @@ if (aprsFilterInput) {
  });
 }
 function onServerAprs(pkt) {
-  if (aprsStatus) aprsStatus.textContent = "Receiving";
-  addAprsPacket(normalizeServerAprsPacket(pkt));
+  const packet = normalizeServerAprsPacket(pkt);
+  if (aprsStatus && isActiveRigDecode(packet.rig_id)) aprsStatus.textContent = "Receiving";
+  addAprsPacket(packet);
 }
 renderAprsHistory();
 window.trxPluginRuntime.registerDecoder({
@@ -314,5 +302,13 @@ 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,3 +1,6 @@
+import {
+  hasAuthRole
+} from "./chunk-PISLBJGN.js";
 import {
  hostState
 } from "./chunk-KL66PICH.js";
@@ -13,15 +16,17 @@ var bgdWindow = window;
      return d.id;
    });
  }
-  let backgroundDecodeRole = null;
+  let backgroundDecodeRoles = [];
  let currentRigId = null;
  let currentConfig = null;
  let bookmarkList = [];
  let statusInterval = null;
  let bgdDirty = false;
-  function initBackgroundDecode(rigId, role) {
-    backgroundDecodeRole = role;
-    currentRigId = rigId || null;
+  let statusByBookmark = /* @__PURE__ */ new Map();
+  let lastStatus = null;
+  function initBackgroundDecode(rigId, roles) {
+    backgroundDecodeRoles = roles;
+    currentRigId = rigId || hostState.lastActiveRigId || null;
    if (currentRigId) loadBackgroundDecode();
    startStatusPolling();
  }
@@ -108,7 +113,7 @@ var bgdWindow = window;
    }
    setCheckbox("background-decode-enabled", currentConfig.enabled);
    renderBookmarkChecklist();
-    const isControl = backgroundDecodeRole === "control" || hostState.authEnabled === false;
+    const isControl = isControlRole();
    const panel = document.getElementById("background-decode-panel");
    if (panel) {
      panel.querySelectorAll("input, select, button.sch-write").forEach(function(el) {
@@ -119,6 +124,10 @@ 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");
@@ -134,20 +143,49 @@ var bgdWindow = window;
      return text.indexOf(filter) >= 0;
    }) : all;
    if (filtered.length === 0) {
-      container.innerHTML = '<div class="bgd-checklist-empty">' + (all.length === 0 ? "No supported bookmarks available." : "No bookmarks match filter.") + "</div>";
+      container.innerHTML = '<div class="bgd-checklist-empty">' + escHtml(emptyListText(all.length)) + "</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 checked = selectedIds.has(bookmark.id) ? " checked" : "";
-      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>";
+      const selected = selectedIds.has(bookmark.id);
+      if (selected) row.classList.add("is-selected");
+      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) {
@@ -182,7 +220,7 @@ var bgdWindow = window;
    }).catch(function(err) {
      showToast(`Save failed: ${errorMessage(err)}`, true);
    }).finally(function() {
-      if (btn) btn.disabled = false;
+      syncSaveButton();
    });
  }
  async function resetBackgroundDecode() {
@@ -210,59 +248,83 @@ var bgdWindow = window;
    });
  }
  function renderStatus(status) {
-    const card = document.getElementById("background-decode-status-card");
-    if (!card) return;
-    const entries = status.entries ?? [];
-    if (!entries.length) {
-      card.textContent = "No background decode bookmarks configured.";
+    lastStatus = status;
+    statusByBookmark = new Map(
+      (status.entries ?? []).filter((entry) => typeof entry.bookmark_id === "string" && entry.bookmark_id.length > 0).map((entry) => [entry.bookmark_id, entry])
+    );
+    renderSpanSummary();
+    renderBookmarkChecklist(currentFilterText());
+  }
+  function renderSpanSummary() {
+    const el = document.getElementById("bgd-span-summary");
+    if (!el) return;
+    const status = lastStatus;
+    if (!status) {
+      el.textContent = "";
      return;
    }
-    const summary = [];
-    if (status.active_rig) {
-      if (typeof status.center_hz === "number" && Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
-      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.");
+    if (!status.active_rig) {
+      el.textContent = "This rig is not the one playing audio.";
+      el.dataset.tone = "warn";
+      return;
+    }
+    const centre = typeof status.center_hz === "number" && Number.isFinite(status.center_hz) ? formatFreq(status.center_hz) : null;
+    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 "✓ Active";
+        return "Decoding";
      case "out_of_span":
-        return "△ Out of span";
+        return "Out of span";
      case "waiting_for_spectrum":
-        return "△ Waiting";
+        return "Waiting for spectrum";
      case "waiting_for_user":
-        return "△ No user";
+        return "Nobody listening";
      case "missing_bookmark":
-        return "✗ Missing";
+        return "Bookmark gone";
      case "no_supported_decoders":
-        return "✗ Unsupported";
+        return "No decoder";
      case "disabled":
-        return "△ Disabled";
+        return "Off";
      case "handled_by_scheduler":
-        return "△ Scheduler";
      case "scheduler_has_control":
-        return "△ Scheduler";
+        return "Scheduler has it";
      case "handled_by_virtual_channel":
-        return "△ VChan";
+        return "On a channel";
+      case "pending":
+        return "Not saved";
      default:
-        return "△ Inactive";
+        return "Idle";
    }
  }
  function setCheckbox(id, value) {
@@ -285,13 +347,21 @@ var bgdWindow = window;
  function markBgdDirty() {
    if (bgdDirty) return;
    bgdDirty = true;
-    const btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.classList.add("sch-dirty");
+    syncSaveButton();
  }
  function clearBgdDirty() {
    bgdDirty = false;
+    syncSaveButton();
+  }
+  function syncSaveButton() {
    const btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.classList.remove("sch-dirty");
+    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() {
+    return hasAuthRole(backgroundDecodeRoles, "control") || hostState.authEnabled === false;
  }
  function showToast(msg, isError) {
    const el = document.getElementById("background-decode-toast");
@@ -311,7 +381,7 @@ var bgdWindow = window;
      return bm.id;
    });
    currentConfig.bookmark_ids = ids;
-    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
+    renderBookmarkChecklist(currentFilterText());
    markBgdDirty();
  }
  function deselectAllBookmarks() {
@@ -319,7 +389,7 @@ var bgdWindow = window;
      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
    }
    currentConfig.bookmark_ids = [];
-    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
+    renderBookmarkChecklist(currentFilterText());
    markBgdDirty();
  }
  function wireBackgroundDecodeEvents() {
@@ -334,7 +404,9 @@ 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,3 +1,6 @@
+import {
+  hasAuthRole
+} from "./chunk-PISLBJGN.js";
 import {
  hostCore,
  hostState
@@ -42,7 +45,7 @@ function bmEsc(str) {
  return d.innerHTML;
 }
 function bmCanControl() {
-  return !hostState.authEnabled || hostState.authRole === "control";
+  return !hostState.authEnabled || hasAuthRole(hostState.authRoles, "write");
 }
 function bmSyncAccess() {
  const canCtrl = bmCanControl();
@@ -211,6 +214,12 @@ 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;
@@ -224,7 +233,9 @@ 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();
@@ -260,6 +271,7 @@ 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) {
@@ -276,7 +288,8 @@ async function bmSave(e) {
    locator: locator || null,
    category,
    comment,
-    decoders
+    decoders,
+    dig_sideband
  };
  try {
    let resp;
@@ -328,6 +341,7 @@ 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;
@@ -340,6 +354,12 @@ 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));
@@ -592,6 +612,7 @@ 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,112 +0,0 @@
-// 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;
-}
-function renderLocalAprsSymbol(packet, escapeHtml) {
-  if (!packet.symbolTable || !packet.symbolCode) return "";
-  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,
-  renderLocalAprsSymbol,
-  normalizeAprsPacket
-};
@@ -0,0 +1,136 @@
+// 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
+};
@@ -0,0 +1,273 @@
+// 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,18 @@
+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,3 +1,7 @@
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -148,14 +152,33 @@ 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 history) {
+    for (const message of rigMessages) {
      if (count >= 200) break;
      if (filterText && !(message.message ?? "").toUpperCase().includes(filterText)) continue;
      fragment.appendChild(renderRow(message));
@@ -163,20 +186,26 @@ function initializeFtxDecoder(config) {
    }
    messagesElement.replaceChildren(fragment);
  };
-  const normalize = (message) => {
+  const plotLocator = (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);
-    if (grids.length > 0) {
-      bridge.mapAddLocator?.(raw, grids, id, station, {
-        ...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) => {
+    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,
@@ -188,7 +217,9 @@ function initializeFtxDecoder(config) {
  };
  const receiveBatch = (messages) => {
    if (messages.length === 0) return;
-    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);
@@ -202,7 +233,7 @@ function initializeFtxDecoder(config) {
    bridge.clearMapMarkersByType?.(id);
  };
  const barFrames = () => {
-    const recent = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 9e5).slice(0, 8);
+    const recent = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 9e5 && isActiveRigDecode(message.rig_id)).slice(0, 8);
    let html = "";
    for (const message of recent) {
      const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
@@ -226,7 +257,15 @@ 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,3 +1,6 @@
+import {
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -25,7 +28,7 @@ var CW_BAR_LINE_GAP_MS = 5e3;
 var cwLastAppendTime = 0;
 var cwTonePickerRaf = null;
 var cwBarHistory = [];
-var cwBarCurrentLine = null;
+var cwBarCurrentLines = /* @__PURE__ */ new Map();
 var cwBarDismissedAtMs = 0;
 var cwAutoLocalOverride = null;
 function escapeCwHtml(input) {
@@ -50,20 +53,22 @@ cwWindow.applyCwAutoUiFromServer = function(enabled) {
  if (cwAutoLocalOverride !== null) return;
  applyCwAutoUi(enabled);
 };
-function cwBarFlushCurrentLine() {
-  if (cwBarCurrentLine && cwBarCurrentLine.text.trim()) {
-    cwBarHistory.unshift(cwBarCurrentLine);
+function cwBarFlushCurrentLine(key) {
+  const line = cwBarCurrentLines.get(key);
+  cwBarCurrentLines.delete(key);
+  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);
-  const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
+  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs && isActiveRigDecode(l.rigId));
+  const inProgress = [...cwBarCurrentLines.values()].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";
@@ -308,7 +313,7 @@ function resetCwHistoryView() {
  if (cwOutputEl) cwOutputEl.innerHTML = "";
  cwLastAppendTime = 0;
  cwBarHistory = [];
-  cwBarCurrentLine = null;
+  cwBarCurrentLines.clear();
  updateCwBar();
  drawCwTonePicker();
 }
@@ -324,8 +329,9 @@ document.getElementById("settings-clear-cw-history")?.addEventListener("click",
  })();
 });
 function onServerCw(evt) {
-  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
-  if (evt.text && cwOutputEl) {
+  const forSelectedRig = isActiveRigDecode(evt.rig_id ?? null);
+  if (cwStatusEl && forSelectedRig) cwStatusEl.textContent = "Receiving";
+  if (evt.text && cwOutputEl && forSelectedRig) {
    const now = Date.now();
    if (!cwOutputEl.lastElementChild || now - cwLastAppendTime > 1e4 || evt.text === "\n") {
      const line = document.createElement("div");
@@ -346,25 +352,29 @@ function onServerCw(evt) {
  }
  if (evt.text) {
    const now = Date.now();
+    const rigId = evt.rig_id ?? null;
+    const key = rigId ?? "";
    if (evt.text === "\n") {
-      cwBarFlushCurrentLine();
+      cwBarFlushCurrentLine(key);
    } else {
-      if (!cwBarCurrentLine || now - cwBarCurrentLine.lastMs > CW_BAR_LINE_GAP_MS) {
-        cwBarFlushCurrentLine();
+      let line = cwBarCurrentLines.get(key);
+      if (!line || now - line.lastMs > CW_BAR_LINE_GAP_MS) {
+        cwBarFlushCurrentLine(key);
        const ts = new Date(now).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-        cwBarCurrentLine = { tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
+        line = { rigId, tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
+        cwBarCurrentLines.set(key, line);
      }
-      cwBarCurrentLine.text += evt.text;
-      cwBarCurrentLine.lastMs = now;
-      if (Number.isFinite(Number(evt.wpm))) cwBarCurrentLine.wpm = clampCwWpm(evt.wpm);
-      if (Number.isFinite(Number(evt.tone_hz))) cwBarCurrentLine.tone_hz = Math.round(Number(evt.tone_hz));
+      line.text += evt.text;
+      line.lastMs = now;
+      if (Number.isFinite(Number(evt.wpm))) line.wpm = clampCwWpm(evt.wpm);
+      if (Number.isFinite(Number(evt.tone_hz))) line.tone_hz = Math.round(Number(evt.tone_hz));
    }
    updateCwBar();
  }
-  if (cwSignalIndicator) {
+  if (cwSignalIndicator && forSelectedRig) {
    cwSignalIndicator.className = evt.signal_on ? "cw-signal-on" : "cw-signal-off";
  }
-  if (!cwAutoInput || cwAutoInput.checked) {
+  if (forSelectedRig && (!cwAutoInput || cwAutoInput.checked)) {
    if (cwWpmInput && Number.isFinite(Number(evt.wpm))) {
      cwWpmInput.value = String(clampCwWpm(evt.wpm));
    }
@@ -389,7 +399,14 @@ 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"];
+  var HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax", "sstv"];
  var workerScope = self;
  function decodeCborUint(view, bytes, state, additional) {
    const offset = state.offset;
@@ -1,6 +1,7 @@
 import {
  initializeFtxDecoder
-} from "./chunk-O2Y7YEVQ.js";
+} from "./chunk-WU5EWJX4.js";
+import "./chunk-S57W63QN.js";
 import "./chunk-KL66PICH.js";

 // src/plugins/ft2.ts
@@ -1,6 +1,7 @@
 import {
  initializeFtxDecoder
-} from "./chunk-O2Y7YEVQ.js";
+} from "./chunk-WU5EWJX4.js";
+import "./chunk-S57W63QN.js";
 import "./chunk-KL66PICH.js";

 // src/plugins/ft4.ts
@@ -2,7 +2,8 @@ import {
  initializeFt8FamilyBar,
  initializeFtxDecoder,
  installFtxCompatibilityHelpers
-} from "./chunk-O2Y7YEVQ.js";
+} from "./chunk-WU5EWJX4.js";
+import "./chunk-S57W63QN.js";
 import "./chunk-KL66PICH.js";

 // src/plugins/ft8.ts
@@ -1,13 +1,14 @@
 import {
  aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsInfo,
-  renderLocalAprsSymbol
-} from "./chunk-M2I6DH4X.js";
+  renderAprsPacketRow
+} from "./chunk-REYSUJQ4.js";
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore,
  hostState
@@ -15,7 +16,6 @@ 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,21 +71,26 @@ function hfAprsFilterMatch(pkt) {
  ].filter(Boolean).join(" ").toUpperCase();
  return haystack.includes(hfAprsFilterText);
 }
+function hfAprsRigPackets() {
+  return forActiveRig(hfAprsPacketHistory);
+}
 function hfAprsVisiblePackets() {
-  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(hfAprsPacketHistory) : hfAprsPacketHistory;
+  const rigPackets = hfAprsRigPackets();
+  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 = `${hfAprsPacketHistory.length} total`;
+    hfAprsTotalCountEl.textContent = `${rigPackets.length} total`;
  }
  if (hfAprsVisibleCountEl) {
    hfAprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (hfAprsLatestSeenEl) {
-    const latest = hfAprsPacketHistory[0];
+    const latest = rigPackets[0];
    if (!latest) {
      hfAprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -102,51 +107,27 @@ function updateHfAprsChipState() {
  hfAprsCollapseDupBtn?.classList.toggle("active", hfAprsCollapseDup);
 }
 function renderHfAprsRow(pkt, isFresh) {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  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">${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);
-      }
-    });
+  return renderAprsPacketRow(pkt, {
+    fresh: isFresh,
+    badge: "HF",
+    distance: hfAprsDistanceText(pkt),
+    onMap: (lat, lon) => {
+      hfAprsWindow.navigateToAprsMap?.(lat, lon);
+    },
+    onCopy: (text) => {
+      void copyHfAprsCoords(text);
+    }
  });
-  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);
-            hostCore.showHint("Coordinates copied", 1200);
-          }
-        } catch {
-          hostCore.showHint("Copy failed", 1500);
-        }
-      })();
-    });
+}
+async function copyHfAprsCoords(text) {
+  try {
+    const clipboard = Reflect.get(navigator, "clipboard");
+    if (!clipboard) return;
+    await clipboard.writeText(text);
+    hostCore.showHint("Coordinates copied", 1200);
+  } catch {
+    hostCore.showHint("Copy failed", 1500);
  }
-  return row;
 }
 function renderHfAprsHistory() {
  pruneHfAprsPacketHistory();
@@ -168,17 +149,32 @@ 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) {
@@ -186,13 +182,14 @@ 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();
@@ -255,8 +252,9 @@ if (hfAprsFilterInput) {
  });
 }
 function onServerHfAprs(pkt) {
-  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
+  const packet = normalizeServerHfAprsPacket(pkt);
+  if (hfAprsStatus && isActiveRigDecode(packet.rig_id)) hfAprsStatus.textContent = "Receiving";
+  addHfAprsPacket(packet);
 }
 renderHfAprsHistory();
 window.trxPluginRuntime.registerDecoder({
@@ -265,5 +263,10 @@ 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);
+  }
 });
@@ -0,0 +1,449 @@
+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,3 +1,7 @@
+import {
+  aprsSymbolSprite
+} from "./chunk-REYSUJQ4.js";
+
 // src/map-core.ts
 function mapEl(id) {
  const element = document.querySelector(`#${CSS.escape(id)}`);
@@ -56,8 +60,9 @@ 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, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
+  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 mapFilter = { ...DEFAULT_MAP_SOURCE_FILTER };
+  const MAP_FILTER_ALL_KEY = "__all";
  const mapLocatorFilter = { phase: "band", bands: /* @__PURE__ */ new Set() };
  let mapSearchFilter = "";
  let mapRigFilter = "";
@@ -123,6 +128,12 @@ 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) {
@@ -144,7 +155,7 @@ var mapWindow = window;
      lineJoin: "round",
      interactive: false
    });
-    track.__trxType = "aprs";
+    track.__trxType = aprsEntrySource(entry);
    track._aprsCall = call;
    entry.track = track;
  }
@@ -376,6 +387,7 @@ 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) {
@@ -391,6 +403,7 @@ 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) {
@@ -834,38 +847,36 @@ var mapWindow = window;
      container.innerHTML = `<span class="map-locator-empty">No ${kind === "band" ? "bands" : "sources"} available</span>`;
      return;
    }
-    let helperText = "";
+    const noun = kind === "band" ? "bands" : "sources";
    const sourceKeys = kind === "source" ? Object.keys(DEFAULT_MAP_SOURCE_FILTER) : [];
-    const noneSelected = kind === "source" && sourceKeys.every((k) => !mapFilter[k]);
-    if (kind === "source") {
-      if (noneSelected) {
-        helperText = "All sources visible — click to filter";
-      }
-    } else if (!(selectedSet instanceof Set) || selectedSet.size === 0) {
-      helperText = `All ${kind === "band" ? "bands" : "sources"} visible by default`;
-    }
+    const showingAll = kind === "source" ? sourceKeys.every((k) => !mapFilter[k]) : !(selectedSet instanceof Set) || selectedSet.size === 0;
+    const allChip = document.createElement("button");
+    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] : !!selectedSet?.has(item.key);
-      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, phase) {
    if (!container) return;
@@ -928,10 +939,8 @@ var mapWindow = window;
      }
    }
    for (const entry of stationMarkers.values()) {
-      if (entry?.type === "aprs" && entry?.visibleInHistoryWindow) {
-        availableSources.add("aprs");
-        break;
-      }
+      if (!entry?.visibleInHistoryWindow) continue;
+      availableSources.add(aprsEntrySource(entry));
    }
    const bandMap = /* @__PURE__ */ new Map();
    for (const entry of locatorMarkers.values()) {
@@ -963,7 +972,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", "bookmark", "ft8", "ft4", "ft2", "wspr"].filter((key) => availableSources.has(key)).map((key) => ({
+    const sourceItems = ["ais", "vdes", "aprs", "hf_aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"].filter((key) => availableSources.has(key)).map((key) => ({
      key,
      label: mapSourceLabel(key),
      color: mapSourceColor(key),
@@ -973,11 +982,10 @@ 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();
@@ -1026,9 +1034,10 @@ var mapWindow = window;
      }
      return parts.join(" ").toLowerCase();
    }
-    if (type === "aprs") {
-      const call = marker?._aprsCall ? String(marker._aprsCall) : "";
-      const entry = stationMarkers.get(call);
+    if (type === "aprs" || type === "hf_aprs") {
+      const key = marker?._aprsCall ? String(marker._aprsCall) : "";
+      const entry = stationMarkers.get(key);
+      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();
@@ -1198,9 +1207,10 @@ var mapWindow = window;
    }
  };
  mapWindow.clearMapMarkersByType = function(type) {
-    if (type === "aprs") {
+    if (type === "aprs" || type === "hf_aprs") {
      selectedAprsTrackCall = null;
-      stationMarkers.forEach((entry) => {
+      stationMarkers.forEach((entry, key) => {
+        if (aprsEntrySource(entry) !== type) return;
        if (entry && entry.marker) {
          if (aprsMap && aprsMap.hasLayer(entry.marker)) entry.marker.removeFrom(aprsMap);
          mapMarkers.delete(entry.marker);
@@ -1209,8 +1219,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") {
@@ -1331,7 +1341,8 @@ var mapWindow = window;
  function applyMapOverlayPanelVisibility() {
    const panel = document.querySelector("#map-stage .map-overlay-panel");
    if (!panel) return;
-    panel.classList.toggle("is-hidden", !mapOverlayPanelVisible);
+    panel.classList.toggle("filters-hidden", !mapOverlayPanelVisible);
+    panel.querySelector(".map-overlay-filters")?.classList.toggle("is-hidden", !mapOverlayPanelVisible);
  }
  function updateMapOverlayToggleButton() {
    const btn = mapEl("map-overlay-toggle-btn");
@@ -1445,13 +1456,15 @@ var mapWindow = window;
        if (!ll) return;
        const entry = stationMarkers.get(marker._aprsCall);
        if (!entry) return;
-        e.popup.setContent(buildAprsPopupHtml(marker._aprsCall, ll.lat, ll.lng, entry.info || "", entry.pkt));
+        const source = aprsEntrySource(entry);
+        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.aprs && !aprsMap.hasLayer(entry.track)) {
+        if (entry.track && aprsMap && mapFilter[source] && !aprsMap.hasLayer(entry.track)) {
          entry.track.addTo(aprsMap);
        }
        selectedAprsTrackCall = String(marker._aprsCall);
-        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor("aprs"), "aprs-radio-path", marker.__trxRigIds);
+        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor(source), "aprs-radio-path", marker.__trxRigIds);
        return;
      }
      if (marker._aisMmsi) {
@@ -1528,7 +1541,13 @@ var mapWindow = window;
        const kind = String(chip.dataset.filterKind || "");
        const key = String(chip.dataset.filterKey || "");
        if (!key) return;
-        if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
+        if (key === MAP_FILTER_ALL_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);
@@ -1643,42 +1662,29 @@ var mapWindow = window;
      return;
    }
    const mapRect = mapContainer.getBoundingClientRect();
-    const width = mapContainer.clientWidth || mapRect.width;
    const footer = document.querySelector(".footer");
-    let bottom = mapIsFullscreen() && stage ? stage.getBoundingClientRect().bottom : window.innerHeight;
-    if (!mapIsFullscreen() && footer) {
+    let bottom = window.innerHeight;
+    if (footer) {
      const fr = footer.getBoundingClientRect();
-      if (fr.top > mapRect.top + 50) bottom = fr.top;
+      if (fr.top > mapRect.top + 50) bottom = Math.min(fr.top, bottom);
    }
-    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));
+    const target = Math.max(0, Math.floor(bottom - mapRect.top - 8));
    mapContainer.style.height = `${target}px`;
    if (aprsMap) aprsMap.invalidateSize();
  }
  function aprsSymbolIcon(symbolTable, symbolCode) {
    if (!symbolTable || !symbolCode) return null;
-    const table = symbolTable === "/" ? "primary" : "alternate";
+    const sprite = aprsSymbolSprite(symbolTable, symbolCode);
+    const html = sprite ? `<div class="aprs-symbol aprs-symbol-marker ${sprite.className}" role="img" style="background-position:${sprite.backgroundPosition}" title="${escapeMapHtml(sprite.label)}" aria-label="${escapeMapHtml(sprite.label)}"></div>` : `<div class="aprs-symbol aprs-symbol-marker aprs-symbol-local" title="${symbolTable === "/" ? "primary" : "alternate"} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`;
    return L.divIcon({
      className: "",
-      html: `<div class="aprs-symbol-local" title="${table} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`,
+      html,
      iconSize: [24, 24],
      iconAnchor: [12, 12],
      popupAnchor: [0, -12]
    });
  }
-  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 = "";
+  function focusMapPosition(lat, lon) {
    initAprsMap();
    sizeAprsMapToViewport();
    if (aprsMap) {
@@ -1690,19 +1696,10 @@ var mapWindow = window;
        });
      });
    }
-  };
-  mapWindow.navigateToMapLocator = function(grid, preferredType = null) {
+  }
+  function focusMapLocator(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;
@@ -1747,7 +1744,7 @@ var mapWindow = window;
      requestAnimationFrame(focusMarker);
    });
    return true;
-  };
+  }
  function buildReceiverPopupHtml(rigIds) {
    const call = T.serverCallsign || T.ownerCallsign || "Receiver";
    let meta = "";
@@ -1861,28 +1858,33 @@ var mapWindow = window;
    }
    return null;
  }
-  function _aprsAddMarkerToMap(call, entry) {
+  function _aprsAddMarkerToMap(key, entry) {
    if (!aprsMap || entry.lat == null || entry.lon == null) return;
-    refreshAprsTrack(call, entry);
+    refreshAprsTrack(key, 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: "#00d17f",
-      fillColor: "#00d17f",
+      color,
+      fillColor: color,
      fillOpacity: 0.8
    }).addTo(aprsMap).bindPopup(popupContent);
-    marker.__trxType = "aprs";
+    marker.__trxType = source;
    marker.__trxRigIds = entry.rigIds || /* @__PURE__ */ new Set();
-    marker._aprsCall = call;
+    marker._aprsCall = key;
    entry.marker = marker;
    mapMarkers.add(marker);
  }
-  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt) {
+  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt, source) {
    const nextPoint = [lat, lon];
    const tsMs = Number.isFinite(pkt?._tsMs) ? Number(pkt._tsMs) : Date.now();
    const msgRigId = pkt?.rig_id || T.lastActiveRigId;
-    const existing = stationMarkers.get(call);
+    const stationSource = source === "hf_aprs" ? "hf_aprs" : "aprs";
+    const key = aprsStationKey(call, stationSource);
+    const existing = stationMarkers.get(key);
    if (existing) {
      existing.pkt = pkt;
      existing.lat = lat;
@@ -1901,7 +1903,8 @@ var mapWindow = window;
      } else if (prevPoint) {
        prevPoint.tsMs = tsMs;
      }
-      pruneAprsEntry(call, existing, mapHistoryCutoffMs());
+      existing.call = call;
+      pruneAprsEntry(key, existing, mapHistoryCutoffMs());
      if (aprsMap && existing.marker && !T.decodeHistoryReplayActive) {
        existing.marker.setLatLng([lat, lon]);
        existing.marker.setPopupContent(buildAprsPopupHtml(call, lat, lon, info, pkt));
@@ -1912,7 +1915,8 @@ var mapWindow = window;
        track: null,
        trackHistory: [{ lat, lon, tsMs }],
        trackPoints: [nextPoint],
-        type: "aprs",
+        type: stationSource,
+        call,
        pkt,
        lat,
        lon,
@@ -1921,9 +1925,9 @@ var mapWindow = window;
        symbolCode,
        rigIds: new Set(msgRigId ? [msgRigId] : [])
      };
-      stationMarkers.set(call, entry);
-      pruneAprsEntry(call, entry, mapHistoryCutoffMs());
-      if (entry.visibleInHistoryWindow) ensureAprsMarker(call, entry);
+      stationMarkers.set(key, entry);
+      pruneAprsEntry(key, entry, mapHistoryCutoffMs());
+      if (entry.visibleInHistoryWindow) ensureAprsMarker(key, entry);
      if (aprsMap) scheduleDecodeMapMaintenance();
    }
  };
@@ -2165,14 +2169,16 @@ 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()) {
@@ -2332,7 +2338,7 @@ var mapWindow = window;
        selectedMapQsoKey = selectedMapQsoKey === entry.pathKey ? null : entry.pathKey ?? null;
        syncDecodeContactPathVisibility();
        if (selectedMapQsoKey && entry.sourceGrid) {
-          mapWindow.navigateToMapLocator?.(entry.sourceGrid, entry.sourceType);
+          focusMapLocator(entry.sourceGrid, entry.sourceType);
        }
      });
      const head = document.createElement("div");
@@ -2438,7 +2444,7 @@ var mapWindow = window;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
        });
      }
      const head = document.createElement("div");
@@ -2544,7 +2550,7 @@ var mapWindow = window;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
        });
      }
      const head = document.createElement("div");
@@ -3049,6 +3055,8 @@ var mapWindow = window;
  }
  modules.map = {
    initAprsMap,
+    focusMapPosition,
+    focusMapLocator,
    sizeAprsMapToViewport,
    syncAprsReceiverMarker,
    updateMapRigFilter,
@@ -3109,5 +3117,6 @@ var mapWindow = window;
    bandForHz,
    reverseGeocodeLocation
  };
+  window.trxPluginRuntime.syncMapAll();
  autoInitIfVisible();
 })();
@@ -8,7 +8,6 @@ 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"),
@@ -17,29 +16,12 @@ 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"),
-  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")
+  viewHistoryBtn: document.getElementById("sat-view-history")
 };
 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);
@@ -48,37 +30,19 @@ 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 (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();
-  }
+  if (view === "history") renderSatHistoryTable();
 }
-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;
@@ -275,200 +239,6 @@ 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");
@@ -0,0 +1,228 @@
+// 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,3 +1,6 @@
+import {
+  hasAuthRole
+} from "./chunk-PISLBJGN.js";
 import {
  hostState
 } from "./chunk-KL66PICH.js";
@@ -15,7 +18,7 @@ function schedulerOptionalEl(id) {
 }
 (function() {
  "use strict";
-  let schedulerRole = null;
+  let schedulerRoles = [];
  let currentRigId = null;
  let currentConfig = null;
  let currentSchedulerStatus = null;
@@ -25,8 +28,8 @@ function schedulerOptionalEl(id) {
  let schedulerStepPending = false;
  let schEntryEditIdx = null;
  let schedulerDirty = false;
-  function initScheduler(rigId, role) {
-    schedulerRole = role;
+  function initScheduler(rigId, roles) {
+    schedulerRoles = roles;
    currentRigId = rigId || null;
    if (currentRigId) loadScheduler();
    startStatusPolling();
@@ -272,7 +275,7 @@ function schedulerOptionalEl(id) {
    const nextBtn = schedulerEl("scheduler-next-btn");
    if (!prevBtn || !nextBtn) return;
    const state = schedulerInterleaveState(currentConfig);
-    const enabled = schedulerRole === "control" && !!currentRigId && !schedulerStepPending && state.activeEntries.length > 1;
+    const enabled = hasAuthRole(schedulerRoles, "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";
@@ -354,7 +357,7 @@ function schedulerOptionalEl(id) {
    const panel = schedulerEl("scheduler-panel");
    if (!panel) return;
    const mode = currentConfig && currentConfig.mode || "disabled";
-    const isControl = schedulerRole === "control";
+    const isControl = hasAuthRole(schedulerRoles, "control");
    setSelected("scheduler-mode-select", mode);
    const satEnabled = currentConfig && currentConfig.satellites && currentConfig.satellites.enabled;
    const controlRow = document.querySelector(".scheduler-control-row");
@@ -1220,8 +1223,8 @@ function schedulerOptionalEl(id) {
    markDirty: markSchedulerDirty
  };
  schedulerWindow.trx.modules.scheduler = schedulerService;
-  if (hostState.authRole != null) {
-    initScheduler(hostState.lastActiveRigId, hostState.authRole);
+  if (!hostState.authEnabled || hostState.authRoles.length > 0) {
+    initScheduler(hostState.lastActiveRigId, hostState.authRoles);
    wireSchedulerEvents();
  }
 })();
@@ -0,0 +1,264 @@
+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,7 +286,10 @@ function vchanSyncModeDisplay() {
  if (!modeEl) return;
  if (vchanIsOnVirtual()) {
    const ch = vchanActiveChannel();
-    if (ch && ch.mode) modeEl.value = ch.mode.toUpperCase();
+    if (ch && ch.mode) {
+      modeEl.value = ch.mode.toUpperCase();
+      hostCore.syncModePicker();
+    }
  }
  const modeUpper = (modeEl.value || "").toUpperCase();
  if (typeof hostState.lastModeName === "string") {
@@ -1,3 +1,7 @@
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -60,17 +64,21 @@ 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 = vdesMessageHistory.length;
+    const count = rigMessages.length;
    vdesFrameCountEl.textContent = `${count} burst${count === 1 ? "" : "s"}`;
  }
  if (vdesLatestSeenEl) {
-    const latest = vdesMessageHistory[0];
+    const latest = rigMessages[0];
    vdesLatestSeenEl.textContent = latest ? vdesAgeText(latest._tsMs) : "No traffic yet";
  }
 }
@@ -137,7 +145,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).slice(0, 6);
+  const messages = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs && isActiveRigDecode(msg.rig_id)).slice(0, 6);
  if (!isVdes || messages.length === 0) {
    vdesBarOverlay.style.display = "none";
    vdesBarOverlay.innerHTML = "";
@@ -182,7 +190,7 @@ function renderVdesHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of vdesMessageHistory) {
+  for (const message of vdesRigMessages()) {
    fragment.appendChild(renderVdesRow(message));
  }
  vdesMessagesEl.replaceChildren(fragment);
@@ -209,10 +217,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([], {
@@ -220,9 +228,7 @@ function onServerVdesBatch(messages) {
      minute: "2-digit",
      second: "2-digit"
    });
-    if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
-      vdesWindow.vdesMapAddPoint(next);
-    }
+    plotVdesMessage(next);
    normalized.push(next);
  }
  normalized.reverse();
@@ -248,13 +254,15 @@ 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);
-  if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
-    vdesWindow.vdesMapAddPoint(next);
-  }
+  plotVdesMessage(next);
 }
 function pruneVdesHistoryView() {
  pruneVdesMessageHistory();
@@ -268,5 +276,13 @@ 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,3 +1,7 @@
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -102,13 +106,17 @@ function paintLine(lineBytes) {
  wefaxLiveCtx.putImageData(imgData, 0, y);
  wefaxLiveLineCount++;
 }
+function wefaxRigImages() {
+  return forActiveRig(wefaxImageHistory);
+}
 function renderWefaxLatestCard() {
  if (!wefaxDom.liveLatest) return;
-  if (wefaxImageHistory.length === 0) {
+  const rigImages = wefaxRigImages();
+  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 = wefaxImageHistory[0];
+  const img = rigImages[0];
  if (!img) return;
  const ts = img._ts || "--";
  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : "";
@@ -129,7 +137,7 @@ function renderWefaxLatestCard() {
  wefaxDom.liveLatest.innerHTML = html;
 }
 function getWefaxFilteredHistory() {
-  let items = wefaxImageHistory;
+  let items = wefaxRigImages();
  if (wefaxFilterText) {
    items = items.filter(function(i) {
      const haystack = [
@@ -173,7 +181,7 @@ function renderWefaxHistoryTable() {
  }
  wefaxDom.historyList.replaceChildren(fragment);
  if (wefaxDom.historyCount) {
-    const total = wefaxImageHistory.length;
+    const total = wefaxRigImages().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`;
  }
@@ -208,6 +216,7 @@ 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;
@@ -234,6 +243,7 @@ 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`;
@@ -328,7 +338,11 @@ wefaxWindow.trxPluginRuntime.registerDecoder({
  onMessage: onServerWefax,
  restore: restoreWefaxHistory,
  prune: pruneWefaxHistoryView,
-  reset: resetWefaxHistoryView
+  reset: resetWefaxHistoryView,
+  rerender: () => {
+    renderWefaxLatestCard();
+    renderWefaxHistoryTable();
+  }
 });
 wefaxWindow.trxPluginRuntime.registerDecoder({
  id: "wefax_progress",
@@ -1,3 +1,7 @@
+import {
+  forActiveRig,
+  isActiveRigDecode
+} from "./chunk-S57W63QN.js";
 import {
  hostCore
 } from "./chunk-KL66PICH.js";
@@ -64,10 +68,10 @@ function renderWsprRow(msg) {
 function renderWsprHistory() {
  pruneWsprMessageHistory();
  if (!wsprMessagesEl) return;
+  const rigMessages = forActiveRig(wsprMessageHistory);
  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < wsprMessageHistory.length; i += 1) {
-    const message = wsprMessageHistory[i];
-    if (message) fragment.appendChild(renderWsprRow(message));
+  for (const message of rigMessages) {
+    fragment.appendChild(renderWsprRow(message));
  }
  wsprMessagesEl.replaceChildren(fragment);
 }
@@ -90,6 +94,8 @@ 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,
@@ -101,16 +107,11 @@ 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 (next.grids.length > 0 && wsprWindow.mapAddLocator) {
-      wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
-        ...msg,
-        ...next.rfHz === null ? {} : { freq_hz: next.rfHz }
-      });
-    }
+    if (wsprStatus && isActiveRigDecode(msg.rig_id)) wsprStatus.textContent = "Receiving";
+    plotWsprLocator(msg);
    next.history._tsMs = Number.isFinite(next.history.ts_ms) ? Number(next.history.ts_ms) : Date.now();
    normalized.push(next.history);
  }
@@ -250,15 +251,19 @@ document.getElementById("settings-clear-wspr-history")?.addEventListener("click"
    }
  })();
 });
-function onServerWspr(msg) {
-  if (wsprStatus) wsprStatus.textContent = "Receiving";
+function plotWsprLocator(msg) {
  const next = normalizeServerWsprMessage(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 }
-    });
-  }
+  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";
+  const next = normalizeServerWsprMessage(msg);
+  plotWsprLocator(msg);
  addWsprMessage(next.history);
 }
 wsprWindow.trxPluginRuntime.registerDecoder({
@@ -267,5 +272,10 @@ 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,9 +12,13 @@ use trx_core::rig::{
    RigAccessMethod, RigCapabilities, RigInfo, RigRxStatus, RigStatus, RigTxStatus, RigVfo,
    RigVfoEntry,
 };
-use trx_core::{DecoderConfig, RdsData, RigFilterState, RigMode, RigSnapshot, WfmDenoiseLevel};
+use trx_core::{
+    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};

@@ -48,6 +52,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    export!(RigStatus);
    export!(DecoderConfig);
    export!(WfmDenoiseLevel);
+    export!(DigSidebandPolicy);
+    export!(NoiseBlankerProfile);
    export!(RigFilterState);
    export!(RdsData);
    export!(SpectrumData);
@@ -56,6 +62,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    export!(RigListItem);
    export!(RigListResponse);
    export!(FrontendMeta);
+    export!(AuthRole);
    export!(DecoderActivation);
    export!(DecoderDescriptor);

@@ -23,14 +23,17 @@ 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",
+    "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",
    "verify-generated": "npm run generate-types && npm run build && git diff --exit-code -- ../assets/web/generated src/api/generated.ts"
  },
  "devDependencies": {
@@ -2,11 +2,51 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later

-export type AuthRole = "rx" | "control";
+import type { AuthRole } from "./generated.js";
+
+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;
-  role?: AuthRole;
+  roles: AuthRole[];
+  username?: string;
  auth_disabled?: boolean;
 }

@@ -18,21 +58,24 @@ 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 = { authenticated: session.authenticated };
-  if (session.role !== undefined) decoded.role = session.role;
+  const decoded: AuthSession = {
+    authenticated: session.authenticated,
+    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,
-  role: "control",
+  roles: [...AUTH_ADMIN_ROLES],
  auth_disabled: true,
 };

@@ -40,19 +83,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 };
+    if (!response.ok) return { authenticated: false, roles: [] };
    return decodeAuthSession(await response.json());
  } catch (error: unknown) {
    console.error("Auth check failed:", error);
-    return { authenticated: false };
+    return { authenticated: false, roles: [] };
  }
 }

-export async function login(passphrase: string): Promise<AuthSession> {
+export async function login(username: string, password: string): Promise<AuthSession> {
  const response = await fetch("/auth/login", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ passphrase }),
+    body: JSON.stringify({ username, password }),
  });
  if (response.status === 404) return authDisabledSession;
  if (!response.ok) {
@@ -62,6 +105,52 @@ export async function login(passphrase: string): Promise<AuthSession> {
  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,11 +51,25 @@ 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, 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, sstv_decode_enabled: boolean, recorder_enabled: boolean, };

 export type WfmDenoiseLevel = "off" | "auto" | "low" | "medium" | "high";

-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 DigSidebandPolicy = "auto" | "usb" | "lsb";
+
+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).
 */
@@ -78,6 +92,10 @@ 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>, 
 /**
@@ -111,7 +129,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, 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, sstv_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, };

@@ -119,6 +137,8 @@ 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"] as const;
+const HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax", "sstv"] 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", "digital-modes", "map", "statistics", "recorder", "settings", "about",
+  "main", "bookmarks", "logbook", "digital-modes", "map", "satellites", "statistics", "recorder", "settings", "about",
 ] as const;

 export type TabName = typeof TAB_ORDER[number];
@@ -11,8 +11,10 @@ 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",
@@ -37,3 +39,66 @@ 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}` : "";
+}
@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 import type * as Leaflet from "leaflet";
+import { aprsSymbolSprite } from "./plugins/aprs-shared";
+import type { PluginRuntimeWindow } from "./plugins/runtime-contract";

 export {};

@@ -29,7 +31,7 @@ function mapEl(id: string): MapElement {
  return element as MapElement;
 }

-type DecoderSource = "ais" | "vdes" | "aprs" | "bookmark" | "ft8" | "ft4" | "ft2" | "wspr" | "sat";
+type DecoderSource = "ais" | "vdes" | "aprs" | "hf_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;
@@ -81,6 +83,9 @@ 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;
@@ -169,7 +174,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): void;
+  aprsMapAddStation?(call: string, lat: number, lon: number, info: string, symbolTable: string, symbolCode: string, packet: MapMessage, source?: "aprs" | "hf_aprs"): void;
  aisMapAddVessel?(message: MapMessage): void;
  vdesMapAddPoint?(message: MapMessage): void;
  syncBookmarkMapLocators?(bookmarks: Array<Record<string, unknown>>): void;
@@ -226,8 +231,10 @@ 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, 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, hf_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
@@ -298,6 +305,18 @@ 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) {
@@ -319,7 +338,7 @@ const mapWindow = window as unknown as MapWindow;
      lineJoin: "round",
      interactive: false,
    }) as unknown as TrxLayer;
-    track.__trxType = "aprs";
+    track.__trxType = aprsEntrySource(entry);
    track._aprsCall = call;
    entry.track = track;
  }
@@ -571,6 +590,7 @@ 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();
  }

@@ -590,6 +610,8 @@ 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);
  }

@@ -1077,38 +1099,42 @@ const mapWindow = window as unknown as MapWindow;
      container.innerHTML = `<span class="map-locator-empty">No ${kind === "band" ? "bands" : "sources"} available</span>`;
      return;
    }
-    let helperText = "";
+    const noun = kind === "band" ? "bands" : "sources";
    const sourceKeys = kind === "source" ? Object.keys(DEFAULT_MAP_SOURCE_FILTER) as MapFilterKey[] : [];
-    const noneSelected = kind === "source" && sourceKeys.every((k) => !mapFilter[k]);
-    if (kind === "source") {
-      if (noneSelected) {
-        helperText = "All sources visible \u2014 click to filter";
-      }
-    } else if (!(selectedSet instanceof Set) || selectedSet.size === 0) {
-      helperText = `All ${kind === "band" ? "bands" : "sources"} visible by default`;
-    }
+    // Selecting nothing selects everything, for both kinds.
+    const showingAll = kind === "source"
+      ? sourceKeys.every((k) => !mapFilter[k])
+      : !(selectedSet instanceof Set) || selectedSet.size === 0;
+    // 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.
+    const allChip = document.createElement("button");
+    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);
-      if (kind === "source" && noneSelected) {
+      // Nothing is filtered out yet, so no chip is dimmed as if it were.
+      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 {
@@ -1180,10 +1206,8 @@ const mapWindow = window as unknown as MapWindow;
      }
    }
    for (const entry of stationMarkers.values()) {
-      if (entry?.type === "aprs" && entry?.visibleInHistoryWindow) {
-        availableSources.add("aprs");
-        break;
-      }
+      if (!entry?.visibleInHistoryWindow) continue;
+      availableSources.add(aprsEntrySource(entry));
    }
    const bandMap = new Map<string, FilterChip>();
    for (const entry of locatorMarkers.values()) {
@@ -1217,7 +1241,7 @@ const mapWindow = window as unknown as MapWindow;
      if (!bandMap.has(key)) mapLocatorFilter.bands.delete(key);
    }

-    const sourceItems: FilterChip[] = (["ais", "vdes", "aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"] as DecoderSource[])
+    const sourceItems: FilterChip[] = (["ais", "vdes", "aprs", "hf_aprs", "bookmark", "ft8", "ft4", "ft2", "wspr"] as DecoderSource[])
      .filter((key) => availableSources.has(key))
      .map((key) => ({
        key,
@@ -1232,11 +1256,12 @@ 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();
@@ -1287,9 +1312,10 @@ const mapWindow = window as unknown as MapWindow;
      }
      return parts.join(" ").toLowerCase();
    }
-    if (type === "aprs") {
-      const call = marker?._aprsCall ? String(marker._aprsCall) : "";
-      const entry = stationMarkers.get(call);
+    if (type === "aprs" || type === "hf_aprs") {
+      const key = marker?._aprsCall ? String(marker._aprsCall) : "";
+      const entry = stationMarkers.get(key);
+      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();
@@ -1487,9 +1513,10 @@ const mapWindow = window as unknown as MapWindow;
  };

  mapWindow.clearMapMarkersByType = function(type) {
-    if (type === "aprs") {
+    if (type === "aprs" || type === "hf_aprs") {
      selectedAprsTrackCall = null;
-      stationMarkers.forEach((entry) => {
+      stationMarkers.forEach((entry, key) => {
+        if (aprsEntrySource(entry) !== type) return;
        if (entry && entry.marker) {
          if (aprsMap && aprsMap.hasLayer(entry.marker)) entry.marker.removeFrom(aprsMap);
          mapMarkers.delete(entry.marker);
@@ -1498,8 +1525,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;
    }

@@ -1635,7 +1662,10 @@ const mapWindow = window as unknown as MapWindow;
  function applyMapOverlayPanelVisibility() {
    const panel = document.querySelector("#map-stage .map-overlay-panel");
    if (!panel) return;
-    panel.classList.toggle("is-hidden", !mapOverlayPanelVisible);
+    // Only the filters collapse. The bar itself stays, because it carries the
+    // button that brings them back.
+    panel.classList.toggle("filters-hidden", !mapOverlayPanelVisible);
+    panel.querySelector(".map-overlay-filters")?.classList.toggle("is-hidden", !mapOverlayPanelVisible);
  }

  function updateMapOverlayToggleButton() {
@@ -1769,13 +1799,15 @@ const mapWindow = window as unknown as MapWindow;
        if (!ll) return;
        const entry = stationMarkers.get(marker._aprsCall);
        if (!entry) return;
-        e.popup.setContent(buildAprsPopupHtml(marker._aprsCall, ll.lat, ll.lng, entry.info || "", entry.pkt));
+        const source = aprsEntrySource(entry);
+        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.aprs && !aprsMap.hasLayer(entry.track)) {
+        if (entry.track && aprsMap && mapFilter[source] && !aprsMap.hasLayer(entry.track)) {
          entry.track.addTo(aprsMap);
        }
        selectedAprsTrackCall = String(marker._aprsCall);
-        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor("aprs"), "aprs-radio-path", marker.__trxRigIds);
+        setMapRadioPathTo(ll.lat, ll.lng, mapSourceColor(source), "aprs-radio-path", marker.__trxRigIds);
        return;
      }

@@ -1858,7 +1890,14 @@ const mapWindow = window as unknown as MapWindow;
        const kind = String(chip.dataset.filterKind || "");
        const key = String(chip.dataset.filterKey || "");
        if (!key) return;
-        if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
+        if (key === MAP_FILTER_ALL_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];
@@ -1979,48 +2018,43 @@ 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 = mapIsFullscreen() && stage
-      ? stage.getBoundingClientRect().bottom
-      : window.innerHeight;
-    if (!mapIsFullscreen() && footer) {
+    let bottom = window.innerHeight;
+    if (footer) {
      const fr = footer.getBoundingClientRect();
-      if (fr.top > mapRect.top + 50) bottom = fr.top;
+      // Clamped to the viewport: once the column is tall enough to push the
+      // 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 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));
+    const target = Math.max(0, Math.floor(bottom - mapRect.top - 8));
    mapContainer.style.height = `${target}px`;
    if (aprsMap) aprsMap.invalidateSize();
  }

  function aprsSymbolIcon(symbolTable: string, symbolCode: string): Leaflet.DivIcon | null {
    if (!symbolTable || !symbolCode) return null;
-    const table = symbolTable === "/" ? "primary" : "alternate";
+    const sprite = aprsSymbolSprite(symbolTable, symbolCode);
+    const html = sprite
+      ? `<div class="aprs-symbol aprs-symbol-marker ${sprite.className}" role="img"` +
+        ` style="background-position:${sprite.backgroundPosition}"` +
+        ` title="${escapeMapHtml(sprite.label)}" aria-label="${escapeMapHtml(sprite.label)}"></div>`
+      : `<div class="aprs-symbol aprs-symbol-marker aprs-symbol-local" title="${symbolTable === "/" ? "primary" : "alternate"} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`;
    return L.divIcon({
      className: "",
-      html: `<div class="aprs-symbol-local" title="${table} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`,
+      html,
      iconSize: [24, 24],
      iconAnchor: [12, 12],
      popupAnchor: [0, -12]
    });
  }

-  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 = "";
+  function focusMapPosition(lat: number, lon: number) {
    initAprsMap();
    sizeAprsMapToViewport();
    if (aprsMap) {
@@ -2032,20 +2066,12 @@ const mapWindow = window as unknown as MapWindow;
        });
      });
    }
-  };
+  }

-  mapWindow.navigateToMapLocator = function(grid, preferredType = null) {
+  function focusMapLocator(grid: string, preferredType: string | null = 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;
@@ -2095,7 +2121,7 @@ const mapWindow = window as unknown as MapWindow;
      requestAnimationFrame(focusMarker);
    });
    return true;
-  };
+  }



@@ -2264,28 +2290,33 @@ const mapWindow = window as unknown as MapWindow;
    return null;
  }

-  function _aprsAddMarkerToMap(call: string, entry: MapEntry): void {
+  function _aprsAddMarkerToMap(key: string, entry: MapEntry): void {
    if (!aprsMap || entry.lat == null || entry.lon == null) return;
-    refreshAprsTrack(call, entry);
+    refreshAprsTrack(key, 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: "#00d17f", fillColor: "#00d17f", fillOpacity: 0.8
+          radius: 6, color, fillColor: color, fillOpacity: 0.8
        }).addTo(aprsMap).bindPopup(popupContent)) as unknown as TrxLayer;
-    marker.__trxType = "aprs";
+    marker.__trxType = source;
    marker.__trxRigIds = entry.rigIds || new Set();
-    marker._aprsCall = call;
+    marker._aprsCall = key;
    entry.marker = marker;
    mapMarkers.add(marker);
  }

-  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt) {
+  mapWindow.aprsMapAddStation = function(call, lat, lon, info, symbolTable, symbolCode, pkt, source) {
    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 existing = stationMarkers.get(call);
+    const stationSource: DecoderSource = source === "hf_aprs" ? "hf_aprs" : "aprs";
+    const key = aprsStationKey(call, stationSource);
+    const existing = stationMarkers.get(key);
    if (existing) {
      existing.pkt = pkt;
      existing.lat = lat;
@@ -2304,7 +2335,8 @@ const mapWindow = window as unknown as MapWindow;
      } else if (prevPoint) {
        prevPoint.tsMs = tsMs;
      }
-      pruneAprsEntry(call, existing, mapHistoryCutoffMs());
+      existing.call = call;
+      pruneAprsEntry(key, existing, mapHistoryCutoffMs());
      if (aprsMap && existing.marker && !T.decodeHistoryReplayActive) {
        existing.marker.setLatLng([lat, lon]);
        existing.marker.setPopupContent(buildAprsPopupHtml(call, lat, lon, info, pkt));
@@ -2315,7 +2347,8 @@ const mapWindow = window as unknown as MapWindow;
        track: null,
        trackHistory: [{ lat, lon, tsMs }],
        trackPoints: [nextPoint],
-        type: "aprs",
+        type: stationSource,
+        call,
        pkt,
        lat,
        lon,
@@ -2324,9 +2357,9 @@ const mapWindow = window as unknown as MapWindow;
        symbolCode,
        rigIds: new Set(msgRigId ? [msgRigId] : []),
      };
-      stationMarkers.set(call, entry);
-      pruneAprsEntry(call, entry, mapHistoryCutoffMs());
-      if (entry.visibleInHistoryWindow) ensureAprsMarker(call, entry);
+      stationMarkers.set(key, entry);
+      pruneAprsEntry(key, entry, mapHistoryCutoffMs());
+      if (entry.visibleInHistoryWindow) ensureAprsMarker(key, entry);
      if (aprsMap) scheduleDecodeMapMaintenance();
    }
  };
@@ -2592,18 +2625,26 @@ 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() {
@@ -2806,7 +2847,7 @@ const mapWindow = window as unknown as MapWindow;
        selectedMapQsoKey = selectedMapQsoKey === entry.pathKey ? null : entry.pathKey ?? null;
        syncDecodeContactPathVisibility();
        if (selectedMapQsoKey && entry.sourceGrid) {
-          mapWindow.navigateToMapLocator?.(entry.sourceGrid, entry.sourceType);
+          focusMapLocator(entry.sourceGrid, entry.sourceType);
        }
      });

@@ -2933,7 +2974,7 @@ const mapWindow = window as unknown as MapWindow;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
        });
      }

@@ -3059,7 +3100,7 @@ const mapWindow = window as unknown as MapWindow;
      card.className = "map-qso-card";
      if (entry.grid) {
        card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
        });
      }

@@ -3623,6 +3664,8 @@ const mapWindow = window as unknown as MapWindow;
  // Register module API for core to call
  modules.map = {
    initAprsMap,
+    focusMapPosition,
+    focusMapLocator,
    sizeAprsMapToViewport,
    syncAprsReceiverMarker,
    updateMapRigFilter,
@@ -3672,6 +3715,18 @@ 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,14 +2,25 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later

-type PluginGroup = "digital-modes" | "map-data" | "map" | "statistics" | "bookmarks" | "recorder" | "settings";
+type PluginGroup =
+  | "digital-modes" | "map-data" | "map" | "satellites" | "statistics"
+  | "bookmarks" | "logbook" | "recorder" | "settings";

 const pluginGroups: Readonly<Record<PluginGroup, readonly string[]>> = {
-  "digital-modes": ["/ft8.js", "/ft4.js", "/ft2.js", "/wspr.js", "/cw.js", "/background-decode.js", "/sat.js", "/wefax.js"],
+  // AIS, VDES and the two APRS decoders have panels on this tab, so they load
+  // 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"],
 };
@@ -37,7 +48,7 @@ async function loadPlugins(group: string): Promise<void> {
 }

 export async function loadEagerPlugins(): Promise<void> {
-  await Promise.all(["digital-modes", "bookmarks", "settings"].map(loadPlugins));
+  await Promise.all(["digital-modes", "bookmarks", "logbook", "settings"].map(loadPlugins));
 }

 export async function loadPluginsForTab(tab: string): Promise<void> {
@@ -81,6 +81,8 @@ 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),
 };
@@ -0,0 +1,26 @@
+// 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,6 +6,7 @@ import { hostCore, hostState } from "./host.js";

 export {};

+import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract";

 interface AisMessage {
@@ -27,6 +28,7 @@ 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;
@@ -189,20 +191,27 @@ 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 vessels = aisLatestByVessel(aisMessageHistory);
+  const rigMessages = aisRigMessages();
+  const vessels = aisLatestByVessel(rigMessages);
  if (aisVesselCountEl) {
    const count = vessels.length;
    aisVesselCountEl.textContent = `${count} vessel${count === 1 ? "" : "s"}`;
  }

  if (aisLatestSeenEl) {
-    const latest = aisMessageHistory[0];
+    const latest = rigMessages[0];
    if (!latest) {
      aisLatestSeenEl.textContent = "No traffic yet";
    } else {
@@ -212,8 +221,21 @@ 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("div");
+  const row = document.createElement("details");
  row.className = "ais-message";
  const ts = msg._ts || new Date().toLocaleTimeString([], {
    hour: "2-digit",
@@ -227,8 +249,9 @@ 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)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>`
+    ? `<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 vesselUrl = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
  row.dataset.filterText = [
    name,
    msg.mmsi,
@@ -243,23 +266,43 @@ function renderAisRow(msg: AisMessage): HTMLElement {
    .join(" ")
    .toUpperCase();
  row.innerHTML =
-    `<div class="ais-row-head">` +
-      `<span class="ais-time">${ts}</span>` +
+    `<summary class="decode-line">` +
+      `<span class="ais-time">${escapeAisHtml(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>` +
+      `<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.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;
 }
@@ -279,7 +322,9 @@ 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((msg) => (msg._tsMs ?? 0) >= cutoffMs);
+  const recent = aisMessageHistory.filter(
+    (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";
@@ -333,7 +378,7 @@ function renderAisHistory() {
    return;
  }
  const fragment = document.createDocumentFragment();
-  for (const message of aisMessageHistory) {
+  for (const message of aisRigMessages()) {
    fragment.appendChild(renderAisRow(message));
  }
  aisMessagesEl.replaceChildren(fragment);
@@ -354,9 +399,13 @@ function addAisMessage(msg: AisMessage): void {
  scheduleAisBarUpdate();
  scheduleAisHistoryRender();

-  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
-    aisWindow.aisMapAddVessel(msg);
-  }
+  plotAisMessage(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 {
@@ -368,10 +417,11 @@ 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([], {
@@ -379,9 +429,7 @@ function onServerAisBatch(messages: AisMessage[]): void {
      minute: "2-digit",
      second: "2-digit",
    });
-    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
-      aisWindow.aisMapAddVessel(next);
-    }
+    plotAisMessage(next);
    normalized.push(next);
  }
  normalized.reverse();
@@ -415,8 +463,9 @@ if (aisFilterInput) {
 }

 function onServerAis(msg: AisMessage): void {
-  if (aisStatus) aisStatus.textContent = "Receiving";
-  addAisMessage(normalizeServerAisMessage(msg));
+  const message = normalizeServerAisMessage(msg);
+  if (aisStatus && isActiveRigDecode(message.rig_id)) aisStatus.textContent = "Receiving";
+  addAisMessage(message);
 }

 updateAisSummary();
@@ -427,4 +476,7 @@ 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,6 +30,14 @@ 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();
@@ -108,8 +116,87 @@ function escapeAprsCharacter(character: string): string {
  return character;
 }

+// The vendored sprite sheets (assets/web/vendor/aprs-symbols-24-*.png) are
+// 16x6 grids of 24px cells covering the printable codes 0x21..0x7E, so a
+// symbol's cell index is simply `code - 0x21`.  The sheet URLs live in CSS so
+// the retina variants can be picked up by a media query; only the cell offsets
+// are computed here.
+const APRS_SPRITE_COLUMNS = 16;
+const APRS_SPRITE_CELL_PX = 24;
+const APRS_SPRITE_FIRST_CODE = 0x21;
+const APRS_SPRITE_LAST_CODE = 0x7e;
+
+export interface AprsSymbolSprite {
+  /** Sheet modifier class appended to `.aprs-symbol`. */
+  className: string;
+  /** `background-position` covering the overlay layer first, if any. */
+  backgroundPosition: string;
+  /** Human-readable description for the tooltip. */
+  label: string;
+}
+
+function aprsSpriteOffset(code: string): string | null {
+  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`;
+}
+
+/**
+ * Resolve an APRS table/code pair to a sprite cell.  A table identifier of `/`
+ * selects the primary sheet and `\` the alternate one; any other character is
+ * an overlay, which draws that character from the overlay sheet on top of the
+ * alternate symbol.  Returns null when the pair is outside the sprite sheets,
+ * leaving callers to fall back to the raw character.
+ */
+export function aprsSymbolSprite(
+  symbolTable: string | null | undefined,
+  symbolCode: string | null | undefined,
+): AprsSymbolSprite | null {
+  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}`,
+  };
+}
+
+/** 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);
+  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>`;
@@ -133,3 +220,201 @@ 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,15 +4,13 @@

 import { hostCore, hostState } from "./host.js";

+import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import {
  aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsInfo,
-  renderLocalAprsSymbol,
+  renderAprsPacketRow,
  type AprsPacket,
  type AprsTypeFilter,
 } from "./aprs-shared";
@@ -25,6 +23,7 @@ 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;
@@ -109,21 +108,29 @@ 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 packets = aprsCollapseDup ? collapseAprsDuplicates(aprsPacketHistory) : aprsPacketHistory;
+  const rigPackets = aprsRigPackets();
+  const packets = aprsCollapseDup ? collapseAprsDuplicates(rigPackets) : rigPackets;
  return packets.filter(aprsFilterMatch);
 }

 function updateAprsSummary() {
+  const rigPackets = aprsRigPackets();
  const visible = aprsVisiblePackets();
  if (aprsTotalCountEl) {
-    aprsTotalCountEl.textContent = `${aprsPacketHistory.length} total`;
+    aprsTotalCountEl.textContent = `${rigPackets.length} total`;
  }
  if (aprsVisibleCountEl) {
    aprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (aprsLatestSeenEl) {
-    const latest = aprsPacketHistory[0];
+    const latest = rigPackets[0];
    if (!latest) {
      aprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -141,93 +148,27 @@ function updateAprsChipState() {
  aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }

-function renderAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-
-  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  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);
-      }
-    })(); });
+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);
  }
+}

-  return row;
+function renderAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
+  return renderAprsPacketRow(pkt, {
+    fresh: isFresh,
+    distance: aprsDistanceText(pkt),
+    onMap: (lat, lon) => { aprsWindow.navigateToAprsMap?.(lat, lon); },
+    onCopy: (text) => { void copyAprsCoords(text); },
+    onLog: (call, gridsquare) => {
+      aprsWindow.logContact?.({ call, gridsquare: gridsquare ?? undefined, decoder: "aprs" });
+    },
+  });
 }

 function renderAprsHistory() {
@@ -251,7 +192,9 @@ 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((p) => p.crcOk && (p._tsMs ?? 0) >= cutoffMs);
+  const okFrames = aprsPacketHistory.filter(
+    (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) {
@@ -301,6 +244,12 @@ 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;
@@ -309,9 +258,7 @@ function addAprsPacket(pkt: AprsPacket): void {
  aprsPacketHistory.unshift(pkt);
  pruneAprsPacketHistory();

-  if (pkt.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
-    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
-  }
+  plotAprsPacket(pkt);

  if (pkt.crcOk) scheduleAprsBarUpdate();

@@ -324,17 +271,16 @@ 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" });
-    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
-      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
-    }
+    plotAprsPacket(next);
    if (next.crcOk) hasCrcOk = true;
    normalized.push(next);
  }
@@ -394,8 +340,9 @@ if (aprsFilterInput) {

 // --- Server-side APRS decode handler ---
 function onServerAprs(pkt: AprsPacket): void {
-  if (aprsStatus) aprsStatus.textContent = "Receiving";
-  addAprsPacket(normalizeServerAprsPacket(pkt));
+  const packet = normalizeServerAprsPacket(pkt);
+  if (aprsStatus && isActiveRigDecode(packet.rig_id)) aprsStatus.textContent = "Receiving";
+  addAprsPacket(packet);
 }

 renderAprsHistory();
@@ -406,4 +353,7 @@ 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,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 import { hostState } from "./host.js";
+import { hasAuthRole, type AuthRole } from "../api/auth.js";

 export {};

@@ -44,7 +45,7 @@ interface BackgroundBridge {
  trx?: { modules?: { backgroundDecode?: BackgroundDecodeService } };
 }
 interface BackgroundDecodeService {
-  initialize(rigId: string | null, role: string | null): void;
+  initialize(rigId: string | null, roles: readonly AuthRole[]): void;
  wireEvents(): void;
  setRig(rigId: string | null): void;
 }
@@ -60,16 +61,23 @@ const bgdWindow = window as unknown as BackgroundBridge;
      .map(function (d) { return d.id; });
  }

-  let backgroundDecodeRole: string | null = null;
+  let backgroundDecodeRoles: readonly AuthRole[] = [];
  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, role: string | null): void {
-    backgroundDecodeRole = role;
-    currentRigId = rigId || null;
+  function initBackgroundDecode(rigId: string | null, roles: readonly AuthRole[]): void {
+    backgroundDecodeRoles = roles;
+    // The panel used to take whatever rig it was handed at load and wait to be
+    // 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();
  }
@@ -171,7 +179,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
    setCheckbox("background-decode-enabled", currentConfig.enabled);
    renderBookmarkChecklist();

-    const isControl = backgroundDecodeRole === "control" || hostState.authEnabled === false;
+    const isControl = isControlRole();
    const panel = document.getElementById("background-decode-panel");
    if (panel) {
        panel.querySelectorAll<HTMLInputElement | HTMLSelectElement | HTMLButtonElement>("input, select, button.sch-write").forEach(function (el) {
@@ -182,6 +190,11 @@ 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 {
@@ -203,26 +216,65 @@ const bgdWindow = window as unknown as BackgroundBridge;
      : all;

    if (filtered.length === 0) {
-      container.innerHTML = '<div class="bgd-checklist-empty">' +
-        (all.length === 0 ? "No supported bookmarks available." : "No bookmarks match filter.") +
-        '</div>';
+      container.innerHTML = '<div class="bgd-checklist-empty">' + escHtml(emptyListText(all.length)) + "</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 checked = selectedIds.has(bookmark.id) ? " checked" : "";
+      const selected = selectedIds.has(bookmark.id);
+      if (selected) row.classList.add("is-selected");
      row.innerHTML =
-        '<input type="checkbox"' + checked + ' data-bm-id="' + escHtml(bookmark.id) + '" />' +
+        '<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) + " " + bookmark.mode + " · " + decoders.join("/").toUpperCase()) + '</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<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 {
@@ -260,7 +312,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
        showToast(`Save failed: ${errorMessage(err)}`, true);
      })
      .finally(function () {
-        if (btn) btn.disabled = false;
+        syncSaveButton();
      });
  }

@@ -295,58 +347,77 @@ const bgdWindow = window as unknown as BackgroundBridge;
  }

  function renderStatus(status: BackgroundDecodeStatus): void {
-    const card = document.getElementById("background-decode-status-card");
-    if (!card) return;
-    const entries = status.entries ?? [];
-    if (!entries.length) {
-      card.textContent = "No background decode bookmarks configured.";
-      return;
-    }
-    const summary = [];
-    if (status.active_rig) {
-      if (typeof status.center_hz === "number" && Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
-      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.");
-    }
-    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;
+    lastStatus = status;
+    statusByBookmark = new Map(
+      (status.entries ?? [])
+        .filter((entry) => typeof entry.bookmark_id === "string" && entry.bookmark_id.length > 0)
+        .map((entry) => [entry.bookmark_id as string, entry]),
+    );
+    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) {
+      el.textContent = "This rig is not the one playing audio.";
+      el.dataset.tone = "warn";
+      return;
+    }
+    const centre = typeof status.center_hz === "number" && Number.isFinite(status.center_hz)
+      ? formatFreq(status.center_hz)
+      : null;
+    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}` : "";
+  }
+
+  /** 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 "\u2713 Active";
-      case "out_of_span": return "\u25B3 Out of span";
-      case "waiting_for_spectrum": return "\u25B3 Waiting";
-      case "waiting_for_user": return "\u25B3 No user";
-      case "missing_bookmark": return "\u2717 Missing";
-      case "no_supported_decoders": return "\u2717 Unsupported";
-      case "disabled": return "\u25B3 Disabled";
-      case "handled_by_scheduler": return "\u25B3 Scheduler";
-      case "scheduler_has_control": return "\u25B3 Scheduler";
-      case "handled_by_virtual_channel": return "\u25B3 VChan";
-      default: return "\u25B3 Inactive";
+      case "active": return "Decoding";
+      case "out_of_span": return "Out of span";
+      case "waiting_for_spectrum": return "Waiting for spectrum";
+      case "waiting_for_user": return "Nobody listening";
+      case "missing_bookmark": return "Bookmark gone";
+      case "no_supported_decoders": return "No decoder";
+      case "disabled": return "Off";
+      case "handled_by_scheduler":
+      case "scheduler_has_control": return "Scheduler has it";
+      case "handled_by_virtual_channel": return "On a channel";
+      case "pending": return "Not saved";
+      default: return "Idle";
    }
  }

@@ -380,14 +451,25 @@ const bgdWindow = window as unknown as BackgroundBridge;
  function markBgdDirty() {
    if (bgdDirty) return;
    bgdDirty = true;
-    const btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.classList.add("sch-dirty");
+    syncSaveButton();
  }

  function clearBgdDirty() {
    bgdDirty = false;
-    const btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.classList.remove("sch-dirty");
+    syncSaveButton();
+  }
+
+  /** 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 {
@@ -407,7 +489,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
    }
    const ids = supportedBookmarks().map(function (bm) { return bm.id; });
    currentConfig.bookmark_ids = ids;
-    renderBookmarkChecklist((document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value);
+    renderBookmarkChecklist(currentFilterText());
    markBgdDirty();
  }

@@ -416,7 +498,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
    }
    currentConfig.bookmark_ids = [];
-    renderBookmarkChecklist((document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value);
+    renderBookmarkChecklist(currentFilterText());
    markBgdDirty();
  }

@@ -432,7 +514,11 @@ 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 () { markBgdDirty(); });
+      enabledCb.addEventListener("change", function () {
+        if (currentConfig) currentConfig.enabled = enabledCb.checked;
+        markBgdDirty();
+        renderBookmarkChecklist(currentFilterText());
+      });
    }

    const selectAllBtn = document.getElementById("bgd-select-all-btn") as WiredElement | null;
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 import { hostCore, hostState } from "./host.js";
+import { hasAuthRole } from "../api/auth.js";

 export {};

@@ -18,6 +19,8 @@ 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;
 }

@@ -100,7 +103,8 @@ function bmEsc(str: unknown): string {
 }

 function bmCanControl() {
-  return !hostState.authEnabled || hostState.authRole === "control";
+  return !hostState.authEnabled
+    || hasAuthRole(hostState.authRoles, "write");
 }

 // Show/hide the Add Bookmark / Select All buttons based on the current auth role.
@@ -319,6 +323,14 @@ 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;
@@ -336,7 +348,9 @@ 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";
@@ -381,6 +395,9 @@ 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 = "";
@@ -401,6 +418,7 @@ async function bmSave(e: Event): Promise<void> {
    category,
    comment,
    decoders,
+    dig_sideband,
  };

  try {
@@ -456,6 +474,7 @@ 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;
@@ -474,6 +493,16 @@ 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));
@@ -767,6 +796,9 @@ 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,6 +4,7 @@

 import { hostCore } from "./host.js";

+import { isActiveRigDecode } from "./active-rig.js";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";

 export {};
@@ -20,8 +21,11 @@ interface CwRenderer {
  drawPoints(points: number[], size: number, color: Rgba): void;
 }
 interface CwSpectrum { bins: number[]; sample_rate: number; center_hz: number }
-interface CwEvent { text?: string; wpm?: number; tone_hz?: number; signal_on?: boolean }
-interface CwLine { tsMs: number; ts: string; text: string; wpm: number | null; tone_hz: number | null; lastMs: number }
+interface CwEvent { rig_id?: string | null; text?: string; wpm?: number; tone_hz?: number; signal_on?: boolean }
+interface CwLine {
+  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;
@@ -66,7 +70,10 @@ const CW_BAR_LINE_GAP_MS = 5000;
 let cwLastAppendTime = 0;
 let cwTonePickerRaf: number | null = null;
 let cwBarHistory: CwLine[] = [];
-let cwBarCurrentLine: CwLine | null = null;
+// One line in progress per rig, keyed by rig id ("" for a decode that names no
+// 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
@@ -101,12 +108,13 @@ cwWindow.applyCwAutoUiFromServer = function(enabled: boolean) {
  applyCwAutoUi(enabled);
 };

-function cwBarFlushCurrentLine(): void {
-  if (cwBarCurrentLine && cwBarCurrentLine.text.trim()) {
-    cwBarHistory.unshift(cwBarCurrentLine);
+function cwBarFlushCurrentLine(key: string): void {
+  const line = cwBarCurrentLines.get(key);
+  cwBarCurrentLines.delete(key);
+  if (line?.text.trim()) {
+    cwBarHistory.unshift(line);
    if (cwBarHistory.length > 50) cwBarHistory.length = 50;
  }
-  cwBarCurrentLine = null;
 }

 function updateCwBar(): void {
@@ -114,9 +122,12 @@ 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);
-  // Prepend the in-progress line so characters appear immediately
-  const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
+  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs && isActiveRigDecode(l.rigId));
+  // Prepend the in-progress lines so characters appear immediately
+  const inProgress = [...cwBarCurrentLines.values()]
+    .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";
@@ -402,7 +413,7 @@ function resetCwHistoryView(): void {
  if (cwOutputEl) cwOutputEl.innerHTML = "";
  cwLastAppendTime = 0;
  cwBarHistory = [];
-  cwBarCurrentLine = null;
+  cwBarCurrentLines.clear();
  updateCwBar();
  drawCwTonePicker();
 }
@@ -421,8 +432,13 @@ document.getElementById("settings-clear-cw-history")?.addEventListener("click",

 // --- Server-side CW decode handler ---
 function onServerCw(evt: CwEvent): void {
-  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
-  if (evt.text && cwOutputEl) {
+  // The panel is a single stream of copied text: characters from a background
+  // rig do not belong in it at all, and interleaving them would make both
+  // 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") {
@@ -445,25 +461,29 @@ 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();
+      cwBarFlushCurrentLine(key);
    } else {
-      if (!cwBarCurrentLine || now - cwBarCurrentLine.lastMs > CW_BAR_LINE_GAP_MS) {
-        cwBarFlushCurrentLine();
+      let line = cwBarCurrentLines.get(key);
+      if (!line || now - line.lastMs > CW_BAR_LINE_GAP_MS) {
+        cwBarFlushCurrentLine(key);
        const ts = new Date(now).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-        cwBarCurrentLine = { tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
+        line = { rigId, tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
+        cwBarCurrentLines.set(key, line);
      }
-      cwBarCurrentLine.text += evt.text;
-      cwBarCurrentLine.lastMs = now;
-      if (Number.isFinite(Number(evt.wpm))) cwBarCurrentLine.wpm = clampCwWpm(evt.wpm);
-      if (Number.isFinite(Number(evt.tone_hz))) cwBarCurrentLine.tone_hz = Math.round(Number(evt.tone_hz));
+      line.text += evt.text;
+      line.lastMs = now;
+      if (Number.isFinite(Number(evt.wpm))) line.wpm = clampCwWpm(evt.wpm);
+      if (Number.isFinite(Number(evt.tone_hz))) line.tone_hz = Math.round(Number(evt.tone_hz));
    }
    updateCwBar();
  }
-  if (cwSignalIndicator) {
+  if (cwSignalIndicator && forSelectedRig) {
    cwSignalIndicator.className = evt.signal_on ? "cw-signal-on" : "cw-signal-off";
  }
-  if (!cwAutoInput || cwAutoInput.checked) {
+  if (forSelectedRig && (!cwAutoInput || cwAutoInput.checked)) {
    if (cwWpmInput && Number.isFinite(Number(evt.wpm))) {
      cwWpmInput.value = String(clampCwWpm(evt.wpm));
    }
@@ -491,6 +511,13 @@ 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,6 +4,7 @@

 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";
@@ -15,6 +16,7 @@ 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;
 }
@@ -47,6 +49,8 @@ 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;
@@ -222,14 +226,37 @@ 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 history) {
+    for (const message of rigMessages) {
      if (count >= 200) break;
      if (filterText && !(message.message ?? "").toUpperCase().includes(filterText)) continue;
      fragment.appendChild(renderRow(message));
@@ -237,20 +264,32 @@ export function initializeFtxDecoder(config: FtxConfig): void {
    }
    messagesElement.replaceChildren(fragment);
  };
-  const normalize = (message: FtxMessage): FtxMessage => {
+  /** Hands a decode's grid squares to the map, if the map module is loaded yet.
+   *  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);
-    if (grids.length > 0) {
-      bridge.mapAddLocator?.(raw, grids, id, station, {
-        ...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,
@@ -262,7 +301,10 @@ export function initializeFtxDecoder(config: FtxConfig): void {
  };
  const receiveBatch = (messages: FtxMessage[]): void => {
    if (messages.length === 0) return;
-    if (status) status.textContent = "Receiving";
+    // "Receiving" is the panel's own status, and the panel is the rig's.
+    if (status && messages.some((message) => isActiveRigDecode(message.rig_id))) {
+      status.textContent = "Receiving";
+    }
    history = messages.map(normalize).reverse().concat(history);
    prune();
    bridge.setFt8FamilyBarDecoder?.(id);
@@ -277,7 +319,8 @@ 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) {
@@ -299,6 +342,9 @@ 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,15 +4,13 @@

 import { hostCore, hostState } from "./host.js";

+import { forActiveRig, isActiveRigDecode } from "./active-rig.js";
 import {
  aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
  aprsPacketCategory,
  collapseAprsDuplicates,
  normalizeAprsPacket,
-  renderAprsInfo,
-  renderLocalAprsSymbol,
+  renderAprsPacketRow,
  type AprsPacket,
  type AprsTypeFilter,
 } from "./aprs-shared";
@@ -22,12 +20,17 @@ 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");
@@ -94,23 +97,31 @@ 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 packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(hfAprsPacketHistory) : hfAprsPacketHistory;
+  const rigPackets = hfAprsRigPackets();
+  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 = `${hfAprsPacketHistory.length} total`;
+    hfAprsTotalCountEl.textContent = `${rigPackets.length} total`;
  }
  if (hfAprsVisibleCountEl) {
    hfAprsVisibleCountEl.textContent = `${visible.length} shown`;
  }
  if (hfAprsLatestSeenEl) {
-    const latest = hfAprsPacketHistory[0];
+    const latest = rigPackets[0];
    if (!latest) {
      hfAprsLatestSeenEl.textContent = "No packets yet";
    } else {
@@ -128,95 +139,27 @@ 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 {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-
-  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  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">${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<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);
-      }
-    });
+  return renderAprsPacketRow(pkt, {
+    fresh: isFresh,
+    badge: "HF",
+    distance: hfAprsDistanceText(pkt),
+    onMap: (lat: number, lon: number) => { hfAprsWindow.navigateToAprsMap?.(lat, lon); },
+    onCopy: (text: string) => { void copyHfAprsCoords(text); },
  });
+}

-  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);
-      }
-    })(); });
+async function copyHfAprsCoords(text: string): Promise<void> {
+  try {
+    const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
+    if (!clipboard) return;
+    await clipboard.writeText(text);
+    hostCore.showHint("Coordinates copied", 1200);
+  } catch {
+    hostCore.showHint("Copy failed", 1500);
  }
-
-  return row;
 }

 function renderHfAprsHistory() {
@@ -240,6 +183,7 @@ function resetHfAprsHistoryView(): void {
  if (hfAprsPacketsEl) hfAprsPacketsEl.innerHTML = "";
  hfAprsPacketHistory = [];
  renderHfAprsHistory();
+  hfAprsWindow.clearMapMarkersByType?.("hf_aprs");
 }

 function pruneHfAprsHistoryView(): void {
@@ -247,6 +191,17 @@ 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;
@@ -255,6 +210,8 @@ function addHfAprsPacket(pkt: AprsPacket): void {
  hfAprsPacketHistory.unshift(pkt);
  pruneHfAprsPacketHistory();

+  plotHfAprsPacket(pkt);
+
  scheduleHfAprsHistoryRender();
 }

@@ -264,13 +221,15 @@ 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();
@@ -338,8 +297,9 @@ if (hfAprsFilterInput) {

 // --- Server-side HF APRS decode handler ---
 function onServerHfAprs(pkt: AprsPacket): void {
-  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
+  const packet = normalizeServerHfAprsPacket(pkt);
+  if (hfAprsStatus && isActiveRigDecode(packet.rig_id)) hfAprsStatus.textContent = "Receiving";
+  addHfAprsPacket(packet);
 }

 renderHfAprsHistory();
@@ -350,4 +310,7 @@ 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,6 +11,8 @@
 // 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;
@@ -22,8 +24,10 @@ 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 authRole: string | null;
+  readonly authRoles: readonly AuthRole[];
  readonly lastActiveRigId: string | null;
  readonly lastRigIds: string[];
  readonly lastRigDisplayNames: Record<string, string>;
@@ -43,6 +47,7 @@ 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;
@@ -59,6 +64,8 @@ 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;
 }

@@ -0,0 +1,577 @@
+// 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,6 +9,13 @@ 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 {
@@ -19,6 +26,8 @@ export interface TrxPluginRuntime {
  reset(id: string): boolean;
  resetAll(): void;
  prune(id: string): boolean;
+  rerenderAll(): void;
+  syncMapAll(): void;
  clearQueued(): void;
  hasDecoder(id: string): boolean;
 }
@@ -4,13 +4,12 @@

 import { hostCore } from "./host.js";

-import type { LrptProgress, SatelliteImage, SatelliteLiveUpdate, SatellitePass, SatellitePassResponse } from "./satellite-types";
+import type { LrptProgress, SatelliteImage, SatelliteLiveUpdate } from "./satellite-types";
 import type { PluginRuntimeWindow } from "./runtime-contract.js";

-type SatelliteView = "live" | "history" | "predictions";
+type SatelliteView = "live" | "history";
 interface SatelliteBridge {
  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
-  clearSatPredictionDom?: () => void;
  updateSatLiveState?: (update: SatelliteLiveUpdate) => void;
  addSatMapOverlay?: (image: SatelliteImage) => void;
  clearSatMapOverlays?: () => void;
@@ -25,14 +24,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"),
@@ -42,30 +41,13 @@ 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 {
@@ -78,33 +60,16 @@ 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.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 (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();
-  }
+  if (satDom.liveView)       satDom.liveView.style.display = view === "live" ? "" : "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.viewHistoryBtn) satDom.viewHistoryBtn.classList.toggle("sat-view-active", view === "history");
+  if (view === "history") renderSatHistoryTable();
 }

-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;
@@ -335,234 +300,6 @@ 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") {
--- a/Show More
+++ b/Show More