[feat](trx-frontend-http): centre the radio controls, split off the mode row

The controls every rig has — mode, wheel, tune step, transmit — now sit
as a centred block rather than packed against the left edge.

What the current mode adds moves out from among them: WFM's six controls
stretched the row sideways whenever it was active, pushing the wheel and
the step pickers off centre, and SAM did the same on a smaller scale.
They get a row of their own below a divider, which appears and leaves
with them — an empty one would still take a track and a gap in the tray
and draw its divider under controls it has nothing to do with.

Signed-off-by: Stan Grams <sjg@haxx.space>

.devcontainer/devcontainer.json

@@ -0,0 +1,22 @@
+{
+  "name": "trx-rs SDK",
+  "image": "git.haxx.space/sjg/trx-rs/sdk:latest",
+  "workspaceFolder": "/work",
+  "workspaceMount": "source=${localWorkspaceFolder},target=/work,type=bind",
+  "mounts": [
+    "source=trx-rs-sccache,target=/sccache,type=volume"
+  ],
+  "containerEnv": {
+    "RUSTC_WRAPPER": "sccache",
+    "CARGO_INCREMENTAL": "0",
+    "SCCACHE_DIR": "/sccache"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "rust-lang.rust-analyzer",
+        "tamasfe.even-better-toml"
+      ]
+    }
+  }
+}

.gitea/workflows/ci.yml

@@ -2,10 +2,11 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-# CI for the self-hosted, host-executor Podman runners (see container/).
-# The runner image bakes in the Rust toolchain and all build dependencies,
-# so jobs go straight to cargo — no apt/rustup setup steps (which also
-# collided on the dpkg lock when jobs ran concurrently in the same runner).
+# CI for the Docker-executor runner (VM). The lint, test and frontend jobs run
+# inside the shared trx-rs SDK image (container/Containerfile), which bakes in
+# the pinned Rust toolchain, Node.js, Chromium and all build dependencies. The
+# reuse job uses the upstream Docker action, which the Docker executor launches
+# as a sibling container.
 
 name: CI
 
@@ -16,28 +17,44 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
+  # sccache: shared compilation cache persisted on the runner host (see the
+  # -v mount in runner-config.example.yaml). CARGO_INCREMENTAL=0 because
+  # sccache cannot cache incremental artifacts.
+  RUSTC_WRAPPER: sccache
+  CARGO_INCREMENTAL: "0"
+  SCCACHE_DIR: /sccache
+  SCCACHE_CACHE_SIZE: "20G"
 
 jobs:
   lint:
     runs-on: ubuntu-latest
+    container: git.haxx.space/sjg/trx-rs/sdk:latest
     steps:
       - uses: actions/checkout@v4
       - name: rustfmt
         run: cargo fmt --all -- --check
       - name: clippy
         run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+      - name: sccache stats
+        if: always()
+        run: sccache --show-stats
 
   test:
     runs-on: ubuntu-latest
+    container: git.haxx.space/sjg/trx-rs/sdk:latest
     steps:
       - uses: actions/checkout@v4
       - name: Build
         run: cargo build --workspace --all-targets --locked
       - name: Test
         run: cargo test --workspace --locked
+      - name: sccache stats
+        if: always()
+        run: sccache --show-stats
 
   frontend:
     runs-on: ubuntu-latest
+    container: git.haxx.space/sjg/trx-rs/sdk:latest
     defaults:
       run:
         working-directory: src/trx-client/trx-frontend/trx-frontend-http/frontend
@@ -58,22 +75,15 @@ jobs:
         run: npm run lint
       - name: Test
         run: npm test
-      - name: Install browser smoke dependency
-        run: command -v chromium >/dev/null || (sudo apt-get update && sudo apt-get install -y --no-install-recommends chromium)
+      # Chromium comes from the SDK image at the path the smoke test defaults
+      # to, so there is nothing to install here.
       - name: Browser smoke test
         run: npm run test:browser
       - name: Verify generated assets
         run: npm run verify-generated
-      - name: Verify generated-file licensing
-        working-directory: .
-        run: reuse lint
 
   reuse:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: REUSE compliance
-        # `reuse` CLI instead of fsfe/reuse-action: the latter is a Docker
-        # action, which the host-executor runners cannot run. `reuse` is baked
-        # into the runner image (see container/Containerfile).
-        run: reuse lint
+      - uses: fsfe/reuse-action@v5

LICENSES/LicenseRef-APRS-Symbols.txt

@@ -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

README.md

@@ -144,4 +144,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).

REUSE.toml

@@ -12,6 +12,8 @@ path = [
     "trx-rs.toml.example",
     "docs/**",
     "aidocs/**",
+    "container/**",
+    ".devcontainer/**",
     "src/decoders/trx-ftx/README.md",
     "src/decoders/trx-wxsat/README.md",
     "assets/trx-logo.png",
@@ -54,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"

container/Containerfile

@@ -2,60 +2,67 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-# Gitea Actions runner image for trx-rs CI (host-executor / "Pattern B").
+# trx-rs SDK / build image.
 #
-# All build dependencies, the Rust toolchain, Node.js (for JS actions such as
-# actions/checkout and actions/cache) and the `reuse` tool are baked in, so CI
-# runs skip the per-run apt/rustup install cost. `sudo` is present so the
-# existing workflow's `sudo apt-get ...` / rustup steps remain valid — they
-# just become fast no-ops because everything is already installed.
+# Single source of truth for the build environment. Used two ways:
+#   * CI  — as the job container for the lint/test jobs (Docker executor).
+#   * Dev — run locally or via .devcontainer for a reproducible toolchain.
+#
+# Pinning the Rust version here (and in rust-toolchain.toml) means CI and every
+# developer share the exact same rustc/clippy, so "works locally, fails in CI"
+# cannot happen.
 FROM docker.io/library/debian:bookworm-slim
 
-ARG ACT_RUNNER_VERSION=0.2.11
+# Keep in sync with rust-toolchain.toml.
+ARG RUST_VERSION=1.97.1
 ARG NODE_MAJOR=20
 
 ENV DEBIAN_FRONTEND=noninteractive \
-    RUSTUP_HOME=/opt/rustup \
-    CARGO_HOME=/opt/cargo \
-    PATH=/opt/cargo/bin:/usr/local/bin:/usr/bin:/bin
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    PATH=/usr/local/cargo/bin:/usr/local/bin:/usr/bin:/bin
 
-# Base tooling + trx-rs build dependencies (mirrors .gitea/workflows/ci.yml).
+# Build dependencies (mirror README's manual instructions).
 RUN apt-get update && apt-get install -y --no-install-recommends \
-        ca-certificates curl xz-utils git sudo pipx \
+        ca-certificates curl git \
         build-essential pkg-config cmake clang libclang-dev \
         libopus-dev libasound2-dev libsoapysdr-dev chromium \
     && rm -rf /var/lib/apt/lists/*
 
-# Node.js (JS-based actions need node in PATH under the host executor).
+# Node.js — JS-based actions (actions/checkout, actions/cache) run *inside*
+# the job container under the Docker executor, so node must be present.
 RUN curl -fsSL https://deb.nodesource.com/setup_${NODE_MAJOR}.x | bash - \
     && apt-get install -y --no-install-recommends nodejs \
     && rm -rf /var/lib/apt/lists/*
 
-# REUSE >= 3 (Debian's packaged reuse is too old for REUSE.toml).
-# The [charset-normalizer] extra provides an encoding-detection backend;
-# without it (and without libmagic) reuse fails to import at runtime.
-RUN PIPX_HOME=/opt/pipx PIPX_BIN_DIR=/usr/local/bin pipx install 'reuse[charset-normalizer]'
-
-# Rust stable with rustfmt + clippy, installed system-wide.
+# Pinned Rust toolchain, installed world-readable so any UID the runner or a
+# devcontainer uses can invoke cargo.
 RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \
-        | sh -s -- -y --no-modify-path --profile minimal \
-          --component rustfmt --component clippy \
-    && chmod -R a+rwX "$CARGO_HOME" "$RUSTUP_HOME"
+      | sh -s -- -y --no-modify-path \
+        --default-toolchain "${RUST_VERSION}" --profile minimal \
+        --component rustfmt --component clippy \
+    && chmod -R a+rwX "$RUSTUP_HOME" "$CARGO_HOME"
 
-# act_runner binary.
-RUN arch="$(dpkg --print-architecture)"; \
-    case "$arch" in amd64) rarch=amd64;; arm64) rarch=arm64;; *) echo "unsupported arch $arch" >&2; exit 1;; esac; \
-    curl -fsSL -o /usr/local/bin/act_runner \
-      "https://gitea.com/gitea/act_runner/releases/download/v${ACT_RUNNER_VERSION}/act_runner-${ACT_RUNNER_VERSION}-linux-${rarch}" \
-    && chmod +x /usr/local/bin/act_runner
+# sccache — shared compilation cache. Enabled at build time via
+# RUSTC_WRAPPER (see the CI workflow and .devcontainer), not repo-wide, so
+# non-SDK builds are unaffected. musl build is static and runs anywhere.
+#
+# The release asset is per-architecture, so resolve it from `uname -m` rather
+# than hardcoding one triple: everything else in this image is arch-agnostic,
+# and a pinned x86_64 URL is what forces an amd64 build (and Rosetta or qemu)
+# on an arm64 host. `uname -m` reflects the build platform under plain
+# docker/podman build as well as buildx, unlike the BuildKit-only TARGETARCH.
+ARG SCCACHE_VERSION=0.8.2
+RUN set -eux; \
+    case "$(uname -m)" in \
+      x86_64)  sccache_arch=x86_64 ;; \
+      aarch64|arm64) sccache_arch=aarch64 ;; \
+      *) echo "unsupported architecture for sccache: $(uname -m)" >&2; exit 1 ;; \
+    esac; \
+    sccache_dist="sccache-v${SCCACHE_VERSION}-${sccache_arch}-unknown-linux-musl"; \
+    curl -fsSL "https://github.com/mozilla/sccache/releases/download/v${SCCACHE_VERSION}/${sccache_dist}.tar.gz" \
+      | tar -xz -C /tmp; \
+    install -m755 "/tmp/${sccache_dist}/sccache" /usr/local/bin/sccache; \
+    rm -rf /tmp/sccache-*
 
-# Default config template (seeded into the /data volume on first boot).
-COPY config.yaml /etc/act_runner/config.yaml
-COPY entrypoint.sh /usr/local/bin/entrypoint.sh
-RUN chmod +x /usr/local/bin/entrypoint.sh
-
-# /data holds the .runner registration, cache and workflow workspaces.
-VOLUME /data
-WORKDIR /data
-
-ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+WORKDIR /work

container/README.md

@@ -3,116 +3,191 @@ SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
 SPDX-License-Identifier: GPL-2.0-or-later
 -->
 
-# Podman-based Gitea Actions runners
+# trx-rs SDK image
 
-Run two independent Gitea Actions runners on one host as rootless Podman
-containers managed by systemd (Quadlet) — one per project — instead of two
-VMs. Uses the **host executor**: workflow steps run directly inside a
-purpose-built runner image that already has the Rust toolchain and all build
-dependencies baked in, so CI runs skip the per-run install cost and no
-Docker/Podman socket is needed.
-
-## Files
+A single container image that is the canonical build environment for trx-rs,
+used **both** by CI and by developers. It bakes in the pinned Rust toolchain
+(matching `rust-toolchain.toml`) and every build dependency, so the compiler
+and `clippy` are identical everywhere — no "works on my machine".
 
 | File | Purpose |
 |------|---------|
-| `Containerfile` | Runner image: Debian + build deps + clang + Rust + Node + `reuse` + `act_runner`. |
-| `entrypoint.sh` | Registers on first boot (if needed), then runs the daemon. |
-| `config.yaml` | act_runner config template (seeded into each runner's volume). |
-| `trx-rs-runner.container` | Quadlet unit for the trx-rs runner. |
-| `project2-runner.container` | Quadlet unit for the second project's runner. |
+| `Containerfile` | The SDK image (Debian + build deps + pinned Rust + Node + git). |
+| `runner-config.example.yaml` | Example act_runner config for the CI VM (Docker executor). |
 
-## Prerequisites (once per host)
+## Build and publish
 
-Rootless Podman with cgroups v2 (default on modern distros). As the unprivileged
-user that will own the runners:
+Nothing in the image is architecture-specific: the base image, the Debian build
+dependencies, Node.js, `rustup` and the `sccache` release all resolve per
+architecture, so the same `Containerfile` builds natively on x86_64 and arm64.
+
+Single architecture — the tag then only works on the architecture you built it
+on:
 
 ```bash
-# Survive logout / start on boot without an interactive session.
-loginctl enable-linger "$USER"
+# from the repo root
+podman build -t git.haxx.space/sjg/trx-rs/sdk:latest container
+podman login git.haxx.space
+podman push git.haxx.space/sjg/trx-rs/sdk:latest
 ```
 
-No `podman.socket` is required for the host executor.
-
-## 1. Build the image
+**Both architectures without emulation.** The CI runner is x86_64 and Apple
+Silicon developer machines are arm64, so `:latest` has to be a manifest list —
+a single-architecture tag makes the other side fall back to Rosetta or qemu.
+Build each half natively on a host of that architecture, then join them:
 
 ```bash
-cd container
-podman build -t trx-rs-ci:latest .
+# on an x86_64 host
+podman build --platform linux/amd64 -t git.haxx.space/sjg/trx-rs/sdk:latest-amd64 container
+podman push git.haxx.space/sjg/trx-rs/sdk:latest-amd64
+
+# on an arm64 host
+podman build --platform linux/arm64 -t git.haxx.space/sjg/trx-rs/sdk:latest-arm64 container
+podman push git.haxx.space/sjg/trx-rs/sdk:latest-arm64
+
+# from either, once both are pushed
+podman manifest create git.haxx.space/sjg/trx-rs/sdk:latest \
+  git.haxx.space/sjg/trx-rs/sdk:latest-amd64 \
+  git.haxx.space/sjg/trx-rs/sdk:latest-arm64
+podman manifest push --all git.haxx.space/sjg/trx-rs/sdk:latest
 ```
 
-## 2. Get a registration token
+Building both from one machine is a single command
+(`podman build --platform linux/amd64,linux/arm64 --manifest ...`), but the
+foreign half runs under emulation and is slow — the two-host flow above is
+what keeps every build native.
 
-For **each** repo: *Settings → Actions → Runners → Create new Runner* and copy
-the token. (Org- or instance-level tokens work too if you prefer wider scope.)
+Tag with the Rust version too (e.g. `:1.97.1`) if you want reproducible pins.
+Make the package **public** (Gitea → Packages → the image → Settings) so the CI
+runner and developers can pull it without credentials. If you keep it private,
+add `credentials:` under the workflow's `container:` and log the runner into the
+registry.
 
-## 3. Install and start the runners
+Pushing a rebuilt image is not enough on its own: `:latest` is a moving tag, and
+act_runner reuses whatever it cached the first time unless `force_pull: true` is
+set (see `runner-config.example.yaml`). Without it the job log says
+`Image exists? true` and the run behaves as though the image were never
+rebuilt — a tool added to the `Containerfile` reads as missing from the image.
+Either set `force_pull`, or refresh the VM's copy by hand:
 
 ```bash
-mkdir -p ~/.config/containers/systemd
-cp trx-rs-runner.container project2-runner.container ~/.config/containers/systemd/
-
-# Paste each repo's token for the FIRST boot only:
-#   Environment=GITEA_RUNNER_REGISTRATION_TOKEN=xxxx…
-$EDITOR ~/.config/containers/systemd/trx-rs-runner.container
-$EDITOR ~/.config/containers/systemd/project2-runner.container
-
-systemctl --user daemon-reload
-systemctl --user start trx-rs-runner
-systemctl --user start project2-runner
-
-systemctl --user status trx-rs-runner
-podman logs -f gitea-runner-trx-rs
+docker pull git.haxx.space/sjg/trx-rs/sdk:latest
+docker run --rm git.haxx.space/sjg/trx-rs/sdk:latest sccache --version
 ```
 
-Once each runner shows **online** in the repo's runner list, blank out the
-`GITEA_RUNNER_REGISTRATION_TOKEN` line again (the registration is persisted in
-the `…-data` volume) and `systemctl --user daemon-reload`.
+### macOS note
 
-## Required workflow change: the `reuse` job
+Apple's `container` CLI builds through a BuildKit helper VM that is configured
+with Rosetta whether or not the target is x86_64, so `container build` fails
+with *"Rosetta is not installed"* on a clean machine. That is a property of the
+builder, not of this image — `container run` works natively without it. Either
+install Rosetta once (`softwareupdate --install-rosetta`, after which an arm64
+build still produces a native arm64 image), or build with Podman, whose arm64
+BuildKit needs no emulation.
 
-The host executor runs steps directly in the container and therefore **cannot
-run Docker-based actions**. The current `reuse` job uses `fsfe/reuse-action@v5`,
-which is a Docker action. `reuse` is baked into the image, so replace that job
-with a plain command:
+## Developer use
 
-```yaml
-  reuse:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: REUSE compliance
-        run: reuse lint
+Reproducible one-off build, no local toolchain needed:
+
+```bash
+podman run --rm -it -v "$PWD":/work -w /work \
+  git.haxx.space/sjg/trx-rs/sdk:latest \
+  cargo build --release
 ```
 
-The `lint` and `test` jobs need no changes: their `sudo apt-get …` and rustup
-steps still run, but become fast no-ops because the image already has those
-packages and the toolchain. (`sudo` is included in the image for exactly this
-reason.)
+Or open the repo in the image via VS Code / JetBrains "Reopen in Container"
+(`.devcontainer/devcontainer.json` points at the same image).
 
-> If you would rather keep Docker-based actions and per-run images, use the
-> **Docker executor** instead: drop the `:host` suffix from the label in
-> `config.yaml`, enable `systemctl --user --now enable podman.socket`, mount it
-> into the container, and set `container.docker_host` to the socket path. That
-> trades the baked-in speed for stronger per-job isolation.
+Building outside the container? `rust-toolchain.toml` pins the same rustc, so
+`rustup` installs the matching toolchain automatically.
 
-## Tuning
+## CI use
 
-- **`capacity`** (in `config.yaml`) — concurrent jobs per runner. Rust builds
-  are heavy; 1–2 is sensible when two runners share a host.
-- **`PodmanArgs=--cpus/--memory`** (in each `.container`) — hard resource caps
-  so one project cannot starve the other.
-- **SELinux** — the `:Z` volume flag is already set; keep it if SELinux is
-  enforcing.
+`.gitea/workflows/ci.yml` runs the `lint`, `test` and `frontend` jobs *inside*
+this image via the `container:` key, so they skip all setup and go straight to
+`cargo` and `npm`. The frontend job needs three things from the image beyond
+Rust: Node.js for the toolchain, Chromium at `/usr/bin/chromium` for the
+browser smoke test, and `cargo` — `npm run verify-generated` regenerates the
+Rust wire contracts before checking for drift.
 
-## Committing these files
+The `reuse` job stays on the upstream `fsfe/reuse-action` (a Docker action the
+Docker executor launches as a sibling container) — nothing REUSE-related is
+baked into the SDK, and it lints the whole repository, so no job runs its own
+licence check.
 
-If you add this directory to a REUSE-checked repo, register the markdown in
-`REUSE.toml` (the other files carry inline SPDX headers):
+## Compilation cache (sccache)
 
-```toml
-[[annotations]]
-path = ["container/**"]
-SPDX-FileCopyrightText = "2026 Stan Grams <sjg@haxx.space>"
-SPDX-License-Identifier = "GPL-2.0-or-later"
+The SDK image ships [`sccache`](https://github.com/mozilla/sccache). It is
+enabled via `RUSTC_WRAPPER=sccache` in CI and the devcontainer (not repo-wide,
+so plain `cargo` builds outside the SDK are unaffected).
+
+- **CI** persists the cache on the runner host — create the dir once:
+  `mkdir -p /var/cache/sccache`. It is bind-mounted into each job container at
+  `/sccache` (see `runner-config.example.yaml`), so cache survives across runs
+  and is shared between the lint/test jobs and both projects.
+- **Devcontainer** uses a named volume (`trx-rs-sccache`).
+- Check effectiveness with `sccache --show-stats` (the CI jobs print it).
+
+`CARGO_INCREMENTAL=0` is set wherever sccache is on, since sccache cannot cache
+incremental artifacts.
+
+## CI runner (Alpine / OpenRC)
+
+The runner uses the **Docker executor** (not the host executor): per-job
+container isolation and standard `ubuntu-latest` semantics. `act_runner` runs
+as an OpenRC service. Files provided:
+
+| File | Purpose |
+|------|---------|
+| `act_runner.openrc` | OpenRC init script (`supervise-daemon`, depends on docker). |
+| `act_runner.confd.example` | Per-instance `conf.d` settings for multi-runner hosts. |
+
+**Cap the thread budget.** In a VM, pin its vCPUs to specific host threads
+(libvirt/KVM):
+
+```xml
+<vcpu placement='static'>2</vcpu>
+<cputune>
+  <vcpupin vcpu='0' cpuset='4'/>
+  <vcpupin vcpu='1' cpuset='5'/>
+</cputune>
 ```
+
+On bare metal, the `container.options: "--cpus=2"` and `capacity: 1` in
+`runner-config.example.yaml` already bound each runner.
+
+**Set it up:**
+
+```bash
+# 1. Docker + a dedicated user with socket access
+apk add docker docker-cli
+rc-update add docker default && rc-service docker start
+adduser -S -D -H -h /var/lib/act_runner act
+addgroup act docker
+
+# 2. act_runner binary (static Go build, works on musl)
+#    Upstream publishes per-architecture builds; pick the host's.
+case "$(uname -m)" in x86_64) arch=amd64 ;; aarch64) arch=arm64 ;; esac
+curl -fsSL -o /usr/local/bin/act_runner \
+  "https://gitea.com/gitea/act_runner/releases/download/v0.2.11/act_runner-0.2.11-linux-${arch}"
+chmod +x /usr/local/bin/act_runner
+
+# 3. Config + register one runner per project (scope keeps their jobs apart)
+install -Dm644 container/runner-config.example.yaml /etc/act_runner/trx-rs.yaml
+install -d -o act /var/lib/act_runner/trx-rs
+su act -s /bin/sh -c 'cd /var/lib/act_runner/trx-rs && \
+  act_runner register --no-interactive \
+    --instance https://git.haxx.space --token <TOKEN> \
+    --name trx-rs-ci \
+    --labels "ubuntu-latest:docker://catthehacker/ubuntu:act-latest"'
+
+# 4. OpenRC service (repeat the symlink+conf.d for the second project)
+install -m755 container/act_runner.openrc /etc/init.d/act_runner
+ln -s act_runner /etc/init.d/act_runner.trx-rs
+install -m644 container/act_runner.confd.example /etc/conf.d/act_runner.trx-rs
+rc-update add act_runner.trx-rs default
+rc-service act_runner.trx-rs start
+```
+
+Check it with `rc-service act_runner.trx-rs status` and
+`tail -f /var/log/act_runner.trx-rs.log`.

container/act_runner.confd.example

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# Per-instance settings for an act_runner OpenRC service.
+# Copy to /etc/conf.d/<service-name>, e.g. /etc/conf.d/act_runner.trx-rs
+# (the name must match the /etc/init.d/ symlink).
+
+# User that runs the daemon. Must be a member of the `docker` group.
+runner_user="act"
+
+# Per-instance state dir (holds the .runner registration) and config file,
+# so two runners on one host stay independent.
+runner_dir="/var/lib/act_runner/trx-rs"
+runner_config="/etc/act_runner/trx-rs.yaml"

container/act_runner.openrc

@@ -0,0 +1,44 @@
+#!/sbin/openrc-run
+# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# OpenRC service for a Gitea act_runner (Docker executor) on Alpine.
+#
+# Install as /etc/init.d/act_runner (chmod +x). Single instance uses
+# /etc/act_runner/config.yaml. For one runner per project, symlink this script
+# and add a matching conf.d file:
+#
+#   ln -s act_runner /etc/init.d/act_runner.trx-rs
+#   cp container/act_runner.confd.example /etc/conf.d/act_runner.trx-rs
+#   $EDITOR /etc/conf.d/act_runner.trx-rs      # set runner_dir / runner_config
+#   rc-update add act_runner.trx-rs default
+#   rc-service act_runner.trx-rs start
+
+description="Gitea Actions runner"
+
+: "${runner_user:=act}"
+: "${runner_dir:=/var/lib/act_runner}"
+: "${runner_config:=/etc/act_runner/config.yaml}"
+
+command="/usr/local/bin/act_runner"
+command_args="daemon --config ${runner_config}"
+# No group given, so supplementary groups (incl. docker) are initialised.
+command_user="${runner_user}"
+directory="${runner_dir}"
+
+supervisor="supervise-daemon"
+respawn_delay=5
+respawn_max=0
+pidfile="/run/${RC_SVCNAME}.pid"
+output_log="/var/log/${RC_SVCNAME}.log"
+error_log="/var/log/${RC_SVCNAME}.log"
+
+depend() {
+	need docker
+	use net dns
+}
+
+start_pre() {
+	checkpath -d -m 0750 -o "${runner_user}" "${runner_dir}"
+	checkpath -f -m 0640 -o "${runner_user}" "${output_log}"
+}

container/config.yaml

@@ -1,32 +0,0 @@
-# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-#
-# act_runner configuration template. Seeded into /data/config.yaml on first
-# boot; edit the copy inside the volume to change settings per runner.
-
-log:
-  level: info
-
-runner:
-  # Registration state. Relative to the daemon's working directory (/data).
-  file: .runner
-  # Concurrent jobs this runner will pick up. Rust builds are heavy — keep this
-  # modest, especially if two runners share one host. The trx-rs workflow has
-  # three parallel jobs (lint, test, reuse); capacity 2 lets two overlap.
-  capacity: 2
-  timeout: 3h
-  # Map the workflow's `runs-on: ubuntu-latest` to the HOST executor, i.e. run
-  # steps directly inside THIS container (which already has all the toolchain).
-  # No Docker/Podman socket is required in this mode.
-  labels:
-    - "ubuntu-latest:host"
-
-cache:
-  # Built-in actions cache server (used by actions/cache). Stored in the volume.
-  enabled: true
-  dir: "/data/cache"
-
-host:
-  # Where per-job workspaces are created.
-  workdir_parent: /data/workflows

container/entrypoint.sh

@@ -1,38 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-#
-# Registers the runner on first boot (if no .runner state exists in /data),
-# then runs the act_runner daemon. Idempotent: on subsequent boots it reuses
-# the stored registration and ignores the token.
-set -euo pipefail
-
-CONFIG_FILE="${CONFIG_FILE:-/data/config.yaml}"
-
-cd /data
-
-# Seed the config from the image's template on first boot so it lives in the
-# persistent volume and can be edited there.
-if [ ! -f "$CONFIG_FILE" ]; then
-    cp /etc/act_runner/config.yaml "$CONFIG_FILE"
-fi
-
-# runner.file in config.yaml is ".runner" (relative to this CWD => /data/.runner).
-if [ ! -f /data/.runner ]; then
-    if [ -z "${GITEA_RUNNER_REGISTRATION_TOKEN:-}" ]; then
-        echo "ERROR: no /data/.runner registration and GITEA_RUNNER_REGISTRATION_TOKEN is empty." >&2
-        echo "       Grab a token from the repo's Settings -> Actions -> Runners and set it" >&2
-        echo "       in the Quadlet unit for the first boot only." >&2
-        exit 1
-    fi
-    echo "Registering runner '${GITEA_RUNNER_NAME:-podman}' with ${GITEA_INSTANCE_URL} ..."
-    act_runner register --no-interactive \
-        --config   "$CONFIG_FILE" \
-        --instance "${GITEA_INSTANCE_URL:?set GITEA_INSTANCE_URL}" \
-        --token    "$GITEA_RUNNER_REGISTRATION_TOKEN" \
-        --name     "${GITEA_RUNNER_NAME:-podman}" \
-        --labels   "${GITEA_RUNNER_LABELS:-ubuntu-latest:host}"
-fi
-
-exec act_runner daemon --config "$CONFIG_FILE"

container/project2-runner.container

@@ -1,40 +0,0 @@
-# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-#
-# Rootless Podman Quadlet for the SECOND project's Gitea Actions runner,
-# co-located on the same host as the trx-rs runner.
-#
-# It has its own name, its own data volume and its own registration token, so
-# the two runners are fully independent. They share the `ubuntu-latest` label,
-# but registration SCOPE (which repo each token came from) keeps their jobs
-# separate — neither will pick up the other's work.
-#
-# If project 2 needs different build dependencies, build it its own image from
-# an adjusted Containerfile and point Image= at that instead of reusing the
-# trx-rs image below.
-
-[Unit]
-Description=Gitea Actions runner — project 2
-After=network-online.target
-Wants=network-online.target
-
-[Container]
-Image=localhost/gitea-act-runner:latest
-ContainerName=gitea-runner-project2
-Volume=gitea-runner-project2-data:/data:Z
-
-Environment=CONFIG_FILE=/data/config.yaml
-Environment=GITEA_INSTANCE_URL=https://git.haxx.space
-Environment=GITEA_RUNNER_NAME=project2-podman
-Environment=GITEA_RUNNER_LABELS=ubuntu-latest:host
-Environment=GITEA_RUNNER_REGISTRATION_TOKEN=
-
-PodmanArgs=--cpus=4.0 --memory=6g
-
-[Service]
-Restart=always
-TimeoutStartSec=0
-
-[Install]
-WantedBy=default.target

container/runner-config.example.yaml

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# Example act_runner config for the Docker-executor runner that lives in the
+# CI VM. This is NOT the SDK image — it configures the runner that launches
+# per-job containers (including the trx-rs SDK image referenced by the
+# workflow's `container:` key). Copy to the VM and pass with
+# `act_runner daemon --config`.
+
+log:
+  level: info
+
+runner:
+  file: .runner
+  # One concurrent job. With one runner per project on a 2-vCPU VM this keeps
+  # total CI usage at ~2 threads.
+  capacity: 1
+  timeout: 3h
+  # Docker executor: no ":host" suffix. Maps runs-on labels to base images
+  # (the workflow overrides these per job via `container:`).
+  labels:
+    - "ubuntu-latest:docker://catthehacker/ubuntu:act-latest"
+
+cache:
+  enabled: true
+
+container:
+  # Cap every job container's CPU so CI stays within the 2-thread budget even
+  # if capacity is raised later. The -v mount persists the sccache cache on the
+  # host (create it first: `mkdir -p /var/cache/sccache`), matching SCCACHE_DIR
+  # in the workflow.
+  options: "--cpus=2 -v /var/cache/sccache:/sccache"
+  # act_runner rejects every bind mount unless it is listed here — the default
+  # is an empty allowlist, so the -v above is dropped with only a
+  # "[...] is not a valid volume, will be ignored" line in the job log, and
+  # SCCACHE_DIR then points at a directory that does not outlive the job.
+  valid_volumes:
+    - /var/cache/sccache
+  # Reuse the host VM's Docker network for the built-in cache/artifact server.
+  network: "host"
+  # The workflow pulls the SDK image by the moving `:latest` tag. Without this
+  # the runner logs "Image exists? true" and reuses whatever it cached the
+  # first time, so pushing a rebuilt image has no effect until someone pulls
+  # on the VM by hand — which looks like the image is missing a tool it in
+  # fact has. The extra registry round-trip per job is nothing next to a build.
+  force_pull: true

container/trx-rs-runner.container

@@ -1,41 +0,0 @@
-# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-#
-# Rootless Podman Quadlet for the trx-rs Gitea Actions runner.
-# Install to ~/.config/containers/systemd/trx-rs-runner.container then:
-#   systemctl --user daemon-reload
-#   systemctl --user start trx-rs-runner
-#
-# First boot only: paste a registration token (repo Settings -> Actions ->
-# Runners) into GITEA_RUNNER_REGISTRATION_TOKEN. After the runner appears
-# online you can blank it again — the registration is persisted in the volume.
-
-[Unit]
-Description=Gitea Actions runner — trx-rs
-After=network-online.target
-Wants=network-online.target
-
-[Container]
-Image=localhost/trx-rs-ci:latest
-ContainerName=gitea-runner-trx-rs
-# Persistent state: .runner registration, cache, workspaces.
-Volume=gitea-runner-trx-rs-data:/data:Z
-
-Environment=CONFIG_FILE=/data/config.yaml
-Environment=GITEA_INSTANCE_URL=https://git.haxx.space
-Environment=GITEA_RUNNER_NAME=trx-rs-podman
-Environment=GITEA_RUNNER_LABELS=ubuntu-latest:host
-Environment=GITEA_RUNNER_REGISTRATION_TOKEN=
-
-# Resource caps so a heavy Rust build here cannot starve the other project's
-# runner on the same host. Tune to your box.
-PodmanArgs=--cpus=4.0 --memory=6g
-
-[Service]
-Restart=always
-# A cold Rust build can be slow; don't let systemd consider startup failed.
-TimeoutStartSec=0
-
-[Install]
-WantedBy=default.target

rust-toolchain.toml

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# Pins the Rust toolchain for reproducible builds. Keep in sync with the
+# SDK image (container/Containerfile, ARG RUST_VERSION). rustup honours this
+# automatically for local builds outside the SDK container.
+
+[toolchain]
+channel = "1.97.1"
+components = ["rustfmt", "clippy"]

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/app.js

@@ -637,6 +637,22 @@ function elementById(id) {
   };
   const layoutCapabilities = { broadcast: false, digital: false };
   let activeRigId = null;
+  const layoutSections = [
+    { id: "advanced-radio-controls", key: "advanced" },
+    { id: "audio-controls", key: "audio" },
+    { id: "scheduler-controls", key: "scheduler" }
+  ];
+  const seededSections = /* @__PURE__ */ new Set();
+  let appliedLayoutName = null;
+  function seedLayoutSections(layout, layoutChanged) {
+    layoutSections.forEach(({ id, key }) => {
+      const section = document.getElementById(id);
+      if (!section) return;
+      if (!layoutChanged && seededSections.has(id)) return;
+      seededSections.add(id);
+      section.open = layout[key];
+    });
+  }
   function layoutStorageKey() {
     return activeRigId ? `trxOperatorLayout:${activeRigId}` : "trxOperatorLayout";
   }
@@ -690,12 +706,9 @@ function elementById(id) {
     const layout = layouts[permittedName];
     document.body.dataset.operatorLayout = permittedName in layouts ? permittedName : "compact";
     if (options.persist !== false) localStorage.setItem(layoutStorageKey(), permittedName);
-    const details = document.getElementById("advanced-radio-controls");
-    if (details) details.open = layout.advanced;
-    const audioDetails = document.getElementById("audio-controls");
-    if (audioDetails) audioDetails.open = layout.audio;
-    const schedulerDetails = document.getElementById("scheduler-controls");
-    if (schedulerDetails) schedulerDetails.open = layout.scheduler;
+    const layoutChanged = appliedLayoutName !== permittedName;
+    appliedLayoutName = permittedName;
+    seedLayoutSections(layout, layoutChanged);
     if (options.navigate && typeof browserWindow.navigateToTab === "function") {
       browserWindow.navigateToTab(layout.preferredTab);
     }
@@ -734,6 +747,98 @@ function elementById(id) {
       api.applyLayout(savedLayoutName(), { persist: false });
     }
   }
+  const overflowOrder = [".operator-layout-picker", ".header-style-pick", "#theme-toggle"];
+  function anchorMenu(button, menu) {
+    const rect = button.getBoundingClientRect();
+    if (menu.parentElement !== document.body) document.body.appendChild(menu);
+    menu.style.position = "fixed";
+    menu.style.zIndex = "9700";
+    menu.style.top = "0px";
+    menu.style.bottom = "auto";
+    menu.style.right = "auto";
+    const width = menu.offsetWidth || 200;
+    const height = menu.offsetHeight || 0;
+    menu.style.left = `${String(Math.round(Math.min(Math.max(8, rect.right - width), window.innerWidth - width - 8)))}px`;
+    const below = rect.bottom + 8;
+    if (below + height <= window.innerHeight - 8) {
+      menu.style.top = `${String(Math.round(below))}px`;
+    } else {
+      menu.style.top = "auto";
+      menu.style.bottom = `${String(Math.round(window.innerHeight - rect.top + 8))}px`;
+    }
+  }
+  function installTopBarOverflow() {
+    const actions = document.querySelector(".top-bar-actions");
+    if (!actions || document.getElementById("top-bar-more")) return;
+    const wrap = document.createElement("div");
+    wrap.id = "top-bar-more";
+    wrap.className = "top-bar-more";
+    const button = document.createElement("button");
+    button.type = "button";
+    button.id = "top-bar-more-btn";
+    button.className = "header-bar-btn top-bar-more-btn";
+    button.textContent = "⋯";
+    button.setAttribute("aria-haspopup", "menu");
+    button.setAttribute("aria-expanded", "false");
+    button.setAttribute("aria-label", "More controls");
+    button.title = "More controls";
+    const menu = document.createElement("div");
+    menu.id = "top-bar-more-menu";
+    menu.className = "top-bar-more-menu";
+    menu.setAttribute("role", "menu");
+    button.setAttribute("aria-controls", menu.id);
+    wrap.append(button, menu);
+    actions.appendChild(wrap);
+    const closeMenu = () => {
+      menu.classList.remove("is-open");
+      button.setAttribute("aria-expanded", "false");
+    };
+    button.addEventListener("click", () => {
+      const open = menu.classList.toggle("is-open");
+      button.setAttribute("aria-expanded", String(open));
+      if (open) anchorMenu(button, menu);
+    });
+    document.addEventListener("click", (event) => {
+      if (!(event.target instanceof Node)) {
+        closeMenu();
+        return;
+      }
+      if (!wrap.contains(event.target) && !menu.contains(event.target)) closeMenu();
+    });
+    document.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") closeMenu();
+    });
+    const barFits = () => {
+      const bar = actions.closest(".tab-bar");
+      if (!bar) return true;
+      const identity = bar.querySelector(".header-main");
+      const nav = bar.querySelector(".tab-bar-nav");
+      const gutters = 48;
+      const needed = (identity?.offsetWidth ?? 0) + (nav?.scrollWidth ?? 0) + actions.scrollWidth + gutters;
+      return needed <= bar.clientWidth;
+    };
+    const reflowOverflow = () => {
+      const nav = document.querySelector(".tab-bar-nav");
+      nav?.classList.remove("nav-icons-only");
+      overflowOrder.forEach((selector) => {
+        const element = menu.querySelector(selector);
+        if (element) actions.insertBefore(element, wrap);
+      });
+      wrap.hidden = true;
+      for (const selector of overflowOrder) {
+        if (barFits()) break;
+        const element = actions.querySelector(selector);
+        if (!element) continue;
+        wrap.hidden = false;
+        menu.appendChild(element);
+      }
+      if (nav && !barFits()) nav.classList.add("nav-icons-only");
+      wrap.hidden = menu.children.length === 0;
+      if (wrap.hidden) closeMenu();
+    };
+    reflowOverflow();
+    window.addEventListener("resize", reflowOverflow);
+  }
   function installMobileMore() {
     const nav = document.querySelector(".tab-bar-nav");
     if (!nav || document.getElementById("mobile-more-btn")) return;
@@ -741,7 +846,8 @@ function elementById(id) {
     more.id = "mobile-more-btn";
     more.className = "tab mobile-more-btn";
     more.type = "button";
-    more.innerHTML = '<span class="tab-more-icon" aria-hidden="true">•••</span><span class="tab-label">More</span>';
+    more.innerHTML = '<span class="tab-more-icon" aria-hidden="true">•••</span><span class="tab-label">Tools</span>';
+    more.setAttribute("aria-label", "Tools and settings");
     more.setAttribute("aria-haspopup", "menu");
     more.setAttribute("aria-expanded", "false");
     const menu = document.createElement("div");
@@ -773,7 +879,10 @@ function elementById(id) {
     more.addEventListener("click", () => {
       const open = menu.classList.toggle("is-open");
       more.setAttribute("aria-expanded", String(open));
-      if (open) menu.querySelector('[role="menuitem"]')?.focus();
+      if (open) {
+        anchorMenu(more, menu);
+        menu.querySelector('[role="menuitem"]')?.focus();
+      }
     });
     document.addEventListener("click", (event) => {
       if (!(event.target instanceof Node) || !menu.contains(event.target) && !more.contains(event.target)) closeMore();
@@ -840,6 +949,7 @@ function elementById(id) {
   api.init = function init() {
     ensureLiveRegions();
     installLayoutControls();
+    installTopBarOverflow();
     installMobileMore();
     installDecoderPicker();
     installDecoderBadges();
@@ -1934,7 +2044,6 @@ var signalSplitValueEl = document.getElementById("signal-split-value");
 var overviewPeakHoldEl = document.getElementById("overview-peak-hold");
 var themeToggleBtn = document.getElementById("theme-toggle");
 var headerRigSwitchSelect = document.getElementById("header-rig-switch-select");
-var headerRigSummary = document.getElementById("header-rig-summary");
 var headerStylePickSelect = document.getElementById("header-style-pick-select");
 var rdsPsOverlay = document.getElementById("rds-ps-overlay");
 var tabMainEl = document.getElementById("tab-main");
@@ -2184,6 +2293,7 @@ async function restorePreviousTuneState() {
   savePreviousTuneState();
   if (saved.mode && modeEl && modeEl.value !== saved.mode) {
     modeEl.value = saved.mode;
+    syncModePicker();
     await postPath(`/set_mode?mode=${encodeURIComponent(saved.mode)}`);
     updateWfmControls();
   }
@@ -2618,6 +2728,17 @@ if (headerStylePickSelect) {
 function readyText() {
   return lastClientCount !== null ? `Ready · ${lastClientCount} user${lastClientCount !== 1 ? "s" : ""}` : "Ready";
 }
+var HINT_ERROR_RE = /failed|missing|unavailable|unknown|lost|required/i;
+var HINT_BUSY_RE = /initializ|connecting|retrying|scanning|shifting|waiting|sending|switching|toggling|setting|not fully/i;
+function hintState(msg) {
+  if (HINT_ERROR_RE.test(msg)) return "error";
+  if (HINT_BUSY_RE.test(msg) || /[\u2026]$|\.\.\.$/.test(msg)) return "busy";
+  return "ok";
+}
+function setPowerHint(msg) {
+  powerHint.textContent = msg;
+  powerHint.dataset.state = hintState(msg);
+}
 function rigBadgeColor(rigId) {
   const text = (rigId || "rx").toString();
   let hash = 0;
@@ -2651,19 +2772,6 @@ function populateRigPicker(selectEl, rigIds, activeRigId, disabled) {
   }
   selectEl.disabled = disabled;
 }
-function updateRigIdentitySummary(rigId, pending = false) {
-  if (!headerRigSummary) return;
-  const rig = serverRigs.find((entry) => entry?.remote === rigId);
-  if (!rig) {
-    headerRigSummary.textContent = pending ? "Switching rigs…" : "No rig details available";
-    return;
-  }
-  const hardware = [rig.manufacturer, rig.model].map((value) => String(value || "").trim()).filter(Boolean).join(" ") || rig.remote;
-  const modes = Array.isArray(rig.supported_modes) ? rig.supported_modes.map(normalizeMode).filter(Boolean) : [];
-  const features = [rig.tx ? "TX" : "RX", rig.filter_controls ? "SDR filters" : null, ...modes.slice(0, 5)];
-  if (modes.length > 5) features.push(`+${modes.length - 5} modes`);
-  headerRigSummary.textContent = `${pending ? "Switching to " : ""}${hardware} · ${features.filter(Boolean).join(" · ")}`;
-}
 function updateRigSubtitle(activeRigId) {
   if (!rigSubtitle) return;
   const name = activeRigId && lastRigDisplayNames[activeRigId] || activeRigId || "--";
@@ -2694,7 +2802,6 @@ function applyRigList(activeRigId, rigIds, displayNames = {}) {
   const disableSwitch = lastRigIds.length === 0 || !authRole || authRole === "rx";
   populateRigPicker(headerRigSwitchSelect, lastRigIds, lastActiveRigId, disableSwitch);
   updateRigSubtitle(lastActiveRigId);
-  updateRigIdentitySummary(lastActiveRigId);
   window.trxUi?.setActiveRig(lastActiveRigId);
   if (rigListChanged) {
     window.trx.modules.scheduler?.setRig(lastActiveRigId);
@@ -2745,12 +2852,12 @@ function refreshOperatorLayoutCapabilities() {
   });
 }
 function showHint(msg, duration) {
-  powerHint.textContent = msg;
+  setPowerHint(msg);
   if (hintTimer) clearTimeout(hintTimer);
   if (duration) hintTimer = setTimeout(() => {
-    powerHint.textContent = readyText();
+    setPowerHint(readyText());
   }, duration);
-  if (/failed|missing|unavailable|unknown|lost|required/i.test(msg)) {
+  if (HINT_ERROR_RE.test(msg)) {
     window.trxUi?.notify(msg, { kind: "error" });
   }
 }
@@ -4021,6 +4128,7 @@ function setDisabled(disabled) {
   [freqEl, centerFreqEl, modeEl, pttBtn, powerBtn, txLimitInput, txLimitBtn, lockBtn].forEach((el) => {
     if (el) el.disabled = disabled;
   });
+  syncModePicker();
 }
 var serverVersion = null;
 var serverBuildDate = null;
@@ -4313,13 +4421,13 @@ function render(update) {
       console.info("Rig initializing:", { manufacturer: manu, model, revision: rev });
       loadingEl.style.display = "";
       if (contentEl) contentEl.style.display = "none";
-      powerHint.textContent = "Initializing rig…";
+      setPowerHint("Initializing rig…");
       setDisabled(true);
       return;
     }
     loadingEl.style.display = "none";
     if (contentEl) contentEl.style.display = "";
-    powerHint.textContent = "Rig not fully initialized yet";
+    setPowerHint("Rig not fully initialized yet");
   } else {
     loadingEl.style.display = "none";
     if (contentEl) contentEl.style.display = "";
@@ -4352,6 +4460,7 @@ function render(update) {
         opt.textContent = m;
         modeEl.appendChild(opt);
       });
+      renderModePicker();
     }
   }
   if (update.info && update.info.capabilities) {
@@ -4478,6 +4587,7 @@ function render(update) {
     const onVirtual = window.trx.modules.vchan?.isOnVirtual() === true;
     if (!onVirtual) {
       modeEl.value = modeUpper2;
+      syncModePicker();
       if (modeUpper2 === "WFM" && lastModeName !== "WFM") {
         setJogDivisor(10);
         resetRdsDisplay();
@@ -4638,7 +4748,7 @@ function render(update) {
     powerBtn.disabled = true;
     powerBtn.textContent = "Power unavailable";
     powerBtn.setAttribute("aria-pressed", "false");
-    powerHint.textContent = "State unknown";
+    setPowerHint("State unknown");
   }
   if (update.status && update.status.tx && typeof update.status.tx.limit === "number") {
     txLimitInput.value = String(update.status.tx.limit);
@@ -4735,7 +4845,7 @@ function render(update) {
   if (Array.isArray(update.remotes)) {
     applyRigList(typeof update.active_remote === "string" ? update.active_remote : null, update.remotes);
   }
-  powerHint.textContent = readyText();
+  setPowerHint(readyText());
   lastLocked = update.status?.lock === true;
   window.trxUi?.setButtonState(lockBtn, {
     active: lastLocked,
@@ -4813,11 +4923,11 @@ function connect() {
       render(data);
       lastEventAt = Date.now();
       if (data.server_connected === false) {
-        powerHint.textContent = "trx-server connection lost";
+        setPowerHint("trx-server connection lost");
         if (tabMainEl) tabMainEl.classList.add("server-disconnected");
       } else {
         if (tabMainEl) tabMainEl.classList.remove("server-disconnected");
-        if (data.initialized) powerHint.textContent = readyText();
+        if (data.initialized) setPowerHint(readyText());
       }
     } catch (e) {
       console.error("Bad event data", e);
@@ -4840,7 +4950,7 @@ function connect() {
   });
   source.onerror = () => {
     if (source.readyState === EventSource.CLOSED) {
-      powerHint.textContent = "trx-client connection lost, retrying…";
+      setPowerHint("trx-client connection lost, retrying…");
       setConnLostOverlay(true, "trx-client connection lost", "Retrying…", true);
       source.close();
       void pollFreshSnapshot();
@@ -4850,7 +4960,7 @@ function connect() {
   esHeartbeat = setInterval(() => {
     const now = Date.now();
     if (now - lastEventAt > 15e3) {
-      powerHint.textContent = "trx-client connection lost, retrying…";
+      setPowerHint("trx-client connection lost, retrying…");
       setConnLostOverlay(true, "trx-client connection lost", "Retrying…", true);
       source.close();
       void pollFreshSnapshot();
@@ -4955,7 +5065,7 @@ async function switchRigFromSelect(selectEl) {
   rigSwitchInProgress = true;
   setControlPending(selectEl, true);
   selectEl.closest(".header-rig-switch")?.classList.add("is-switching");
-  updateRigIdentitySummary(nextRig, true);
+  showHint(`Switching to ${lastRigDisplayNames[nextRig] || nextRig}…`);
   showHint(`Switching to ${lastRigDisplayNames[nextRig] || nextRig}…`);
   try {
     const sidParam = sseSessionId ? `&session_id=${encodeURIComponent(sseSessionId)}` : "";
@@ -4963,7 +5073,6 @@ async function switchRigFromSelect(selectEl) {
     lastActiveRigId = nextRig;
     resetDecoderStateOnRigSwitch();
     updateRigSubtitle(lastActiveRigId);
-    updateRigIdentitySummary(lastActiveRigId);
     window.trxUi?.setActiveRig(lastActiveRigId);
     window.trx.modules.scheduler?.setRig(lastActiveRigId);
     window.trx.modules.backgroundDecode?.setRig(lastActiveRigId);
@@ -4982,7 +5091,6 @@ async function switchRigFromSelect(selectEl) {
   } catch (err) {
     console.error("select_rig failed:", err);
     selectEl.value = prevRig || "";
-    updateRigIdentitySummary(prevRig);
     window.trxUi?.notify("Rig could not be switched", { kind: "error" });
   } finally {
     rigSwitchInProgress = false;
@@ -5237,6 +5345,33 @@ if (jogMultEl) {
   }
   jogStep = Math.max(Math.round(jogUnit / jogMult), minFreqStepHz);
 }
+var modePickerEl = requiredElement("mode-picker");
+function renderModePicker() {
+  modePickerEl.replaceChildren();
+  for (const option of Array.from(modeEl.options)) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.dataset.mode = option.value;
+    btn.textContent = option.textContent;
+    btn.addEventListener("click", () => {
+      if (btn.disabled || modeEl.value === option.value) return;
+      modeEl.value = option.value;
+      syncModePicker();
+      void applyModeFromPicker();
+    });
+    modePickerEl.appendChild(btn);
+  }
+  syncModePicker();
+}
+function syncModePicker() {
+  const active = (modeEl.value || "").toUpperCase();
+  modePickerEl.querySelectorAll("button").forEach((btn) => {
+    const selected = (btn.dataset.mode || "").toUpperCase() === active;
+    btn.classList.toggle("active", selected);
+    btn.disabled = modeEl.disabled;
+    btn.setAttribute("aria-pressed", String(selected));
+  });
+}
 async function applyModeFromPicker() {
   const mode = modeEl.value || "";
   if (!mode) {
@@ -5245,6 +5380,7 @@ async function applyModeFromPicker() {
   }
   updateWfmControls();
   setControlPending(modeEl, true);
+  syncModePicker();
   showHint("Setting mode…");
   try {
     if (await window.trx.modules.vchan?.interceptMode(mode)) {
@@ -5262,6 +5398,7 @@ async function applyModeFromPicker() {
     console.error(err);
   } finally {
     setControlPending(modeEl, false);
+    syncModePicker();
   }
 }
 modeEl.addEventListener("change", applyModeFromPicker);
@@ -5502,6 +5639,11 @@ function navigateToTab(name, options = {}) {
   _activeTab = name;
   document.querySelectorAll(".tab-bar .tab").forEach((t) => t.classList.remove("active"));
   btn.classList.add("active");
+  const toolsBtn = document.getElementById("mobile-more-btn");
+  if (toolsBtn) {
+    const inToolsMenu = !!document.querySelector(`#mobile-more-menu [data-navigate-tab="${name}"]`);
+    toolsBtn.classList.toggle("active", inToolsMenu);
+  }
   window.trxUi?.syncSelectedTab(document.querySelector(".tab-bar-nav"), btn);
   document.querySelectorAll(".tab-panel").forEach((p) => p.style.display = "none");
   const panel = document.getElementById(`tab-${name}`);
@@ -5846,6 +5988,7 @@ var trxCore = Object.freeze({
   syncBandwidthInput,
   scheduleSpectrumDraw,
   onDecoderRegistryReady,
+  syncModePicker,
   formatFreqForStep: formatFrequencyForStep,
   refreshFreqDisplay,
   setJogDivisor,
@@ -6058,6 +6201,7 @@ var wfmCciValEl = document.getElementById("wfm-cci-val");
 var wfmAciFillEl = document.getElementById("wfm-aci-fill");
 var wfmAciValEl = document.getElementById("wfm-aci-val");
 var samControlsCol = document.getElementById("sam-controls-col");
+var modeControlsRow = document.getElementById("mode-controls-row");
 var samStereoWidthEl = document.getElementById("sam-stereo-width");
 var samCarrierSyncEl = document.getElementById("sam-carrier-sync");
 var sdrSquelchWrapEl = document.getElementById("sdr-squelch-wrap");
@@ -6365,6 +6509,7 @@ function updateWfmControls() {
   const mode = (modeEl && modeEl.value ? modeEl.value : "").toUpperCase();
   if (wfmControlsCol) wfmControlsCol.style.display = mode === "WFM" ? "" : "none";
   if (samControlsCol) samControlsCol.style.display = mode === "SAM" ? "" : "none";
+  if (modeControlsRow) modeControlsRow.style.display = mode === "WFM" || mode === "SAM" ? "" : "none";
 }
 if (!hasWebCodecs) {
   rxAudioBtn.disabled = true;
@@ -7332,7 +7477,7 @@ function connectDecode() {
         return;
       }
       if (data.type === "group") {
-        const messages = Array.isArray(data.messages) ? data.messages.filter((message) => isRecord2(message) && typeof message.type === "string") : [];
+        const messages = Array.isArray(data.messages) ? data.messages.filter((message) => isRecord2(message)) : [];
         enqueueDecodeHistoryGroup(typeof data.kind === "string" ? data.kind : "", messages);
         return;
       }
@@ -8482,7 +8627,8 @@ function updateBookmarkAxis(range) {
   updateSideBookmarkStack(leftSideEl, leftBookmarks, colorMap);
   updateSideBookmarkStack(rightSideEl, rightBookmarks, colorMap);
   const hasVisible = visBookmarks.length > 0;
-  axisEl.classList.toggle("bm-axis-visible", hasVisible);
+  axisEl.classList.add("bm-axis-visible");
+  axisEl.classList.toggle("bm-axis-empty", !hasVisible);
   if (!hasVisible) {
     if (axisEl.dataset.bmKey) {
       axisEl.replaceChildren();
@@ -9277,24 +9423,28 @@ function bandplanVisibleSegments(region, loHz, hiHz) {
   }
   return result;
 }
-function _hideBandplanStrip() {
+function _clearBandplanStrip(reserveSpace) {
   if (!bandplanStripEl) return;
-  bandplanStripEl.classList.remove("bp-visible");
-  bandplanStripEl.replaceChildren();
-  bandplanCacheKey = "";
+  if (bandplanCacheKey) {
+    bandplanStripEl.replaceChildren();
+    bandplanCacheKey = "";
+  }
+  bandplanStripEl.classList.toggle("bp-visible", reserveSpace);
+  bandplanStripEl.classList.toggle("bp-empty", reserveSpace);
 }
 function updateBandplanStrip(range) {
   if (!bandplanStripEl) return;
   if (!range || bandplanRegion === "off" || !bandplanData) {
-    if (bandplanStripEl.classList.contains("bp-visible")) _hideBandplanStrip();
+    _clearBandplanStrip(false);
     return;
   }
   const segments = bandplanVisibleSegments(bandplanRegion, range.visLoHz, range.visHiHz);
   if (segments.length === 0) {
-    if (bandplanStripEl.classList.contains("bp-visible")) _hideBandplanStrip();
+    _clearBandplanStrip(true);
     return;
   }
   bandplanStripEl.classList.add("bp-visible");
+  bandplanStripEl.classList.remove("bp-empty");
   const newKey = bandplanRegion + ":" + (bandplanShowLabels ? "L" : "N") + ":" + segments.map((s) => s.low_hz + "-" + s.high_hz).join(",");
   const stripW = bandplanStripEl.clientWidth || 1;
   if (bandplanCacheKey !== newKey) {

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/aprs.js

@@ -7,7 +7,7 @@ import {
   normalizeAprsPacket,
   renderAprsInfo,
   renderLocalAprsSymbol
-} from "./chunk-M2I6DH4X.js";
+} from "./chunk-ROTCLFXS.js";
 import {
   hostCore,
   hostState

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/bookmarks.js

@@ -328,6 +328,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;

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/chunk-ROTCLFXS.js

@@ -75,8 +75,51 @@ function escapeAprsCharacter(character) {
   if (character === '"') return """;
   return character;
 }
+var APRS_SPRITE_COLUMNS = 16;
+var APRS_SPRITE_CELL_PX = 24;
+var APRS_SPRITE_FIRST_CODE = 33;
+var APRS_SPRITE_LAST_CODE = 126;
+function aprsSpriteOffset(code) {
+  if (code.length !== 1) return null;
+  const point = code.charCodeAt(0);
+  if (point < APRS_SPRITE_FIRST_CODE || point > APRS_SPRITE_LAST_CODE) return null;
+  const index = point - APRS_SPRITE_FIRST_CODE;
+  const column = index % APRS_SPRITE_COLUMNS;
+  const row = Math.floor(index / APRS_SPRITE_COLUMNS);
+  return `${String(-column * APRS_SPRITE_CELL_PX)}px ${String(-row * APRS_SPRITE_CELL_PX)}px`;
+}
+function aprsSymbolSprite(symbolTable, symbolCode) {
+  if (!symbolTable || !symbolCode) return null;
+  const symbolOffset = aprsSpriteOffset(symbolCode);
+  if (!symbolOffset) return null;
+  if (symbolTable === "/") {
+    return {
+      className: "aprs-symbol-primary",
+      backgroundPosition: symbolOffset,
+      label: `Primary APRS symbol ${symbolTable}${symbolCode}`
+    };
+  }
+  if (symbolTable === "\\") {
+    return {
+      className: "aprs-symbol-alternate",
+      backgroundPosition: symbolOffset,
+      label: `Alternate APRS symbol ${symbolTable}${symbolCode}`
+    };
+  }
+  const overlayOffset = aprsSpriteOffset(symbolTable);
+  if (!overlayOffset) return null;
+  return {
+    className: "aprs-symbol-overlaid",
+    backgroundPosition: `${overlayOffset}, ${symbolOffset}`,
+    label: `Alternate APRS symbol \\${symbolCode} with overlay ${symbolTable}`
+  };
+}
 function renderLocalAprsSymbol(packet, escapeHtml) {
   if (!packet.symbolTable || !packet.symbolCode) return "";
+  const sprite = aprsSymbolSprite(packet.symbolTable, packet.symbolCode);
+  if (sprite) {
+    return `<span class="aprs-symbol ${sprite.className}" role="img" style="background-position:${sprite.backgroundPosition}" title="${escapeHtml(sprite.label)}" aria-label="${escapeHtml(sprite.label)}"></span>`;
+  }
   const symbol = escapeHtml(packet.symbolCode);
   const table = packet.symbolTable === "/" ? "Primary" : "Alternate";
   return `<span class="aprs-symbol aprs-symbol-local" title="${table} APRS symbol ${symbol}">${symbol}</span>`;
@@ -107,6 +150,7 @@ export {
   collapseAprsDuplicates,
   aprsHexBytes,
   renderAprsInfo,
+  aprsSymbolSprite,
   renderLocalAprsSymbol,
   normalizeAprsPacket
 };

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/hf-aprs.js

@@ -7,7 +7,7 @@ import {
   normalizeAprsPacket,
   renderAprsInfo,
   renderLocalAprsSymbol
-} from "./chunk-M2I6DH4X.js";
+} from "./chunk-ROTCLFXS.js";
 import {
   hostCore,
   hostState

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/map-core.js

@@ -1,3 +1,7 @@
+import {
+  aprsSymbolSprite
+} from "./chunk-ROTCLFXS.js";
+
 // src/map-core.ts
 function mapEl(id) {
   const element = document.querySelector(`#${CSS.escape(id)}`);
@@ -1643,27 +1647,23 @@ 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]

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/vchan.js

@@ -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") {

src/trx-client/trx-frontend/trx-frontend-http/assets/web/index.html

@@ -46,7 +46,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
         <div class="tab-bar-nav" aria-label="Primary navigation">
           <button class="tab active" data-tab="main">
             <svg class="tab-icon" aria-hidden="true"><use href="#icon-home"/></svg>
-            <span class="tab-label">Main</span>
+            <span class="tab-label">Radio</span>
           </button>
           <button class="tab" data-tab="bookmarks">
             <svg class="tab-icon" aria-hidden="true"><use href="#icon-bookmark"/></svg>
@@ -85,7 +85,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
         <button id="header-rec-btn" class="header-bar-btn header-rec-btn" type="button" aria-label="Toggle recording" title="Toggle recording">REC</button>
         <div class="header-rig-switch">
           <select id="header-rig-switch-select" aria-label="Select active rig"></select>
-          <span id="header-rig-summary" class="header-rig-summary" aria-live="polite"></span>
         </div>
         <div class="header-style-pick">
           <select id="header-style-pick-select" aria-label="Select UI style">
@@ -213,31 +212,20 @@ SPDX-License-Identifier: GPL-2.0-or-later
             <input class="status-input" id="center-freq" type="text" value="--" aria-describedby="center-freq-label" aria-label="SDR center frequency" />
             <div class="label" id="center-freq-label"><span>Center Frequency</span></div>
           </div>
-          <div class="freq-field unit-col">
-            <div class="jog-step" id="jog-step">
-              <button type="button" data-step="1000000">MHz</button>
-              <button type="button" data-step="1000" class="active">kHz</button>
-              <button type="button" data-step="1">Hz</button>
-            </div>
-            <div class="label"><span>Unit</span></div>
-          </div>
-          <div class="freq-field mult-col">
-            <div class="jog-mult" id="jog-mult">
-              <button type="button" data-mult="1" class="active" aria-label="Use full tune step">1x</button>
-              <button type="button" data-mult="10" aria-label="Use one tenth tune step">0.1x</button>
-            </div>
-            <div class="label"><span>Step Scale</span></div>
-          </div>
         </div>
       </div>
       <div class="full-row controls-tray-shell">
         <div class="controls-tray-scroll">
           <div class="controls-tray">
             <div class="controls-row full-row">
-              <div class="controls-col label-below-col">
+              <div class="controls-col controls-col-mode label-below-col">
                 <div class="label"><span>Mode</span></div>
                 <div class="inline">
-                  <select class="status-input" id="mode" aria-label="Demodulation mode"></select>
+                  <!-- The select stays as the mode's value: a dozen call sites and
+                       several plugins read #mode.value. It is hidden from sight and
+                       from assistive tech; the buttons beside it are the control. -->
+                  <select class="visually-hidden" id="mode" tabindex="-1" aria-hidden="true"></select>
+                  <div id="mode-picker" class="mode-picker" role="group" aria-label="Demodulation mode"></div>
                 </div>
               </div>
               <div class="controls-col controls-col-center">
@@ -249,6 +237,35 @@ SPDX-License-Identifier: GPL-2.0-or-later
                   <button id="jog-up" type="button" class="jog-btn">+</button>
                 </div>
               </div>
+              <div class="controls-col controls-col-step">
+                <div class="inline step-controls-inline">
+                  <div class="freq-field unit-col">
+                    <div class="jog-step" id="jog-step">
+                      <button type="button" data-step="1000000">MHz</button>
+                      <button type="button" data-step="1000" class="active">kHz</button>
+                      <button type="button" data-step="1">Hz</button>
+                    </div>
+                    <div class="label"><span>Unit</span></div>
+                  </div>
+                  <div class="freq-field mult-col">
+                    <div class="jog-mult" id="jog-mult">
+                      <button type="button" data-mult="1" class="active" aria-label="Use full tune step">1x</button>
+                      <button type="button" data-mult="10" aria-label="Use one tenth tune step">0.1x</button>
+                    </div>
+                    <div class="label"><span>Step Scale</span></div>
+                  </div>
+                </div>
+              </div>
+              <div class="controls-col controls-col-power label-below-col" id="tx-power-col">
+                <div class="label"><span>Transmit / Power</span></div>
+                <div class="btn-grid">
+                  <button id="ptt-btn" type="button" aria-pressed="false">Start TX</button>
+                  <button id="power-btn" type="button" aria-pressed="false">Power On</button>
+                  <button id="lock-btn" type="button" aria-pressed="false">Lock Tuning</button>
+                </div>
+              </div>
+            </div>
+            <div class="controls-row controls-row-mode full-row" id="mode-controls-row" style="display:none">
               <div class="controls-col controls-col-wfm label-below-col" id="wfm-controls-col" style="display:none;">
                 <div class="inline wfm-controls-inline">
                   <label class="wfm-control">
@@ -306,14 +323,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
                 </div>
                 <div class="label"><span>SAM</span></div>
               </div>
-              <div class="controls-col controls-col-power label-below-col" id="tx-power-col">
-                <div class="label"><span>Transmit / Power</span></div>
-                <div class="btn-grid">
-                  <button id="ptt-btn" type="button" aria-pressed="false">Start TX</button>
-                  <button id="power-btn" type="button" aria-pressed="false">Power On</button>
-                  <button id="lock-btn" type="button" aria-pressed="false">Lock Tuning</button>
-                </div>
-              </div>
             </div>
             <div class="full-row label-below-row" id="vfo-row">
               <div class="label"><span>VFO</span></div>
@@ -368,23 +377,25 @@ SPDX-License-Identifier: GPL-2.0-or-later
               <div class="advanced-radio-body">
                 <div class="scheduler-control-row" style="display:none">
                   <div class="scheduler-release-wrap">
-                    <button id="scheduler-release-btn" type="button">Release to Scheduler</button>
-                    <div class="scheduler-step-controls">
-                      <button id="scheduler-prev-btn" type="button">Previous Entry</button>
-                      <button id="scheduler-next-btn" type="button">Next Entry</button>
-                    </div>
-                    <div id="scheduler-release-status" class="scheduler-release-status">Scheduler is controlling the rig.</div>
-                    <div id="scheduler-cycle-status" class="interleave-ring-wrap" style="display:none;">
-                      <svg class="interleave-ring" viewBox="0 0 36 36">
-                        <circle class="interleave-ring-bg" cx="18" cy="18" r="15.915" />
-                        <circle class="interleave-ring-fill" id="interleave-ring-fill" cx="18" cy="18" r="15.915"
-                                stroke-dasharray="100" stroke-dashoffset="100" />
-                      </svg>
-                      <div class="interleave-ring-text">
-                        <div class="interleave-ring-label" id="interleave-active-name">--</div>
-                        <div class="interleave-ring-sub" id="interleave-countdown">--</div>
+                    <div class="scheduler-action-row">
+                      <div class="scheduler-step-controls">
+                        <button id="scheduler-prev-btn" type="button">Previous Entry</button>
+                        <button id="scheduler-next-btn" type="button">Next Entry</button>
+                      </div>
+                      <button id="scheduler-release-btn" type="button">Release to Scheduler</button>
+                      <div id="scheduler-cycle-status" class="interleave-ring-wrap" style="display:none;">
+                        <svg class="interleave-ring" viewBox="0 0 36 36">
+                          <circle class="interleave-ring-bg" cx="18" cy="18" r="15.915" />
+                          <circle class="interleave-ring-fill" id="interleave-ring-fill" cx="18" cy="18" r="15.915"
+                                  stroke-dasharray="100" stroke-dashoffset="100" />
+                        </svg>
+                        <div class="interleave-ring-text">
+                          <div class="interleave-ring-label" id="interleave-active-name">--</div>
+                          <div class="interleave-ring-sub" id="interleave-countdown">--</div>
+                        </div>
                       </div>
                     </div>
+                    <div id="scheduler-release-status" class="scheduler-release-status">Scheduler is controlling the rig.</div>
                   </div>
                 </div>
               </div>
@@ -1052,6 +1063,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
       </template>
     </div>
     <div id="tab-statistics" class="tab-panel" style="display:none;">
+      <h2 class="section-heading">Statistics</h2>
       <template id="tmpl-statistics">
       <div class="stats-controls">
         <div class="stats-control-group">
@@ -1192,6 +1204,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
       </section>
     </div>
     <div id="tab-settings" class="tab-panel" style="display:none;">
+      <h2 class="section-heading">Settings</h2>
       <div class="sub-tab-bar">
         <button class="sub-tab active" data-subtab="settings-scheduler">Scheduler</button>
         <button class="sub-tab" data-subtab="settings-background-decode">Background Decode</button>
@@ -1487,6 +1500,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
       </div>
     </div>
     <div id="tab-about" class="tab-panel" style="display:none;">
+      <h2 class="section-heading">About</h2>
       <div id="auth-badge" style="display:none; margin-bottom: 1rem; padding: 0.5rem; background: var(--bg-secondary); border-radius: 0.25rem; color: var(--text-muted); font-size: 0.85rem;">Authenticated as: <strong id="auth-role-badge">--</strong></div>
       <template id="tmpl-about">
       <div class="sub-tab-bar">
@@ -1592,10 +1606,13 @@ SPDX-License-Identifier: GPL-2.0-or-later
       </template>
     </div>
     <div class="footer">
-      <div class="copyright">
-        Built by <a href="https://www.qrzcq.com/call/SP2SJG" target="_blank" rel="noopener">SP2SJG</a> from <a href="https://haxx.space" target="_blank" rel="noopener">haxx.space</a> · <span class="gh-link-wrap"><a class="gh-link" href="https://git.haxx.space/sjg/trx-rs" target="_blank" rel="noopener" aria-label="Open trx-rs source repository"><svg class="gh-link-icon" viewBox="0 0 16 16" aria-hidden="true"><path d="M9.5 3.25a2.25 2.25 0 1 1 3 2.122V6A2.5 2.5 0 0 1 10 8.5H6a1 1 0 0 0-1 1v1.128a2.251 2.251 0 1 1-1.5 0V5.372a2.25 2.25 0 1 1 1.5 0v1.836A2.493 2.493 0 0 1 6 7h4a1 1 0 0 0 1-1v-.628A2.25 2.25 0 0 1 9.5 3.25Zm-6 0a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Zm8.25-.75a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5ZM4.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Z"></path></svg><span>trx-rs source</span></a></span> — <span id="copyright-year"></span>
+      <div class="footer-meta">
+        <span class="copyright">
+          Built by <a href="https://www.qrzcq.com/call/SP2SJG" target="_blank" rel="noopener">SP2SJG</a> from <a href="https://haxx.space" target="_blank" rel="noopener">haxx.space</a> · &copy; <span id="copyright-year"></span>
+        </span>
+        <span class="gh-link-wrap"><a class="gh-link" href="https://git.haxx.space/sjg/trx-rs" target="_blank" rel="noopener" aria-label="Open trx-rs source repository"><svg class="gh-link-icon" viewBox="0 0 16 16" aria-hidden="true"><path d="M9.5 3.25a2.25 2.25 0 1 1 3 2.122V6A2.5 2.5 0 0 1 10 8.5H6a1 1 0 0 0-1 1v1.128a2.251 2.251 0 1 1-1.5 0V5.372a2.25 2.25 0 1 1 1.5 0v1.836A2.493 2.493 0 0 1 6 7h4a1 1 0 0 0 1-1v-.628A2.25 2.25 0 0 1 9.5 3.25Zm-6 0a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Zm8.25-.75a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5ZM4.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Z"></path></svg><span>trx-rs source</span></a></span>
       </div>
-      <div class="hint" id="power-hint" aria-live="polite">Connecting…</div>
+      <div class="hint" id="power-hint" data-state="busy" aria-live="polite">Connecting…</div>
     </div>
     <div id="conn-lost-overlay" class="decode-history-overlay content-overlay is-hidden" aria-live="assertive" aria-atomic="true">
       <div class="decode-history-overlay-card">

src/trx-client/trx-frontend/trx-frontend-http/assets/web/style.css

@@ -18,6 +18,9 @@ SPDX-License-Identifier: GPL-2.0-or-later
   --accent-green: #c24b1a;
   --accent-yellow: #f0ad4e;
   --accent-red: #e55353;
+  /* Healthy/on indicator. Distinct from --accent-green, which this theme
+     family uses as the (orange) brand accent rather than a status colour. */
+  --status-ok: #00d17f;
   --vchan-color: #38bdf8;
   --control-height: 2.6rem;
   --jog-hi: #243a5b;
@@ -107,6 +110,8 @@ SPDX-License-Identifier: GPL-2.0-or-later
   --accent-green: #b04317;
   --accent-yellow: #b57600;
   --accent-red: #cf3f3f;
+  /* Darker on light backgrounds: #00d17f as text/dots is barely legible there. */
+  --status-ok: #0a9d63;
   --jog-hi: #e6edf8;
   --jog-lo: #cdd9eb;
   --jog-shadow: rgba(58, 79, 110, 0.18);
@@ -267,11 +272,22 @@ input.status-input, select.status-input { width: 100%; padding: 0.45rem 0.5rem;
   -webkit-text-fill-color: currentColor;
 }
 #center-freq { color: var(--wavelength-fg); }
+/* Packs left. As a grid it held a track for every column, but the WFM, SAM and
+   transmit columns are hidden on most rigs, so the row ended in a hole of dead
+   space and the power buttons' label chip floated far from the buttons. */
 .controls-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) auto auto minmax(0, 1fr);
-  gap: 1rem;
-  align-items: start;
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 1rem 1.25rem;
+  align-items: flex-start;
+}
+/* Whatever the current mode adds — WFM's deemphasis and interference meters,
+   SAM's carrier sync — sits on its own line under the controls every rig has,
+   instead of stretching the row sideways when one mode happens to be active. */
+.controls-row-mode {
+  padding-top: 0.85rem;
+  border-top: 1px solid color-mix(in srgb, var(--border-light) 45%, transparent);
 }
 .controls-col {
   min-width: 0;
@@ -299,10 +315,74 @@ input.status-input, select.status-input { width: 100%; padding: 0.45rem 0.5rem;
   width: 100%;
   margin-top: calc((var(--jog-wheel-size) - var(--control-height)) / 2);
 }
+/* Mode: a segmented group sized by its content. As a full-width select it took
+   483px of the row to show "FM"; the modes are all three or four characters and
+   there are at most twelve of them, so they fit two rows in a third of that. */
+.controls-col-mode {
+  flex: 0 1 auto;
+  min-width: 0;
+}
+/* Specific enough to beat .controls-col.label-below-col .inline, whose offset
+   assumes a --control-height field: the picker and the step groups are both
+   3.35rem, so they line up with each other beside the wheel. */
+.controls-col-mode.label-below-col .inline {
+  width: auto;
+  margin-top: calc((var(--jog-wheel-size) - 3.35rem) / 2);
+}
+.mode-picker {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 1px;
+  width: max-content;
+  max-width: 22rem;
+  border: 1px solid var(--border-light);
+  border-radius: 6px;
+  overflow: hidden;
+  background: var(--border-light);
+}
+.mode-picker button {
+  flex: 1 0 3.2rem;
+  border: none;
+  border-radius: 0;
+  min-height: 1.65rem;
+  height: auto;
+  padding: 0.32rem 0.55rem;
+  font-size: 0.82rem;
+  font-weight: 600;
+  background: var(--input-bg);
+  color: var(--text-muted);
+  cursor: pointer;
+}
+.mode-picker button:hover:not(:disabled):not(.active) {
+  color: var(--text);
+  background: var(--btn-hover-bg);
+}
+.mode-picker button.active {
+  background: var(--btn-bg);
+  color: var(--accent-green);
+}
+.mode-picker button:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+/* Tune step: the unit and the scale drive the wheel and the +/- beside it, so
+   they sit with it rather than up in the frequency row. */
+.controls-col-step {
+  flex: 0 0 auto;
+}
+.step-controls-inline {
+  display: flex;
+  gap: 0.75rem;
+  align-items: flex-start;
+  margin-top: calc((var(--jog-wheel-size) - 3.35rem) / 2);
+}
+.step-controls-inline .label {
+  justify-content: flex-start;
+}
 .controls-col-center {
-  justify-self: center;
   width: auto;
   align-items: center;
+  flex: 0 0 auto;
 }
 .controls-col-wfm.label-below-col .label {
   justify-content: flex-start;
@@ -444,12 +524,15 @@ input.status-input, select.status-input { width: 100%; padding: 0.45rem 0.5rem;
   align-self: stretch;
 }
 .controls-col .jog-container { align-self: center; }
+/* Sized by the buttons that are actually there. Three fixed tracks meant a rig
+   without transmit or lock kept two empty ones, leaving its label chip stranded
+   at the far edge of the group. */
 .btn-grid {
-  display: grid;
-  grid-template-columns: repeat(3, 1fr);
+  display: flex;
+  flex-wrap: wrap;
   gap: 0.5rem;
 }
-.btn-grid button { width: 100%; height: var(--control-height); }
+.btn-grid button { flex: 0 1 auto; min-width: 6rem; height: var(--control-height); }
 .jog-container {
   display: flex;
   align-items: center;
@@ -570,6 +653,24 @@ input.status-input, select.status-input { width: 100%; padding: 0.45rem 0.5rem;
   border-color: var(--accent-yellow);
   color: var(--accent-yellow);
 }
+/* One row, read left to right: step through the entries, hand the rig back,
+   then — fenced off — the entry actually on air. */
+.scheduler-action-row {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.35rem;
+}
+/* The rule belongs to the current-entry block, so it leaves with it: the
+   block is display-toggled whenever fewer than two entries are active. */
+.scheduler-action-row #scheduler-cycle-status::before {
+  content: "";
+  align-self: stretch;
+  width: 1px;
+  min-height: 1.7rem;
+  margin-inline: 0.3rem;
+  background: color-mix(in srgb, var(--border-light) 70%, transparent);
+}
 .scheduler-step-controls {
   display: flex;
   flex-wrap: wrap;
@@ -1229,12 +1330,20 @@ small { color: var(--text-muted); }
   gap: 0;
   flex-shrink: 0;
 }
+/* One row, always.  Controls that do not fit are moved into the overflow menu
+ * by ui-core rather than wrapping: wrapping made the header's height depend on
+ * the viewport width in a way that was not even monotonic (112px at 1440,
+ * 169px at 1100, 131px at 900), which is what made the bar feel unstable. */
 .top-bar-actions {
   display: flex;
-  align-items: flex-start;
-  gap: 0.45rem 0.6rem;
+  align-items: center;
+  gap: 0.4rem;
   min-width: 0;
-  flex-wrap: wrap;
+  flex-wrap: nowrap;
+}
+/* Every control in the bar is the same height and none of them stretch. */
+.top-bar-actions > * {
+  flex: 0 0 auto;
 }
 .header-bar-btn.header-audio-btn {
   width: 2rem;
@@ -1403,21 +1512,13 @@ small { color: var(--text-muted); }
   gap: 0.8rem;
   padding: 0.9rem 0.2rem 0;
 }
+/* Inline, not stacked: the summary used to sit under the select, making this
+ * the only 54px control in a bar of 32px ones. */
 .header-rig-switch {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr);
-  align-items: start;
-  gap: 0.35rem;
-}
-.header-rig-summary {
-  display: block;
-  max-width: 20rem;
-  color: var(--text-muted);
-  font-size: var(--fs-xs);
-  line-height: 1.35;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  min-width: 0;
 }
 .header-rig-switch select {
   min-width: 8rem;
@@ -1531,21 +1632,54 @@ small { color: var(--text-muted); }
   align-items: center;
   gap: 0.2rem;
   min-width: 0;
-  flex-wrap: wrap;
+  /* Never wraps.  It must still be able to shrink below its content, or it
+   * overlaps the controls; the menus it anchors are reparented to the body on
+   * open, so clipping here no longer reaches them. */
+  flex-wrap: nowrap;
+  overflow: hidden;
 }
+.tab-bar-nav .tab { flex: 0 0 auto; }
+/* Icons before scrolling: every tab already carries one, and four icons plus
+ * More always fit, so the strip never has to hide a destination.  Applied by
+ * measurement (ui-core's reflowOverflow) rather than at a viewport width: how
+ * much fits depends on the rig name and on how wide the platform renders the
+ * labels, so the same width fits on one machine and clips on another.
+ * Bounded below 761px, where the strip becomes the bottom nav and keeps its
+ * labels under the icons. */
+@media (min-width: 761px) {
+  .tab-bar-nav.nav-icons-only .tab .tab-label { display: none; }
+  .tab-bar-nav.nav-icons-only .tab .tab-icon,
+  .tab-bar-nav.nav-icons-only .tab .tab-more-icon { display: block; }
+  .tab-bar-nav.nav-icons-only .tab { padding: 0.45rem 0.55rem; }
+}
+/* The selected destination is boxed, not underlined — the same treatment the
+   mobile bottom nav already used, so one navigation model reads the same at
+   every width. The transparent border is on the base so switching tabs moves
+   no neighbours. */
 .tab {
   background: transparent;
-  border: none;
-  border-bottom: 2px solid transparent;
-  border-radius: 0;
-  padding: 0.5rem 0.95rem;
+  border: 1px solid transparent;
+  border-radius: var(--radius-md);
+  padding: 0.45rem 0.9rem;
   color: var(--text-muted);
   cursor: pointer;
   font-size: 0.95rem;
   height: auto;
+  transition: color var(--dur-fast) var(--ease-standard),
+              background-color var(--dur-fast) var(--ease-standard),
+              border-color var(--dur-fast) var(--ease-standard);
+}
+.tab.active {
+  border-color: color-mix(in srgb, var(--accent-green) 50%, var(--border-light));
+  background: color-mix(in srgb, var(--accent-green) 12%, transparent);
+  color: var(--accent-text);
+  font-weight: 600;
+}
+.tab:hover:not(.active) {
+  color: var(--text);
+  background: color-mix(in srgb, var(--btn-bg) 55%, transparent);
+  border-color: color-mix(in srgb, var(--border-light) 40%, transparent);
 }
-.tab.active { border-bottom-color: var(--accent-green); color: var(--accent-text); font-weight: 600; }
-.tab:hover:not(.active) { color: var(--text); }
 /* Tab icons — hidden on desktop, shown on mobile bottom nav */
 .tab-icon {
   display: none;
@@ -1554,6 +1688,7 @@ small { color: var(--text-muted); }
   flex-shrink: 0;
 }
 .tab-label { display: block; }
+.tab-more-icon { display: none; }
 .about-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(320px, 1fr)); gap: 1rem; }
 .about-card { background: var(--card-bg); border: 1px solid var(--border); border-radius: 0.5rem; padding: 0; overflow: hidden; }
 .about-card-title { display: flex; align-items: center; gap: 0.5rem; padding: 0.6rem 0.75rem; font-size: 0.8rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.04em; color: var(--text-heading); border-bottom: 1px solid var(--border); background: color-mix(in srgb, var(--card-bg) 50%, var(--bg)); }
@@ -1562,15 +1697,88 @@ small { color: var(--text-muted); }
 .about-table td { padding: 0.4rem 0.75rem; border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent); font-size: 0.85rem; }
 .about-table tr:last-child td { border-bottom: none; }
 .about-table td:first-child { color: var(--text-muted); width: 40%; }
-.about-status-on { color: #00d17f; }
+.about-status-on { color: var(--status-ok); }
 .about-status-off { color: var(--text-muted); }
 .plugin-item { padding: 0.5rem 0.6rem; border-bottom: 1px solid var(--border); color: var(--text); }
 .plugin-item:last-child { border-bottom: none; }
-.footer { display: flex; justify-content: space-between; align-items: baseline; margin-top: auto; padding-top: 1rem; flex-shrink: 0; }
+/* ── Footer ───────────────────────────────────────────────────────────
+   A hairline rule closes the page the way .tab-bar opens it; the two
+   clusters (attribution + source pill, live status chip) sit on one
+   baseline-free centre line so the pills don't hang off the text. */
+.footer {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: var(--space-4);
+  flex-wrap: wrap;
+  margin-top: auto;
+  padding: var(--space-3) 0 var(--space-1);
+  border-top: 1px solid color-mix(in srgb, var(--border-light) 45%, transparent);
+  flex-shrink: 0;
+}
+.footer-meta {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+  flex-wrap: wrap;
+  min-width: 0;
+}
 .full-row { grid-column: 1 / -1; }
-.copyright { color: var(--text-muted); font-size: 0.75rem; opacity: 0.7; }
+/* No opacity: --text-muted is already the muted step, and stacking the
+   two put the attribution below a readable contrast ratio. */
+.copyright { color: var(--text-muted); font-size: var(--fs-xs); }
 .copyright a { color: var(--accent-text); text-decoration: none; }
 .copyright a:hover { text-decoration: underline; }
+/* Live status: dot + text, colour driven by the data-state app.ts sets. */
+.footer .hint {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-2);
+  font-size: var(--fs-xs);
+  color: var(--text-heading);
+  padding: 0.2rem 0.6rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid color-mix(in srgb, var(--border-light) 60%, transparent);
+  background: color-mix(in srgb, var(--btn-bg) 55%, transparent);
+  font-variant-numeric: tabular-nums;
+}
+.footer .hint::before {
+  content: "";
+  width: 0.45rem;
+  height: 0.45rem;
+  flex-shrink: 0;
+  border-radius: 50%;
+  background: var(--text-muted);
+  box-shadow: 0 0 0 0.16rem color-mix(in srgb, var(--text-muted) 22%, transparent);
+  transition: background var(--dur-base) var(--ease-standard),
+              box-shadow var(--dur-base) var(--ease-standard);
+}
+.footer .hint[data-state="ok"]::before {
+  background: var(--status-ok);
+  box-shadow: 0 0 0 0.16rem color-mix(in srgb, var(--status-ok) 24%, transparent);
+}
+.footer .hint[data-state="busy"]::before {
+  background: var(--accent-yellow);
+  box-shadow: 0 0 0 0.16rem color-mix(in srgb, var(--accent-yellow) 24%, transparent);
+}
+.footer .hint[data-state="error"] {
+  color: var(--accent-red);
+  border-color: color-mix(in srgb, var(--accent-red) 45%, var(--border-light));
+}
+.footer .hint[data-state="error"]::before {
+  background: var(--accent-red);
+  box-shadow: 0 0 0 0.16rem color-mix(in srgb, var(--accent-red) 24%, transparent);
+}
+@media (prefers-reduced-motion: no-preference) {
+  .footer .hint[data-state="busy"]::before,
+  .footer .hint[data-state="error"]::before {
+    animation: trx-status-pulse 1.8s var(--ease-standard) infinite;
+  }
+}
+@keyframes trx-status-pulse {
+  0%, 100% { opacity: 1; }
+  50%      { opacity: 0.45; }
+}
 .gh-link-wrap {
   display: inline-flex;
   vertical-align: middle;
@@ -1579,6 +1787,8 @@ small { color: var(--text-muted); }
 .gh-link {
   display: inline-flex;
   align-items: center;
+  text-decoration: none;
+  font-size: var(--fs-xs);
   gap: 0.34rem;
   padding: 0.18rem 0.5rem;
   border-radius: 999px;
@@ -1826,11 +2036,17 @@ small { color: var(--text-muted); }
   font-size: 0.82rem;
   color: var(--text-muted);
 }
+/* Full-bleed: break the map panel out of the centred .card column so the
+   stage spans the whole viewport width. The negative inline margins cancel
+   the card's centring offset plus its side padding, whatever they are. */
 #tab-map {
   display: flex;
   flex-direction: column;
   min-height: 0;
   gap: 0.85rem;
+  width: 100vw;
+  max-width: 100vw;
+  margin-inline: calc(50% - 50vw);
 }
 /* map-loading uses the shared .decode-history-overlay .content-overlay classes */
 #map-stage {
@@ -1838,8 +2054,9 @@ small { color: var(--text-muted); }
   flex: 0 1 auto;
   min-height: 0;
   overflow: hidden;
-  border-radius: 6px;
+  border-radius: 0;
   border: 1px solid color-mix(in srgb, var(--border-light) 78%, transparent);
+  border-inline: 0;
   background:
     linear-gradient(180deg, color-mix(in srgb, var(--card-bg) 86%, transparent), color-mix(in srgb, var(--card-bg) 64%, transparent)),
     color-mix(in srgb, var(--input-bg) 88%, transparent);
@@ -2520,7 +2737,21 @@ body.map-fake-fullscreen-active {
   font-size: 0.75rem;
   word-break: break-all;
 }
-.aprs-symbol { display: inline-block; width: 24px; height: 24px; background-size: 384px 192px; vertical-align: middle; margin-right: 0.3rem; }
+/* APRS symbols are drawn from the vendored hessu/aprs-symbols sprite sheets:
+   16x6 grids of 24px cells, indexed by `symbol code - 0x21`.  The cell offset
+   is set inline by the APRS/map bundles; the sheet URL stays here so retina
+   displays can swap in the @2x variants. */
+.aprs-symbol { display: inline-block; width: 24px; height: 24px; background-repeat: no-repeat; background-size: 384px 144px; vertical-align: middle; margin-right: 0.3rem; }
+.aprs-symbol-marker { margin-right: 0; }
+.aprs-symbol-primary { background-image: url('/vendor/aprs-symbols-24-0.png'); }
+.aprs-symbol-alternate { background-image: url('/vendor/aprs-symbols-24-1.png'); }
+.aprs-symbol-overlaid { background-image: url('/vendor/aprs-symbols-24-2.png'), url('/vendor/aprs-symbols-24-1.png'); }
+@media (min-resolution: 2dppx) {
+  .aprs-symbol-primary { background-image: url('/vendor/aprs-symbols-24-0-2x.png'); }
+  .aprs-symbol-alternate { background-image: url('/vendor/aprs-symbols-24-1-2x.png'); }
+  .aprs-symbol-overlaid { background-image: url('/vendor/aprs-symbols-24-2-2x.png'), url('/vendor/aprs-symbols-24-1-2x.png'); }
+}
+/* Fallback for symbol codes outside the sprite sheets: show the raw character. */
 .aprs-symbol-local { border: 1px solid var(--border); border-radius: 4px; background: var(--surface-raised); color: var(--text); font: 700 0.8rem/22px ui-monospace, monospace; text-align: center; }
 .aprs-pos { color: var(--accent-green); text-decoration: none; margin-left: 0.3rem; font-size: 0.8rem; }
 .aprs-pos:hover { text-decoration: underline; }
@@ -2964,7 +3195,10 @@ button.is-active {
   text-transform: uppercase;
   overflow: visible;
 }
-.operator-layout-picker::before { content: "Layout"; }
+/* The prefix made the least-used control the widest in the bar; the
+ * select carries its own aria-label and title instead. */
+.operator-layout-picker { padding-left: 0; }
+.operator-layout-picker select { max-width: 8rem; }
 .operator-layout-picker select {
   width: auto;
   min-height: 2rem;
@@ -3024,9 +3258,6 @@ body[data-operator-layout="broadcast"] #sam-controls-col,
 body[data-operator-layout="broadcast"] #advanced-radio-controls {
   display: none !important;
 }
-body[data-operator-layout="broadcast"] .controls-row {
-  grid-template-columns: minmax(8rem, 0.65fr) auto minmax(20rem, 2fr);
-}
 body[data-operator-layout="broadcast"] #wfm-controls-col,
 body[data-operator-layout="broadcast"] #audio-row,
 body[data-operator-layout="broadcast"] #spectrum-bw-row {
@@ -3057,12 +3288,24 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
   display: none !important;
 }
 @media (max-width: 760px) {
-  body[data-operator-layout="broadcast"] .controls-row { grid-template-columns: 1fr auto; }
-  body[data-operator-layout="broadcast"] #wfm-controls-col { grid-column: 1 / -1; }
+  body[data-operator-layout="broadcast"] #wfm-controls-col { flex-basis: 100%; }
 }
-.mobile-more-btn, .mobile-more-menu, .decoder-tab-select { display: none; }
+/* One navigation model at every width.  Statistics, Recorder, Settings and
+ * About are occasional destinations: they live behind More rather than
+ * competing with the operating tabs for the row and then scrolling out of
+ * reach.  The mobile layout already grouped them this way; the desktop strip
+ * now matches it, which is why the tab strip no longer needs to scroll. */
+.tab-bar-nav .tab[data-tab="statistics"],
+.tab-bar-nav .tab[data-tab="recorder"],
+.tab-bar-nav .tab[data-tab="settings"],
+.tab-bar-nav .tab[data-tab="about"] { display: none; }
+.mobile-more-btn { display: flex; flex: 0 0 auto; }
+.mobile-more-menu, .decoder-tab-select { display: none; }
+.tab-bar-nav { position: relative; }
 .mobile-more-menu {
-  position: fixed;
+  position: absolute;
+  top: calc(100% + 0.4rem);
+  right: 0;
   right: max(0.75rem, env(safe-area-inset-right));
   bottom: calc(5.4rem + env(safe-area-inset-bottom));
   z-index: 80;
@@ -3170,9 +3413,8 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
     height: 1rem;
     cursor: ew-resize;
   }
-  .controls-row { grid-template-columns: 1fr auto; }
-  .controls-col-wfm { grid-column: 1 / -1; }
-  .controls-col-power { grid-column: 1 / -1; }
+  .controls-col-wfm { flex-basis: 100%; }
+  .controls-col-power { flex-basis: 100%; }
   .controls-col.label-below-col .inline,
   .controls-col.label-below-col .btn-grid { margin-top: 0; }
   .wfm-controls-inline { flex-wrap: wrap; }
@@ -3231,7 +3473,6 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
     min-height: 3.2rem;
     padding: 0.35rem 0.1rem 0.3rem;
     border: 1px solid transparent;
-    border-bottom: none;
     border-radius: 0.75rem;
     white-space: nowrap;
     text-align: center;
@@ -3251,7 +3492,7 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
     color: var(--text);
     box-shadow: inset 0 1px 0 color-mix(in srgb, #ffffff 8%, transparent);
   }
-  .tab-icon { display: block; }
+  .tab-icon, .tab-more-icon { display: block; }
   /* Shorten long tab labels to keep bottom nav compact */
   .tab[data-tab="bookmarks"] .tab-label { font-size: 0.6rem; }
   .tab[data-tab="digital-modes"] .tab-label  { font-size: 0.6rem; }
@@ -3259,6 +3500,12 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
   .tab[data-tab="statistics"], .tab[data-tab="recorder"],
   .tab[data-tab="settings"], .tab[data-tab="about"] { display: none; }
   .mobile-more-btn { display: flex; }
+  .mobile-more-menu {
+    position: fixed;
+    top: auto;
+    right: max(0.75rem, env(safe-area-inset-right));
+    bottom: calc(5.4rem + env(safe-area-inset-bottom));
+  }
   .mobile-more-btn[aria-expanded="true"] {
     color: var(--accent-text);
     background: color-mix(in srgb, var(--accent-green) 10%, transparent);
@@ -3282,24 +3529,24 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
   .toast-region { bottom: calc(5.7rem + env(safe-area-inset-bottom)); }
   .top-bar-actions {
     width: 100%;
-    justify-content: flex-start;
-    flex-wrap: wrap;
-    gap: 0.45rem;
+    justify-content: flex-end;
+    flex-wrap: nowrap;
+    gap: 0.4rem;
   }
   .operator-layout-picker { max-width: 100%; }
   .operator-layout-picker select { max-width: 10rem; }
   .header-rig-switch,
   .header-style-pick {
-    flex: 1 1 12rem;
+    flex: 0 0 auto;
     min-width: 0;
   }
   .header-rig-switch select,
   .header-style-pick select {
-    width: 100%;
+    width: auto;
     min-width: 0;
   }
   .header-bar-btn {
-    flex: 1 1 calc(50% - 0.3rem);
+    flex: 0 0 auto;
     min-width: 0;
   }
   #tab-main,
@@ -3799,6 +4046,11 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
   overflow: hidden;
   border-bottom-color: var(--border-light, rgba(255,255,255,0.06));
 }
+/* No allocations in range. The height stays reserved — collapsing it moved
+   every element below by 18px each time tuning left a band. */
+#spectrum-bandplan-strip.bp-empty {
+  background: color-mix(in srgb, var(--border) 22%, transparent);
+}
 .bp-segment {
   position: absolute;
   top: 0;
@@ -3889,6 +4141,12 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
   height: 38px;
   overflow: visible;
 }
+/* The rail sits over the top of the overview plot, so it must not swallow
+   drags and clicks meant for it — only the chips themselves are targets. */
+#spectrum-bookmark-axis { pointer-events: none; }
+#spectrum-bookmark-axis .spectrum-bookmark-chip { pointer-events: auto; }
+/* Nothing bookmarked in range: the rail keeps its place but stays blank —
+   no caption over the plot. */
 .spectrum-bookmark-chip {
   position: absolute;
   top: 2px;
@@ -4137,11 +4395,12 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
 @media (max-width: 520px) {
   /* Single-column controls: jog first, then mode, then power */
   .controls-row {
-    grid-template-columns: 1fr;
+    flex-direction: column;
+    align-items: stretch;
   }
   .controls-col-center {
     order: -1;
-    justify-self: center;
+    align-self: center;
     width: auto;
   }
   .controls-col-center::after { display: none; }
@@ -5153,7 +5412,6 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
   display: flex;
   flex-direction: column;
   gap: 1rem;
-  padding: 1rem;
 }
 .stats-controls {
   display: flex;
@@ -5379,3 +5637,51 @@ body[data-operator-layout="broadcast"] #cw-bar-overlay {
     font-size: max(0.75rem, 12px);
   }
 }
+
+
+/* --- Top bar overflow menu ------------------------------------------------ */
+.top-bar-more { position: relative; }
+.top-bar-more[hidden] { display: none; }
+.top-bar-more-btn {
+  width: 2rem;
+  height: 2rem;
+  min-height: 2rem;
+  padding: 0;
+  font-size: 1rem;
+  line-height: 1;
+}
+.top-bar-more-menu {
+  position: absolute;
+  top: calc(100% + 0.35rem);
+  right: 0;
+  z-index: 40;
+  display: none;
+  flex-direction: column;
+  gap: 0.4rem;
+  min-width: 12rem;
+  padding: 0.5rem;
+  border: 1px solid var(--border-light);
+  border-radius: var(--radius-md);
+  background: var(--surface);
+  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.28);
+}
+.top-bar-more-menu.is-open { display: flex; }
+.top-bar-more-menu > * { width: 100%; }
+.top-bar-more-menu select { width: 100%; max-width: none; }
+
+
+/* Page title for destinations reached through the Tools menu.  The tab strip
+ * cannot show which of them is active, so each states its own name.
+ *
+ * The margin is the spacing on the plain block panels; #tab-statistics is a
+ * flex column with its own `gap`, where the margin lands on top of that gap
+ * and doubles the space under the title. */
+.section-heading {
+  margin: 0 0 var(--space-3);
+  font-size: 1.15rem;
+  font-weight: 700;
+  line-height: 1.2;
+  color: var(--text);
+}
+
+#tab-statistics > .section-heading { margin-bottom: 0; }

src/trx-client/trx-frontend/trx-frontend-http/frontend/package.json

@@ -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",
     "verify-generated": "npm run generate-types && npm run build && git diff --exit-code -- ../assets/web/generated src/api/generated.ts"
   },
   "devDependencies": {

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/app.ts

@@ -724,7 +724,6 @@ const signalSplitValueEl = document.getElementById("signal-split-value");
 const overviewPeakHoldEl = document.getElementById("overview-peak-hold") as HTMLInputElement | null;
 const themeToggleBtn = document.getElementById("theme-toggle") as HTMLButtonElement | null;
 const headerRigSwitchSelect = document.getElementById("header-rig-switch-select") as HTMLSelectElement | null;
-const headerRigSummary = document.getElementById("header-rig-summary");
 const headerStylePickSelect = document.getElementById("header-style-pick-select") as HTMLSelectElement | null;
 const rdsPsOverlay = document.getElementById("rds-ps-overlay");
 const tabMainEl = document.getElementById("tab-main");
@@ -1004,6 +1003,7 @@ async function restorePreviousTuneState() {
   savePreviousTuneState(); // save current as previous so B toggles back
   if (saved.mode && modeEl && modeEl.value !== saved.mode) {
     modeEl.value = saved.mode;
+    syncModePicker();
     await postPath(`/set_mode?mode=${encodeURIComponent(saved.mode)}`);
     updateWfmControls();
   }
@@ -1333,6 +1333,22 @@ function readyText() {
   return lastClientCount !== null ? `Ready \u00b7 ${lastClientCount} user${lastClientCount !== 1 ? "s" : ""}` : "Ready";
 }
 
+// The footer hint is a status pill whose dot is coloured from data-state,
+// so the text has to be written through setPowerHint rather than assigned.
+const HINT_ERROR_RE = /failed|missing|unavailable|unknown|lost|required/i;
+const HINT_BUSY_RE = /initializ|connecting|retrying|scanning|shifting|waiting|sending|switching|toggling|setting|not fully/i;
+
+function hintState(msg: string): "ok" | "busy" | "error" {
+  if (HINT_ERROR_RE.test(msg)) return "error";
+  if (HINT_BUSY_RE.test(msg) || /[\u2026]$|\.\.\.$/.test(msg)) return "busy";
+  return "ok";
+}
+
+function setPowerHint(msg: string) {
+  powerHint.textContent = msg;
+  powerHint.dataset.state = hintState(msg);
+}
+
 function rigBadgeColor(rigId: string) {
   const text = (rigId || "rx").toString();
   let hash = 0;
@@ -1371,20 +1387,6 @@ function populateRigPicker(selectEl: HTMLSelectElement | null, rigIds: string[],
   selectEl.disabled = disabled;
 }
 
-function updateRigIdentitySummary(rigId: string | null, pending = false) {
-  if (!headerRigSummary) return;
-  const rig = serverRigs.find((entry) => entry?.remote === rigId);
-  if (!rig) {
-    headerRigSummary.textContent = pending ? "Switching rigs…" : "No rig details available";
-    return;
-  }
-  const hardware = [rig.manufacturer, rig.model].map(value => String(value || "").trim()).filter(Boolean).join(" ") || rig.remote;
-  const modes = Array.isArray(rig.supported_modes) ? rig.supported_modes.map(normalizeMode).filter(Boolean) : [];
-  const features = [rig.tx ? "TX" : "RX", rig.filter_controls ? "SDR filters" : null, ...modes.slice(0, 5)];
-  if (modes.length > 5) features.push(`+${modes.length - 5} modes`);
-  headerRigSummary.textContent = `${pending ? "Switching to " : ""}${hardware} · ${features.filter(Boolean).join(" · ")}`;
-}
-
 function updateRigSubtitle(activeRigId: string | null) {
   if (!rigSubtitle) return;
   const name = (activeRigId && lastRigDisplayNames[activeRigId]) || activeRigId || "--";
@@ -1421,7 +1423,6 @@ function applyRigList(activeRigId: string | null, rigIds: string[], displayNames
   const disableSwitch = lastRigIds.length === 0 || !authRole || authRole === "rx";
   populateRigPicker(headerRigSwitchSelect, lastRigIds, lastActiveRigId, disableSwitch);
   updateRigSubtitle(lastActiveRigId);
-  updateRigIdentitySummary(lastActiveRigId);
   window.trxUi?.setActiveRig(lastActiveRigId);
   if (rigListChanged) {
     window.trx.modules.scheduler?.setRig(lastActiveRigId);
@@ -1477,10 +1478,10 @@ function refreshOperatorLayoutCapabilities() {
 }
 
 function showHint(msg: string, duration?: number) {
-  powerHint.textContent = msg;
+  setPowerHint(msg);
   if (hintTimer) clearTimeout(hintTimer);
-  if (duration) hintTimer = setTimeout(() => { powerHint.textContent = readyText(); }, duration);
-  if (/failed|missing|unavailable|unknown|lost|required/i.test(msg)) {
+  if (duration) hintTimer = setTimeout(() => { setPowerHint(readyText()); }, duration);
+  if (HINT_ERROR_RE.test(msg)) {
     window.trxUi?.notify(msg, { kind: "error" });
   }
 }
@@ -2963,6 +2964,7 @@ function setDisabled(disabled: boolean) {
   [freqEl, centerFreqEl, modeEl, pttBtn, powerBtn, txLimitInput, txLimitBtn, lockBtn].forEach((el) => {
     if (el) el.disabled = disabled;
   });
+  syncModePicker();
 }
 
 let serverVersion: string | null = null;
@@ -3308,13 +3310,13 @@ function render(update: AppUpdate) {
       console.info("Rig initializing:", { manufacturer: manu, model, revision: rev });
       loadingEl.style.display = "";
       if (contentEl) contentEl.style.display = "none";
-      powerHint.textContent = "Initializing rig…";
+      setPowerHint("Initializing rig…");
       setDisabled(true);
       return;
     }
     loadingEl.style.display = "none";
     if (contentEl) contentEl.style.display = "";
-    powerHint.textContent = "Rig not fully initialized yet";
+    setPowerHint("Rig not fully initialized yet");
   } else {
     loadingEl.style.display = "none";
     if (contentEl) contentEl.style.display = "";
@@ -3352,6 +3354,7 @@ function render(update: AppUpdate) {
         opt.textContent = m;
         modeEl.appendChild(opt);
       });
+      renderModePicker();
     }
   }
   if (update.info && update.info.capabilities) {
@@ -3497,6 +3500,7 @@ function render(update: AppUpdate) {
     // vchan.js will apply the correct mode via vchanSyncModeDisplay().
     if (!onVirtual) {
       modeEl.value = modeUpper;
+      syncModePicker();
       if (modeUpper === "WFM" && lastModeName !== "WFM") {
         setJogDivisor(10);
         resetRdsDisplay();
@@ -3665,7 +3669,7 @@ function render(update: AppUpdate) {
     powerBtn.disabled = true;
     powerBtn.textContent = "Power unavailable";
     powerBtn.setAttribute("aria-pressed", "false");
-    powerHint.textContent = "State unknown";
+    setPowerHint("State unknown");
   }
 
   if (update.status && update.status.tx && typeof update.status.tx.limit === "number") {
@@ -3776,7 +3780,7 @@ function render(update: AppUpdate) {
   if (Array.isArray(update.remotes)) {
     applyRigList(typeof update.active_remote === "string" ? update.active_remote : null, update.remotes);
   }
-  powerHint.textContent = readyText();
+  setPowerHint(readyText());
   lastLocked = update.status?.lock === true;
   window.trxUi?.setButtonState(lockBtn, {
     active: lastLocked,
@@ -3863,11 +3867,11 @@ function connect() {
       render(data);
       lastEventAt = Date.now();
       if (data.server_connected === false) {
-        powerHint.textContent = "trx-server connection lost";
+        setPowerHint("trx-server connection lost");
         if (tabMainEl) tabMainEl.classList.add("server-disconnected");
       } else {
         if (tabMainEl) tabMainEl.classList.remove("server-disconnected");
-        if (data.initialized) powerHint.textContent = readyText();
+        if (data.initialized) setPowerHint(readyText());
       }
     } catch (e) {
       console.error("Bad event data", e);
@@ -3890,7 +3894,7 @@ function connect() {
   source.onerror = () => {
     // Check if this is an auth error by looking at readyState
     if (source.readyState === EventSource.CLOSED) {
-      powerHint.textContent = "trx-client connection lost, retrying\u2026";
+      setPowerHint("trx-client connection lost, retrying\u2026");
       setConnLostOverlay(true, "trx-client connection lost", "Retrying\u2026", true);
       source.close();
       void pollFreshSnapshot();
@@ -3901,7 +3905,7 @@ function connect() {
   esHeartbeat = setInterval(() => {
     const now = Date.now();
     if (now - lastEventAt > 15000) {
-      powerHint.textContent = "trx-client connection lost, retrying\u2026";
+      setPowerHint("trx-client connection lost, retrying\u2026");
       setConnLostOverlay(true, "trx-client connection lost", "Retrying\u2026", true);
       source.close();
       void pollFreshSnapshot();
@@ -4023,7 +4027,7 @@ async function switchRigFromSelect(selectEl: HTMLSelectElement) {
   rigSwitchInProgress = true;
   setControlPending(selectEl, true);
   selectEl.closest(".header-rig-switch")?.classList.add("is-switching");
-  updateRigIdentitySummary(nextRig, true);
+  showHint(`Switching to ${lastRigDisplayNames[nextRig] || nextRig}…`);
   showHint(`Switching to ${lastRigDisplayNames[nextRig] || nextRig}…`);
   try {
     const sidParam = sseSessionId ? `&session_id=${encodeURIComponent(sseSessionId)}` : "";
@@ -4031,7 +4035,6 @@ async function switchRigFromSelect(selectEl: HTMLSelectElement) {
     lastActiveRigId = nextRig;
     resetDecoderStateOnRigSwitch();
     updateRigSubtitle(lastActiveRigId);
-    updateRigIdentitySummary(lastActiveRigId);
     window.trxUi?.setActiveRig(lastActiveRigId);
     window.trx.modules.scheduler?.setRig(lastActiveRigId);
     window.trx.modules.backgroundDecode?.setRig(lastActiveRigId);
@@ -4050,7 +4053,6 @@ async function switchRigFromSelect(selectEl: HTMLSelectElement) {
   } catch (err) {
     console.error("select_rig failed:", err);
     selectEl.value = prevRig || "";
-    updateRigIdentitySummary(prevRig);
     window.trxUi?.notify("Rig could not be switched", { kind: "error" });
   } finally {
     rigSwitchInProgress = false;
@@ -4333,6 +4335,39 @@ if (jogMultEl) {
   jogStep = Math.max(Math.round(jogUnit / jogMult), minFreqStepHz);
 }
 
+// The mode buttons are a view of the <select>, which stays the value everything
+// else reads. Rebuilt when the rig's mode list changes, re-synced whenever
+// anything writes to the select — including the plugins, via trxCore.
+const modePickerEl = requiredElement("mode-picker");
+
+function renderModePicker() {
+  modePickerEl.replaceChildren();
+  for (const option of Array.from(modeEl.options)) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.dataset.mode = option.value;
+    btn.textContent = option.textContent;
+    btn.addEventListener("click", () => {
+      if (btn.disabled || modeEl.value === option.value) return;
+      modeEl.value = option.value;
+      syncModePicker();
+      void applyModeFromPicker();
+    });
+    modePickerEl.appendChild(btn);
+  }
+  syncModePicker();
+}
+
+function syncModePicker() {
+  const active = (modeEl.value || "").toUpperCase();
+  modePickerEl.querySelectorAll<HTMLButtonElement>("button").forEach((btn) => {
+    const selected = (btn.dataset.mode || "").toUpperCase() === active;
+    btn.classList.toggle("active", selected);
+    btn.disabled = modeEl.disabled;
+    btn.setAttribute("aria-pressed", String(selected));
+  });
+}
+
 async function applyModeFromPicker() {
   const mode = modeEl.value || "";
   if (!mode) {
@@ -4341,6 +4376,7 @@ async function applyModeFromPicker() {
   }
   updateWfmControls();
   setControlPending(modeEl, true);
+  syncModePicker();
   showHint("Setting mode…");
   try {
     if (await window.trx.modules.vchan?.interceptMode(mode)) {
@@ -4359,6 +4395,7 @@ async function applyModeFromPicker() {
     console.error(err);
   } finally {
     setControlPending(modeEl, false);
+    syncModePicker();
   }
 }
 
@@ -4618,6 +4655,19 @@ function navigateToTab(name: TabName, options: { updateHistory?: boolean; replac
   _activeTab = name;
   document.querySelectorAll(".tab-bar .tab").forEach((t) => t.classList.remove("active"));
   btn.classList.add("active");
+  // A destination the strip hides is reached through Tools, so mark that
+  // button instead — otherwise the strip looks identical on all four of them.
+  // Membership of the Tools menu is the test: it still reads from the grouping
+  // ui-core installs rather than a second copy of it, but unlike the tab's
+  // computed display it does not depend on anything being laid out. The first
+  // route navigation runs while the card is still behind the loading state,
+  // where every tab computes to display:none — which lit Tools up on every
+  // refresh of every page.
+  const toolsBtn = document.getElementById("mobile-more-btn");
+  if (toolsBtn) {
+    const inToolsMenu = !!document.querySelector(`#mobile-more-menu [data-navigate-tab="${name}"]`);
+    toolsBtn.classList.toggle("active", inToolsMenu);
+  }
   window.trxUi?.syncSelectedTab(document.querySelector(".tab-bar-nav"), btn);
   document.querySelectorAll<HTMLElement>(".tab-panel").forEach((p) => p.style.display = "none");
   const panel = document.getElementById(`tab-${name}`);
@@ -4884,7 +4934,7 @@ const trxCore = Object.freeze({
   formatWavelength, formatBwLabel, formatUptime, formatSigStrength, formatSignal,
   postPath, scheduleUiFrameJob, navigateToTab, rigBadgeColor,
   setRigFrequency, applyLocalTunedFrequency, armOptimisticFrequency,
-  syncBandwidthInput, scheduleSpectrumDraw, onDecoderRegistryReady,
+  syncBandwidthInput, scheduleSpectrumDraw, onDecoderRegistryReady, syncModePicker,
   formatFreqForStep, refreshFreqDisplay, setJogDivisor, mwDefaultsForMode,
   resetRdsDisplay, positionRdsPsOverlay, updateWfmControls,
   updateSdrSquelchControlVisibility, startRxAudio, stopRxAudio,
@@ -5095,6 +5145,7 @@ const wfmCciValEl = document.getElementById("wfm-cci-val");
 const wfmAciFillEl = document.getElementById("wfm-aci-fill");
 const wfmAciValEl = document.getElementById("wfm-aci-val");
 const samControlsCol = document.getElementById("sam-controls-col");
+const modeControlsRow = document.getElementById("mode-controls-row");
 const samStereoWidthEl = document.getElementById("sam-stereo-width") as HTMLInputElement | null;
 const samCarrierSyncEl = document.getElementById("sam-carrier-sync") as HTMLSelectElement | null;
 const sdrSquelchWrapEl = document.getElementById("sdr-squelch-wrap");
@@ -5413,6 +5464,9 @@ function updateWfmControls() {
   const mode = (modeEl && modeEl.value ? modeEl.value : "").toUpperCase();
   if (wfmControlsCol) wfmControlsCol.style.display = mode === "WFM" ? "" : "none";
   if (samControlsCol) samControlsCol.style.display = mode === "SAM" ? "" : "none";
+  // The row holds only these two, so it goes with them — an empty one would
+  // still take a track and a gap in the tray, and draw its divider.
+  if (modeControlsRow) modeControlsRow.style.display = (mode === "WFM" || mode === "SAM") ? "" : "none";
 }
 
 // Show compatibility warning for non-Chromium browsers
@@ -6378,7 +6432,12 @@ function connectDecode() {
       }
       if (data.type === "group") {
         const messages = Array.isArray(data.messages)
-          ? data.messages.filter((message): message is DecodeMessage => isRecord(message) && typeof message.type === "string")
+          // Stored records carry only decoder fields — an AIS entry has mmsi,
+          // lat, lon and so on, and no `type`.  That field identifies live SSE
+          // frames; history is already grouped, and the group's kind is
+          // delivered alongside these messages, so requiring it here discarded
+          // every restored record silently.
+          ? data.messages.filter((message): message is DecodeMessage => isRecord(message))
           : [];
         enqueueDecodeHistoryGroup(typeof data.kind === "string" ? data.kind : "", messages);
         return;
@@ -7745,7 +7804,12 @@ function updateBookmarkAxis(range: SpectrumRange) {
   updateSideBookmarkStack(rightSideEl, rightBookmarks, colorMap);
 
   const hasVisible = visBookmarks.length > 0;
-  axisEl.classList.toggle("bm-axis-visible", hasVisible);
+  // The rail is kept up with nothing in range — blank, no caption — so tuning
+  // across bands only swaps its contents rather than taking the strip itself
+  // away. This function only runs with a spectrum range in hand, so rigs
+  // without a spectrum never get it.
+  axisEl.classList.add("bm-axis-visible");
+  axisEl.classList.toggle("bm-axis-empty", !hasVisible);
 
   if (!hasVisible) {
     if (axisEl.dataset.bmKey) { axisEl.replaceChildren(); axisEl.dataset.bmKey = ""; }
@@ -8624,27 +8688,36 @@ function bandplanVisibleSegments(region: string, loHz: number, hiHz: number): Vi
   return result;
 }
 
-function _hideBandplanStrip() {
+// Empties the strip. `reserveSpace` keeps its height: the strip is in flow, so
+// collapsing it on a range with no allocations shifted the whole page down by
+// its height every time tuning crossed out of a band. Space stays reserved
+// whenever a band plan could be drawn at all, and is only given back when the
+// feature is off, has no data, or there is no spectrum to annotate.
+function _clearBandplanStrip(reserveSpace: boolean) {
   if (!bandplanStripEl) return;
-  bandplanStripEl.classList.remove("bp-visible");
-  bandplanStripEl.replaceChildren();
-  bandplanCacheKey = "";
+  if (bandplanCacheKey) {
+    bandplanStripEl.replaceChildren();
+    bandplanCacheKey = "";
+  }
+  bandplanStripEl.classList.toggle("bp-visible", reserveSpace);
+  bandplanStripEl.classList.toggle("bp-empty", reserveSpace);
 }
 
 function updateBandplanStrip(range: SpectrumRange | null) {
   if (!bandplanStripEl) return;
   if (!range || bandplanRegion === "off" || !bandplanData) {
-    if (bandplanStripEl.classList.contains("bp-visible")) _hideBandplanStrip();
+    _clearBandplanStrip(false);
     return;
   }
 
   const segments = bandplanVisibleSegments(bandplanRegion, range.visLoHz, range.visHiHz);
   if (segments.length === 0) {
-    if (bandplanStripEl.classList.contains("bp-visible")) _hideBandplanStrip();
+    _clearBandplanStrip(true);
     return;
   }
 
   bandplanStripEl.classList.add("bp-visible");
+  bandplanStripEl.classList.remove("bp-empty");
 
   const newKey = bandplanRegion + ":" + (bandplanShowLabels ? "L" : "N") + ":" +
     segments.map((s) => s.low_hz + "-" + s.high_hz).join(",");

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/map-core.ts

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 import type * as Leaflet from "leaflet";
+import { aprsSymbolSprite } from "./plugins/aprs-shared";
 
 export {};
 
@@ -1979,33 +1980,36 @@ 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]

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/aprs-shared.ts

@@ -108,8 +108,80 @@ 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}`,
+  };
+}
+
 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>`;

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/bookmarks.ts

@@ -456,6 +456,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;

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/host.ts

@@ -59,6 +59,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;
 }
 

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/vchan.ts

@@ -403,7 +403,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();
+    }
   }
   // When on primary channel, app.js rig-state updates handle the picker.
   const modeUpper = (modeEl.value || "").toUpperCase();

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/ui-core.ts

@@ -195,6 +195,31 @@ function elementById<T extends HTMLElement>(id: string): T {
   const layoutCapabilities: Record<LayoutCapability, boolean> = { broadcast: false, digital: false };
   let activeRigId: string | null = null;
 
+  // A layout seeds the collapsible sections; it does not hold them there.
+  // applyLayout runs on every rig-state refresh, so re-applying the disclosure
+  // state unconditionally would reopen or close sections under the operator
+  // once a second — the reason a section could not be expanded while a layout
+  // that collapses it was selected.  Sections are therefore written only when
+  // the layout actually changes, or the first time each one appears in the DOM
+  // (the advanced controls are built after the first applyLayout call).
+  const layoutSections: { id: string; key: "advanced" | "audio" | "scheduler" }[] = [
+    { id: "advanced-radio-controls", key: "advanced" },
+    { id: "audio-controls", key: "audio" },
+    { id: "scheduler-controls", key: "scheduler" },
+  ];
+  const seededSections = new Set<string>();
+  let appliedLayoutName: LayoutName | null = null;
+
+  function seedLayoutSections(layout: OperatorLayout, layoutChanged: boolean) {
+    layoutSections.forEach(({ id, key }) => {
+      const section = document.getElementById(id) as HTMLDetailsElement | null;
+      if (!section) return;
+      if (!layoutChanged && seededSections.has(id)) return;
+      seededSections.add(id);
+      section.open = layout[key];
+    });
+  }
+
   function layoutStorageKey() {
     return activeRigId ? `trxOperatorLayout:${activeRigId}` : "trxOperatorLayout";
   }
@@ -255,12 +280,9 @@ function elementById<T extends HTMLElement>(id: string): T {
     const layout = layouts[permittedName];
     document.body.dataset.operatorLayout = permittedName in layouts ? permittedName : "compact";
     if (options.persist !== false) localStorage.setItem(layoutStorageKey(), permittedName);
-    const details = document.getElementById("advanced-radio-controls") as HTMLDetailsElement | null;
-    if (details) details.open = layout.advanced;
-    const audioDetails = document.getElementById("audio-controls") as HTMLDetailsElement | null;
-    if (audioDetails) audioDetails.open = layout.audio;
-    const schedulerDetails = document.getElementById("scheduler-controls") as HTMLDetailsElement | null;
-    if (schedulerDetails) schedulerDetails.open = layout.scheduler;
+    const layoutChanged = appliedLayoutName !== permittedName;
+    appliedLayoutName = permittedName;
+    seedLayoutSections(layout, layoutChanged);
     if (options.navigate && typeof browserWindow.navigateToTab === "function") {
       browserWindow.navigateToTab(layout.preferredTab);
     }
@@ -300,6 +322,135 @@ function elementById<T extends HTMLElement>(id: string): T {
     }
   }
 
+  // Secondary controls, in the order they leave the bar when it gets tight.
+  // Audio, record and the rig picker are the operating controls and stay.
+  const overflowOrder = [".operator-layout-picker", ".header-style-pick", "#theme-toggle"];
+
+  // Anchored at paint time in fixed coordinates.  An absolutely positioned
+  // dropdown is clipped by any scrolling ancestor and trapped inside the
+  // stacking context its ancestors create, so it can end up squashed inside
+  // the bar or painted underneath page content.  Fixed positioning answers to
+  // the viewport instead, and the menu flips above its button near the bottom
+  // edge.
+  function anchorMenu(button: HTMLElement, menu: HTMLElement) {
+    const rect = button.getBoundingClientRect();
+    // Reparent to the body.  Fixed positioning escapes clipping but not
+    // stacking: the header sets `z-index: 2`, which makes it a stacking
+    // context, so any z-index the menu carries is confined below every panel
+    // that paints above level 2 — the spectrum overlays reach 9600.  Only
+    // leaving that subtree lets the menu sit above the page.
+    if (menu.parentElement !== document.body) document.body.appendChild(menu);
+    menu.style.position = "fixed";
+    menu.style.zIndex = "9700";
+    menu.style.top = "0px";
+    menu.style.bottom = "auto";
+    // The stylesheet pins these menus to the right of their anchor; leaving
+    // that in place while setting a left would stretch them across the bar.
+    menu.style.right = "auto";
+    const width = menu.offsetWidth || 200;
+    const height = menu.offsetHeight || 0;
+    menu.style.left = `${String(Math.round(Math.min(Math.max(8, rect.right - width), window.innerWidth - width - 8)))}px`;
+    const below = rect.bottom + 8;
+    if (below + height <= window.innerHeight - 8) {
+      menu.style.top = `${String(Math.round(below))}px`;
+    } else {
+      menu.style.top = "auto";
+      menu.style.bottom = `${String(Math.round(window.innerHeight - rect.top + 8))}px`;
+    }
+  }
+
+  function installTopBarOverflow() {
+    const actions = document.querySelector<HTMLElement>(".top-bar-actions");
+    if (!actions || document.getElementById("top-bar-more")) return;
+    const wrap = document.createElement("div");
+    wrap.id = "top-bar-more";
+    wrap.className = "top-bar-more";
+    const button = document.createElement("button");
+    button.type = "button";
+    button.id = "top-bar-more-btn";
+    button.className = "header-bar-btn top-bar-more-btn";
+    button.textContent = "⋯";
+    button.setAttribute("aria-haspopup", "menu");
+    button.setAttribute("aria-expanded", "false");
+    button.setAttribute("aria-label", "More controls");
+    button.title = "More controls";
+    const menu = document.createElement("div");
+    menu.id = "top-bar-more-menu";
+    menu.className = "top-bar-more-menu";
+    menu.setAttribute("role", "menu");
+    button.setAttribute("aria-controls", menu.id);
+    wrap.append(button, menu);
+    actions.appendChild(wrap);
+
+    const closeMenu = () => {
+      menu.classList.remove("is-open");
+      button.setAttribute("aria-expanded", "false");
+    };
+    button.addEventListener("click", () => {
+      const open = menu.classList.toggle("is-open");
+      button.setAttribute("aria-expanded", String(open));
+      if (open) anchorMenu(button, menu);
+    });
+    document.addEventListener("click", (event) => {
+      if (!(event.target instanceof Node)) { closeMenu(); return; }
+      if (!wrap.contains(event.target) && !menu.contains(event.target)) closeMenu();
+    });
+    document.addEventListener("keydown", (event) => { if (event.key === "Escape") closeMenu(); });
+
+    // Measured against the bar, not the actions container: the actions are
+    // sized by their content, so their own scrollWidth never exceeds their
+    // clientWidth.  A viewport-width threshold is not enough either — how much
+    // fits depends on the rig name and the translated labels, so a bar that is
+    // wide enough on one rig clips a control on another.
+    // `bar.scrollWidth > bar.clientWidth` is true even when nothing is clipped,
+    // so it cannot be the test.  What actually matters is that the controls stay
+    // inside the bar and the page tabs are not squeezed into a scroller: seeing
+    // every tab beats keeping the style picker inline.
+    // Compare natural widths against the space available.  Rendered widths
+    // cannot answer this: the nav has min-width 0 and scrolls, so it always
+    // shrinks to the leftover space and always reports "scrolling", while the
+    // bar reports overflow even when nothing is clipped.  scrollWidth on a
+    // scroll container is its unconstrained content width, which is what a fit
+    // test needs.
+    const barFits = () => {
+      const bar = actions.closest<HTMLElement>(".tab-bar");
+      if (!bar) return true;
+      const identity = bar.querySelector<HTMLElement>(".header-main");
+      const nav = bar.querySelector<HTMLElement>(".tab-bar-nav");
+      const gutters = 48;
+      const needed = (identity?.offsetWidth ?? 0) + (nav?.scrollWidth ?? 0) + actions.scrollWidth + gutters;
+      return needed <= bar.clientWidth;
+    };
+    const reflowOverflow = () => {
+      const nav = document.querySelector<HTMLElement>(".tab-bar-nav");
+      // Measure from the roomiest state every time, so the decision is a
+      // function of the current widths alone and cannot ratchet.
+      nav?.classList.remove("nav-icons-only");
+      overflowOrder.forEach((selector) => {
+        const element = menu.querySelector<HTMLElement>(selector);
+        if (element) actions.insertBefore(element, wrap);
+      });
+      wrap.hidden = true;
+      for (const selector of overflowOrder) {
+        if (barFits()) break;
+        const element = actions.querySelector<HTMLElement>(selector);
+        if (!element) continue;
+        wrap.hidden = false;
+        menu.appendChild(element);
+      }
+      // Last resort, once every movable control is already in the menu: drop
+      // the tabs to their icons.  Without it the nav — which may shrink below
+      // its content — keeps its tabs at full width and runs them under the
+      // controls, so the destinations nearest the controls become unclickable.
+      // Icon widths are fixed, so this always buys back the labels' width.
+      if (nav && !barFits()) nav.classList.add("nav-icons-only");
+      wrap.hidden = menu.children.length === 0;
+      if (wrap.hidden) closeMenu();
+    };
+    reflowOverflow();
+    window.addEventListener("resize", reflowOverflow);
+  }
+
   function installMobileMore() {
     const nav = document.querySelector(".tab-bar-nav");
     if (!nav || document.getElementById("mobile-more-btn")) return;
@@ -307,7 +458,8 @@ function elementById<T extends HTMLElement>(id: string): T {
     more.id = "mobile-more-btn";
     more.className = "tab mobile-more-btn";
     more.type = "button";
-    more.innerHTML = '<span class="tab-more-icon" aria-hidden="true">•••</span><span class="tab-label">More</span>';
+    more.innerHTML = '<span class="tab-more-icon" aria-hidden="true">•••</span><span class="tab-label">Tools</span>';
+    more.setAttribute("aria-label", "Tools and settings");
     more.setAttribute("aria-haspopup", "menu");
     more.setAttribute("aria-expanded", "false");
     const menu = document.createElement("div");
@@ -339,7 +491,10 @@ function elementById<T extends HTMLElement>(id: string): T {
     more.addEventListener("click", () => {
       const open = menu.classList.toggle("is-open");
       more.setAttribute("aria-expanded", String(open));
-      if (open) menu.querySelector<HTMLElement>('[role="menuitem"]')?.focus();
+      if (open) {
+        anchorMenu(more, menu);
+        menu.querySelector<HTMLElement>('[role="menuitem"]')?.focus();
+      }
     });
     document.addEventListener("click", (event) => {
       if (!(event.target instanceof Node) || (!menu.contains(event.target) && !more.contains(event.target))) closeMore();
@@ -404,6 +559,7 @@ function elementById<T extends HTMLElement>(id: string): T {
   api.init = function init() {
     ensureLiveRegions();
     installLayoutControls();
+    installTopBarOverflow();
     installMobileMore();
     installDecoderPicker();
     installDecoderBadges();

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/aprs-symbols.test.mjs

@@ -0,0 +1,85 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { readFile } from "node:fs/promises";
+import { bundleEntry } from "./bundle-entry.mjs";
+
+const sharedUrl = new URL("../src/plugins/aprs-shared.ts", import.meta.url);
+const stylePath = new URL("../../assets/web/style.css", import.meta.url);
+
+async function loadShared() {
+  const source = await bundleEntry(sharedUrl, "trxAprsShared");
+  const context = vm.createContext({ Math, String, Number, Array, Date, Set, console });
+  new vm.Script(source).runInContext(context);
+  return context.trxAprsShared;
+}
+
+// The sheets are 16x6 grids of 24px cells covering 0x21..0x7E, so cell index
+// is `code - 0x21`.  Getting this wrong shifts every station to a neighbouring
+// icon, which is invisible in a screenshot but wrong on every packet.
+test("sprite cells are indexed from the first printable symbol code", async () => {
+  const { aprsSymbolSprite } = await loadShared();
+
+  const first = aprsSymbolSprite("/", "!");
+  assert.equal(first.className, "aprs-symbol-primary");
+  assert.equal(first.backgroundPosition, "0px 0px");
+  assert.equal(first.label, "Primary APRS symbol /!");
+  // '>' is 0x3E -> index 29 -> column 13, row 1.
+  assert.equal(aprsSymbolSprite("/", ">").backgroundPosition, "-312px -24px");
+  // '~' is 0x7E -> index 93 -> the last cell of the last row.
+  assert.equal(aprsSymbolSprite("/", "~").backgroundPosition, "-312px -120px");
+});
+
+test("the table identifier selects the primary, alternate, or overlay sheet", async () => {
+  const { aprsSymbolSprite } = await loadShared();
+
+  assert.equal(aprsSymbolSprite("/", "_").className, "aprs-symbol-primary");
+  assert.equal(aprsSymbolSprite("\\", "_").className, "aprs-symbol-alternate");
+
+  // An alphanumeric table identifier is an overlay character drawn on top of
+  // the alternate symbol: overlay cell first, then the symbol cell.
+  const overlaid = aprsSymbolSprite("S", ">");
+  assert.equal(overlaid.className, "aprs-symbol-overlaid");
+  assert.equal(overlaid.backgroundPosition, "-48px -72px, -312px -24px");
+  assert.equal(overlaid.label, "Alternate APRS symbol \\> with overlay S");
+});
+
+test("codes outside the sprite sheets fall back to the raw character", async () => {
+  const { aprsSymbolSprite, renderLocalAprsSymbol } = await loadShared();
+  const escape = (value) => value;
+
+  assert.equal(aprsSymbolSprite("/", " "), null);
+  assert.equal(aprsSymbolSprite("/", ""), null);
+  assert.equal(aprsSymbolSprite("/", "ab"), null);
+  assert.equal(aprsSymbolSprite(null, ">"), null);
+
+  assert.equal(renderLocalAprsSymbol({ symbolTable: "/", symbolCode: " " }, escape),
+    '<span class="aprs-symbol aprs-symbol-local" title="Primary APRS symbol  "> </span>');
+  assert.equal(renderLocalAprsSymbol({}, escape), "");
+});
+
+test("rendered symbols carry a sprite class and an inline cell offset", async () => {
+  const { renderLocalAprsSymbol } = await loadShared();
+  const html = renderLocalAprsSymbol({ symbolTable: "/", symbolCode: ">" }, (value) => value);
+
+  assert.match(html, /class="aprs-symbol aprs-symbol-primary"/);
+  assert.match(html, /style="background-position:-312px -24px"/);
+  assert.match(html, /aria-label="Primary APRS symbol \/>"/);
+  assert.equal(html.includes("http"), false);
+});
+
+// The cell offsets are computed in the bundles, so the sheet URLs and the grid
+// geometry have to stay in lockstep with them here.
+test("the stylesheet serves every sheet locally at the sprite geometry", async () => {
+  const css = await readFile(stylePath, "utf8");
+
+  assert.match(css, /\.aprs-symbol\s*\{[^}]*background-size:\s*384px 144px/);
+  for (const sheet of ["24-0", "24-1", "24-2", "24-0-2x", "24-1-2x", "24-2-2x"]) {
+    assert.ok(css.includes(`url('/vendor/aprs-symbols-${sheet}.png')`), `missing sheet ${sheet}`);
+  }
+  assert.match(css, /\.aprs-symbol-overlaid\s*\{[^}]*aprs-symbols-24-2\.png'\), url\('\/vendor\/aprs-symbols-24-1\.png'\)/);
+});

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/bookmarks.test.mjs

@@ -29,7 +29,7 @@ class ElementFixture {
 // Mirrors the `window.trx` host contract published by app.ts.  The plugin is a
 // separate bundle, so every application service it uses arrives this way.
 function hostFixture(overrides = {}) {
-  const calls = { postPath: [], setRigFrequency: [], armOptimisticFrequency: [], applyLocalTunedFrequency: [], syncBandwidthInput: [], scheduleSpectrumDraw: 0 };
+  const calls = { postPath: [], setRigFrequency: [], armOptimisticFrequency: [], applyLocalTunedFrequency: [], syncBandwidthInput: [], scheduleSpectrumDraw: 0, syncModePicker: 0 };
   const state = {
     authEnabled: false,
     authRole: "control",
@@ -50,6 +50,7 @@ function hostFixture(overrides = {}) {
     armOptimisticFrequency: (hz) => { calls.armOptimisticFrequency.push(hz); },
     syncBandwidthInput: (hz) => { calls.syncBandwidthInput.push(hz); },
     scheduleSpectrumDraw: () => { calls.scheduleSpectrumDraw += 1; },
+    syncModePicker: () => { calls.syncModePicker += 1; },
     onDecoderRegistryReady: () => {},
   };
   return { window: { trx: { state, core, modules: {} }, trxUi: { confirm: async () => true } }, calls };

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/browser-smoke.mjs

@@ -3,167 +3,18 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import http from "node:http";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { chromium } from "playwright-core";
+import { startBrowser, startWebFixture } from "./web-fixture.mjs";
 
-const frontendDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const webDir = path.resolve(frontendDir, "../assets/web");
-const generatedDir = path.join(webDir, "generated");
-const rigItems = ["rig-a", "rig-b"].map((remote) => ({
-  remote,
-  display_name: remote === "rig-a" ? "Primary fixture" : "Secondary fixture",
-  manufacturer: "Smoke",
-  model: "Fixture",
-  supported_modes: ["FM"],
-  tx: false,
-  filter_controls: false,
-  initialized: true,
-  latitude: null,
-  longitude: null,
-}));
-const rigsResponse = { rigs: rigItems, active_remote: "rig-a" };
-const selectedRigs = [];
+// page.evaluate callbacks run in the browser, not in this Node process.
+/* global document, getComputedStyle */
 
-const jsonRoutes = new Map([
-  ["/auth/session", { authenticated: true, role: "control", auth_disabled: true }],
-  ["/decoders", []],
-  ["/rigs", rigsResponse],
-  ["/status", {
-    info: {
-      manufacturer: "Smoke",
-      model: "Fixture",
-      revision: "1",
-      access: { Tcp: { addr: "127.0.0.1:0" } },
-      capabilities: {
-        min_freq_step_hz: 1,
-        supported_bands: [],
-        supported_modes: ["FM"],
-        num_vfos: 1,
-        lock: false,
-        lockable: false,
-        attenuator: false,
-        preamp: false,
-        rit: false,
-        rpt: false,
-        split: false,
-        tx: false,
-        tx_limit: false,
-        vfo_switch: false,
-        filter_controls: false,
-        signal_meter: false,
-      },
-    },
-    status: { freq: { hz: 100_000_000 }, mode: "FM", tx_en: false, vfo: null, tx: null, rx: null, lock: null },
-    band: null,
-    enabled: true,
-    initialized: true,
-    cw_auto: false,
-    cw_wpm: 20,
-    cw_tone_hz: 700,
-    aprs_decode_enabled: false,
-    hf_aprs_decode_enabled: false,
-    cw_decode_enabled: false,
-    ft8_decode_enabled: false,
-    ft4_decode_enabled: false,
-    ft2_decode_enabled: false,
-    wspr_decode_enabled: false,
-    lrpt_decode_enabled: false,
-    wefax_decode_enabled: false,
-    recorder_enabled: false,
-    clients: 1,
-    rigctl_clients: 0,
-    audio_clients: 0,
-    active_remote: "rig-a",
-    remotes: ["rig-a", "rig-b"],
-    show_sdr_gain_control: false,
-    initial_map_zoom: 10,
-    spectrum_coverage_margin_hz: 50_000,
-    spectrum_usable_span_ratio: 0.92,
-    bandplan_enabled: false,
-    bandplan_region: "iaru1",
-    decode_history_retention_min: 1440,
-    server_connected: true,
-  }],
-  ["/bandplan.json", {}],
-  ["/api/recorder/status", []],
-  ["/api/recorder/files", []],
-]);
-
-const contentTypes = new Map([
-  [".css", "text/css; charset=utf-8"],
-  [".html", "text/html; charset=utf-8"],
-  [".js", "application/javascript; charset=utf-8"],
-  [".json", "application/json; charset=utf-8"],
-  [".png", "image/png"],
-  [".woff2", "font/woff2"],
-]);
-
-function assetPath(urlPath) {
-  if (urlPath === "/") return path.join(webDir, "index.html");
-  if (urlPath.startsWith("/vendor/")) return path.join(webDir, urlPath);
-  const generated = path.join(generatedDir, path.basename(urlPath));
-  if (urlPath.endsWith(".js")) return generated;
-  return path.join(webDir, urlPath);
-}
-
-const server = http.createServer(async (request, response) => {
-  const url = new URL(request.url ?? "/", "http://127.0.0.1");
-  if (url.pathname === "/select_rig" && request.method === "POST") {
-    const remote = url.searchParams.get("remote");
-    if (remote) {
-      rigsResponse.active_remote = remote;
-      jsonRoutes.get("/status").active_remote = remote;
-      selectedRigs.push(remote);
-    }
-    response.writeHead(200).end();
-    return;
-  }
-  if (jsonRoutes.has(url.pathname)) {
-    response.writeHead(200, { "content-type": "application/json" });
-    response.end(JSON.stringify(jsonRoutes.get(url.pathname)));
-    return;
-  }
-  if (url.pathname === "/audio") {
-    response.writeHead(404).end();
-    return;
-  }
-  if (["/events", "/decode", "/spectrum", "/meter"].includes(url.pathname)) {
-    response.writeHead(200, {
-      "cache-control": "no-cache",
-      connection: "keep-alive",
-      "content-type": "text/event-stream",
-    });
-    response.write(": browser smoke stream\n\n");
-    return;
-  }
-  try {
-    const file = assetPath(url.pathname);
-    const bytes = await readFile(file);
-    response.writeHead(200, {
-      "content-type": contentTypes.get(path.extname(file)) ?? "application/octet-stream",
-    });
-    response.end(bytes);
-  } catch {
-    response.writeHead(404).end();
-  }
-});
-
-await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-const address = server.address();
-assert(address && typeof address === "object");
-
-const executablePath = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
-  ?? "/usr/bin/chromium";
-const browser = await chromium.launch({ executablePath, headless: true, args: ["--no-sandbox"] });
-const page = await browser.newPage();
-const runtimeErrors = [];
-page.on("pageerror", (error) => runtimeErrors.push(error.stack ?? error.message));
+const fixture = await startWebFixture();
+const { selectedRigs } = fixture;
+const { browser, page, runtimeErrors } = await startBrowser(chromium);
 
 try {
-  await page.goto(`http://127.0.0.1:${address.port}/`, { waitUntil: "domcontentloaded" });
+  await page.goto(`${fixture.origin}/`, { waitUntil: "domcontentloaded" });
   await page.waitForTimeout(500);
   assert.deepEqual(runtimeErrors, []);
   await page.locator("#content").waitFor({ state: "visible" });
@@ -172,6 +23,67 @@ try {
   await page.locator("summary", { hasText: "Audio controls" }).click();
   assert.equal(await page.locator("#rx-audio-btn").count(), 1);
 
+  // Mode is a button group over a hidden <select>, which stays the value a
+  // dozen call sites and several plugins read. The click has to reach it, and
+  // the select must not take part in layout while it does.
+  const modeBefore = await page.evaluate(() => ({
+    buttons: document.querySelectorAll("#mode-picker button").length,
+    value: document.getElementById("mode").value,
+    active: document.querySelector("#mode-picker button.active")?.dataset.mode,
+  }));
+  assert.ok(modeBefore.buttons > 1, `mode picker rendered ${modeBefore.buttons} buttons`);
+  assert.equal(modeBefore.active, modeBefore.value, "mode picker disagrees with the select");
+  const target = await page.evaluate(() => {
+    const other = [...document.querySelectorAll("#mode-picker button")]
+      .find((btn) => btn.dataset.mode !== document.getElementById("mode").value);
+    return other?.dataset.mode;
+  });
+  await page.locator(`#mode-picker button[data-mode="${target}"]`).click();
+  await page.waitForTimeout(200);
+  const modeAfter = await page.evaluate(() => ({
+    value: document.getElementById("mode").value,
+    active: document.querySelector("#mode-picker button.active")?.dataset.mode,
+    selectWidth: Math.round(document.getElementById("mode").getBoundingClientRect().width),
+  }));
+  assert.equal(modeAfter.value, target, `clicking ${target} left the select at ${modeAfter.value}`);
+  assert.equal(modeAfter.active, target, "the clicked mode is not the marked one");
+  assert.ok(modeAfter.selectWidth <= 2, `the hidden select still occupies ${modeAfter.selectWidth}px`);
+
+  // Mode-specific controls live on their own row, which has to leave with them:
+  // an empty one would still take a track and a gap in the tray and draw its
+  // divider under the controls every rig has.
+  const modeRowState = async () => page.evaluate(() => {
+    const row = document.getElementById("mode-controls-row");
+    return { display: getComputedStyle(row).display, height: Math.round(row.getBoundingClientRect().height) };
+  });
+  await page.locator('#mode-picker button[data-mode="WFM"]').click();
+  await page.waitForTimeout(250);
+  const withWfm = await modeRowState();
+  assert.notEqual(withWfm.display, "none", "WFM controls did not bring their row up");
+  assert.ok(withWfm.height > 0, `WFM row has no height (${withWfm.height}px)`);
+  await page.locator('#mode-picker button[data-mode="FM"]').click();
+  await page.waitForTimeout(250);
+  const withoutWfm = await modeRowState();
+  assert.equal(withoutWfm.display, "none", "the mode row stayed behind with nothing in it");
+
+  // Scheduler controls read left to right: step, hand back, then the entry on
+  // air. The separator is drawn by the current-entry block, so it can only sit
+  // in the right place if that block is last.
+  const schedulerRow = await page.evaluate(() => [...document.querySelectorAll(".scheduler-action-row > *")]
+    .map((el) => el.id || [...el.children].map((c) => c.id).join("+")));
+  assert.deepEqual(schedulerRow,
+    ["scheduler-prev-btn+scheduler-next-btn", "scheduler-release-btn", "scheduler-cycle-status"],
+    `scheduler control order is ${JSON.stringify(schedulerRow)}`);
+
+  // The footer status pill colours its dot from data-state, so a hint written
+  // straight to textContent would leave the dot stuck on the previous state.
+  const hint = await page.evaluate(() => {
+    const element = document.getElementById("power-hint");
+    return { state: element.dataset.state, text: element.textContent.trim() };
+  });
+  assert.ok(["ok", "busy", "error"].includes(hint.state), `status pill state is ${hint.state}`);
+  assert.equal(hint.state, "ok", `fixture reports "${hint.text}" but the pill is ${hint.state}`);
+
   const rigPicker = page.locator("#header-rig-switch-select");
   await rigPicker.locator("option").nth(1).waitFor({ state: "attached" });
   await rigPicker.selectOption("rig-b");
@@ -181,10 +93,51 @@ try {
   await page.locator('.tab[data-tab="map"]').click();
   await page.locator("#aprs-map .leaflet-pane").first().waitFor({ state: "attached" });
   assert.equal(new URL(page.url()).pathname, "/map");
+
+  // The selected destination is marked by a box on all four sides, so a rule
+  // that drops one edge (the mobile nav used to lose its bottom border) is a
+  // regression even though the tab still reads as "active".
+  const activeTab = await page.evaluate(() => {
+    const style = getComputedStyle(document.querySelector(".tab-bar-nav .tab.active"));
+    return ["Top", "Right", "Bottom", "Left"].map((side) => ({
+      width: style.getPropertyValue(`border-${side.toLowerCase()}-width`),
+      color: style.getPropertyValue(`border-${side.toLowerCase()}-color`),
+    }));
+  });
+  for (const edge of activeTab) {
+    assert.notEqual(edge.width, "0px", `active tab border: ${JSON.stringify(activeTab)}`);
+    assert.ok(!/rgba\(0, 0, 0, 0\)|transparent/.test(edge.color), `active tab border: ${JSON.stringify(activeTab)}`);
+  }
+
+  // The map is full-bleed: it breaks out of the centred .card column and
+  // reaches both viewport edges, without pushing the page sideways.
+  const stage = await page.evaluate(() => {
+    const rect = document.getElementById("map-stage").getBoundingClientRect();
+    return {
+      left: Math.round(rect.left),
+      right: Math.round(rect.right),
+      viewport: document.documentElement.clientWidth,
+      sideways: document.documentElement.scrollWidth > document.documentElement.clientWidth + 1,
+      gapToFooter: Math.round(document.querySelector(".footer").getBoundingClientRect().top - rect.bottom),
+      pageScrolls: document.documentElement.scrollHeight > document.documentElement.clientHeight + 1,
+    };
+  });
+  assert.equal(stage.left, 0, `map stage starts at ${stage.left}px, not the viewport edge`);
+  assert.equal(stage.right, stage.viewport, `map stage ends at ${stage.right}px, not ${stage.viewport}px`);
+  assert.equal(stage.sideways, false, "full-bleed map makes the page scroll sideways");
+  // ...and fills the column down to the footer. Capping the height at a
+  // fraction of the viewport left a dead band that grew with the window.
+  assert.ok(stage.gapToFooter <= 16,
+    `${stage.gapToFooter}px of dead space between the map and the footer`);
+  assert.equal(stage.pageScrolls, false, "the map grew past the viewport");
+
   await page.locator('.tab[data-tab="main"]').click();
   assert.equal(new URL(page.url()).pathname, "/");
 
-  await page.locator('.tab[data-tab="about"]').click();
+  // About is an occasional destination, so it lives behind More at every
+  // width rather than in the operating tab strip.
+  await page.locator("#mobile-more-btn").click();
+  await page.locator('[data-navigate-tab="about"]').click();
   await page.locator("#tab-about").waitFor({ state: "visible" });
   assert.equal(new URL(page.url()).pathname, "/about");
 
@@ -192,7 +145,102 @@ try {
   await page.locator("#tab-main").waitFor({ state: "visible" });
   assert.equal(new URL(page.url()).pathname, "/");
   assert.deepEqual(runtimeErrors, []);
+
+  // Refreshing or deep-linking must mark the destination, not Tools. The first
+  // route navigation runs while the card is still behind the loading state, so
+  // a test that asked whether the tab was displayed saw "none" for every tab
+  // and lit Tools up on every refresh of every page.
+  for (const [route, tab, toolsLit] of [["/map", "map", false], ["/about", "about", true]]) {
+    await page.goto(`${fixture.origin}${route}`, { waitUntil: "domcontentloaded" });
+    await page.locator(`#tab-${tab}`).waitFor({ state: "visible" });
+    const marked = await page.evaluate(() => ({
+      actives: [...document.querySelectorAll(".tab-bar .tab.active")].map((t) => t.dataset.tab || t.id),
+      tools: document.getElementById("mobile-more-btn").classList.contains("active"),
+    }));
+    assert.ok(marked.actives.includes(tab), `${route} marks ${JSON.stringify(marked.actives)}`);
+    assert.equal(marked.tools, toolsLit, `${route}: Tools active is ${marked.tools}`);
+  }
+  await page.goto(`${fixture.origin}/`, { waitUntil: "domcontentloaded" });
+  await page.locator("#tab-main").waitFor({ state: "visible" });
+  assert.deepEqual(runtimeErrors, []);
+
+  // --- Layout regressions -------------------------------------------------
+  // Every fault below shipped at some point while the rest of this file
+  // passed, because nothing here looked at geometry: a header whose height
+  // tracked the viewport, controls that stretched, a tab strip that ran under
+  // the controls, and a dropdown that opened underneath the spectrum.
+  for (const width of [1440, 1280, 1100, 900]) {
+    await page.setViewportSize({ width, height: 900 });
+    await page.waitForTimeout(250);
+    const header = await page.evaluate(() => {
+      const bar = document.querySelector(".tab-bar");
+      const nav = document.querySelector(".tab-bar-nav");
+      const actions = document.querySelector(".top-bar-actions");
+      const controls = [...actions.children]
+        .filter((el) => !el.hidden && el.getBoundingClientRect().height > 0)
+        .map((el) => Math.round(el.getBoundingClientRect().height));
+      return {
+        barHeight: Math.round(bar.getBoundingClientRect().height),
+        // The tabs, not the strip: with the strip allowed to overflow its box
+        // shrinks while its content paints across the controls, so the
+        // container's own rect never registers the collision.
+        overlap: Math.round(Math.max(...[...nav.querySelectorAll(".tab")]
+          .filter((tab) => tab.offsetParent !== null)
+          .map((tab) => tab.getBoundingClientRect().right))
+          - actions.getBoundingClientRect().left),
+        heights: [...new Set(controls)],
+        pageScrollsSideways: document.documentElement.scrollWidth > document.documentElement.clientWidth + 1,
+      };
+    });
+    assert.ok(header.barHeight <= 96, `header is ${header.barHeight}px at ${width}px; it should stay one row`);
+    assert.ok(header.overlap <= 0, `tab strip overlaps the controls by ${header.overlap}px at ${width}px`);
+    assert.ok(header.heights.length <= 2, `controls have heights ${header.heights.join(", ")} at ${width}px`);
+    assert.equal(header.pageScrollsSideways, false, `page scrolls sideways at ${width}px`);
+  }
+
+  // A dropdown must paint over the page, not inside the header: fixed
+  // positioning escapes clipping but not the header's stacking context.
+  await page.setViewportSize({ width: 1280, height: 900 });
+  await page.waitForTimeout(250);
+  const menu = await page.evaluate(() => {
+    document.getElementById("mobile-more-btn").click();
+    const element = document.getElementById("mobile-more-menu");
+    const rect = element.getBoundingClientRect();
+    const hit = document.elementFromPoint(rect.left + rect.width / 2, rect.top + rect.height / 2);
+    return { width: Math.round(rect.width), height: Math.round(rect.height), onTop: element.contains(hit) };
+  });
+  assert.ok(menu.height > 40 && menu.width > 80, `menu rendered ${menu.width}x${menu.height}`);
+  assert.ok(menu.onTop, "menu is painted underneath the page");
+
+  // Wider text than this machine renders. The checks above passed on macOS
+  // while CI, whose system font is wider, put the tab strip 9px into the
+  // controls: the bar had run out of controls to move into the overflow menu
+  // and the tabs kept their full width anyway. Scaling the bar's own text
+  // reproduces that on any machine. The tabs carry their font size themselves,
+  // so the parent size alone does not cascade to them.
+  await page.addStyleTag({ content: `
+    .tab-bar { font-size: 160%; }
+    .tab-bar .tab, .tab-bar select, .tab-bar button { font-size: 1.52rem; }
+  ` });
+  for (const width of [1440, 1280, 1100]) {
+    await page.setViewportSize({ width, height: 900 });
+    await page.waitForTimeout(250);
+    const crowded = await page.evaluate(() => {
+      const nav = document.querySelector(".tab-bar-nav");
+      const actions = document.querySelector(".top-bar-actions");
+      const tabs = [...nav.querySelectorAll(".tab")].filter((tab) => tab.offsetParent !== null);
+      return {
+        overlap: Math.round(Math.max(...tabs.map((tab) => tab.getBoundingClientRect().right))
+          - actions.getBoundingClientRect().left),
+        iconsOnly: nav.classList.contains("nav-icons-only"),
+      };
+    });
+    assert.ok(crowded.overlap <= 0,
+      `with wider text the tab strip overlaps the controls by ${crowded.overlap}px at ${width}px`);
+    assert.equal(crowded.iconsOnly, true, `the strip kept its labels at ${width}px with no room for them`);
+  }
+
 } finally {
   await browser.close();
-  await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  await fixture.close();
 }

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/bundle-entry.mjs

@@ -4,7 +4,7 @@
 
 import { build } from "esbuild";
 
-export async function bundleEntry(entryUrl) {
+export async function bundleEntry(entryUrl, globalName) {
   const result = await build({
     entryPoints: [entryUrl.pathname],
     bundle: true,
@@ -12,6 +12,7 @@ export async function bundleEntry(entryUrl) {
     platform: "browser",
     target: "es2022",
     write: false,
+    ...(globalName ? { globalName } : {}),
   });
   const output = result.outputFiles[0];
   if (!output) throw new Error(`No bundle output for ${entryUrl.pathname}`);

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/host-fixture.mjs

@@ -57,6 +57,7 @@ export function createHost({ state = {}, core = {}, modules = {} } = {}) {
         setRigFrequency: record("setRigFrequency"),
         syncBandwidthInput: record("syncBandwidthInput"),
         scheduleSpectrumDraw: record("scheduleSpectrumDraw"),
+        syncModePicker: record("syncModePicker"),
         onDecoderRegistryReady: record("onDecoderRegistryReady"),
         ...core,
       },

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/spectrum-layout.mjs

@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Geometry of the spectrum area while tuning. Everything above the spectrum is
+// driven by what happens to be in the visible range — band plan allocations,
+// bookmarks — and the strips that show them used to appear and disappear with
+// it, so tuning across a band edge moved the whole page under the operator's
+// cursor. Nothing else in the suite serves a rig with a spectrum.
+
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+import { startBrowser, startWebFixture } from "./web-fixture.mjs";
+
+/* global document */
+
+const BOOKMARKS = [
+  { id: "b1", name: "40m FT8", freq_hz: 7074000, mode: "DIG", category: "Digital", comment: "", locator: "" },
+  { id: "b2", name: "40m CW", freq_hz: 7030000, mode: "CW", category: "", comment: "", locator: "" },
+];
+const BANDPLAN = {
+  iaru1: {
+    bands: [{
+      name: "40m",
+      low_hz: 7000000,
+      high_hz: 7200000,
+      segments: [
+        { low_hz: 7000000, high_hz: 7040000, mode: "CW", label: "CW" },
+        { low_hz: 7040000, high_hz: 7200000, mode: "All", label: "All modes" },
+      ],
+    }],
+  },
+};
+// 40m has both bookmarks and allocations; 20m has neither.
+const BAND_WITH_CONTENT = 7074000;
+const BAND_WITHOUT_CONTENT = 14074000;
+
+const fixture = await startWebFixture({
+  spectrum: true,
+  bookmarks: BOOKMARKS,
+  bandplan: BANDPLAN,
+  bandplanEnabled: true,
+});
+const { browser, page, runtimeErrors } = await startBrowser(chromium);
+
+function readGeometry() {
+  const top = (selector) => {
+    const el = document.querySelector(selector);
+    return el ? Math.round(el.getBoundingClientRect().top) : null;
+  };
+  const axis = document.getElementById("spectrum-bookmark-axis");
+  const strip = document.getElementById("spectrum-bandplan-strip");
+  return {
+    chips: axis.querySelectorAll(".spectrum-bookmark-chip").length,
+    axisEmpty: axis.classList.contains("bm-axis-empty"),
+    stripReserved: strip.classList.contains("bp-visible"),
+    stripEmpty: strip.classList.contains("bp-empty"),
+    overviewTop: top(".overview-strip"),
+    spectrumTop: top("#spectrum-panel"),
+    controlsTop: top(".controls-row"),
+    footerTop: top(".footer"),
+    docHeight: document.documentElement.scrollHeight,
+  };
+}
+
+const layoutOf = (geometry) => ({
+  overviewTop: geometry.overviewTop,
+  spectrumTop: geometry.spectrumTop,
+  controlsTop: geometry.controlsTop,
+  footerTop: geometry.footerTop,
+  docHeight: geometry.docHeight,
+});
+
+async function tuneTo(hz) {
+  fixture.setCenterHz(hz);
+  await page.waitForTimeout(900);
+  return page.evaluate(readGeometry);
+}
+
+try {
+  await page.setViewportSize({ width: 1600, height: 950 });
+  await page.goto(fixture.origin, { waitUntil: "domcontentloaded" });
+  await page.locator("#content").waitFor({ state: "visible" });
+  await page.locator("#spectrum-panel").waitFor({ state: "visible" });
+  await page.waitForTimeout(1500);
+
+  const populated = await tuneTo(BAND_WITH_CONTENT);
+  assert.equal(populated.chips, BOOKMARKS.length, `expected both bookmarks, saw ${populated.chips}`);
+  assert.equal(populated.axisEmpty, false, "bookmark rail claims to be empty with chips in it");
+  assert.equal(populated.stripReserved, true, "band plan strip is missing on a band with allocations");
+  assert.equal(populated.stripEmpty, false, "band plan strip claims to be empty with segments in it");
+
+  const bare = await tuneTo(BAND_WITHOUT_CONTENT);
+  assert.equal(bare.chips, 0, `expected no bookmarks on ${BAND_WITHOUT_CONTENT}Hz, saw ${bare.chips}`);
+  assert.equal(bare.axisEmpty, true, "bookmark rail should show its placeholder");
+  assert.equal(bare.stripReserved, true, "band plan strip gave its height back");
+  assert.equal(bare.stripEmpty, true, "band plan strip should be marked empty");
+
+  // The point of both placeholders: tuning must not move anything.
+  assert.deepEqual(layoutOf(bare), layoutOf(populated),
+    `tuning off the band moved the page: ${JSON.stringify(populated)} -> ${JSON.stringify(bare)}`);
+
+  const back = await tuneTo(BAND_WITH_CONTENT);
+  assert.equal(back.chips, BOOKMARKS.length, "bookmarks did not come back");
+  assert.deepEqual(layoutOf(back), layoutOf(populated), "tuning back moved the page");
+
+  // The rail covers the top of the overview, so only the chips may take
+  // pointer events — the rest has to fall through to the plot behind it.
+  const hits = await page.evaluate(() => {
+    const chip = document.querySelector("#spectrum-bookmark-axis .spectrum-bookmark-chip");
+    const chipRect = chip.getBoundingClientRect();
+    const axisRect = document.getElementById("spectrum-bookmark-axis").getBoundingClientRect();
+    const onChip = document.elementFromPoint(chipRect.left + chipRect.width / 2, chipRect.top + chipRect.height / 2);
+    const besideChip = document.elementFromPoint(axisRect.right - 30, axisRect.top + 10);
+    return {
+      chip: onChip?.closest(".spectrum-bookmark-chip") ? "chip" : (onChip?.id || onChip?.tagName),
+      besideChip: besideChip?.id || besideChip?.tagName,
+    };
+  });
+  assert.equal(hits.chip, "chip", `chip is not clickable, hit ${hits.chip}`);
+  assert.equal(hits.besideChip, "overview-canvas", `rail swallows events, hit ${hits.besideChip}`);
+
+  assert.deepEqual(runtimeErrors, []);
+} finally {
+  await browser.close();
+  await fixture.close();
+}

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/ui-core.test.mjs

@@ -143,4 +143,31 @@ ui.applyLayout("digital");
 assert.equal(document.body.dataset.operatorLayout, "compact");
 assert.equal(localStorage.getItem("trxOperatorLayout:rig-b"), "compact");
 
+// A layout seeds the collapsible sections but must not hold them there:
+// applyLayout runs on every rig-state refresh, so an operator who expands a
+// section a layout collapses by default had it shut again about once a second.
+const schedulerSection = new Element("details", document);
+schedulerSection.id = "scheduler-controls";
+const audioSection = new Element("details", document);
+audioSection.id = "audio-controls";
+
+ui.setActiveRig("rig-c");
+ui.applyLayout("compact");
+assert.equal(schedulerSection.open, false, "compact seeds the scheduler section closed");
+
+schedulerSection.open = true;             // operator expands it
+ui.applyLayout("compact");                // the next rig-state refresh
+assert.equal(schedulerSection.open, true, "re-applying the same layout leaves sections alone");
+ui.setActiveRig("rig-c");
+assert.equal(schedulerSection.open, true, "a rig-state refresh leaves sections alone");
+
+// Choosing a different layout is an explicit request for its defaults.
+ui.applyLayout("full");
+assert.equal(schedulerSection.open, true, "full seeds the scheduler section open");
+assert.equal(audioSection.open, true, "full seeds the audio section open");
+audioSection.open = false;
+ui.applyLayout("compact");
+assert.equal(audioSection.open, false, "compact seeds the audio section closed");
+assert.equal(schedulerSection.open, false, "switching layout reseeds every section");
+
 console.log("ui-core component tests passed");

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/web-fixture.mjs

@@ -0,0 +1,239 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// The static server the browser tests load the real web assets from. It was
+// inline in browser-smoke.mjs until a second browser test needed a rig with a
+// spectrum: the interesting layout lives in the spectrum area, and none of it
+// could be exercised while the only fixture served a CAT-only rig.
+
+import { readFile } from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const frontendDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const webDir = path.resolve(frontendDir, "../assets/web");
+const generatedDir = path.join(webDir, "generated");
+
+// A realistic decoder registry.  Serving an empty one hid most of the
+// application from this test: the decoder sub-tabs, their panels, the decode
+// toggles and the bookmark decoder checkboxes are all built from it, so with
+// no decoders only three of thirteen sub-tabs existed and none of the decoder
+// UI was ever constructed.
+const DECODER_REGISTRY = [
+  { id: "ft8", label: "FT8", activation: "toggle", active_modes: ["USB"] },
+  { id: "ft4", label: "FT4", activation: "toggle", active_modes: ["USB"] },
+  { id: "ft2", label: "FT2", activation: "toggle", active_modes: ["USB"] },
+  { id: "wspr", label: "WSPR", activation: "toggle", active_modes: ["USB"] },
+  { id: "cw", label: "CW", activation: "toggle", active_modes: ["CW", "CWR"] },
+  { id: "sat", label: "SAT", activation: "toggle", active_modes: ["FM"] },
+  { id: "wefax", label: "WEFAX", activation: "toggle", active_modes: ["USB"] },
+  { id: "ais", label: "AIS", activation: "toggle", active_modes: ["FM"] },
+  { id: "aprs", label: "APRS", activation: "toggle", active_modes: ["FM"] },
+  { id: "hf-aprs", label: "HF APRS", activation: "toggle", active_modes: ["USB"] },
+  { id: "vdes", label: "VDES", activation: "toggle", active_modes: ["FM"] },
+].map((decoder) => ({ ...decoder, background_decode: false, bookmark_selectable: true }));
+
+const CONTENT_TYPES = new Map([
+  [".css", "text/css; charset=utf-8"],
+  [".html", "text/html; charset=utf-8"],
+  [".js", "application/javascript; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".png", "image/png"],
+  [".woff2", "font/woff2"],
+]);
+
+function assetPath(urlPath) {
+  // Every tab route has its own index handler on the server (see api/assets.rs),
+  // so a deep link or a refresh serves the SPA shell, not a 404.
+  if (!path.extname(urlPath)) return path.join(webDir, "index.html");
+  if (urlPath.startsWith("/vendor/")) return path.join(webDir, urlPath);
+  const generated = path.join(generatedDir, path.basename(urlPath));
+  if (urlPath.endsWith(".js")) return generated;
+  return path.join(webDir, urlPath);
+}
+
+/**
+ * Starts the fixture server.
+ *
+ * `spectrum` turns the rig into an SDR: `filter_controls` is what gates the
+ * spectrum panel, and frames are pushed on the /spectrum stream from a centre
+ * frequency the test moves with `setCenterHz` to simulate tuning across bands.
+ */
+export async function startWebFixture({
+  spectrum = false,
+  tx = false,
+  bookmarks = [],
+  bandplan = {},
+  bandplanEnabled = false,
+} = {}) {
+  const rigItems = ["rig-a", "rig-b"].map((remote) => ({
+    remote,
+    display_name: remote === "rig-a" ? "Primary fixture" : "Secondary fixture",
+    manufacturer: "Smoke",
+    model: "Fixture",
+    supported_modes: ["FM"],
+    tx,
+    filter_controls: spectrum,
+    initialized: true,
+    latitude: null,
+    longitude: null,
+  }));
+  const rigsResponse = { rigs: rigItems, active_remote: "rig-a" };
+  const selectedRigs = [];
+  const state = { centerHz: 7074000 };
+
+  const status = {
+    info: {
+      manufacturer: "Smoke",
+      model: "Fixture",
+      revision: "1",
+      access: { Tcp: { addr: "127.0.0.1:0" } },
+      capabilities: {
+        min_freq_step_hz: 1,
+        supported_bands: [],
+        supported_modes: ["LSB", "USB", "CW", "CWR", "AM", "SAM", "WFM", "FM", "AIS", "VDES", "DIG", "PKT"],
+        num_vfos: 1,
+        lock: false,
+        lockable: tx,
+        attenuator: false,
+        preamp: false,
+        rit: false,
+        rpt: false,
+        split: false,
+        tx,
+        tx_limit: tx,
+        vfo_switch: false,
+        filter_controls: spectrum,
+        signal_meter: spectrum,
+      },
+    },
+    status: { freq: { hz: 100_000_000 }, mode: "FM", tx_en: false, vfo: null, tx: null, rx: null, lock: null },
+    band: null,
+    enabled: true,
+    initialized: true,
+    cw_auto: false,
+    cw_wpm: 20,
+    cw_tone_hz: 700,
+    aprs_decode_enabled: false,
+    hf_aprs_decode_enabled: false,
+    cw_decode_enabled: false,
+    ft8_decode_enabled: false,
+    ft4_decode_enabled: false,
+    ft2_decode_enabled: false,
+    wspr_decode_enabled: false,
+    lrpt_decode_enabled: false,
+    wefax_decode_enabled: false,
+    recorder_enabled: false,
+    clients: 1,
+    rigctl_clients: 0,
+    audio_clients: 0,
+    active_remote: "rig-a",
+    remotes: ["rig-a", "rig-b"],
+    show_sdr_gain_control: false,
+    initial_map_zoom: 10,
+    spectrum_coverage_margin_hz: 50_000,
+    spectrum_usable_span_ratio: 0.92,
+    bandplan_enabled: bandplanEnabled,
+    bandplan_region: "iaru1",
+    decode_history_retention_min: 1440,
+    server_connected: true,
+  };
+
+  const jsonRoutes = new Map([
+    ["/auth/session", { authenticated: true, role: "control", auth_disabled: true }],
+    ["/decoders", DECODER_REGISTRY],
+    ["/rigs", rigsResponse],
+    ["/status", status],
+    ["/bookmarks", bookmarks],
+    ["/bandplan.json", bandplan],
+    ["/api/recorder/status", []],
+    ["/api/recorder/files", []],
+  ]);
+
+  // Flat i8 bins: the shape does not matter, only that frames arrive so the
+  // page has a spectrum range to place bookmarks and allocations against.
+  const spectrumBins = Buffer.alloc(512, 200);
+  const spectrumB64 = spectrumBins.toString("base64");
+
+  const server = http.createServer(async (request, response) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (url.pathname === "/select_rig" && request.method === "POST") {
+      const remote = url.searchParams.get("remote");
+      if (remote) {
+        rigsResponse.active_remote = remote;
+        status.active_remote = remote;
+        selectedRigs.push(remote);
+      }
+      response.writeHead(200).end();
+      return;
+    }
+    if (jsonRoutes.has(url.pathname)) {
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify(jsonRoutes.get(url.pathname)));
+      return;
+    }
+    if (url.pathname === "/audio") {
+      response.writeHead(404).end();
+      return;
+    }
+    if (spectrum && url.pathname === "/spectrum") {
+      response.writeHead(200, {
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+        "content-type": "text/event-stream",
+      });
+      const timer = setInterval(() => {
+        response.write(`event: b\ndata: ${state.centerHz},192000,${spectrumB64}\n\n`);
+      }, 100);
+      request.on("close", () => clearInterval(timer));
+      return;
+    }
+    if (["/events", "/decode", "/spectrum", "/meter"].includes(url.pathname)) {
+      response.writeHead(200, {
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+        "content-type": "text/event-stream",
+      });
+      response.write(": browser smoke stream\n\n");
+      return;
+    }
+    try {
+      const file = assetPath(url.pathname);
+      const bytes = await readFile(file);
+      response.writeHead(200, {
+        "content-type": CONTENT_TYPES.get(path.extname(file)) ?? "application/octet-stream",
+      });
+      response.end(bytes);
+    } catch {
+      response.writeHead(404).end();
+    }
+  });
+
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  if (!address || typeof address !== "object") throw new Error("fixture server has no port");
+
+  return {
+    origin: `http://127.0.0.1:${address.port}`,
+    selectedRigs,
+    rigsResponse,
+    /** Moves the spectrum centre, i.e. tunes the fixture rig to another band. */
+    setCenterHz(hz) { state.centerHz = hz; },
+    close() {
+      return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+    },
+  };
+}
+
+/** Launches headless Chromium and records any uncaught page error. */
+export async function startBrowser(chromium) {
+  const executablePath = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
+    ?? "/usr/bin/chromium";
+  const browser = await chromium.launch({ executablePath, headless: true, args: ["--no-sandbox"] });
+  const page = await browser.newPage();
+  const runtimeErrors = [];
+  page.on("pageerror", (error) => runtimeErrors.push(error.stack ?? error.message));
+  return { browser, page, runtimeErrors };
+}

src/trx-client/trx-frontend/trx-frontend-http/src/api/assets.rs

@@ -95,6 +95,18 @@ pub(crate) async fn about_index(req: HttpRequest) -> impl Responder {
     static_asset_response(&req, "text/html; charset=utf-8", c)
 }
 
+#[get("/statistics")]
+pub(crate) async fn statistics_index(req: HttpRequest) -> impl Responder {
+    let c = gz_index_html();
+    static_asset_response(&req, "text/html; charset=utf-8", c)
+}
+
+#[get("/bookmarks")]
+pub(crate) async fn bookmarks_index(req: HttpRequest) -> impl Responder {
+    let c = gz_index_html();
+    static_asset_response(&req, "text/html; charset=utf-8", c)
+}
+
 // ---------------------------------------------------------------------------
 // Favicon & logo
 // ---------------------------------------------------------------------------
@@ -267,6 +279,47 @@ pub(crate) async fn leaflet_layers_2x() -> impl Responder {
         .body(status::LEAFLET_LAYERS_2X)
 }
 
+// ---------------------------------------------------------------------------
+// Vendored APRS symbol sprites
+// ---------------------------------------------------------------------------
+
+fn embedded_png(bytes: &'static [u8]) -> HttpResponse {
+    HttpResponse::Ok()
+        .insert_header((header::CONTENT_TYPE, "image/png"))
+        .insert_header((header::CACHE_CONTROL, "public, max-age=604800, immutable"))
+        .body(bytes)
+}
+
+#[get("/vendor/aprs-symbols-24-0.png")]
+pub(crate) async fn aprs_symbols_primary() -> impl Responder {
+    embedded_png(status::APRS_SYMBOLS_PRIMARY)
+}
+
+#[get("/vendor/aprs-symbols-24-0-2x.png")]
+pub(crate) async fn aprs_symbols_primary_2x() -> impl Responder {
+    embedded_png(status::APRS_SYMBOLS_PRIMARY_2X)
+}
+
+#[get("/vendor/aprs-symbols-24-1.png")]
+pub(crate) async fn aprs_symbols_alternate() -> impl Responder {
+    embedded_png(status::APRS_SYMBOLS_ALTERNATE)
+}
+
+#[get("/vendor/aprs-symbols-24-1-2x.png")]
+pub(crate) async fn aprs_symbols_alternate_2x() -> impl Responder {
+    embedded_png(status::APRS_SYMBOLS_ALTERNATE_2X)
+}
+
+#[get("/vendor/aprs-symbols-24-2.png")]
+pub(crate) async fn aprs_symbols_overlay() -> impl Responder {
+    embedded_png(status::APRS_SYMBOLS_OVERLAY)
+}
+
+#[get("/vendor/aprs-symbols-24-2-2x.png")]
+pub(crate) async fn aprs_symbols_overlay_2x() -> impl Responder {
+    embedded_png(status::APRS_SYMBOLS_OVERLAY_2X)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -295,4 +348,41 @@ mod tests {
         );
         assert_eq!(generated_content_type("secret.txt"), None);
     }
+
+    /// Reads the width and height out of a PNG IHDR chunk.
+    fn png_dimensions(bytes: &[u8]) -> (u32, u32) {
+        assert_eq!(&bytes[..8], b"\x89PNG\r\n\x1a\n", "not a PNG");
+        assert_eq!(&bytes[12..16], b"IHDR", "first chunk is not IHDR");
+        let width = u32::from_be_bytes(bytes[16..20].try_into().expect("IHDR width"));
+        let height = u32::from_be_bytes(bytes[20..24].try_into().expect("IHDR height"));
+        (width, height)
+    }
+
+    /// The browser computes sprite cell offsets from a 16x6 grid of 24px cells,
+    /// so a sheet at any other size would silently shift every APRS symbol.
+    #[test]
+    fn aprs_symbol_sheets_match_the_sprite_grid_the_frontend_assumes() {
+        for (name, bytes) in [
+            ("aprs-symbols-24-0", status::APRS_SYMBOLS_PRIMARY),
+            ("aprs-symbols-24-1", status::APRS_SYMBOLS_ALTERNATE),
+            ("aprs-symbols-24-2", status::APRS_SYMBOLS_OVERLAY),
+        ] {
+            assert_eq!(
+                png_dimensions(bytes),
+                (384, 144),
+                "{name} is not a 16x6 grid"
+            );
+        }
+        for (name, bytes) in [
+            ("aprs-symbols-24-0-2x", status::APRS_SYMBOLS_PRIMARY_2X),
+            ("aprs-symbols-24-1-2x", status::APRS_SYMBOLS_ALTERNATE_2X),
+            ("aprs-symbols-24-2-2x", status::APRS_SYMBOLS_OVERLAY_2X),
+        ] {
+            assert_eq!(
+                png_dimensions(bytes),
+                (768, 288),
+                "{name} is not a 2x sheet"
+            );
+        }
+    }
 }

src/trx-client/trx-frontend/trx-frontend-http/src/api/mod.rs

@@ -637,6 +637,8 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
         .service(assets::recorder_index)
         .service(assets::settings_index)
         .service(assets::about_index)
+        .service(assets::statistics_index)
+        .service(assets::bookmarks_index)
         .service(assets::favicon)
         .service(assets::favicon_png)
         .service(assets::logo)
@@ -656,6 +658,13 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
         .service(assets::leaflet_marker_shadow)
         .service(assets::leaflet_layers)
         .service(assets::leaflet_layers_2x)
+        // Vendored APRS symbol sprites
+        .service(assets::aprs_symbols_primary)
+        .service(assets::aprs_symbols_primary_2x)
+        .service(assets::aprs_symbols_alternate)
+        .service(assets::aprs_symbols_alternate_2x)
+        .service(assets::aprs_symbols_overlay)
+        .service(assets::aprs_symbols_overlay_2x)
         .service(assets::generated_asset)
         // Virtual channels
         .service(vchan::list_channels)

src/trx-client/trx-frontend/trx-frontend-http/src/status.rs

@@ -37,6 +37,23 @@ pub const LEAFLET_MARKER_SHADOW: &[u8] = include_bytes!("../assets/web/vendor/ma
 pub const LEAFLET_LAYERS: &[u8] = include_bytes!("../assets/web/vendor/layers.png");
 pub const LEAFLET_LAYERS_2X: &[u8] = include_bytes!("../assets/web/vendor/layers-2x.png");
 
+// Vendored APRS symbol sprites (https://github.com/hessu/aprs-symbols).
+// Each sheet is a 16x6 grid of 24px cells indexed by `symbol code - 0x21`:
+// table 0 is the primary ('/') set, table 1 the alternate ('\') set, and
+// table 2 the overlay characters drawn on top of an alternate symbol.
+pub const APRS_SYMBOLS_PRIMARY: &[u8] =
+    include_bytes!("../assets/web/vendor/aprs-symbols-24-0.png");
+pub const APRS_SYMBOLS_PRIMARY_2X: &[u8] =
+    include_bytes!("../assets/web/vendor/aprs-symbols-24-0-2x.png");
+pub const APRS_SYMBOLS_ALTERNATE: &[u8] =
+    include_bytes!("../assets/web/vendor/aprs-symbols-24-1.png");
+pub const APRS_SYMBOLS_ALTERNATE_2X: &[u8] =
+    include_bytes!("../assets/web/vendor/aprs-symbols-24-1-2x.png");
+pub const APRS_SYMBOLS_OVERLAY: &[u8] =
+    include_bytes!("../assets/web/vendor/aprs-symbols-24-2.png");
+pub const APRS_SYMBOLS_OVERLAY_2X: &[u8] =
+    include_bytes!("../assets/web/vendor/aprs-symbols-24-2-2x.png");
+
 /// Build version tag used for cache-busting asset URLs and ETag headers.
 /// Computed once from `PKG_VERSION` + `CLIENT_BUILD_DATE`.
 pub fn build_version_tag() -> &'static str {