[fix](trx-frontend-http): tidy up the map's filter bar

The bar explained itself in prose: "All bands visible by default" sat
between the chips and the next group, taking width the bar could not
spare and reading as a stray line of text. An "All" chip says the same
thing in a chip's width and gives the selection somewhere to be undone.

Band chips also came up dimmed at the very moment every band was on the
map -- an empty selection is no filter at all, so nothing is dimmed
until something is picked. The path toggles drop their "On"/"Off"
suffix, which cost most of a row and only repeated what their own
highlight already said; state moves to aria-pressed and the tooltip.

The rest is alignment. The rule dividing the buttons from the filters
is drawn on the button block's edge, and a centred block left it
floating as a stub beside a two-row bar; stacked, it lay down the left
of a block that sits underneath. The labels sat at their natural
widths, so each row's first control started somewhere different, and
the two pairs of phase buttons differed in width, so the groups after
them missed each other by four pixels. One gutter for every label, one
width for both pairs, and the search field moved last where it can take
the room the fixed-width groups leave.

The map layout test now covers the chips, the divider's height and the
rows' shared start.

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/).
+# CI for the Docker-executor runner (VM). The lint, test and frontend jobs run
-# The runner image bakes in the Rust toolchain and all build dependencies,
+# inside the shared trx-rs SDK image (container/Containerfile), which bakes in
-# so jobs go straight to cargo — no apt/rustup setup steps (which also
+# the pinned Rust toolchain, Node.js, Chromium and all build dependencies. The
-# collided on the dpkg lock when jobs ran concurrently in the same runner).
+# reuse job uses the upstream Docker action, which the Docker executor launches
+# as a sibling container.
 
 name: CI
 
@@ -16,33 +17,56 @@ 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
     steps:
       - uses: actions/checkout@v4
+      - name: Cache npm downloads
+        uses: actions/cache@v4
+        with:
+          path: ~/.npm
+          key: npm-${{ runner.os }}-${{ hashFiles('src/trx-client/trx-frontend/trx-frontend-http/frontend/package-lock.json') }}
+          restore-keys: |
+            npm-${{ runner.os }}-
       - name: Install locked frontend dependencies
         run: npm ci
       - name: Type-check
@@ -51,6 +75,10 @@ jobs:
         run: npm run lint
       - name: Test
         run: npm test
+      # 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
 
@@ -58,8 +86,4 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: REUSE compliance
+      - uses: fsfe/reuse-action@v5
-        # `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

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,13 +12,19 @@ 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",
     "src/trx-client/trx-frontend/trx-frontend-http/assets/trx-favicon.png",
     "src/trx-client/trx-frontend/trx-frontend-http/assets/trx-logo.png",
     "src/trx-client/trx-frontend/trx-frontend-http/assets/web/bandplan.json",
-    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/leaflet-ais-tracksymbol.js",
+    "src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/**",
+    "src/trx-client/trx-frontend/trx-frontend-http/frontend/package.json",
+    "src/trx-client/trx-frontend/trx-frontend-http/frontend/package-lock.json",
+    "src/trx-client/trx-frontend/trx-frontend-http/frontend/tsconfig.json",
+    "src/trx-client/trx-frontend/trx-frontend-http/frontend/tsconfig.worker.json",
 ]
 SPDX-FileCopyrightText = "2026 Stan Grams <sjg@haxx.space>"
 SPDX-License-Identifier = "GPL-2.0-or-later"
@@ -50,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
+# Single source of truth for the build environment. Used two ways:
-# actions/checkout and actions/cache) and the `reuse` tool are baked in, so CI
+#   * CI  — as the job container for the lint/test jobs (Docker executor).
-# runs skip the per-run apt/rustup install cost. `sudo` is present so the
+#   * Dev — run locally or via .devcontainer for a reproducible toolchain.
-# existing workflow's `sudo apt-get ...` / rustup steps remain valid — they
+#
-# just become fast no-ops because everything is already installed.
+# 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 \
+    RUSTUP_HOME=/usr/local/rustup \
-    CARGO_HOME=/opt/cargo \
+    CARGO_HOME=/usr/local/cargo \
-    PATH=/opt/cargo/bin:/usr/local/bin:/usr/bin:/bin
+    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 \
+        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).
+# Pinned Rust toolchain, installed world-readable so any UID the runner or a
-# The [charset-normalizer] extra provides an encoding-detection backend;
+# devcontainer uses can invoke cargo.
-# 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.
 RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \
-        | sh -s -- -y --no-modify-path --profile minimal \
+      | sh -s -- -y --no-modify-path \
+        --default-toolchain "${RUST_VERSION}" --profile minimal \
         --component rustfmt --component clippy \
-    && chmod -R a+rwX "$CARGO_HOME" "$RUSTUP_HOME"
+    && chmod -R a+rwX "$RUSTUP_HOME" "$CARGO_HOME"
 
-# act_runner binary.
+# sccache — shared compilation cache. Enabled at build time via
-RUN arch="$(dpkg --print-architecture)"; \
+# RUSTC_WRAPPER (see the CI workflow and .devcontainer), not repo-wide, so
-    case "$arch" in amd64) rarch=amd64;; arm64) rarch=arm64;; *) echo "unsupported arch $arch" >&2; exit 1;; esac; \
+# non-SDK builds are unaffected. musl build is static and runs anywhere.
-    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}" \
+# The release asset is per-architecture, so resolve it from `uname -m` rather
-    && chmod +x /usr/local/bin/act_runner
+# 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).
+WORKDIR /work
-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"]

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
+A single container image that is the canonical build environment for trx-rs,
-containers managed by systemd (Quadlet) — one per project — instead of two
+used **both** by CI and by developers. It bakes in the pinned Rust toolchain
-VMs. Uses the **host executor**: workflow steps run directly inside a
+(matching `rust-toolchain.toml`) and every build dependency, so the compiler
-purpose-built runner image that already has the Rust toolchain and all build
+and `clippy` are identical everywhere — no "works on my machine".
-dependencies baked in, so CI runs skip the per-run install cost and no
-Docker/Podman socket is needed.
-
-## Files
 
 | File | Purpose |
 |------|---------|
-| `Containerfile` | Runner image: Debian + build deps + clang + Rust + Node + `reuse` + `act_runner`. |
+| `Containerfile` | The SDK image (Debian + build deps + pinned Rust + Node + git). |
-| `entrypoint.sh` | Registers on first boot (if needed), then runs the daemon. |
+| `runner-config.example.yaml` | Example act_runner config for the CI VM (Docker executor). |
-| `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. |
 
-## Prerequisites (once per host)
+## Build and publish
 
-Rootless Podman with cgroups v2 (default on modern distros). As the unprivileged
+Nothing in the image is architecture-specific: the base image, the Debian build
-user that will own the runners:
+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.
+# from the repo root
-loginctl enable-linger "$USER"
+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.
+**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 —
-## 1. Build the image
+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
+# on an x86_64 host
-podman build -t trx-rs-ci:latest .
+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
+Tag with the Rust version too (e.g. `:1.97.1`) if you want reproducible pins.
-the token. (Org- or instance-level tokens work too if you prefer wider scope.)
+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
+docker pull git.haxx.space/sjg/trx-rs/sdk:latest
-cp trx-rs-runner.container project2-runner.container ~/.config/containers/systemd/
+docker run --rm git.haxx.space/sjg/trx-rs/sdk:latest sccache --version
-
-# 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
 ```
 
-Once each runner shows **online** in the repo's runner list, blank out the
+### macOS note
-`GITEA_RUNNER_REGISTRATION_TOKEN` line again (the registration is persisted in
-the `…-data` volume) and `systemctl --user daemon-reload`.
 
-## 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
+## Developer use
-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:
 
-```yaml
+Reproducible one-off build, no local toolchain needed:
-  reuse:
+
-    runs-on: ubuntu-latest
+```bash
-    steps:
+podman run --rm -it -v "$PWD":/work -w /work \
-      - uses: actions/checkout@v4
+  git.haxx.space/sjg/trx-rs/sdk:latest \
-      - name: REUSE compliance
+  cargo build --release
-        run: reuse lint
 ```
 
-The `lint` and `test` jobs need no changes: their `sudo apt-get …` and rustup
+Or open the repo in the image via VS Code / JetBrains "Reopen in Container"
-steps still run, but become fast no-ops because the image already has those
+(`.devcontainer/devcontainer.json` points at the same image).
-packages and the toolchain. (`sudo` is included in the image for exactly this
-reason.)
 
-> If you would rather keep Docker-based actions and per-run images, use the
+Building outside the container? `rust-toolchain.toml` pins the same rustc, so
-> **Docker executor** instead: drop the `:host` suffix from the label in
+`rustup` installs the matching toolchain automatically.
-> `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.
 
-## Tuning
+## CI use
 
-- **`capacity`** (in `config.yaml`) — concurrent jobs per runner. Rust builds
+`.gitea/workflows/ci.yml` runs the `lint`, `test` and `frontend` jobs *inside*
-  are heavy; 1–2 is sensible when two runners share a host.
+this image via the `container:` key, so they skip all setup and go straight to
-- **`PodmanArgs=--cpus/--memory`** (in each `.container`) — hard resource caps
+`cargo` and `npm`. The frontend job needs three things from the image beyond
-  so one project cannot starve the other.
+Rust: Node.js for the toolchain, Chromium at `/usr/bin/chromium` for the
-- **SELinux** — the `:Z` volume flag is already set; keep it if SELinux is
+browser smoke test, and `cargo` — `npm run verify-generated` regenerates the
-  enforcing.
+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
+## Compilation cache (sccache)
-`REUSE.toml` (the other files carry inline SPDX headers):
 
-```toml
+The SDK image ships [`sccache`](https://github.com/mozilla/sccache). It is
-[[annotations]]
+enabled via `RUSTC_WRAPPER=sccache` in CI and the devcontainer (not repo-wide,
-path = ["container/**"]
+so plain `cargo` builds outside the SDK are unaffected).
-SPDX-FileCopyrightText = "2026 Stan Grams <sjg@haxx.space>"
+
-SPDX-License-Identifier = "GPL-2.0-or-later"
+- **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

docs/frontend-architecture.md

@@ -0,0 +1,87 @@
+<!--
+SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+
+SPDX-License-Identifier: GPL-2.0-or-later
+-->
+
+# Frontend architecture
+
+The HTTP frontend is a strict TypeScript application built with esbuild. Rust
+embeds deterministic JavaScript output from `assets/web/generated`; Cargo does
+not run Node.js or contact the network.
+
+## Runtime graph
+
+`frontend/src/bootstrap.ts` is the only first-party script referenced by the
+HTML document. Its imports establish startup order for WebGL support, shared UI
+services, decoder dispatch, the local Leaflet AIS adapter, and the application
+coordinator. Leaflet and the Opus decoder remain isolated vendored scripts.
+
+Feature entries under `frontend/src/plugins` are ESM bundles. The typed plugin
+loader imports them by feature group and keeps expensive map, scheduling, and
+decoder behavior lazy. Shared code is emitted as content-hashed chunks. The
+decode-history worker is an independent entry compiled against Web Worker
+globals.
+
+Dependencies point from application and feature code toward `core` and `api`.
+`api/generated.ts` contains Rust wire formats; `api/client.ts` and focused
+parsers validate untrusted HTTP, SSE, WebSocket, and worker data before it is
+used as typed application state.
+
+## Browser host contract
+
+Separate lazy bundles cannot share module instances with the stable application
+entry, so they use three intentional host namespaces:
+
+| Global | Purpose | Mutation policy |
+| --- | --- | --- |
+| `window.trx` | Application state, core services, and feature registrations | The root is frozen; lazy features may register only their documented `modules.*` service. |
+| `window.trxPluginRuntime` | Typed decoder registration and message dispatch | Runtime object is installed once; plugins register lifecycle handlers through its API. |
+| `window.trxUi` | Notifications, confirmations, tab accessibility, and control presentation | Installed once by `ui-core.ts`; consumers call methods but do not replace them. |
+
+`frontend/src/plugins/host.ts` declares the typed view of `window.trx.state`
+and `window.trx.core` that feature bundles consume. Feature entries import it
+instead of re-deriving the contract, so a service that moves out of the
+application entry is added in one place. Application state that a feature needs
+belongs in `trx.state`, and shared behavior belongs in `trx.core`; a feature
+that has to intercept application behavior registers a `modules.*` method the
+application calls, as the virtual-channel entry does for tuning, mode,
+bandwidth, and frequency display.
+
+The WebGL adapter exposes `createTrxWebGlRenderer`, `trxParseCssColor`,
+`trxHslToRgba`, and `trxClearCssColorCache` for the application bundle. Leaflet
+adds `L.TrxAisTrackSymbol` and `L.trxAisTrackSymbol` to the vendored Leaflet
+namespace.
+
+The following transitional properties are explicitly part of the lazy-feature
+host contract and are declared in `app.ts`: `lastSpectrumData`, `lastFreqHz`,
+`currentBandwidthHz`, `ft8BaseHz`, `getDecodeHistoryRetentionMs`,
+`applyDecodeHistoryRetention`, `getDecodeRigMeta`, `renderRdsOverlays`,
+`buildAisVesselUrl`, `trxScheduleUiFrameJob`,
+`takeSchedulerControlForDecoderDisable`, `navigateToTab`, `_syncRecorderState`,
+and `refreshRdsUi`. Optional callbacks owned by lazy features are
+`refreshCwTonePicker`, `updateFt8RfDisplay`, `clearSatPredictionDom`,
+`syncWefaxToggle`, `updateAisBar`, `updateVdesBar`, `updateAprsBar`,
+`updateFt8Bar`, `updateSatLiveState`, `applyCwAutoUi`, and
+`applyCwAutoUiFromServer`.
+
+This list is closed: new standalone mutable `window` properties are not an
+accepted integration mechanism. Extend an existing typed service or introduce
+an imported interface instead. Removing transitional properties as feature
+boundaries become directly importable remains preferable.
+
+## Build and verification
+
+The generated directory is removed before every build, preventing orphaned
+compatibility bundles. Stable feature entry names are allowlisted by the Rust
+asset manifest; shared chunks use content hashes. The generic Rust handler
+rejects unknown names and unsupported MIME types and serves embedded assets
+with compression, ETags, and immutable caching.
+
+CI installs from `package-lock.json`, caches only npm downloads, type-checks the
+window and worker environments separately, lints, runs unit and DOM tests,
+starts the application in Chromium, regenerates Rust contracts and bundles,
+checks for drift, and runs REUSE validation after generation.
+
+See `frontend/src/README.md` for local commands and
+`docs/ts-migration-plan.md` for the migration decisions and completion gates.

docs/frontend_improvements.md

@@ -7,7 +7,11 @@ trx-rs web frontend (`trx-frontend-http`). The frontend is a single-page
 application served as embedded static assets (gzip-compressed with ETag
 caching) from the Actix-Web server.
 
-## Current asset inventory
+## Historical asset inventory
+
+This inventory records the frontend before the TypeScript migration. The
+first-party JavaScript copies listed here have since been replaced by strict
+TypeScript source and deterministic output under `assets/web/generated`.
 
 | File | Lines | Size |
 |------|------:|-----:|

docs/ts-migration-plan.md

@@ -8,7 +8,44 @@ SPDX-License-Identifier: GPL-2.0-or-later
 
 > **Scope**: `src/trx-client/trx-frontend/trx-frontend-http/`
 >
-> **Status**: Proposed
+> **Status**: Complete (2026-08-01)
+
+## Implementation result
+
+The migration was completed on `feat/typescript-frontend-migration`. The
+baseline and phased sections below are retained as the decision record; their
+descriptions of JavaScript files and classic loading refer to the pre-migration
+state.
+
+Completion evidence:
+
+- all first-party browser sources are strict `.ts` files, checked by separate
+  DOM and Web Worker TypeScript projects with no JavaScript compatibility mode
+  or suppression directives;
+- `bootstrap.ts` is the single first-party HTML entry and esbuild represents
+  startup order, lazy feature imports, shared hashed chunks, and the worker in
+  its module graph;
+- obsolete source and generated compatibility JavaScript was removed;
+- Rust generates rig, status, capability, decoder, and flattened frontend
+  metadata contracts into `api/generated.ts`; runtime guards validate HTTP,
+  SSE, WebSocket, and worker boundaries;
+- the generic embedded-asset handler serves a build-generated allowlist with
+  constrained MIME types, compression, ETags, immutable caching, and no file
+  system lookup;
+- intentional browser host namespaces and transitional lazy-feature properties
+  are documented in `docs/frontend-architecture.md`;
+- CI uses locked npm dependencies, caches npm downloads rather than
+  `node_modules`, runs strict type checking and linting, unit/DOM/worker tests,
+  Chromium startup coverage, generated-output drift checks, and REUSE after
+  generation;
+- Cargo continues to consume committed generated assets without invoking Node
+  or requiring network access.
+
+The final local gate ran `npm ci`, type checking, linting, 30 frontend tests,
+the Chromium smoke flow (startup, auth gate, audio controls, rig switching, map
+initialization, and navigation), generated-contract and bundle verification,
+workspace formatting, Clippy with warnings denied, all-target builds, workspace
+tests, and REUSE 3.3 validation.
 
 ## 1. Decision
 
@@ -20,7 +57,7 @@ the main safety benefits.
 The migration must be incremental. Every intermediate commit and pull request
 must leave the frontend buildable and usable.
 
-## 2. Current State
+## 2. Baseline State
 
 The frontend currently contains roughly 21,700 lines of first-party
 JavaScript. Its largest components include:

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/decode-history-worker.js

@@ -1,180 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-const textDecoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
-const HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax"];
-
-function decodeCborUint(view, bytes, state, additional) {
-  const offset = state.offset;
-  if (additional < 24) return additional;
-  if (additional === 24) {
-    if (offset + 1 > bytes.length) throw new Error("CBOR payload truncated");
-    state.offset += 1;
-    return bytes[offset];
-  }
-  if (additional === 25) {
-    if (offset + 2 > bytes.length) throw new Error("CBOR payload truncated");
-    state.offset += 2;
-    return view.getUint16(offset);
-  }
-  if (additional === 26) {
-    if (offset + 4 > bytes.length) throw new Error("CBOR payload truncated");
-    state.offset += 4;
-    return view.getUint32(offset);
-  }
-  if (additional === 27) {
-    if (offset + 8 > bytes.length) throw new Error("CBOR payload truncated");
-    const value = view.getBigUint64(offset);
-    state.offset += 8;
-    const numeric = Number(value);
-    if (!Number.isSafeInteger(numeric)) throw new Error("CBOR integer exceeds JS safe range");
-    return numeric;
-  }
-  throw new Error("Unsupported CBOR additional info");
-}
-
-function decodeCborFloat16(bits) {
-  const sign = (bits & 0x8000) ? -1 : 1;
-  const exponent = (bits >> 10) & 0x1f;
-  const fraction = bits & 0x03ff;
-  if (exponent === 0) {
-    return fraction === 0 ? sign * 0 : sign * Math.pow(2, -14) * (fraction / 1024);
-  }
-  if (exponent === 0x1f) {
-    return fraction === 0 ? sign * Infinity : Number.NaN;
-  }
-  return sign * Math.pow(2, exponent - 15) * (1 + (fraction / 1024));
-}
-
-function decodeCborItem(view, bytes, state) {
-  if (state.offset >= bytes.length) throw new Error("CBOR payload truncated");
-  const initial = bytes[state.offset++];
-  const major = initial >> 5;
-  const additional = initial & 0x1f;
-  if (major === 0) return decodeCborUint(view, bytes, state, additional);
-  if (major === 1) return -1 - decodeCborUint(view, bytes, state, additional);
-  if (major === 2) {
-    const length = decodeCborUint(view, bytes, state, additional);
-    if (state.offset + length > bytes.length) throw new Error("CBOR payload truncated");
-    const chunk = bytes.slice(state.offset, state.offset + length);
-    state.offset += length;
-    return Array.from(chunk);
-  }
-  if (major === 3) {
-    const length = decodeCborUint(view, bytes, state, additional);
-    if (state.offset + length > bytes.length) throw new Error("CBOR payload truncated");
-    const chunk = bytes.subarray(state.offset, state.offset + length);
-    state.offset += length;
-    return textDecoder ? textDecoder.decode(chunk) : String.fromCharCode(...chunk);
-  }
-  if (major === 4) {
-    const length = decodeCborUint(view, bytes, state, additional);
-    const items = new Array(length);
-    for (let i = 0; i < length; i += 1) {
-      items[i] = decodeCborItem(view, bytes, state);
-    }
-    return items;
-  }
-  if (major === 5) {
-    const length = decodeCborUint(view, bytes, state, additional);
-    const value = {};
-    for (let i = 0; i < length; i += 1) {
-      const key = decodeCborItem(view, bytes, state);
-      value[String(key)] = decodeCborItem(view, bytes, state);
-    }
-    return value;
-  }
-  if (major === 6) {
-    decodeCborUint(view, bytes, state, additional);
-    return decodeCborItem(view, bytes, state);
-  }
-  if (major === 7) {
-    if (additional === 20) return false;
-    if (additional === 21) return true;
-    if (additional === 22) return null;
-    if (additional === 23) return undefined;
-    if (additional === 25) {
-      if (state.offset + 2 > bytes.length) throw new Error("CBOR payload truncated");
-      const bits = view.getUint16(state.offset);
-      state.offset += 2;
-      return decodeCborFloat16(bits);
-    }
-    if (additional === 26) {
-      if (state.offset + 4 > bytes.length) throw new Error("CBOR payload truncated");
-      const value = view.getFloat32(state.offset);
-      state.offset += 4;
-      return value;
-    }
-    if (additional === 27) {
-      if (state.offset + 8 > bytes.length) throw new Error("CBOR payload truncated");
-      const value = view.getFloat64(state.offset);
-      state.offset += 8;
-      return value;
-    }
-  }
-  throw new Error("Unsupported CBOR major type");
-}
-
-function decodeCborPayload(buffer) {
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const state = { offset: 0 };
-  const value = decodeCborItem(view, bytes, state);
-  if (state.offset !== bytes.length) {
-    throw new Error("Unexpected trailing bytes in decode history payload");
-  }
-  return value;
-}
-
-async function fetchAndDecodeHistory(url, batchLimit) {
-  self.postMessage({ type: "status", phase: "fetching" });
-  const resp = await fetch(url, { credentials: "same-origin" });
-  if (!resp.ok) throw new Error(`History fetch failed: ${resp.status}`);
-  const payload = await resp.arrayBuffer();
-  if (!payload || payload.byteLength === 0) {
-    self.postMessage({ type: "start", total: 0 });
-    self.postMessage({ type: "done", total: 0 });
-    return;
-  }
-
-  self.postMessage({ type: "status", phase: "decoding" });
-  const history = decodeCborPayload(payload);
-  const total = HISTORY_GROUP_KEYS.reduce((sum, key) => {
-    const items = history && Array.isArray(history[key]) ? history[key] : [];
-    return sum + items.length;
-  }, 0);
-  self.postMessage({ type: "start", total });
-
-  let processed = 0;
-  const safeLimit = Math.max(1, Math.min(2048, Number(batchLimit) || 512));
-
-  for (const kind of HISTORY_GROUP_KEYS) {
-    const items = history && Array.isArray(history[kind]) ? history[kind] : [];
-    if (items.length === 0) continue;
-    for (let index = 0; index < items.length; index += safeLimit) {
-      const messages = items.slice(index, index + safeLimit);
-      processed += messages.length;
-      self.postMessage({
-        type: "group",
-        kind,
-        messages,
-        processed,
-        total,
-      });
-    }
-  }
-  self.postMessage({ type: "done", total });
-}
-
-self.onmessage = (event) => {
-  const data = event?.data || {};
-  if (data?.type !== "fetch-history") return;
-  fetchAndDecodeHistory(data.url || "/decode/history", data.batchLimit)
-    .catch((err) => {
-      self.postMessage({
-        type: "error",
-        message: err && err.message ? err.message : String(err || "unknown worker failure"),
-      });
-    });
-};

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

@@ -1,6 +1,11 @@
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/ais.ts
 var aisWindow = window;
-var escapeAisHtml = (input) => aisWindow.escapeMapHtml?.(input) ?? input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var escapeAisHtml = (input) => hostCore.escapeMapHtml(input);
 var aisStatus = document.getElementById("ais-status");
 var aisMessagesEl = document.getElementById("ais-messages");
 var aisFilterInput = document.getElementById("ais-filter");
@@ -119,10 +124,10 @@ function aisRouteText(msg) {
   return [msg.callsign, msg.destination].filter(Boolean).join(" -> ");
 }
 function aisDistanceText(msg) {
-  if (aisWindow.serverLat == null || aisWindow.serverLon == null || msg.lat == null || msg.lon == null || !aisWindow.haversineKm) {
+  if (hostState.serverLat == null || hostState.serverLon == null || msg.lat == null || msg.lon == null) {
     return "";
   }
-  const distKm = aisWindow.haversineKm(aisWindow.serverLat, aisWindow.serverLon, msg.lat, msg.lon);
+  const distKm = hostCore.haversineKm(hostState.serverLat, hostState.serverLon, msg.lat, msg.lon);
   if (!Number.isFinite(distKm)) return "";
   if (distKm < 1) return `${Math.round(distKm * 1e3)} m from TRX`;
   return `${distKm.toFixed(1)} km from TRX`;
@@ -155,8 +160,18 @@ function updateAisSummary() {
     }
   }
 }
+function aisSummaryText(msg) {
+  const parts = [];
+  if (msg.lat != null && msg.lon != null) parts.push(`${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}`);
+  const motion = aisMotionText(msg);
+  if (motion) parts.push(motion);
+  const route = aisRouteText(msg);
+  if (route && parts.length < 2) parts.push(route);
+  if (!parts.length) return route || "no position reported";
+  return parts.join(" · ");
+}
 function renderAisRow(msg) {
-  const row = document.createElement("div");
+  const row = document.createElement("details");
   row.className = "ais-message";
   const ts = msg._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], {
     hour: "2-digit",
@@ -169,7 +184,8 @@ function renderAisRow(msg) {
   const motion = aisMotionText(msg);
   const route = aisRouteText(msg);
   const distance = aisDistanceText(msg);
-  const pos = msg.lat != null && msg.lon != null ? `<a class="ais-pos-link" href="javascript:void(0)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>` : "";
+  const pos = msg.lat != null && msg.lon != null ? `<a class="ais-pos-link" href="javascript:void(0)" data-ais-map="${msg.lat},${msg.lon}">${msg.lat.toFixed(5)}, ${msg.lon.toFixed(5)}</a>` : "";
+  const vesselUrl = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
   row.dataset.filterText = [
     name,
     msg.mmsi,
@@ -180,7 +196,16 @@ function renderAisRow(msg) {
     msg.destination,
     aisTypeLabel(msg.message_type)
   ].filter(Boolean).join(" ").toUpperCase();
-  row.innerHTML = `<div class="ais-row-head"><span class="ais-time">${ts}</span><span class="ais-call">${nameHtml}</span><span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span><span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span></div><div class="ais-row-meta"><span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span>` + (route ? `<span class="ais-meta-text">${escapeAisHtml(route)}</span>` : "") + `<span class="ais-meta-text">${escapeAisHtml(channel.freqText)}</span></div><div class="ais-row-detail">` + (motion ? `<span>${escapeAisHtml(motion)}</span>` : `<span>No motion data</span>`) + (distance ? `<span>${escapeAisHtml(distance)}</span>` : "") + (pos ? `<span>${pos}</span>` : "") + `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span></div>`;
+  row.innerHTML = `<summary class="decode-line"><span class="ais-time">${escapeAisHtml(ts)}</span><span class="ais-call">${nameHtml}</span><span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span><span class="decode-line-summary">${escapeAisHtml(aisSummaryText(msg))}</span><span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span>` + (distance ? `<span class="decode-line-distance">${escapeAisHtml(distance)}</span>` : "") + `</summary><div class="decode-expanded"><div class="decode-expanded-meta"><span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span><span>${escapeAisHtml(channel.freqText)}</span>` + (route ? `<span>${escapeAisHtml(route)}</span>` : "") + (motion ? `<span>${escapeAisHtml(motion)}</span>` : "") + `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span>` + (pos ? `<span>${pos}</span>` : "") + `</div><div class="aprs-row-actions">` + (msg.lat != null && msg.lon != null ? `<button class="aprs-inline-btn" type="button" data-ais-map="${msg.lat},${msg.lon}">Map</button>` : "") + (vesselUrl ? `<a class="aprs-inline-btn" href="${escapeAisHtml(vesselUrl)}" target="_blank" rel="noopener">Vessel</a>` : "") + `</div></div>`;
+  row.querySelectorAll("[data-ais-map]").forEach((element) => {
+    element.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const [lat, lon] = (element.dataset.aisMap ?? "").split(",").map(Number);
+      if (lat == null || lon == null || !Number.isFinite(lat) || !Number.isFinite(lon)) return;
+      aisWindow.navigateToAprsMap?.(lat, lon);
+    });
+  });
   applyAisFilterToRow(row);
   return row;
 }
@@ -260,9 +285,11 @@ function addAisMessage(msg) {
   pruneAisMessageHistory();
   scheduleAisBarUpdate();
   scheduleAisHistoryRender();
-  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
+  plotAisMessage(msg);
-    aisWindow.aisMapAddVessel(msg);
 }
+function plotAisMessage(msg) {
+  if (msg.lat == null || msg.lon == null || !aisWindow.aisMapAddVessel) return;
+  aisWindow.aisMapAddVessel(msg);
 }
 function normalizeServerAisMessage(msg) {
   return {
@@ -283,9 +310,7 @@ function onServerAisBatch(messages) {
       minute: "2-digit",
       second: "2-digit"
     });
-    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
+    plotAisMessage(next);
-      aisWindow.aisMapAddVessel(next);
-    }
     normalized.push(next);
   }
   normalized.reverse();
@@ -303,7 +328,7 @@ document.getElementById("settings-clear-ais-history")?.addEventListener("click",
   void (async () => {
     if (!await aisWindow.trxUi.confirm({ title: "Clear AIS history?", message: "All stored AIS messages will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await aisWindow.postPath?.("/clear_ais_decode");
+      await hostCore.postPath("/clear_ais_decode");
       resetAisHistoryView();
     } catch (e) {
       console.error("AIS history clear failed", e);
@@ -327,5 +352,9 @@ window.trxPluginRuntime.registerDecoder({
   onBatch: onServerAisBatch,
   restore: onServerAisBatch,
   reset: resetAisHistoryView,
-  prune: pruneAisHistoryView
+  prune: pruneAisHistoryView,
+  // Oldest first, so vessel tracks are rebuilt in the order they happened.
+  syncMap: () => {
+    for (const entry of [...aisMessageHistory].reverse()) plotAisMessage(entry);
+  }
 });

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

@@ -1,71 +0,0 @@
-"use strict";
-export class ApiError extends Error {
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-    this.name = "ApiError";
-  }
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function isRigSnapshot(value) {
-  if (!isRecord(value) || !isRecord(value.info) || !isRecord(value.status)) {
-    return false;
-  }
-  const { info, status } = value;
-  return typeof value.initialized === "boolean" && typeof info.manufacturer === "string" && typeof info.model === "string" && isRecord(status.freq) && typeof status.freq.hz === "number" && (typeof status.mode === "string" || isRecord(status.mode)) && typeof status.tx_en === "boolean";
-}
-export function isRigListResponse(value) {
-  return isRecord(value) && (value.active_remote === null || typeof value.active_remote === "string") && Array.isArray(value.rigs) && value.rigs.every(
-    (rig) => isRecord(rig) && typeof rig.remote === "string" && typeof rig.manufacturer === "string" && typeof rig.model === "string" && Array.isArray(rig.supported_modes) && typeof rig.tx === "boolean" && typeof rig.filter_controls === "boolean" && typeof rig.initialized === "boolean"
-  );
-}
-export function isDecoderRegistry(value) {
-  return Array.isArray(value) && value.every(
-    (decoder) => isRecord(decoder) && typeof decoder.id === "string" && typeof decoder.label === "string" && (decoder.activation === "mode_bound" || decoder.activation === "toggle") && Array.isArray(decoder.active_modes) && decoder.active_modes.every((mode) => typeof mode === "string") && typeof decoder.background_decode === "boolean" && typeof decoder.bookmark_selectable === "boolean"
-  );
-}
-export class TrxApi {
-  constructor(baseUrl = "") {
-    this.baseUrl = baseUrl;
-  }
-  async get(path, validate) {
-    return this.request(path, { cache: "no-store" }, validate);
-  }
-  async post(path, body, validate) {
-    return this.request(
-      path,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      },
-      validate
-    );
-  }
-  async request(path, init, validate) {
-    const response = await fetch(`${this.baseUrl}${path}`, init);
-    if (!response.ok) {
-      const detail = await response.text();
-      throw new ApiError(response.status, detail || response.statusText);
-    }
-    const value = await response.json();
-    if (!validate(value)) {
-      throw new ApiError(response.status, `Malformed response from ${path}`);
-    }
-    return value;
-  }
-}
-export function decodeServerEvent(event, validate) {
-  let value;
-  try {
-    value = JSON.parse(event.data);
-  } catch (error) {
-    throw new TypeError("Server event is not valid JSON", { cause: error });
-  }
-  if (!validate(value)) {
-    throw new TypeError("Server event has an unexpected shape");
-  }
-  return value;
-}

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

@@ -1,19 +1,20 @@
 import {
   aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
   aprsPacketCategory,
   collapseAprsDuplicates,
   normalizeAprsPacket,
-  renderAprsInfo,
+  renderAprsPacketRow
-  renderLocalAprsSymbol
+} from "./chunk-OPEIVJGD.js";
-} from "./chunk-M2I6DH4X.js";
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
 
 // src/plugins/aprs.ts
 var aprsWindow = window;
-var escapeAprsHtml = (input) => aprsWindow.escapeMapHtml?.(input) ?? input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var escapeAprsHtml = (input) => hostCore.escapeMapHtml(input);
 var showAprsHint = (message, durationMs) => {
-  aprsWindow.showHint?.(message, durationMs);
+  hostCore.showHint(message, durationMs);
 };
 var aprsStatus = document.getElementById("aprs-status");
 var aprsPacketsEl = document.getElementById("aprs-packets");
@@ -58,8 +59,8 @@ function scheduleAprsBarUpdate() {
   });
 }
 function aprsDistanceText(pkt) {
-  if (aprsWindow.serverLat == null || aprsWindow.serverLon == null || pkt.lat == null || pkt.lon == null || !aprsWindow.haversineKm) return "";
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
-  const distKm = aprsWindow.haversineKm(aprsWindow.serverLat, aprsWindow.serverLon, pkt.lat, pkt.lon);
+  const distKm = hostCore.haversineKm(hostState.serverLat, hostState.serverLon, pkt.lat, pkt.lon);
   if (!Number.isFinite(distKm)) return "";
   if (distKm < 1) return `${Math.round(distKm * 1e3)} m from TRX`;
   return `${distKm.toFixed(1)} km from TRX`;
@@ -110,51 +111,27 @@ function updateAprsChipState() {
   aprsHideCrcBtn?.classList.toggle("active", aprsHideCrc);
   aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }
-function renderAprsRow(pkt, isFresh) {
+async function copyAprsCoords(text) {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  const age = aprsAgeText(pkt._tsMs);
-  const category = aprsPacketCategory(pkt);
-  const categoryLabel = aprsCategoryLabel(category);
-  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeAprsHtml(pkt.path)}</span>` : "";
-  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-  const symbolHtml = renderLocalAprsSymbol(pkt, escapeAprsHtml);
-  const posLink = pkt.lat != null && pkt.lon != null ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>` : "";
-  const distance = aprsDistanceText(pkt);
-  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
-  row.innerHTML = `<div class="aprs-row-head"><span class="aprs-time">${ts}</span>` + symbolHtml + `<span class="aprs-call">${escapeAprsHtml(pkt.srcCall ?? "")}</span><span>&gt;${escapeAprsHtml(pkt.destCall || "")}</span><span class="${categoryClass}">${escapeAprsHtml(categoryLabel)}</span>` + pathBadge + crcBadge + `</div><div class="aprs-row-meta"><span class="aprs-meta-text">${escapeAprsHtml(age)}</span>` + (distance ? `<span class="aprs-meta-text">${escapeAprsHtml(distance)}</span>` : "") + `<span class="aprs-meta-text">${escapeAprsHtml(pkt.type || "--")}</span></div><div class="aprs-row-detail"><span title="${escapeAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` + (posLink ? `<span>${posLink}</span>` : "") + `</div><div class="aprs-row-actions">` + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div><details class="aprs-details"><summary>Details</summary><div class="aprs-details-grid"><span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.srcCall || "--")}</span><span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.destCall || "--")}</span><span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.type || "--")}</span><span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.path || "--")}</span><span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeAprsHtml(age)}</span><span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span><span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span><span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.info || "--")}</span><span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeAprsHtml(aprsHexBytes(pkt.info_bytes))}</span></div></details>`;
-  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
-    el.addEventListener("click", (evt) => {
-      evt.preventDefault();
-      const raw = el.dataset.aprsMap ?? "";
-      const [lat, lon] = raw.split(",").map(Number);
-      if (aprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
-        aprsWindow.navigateToAprsMap(lat, lon);
-      }
-    });
-  });
-  const copyBtn = row.querySelector("[data-aprs-copy]");
-  if (copyBtn) {
-    copyBtn.addEventListener("click", () => {
-      void (async () => {
-        const raw = copyBtn.dataset.aprsCopy ?? "";
   try {
     const clipboard = Reflect.get(navigator, "clipboard");
-          if (clipboard) {
+    if (!clipboard) return;
-            await clipboard.writeText(raw);
+    await clipboard.writeText(text);
     showAprsHint("Coordinates copied", 1200);
-          }
   } catch {
     showAprsHint("Copy failed", 1500);
   }
-      })();
-    });
 }
-  return row;
+function renderAprsRow(pkt, isFresh) {
+  return renderAprsPacketRow(pkt, {
+    fresh: isFresh,
+    distance: aprsDistanceText(pkt),
+    onMap: (lat, lon) => {
+      aprsWindow.navigateToAprsMap?.(lat, lon);
+    },
+    onCopy: (text) => {
+      void copyAprsCoords(text);
+    }
+  });
 }
 function renderAprsHistory() {
   pruneAprsPacketHistory();
@@ -219,15 +196,17 @@ function pruneAprsHistoryView() {
   updateAprsBar();
   renderAprsHistory();
 }
+function plotAprsPacket(pkt) {
+  if (pkt.lat == null || pkt.lon == null || !aprsWindow.aprsMapAddStation) return;
+  aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
+}
 function addAprsPacket(pkt) {
   const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
   pkt._tsMs = tsMs;
   pkt._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
   aprsPacketHistory.unshift(pkt);
   pruneAprsPacketHistory();
-  if (pkt.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
+  plotAprsPacket(pkt);
-    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
-  }
   if (pkt.crcOk) scheduleAprsBarUpdate();
   scheduleAprsHistoryRender();
 }
@@ -244,9 +223,7 @@ function onServerAprsBatch(packets) {
     const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
     next._tsMs = tsMs;
     next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
+    plotAprsPacket(next);
-      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
-    }
     if (next.crcOk) hasCrcOk = true;
     normalized.push(next);
   }
@@ -260,7 +237,7 @@ document.getElementById("settings-clear-aprs-history")?.addEventListener("click"
   void (async () => {
     if (!await aprsWindow.trxUi.confirm({ title: "Clear APRS history?", message: "All stored APRS packets will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await aprsWindow.postPath?.("/clear_aprs_decode");
+      await hostCore.postPath("/clear_aprs_decode");
       resetAprsHistoryView();
     } catch (e) {
       console.error("APRS history clear failed", e);
@@ -310,5 +287,9 @@ window.trxPluginRuntime.registerDecoder({
   onBatch: onServerAprsBatch,
   restore: onServerAprsBatch,
   reset: resetAprsHistoryView,
-  prune: pruneAprsHistoryView
+  prune: pruneAprsHistoryView,
+  // Oldest first, so station tracks are rebuilt in the order they happened.
+  syncMap: () => {
+    for (const entry of [...aprsPacketHistory].reverse()) plotAprsPacket(entry);
+  }
 });

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

@@ -1,3 +1,7 @@
+import {
+  hostState
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/background-decode.ts
 var bgdWindow = window;
 (function() {
@@ -104,7 +108,7 @@ var bgdWindow = window;
     }
     setCheckbox("background-decode-enabled", currentConfig.enabled);
     renderBookmarkChecklist();
-    const isControl = backgroundDecodeRole === "control" || bgdWindow.authEnabled === false;
+    const isControl = backgroundDecodeRole === "control" || hostState.authEnabled === false;
     const panel = document.getElementById("background-decode-panel");
     if (panel) {
       panel.querySelectorAll("input, select, button.sch-write").forEach(function(el) {

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

@@ -1,3 +1,8 @@
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/bookmarks.ts
 var bridge = window;
 function bmEl(id) {
@@ -5,6 +10,9 @@ function bmEl(id) {
   if (!element) throw new Error(`Missing bookmark element #${id}`);
   return element;
 }
+function bmOptionalEl(id) {
+  return document.getElementById(id);
+}
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -34,7 +42,7 @@ function bmEsc(str) {
   return d.innerHTML;
 }
 function bmCanControl() {
-  return typeof bridge.authEnabled !== "undefined" && !bridge.authEnabled || typeof bridge.authRole !== "undefined" && bridge.authRole === "control";
+  return !hostState.authEnabled || hostState.authRole === "control";
 }
 function bmSyncAccess() {
   const canCtrl = bmCanControl();
@@ -44,8 +52,7 @@ function bmSyncAccess() {
   if (selectAllBtn) selectAllBtn.style.display = canCtrl ? "" : "none";
 }
 function bmListScope() {
-  const rig = typeof bridge.lastActiveRigId !== "undefined" ? bridge.lastActiveRigId : null;
+  return hostState.lastActiveRigId || "general";
-  return rig || "general";
 }
 async function bmFetchOverlay() {
   const overlayScope = bmListScope();
@@ -61,7 +68,7 @@ async function bmFetchOverlay() {
   if (typeof bridge.syncBookmarkMapLocators === "function") {
     bridge.syncBookmarkMapLocators(bmOverlayList);
   }
-  if (typeof bridge.scheduleSpectrumDraw === "function") bridge.scheduleSpectrumDraw();
+  hostCore.scheduleSpectrumDraw();
 }
 async function bmFetch(categoryFilter) {
   let url = "/bookmarks";
@@ -184,12 +191,12 @@ function bmChangePage(delta) {
   bmRender(bmFilteredList);
 }
 function bmReadDecoders() {
-  return (bridge.decoderRegistry || []).filter((d) => d.bookmark_selectable).filter((d) => bmEl("bm-dec-" + d.id)?.checked).map((d) => d.id);
+  return hostState.decoderRegistry.filter((d) => d.bookmark_selectable).filter((d) => bmOptionalEl("bm-dec-" + d.id)?.checked).map((d) => d.id);
 }
 function bmWriteDecoders(decoders) {
   const set = new Set(decoders || []);
-  (bridge.decoderRegistry || []).filter((d) => d.bookmark_selectable).forEach((d) => {
+  hostState.decoderRegistry.filter((d) => d.bookmark_selectable).forEach((d) => {
-    const el = bmEl("bm-dec-" + d.id);
+    const el = bmOptionalEl("bm-dec-" + d.id);
     if (el) el.checked = set.has(d.id);
   });
 }
@@ -197,7 +204,7 @@ function bmBuildDecoderCheckboxes() {
   const container = bmEl("bm-decoder-checkboxes");
   if (!container) return;
   container.innerHTML = "";
-  (bridge.decoderRegistry || []).filter((d) => d.bookmark_selectable).forEach((d) => {
+  hostState.decoderRegistry.filter((d) => d.bookmark_selectable).forEach((d) => {
     const label = document.createElement("label");
     label.className = "bm-decoder-check";
     label.innerHTML = '<input type="checkbox" id="bm-dec-' + d.id + '" value="' + d.id + '" /> ' + d.label;
@@ -227,19 +234,17 @@ function bmCloseForm() {
   if (wrap) wrap.style.display = "none";
 }
 function bmPrefillFromStatus() {
-  if (typeof bridge.lastFreqHz === "number" && Number.isFinite(bridge.lastFreqHz)) {
+  const freqHz = hostState.lastFreqHz;
-    bmEl("bm-freq").value = String(Math.round(bridge.lastFreqHz));
+  if (freqHz != null && Number.isFinite(freqHz)) {
+    bmEl("bm-freq").value = String(Math.round(freqHz));
   }
-  if (typeof bridge.lastModeName === "string" && bridge.lastModeName) {
+  if (hostState.lastModeName) {
-    bmEl("bm-mode").value = bridge.lastModeName;
+    bmEl("bm-mode").value = hostState.lastModeName;
   }
-  if (typeof bridge.currentBandwidthHz === "number" && bridge.currentBandwidthHz > 0) {
+  if (hostState.currentBandwidthHz > 0) {
-    bmEl("bm-bw").value = String(Math.round(bridge.currentBandwidthHz));
+    bmEl("bm-bw").value = String(Math.round(hostState.currentBandwidthHz));
   }
-  const activeDecoders = (bridge.decoderRegistry || []).filter((d) => d.bookmark_selectable && d.activation === "toggle").filter((d) => {
+  const activeDecoders = hostState.decoderRegistry.filter((d) => d.bookmark_selectable && d.activation === "toggle").filter((d) => bmOptionalEl(d.id + "-decode-toggle-btn")?.dataset.enabled === "true").map((d) => d.id);
-    const btn = bmEl(d.id + "-decode-toggle-btn");
-    return btn && btn.dataset.enabled === "true";
-  }).map((d) => d.id);
   bmWriteDecoders(activeDecoders);
 }
 async function bmSave(e) {
@@ -320,55 +325,44 @@ async function bmDelete(id) {
 }
 function bmApply(bm) {
   try {
-    if (typeof bridge.modeEl !== "undefined" && bridge.modeEl) {
+    const modeEl = document.getElementById("mode");
-      bridge.modeEl.value = (bm.mode || "").toUpperCase();
+    if (modeEl) {
+      modeEl.value = (bm.mode || "").toUpperCase();
+      hostCore.syncModePicker();
     }
     if (bm.bandwidth_hz) {
-      if (typeof bridge.currentBandwidthHz !== "undefined") {
+      hostState.currentBandwidthHz = bm.bandwidth_hz;
-        bridge.currentBandwidthHz = bm.bandwidth_hz;
+      hostCore.syncBandwidthInput(bm.bandwidth_hz);
     }
-      bridge.currentBandwidthHz = bm.bandwidth_hz;
+    hostCore.armOptimisticFrequency(bm.freq_hz);
-      if (typeof bridge.syncBandwidthInput === "function") {
+    hostCore.applyLocalTunedFrequency(bm.freq_hz, true);
-        bridge.syncBandwidthInput(bm.bandwidth_hz);
+    if (hostState.lastSpectrumData) {
-      }
+      hostCore.scheduleSpectrumDraw();
-    }
-    if (typeof bridge.applyLocalTunedFrequency === "function") {
-      if (typeof bridge._freqOptimisticSeq !== "undefined") {
-        ++bridge._freqOptimisticSeq;
-        bridge._freqOptimisticHz = bm.freq_hz;
-      }
-      bridge.applyLocalTunedFrequency(bm.freq_hz, true);
-    }
-    if (typeof bridge.scheduleSpectrumDraw === "function" && typeof bridge.lastSpectrumData !== "undefined" && bridge.lastSpectrumData) {
-      bridge.scheduleSpectrumDraw();
     }
     const tunePromise = (async () => {
-      await bridge.trx?.modules?.vchan?.takeSchedulerControl();
+      await bridge.trx.modules.vchan?.takeSchedulerControl();
-      const onVirtual = await bridge.trx?.modules?.vchan?.interceptMode(bm.mode) ?? false;
+      const onVirtual = await bridge.trx.modules.vchan?.interceptMode(bm.mode) ?? false;
       if (!onVirtual) {
-        await bridge.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
+        await hostCore.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
       }
       if (bm.bandwidth_hz) {
-        const bwHandledByVchan = await bridge.trx?.modules?.vchan?.interceptBandwidth(bm.bandwidth_hz) ?? false;
+        const bwHandledByVchan = await bridge.trx.modules.vchan?.interceptBandwidth(bm.bandwidth_hz) ?? false;
         if (!bwHandledByVchan) {
-          await bridge.postPath(`/set_bandwidth?hz=${bm.bandwidth_hz}`);
+          await hostCore.postPath(`/set_bandwidth?hz=${bm.bandwidth_hz}`);
         }
       }
-      if (typeof bridge.setRigFrequency === "function") {
+      hostCore.setRigFrequency(bm.freq_hz);
-        await bridge.setRigFrequency(bm.freq_hz);
-      } else {
-        await bridge.postPath(`/set_freq?hz=${bm.freq_hz}`);
-      }
     })();
     const hasDecoders = Array.isArray(bm.decoders) && bm.decoders.length > 0;
     const modeUp = (bm.mode || "").toUpperCase();
-    const allToggleDecoders = (bridge.decoderRegistry || []).filter(
+    const allToggleDecoders = hostState.decoderRegistry.filter(
       (d) => d.activation === "toggle"
     );
     const decoderPromise = allToggleDecoders.length ? (async () => {
       let statusUrl = "/status";
-      if (typeof bridge.lastActiveRigId !== "undefined" && bridge.lastActiveRigId) {
+      const rigId = hostState.lastActiveRigId;
-        statusUrl += "?remote=" + encodeURIComponent(bridge.lastActiveRigId);
+      if (rigId) {
+        statusUrl += "?remote=" + encodeURIComponent(rigId);
       }
       const statusResp = await fetch(statusUrl);
       if (!statusResp.ok) return;
@@ -387,7 +381,7 @@ function bmApply(bm) {
           wanted = currentlyOn;
         }
         if (wanted !== currentlyOn) {
-          toggles.push(bridge.postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
+          toggles.push(hostCore.postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
         }
       }
       if (toggles.length) await Promise.all(toggles);
@@ -399,8 +393,6 @@ function bmApply(bm) {
     console.error("Failed to apply bookmark:", err);
   }
 }
-bridge.trx ??= {};
-bridge.trx.modules ??= {};
 bridge.trx.modules.bookmarks = {
   get overlayList() {
     return bmOverlayList;
@@ -439,8 +431,8 @@ function bmUpdateSelectionUi() {
 function bmPopulateMoveTarget() {
   const sel = bmEl("bm-move-target");
   if (!sel) return;
-  const rigIds = typeof bridge.lastRigIds !== "undefined" && Array.isArray(bridge.lastRigIds) ? bridge.lastRigIds : [];
+  const rigIds = hostState.lastRigIds;
-  const displayNames = typeof bridge.lastRigDisplayNames !== "undefined" ? bridge.lastRigDisplayNames : {};
+  const displayNames = hostState.lastRigDisplayNames;
   const prev = sel.value;
   sel.innerHTML = "";
   if (bmScope !== "general") {
@@ -545,8 +537,8 @@ async function bmDeleteSelected() {
 function bmPopulateScopePicker() {
   const picker = bmEl("bm-scope-picker");
   if (!picker) return;
-  const rigIds = typeof bridge.lastRigIds !== "undefined" && Array.isArray(bridge.lastRigIds) ? bridge.lastRigIds : [];
+  const rigIds = hostState.lastRigIds;
-  const displayNames = typeof bridge.lastRigDisplayNames !== "undefined" ? bridge.lastRigDisplayNames : {};
+  const displayNames = hostState.lastRigDisplayNames;
   const prev = picker.value;
   while (picker.options.length > 1) picker.remove(1);
   rigIds.forEach((id) => {
@@ -565,9 +557,7 @@ function bmPopulateScopePicker() {
 (function initBookmarks() {
   bmSyncAccess();
   bmBuildDecoderCheckboxes();
-  if (typeof bridge.onDecoderRegistryReady === "function") {
+  hostCore.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
-    bridge.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
-  }
   bmPopulateScopePicker();
   const scopePicker = bmEl("bm-scope-picker");
   if (scopePicker) {

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

@@ -0,0 +1,9 @@
+// src/plugins/host.ts
+var host = window;
+var hostState = host.trx.state;
+var hostCore = host.trx.core;
+
+export {
+  hostState,
+  hostCore
+};

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

@@ -1,112 +0,0 @@
-// src/plugins/aprs-shared.ts
-function aprsPacketCategory(packet) {
-  const type = (packet.type ?? "").toLowerCase();
-  const info = (packet.info ?? "").toLowerCase();
-  if (packet.lat != null && packet.lon != null || type.includes("position")) return "position";
-  if (type.includes("message") || info.startsWith(":")) return "message";
-  if (type.includes("weather") || info.startsWith("_")) return "weather";
-  if (type.includes("telemetry") || info.startsWith("t#")) return "telemetry";
-  return "other";
-}
-function aprsCategoryLabel(category) {
-  switch (category) {
-    case "position":
-      return "Position";
-    case "message":
-      return "Message";
-    case "weather":
-      return "Weather";
-    case "telemetry":
-      return "Telemetry";
-    default:
-      return "Other";
-  }
-}
-function aprsAgeText(timestampMs) {
-  if (typeof timestampMs !== "number" || !Number.isFinite(timestampMs)) return "just now";
-  const seconds = Math.round(Math.max(0, Date.now() - timestampMs) / 1e3);
-  if (seconds < 5) return "just now";
-  if (seconds < 60) return `${String(seconds)}s ago`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${String(minutes)}m ago`;
-  return `${String(Math.round(minutes / 60))}h ago`;
-}
-function aprsPacketSignature(packet) {
-  return [
-    packet.srcCall ?? "",
-    packet.destCall ?? "",
-    packet.path ?? "",
-    packet.info ?? "",
-    packet.type ?? "",
-    packet.lat?.toFixed(4) ?? "",
-    packet.lon?.toFixed(4) ?? ""
-  ].join("|");
-}
-function collapseAprsDuplicates(packets) {
-  const seen = /* @__PURE__ */ new Set();
-  return packets.filter((packet) => {
-    const signature = aprsPacketSignature(packet);
-    if (seen.has(signature)) return false;
-    seen.add(signature);
-    return true;
-  });
-}
-function aprsHexBytes(bytes) {
-  if (!bytes?.length) return "--";
-  return bytes.map((byte) => byte.toString(16).toUpperCase().padStart(2, "0")).join(" ");
-}
-function renderAprsInfo(packet) {
-  if (packet.info_bytes?.length) {
-    return packet.info_bytes.map((byte) => renderAprsByte(byte)).join("");
-  }
-  return Array.from(packet.info ?? "", (character) => renderAprsCharacter(character)).join("");
-}
-function renderAprsByte(byte) {
-  return byte >= 32 && byte <= 126 ? escapeAprsCharacter(String.fromCharCode(byte)) : `<span class="aprs-byte">0x${byte.toString(16).toUpperCase().padStart(2, "0")}</span>`;
-}
-function renderAprsCharacter(character) {
-  const code = character.charCodeAt(0);
-  return code >= 32 && code <= 126 ? escapeAprsCharacter(character) : `<span class="aprs-byte">0x${code.toString(16).toUpperCase().padStart(2, "0")}</span>`;
-}
-function escapeAprsCharacter(character) {
-  if (character === "<") return "&lt;";
-  if (character === ">") return "&gt;";
-  if (character === "&") return "&amp;";
-  if (character === '"') return "&quot;";
-  return character;
-}
-function renderLocalAprsSymbol(packet, escapeHtml) {
-  if (!packet.symbolTable || !packet.symbolCode) return "";
-  const symbol = escapeHtml(packet.symbolCode);
-  const table = packet.symbolTable === "/" ? "Primary" : "Alternate";
-  return `<span class="aprs-symbol aprs-symbol-local" title="${table} APRS symbol ${symbol}">${symbol}</span>`;
-}
-function normalizeAprsPacket(packet, receiver) {
-  return {
-    rig_id: packet.rig_id || null,
-    receiver,
-    srcCall: packet.src_call ?? "",
-    destCall: packet.dest_call ?? "",
-    path: packet.path ?? "",
-    info: packet.info ?? "",
-    info_bytes: packet.info_bytes ?? [],
-    type: packet.packet_type ?? "",
-    crcOk: packet.crc_ok ?? false,
-    ts_ms: packet.ts_ms ?? null,
-    lat: packet.lat ?? null,
-    lon: packet.lon ?? null,
-    symbolTable: packet.symbol_table ?? null,
-    symbolCode: packet.symbol_code ?? null
-  };
-}
-
-export {
-  aprsPacketCategory,
-  aprsCategoryLabel,
-  aprsAgeText,
-  collapseAprsDuplicates,
-  aprsHexBytes,
-  renderAprsInfo,
-  renderLocalAprsSymbol,
-  normalizeAprsPacket
-};

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

@@ -1,5 +1,13 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/ftx-family.ts
 var bridge = window;
+function formatBarTime(timestampMs) {
+  if (!timestampMs) return "--:--:--";
+  return new Date(timestampMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
 function finiteNumber(value) {
   const number = typeof value === "number" ? value : Number(value);
   return Number.isFinite(number) ? number : null;
@@ -198,7 +206,7 @@ function initializeFtxDecoder(config) {
     let html = "";
     for (const message of recent) {
       const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
-      const time = timestamp === null ? "" : `<span class="aprs-bar-time">${bridge.fmtTime?.(timestamp) ?? ""}</span>`;
+      const time = timestamp === null ? "" : `<span class="aprs-bar-time">${formatBarTime(timestamp)}</span>`;
       const snr = finiteNumber(message.snr_db);
       const delta = finiteNumber(message.dt_s);
       const frequency = displayFrequency(message.freq_hz);
@@ -243,7 +251,7 @@ function initializeFtxDecoder(config) {
     void (async () => {
       try {
         await bridge.takeSchedulerControlForDecoderDisable?.(toggle);
-        await bridge.postPath?.(`/toggle_${id}_decode`);
+        await hostCore.postPath(`/toggle_${id}_decode`);
       } catch (error) {
         console.error(`${label} toggle failed`, error);
       }
@@ -253,7 +261,7 @@ function initializeFtxDecoder(config) {
     void (async () => {
       if (!await bridge.trxUi.confirm({ title: `Clear ${label} history?`, message: `All stored ${label} decodes will be permanently removed.`, confirmLabel: "Clear history" })) return;
       try {
-        await bridge.postPath?.(`/clear_${id}_decode`);
+        await hostCore.postPath(`/clear_${id}_decode`);
         reset();
       } catch (error) {
         console.error(`${label} history clear failed`, error);

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

@@ -0,0 +1,254 @@
+// src/plugins/aprs-shared.ts
+function escapeAprsHtml(value) {
+  return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function aprsPacketCategory(packet) {
+  const type = (packet.type ?? "").toLowerCase();
+  const info = (packet.info ?? "").toLowerCase();
+  if (packet.lat != null && packet.lon != null || type.includes("position")) return "position";
+  if (type.includes("message") || info.startsWith(":")) return "message";
+  if (type.includes("weather") || info.startsWith("_")) return "weather";
+  if (type.includes("telemetry") || info.startsWith("t#")) return "telemetry";
+  return "other";
+}
+function aprsCategoryLabel(category) {
+  switch (category) {
+    case "position":
+      return "Position";
+    case "message":
+      return "Message";
+    case "weather":
+      return "Weather";
+    case "telemetry":
+      return "Telemetry";
+    default:
+      return "Other";
+  }
+}
+function aprsAgeText(timestampMs) {
+  if (typeof timestampMs !== "number" || !Number.isFinite(timestampMs)) return "just now";
+  const seconds = Math.round(Math.max(0, Date.now() - timestampMs) / 1e3);
+  if (seconds < 5) return "just now";
+  if (seconds < 60) return `${String(seconds)}s ago`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${String(minutes)}m ago`;
+  return `${String(Math.round(minutes / 60))}h ago`;
+}
+function aprsPacketSignature(packet) {
+  return [
+    packet.srcCall ?? "",
+    packet.destCall ?? "",
+    packet.path ?? "",
+    packet.info ?? "",
+    packet.type ?? "",
+    packet.lat?.toFixed(4) ?? "",
+    packet.lon?.toFixed(4) ?? ""
+  ].join("|");
+}
+function collapseAprsDuplicates(packets) {
+  const seen = /* @__PURE__ */ new Set();
+  return packets.filter((packet) => {
+    const signature = aprsPacketSignature(packet);
+    if (seen.has(signature)) return false;
+    seen.add(signature);
+    return true;
+  });
+}
+function aprsHexBytes(bytes) {
+  if (!bytes?.length) return "--";
+  return bytes.map((byte) => byte.toString(16).toUpperCase().padStart(2, "0")).join(" ");
+}
+function renderAprsInfo(packet) {
+  if (packet.info_bytes?.length) {
+    return packet.info_bytes.map((byte) => renderAprsByte(byte)).join("");
+  }
+  return Array.from(packet.info ?? "", (character) => renderAprsCharacter(character)).join("");
+}
+function renderAprsByte(byte) {
+  return byte >= 32 && byte <= 126 ? escapeAprsCharacter(String.fromCharCode(byte)) : `<span class="aprs-byte">0x${byte.toString(16).toUpperCase().padStart(2, "0")}</span>`;
+}
+function renderAprsCharacter(character) {
+  const code = character.charCodeAt(0);
+  return code >= 32 && code <= 126 ? escapeAprsCharacter(character) : `<span class="aprs-byte">0x${code.toString(16).toUpperCase().padStart(2, "0")}</span>`;
+}
+function escapeAprsCharacter(character) {
+  if (character === "<") return "&lt;";
+  if (character === ">") return "&gt;";
+  if (character === "&") return "&amp;";
+  if (character === '"') return "&quot;";
+  return character;
+}
+var APRS_SPRITE_COLUMNS = 16;
+var APRS_SPRITE_CELL_PX = 24;
+var APRS_SPRITE_FIRST_CODE = 33;
+var APRS_SPRITE_LAST_CODE = 126;
+function aprsSpriteOffset(code) {
+  if (code.length !== 1) return null;
+  const point = code.charCodeAt(0);
+  if (point < APRS_SPRITE_FIRST_CODE || point > APRS_SPRITE_LAST_CODE) return null;
+  const index = point - APRS_SPRITE_FIRST_CODE;
+  const column = index % APRS_SPRITE_COLUMNS;
+  const row = Math.floor(index / APRS_SPRITE_COLUMNS);
+  return `${String(-column * APRS_SPRITE_CELL_PX)}px ${String(-row * APRS_SPRITE_CELL_PX)}px`;
+}
+function aprsSymbolSprite(symbolTable, symbolCode) {
+  if (!symbolTable || !symbolCode) return null;
+  const symbolOffset = aprsSpriteOffset(symbolCode);
+  if (!symbolOffset) return null;
+  if (symbolTable === "/") {
+    return {
+      className: "aprs-symbol-primary",
+      backgroundPosition: symbolOffset,
+      label: `Primary APRS symbol ${symbolTable}${symbolCode}`
+    };
+  }
+  if (symbolTable === "\\") {
+    return {
+      className: "aprs-symbol-alternate",
+      backgroundPosition: symbolOffset,
+      label: `Alternate APRS symbol ${symbolTable}${symbolCode}`
+    };
+  }
+  const overlayOffset = aprsSpriteOffset(symbolTable);
+  if (!overlayOffset) return null;
+  return {
+    className: "aprs-symbol-overlaid",
+    backgroundPosition: `${overlayOffset}, ${symbolOffset}`,
+    label: `Alternate APRS symbol \\${symbolCode} with overlay ${symbolTable}`
+  };
+}
+function renderAprsSymbolSlot(packet, escapeHtml) {
+  return renderLocalAprsSymbol(packet, escapeHtml) || '<span class="aprs-symbol aprs-symbol-empty" aria-hidden="true"></span>';
+}
+function renderLocalAprsSymbol(packet, escapeHtml) {
+  if (!packet.symbolTable || !packet.symbolCode) return "";
+  const sprite = aprsSymbolSprite(packet.symbolTable, packet.symbolCode);
+  if (sprite) {
+    return `<span class="aprs-symbol ${sprite.className}" role="img" style="background-position:${sprite.backgroundPosition}" title="${escapeHtml(sprite.label)}" aria-label="${escapeHtml(sprite.label)}"></span>`;
+  }
+  const symbol = escapeHtml(packet.symbolCode);
+  const table = packet.symbolTable === "/" ? "Primary" : "Alternate";
+  return `<span class="aprs-symbol aprs-symbol-local" title="${table} APRS symbol ${symbol}">${symbol}</span>`;
+}
+function normalizeAprsPacket(packet, receiver) {
+  return {
+    rig_id: packet.rig_id || null,
+    receiver,
+    srcCall: packet.src_call ?? "",
+    destCall: packet.dest_call ?? "",
+    path: packet.path ?? "",
+    info: packet.info ?? "",
+    info_bytes: packet.info_bytes ?? [],
+    type: packet.packet_type ?? "",
+    crcOk: packet.crc_ok ?? false,
+    ts_ms: packet.ts_ms ?? null,
+    lat: packet.lat ?? null,
+    lon: packet.lon ?? null,
+    symbolTable: packet.symbol_table ?? null,
+    symbolCode: packet.symbol_code ?? null
+  };
+}
+function fahrenheitToCelsius(fahrenheit) {
+  return Math.round((fahrenheit - 32) * 5 / 9 * 10) / 10;
+}
+function summarizeAprsWeather(info) {
+  const parts = [];
+  const temperature = /t(-?\d{2,3})/.exec(info);
+  if (temperature) parts.push(`${fahrenheitToCelsius(Number(temperature[1]))} °C`);
+  const wind = /(\d{3})\/(\d{3})/.exec(info) ?? /c(\d{3}).*?s(\d{3})/.exec(info);
+  if (wind) {
+    const gust = /g(\d{3})/.exec(info);
+    const knots = Number(wind[2]);
+    parts.push(`wind ${Number(wind[1])}° ${knots} kt${gust ? ` gust ${Number(gust[1])}` : ""}`);
+  }
+  const humidity = /h(\d{2})/.exec(info);
+  if (humidity) {
+    const value = Number(humidity[1]);
+    parts.push(`${value === 0 ? 100 : value}% RH`);
+  }
+  const pressure = /b(\d{5})/.exec(info);
+  if (pressure) parts.push(`${(Number(pressure[1]) / 10).toFixed(1)} hPa`);
+  const rain = /r(\d{3})/.exec(info);
+  if (rain && Number(rain[1]) > 0) parts.push(`rain ${(Number(rain[1]) / 100).toFixed(2)}"`);
+  return parts.length ? parts.join(" · ") : null;
+}
+function summarizeAprsTelemetry(info) {
+  const match = /^T#(\d+|MIC)((?:,-?[\d.]*)+)(?:,([01]{8}))?/.exec(info.trim());
+  if (!match?.[2]) return null;
+  const channels = match[2].split(",").filter((value) => value.length > 0);
+  const bits = match[3] ? ` · bits ${match[3]}` : "";
+  return `#${match[1]} · ${channels.join(" ")}${bits}`;
+}
+function summarizeAprsMessage(info) {
+  const match = /^:([^:]{9}):(.*)$/.exec(info);
+  if (!match?.[1] || match[2] == null) return null;
+  const addressee = match[1].trim();
+  const text = match[2].replace(/\{\d+\s*$/, "").trim();
+  return `→ ${addressee}: ${text}`;
+}
+function summarizeAprsCourseSpeed(info) {
+  const match = /(\d{3})\/(\d{3})/.exec(info);
+  if (!match) return null;
+  const knots = Number(match[2]);
+  if (knots === 0) return null;
+  return `${Number(match[1])}° ${knots} kt`;
+}
+function summarizeAprsPayload(packet) {
+  const info = packet.info ?? "";
+  if (!info) return null;
+  const category = aprsPacketCategory(packet);
+  if (category === "message") return summarizeAprsMessage(info);
+  if (category === "weather") return summarizeAprsWeather(info);
+  if (category === "telemetry") return summarizeAprsTelemetry(info);
+  if (category === "position") {
+    const parts = [];
+    if (packet.lat != null && packet.lon != null) {
+      parts.push(`${packet.lat.toFixed(4)}, ${packet.lon.toFixed(4)}`);
+    }
+    const courseSpeed = summarizeAprsCourseSpeed(info);
+    if (courseSpeed) parts.push(courseSpeed);
+    const comment = info.replace(/^[!=@/][^>]*[>_]?/, "").replace(/\d{3}\/\d{3}/, "").trim();
+    if (comment && comment.length <= 60) parts.push(comment);
+    return parts.length ? parts.join(" · ") : null;
+  }
+  const text = info.replace(/^[>;<?]/, "").trim();
+  return text.length ? text : null;
+}
+function renderAprsPacketRow(packet, options = {}) {
+  const row = document.createElement("details");
+  row.className = "aprs-packet";
+  if (!packet.crcOk) row.classList.add("aprs-packet-crc");
+  if (options.fresh) row.classList.add("aprs-packet-new");
+  const time = packet._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  const category = aprsPacketCategory(packet);
+  const summary = summarizeAprsPayload(packet);
+  const hasPosition = packet.lat != null && packet.lon != null;
+  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(packet.srcCall || "")}`;
+  row.innerHTML = `<summary class="decode-line"><span class="aprs-time">${escapeAprsHtml(time)}</span>` + (options.badge ? `<span class="aprs-badge aprs-badge-band">${escapeAprsHtml(options.badge)}</span>` : "") + renderAprsSymbolSlot(packet, escapeAprsHtml) + `<span class="aprs-call">${escapeAprsHtml(packet.srcCall ?? "")}</span><span class="aprs-badge aprs-badge-type aprs-badge-type-${category}">${escapeAprsHtml(aprsCategoryLabel(category))}</span><span class="decode-line-summary">${summary ? escapeAprsHtml(summary) : renderAprsInfo(packet)}</span>` + (packet.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC</span>') + (options.distance ? `<span class="decode-line-distance">${escapeAprsHtml(options.distance)}</span>` : "") + `</summary><div class="decode-expanded"><div class="decode-expanded-meta"><span>&gt;${escapeAprsHtml(packet.destCall || "--")}</span><span>${escapeAprsHtml(packet.path || "no path")}</span><span>${escapeAprsHtml(aprsAgeText(packet._tsMs))}</span><span>CRC ${packet.crcOk ? "ok" : "failed"}</span>` + (hasPosition ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${packet.lat},${packet.lon}">${packet.lat?.toFixed(5)}, ${packet.lon?.toFixed(5)}</a>` : "") + `</div><div class="decode-expanded-raw">${renderAprsInfo(packet)}</div>` + (packet.info_bytes?.length ? `<div class="decode-expanded-bytes">${escapeAprsHtml(aprsHexBytes(packet.info_bytes))}</div>` : "") + `<div class="aprs-row-actions">` + (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${packet.lat},${packet.lon}">Map</button>` : "") + (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${packet.lat},${packet.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div></div>`;
+  row.querySelectorAll("[data-aprs-map]").forEach((element) => {
+    element.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const [lat, lon] = (element.dataset.aprsMap ?? "").split(",").map(Number);
+      if (Number.isFinite(lat) && Number.isFinite(lon)) options.onMap?.(lat, lon);
+    });
+  });
+  const copyButton = row.querySelector("[data-aprs-copy]");
+  if (copyButton) {
+    copyButton.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      options.onCopy?.(copyButton.dataset.aprsCopy ?? "", copyButton);
+    });
+  }
+  return row;
+}
+
+export {
+  aprsPacketCategory,
+  aprsAgeText,
+  collapseAprsDuplicates,
+  aprsSymbolSprite,
+  normalizeAprsPacket,
+  renderAprsPacketRow
+};

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

@@ -1,3 +1,7 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/cw.ts
 var cwWindow = window;
 var cwStatusEl = document.getElementById("cw-status");
@@ -25,7 +29,7 @@ var cwBarCurrentLine = null;
 var cwBarDismissedAtMs = 0;
 var cwAutoLocalOverride = null;
 function escapeCwHtml(input) {
-  return cwWindow.escapeMapHtml?.(input) ?? input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+  return hostCore.escapeMapHtml(input);
 }
 function applyCwAutoUi(enabled) {
   if (cwAutoInput) cwAutoInput.checked = enabled;
@@ -246,7 +250,7 @@ async function setCwTone(tone, { syncInput = true } = {}) {
     cwToneInput.value = String(clamped);
   }
   try {
-    await cwWindow.postPath?.(`/set_cw_tone?tone_hz=${encodeURIComponent(clamped)}`);
+    await hostCore.postPath(`/set_cw_tone?tone_hz=${encodeURIComponent(clamped)}`);
   } catch (e) {
     console.error("CW tone set failed", e);
   }
@@ -259,7 +263,7 @@ if (cwAutoInput) {
       cwAutoLocalOverride = enabled;
       applyCwAutoUi(enabled);
       try {
-        await cwWindow.postPath?.(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
+        await hostCore.postPath(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
         drawCwTonePicker();
       } catch (error) {
         console.error("CW auto toggle failed", error);
@@ -276,7 +280,7 @@ if (cwWpmInput) {
       const wpm = clampCwWpm(cwWpmInput.value);
       cwWpmInput.value = String(wpm);
       try {
-        await cwWindow.postPath?.(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`);
+        await hostCore.postPath(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`);
       } catch (error) {
         console.error("CW WPM set failed", error);
       }
@@ -312,7 +316,7 @@ document.getElementById("settings-clear-cw-history")?.addEventListener("click",
   void (async () => {
     if (!await cwWindow.trxUi.confirm({ title: "Clear CW history?", message: "All stored CW decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await cwWindow.postPath?.("/clear_cw_decode");
+      await hostCore.postPath("/clear_cw_decode");
       resetCwHistoryView();
     } catch (error) {
       console.error("CW history clear failed", error);

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

@@ -1,6 +1,7 @@
 import {
   initializeFtxDecoder
-} from "./chunk-SGMG5LG2.js";
+} from "./chunk-O2Y7YEVQ.js";
+import "./chunk-KL66PICH.js";
 
 // src/plugins/ft2.ts
 initializeFtxDecoder({ id: "ft2", label: "FT2", periodMs: 3750 });

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

@@ -1,6 +1,7 @@
 import {
   initializeFtxDecoder
-} from "./chunk-SGMG5LG2.js";
+} from "./chunk-O2Y7YEVQ.js";
+import "./chunk-KL66PICH.js";
 
 // src/plugins/ft4.ts
 initializeFtxDecoder({ id: "ft4", label: "FT4", periodMs: 7500 });

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

@@ -2,7 +2,8 @@ import {
   initializeFt8FamilyBar,
   initializeFtxDecoder,
   installFtxCompatibilityHelpers
-} from "./chunk-SGMG5LG2.js";
+} from "./chunk-O2Y7YEVQ.js";
+import "./chunk-KL66PICH.js";
 
 // src/plugins/ft8.ts
 installFtxCompatibilityHelpers();

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

@@ -1,17 +1,17 @@
 import {
   aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
   aprsPacketCategory,
   collapseAprsDuplicates,
   normalizeAprsPacket,
-  renderAprsInfo,
+  renderAprsPacketRow
-  renderLocalAprsSymbol
+} from "./chunk-OPEIVJGD.js";
-} from "./chunk-M2I6DH4X.js";
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
 
 // src/plugins/hf-aprs.ts
 var hfAprsWindow = window;
-var escapeHfAprsHtml = (input) => hfAprsWindow.escapeMapHtml?.(input) ?? input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var hfAprsStatus = document.getElementById("hf-aprs-status");
 var hfAprsPacketsEl = document.getElementById("hf-aprs-packets");
 var hfAprsFilterInput = document.getElementById("hf-aprs-filter");
@@ -44,8 +44,8 @@ function scheduleHfAprsHistoryRender() {
   renderHfAprsHistory();
 }
 function hfAprsDistanceText(pkt) {
-  if (hfAprsWindow.serverLat == null || hfAprsWindow.serverLon == null || pkt.lat == null || pkt.lon == null || !hfAprsWindow.haversineKm) return "";
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
-  const distKm = hfAprsWindow.haversineKm(hfAprsWindow.serverLat, hfAprsWindow.serverLon, pkt.lat, pkt.lon);
+  const distKm = hostCore.haversineKm(hostState.serverLat, hostState.serverLon, pkt.lat, pkt.lon);
   if (!Number.isFinite(distKm)) return "";
   if (distKm < 1) return `${Math.round(distKm * 1e3)} m from TRX`;
   return `${distKm.toFixed(1)} km from TRX`;
@@ -98,51 +98,27 @@ function updateHfAprsChipState() {
   hfAprsCollapseDupBtn?.classList.toggle("active", hfAprsCollapseDup);
 }
 function renderHfAprsRow(pkt, isFresh) {
-  const row = document.createElement("div");
+  return renderAprsPacketRow(pkt, {
-  row.className = "aprs-packet";
+    fresh: isFresh,
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
+    badge: "HF",
-  if (isFresh) row.classList.add("aprs-packet-new");
+    distance: hfAprsDistanceText(pkt),
-  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    onMap: (lat, lon) => {
-  const age = aprsAgeText(pkt._tsMs);
+      hfAprsWindow.navigateToAprsMap?.(lat, lon);
-  const category = aprsPacketCategory(pkt);
+    },
-  const categoryLabel = aprsCategoryLabel(category);
+    onCopy: (text) => {
-  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
+      void copyHfAprsCoords(text);
-  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeHfAprsHtml(pkt.path)}</span>` : "";
-  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-  const hfBadge = '<span class="aprs-badge" style="background:var(--accent-alt,#f59e0b);color:#000">HF</span>';
-  const symbolHtml = renderLocalAprsSymbol(pkt, escapeHfAprsHtml);
-  const posLink = pkt.lat != null && pkt.lon != null ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>` : "";
-  const distance = hfAprsDistanceText(pkt);
-  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
-  row.innerHTML = `<div class="aprs-row-head"><span class="aprs-time">${ts}</span>` + hfBadge + symbolHtml + `<span class="aprs-call">${escapeHfAprsHtml(pkt.srcCall ?? "")}</span><span>&gt;${escapeHfAprsHtml(pkt.destCall || "")}</span><span class="${categoryClass}">${escapeHfAprsHtml(categoryLabel)}</span>` + pathBadge + crcBadge + `</div><div class="aprs-row-meta"><span class="aprs-meta-text">${escapeHfAprsHtml(age)}</span>` + (distance ? `<span class="aprs-meta-text">${escapeHfAprsHtml(distance)}</span>` : "") + `<span class="aprs-meta-text">${escapeHfAprsHtml(pkt.type || "--")}</span></div><div class="aprs-row-detail"><span title="${escapeHfAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` + (posLink ? `<span>${posLink}</span>` : "") + `</div><div class="aprs-row-actions">` + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div><details class="aprs-details"><summary>Details</summary><div class="aprs-details-grid"><span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.srcCall || "--")}</span><span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.destCall || "--")}</span><span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.type || "--")}</span><span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.path || "--")}</span><span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeHfAprsHtml(age)}</span><span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span><span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span><span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.info || "--")}</span><span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeHfAprsHtml(aprsHexBytes(pkt.info_bytes))}</span></div></details>`;
-  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
-    el.addEventListener("click", (evt) => {
-      evt.preventDefault();
-      const raw = el.dataset.aprsMap ?? "";
-      const [lat, lon] = raw.split(",").map(Number);
-      if (hfAprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
-        hfAprsWindow.navigateToAprsMap(lat, lon);
     }
   });
-  });
+}
-  const copyBtn = row.querySelector("[data-aprs-copy]");
+async function copyHfAprsCoords(text) {
-  if (copyBtn) {
-    copyBtn.addEventListener("click", () => {
-      void (async () => {
-        const raw = copyBtn.dataset.aprsCopy ?? "";
   try {
     const clipboard = Reflect.get(navigator, "clipboard");
-          if (clipboard) {
+    if (!clipboard) return;
-            await clipboard.writeText(raw);
+    await clipboard.writeText(text);
-            hfAprsWindow.showHint?.("Coordinates copied", 1200);
+    hostCore.showHint("Coordinates copied", 1200);
-          }
   } catch {
-          hfAprsWindow.showHint?.("Copy failed", 1500);
+    hostCore.showHint("Copy failed", 1500);
   }
-      })();
-    });
-  }
-  return row;
 }
 function renderHfAprsHistory() {
   pruneHfAprsPacketHistory();
@@ -201,7 +177,7 @@ hfAprsDecodeToggleBtn?.addEventListener("click", () => {
   void (async () => {
     try {
       await hfAprsWindow.takeSchedulerControlForDecoderDisable?.(hfAprsDecodeToggleBtn);
-      await hfAprsWindow.postPath?.("/toggle_hf_aprs_decode");
+      await hostCore.postPath("/toggle_hf_aprs_decode");
     } catch (e) {
       console.error("HF APRS toggle failed", e);
     }
@@ -211,7 +187,7 @@ document.getElementById("settings-clear-hf-aprs-history")?.addEventListener("cli
   void (async () => {
     if (!await hfAprsWindow.trxUi.confirm({ title: "Clear HF APRS history?", message: "All stored HF APRS packets will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await hfAprsWindow.postPath?.("/clear_hf_aprs_decode");
+      await hostCore.postPath("/clear_hf_aprs_decode");
       resetHfAprsHistoryView();
     } catch (e) {
       console.error("HF APRS history clear failed", e);

src/trx-client/trx-frontend/trx-frontend-http/assets/web/generated/leaflet-ais-tracksymbol.js

@@ -1,95 +0,0 @@
-// src/leaflet-ais-tracksymbol.ts
-(function() {
-  const leaflet = globalThis.L;
-  if (!leaflet) return;
-  function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-  }
-  function finiteAngle(value) {
-    if (value === null || !Number.isFinite(value)) return null;
-    const normalized = (value % 360 + 360) % 360;
-    return normalized;
-  }
-  function svgColor(value, fallback) {
-    const text = value || fallback || "";
-    return text.replace(/"/g, """);
-  }
-  function buildSymbolHtml(options, zoom) {
-    const heading = finiteAngle(options.heading);
-    const course = finiteAngle(options.course);
-    const angle = heading != null ? heading : course;
-    const speed = Number.isFinite(options.speed) ? Math.max(0, Number(options.speed)) : 0;
-    const sizeBase = Number.isFinite(options.size) ? options.size : 22;
-    const zoomBoost = zoom >= 12 ? 4 : zoom >= 9 ? 2 : 0;
-    const size = clamp(sizeBase + zoomBoost, 16, 32);
-    const courseLen = course != null ? clamp(size * (0.55 + Math.min(speed, 30) / 30), size * 0.55, size * 1.2) : 0;
-    const color = svgColor(options.color, "#ff7559");
-    const outline = svgColor(options.outline, "#6b2118");
-    const body = angle != null ? `<g transform="translate(${size / 2} ${size / 2}) rotate(${angle}) translate(${-size / 2} ${-size / 2})"><path d="M ${size * 0.5} ${size * 0.06} L ${size * 0.82} ${size * 0.78} L ${size * 0.5} ${size * 0.62} L ${size * 0.18} ${size * 0.78} Z" fill="${color}" stroke="${outline}" stroke-width="1.2" stroke-linejoin="round" /></g>` : `<path d="M ${size * 0.5} ${size * 0.12} L ${size * 0.88} ${size * 0.5} L ${size * 0.5} ${size * 0.88} L ${size * 0.12} ${size * 0.5} Z" fill="${color}" stroke="${outline}" stroke-width="1.2" stroke-linejoin="round" />`;
-    const courseLine = course != null ? `<g transform="translate(${size / 2} ${size / 2}) rotate(${course})"><line x1="0" y1="${-size * 0.22}" x2="0" y2="${-(size * 0.22 + courseLen)}" stroke="${color}" stroke-width="1.4" stroke-linecap="round" opacity="0.75" /></g>` : "";
-    return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" aria-hidden="true">` + courseLine + body + `</svg>`;
-  }
-  leaflet.TrxAisTrackSymbol = leaflet.Marker.extend({
-    options: {
-      heading: null,
-      course: null,
-      speed: null,
-      color: "#ff7559",
-      outline: "#6b2118",
-      size: 22,
-      interactive: true,
-      keyboard: true,
-      riseOnHover: true
-    },
-    initialize: function(latlng, options) {
-      const merged = leaflet.Util.extend({}, this.options, options || {});
-      merged.icon = leaflet.divIcon({
-        className: "trx-ais-track-symbol-icon",
-        html: "",
-        iconSize: [merged.size, merged.size],
-        iconAnchor: [merged.size / 2, merged.size / 2]
-      });
-      leaflet.Marker.prototype.initialize.call(this, latlng, merged);
-    },
-    onAdd: function(map) {
-      leaflet.Marker.prototype.onAdd.call(this, map);
-      this._refreshIcon();
-      this._boundZoomRefresh = this._refreshIcon.bind(this);
-      map.on("zoomend", this._boundZoomRefresh);
-    },
-    onRemove: function(map) {
-      if (this._boundZoomRefresh) {
-        map.off("zoomend", this._boundZoomRefresh);
-        this._boundZoomRefresh = null;
-      }
-      leaflet.Marker.prototype.onRemove.call(this, map);
-    },
-    setAisState: function(next) {
-      if ("heading" in next) this.options.heading = next.heading;
-      if ("course" in next) this.options.course = next.course;
-      if ("speed" in next) this.options.speed = next.speed;
-      if ("color" in next) this.options.color = next.color;
-      if ("outline" in next) this.options.outline = next.outline;
-      this._refreshIcon();
-      return this;
-    },
-    _refreshIcon: function() {
-      if (!this._icon) return;
-      const zoom = this._map && typeof this._map.getZoom === "function" ? this._map.getZoom() : 0;
-      const html = buildSymbolHtml(this.options, zoom);
-      this._icon.innerHTML = html;
-      const sizeBase = Number.isFinite(this.options.size) ? this.options.size : 22;
-      const zoomBoost = zoom >= 12 ? 4 : zoom >= 9 ? 2 : 0;
-      const size = clamp(sizeBase + zoomBoost, 16, 32);
-      this._icon.style.width = `${size}px`;
-      this._icon.style.height = `${size}px`;
-      this._icon.style.marginLeft = `${-size / 2}px`;
-      this._icon.style.marginTop = `${-size / 2}px`;
-    }
-  });
-  leaflet.trxAisTrackSymbol = function(latlng, options) {
-    const Constructor = leaflet.TrxAisTrackSymbol;
-    if (!Constructor) throw new Error("AIS track symbol constructor is unavailable");
-    return new Constructor(latlng, options);
-  };
-})();

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

@@ -1,3 +1,7 @@
+import {
+  aprsSymbolSprite
+} from "./chunk-OPEIVJGD.js";
+
 // src/map-core.ts
 function mapEl(id) {
   const element = document.querySelector(`#${CSS.escape(id)}`);
@@ -58,6 +62,7 @@ var mapWindow = window;
   const mapMarkers = /* @__PURE__ */ new Set();
   const DEFAULT_MAP_SOURCE_FILTER = { ais: true, vdes: true, aprs: true, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
   const mapFilter = { ...DEFAULT_MAP_SOURCE_FILTER };
+  const MAP_FILTER_ALL_KEY = "__all";
   const mapLocatorFilter = { phase: "band", bands: /* @__PURE__ */ new Set() };
   let mapSearchFilter = "";
   let mapRigFilter = "";
@@ -834,38 +839,36 @@ var mapWindow = window;
       container.innerHTML = `<span class="map-locator-empty">No ${kind === "band" ? "bands" : "sources"} available</span>`;
       return;
     }
-    let helperText = "";
+    const noun = kind === "band" ? "bands" : "sources";
     const sourceKeys = kind === "source" ? Object.keys(DEFAULT_MAP_SOURCE_FILTER) : [];
-    const noneSelected = kind === "source" && sourceKeys.every((k) => !mapFilter[k]);
+    const showingAll = kind === "source" ? sourceKeys.every((k) => !mapFilter[k]) : !(selectedSet instanceof Set) || selectedSet.size === 0;
-    if (kind === "source") {
+    const allChip = document.createElement("button");
-      if (noneSelected) {
+    allChip.type = "button";
-        helperText = "All sources visible — click to filter";
+    allChip.className = "map-locator-chip map-locator-chip-all";
-      }
+    if (showingAll) allChip.classList.add("is-active");
-    } else if (!(selectedSet instanceof Set) || selectedSet.size === 0) {
+    allChip.dataset.filterKind = kind;
-      helperText = `All ${kind === "band" ? "bands" : "sources"} visible by default`;
+    allChip.dataset.filterKey = MAP_FILTER_ALL_KEY;
-    }
+    allChip.setAttribute("aria-pressed", showingAll ? "true" : "false");
+    allChip.title = showingAll ? `All ${noun} shown` : `Show all ${noun}`;
+    allChip.innerHTML = `<span class="map-locator-chip-text">All</span>`;
+    container.appendChild(allChip);
     for (const item of items) {
       const btn = document.createElement("button");
       btn.type = "button";
       btn.className = "map-locator-chip";
       const isActive = kind === "source" ? !!mapFilter[item.key] : !!selectedSet?.has(item.key);
-      if (kind === "source" && noneSelected) {
+      if (showingAll) {
         btn.classList.add("is-default");
       } else if (!isActive) {
         btn.classList.add("is-inactive");
       }
+      btn.setAttribute("aria-pressed", !showingAll && isActive ? "true" : "false");
       btn.dataset.filterKind = kind;
       btn.dataset.filterKey = item.key;
       btn.style.setProperty("--chip-color", item.color);
       btn.innerHTML = `<span class="map-locator-chip-text">${escapeMapHtml(item.label)}</span>`;
       container.appendChild(btn);
     }
-    if (helperText) {
-      const hint = document.createElement("span");
-      hint.className = "map-locator-empty";
-      hint.textContent = helperText;
-      container.appendChild(hint);
-    }
   }
   function renderMapLocatorPhaseRow(container, phase) {
     if (!container) return;
@@ -973,11 +976,10 @@ var mapWindow = window;
     renderMapLocatorLegend(mapLocatorFilter.phase, sourceItems, bandItems);
     if (!phaseEl || !choiceEl || !choiceLabelEl) return;
     renderMapLocatorPhaseRow(phaseEl, mapLocatorFilter.phase);
+    choiceLabelEl.textContent = "Show";
     if (mapLocatorFilter.phase === "band") {
-      choiceLabelEl.textContent = "Visible Bands";
       renderMapLocatorChipRow(choiceEl, bandItems, mapLocatorFilter.bands, "band");
     } else {
-      choiceLabelEl.textContent = "Visible Sources";
       renderMapLocatorChipRow(choiceEl, sourceItems, null, "source");
     }
     syncLocatorMarkerStyles();
@@ -1331,7 +1333,8 @@ var mapWindow = window;
   function applyMapOverlayPanelVisibility() {
     const panel = document.querySelector("#map-stage .map-overlay-panel");
     if (!panel) return;
-    panel.classList.toggle("is-hidden", !mapOverlayPanelVisible);
+    panel.classList.toggle("filters-hidden", !mapOverlayPanelVisible);
+    panel.querySelector(".map-overlay-filters")?.classList.toggle("is-hidden", !mapOverlayPanelVisible);
   }
   function updateMapOverlayToggleButton() {
     const btn = mapEl("map-overlay-toggle-btn");
@@ -1528,7 +1531,13 @@ var mapWindow = window;
         const kind = String(chip.dataset.filterKind || "");
         const key = String(chip.dataset.filterKey || "");
         if (!key) return;
-        if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
+        if (key === MAP_FILTER_ALL_KEY) {
+          if (kind === "source") {
+            for (const srcKey of Object.keys(DEFAULT_MAP_SOURCE_FILTER)) mapFilter[srcKey] = false;
+          } else {
+            mapLocatorFilter.bands.clear();
+          }
+        } else if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
           const sourceKey = key;
           mapFilter[sourceKey] = !mapFilter[sourceKey];
           const srcKeys = Object.keys(DEFAULT_MAP_SOURCE_FILTER);
@@ -1643,42 +1652,29 @@ var mapWindow = window;
       return;
     }
     const mapRect = mapContainer.getBoundingClientRect();
-    const width = mapContainer.clientWidth || mapRect.width;
     const footer = document.querySelector(".footer");
-    let bottom = mapIsFullscreen() && stage ? stage.getBoundingClientRect().bottom : window.innerHeight;
+    let bottom = window.innerHeight;
-    if (!mapIsFullscreen() && footer) {
+    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 target = Math.max(0, Math.floor(bottom - mapRect.top - 8));
-    const widthDriven = width > 0 ? Math.floor(width / 1.55) : available;
-    const viewportCap = mapIsFullscreen() ? Math.floor(window.innerHeight * 0.9) : Math.floor(window.innerHeight * 0.75);
-    const minHeight = Math.min(260, available);
-    const target = Math.max(minHeight, Math.min(available, viewportCap, widthDriven));
     mapContainer.style.height = `${target}px`;
     if (aprsMap) aprsMap.invalidateSize();
   }
   function aprsSymbolIcon(symbolTable, symbolCode) {
     if (!symbolTable || !symbolCode) return null;
-    const table = symbolTable === "/" ? "primary" : "alternate";
+    const sprite = aprsSymbolSprite(symbolTable, symbolCode);
+    const html = sprite ? `<div class="aprs-symbol aprs-symbol-marker ${sprite.className}" role="img" style="background-position:${sprite.backgroundPosition}" title="${escapeMapHtml(sprite.label)}" aria-label="${escapeMapHtml(sprite.label)}"></div>` : `<div class="aprs-symbol aprs-symbol-marker aprs-symbol-local" title="${symbolTable === "/" ? "primary" : "alternate"} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`;
     return L.divIcon({
       className: "",
-      html: `<div class="aprs-symbol-local" title="${table} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`,
+      html,
       iconSize: [24, 24],
       iconAnchor: [12, 12],
       popupAnchor: [0, -12]
     });
   }
-  mapWindow.navigateToAprsMap = function(lat, lon) {
+  function focusMapPosition(lat, lon) {
-    T._activeTab = "map";
-    document.querySelectorAll(".tab-bar .tab").forEach((t) => {
-      t.classList.remove("active");
-    });
-    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
-    if (mapTabBtn) mapTabBtn.classList.add("active");
-    document.querySelectorAll(".tab-panel").forEach((p) => p.style.display = "none");
-    const mapPanel = mapEl("tab-map");
-    if (mapPanel) mapPanel.style.display = "";
     initAprsMap();
     sizeAprsMapToViewport();
     if (aprsMap) {
@@ -1690,19 +1686,10 @@ var mapWindow = window;
         });
       });
     }
-  };
+  }
-  mapWindow.navigateToMapLocator = function(grid, preferredType = null) {
+  function focusMapLocator(grid, preferredType = null) {
     const normalizedGrid = String(grid || "").trim().toUpperCase();
     if (!/^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalizedGrid)) return false;
-    T._activeTab = "map";
-    document.querySelectorAll(".tab-bar .tab").forEach((t) => {
-      t.classList.remove("active");
-    });
-    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
-    if (mapTabBtn) mapTabBtn.classList.add("active");
-    document.querySelectorAll(".tab-panel").forEach((p) => p.style.display = "none");
-    const mapPanel = mapEl("tab-map");
-    if (mapPanel) mapPanel.style.display = "";
     initAprsMap();
     sizeAprsMapToViewport();
     if (!aprsMap) return false;
@@ -1747,7 +1734,7 @@ var mapWindow = window;
       requestAnimationFrame(focusMarker);
     });
     return true;
-  };
+  }
   function buildReceiverPopupHtml(rigIds) {
     const call = T.serverCallsign || T.ownerCallsign || "Receiver";
     let meta = "";
@@ -2165,14 +2152,16 @@ var mapWindow = window;
   function updateMapContactPathsToggle() {
     const btn = mapEl("map-contact-paths-toggle");
     if (!btn) return;
-    btn.textContent = mapDecodeContactPathsEnabled ? "Contact Paths On" : "Contact Paths Off";
     btn.classList.toggle("is-active", mapDecodeContactPathsEnabled);
+    btn.setAttribute("aria-pressed", mapDecodeContactPathsEnabled ? "true" : "false");
+    btn.title = mapDecodeContactPathsEnabled ? "Directed decode paths are drawn when the target locator is known" : "Directed decode paths are hidden";
   }
   function updateMapP2pPathsToggle() {
     const btn = mapEl("map-p2p-paths-toggle");
     if (!btn) return;
-    btn.textContent = mapP2pRadioPathsEnabled ? "TRX Paths On" : "TRX Paths Off";
     btn.classList.toggle("is-active", mapP2pRadioPathsEnabled);
+    btn.setAttribute("aria-pressed", mapP2pRadioPathsEnabled ? "true" : "false");
+    btn.title = mapP2pRadioPathsEnabled ? "TRX paths are drawn from a station popup" : "TRX paths are hidden";
   }
   function scheduleDecodeMapMaintenance() {
     if (C.decodeHistoryMapRenderingDeferred()) {
@@ -2332,7 +2321,7 @@ var mapWindow = window;
         selectedMapQsoKey = selectedMapQsoKey === entry.pathKey ? null : entry.pathKey ?? null;
         syncDecodeContactPathVisibility();
         if (selectedMapQsoKey && entry.sourceGrid) {
-          mapWindow.navigateToMapLocator?.(entry.sourceGrid, entry.sourceType);
+          focusMapLocator(entry.sourceGrid, entry.sourceType);
         }
       });
       const head = document.createElement("div");
@@ -2438,7 +2427,7 @@ var mapWindow = window;
       card.className = "map-qso-card";
       if (entry.grid) {
         card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
         });
       }
       const head = document.createElement("div");
@@ -2544,7 +2533,7 @@ var mapWindow = window;
       card.className = "map-qso-card";
       if (entry.grid) {
         card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
         });
       }
       const head = document.createElement("div");
@@ -3049,6 +3038,8 @@ var mapWindow = window;
   }
   modules.map = {
     initAprsMap,
+    focusMapPosition,
+    focusMapLocator,
     sizeAprsMapToViewport,
     syncAprsReceiverMarker,
     updateMapRigFilter,
@@ -3109,5 +3100,6 @@ var mapWindow = window;
     bandForHz,
     reverseGeocodeLocation
   };
+  window.trxPluginRuntime.syncMapAll();
   autoInitIfVisible();
 })();

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

@@ -1,45 +0,0 @@
-"use strict";
-const pluginGroups = {
-  "digital-modes": ["/ft8.js", "/ft4.js", "/ft2.js", "/wspr.js", "/cw.js", "/background-decode.js", "/sat.js", "/wefax.js"],
-  "map-data": ["/map-core.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js"],
-  map: ["/map-core.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js", "/sat.js", "/sat-scheduler.js"],
-  statistics: ["/map-core.js"],
-  bookmarks: ["/bookmarks.js"],
-  recorder: [],
-  settings: ["/vchan.js", "/scheduler.js"]
-};
-const loaded = /* @__PURE__ */ new Set();
-const loading = /* @__PURE__ */ new Map();
-async function loadPlugin(path) {
-  if (loaded.has(path)) return;
-  const pending = loading.get(path);
-  if (pending) return pending;
-  const request = import(path).then(() => {
-    loaded.add(path);
-    loading.delete(path);
-  }).catch((error) => {
-    loading.delete(path);
-    throw new Error(`Failed to load plugin module: ${path}`, { cause: error });
-  });
-  loading.set(path, request);
-  return request;
-}
-async function loadPlugins(group) {
-  if (!(group in pluginGroups)) return;
-  for (const path of pluginGroups[group]) await loadPlugin(path);
-}
-function requestPlugins(group) {
-  void loadPlugins(group).catch((error) => {
-    console.error(error);
-  });
-}
-const loaderWindow = window;
-loaderWindow.loadEagerPlugins = async () => {
-  await Promise.all(["digital-modes", "map-data", "bookmarks", "settings"].map(loadPlugins));
-};
-loaderWindow.loadPluginsForTab = loadPlugins;
-document.addEventListener("click", (event) => {
-  if (!(event.target instanceof Element)) return;
-  const tab = event.target.closest("[data-tab]")?.dataset.tab;
-  if (tab) requestPlugins(tab);
-});

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

@@ -1,80 +0,0 @@
-"use strict";
-const decoders = /* @__PURE__ */ new Map();
-const queued = /* @__PURE__ */ new Map();
-const MAX_QUEUED_ACTIONS_PER_DECODER = 512;
-function enqueue(id, action) {
-  const actions = queued.get(id) ?? [];
-  actions.push(action);
-  if (actions.length > MAX_QUEUED_ACTIONS_PER_DECODER) actions.splice(0, actions.length - MAX_QUEUED_ACTIONS_PER_DECODER);
-  queued.set(id, actions);
-}
-function deliver(plugin, action) {
-  if (action.kind === "message" && plugin.onMessage) {
-    plugin.onMessage(action.payload);
-    return true;
-  }
-  if (action.kind === "batch" && plugin.onBatch) {
-    plugin.onBatch(action.payload);
-    return true;
-  }
-  if (action.kind === "restore" && plugin.restore) {
-    plugin.restore(action.payload);
-    return true;
-  }
-  return false;
-}
-function dispatchOrQueue(id, action) {
-  const plugin = decoders.get(id);
-  if (!plugin) {
-    enqueue(id, action);
-    return false;
-  }
-  if (!deliver(plugin, action)) {
-    if (action.kind === "batch" && plugin.onMessage) {
-      for (const message of action.payload) plugin.onMessage(message);
-      return true;
-    }
-    if (action.kind === "restore" && plugin.onBatch) {
-      plugin.onBatch(action.payload);
-      return true;
-    }
-    return false;
-  }
-  return true;
-}
-const runtime = {
-  registerDecoder(plugin) {
-    if (decoders.has(plugin.id)) throw new Error(`Decoder plugin already registered: ${plugin.id}`);
-    const erased = plugin;
-    decoders.set(plugin.id, erased);
-    const pending = queued.get(plugin.id) ?? [];
-    queued.delete(plugin.id);
-    for (const action of pending) deliver(erased, action);
-    return () => {
-      if (decoders.get(plugin.id) === erased) decoders.delete(plugin.id);
-    };
-  },
-  dispatch: (id, message) => dispatchOrQueue(id, { kind: "message", payload: message }),
-  dispatchBatch: (id, messages) => dispatchOrQueue(id, { kind: "batch", payload: messages }),
-  restore: (id, messages) => dispatchOrQueue(id, { kind: "restore", payload: messages }),
-  reset(id) {
-    const plugin = decoders.get(id);
-    if (!plugin?.reset) return false;
-    plugin.reset();
-    return true;
-  },
-  resetAll() {
-    for (const plugin of decoders.values()) plugin.reset?.();
-  },
-  prune(id) {
-    const plugin = decoders.get(id);
-    if (!plugin?.prune) return false;
-    plugin.prune();
-    return true;
-  },
-  clearQueued() {
-    queued.clear();
-  },
-  hasDecoder: (id) => decoders.has(id)
-};
-window.trxPluginRuntime = runtime;

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

@@ -1,3 +1,7 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/sat.ts
 var satWindow = window;
 var satDom = {
@@ -243,7 +247,7 @@ lrptDecodeToggleBtn?.addEventListener("click", () => {
   void (async () => {
     try {
       await satWindow.takeSchedulerControlForDecoderDisable?.(lrptDecodeToggleBtn);
-      await satWindow.postPath?.("/toggle_lrpt_decode");
+      await hostCore.postPath("/toggle_lrpt_decode");
     } catch (e) {
       console.error("LRPT toggle failed", e);
     }
@@ -264,7 +268,7 @@ document.getElementById("settings-clear-sat-history")?.addEventListener("click",
   void (async () => {
     if (!await satWindow.trxUi.confirm({ title: "Clear satellite history?", message: "All stored satellite decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await satWindow.postPath?.("/clear_lrpt_decode");
+      await hostCore.postPath("/clear_lrpt_decode");
       resetSatHistoryView();
     } catch (e) {
       console.error("Weather satellite history clear failed", e);

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

@@ -1,3 +1,7 @@
+import {
+  hostState
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/scheduler.ts
 var schedulerWindow = window;
 var wiredElements = /* @__PURE__ */ new WeakSet();
@@ -6,6 +10,9 @@ function schedulerEl(id) {
   if (!element) throw new Error(`Missing scheduler element #${id}`);
   return element;
 }
+function schedulerOptionalEl(id) {
+  return document.getElementById(id);
+}
 (function() {
   "use strict";
   let schedulerRole = null;
@@ -359,8 +366,8 @@ function schedulerEl(id) {
     renderSatelliteSection();
     if (mode === "grayline" && currentConfig && currentConfig.grayline) {
       const gl = currentConfig.grayline;
-      const lat = gl.lat ?? schedulerWindow.serverLat ?? "";
+      const lat = gl.lat ?? hostState.serverLat ?? "";
-      const lon = gl.lon ?? schedulerWindow.serverLon ?? "";
+      const lon = gl.lon ?? hostState.serverLon ?? "";
       setInputValue("scheduler-gl-lat", lat != null ? lat : "");
       setInputValue("scheduler-gl-lon", lon != null ? lon : "");
       const gridEl = schedulerEl("scheduler-gl-grid");
@@ -373,8 +380,8 @@ function schedulerEl(id) {
       renderBookmarkSelect("scheduler-gl-dusk", gl.dusk_bookmark_id);
       renderBookmarkSelect("scheduler-gl-night", gl.night_bookmark_id);
     } else if (mode === "grayline") {
-      const lat = schedulerWindow.serverLat ?? "";
+      const lat = hostState.serverLat ?? "";
-      const lon = schedulerWindow.serverLon ?? "";
+      const lon = hostState.serverLon ?? "";
       setInputValue("scheduler-gl-lat", lat != null ? lat : "");
       setInputValue("scheduler-gl-lon", lon != null ? lon : "");
       const gridEl2 = schedulerEl("scheduler-gl-grid");
@@ -624,7 +631,7 @@ function schedulerEl(id) {
     return '<line class="sch-timeline-needle" x1="' + x.toFixed(1) + '" y1="2" x2="' + x.toFixed(1) + '" y2="38" /><polygon class="sch-timeline-needle-head" points="' + (x - 3).toFixed(1) + ",2 " + (x + 3).toFixed(1) + ",2 " + x.toFixed(1) + ',6" />';
   }
   function renderTimelineNeedle() {
-    const g = schedulerEl("sch-timeline-needle-g");
+    const g = schedulerOptionalEl("sch-timeline-needle-g");
     if (g) g.innerHTML = timelineNeedleSvg();
   }
   function schInlineEdit(tr, entry, idx) {
@@ -1213,8 +1220,8 @@ function schedulerEl(id) {
     markDirty: markSchedulerDirty
   };
   schedulerWindow.trx.modules.scheduler = schedulerService;
-  if (schedulerWindow.authRole != null) {
+  if (hostState.authRole != null) {
-    initScheduler(schedulerWindow.lastActiveRigId ?? null, schedulerWindow.authRole);
+    initScheduler(hostState.lastActiveRigId, hostState.authRole);
     wireSchedulerEvents();
   }
 })();

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

@@ -1,5 +1,5 @@
-"use strict";
+// src/screenshot.ts
-const screenshotWindow = window;
+var screenshotWindow = window;
 (function() {
   "use strict";
   const T = screenshotWindow.trx;

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

@@ -1,360 +0,0 @@
-"use strict";
-const browserWindow = window;
-const preparedTabLists = /* @__PURE__ */ new WeakSet();
-function elementById(id) {
-  const element = document.getElementById(id);
-  if (!element) throw new Error(`Missing required UI element #${id}`);
-  return element;
-}
-(function initUiCore() {
-  const api = browserWindow.trxUi ?? {};
-  browserWindow.trxUi = api;
-  function ensureLiveRegions() {
-    if (!document.getElementById("toast-region")) {
-      const region = document.createElement("div");
-      region.id = "toast-region";
-      region.className = "toast-region";
-      region.setAttribute("aria-live", "polite");
-      region.setAttribute("aria-atomic", "false");
-      document.body.appendChild(region);
-    }
-    if (!document.getElementById("ui-confirm-dialog")) {
-      const dialog = document.createElement("dialog");
-      dialog.id = "ui-confirm-dialog";
-      dialog.className = "ui-dialog";
-      dialog.innerHTML = `
-        <form method="dialog" class="ui-dialog-card">
-          <h2 id="ui-confirm-title">Confirm action</h2>
-          <p id="ui-confirm-message"></p>
-          <div class="ui-dialog-actions">
-            <button value="cancel" type="submit">Cancel</button>
-            <button value="confirm" type="submit" class="danger">Confirm</button>
-          </div>
-        </form>`;
-      document.body.appendChild(dialog);
-    }
-  }
-  api.notify = function notify(message, options = {}) {
-    ensureLiveRegions();
-    const { kind = "info", duration = kind === "error" ? 7e3 : 3200, action = null } = options;
-    const toast = document.createElement("div");
-    toast.className = `toast toast-${kind}`;
-    toast.setAttribute("role", kind === "error" ? "alert" : "status");
-    const text = document.createElement("span");
-    text.textContent = message;
-    toast.appendChild(text);
-    if (action && typeof action.run === "function") {
-      const button = document.createElement("button");
-      button.type = "button";
-      button.textContent = action.label || "Retry";
-      button.addEventListener("click", () => {
-        action.run();
-        toast.remove();
-      });
-      toast.appendChild(button);
-    }
-    elementById("toast-region").appendChild(toast);
-    requestAnimationFrame(() => {
-      toast.classList.add("toast-visible");
-    });
-    if (duration > 0) setTimeout(() => {
-      toast.remove();
-    }, duration);
-    return toast;
-  };
-  api.confirm = function confirmAction(options = {}) {
-    ensureLiveRegions();
-    const dialog = elementById("ui-confirm-dialog");
-    elementById("ui-confirm-title").textContent = options.title || "Confirm action";
-    elementById("ui-confirm-message").textContent = options.message || "Continue?";
-    const confirmButton = dialog.querySelector('[value="confirm"]');
-    if (!confirmButton) throw new Error("Confirmation dialog has no confirm button");
-    confirmButton.textContent = options.confirmLabel || "Confirm";
-    confirmButton.classList.toggle("danger", options.danger !== false);
-    return new Promise((resolve) => {
-      const finish = () => {
-        resolve(dialog.returnValue === "confirm");
-      };
-      dialog.addEventListener("close", finish, { once: true });
-      dialog.showModal();
-    });
-  };
-  api.setButtonState = function setButtonState(button, options = {}) {
-    if (!button) return;
-    const { active = false, activeLabel, inactiveLabel, busy = false, disabled = false } = options;
-    button.classList.toggle("is-active", active);
-    button.classList.toggle("is-busy", busy);
-    button.setAttribute("aria-pressed", String(active));
-    button.setAttribute("aria-busy", String(busy));
-    button.disabled = disabled || busy;
-    const label = active ? activeLabel : inactiveLabel;
-    if (label) button.textContent = label;
-  };
-  api.prepareTabList = function prepareTabList(bar, kind = "primary") {
-    if (!bar) return;
-    if (preparedTabLists.has(bar)) return;
-    preparedTabLists.add(bar);
-    const selector = kind === "primary" ? ".tab[data-tab]" : ".sub-tab[data-subtab]";
-    const buttons = Array.from(bar.querySelectorAll(selector));
-    bar.setAttribute("role", "tablist");
-    buttons.forEach((button, index) => {
-      button.setAttribute("role", "tab");
-      button.setAttribute("aria-selected", String(button.classList.contains("active")));
-      button.tabIndex = button.classList.contains("active") || !buttons.some((b) => b.classList.contains("active")) && index === 0 ? 0 : -1;
-      const key = button.dataset.tab || button.dataset.subtab;
-      if (!key) return;
-      button.setAttribute("aria-controls", `${kind === "primary" ? "tab-" : "subtab-"}${key}`);
-      const panel = document.getElementById(`${kind === "primary" ? "tab-" : "subtab-"}${key}`);
-      if (panel) {
-        if (!button.id) button.id = `${kind}-tab-${key}`;
-        panel.setAttribute("role", "tabpanel");
-        panel.setAttribute("aria-labelledby", button.id);
-      }
-    });
-    bar.addEventListener("keydown", (event) => {
-      if (!(event.target instanceof HTMLElement) || !buttons.includes(event.target)) return;
-      const direction = event.key === "ArrowRight" || event.key === "ArrowDown" ? 1 : event.key === "ArrowLeft" || event.key === "ArrowUp" ? -1 : 0;
-      if (!direction) return;
-      event.preventDefault();
-      const next = buttons[(buttons.indexOf(event.target) + direction + buttons.length) % buttons.length];
-      if (!next) return;
-      next.focus();
-      next.click();
-    });
-  };
-  api.syncSelectedTab = function syncSelectedTab(bar, selected) {
-    if (!bar) return;
-    bar.querySelectorAll('[role="tab"]').forEach((tab) => {
-      const active = tab === selected;
-      tab.setAttribute("aria-selected", String(active));
-      tab.tabIndex = active ? 0 : -1;
-    });
-  };
-  const layouts = {
-    compact: { label: "Compact", advanced: false, audio: false, scheduler: false, preferredTab: "main" },
-    broadcast: { label: "Broadcast", unavailable: "Broadcast requires an enumerated WFM-capable receiver", advanced: false, audio: true, scheduler: false, preferredTab: "main", capability: "broadcast" },
-    digital: { label: "Digital", unavailable: "Digital requires a compatible rig mode and an available decoder", advanced: false, audio: false, scheduler: false, preferredTab: "digital-modes", capability: "digital" },
-    full: { label: "Full controls", advanced: true, audio: true, scheduler: true, preferredTab: "main" }
-  };
-  const layoutCapabilities = { broadcast: false, digital: false };
-  let activeRigId = null;
-  function layoutStorageKey() {
-    return activeRigId ? `trxOperatorLayout:${activeRigId}` : "trxOperatorLayout";
-  }
-  function savedLayoutName() {
-    return localStorage.getItem(layoutStorageKey()) || localStorage.getItem("trxOperatorLayout") || "compact";
-  }
-  function layoutAvailable(layout) {
-    return !layout.capability || layoutCapabilities[layout.capability];
-  }
-  function unavailableLayoutMessage() {
-    const unavailable = Object.values(layouts).filter((layout) => !layoutAvailable(layout) && layout.unavailable);
-    return unavailable.length ? `Unavailable: ${unavailable.map((layout) => layout.unavailable).join("; ")}.` : "";
-  }
-  function refreshLayoutOptions() {
-    const select = document.getElementById("operator-layout-select");
-    if (!select) return;
-    const previous = select.value || document.body.dataset.operatorLayout || "compact";
-    select.replaceChildren();
-    Object.entries(layouts).forEach(([value, layout]) => {
-      if (!layoutAvailable(layout)) return;
-      select.add(new Option(layout.label, value));
-    });
-    const available = Array.from(select.options).some((option) => option.value === previous);
-    select.value = available ? previous : "compact";
-    if (!available && previous !== "compact") api.applyLayout("compact", { persist: false });
-    select.title = unavailableLayoutMessage();
-  }
-  api.setLayoutCapabilities = function setLayoutCapabilities(capabilities = {}) {
-    Object.keys(layoutCapabilities).forEach((name) => {
-      if (name in capabilities) layoutCapabilities[name] = Boolean(capabilities[name]);
-    });
-    refreshLayoutOptions();
-    const select = document.getElementById("operator-layout-select");
-    const saved = savedLayoutName();
-    if (select && Array.from(select.options).some((option) => option.value === saved)) {
-      select.value = saved;
-      api.applyLayout(saved, { persist: false });
-    }
-  };
-  api.setActiveRig = function setActiveRig(rigId) {
-    activeRigId = typeof rigId === "string" && rigId ? rigId : null;
-    const saved = savedLayoutName();
-    const select = document.getElementById("operator-layout-select");
-    if (select) select.value = Array.from(select.options).some((option) => option.value === saved) ? saved : "compact";
-    api.applyLayout(select?.value || saved, { persist: false });
-  };
-  api.applyLayout = function applyLayout(name, options = {}) {
-    const requestedName = name in layouts ? name : "compact";
-    const requestedLayout = layouts[requestedName];
-    const permittedName = layoutAvailable(requestedLayout) ? requestedName : "compact";
-    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;
-    if (options.navigate && typeof browserWindow.navigateToTab === "function") {
-      browserWindow.navigateToTab(layout.preferredTab);
-    }
-  };
-  function installLayoutControls() {
-    const actions = document.querySelector(".top-bar-actions");
-    if (actions && !document.getElementById("operator-layout-select")) {
-      const label = document.createElement("label");
-      label.className = "operator-layout-picker";
-      label.innerHTML = '<span class="visually-hidden">Operator layout</span><select id="operator-layout-select" aria-label="Operator layout"></select>';
-      const select = label.querySelector("select");
-      if (!select) throw new Error("Operator layout picker has no select element");
-      const savedLayout = savedLayoutName();
-      actions.insertBefore(label, actions.firstChild);
-      select.value = savedLayout;
-      refreshLayoutOptions();
-      if (savedLayout !== "broadcast" && savedLayout in layouts) select.value = savedLayout;
-      select.addEventListener("change", () => {
-        api.applyLayout(select.value, { navigate: true });
-      });
-      api.applyLayout(select.value);
-    }
-    const tray = document.querySelector(".controls-tray");
-    if (tray && !document.getElementById("advanced-radio-controls")) {
-      const details = document.createElement("details");
-      details.id = "advanced-radio-controls";
-      details.className = "advanced-radio-controls";
-      details.innerHTML = '<summary>Advanced radio controls</summary><div class="advanced-radio-body"></div>';
-      const body = details.querySelector(".advanced-radio-body");
-      if (!body) throw new Error("Advanced controls have no body");
-      ["sdr-settings-row", "vchan-row", "tx-limit-row"].forEach((id) => {
-        const element = document.getElementById(id);
-        if (element) body.appendChild(element);
-      });
-      tray.appendChild(details);
-      api.applyLayout(savedLayoutName(), { persist: false });
-    }
-  }
-  function installMobileMore() {
-    const nav = document.querySelector(".tab-bar-nav");
-    if (!nav || document.getElementById("mobile-more-btn")) return;
-    const more = document.createElement("button");
-    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.setAttribute("aria-haspopup", "menu");
-    more.setAttribute("aria-expanded", "false");
-    const menu = document.createElement("div");
-    menu.id = "mobile-more-menu";
-    menu.className = "mobile-more-menu";
-    menu.setAttribute("role", "menu");
-    more.setAttribute("aria-controls", menu.id);
-    const closeMore = (restoreFocus = false) => {
-      if (!menu.classList.contains("is-open")) return;
-      menu.classList.remove("is-open");
-      more.setAttribute("aria-expanded", "false");
-      if (restoreFocus) more.focus();
-    };
-    api.closeMobileOverlays = closeMore;
-    ["statistics", "recorder", "settings", "about"].forEach((tabName) => {
-      const source = nav.querySelector(`[data-tab="${tabName}"]`);
-      if (!source) return;
-      const item = document.createElement("button");
-      item.type = "button";
-      item.setAttribute("role", "menuitem");
-      item.dataset.navigateTab = tabName;
-      item.textContent = source.textContent.trim();
-      item.addEventListener("click", () => {
-        if (typeof browserWindow.navigateToTab === "function") browserWindow.navigateToTab(tabName);
-        closeMore();
-      });
-      menu.appendChild(item);
-    });
-    more.addEventListener("click", () => {
-      const open = menu.classList.toggle("is-open");
-      more.setAttribute("aria-expanded", String(open));
-      if (open) menu.querySelector('[role="menuitem"]')?.focus();
-    });
-    document.addEventListener("click", (event) => {
-      if (!(event.target instanceof Node) || !menu.contains(event.target) && !more.contains(event.target)) closeMore();
-    });
-    document.addEventListener("keydown", (event) => {
-      if (event.key === "Escape") closeMore(true);
-    });
-    window.addEventListener("resize", () => {
-      closeMore();
-    });
-    window.addEventListener("popstate", () => {
-      closeMore();
-    });
-    nav.append(more, menu);
-  }
-  function installDecoderPicker() {
-    const bar = document.querySelector("#tab-digital-modes > .sub-tab-bar");
-    if (!bar || document.getElementById("decoder-tab-select")) return;
-    const select = document.createElement("select");
-    select.id = "decoder-tab-select";
-    select.className = "decoder-tab-select";
-    select.setAttribute("aria-label", "Decoder view");
-    const groups = [
-      ["Overview", ["overview"]],
-      ["Marine & packet", ["ais", "vdes", "aprs", "hf-aprs"]],
-      ["Weak signal", ["cw", "ft8", "ft4", "ft2", "wspr"]],
-      ["Broadcast & images", ["rds", "sat", "wefax"]]
-    ];
-    groups.forEach(([label, ids]) => {
-      const group = document.createElement("optgroup");
-      group.label = label;
-      ids.forEach((id) => {
-        const button = bar.querySelector(`[data-subtab="${id}"]`);
-        if (button) group.appendChild(new Option(button.textContent.trim(), id));
-      });
-      select.appendChild(group);
-    });
-    select.addEventListener("change", () => bar.querySelector(`[data-subtab="${select.value}"]`)?.click());
-    bar.insertAdjacentElement("afterend", select);
-  }
-  function installDecoderBadges() {
-    const bar = document.querySelector("#tab-digital-modes > .sub-tab-bar");
-    if (!bar) return;
-    bar.querySelectorAll(".sub-tab[data-subtab]").forEach((button) => {
-      const id = button.dataset.subtab;
-      if (!id) return;
-      if (id === "overview" || button.querySelector(".decoder-state-dot")) return;
-      const dot = document.createElement("span");
-      dot.className = "decoder-state-dot";
-      dot.setAttribute("aria-hidden", "true");
-      button.appendChild(dot);
-      const status = document.getElementById(`${id}-status`);
-      if (!status) return;
-      const sync = () => {
-        const value = status.textContent.toLowerCase();
-        const state = /receiv|decod|connected|listening/.test(value) ? "active" : /error|fail|disconnected/.test(value) ? "error" : "idle";
-        dot.dataset.state = state;
-        button.title = `${button.childNodes[0]?.textContent?.trim() || id}: ${status.textContent.trim()}`;
-      };
-      new MutationObserver(sync).observe(status, { childList: true, characterData: true, subtree: true });
-      sync();
-    });
-  }
-  api.init = function init() {
-    ensureLiveRegions();
-    installLayoutControls();
-    installMobileMore();
-    installDecoderPicker();
-    installDecoderBadges();
-    api.prepareTabList(document.querySelector(".tab-bar-nav"), "primary");
-    document.querySelectorAll(".sub-tab-bar").forEach((bar) => {
-      api.prepareTabList(bar, "secondary");
-    });
-    window.addEventListener("unhandledrejection", (event) => {
-      const message = event.reason instanceof Error ? event.reason.message : "An operation failed unexpectedly";
-      api.notify(message, { kind: "error" });
-    });
-  };
-  if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", () => {
-    api.init();
-  }, { once: true });
-  else api.init();
-})();

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

@@ -1,3 +1,8 @@
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/vchan.ts
 var vchanWindow = window;
 var vchanSessionId = null;
@@ -63,7 +68,7 @@ function vchanStartSchedulerReleasePolling() {
 }
 async function vchanToggleSchedulerRelease() {
   if (!vchanSessionId) return;
-  const rigId = vchanRigId || vchanWindow.lastActiveRigId || null;
+  const rigId = vchanRigId || hostState.lastActiveRigId || null;
   try {
     const resp = await fetch("/scheduler-control", {
       method: "PUT",
@@ -161,14 +166,12 @@ function vchanRender() {
   });
   picker.appendChild(addBtn);
   vchanSyncAccentUI();
-  if (vchanWindow.updateDocumentTitle && vchanWindow.activeChannelRds) {
+  hostCore.updateDocumentTitle(hostCore.activeChannelRds());
-    vchanWindow.updateDocumentTitle(vchanWindow.activeChannelRds());
-  }
   vchanRenderSchedulerRelease();
 }
 async function vchanAllocate() {
   if (!vchanSessionId || !vchanRigId) return;
-  const freqHz = typeof vchanWindow.lastFreqHz === "number" && vchanWindow.lastFreqHz > 0 ? vchanWindow.lastFreqHz : 0;
+  const freqHz = typeof hostState.lastFreqHz === "number" && hostState.lastFreqHz > 0 ? hostState.lastFreqHz : 0;
   const modeEl = document.getElementById("mode");
   const mode = modeEl ? modeEl.value || "USB" : "USB";
   try {
@@ -251,11 +254,11 @@ async function vchanSubscribe(channelId) {
 }
 function vchanReconnectAudio() {
   const ch = vchanIsOnVirtual() ? vchanActiveChannel() : null;
-  vchanWindow._audioChannelOverride = ch?.id ?? null;
+  hostState.audioChannelOverride = ch?.id ?? null;
-  if (!vchanWindow.rxActive) return;
+  if (!hostState.rxActive) return;
-  vchanWindow.stopRxAudio?.();
+  hostCore.stopRxAudio();
   setTimeout(() => {
-    vchanWindow.startRxAudio?.();
+    hostCore.startRxAudio();
   }, 300);
 }
 function vchanApplyCapabilities(caps) {
@@ -276,35 +279,34 @@ function vchanUpdateFreqDisplay() {
   if (!ch) return;
   const el = document.getElementById("freq");
   if (!el) return;
-  if (vchanWindow.formatFreqForStep && typeof vchanWindow.jogUnit === "number") {
+  el.value = hostCore.formatFreqForStep(ch.freq_hz, hostState.jogUnit);
-    el.value = vchanWindow.formatFreqForStep(ch.freq_hz, vchanWindow.jogUnit);
-  } else {
-    el.value = (ch.freq_hz / 1e6).toFixed(6).replace(/\.?0+$/, "");
-  }
 }
 function vchanSyncModeDisplay() {
   const modeEl = document.getElementById("mode");
   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 vchanWindow.lastModeName === "string") {
+  if (typeof hostState.lastModeName === "string") {
-    if (modeUpper === "WFM" && vchanWindow.lastModeName !== "WFM") {
+    if (modeUpper === "WFM" && hostState.lastModeName !== "WFM") {
-      vchanWindow.setJogDivisor?.(10);
+      hostCore.setJogDivisor(10);
-      vchanWindow.resetRdsDisplay?.();
+      hostCore.resetRdsDisplay();
-    } else if (modeUpper !== "WFM" && vchanWindow.lastModeName === "WFM") {
+    } else if (modeUpper !== "WFM" && hostState.lastModeName === "WFM") {
-      vchanWindow.resetRdsDisplay?.();
+      hostCore.resetRdsDisplay();
     }
-    vchanWindow.lastModeName = modeUpper;
+    hostState.lastModeName = modeUpper;
   }
-  vchanWindow.updateWfmControls?.();
+  hostCore.updateWfmControls();
-  vchanWindow.updateSdrSquelchControlVisibility?.();
+  hostCore.updateSdrSquelchControlVisibility();
   if (vchanWindow.refreshRdsUi) {
     vchanWindow.refreshRdsUi();
   } else {
-    vchanWindow.positionRdsPsOverlay?.();
+    hostCore.positionRdsPsOverlay();
   }
 }
 function vchanSyncBwDisplay() {
@@ -314,12 +316,12 @@ function vchanSyncBwDisplay() {
   const bwEl = document.getElementById("spectrum-bw-input");
   if (!bwEl) return;
   let bwHz = ch.bandwidth_hz || 0;
-  if (bwHz === 0 && vchanWindow.mwDefaultsForMode) {
+  if (bwHz === 0) {
-    bwHz = vchanWindow.mwDefaultsForMode(ch.mode)[0] || 0;
+    bwHz = hostCore.mwDefaultsForMode(ch.mode)[0] || 0;
   }
   if (bwHz > 0) {
     bwEl.value = (bwHz / 1e3).toFixed(3).replace(/\.?0+$/, "");
-    vchanWindow.currentBandwidthHz = bwHz;
+    hostState.currentBandwidthHz = bwHz;
   }
 }
 function vchanSyncAccentUI() {
@@ -333,25 +335,20 @@ function vchanSyncAccentUI() {
     vchanSyncModeDisplay();
     vchanSyncBwDisplay();
   } else {
-    origRefreshFreqDisplay?.();
+    hostCore.refreshFreqDisplay();
   }
-  if (vchanWindow.updateDocumentTitle && vchanWindow.activeChannelRds) {
+  hostCore.updateDocumentTitle(hostCore.activeChannelRds());
-    vchanWindow.updateDocumentTitle(vchanWindow.activeChannelRds());
 }
-}
-var origRefreshFreqDisplay = null;
 function vchanSetChannelFreq(freqHz) {
   if (!vchanRigId || !vchanActiveId) return;
-  if (vchanWindow.lastSpectrumData && vchanWindow.lastSpectrumData.sample_rate > 0) {
+  if (hostState.lastSpectrumData && hostState.lastSpectrumData.sample_rate > 0) {
-    const halfSpan = vchanWindow.lastSpectrumData.sample_rate / 2;
+    const halfSpan = hostState.lastSpectrumData.sample_rate / 2;
-    const center = vchanWindow.lastSpectrumData.center_hz;
+    const center = hostState.lastSpectrumData.center_hz;
     if (Math.abs(freqHz - center) > halfSpan) {
-      if (vchanWindow.showHint) {
+      hostCore.showHint(
-        vchanWindow.showHint(
         `Out of SDR bandwidth (center ${(center / 1e6).toFixed(3)} MHz ±${(halfSpan / 1e3).toFixed(0)} kHz)`,
         3e3
       );
-      }
       return;
     }
   }
@@ -411,6 +408,19 @@ async function vchanInterceptBandwidth(bwHz) {
   await vchanSetChannelBandwidth(bwHz);
   return true;
 }
+function vchanInterceptFrequency(freqHz) {
+  if (!vchanIsOnVirtual()) return false;
+  const targetHz = Math.round(freqHz);
+  hostCore.armOptimisticFrequency(targetHz);
+  hostCore.applyLocalTunedFrequency(targetHz);
+  vchanSetChannelFreq(freqHz);
+  return true;
+}
+function vchanInterceptFreqDisplay() {
+  if (!vchanIsOnVirtual()) return false;
+  vchanUpdateFreqDisplay();
+  return true;
+}
 vchanWindow.trx ??= {};
 vchanWindow.trx.modules ??= {};
 vchanWindow.trx.modules.vchan = {
@@ -427,27 +437,11 @@ vchanWindow.trx.modules.vchan = {
   isOnVirtual: vchanIsOnVirtual,
   interceptMode: vchanInterceptMode,
   interceptBandwidth: vchanInterceptBandwidth,
+  interceptFrequency: vchanInterceptFrequency,
+  interceptFreqDisplay: vchanInterceptFreqDisplay,
   takeSchedulerControl: vchanTakeSchedulerControl,
   releaseToScheduler: vchanToggleSchedulerRelease
 };
-(function() {
-  const original = vchanWindow.setRigFrequency;
-  vchanWindow.setRigFrequency = function(freqHz) {
-    if (vchanIsOnVirtual()) {
-      if (vchanWindow.applyLocalTunedFrequency) {
-        if (typeof vchanWindow._freqOptimisticSeq === "number") {
-          vchanWindow._freqOptimisticSeq += 1;
-          vchanWindow._freqOptimisticHz = Math.round(freqHz);
-        }
-        vchanWindow.applyLocalTunedFrequency(Math.round(freqHz));
-      }
-      vchanSetChannelFreq(freqHz);
-      return;
-    }
-    void vchanTakeSchedulerControl();
-    original?.(freqHz);
-  };
-})();
 (function initSchedulerReleaseControl() {
   const btn = document.getElementById("scheduler-release-btn");
   if (btn) {
@@ -458,13 +452,3 @@ vchanWindow.trx.modules.vchan = {
   vchanStartSchedulerReleasePolling();
   vchanRenderSchedulerRelease();
 })();
-(function() {
-  origRefreshFreqDisplay = vchanWindow.refreshFreqDisplay ?? null;
-  vchanWindow.refreshFreqDisplay = function() {
-    if (vchanIsOnVirtual()) {
-      vchanUpdateFreqDisplay();
-      return;
-    }
-    origRefreshFreqDisplay?.();
-  };
-})();

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

@@ -1,6 +1,10 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/vdes.ts
 var vdesWindow = window;
-var escapeVdesHtml = (input) => vdesWindow.escapeMapHtml?.(input) ?? input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var escapeVdesHtml = (input) => hostCore.escapeMapHtml(input);
 var vdesStatus = document.getElementById("vdes-status");
 var vdesMessagesEl = document.getElementById("vdes-messages");
 var vdesFilterInput = document.getElementById("vdes-filter");
@@ -216,9 +220,7 @@ function onServerVdesBatch(messages) {
       minute: "2-digit",
       second: "2-digit"
     });
-    if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
+    plotVdesMessage(next);
-      vdesWindow.vdesMapAddPoint(next);
-    }
     normalized.push(next);
   }
   normalized.reverse();
@@ -231,7 +233,7 @@ document.getElementById("settings-clear-vdes-history")?.addEventListener("click"
   void (async () => {
     if (!await vdesWindow.trxUi.confirm({ title: "Clear VDES history?", message: "All stored VDES decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await vdesWindow.postPath?.("/clear_vdes_decode");
+      await hostCore.postPath("/clear_vdes_decode");
       resetVdesHistoryView();
     } catch (e) {
       console.error("VDES history clear failed", e);
@@ -244,13 +246,15 @@ if (vdesFilterInput) {
     renderVdesHistory();
   });
 }
+function plotVdesMessage(msg) {
+  if (msg.lat == null || msg.lon == null || !vdesWindow.vdesMapAddPoint) return;
+  vdesWindow.vdesMapAddPoint(msg);
+}
 function onServerVdes(msg) {
   if (vdesStatus) vdesStatus.textContent = "Receiving";
   const next = normalizeServerVdesMessage(msg);
   addVdesMessage(next);
-  if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
+  plotVdesMessage(next);
-    vdesWindow.vdesMapAddPoint(next);
-  }
 }
 function pruneVdesHistoryView() {
   pruneVdesMessageHistory();
@@ -264,5 +268,9 @@ window.trxPluginRuntime.registerDecoder({
   onBatch: onServerVdesBatch,
   restore: onServerVdesBatch,
   reset: resetVdesHistoryView,
-  prune: pruneVdesHistoryView
+  prune: pruneVdesHistoryView,
+  // Oldest first, so tracks are rebuilt in the order they happened.
+  syncMap: () => {
+    for (const entry of [...vdesMessageHistory].reverse()) plotVdesMessage(entry);
+  }
 });

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

@@ -1,498 +0,0 @@
-"use strict";
-(function initTrxWebGl(global) {
-  "use strict";
-  const cssColorCache = /* @__PURE__ */ new Map();
-  let cssColorProbe = null;
-  function clearCssColorCache() {
-    cssColorCache.clear();
-  }
-  function ensureCssColorProbe() {
-    if (cssColorProbe) return cssColorProbe;
-    const el = document.createElement("span");
-    el.style.position = "absolute";
-    el.style.left = "-9999px";
-    el.style.top = "-9999px";
-    el.style.pointerEvents = "none";
-    el.style.opacity = "0";
-    document.body.appendChild(el);
-    cssColorProbe = el;
-    return cssColorProbe;
-  }
-  function parseRgbString(value) {
-    const m = /^rgba?\(([^)]+)\)$/.exec(value.trim());
-    if (!m) return null;
-    const parts = m[1]?.split(",").map((p) => p.trim()) ?? [];
-    if (parts.length < 3) return null;
-    const r = Number(parts[0]);
-    const g = Number(parts[1]);
-    const b = Number(parts[2]);
-    const a = parts.length > 3 ? Number(parts[3]) : 1;
-    if (![r, g, b, a].every(Number.isFinite)) return null;
-    return [
-      Math.max(0, Math.min(1, r / 255)),
-      Math.max(0, Math.min(1, g / 255)),
-      Math.max(0, Math.min(1, b / 255)),
-      Math.max(0, Math.min(1, a))
-    ];
-  }
-  function parseHexColor(value) {
-    const raw = value.trim();
-    if (!/^#([0-9a-f]{3,8})$/i.test(raw)) return null;
-    let hex = raw.slice(1);
-    if (hex.length === 3 || hex.length === 4) {
-      hex = hex.split("").map((ch) => ch + ch).join("");
-    }
-    if (!(hex.length === 6 || hex.length === 8)) return null;
-    const r = parseInt(hex.slice(0, 2), 16) / 255;
-    const g = parseInt(hex.slice(2, 4), 16) / 255;
-    const b = parseInt(hex.slice(4, 6), 16) / 255;
-    const a = hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1;
-    return [r, g, b, a];
-  }
-  function parseCssColor(value) {
-    const key = value;
-    const cached = cssColorCache.get(key);
-    if (cached) return [...cached];
-    let parsed = parseHexColor(key) || parseRgbString(key);
-    if (!parsed) {
-      const probe = ensureCssColorProbe();
-      probe.style.color = "";
-      probe.style.color = key;
-      const computed = getComputedStyle(probe).color;
-      parsed = parseRgbString(computed) || [0, 0, 0, 1];
-    }
-    cssColorCache.set(key, [...parsed]);
-    return [...parsed];
-  }
-  function hslToRgba(h, s, l, a = 1) {
-    const hue = ((h || 0) % 360 + 360) % 360 / 360;
-    const sat = Math.max(0, Math.min(1, (s || 0) / 100));
-    const lig = Math.max(0, Math.min(1, (l || 0) / 100));
-    const q = lig < 0.5 ? lig * (1 + sat) : lig + sat - lig * sat;
-    const p = 2 * lig - q;
-    const hueToRgb = (t) => {
-      let tt = t;
-      if (tt < 0) tt += 1;
-      if (tt > 1) tt -= 1;
-      if (tt < 1 / 6) return p + (q - p) * 6 * tt;
-      if (tt < 1 / 2) return q;
-      if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
-      return p;
-    };
-    const r = sat === 0 ? lig : hueToRgb(hue + 1 / 3);
-    const g = sat === 0 ? lig : hueToRgb(hue);
-    const b = sat === 0 ? lig : hueToRgb(hue - 1 / 3);
-    return [r, g, b, Math.max(0, Math.min(1, a))];
-  }
-  function normalizeColor(input, alphaMul = 1) {
-    let rgba;
-    if (Array.isArray(input)) {
-      const arr = input;
-      if (arr.length >= 4) {
-        rgba = [arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 1];
-      } else {
-        rgba = [0, 0, 0, 1];
-      }
-    } else if (typeof input === "string") {
-      rgba = parseCssColor(input);
-    } else {
-      rgba = [
-        input.r || 0,
-        input.g || 0,
-        input.b || 0,
-        input.a ?? 1
-      ];
-    }
-    const out = [
-      Math.max(0, Math.min(1, rgba[0])),
-      Math.max(0, Math.min(1, rgba[1])),
-      Math.max(0, Math.min(1, rgba[2])),
-      Math.max(0, Math.min(1, rgba[3] * alphaMul))
-    ];
-    return out;
-  }
-  function compileShader(gl, type, source) {
-    const shader = gl.createShader(type);
-    if (shader === null) throw new Error("Unable to create WebGL shader");
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-      const log = gl.getShaderInfoLog(shader) || "shader compile error";
-      gl.deleteShader(shader);
-      throw new Error(log);
-    }
-    return shader;
-  }
-  function createProgram(gl, vertexSrc, fragmentSrc) {
-    const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);
-    const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
-    const program = gl.createProgram();
-    gl.attachShader(program, vs);
-    gl.attachShader(program, fs);
-    gl.linkProgram(program);
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-      const log = gl.getProgramInfoLog(program) || "program link error";
-      gl.deleteProgram(program);
-      throw new Error(log);
-    }
-    return program;
-  }
-  function pushColoredVertex(target, x, y, rgba) {
-    target.push(x, y, rgba[0], rgba[1], rgba[2], rgba[3]);
-  }
-  function segmentToQuadVertices(out, x0, y0, x1, y1, halfW, rgba) {
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    const len = Math.hypot(dx, dy);
-    if (!(len > 1e-4)) return;
-    const nx = -dy / len * halfW;
-    const ny = dx / len * halfW;
-    const ax = x0 - nx, ay = y0 - ny;
-    const bx = x0 + nx, by = y0 + ny;
-    const cx = x1 + nx, cy = y1 + ny;
-    const dx2 = x1 - nx, dy2 = y1 - ny;
-    pushColoredVertex(out, ax, ay, rgba);
-    pushColoredVertex(out, bx, by, rgba);
-    pushColoredVertex(out, cx, cy, rgba);
-    pushColoredVertex(out, ax, ay, rgba);
-    pushColoredVertex(out, cx, cy, rgba);
-    pushColoredVertex(out, dx2, dy2, rgba);
-  }
-  class TrxWebGlRenderer {
-    canvas;
-    options;
-    gl;
-    ready;
-    textures = /* @__PURE__ */ new Map();
-    _colorScratch = new Float32Array(4096 * 6);
-    _colorGpuSize = 0;
-    _texScratch = new Float32Array(6 * 4);
-    colorProgram;
-    colorBuffer;
-    colorLoc;
-    textureProgram;
-    textureBuffer;
-    textureLoc;
-    constructor(canvas, options = {}) {
-      this.canvas = canvas;
-      this.options = { alpha: true, premultipliedAlpha: false, ...options };
-      this.gl = canvas.getContext("webgl", this.options) || canvas.getContext("experimental-webgl", this.options);
-      this.ready = !!this.gl;
-      if (!this.ready) return;
-      const gl = this.gl;
-      if (!gl) return;
-      gl.disable(gl.DEPTH_TEST);
-      gl.disable(gl.CULL_FACE);
-      gl.enable(gl.BLEND);
-      gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-      const colorVertexSrc = "attribute vec2 a_pos;\nattribute vec4 a_color;\nuniform vec2 u_resolution;\nvarying vec4 v_color;\nvoid main() {\n  vec2 zeroToOne = a_pos / u_resolution;\n  vec2 clip = zeroToOne * 2.0 - 1.0;\n  gl_Position = vec4(clip * vec2(1.0, -1.0), 0.0, 1.0);\n  v_color = a_color;\n}\n";
-      const colorFragmentSrc = "precision mediump float;\nvarying vec4 v_color;\nvoid main() {\n  gl_FragColor = v_color;\n}\n";
-      const textureVertexSrc = "attribute vec2 a_pos;\nattribute vec2 a_uv;\nuniform vec2 u_resolution;\nvarying vec2 v_uv;\nvoid main() {\n  vec2 zeroToOne = a_pos / u_resolution;\n  vec2 clip = zeroToOne * 2.0 - 1.0;\n  gl_Position = vec4(clip * vec2(1.0, -1.0), 0.0, 1.0);\n  v_uv = a_uv;\n}\n";
-      const textureFragmentSrc = "precision mediump float;\nvarying vec2 v_uv;\nuniform sampler2D u_tex;\nuniform float u_alpha;\nvoid main() {\n  vec4 c = texture2D(u_tex, v_uv);\n  gl_FragColor = vec4(c.rgb, c.a * u_alpha);\n}\n";
-      this.colorProgram = createProgram(gl, colorVertexSrc, colorFragmentSrc);
-      this.colorBuffer = gl.createBuffer();
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.colorBuffer);
-      gl.bufferData(gl.ARRAY_BUFFER, this._colorScratch, gl.DYNAMIC_DRAW);
-      this._colorGpuSize = this._colorScratch.length;
-      this.colorLoc = {
-        pos: gl.getAttribLocation(this.colorProgram, "a_pos"),
-        color: gl.getAttribLocation(this.colorProgram, "a_color"),
-        resolution: gl.getUniformLocation(this.colorProgram, "u_resolution")
-      };
-      this.textureProgram = createProgram(gl, textureVertexSrc, textureFragmentSrc);
-      this.textureBuffer = gl.createBuffer();
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.textureBuffer);
-      gl.bufferData(gl.ARRAY_BUFFER, this._texScratch, gl.DYNAMIC_DRAW);
-      this.textureLoc = {
-        pos: gl.getAttribLocation(this.textureProgram, "a_pos"),
-        uv: gl.getAttribLocation(this.textureProgram, "a_uv"),
-        resolution: gl.getUniformLocation(this.textureProgram, "u_resolution"),
-        alpha: gl.getUniformLocation(this.textureProgram, "u_alpha"),
-        tex: gl.getUniformLocation(this.textureProgram, "u_tex")
-      };
-    }
-    ensureSize(cssWidth, cssHeight, dpr = window.devicePixelRatio || 1) {
-      if (!this.gl) return false;
-      const nextW = Math.max(1, Math.round(cssWidth * dpr));
-      const nextH = Math.max(1, Math.round(cssHeight * dpr));
-      const changed = this.canvas.width !== nextW || this.canvas.height !== nextH;
-      if (changed) {
-        this.canvas.width = nextW;
-        this.canvas.height = nextH;
-      }
-      this.gl.viewport(0, 0, this.canvas.width, this.canvas.height);
-      return changed;
-    }
-    clear(color) {
-      if (!this.gl) return;
-      const gl = this.gl;
-      const rgba = normalizeColor(color);
-      gl.clearColor(rgba[0], rgba[1], rgba[2], rgba[3]);
-      gl.clear(gl.COLOR_BUFFER_BIT);
-    }
-    drawTriangles(vertices) {
-      if (!this.gl) return;
-      this._drawColorGeometry(vertices, this.gl.TRIANGLES);
-    }
-    drawTriangleStrip(vertices) {
-      if (!this.gl) return;
-      this._drawColorGeometry(vertices, this.gl.TRIANGLE_STRIP);
-    }
-    _drawColorGeometry(vertices, mode) {
-      if (!this.gl || vertices.length === 0) return;
-      const gl = this.gl;
-      const count = vertices.length;
-      if (count > this._colorScratch.length) {
-        let newLen = this._colorScratch.length;
-        while (newLen < count) newLen *= 2;
-        this._colorScratch = new Float32Array(newLen);
-      }
-      this._colorScratch.set(vertices);
-      const view = this._colorScratch.subarray(0, count);
-      gl.useProgram(this.colorProgram);
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.colorBuffer);
-      if (count > this._colorGpuSize) {
-        gl.bufferData(gl.ARRAY_BUFFER, this._colorScratch, gl.DYNAMIC_DRAW);
-        this._colorGpuSize = this._colorScratch.length;
-      } else {
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, view);
-      }
-      gl.enableVertexAttribArray(this.colorLoc.pos);
-      gl.vertexAttribPointer(this.colorLoc.pos, 2, gl.FLOAT, false, 24, 0);
-      gl.enableVertexAttribArray(this.colorLoc.color);
-      gl.vertexAttribPointer(this.colorLoc.color, 4, gl.FLOAT, false, 24, 8);
-      gl.uniform2f(this.colorLoc.resolution, this.canvas.width, this.canvas.height);
-      gl.drawArrays(mode, 0, count / 6);
-    }
-    fillRect(x, y, w, h, color) {
-      if (w <= 0 || h <= 0) return;
-      const rgba = normalizeColor(color);
-      const v = [];
-      pushColoredVertex(v, x, y, rgba);
-      pushColoredVertex(v, x + w, y, rgba);
-      pushColoredVertex(v, x + w, y + h, rgba);
-      pushColoredVertex(v, x, y, rgba);
-      pushColoredVertex(v, x + w, y + h, rgba);
-      pushColoredVertex(v, x, y + h, rgba);
-      this.drawTriangles(v);
-    }
-    fillGradientRect(x, y, w, h, colorTL, colorTR, colorBR, colorBL) {
-      if (w <= 0 || h <= 0) return;
-      const tl = normalizeColor(colorTL);
-      const tr = normalizeColor(colorTR);
-      const br = normalizeColor(colorBR);
-      const bl = normalizeColor(colorBL);
-      const v = [];
-      pushColoredVertex(v, x, y, tl);
-      pushColoredVertex(v, x + w, y, tr);
-      pushColoredVertex(v, x + w, y + h, br);
-      pushColoredVertex(v, x, y, tl);
-      pushColoredVertex(v, x + w, y + h, br);
-      pushColoredVertex(v, x, y + h, bl);
-      this.drawTriangles(v);
-    }
-    drawPolyline(points, color, width = 1) {
-      if (!Array.isArray(points) || points.length < 4) return;
-      const rgba = normalizeColor(color);
-      const halfW = Math.max(0.5, width || 1) / 2;
-      const verts = [];
-      for (let i = 0; i < points.length - 2; i += 2) {
-        segmentToQuadVertices(
-          verts,
-          points[i] ?? 0,
-          points[i + 1] ?? 0,
-          points[i + 2] ?? 0,
-          points[i + 3] ?? 0,
-          halfW,
-          rgba
-        );
-      }
-      this.drawTriangles(verts);
-    }
-    drawSegments(segments, color, width = 1) {
-      if (!Array.isArray(segments) || segments.length < 4) return;
-      const rgba = normalizeColor(color);
-      const halfW = Math.max(0.5, width || 1) / 2;
-      const verts = [];
-      for (let i = 0; i < segments.length - 3; i += 4) {
-        segmentToQuadVertices(
-          verts,
-          segments[i] ?? 0,
-          segments[i + 1] ?? 0,
-          segments[i + 2] ?? 0,
-          segments[i + 3] ?? 0,
-          halfW,
-          rgba
-        );
-      }
-      this.drawTriangles(verts);
-    }
-    drawFilledArea(points, baselineY, color) {
-      if (!Array.isArray(points) || points.length < 4) return;
-      const rgba = normalizeColor(color);
-      const verts = [];
-      for (let i = 0; i < points.length; i += 2) {
-        pushColoredVertex(verts, points[i] ?? 0, baselineY, rgba);
-        pushColoredVertex(verts, points[i] ?? 0, points[i + 1] ?? 0, rgba);
-      }
-      this.drawTriangleStrip(verts);
-    }
-    drawPoints(points, size, color) {
-      if (!Array.isArray(points) || points.length < 2) return;
-      const radius = Math.max(1, size || 1);
-      const rgba = normalizeColor(color);
-      const verts = [];
-      for (let i = 0; i < points.length; i += 2) {
-        const x = (points[i] ?? 0) - radius;
-        const y = (points[i + 1] ?? 0) - radius;
-        const w = radius * 2;
-        const h = radius * 2;
-        pushColoredVertex(verts, x, y, rgba);
-        pushColoredVertex(verts, x + w, y, rgba);
-        pushColoredVertex(verts, x + w, y + h, rgba);
-        pushColoredVertex(verts, x, y, rgba);
-        pushColoredVertex(verts, x + w, y + h, rgba);
-        pushColoredVertex(verts, x, y + h, rgba);
-      }
-      this.drawTriangles(verts);
-    }
-    drawDashedVerticalLine(x, y0, y1, dashLen, gapLen, color, width = 1) {
-      const dash = Math.max(1, dashLen || 1);
-      const gap = Math.max(1, gapLen || 1);
-      const top = Math.min(y0, y1);
-      const bottom = Math.max(y0, y1);
-      const segments = [];
-      for (let y = top; y < bottom; y += dash + gap) {
-        const segEnd = Math.min(bottom, y + dash);
-        segments.push(x, y, x, segEnd);
-      }
-      this.drawSegments(segments, color, width);
-    }
-    uploadRgbaTexture(name, width, height, data, filter = "linear") {
-      if (!this.gl || !name) return null;
-      const gl = this.gl;
-      let entry = this.textures.get(name);
-      if (!entry) {
-        const texture = gl.createTexture();
-        entry = { texture, width: 0, height: 0 };
-        this.textures.set(name, entry);
-      }
-      gl.bindTexture(gl.TEXTURE_2D, entry.texture);
-      gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
-      const mode = filter === "nearest" ? gl.NEAREST : gl.LINEAR;
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, mode);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, mode);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-      if (entry.width !== width || entry.height !== height) {
-        gl.texImage2D(
-          gl.TEXTURE_2D,
-          0,
-          gl.RGBA,
-          width,
-          height,
-          0,
-          gl.RGBA,
-          gl.UNSIGNED_BYTE,
-          data
-        );
-        entry.width = width;
-        entry.height = height;
-      } else {
-        gl.texSubImage2D(
-          gl.TEXTURE_2D,
-          0,
-          0,
-          0,
-          width,
-          height,
-          gl.RGBA,
-          gl.UNSIGNED_BYTE,
-          data
-        );
-      }
-      return entry.texture;
-    }
-    drawTexture(name, x, y, w, h, alpha = 1, flipY = true) {
-      if (!this.gl || !name || w <= 0 || h <= 0) return;
-      const entry = this.textures.get(name);
-      if (!entry) return;
-      const gl = this.gl;
-      const s = this._texScratch;
-      const x2 = x + w, y2 = y + h;
-      if (flipY) {
-        s[0] = x;
-        s[1] = y;
-        s[2] = 0;
-        s[3] = 1;
-        s[4] = x2;
-        s[5] = y;
-        s[6] = 1;
-        s[7] = 1;
-        s[8] = x2;
-        s[9] = y2;
-        s[10] = 1;
-        s[11] = 0;
-        s[12] = x;
-        s[13] = y;
-        s[14] = 0;
-        s[15] = 1;
-        s[16] = x2;
-        s[17] = y2;
-        s[18] = 1;
-        s[19] = 0;
-        s[20] = x;
-        s[21] = y2;
-        s[22] = 0;
-        s[23] = 0;
-      } else {
-        s[0] = x;
-        s[1] = y;
-        s[2] = 0;
-        s[3] = 0;
-        s[4] = x2;
-        s[5] = y;
-        s[6] = 1;
-        s[7] = 0;
-        s[8] = x2;
-        s[9] = y2;
-        s[10] = 1;
-        s[11] = 1;
-        s[12] = x;
-        s[13] = y;
-        s[14] = 0;
-        s[15] = 0;
-        s[16] = x2;
-        s[17] = y2;
-        s[18] = 1;
-        s[19] = 1;
-        s[20] = x;
-        s[21] = y2;
-        s[22] = 0;
-        s[23] = 1;
-      }
-      gl.useProgram(this.textureProgram);
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.textureBuffer);
-      gl.bufferSubData(gl.ARRAY_BUFFER, 0, s);
-      gl.enableVertexAttribArray(this.textureLoc.pos);
-      gl.vertexAttribPointer(this.textureLoc.pos, 2, gl.FLOAT, false, 16, 0);
-      gl.enableVertexAttribArray(this.textureLoc.uv);
-      gl.vertexAttribPointer(this.textureLoc.uv, 2, gl.FLOAT, false, 16, 8);
-      gl.uniform2f(this.textureLoc.resolution, this.canvas.width, this.canvas.height);
-      gl.uniform1f(this.textureLoc.alpha, Math.max(0, Math.min(1, alpha || 0)));
-      gl.activeTexture(gl.TEXTURE0);
-      gl.bindTexture(gl.TEXTURE_2D, entry.texture);
-      gl.uniform1i(this.textureLoc.tex, 0);
-      gl.drawArrays(gl.TRIANGLES, 0, 6);
-    }
-  }
-  function createRenderer(canvas, options = {}) {
-    return new TrxWebGlRenderer(canvas, options);
-  }
-  global.trxParseCssColor = parseCssColor;
-  global.trxHslToRgba = hslToRgba;
-  global.createTrxWebGlRenderer = createRenderer;
-  global.trxClearCssColorCache = clearCssColorCache;
-})(window);

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

@@ -1,3 +1,7 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/wefax.ts
 var wefaxWindow = window;
 var wefaxDom = {
@@ -299,7 +303,7 @@ if (wefaxDom.toggleBtn) {
         if (wefaxWindow.takeSchedulerControlForDecoderDisable) {
           await wefaxWindow.takeSchedulerControlForDecoderDisable(toggleButton);
         }
-        await wefaxWindow.postPath?.("/toggle_wefax_decode");
+        await hostCore.postPath("/toggle_wefax_decode");
       } catch (e) {
         console.error("WEFAX toggle failed", e);
       }
@@ -310,7 +314,7 @@ if (wefaxDom.clearBtn) {
   wefaxDom.clearBtn.addEventListener("click", () => {
     void (async () => {
       try {
-        await wefaxWindow.postPath?.("/clear_wefax_decode");
+        await hostCore.postPath("/clear_wefax_decode");
         resetWefaxHistoryView();
       } catch (e) {
         console.error("WEFAX clear failed", e);

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

@@ -1,3 +1,7 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
 // src/plugins/wspr.ts
 var wsprWindow = window;
 var wsprStatus = document.getElementById("wspr-status");
@@ -229,7 +233,7 @@ wsprDecodeToggleBtn?.addEventListener("click", () => {
   void (async () => {
     try {
       await wsprWindow.takeSchedulerControlForDecoderDisable?.(wsprDecodeToggleBtn);
-      await wsprWindow.postPath?.("/toggle_wspr_decode");
+      await hostCore.postPath("/toggle_wspr_decode");
     } catch (error) {
       console.error("WSPR toggle failed", error);
     }
@@ -239,7 +243,7 @@ document.getElementById("settings-clear-wspr-history")?.addEventListener("click"
   void (async () => {
     if (!await wsprWindow.trxUi.confirm({ title: "Clear WSPR history?", message: "All stored WSPR decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await wsprWindow.postPath?.("/clear_wspr_decode");
+      await hostCore.postPath("/clear_wspr_decode");
       resetWsprHistoryView();
     } catch (error) {
       console.error("WSPR history clear failed", error);

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

@@ -22,7 +22,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
   <svg xmlns="http://www.w3.org/2000/svg" style="display:none">
     <symbol id="icon-home" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M2.8 7 8 2.9 13.2 7"/><path d="M4.3 5.9V13h7.4V5.9"/><path d="M6.8 13V9.3h2.4V13"/></symbol>
     <symbol id="icon-bookmark" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M4 2h8v12l-4-2.5L4 14V2z"/></symbol>
-    <symbol id="icon-signal" viewBox="0 0 16 16" fill="currentColor"><rect x="1" y="11" width="2.5" height="4" rx="0.5"/><rect x="4.75" y="8" width="2.5" height="7" rx="0.5"/><rect x="8.5" y="5" width="2.5" height="10" rx="0.5"/><rect x="12.25" y="2" width="2.5" height="13" rx="0.5"/></symbol>
+    <symbol id="icon-digital" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1 11.5h2.6V4.5h3.2v7h3.2v-7h3.2v7H15"/></symbol>
     <symbol id="icon-map" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8 2a4 4 0 0 1 4 4c0 3-4 8-4 8S4 9 4 6a4 4 0 0 1 4-4z"/><circle cx="8" cy="6" r="1.2" fill="currentColor" stroke="none"/></symbol>
     <symbol id="icon-stats" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"><path d="M2 14h12"/><rect x="3" y="8" width="2" height="6" rx="0.4" fill="currentColor" stroke="none" opacity="0.6"/><rect x="7" y="5" width="2" height="9" rx="0.4" fill="currentColor" stroke="none" opacity="0.75"/><rect x="11" y="2" width="2" height="12" rx="0.4" fill="currentColor" stroke="none" opacity="0.9"/></symbol>
     <symbol id="icon-record" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><circle cx="8" cy="8" r="2.5" fill="currentColor" stroke="none"/></symbol>
@@ -46,14 +46,14 @@ 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>
             <span class="tab-label">Bookmarks</span>
           </button>
           <button class="tab" data-tab="digital-modes">
-            <svg class="tab-icon" aria-hidden="true"><use href="#icon-signal"/></svg>
+            <svg class="tab-icon" aria-hidden="true"><use href="#icon-digital"/></svg>
             <span class="tab-label">Digital modes</span>
           </button>
           <button class="tab" data-tab="map">
@@ -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">
@@ -143,6 +142,10 @@ SPDX-License-Identifier: GPL-2.0-or-later
           <div id="spectrum-bookmark-side-left" class="spectrum-bookmark-side spectrum-bookmark-side-left" aria-hidden="true"></div>
           <canvas id="spectrum-canvas" tabindex="0" role="img" aria-label="Spectrum display" aria-describedby="spectrum-text-summary"></canvas>
           <p id="spectrum-text-summary" class="visually-hidden">Spectrum data is waiting for the receiver.</p>
+          <div id="spectrum-squelch-line" class="spectrum-squelch-line" style="display:none;" data-state="closed">
+            <span class="spectrum-squelch-grip" id="spectrum-squelch-grip" role="slider" tabindex="0"
+                  aria-label="Squelch threshold" aria-valuemin="-120" aria-valuemax="-30" aria-valuenow="-95">SQL <span id="spectrum-squelch-label">-95</span> dB</span>
+          </div>
           <div id="spectrum-zoom-indicator" aria-hidden="true"></div>
           <div id="spectrum-minimap" aria-hidden="true"><div class="minimap-view"></div></div>
           <div id="spectrum-db-axis" aria-hidden="true"></div>
@@ -206,13 +209,40 @@ SPDX-License-Identifier: GPL-2.0-or-later
             <div class="label"><span>Signal strength</span></div>
           </div>
           <div class="freq-field frequency-col">
-            <input class="status-input" id="freq" type="text" value="--" aria-describedby="freq-label" aria-label="Tuned frequency" />
+            <input class="status-input" id="freq" type="text" value="--" aria-describedby="freq-label" aria-label="Tuned frequency" autocomplete="off" autocorrect="off" spellcheck="false" />
             <div class="label" id="freq-label"><span>Frequency</span></div>
           </div>
           <div class="freq-field frequency-col center-frequency-col" id="center-freq-field" style="display:none;">
-            <input class="status-input" id="center-freq" type="text" value="--" aria-describedby="center-freq-label" aria-label="SDR center frequency" />
+            <input class="status-input" id="center-freq" type="text" value="--" aria-describedby="center-freq-label" aria-label="SDR center frequency" autocomplete="off" autocorrect="off" spellcheck="false" />
             <div class="label" id="center-freq-label"><span>Center Frequency</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 controls-col-mode label-below-col">
+                <div class="label"><span>Mode</span></div>
+                <div class="inline">
+                  <!-- 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">
+                <div class="jog-container">
+                  <button id="jog-down" type="button" class="jog-btn">&minus;</button>
+                  <div class="jog-wheel" id="jog-wheel">
+                    <div class="jog-indicator" id="jog-indicator"></div>
+                  </div>
+                  <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>
@@ -230,25 +260,16 @@ SPDX-License-Identifier: GPL-2.0-or-later
                   </div>
                 </div>
               </div>
-      <div class="full-row controls-tray-shell">
+              <div class="controls-col controls-col-power label-below-col" id="tx-power-col">
-        <div class="controls-tray-scroll">
+                <div class="label"><span>Transmit / Power</span></div>
-          <div class="controls-tray">
+                <div class="btn-grid">
-            <div class="controls-row full-row">
+                  <button id="ptt-btn" type="button" aria-pressed="false">Start TX</button>
-              <div class="controls-col label-below-col">
+                  <button id="power-btn" type="button" aria-pressed="false">Power On</button>
-                <div class="label"><span>Mode</span></div>
+                  <button id="lock-btn" type="button" aria-pressed="false">Lock Tuning</button>
-                <div class="inline">
-                  <select class="status-input" id="mode" aria-label="Demodulation mode"></select>
                 </div>
               </div>
-              <div class="controls-col controls-col-center">
-                <div class="jog-container">
-                  <button id="jog-down" type="button" class="jog-btn">&minus;</button>
-                  <div class="jog-wheel" id="jog-wheel">
-                    <div class="jog-indicator" id="jog-indicator"></div>
-                  </div>
-                  <button id="jog-up" type="button" class="jog-btn">+</button>
-                </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 +327,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>
@@ -363,32 +376,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
                 <div class="vchan-picker" id="vchan-picker"></div>
               </div>
             </div>
-            <details id="scheduler-controls" class="advanced-radio-controls scheduler-controls-section">
-              <summary>Scheduler controls</summary>
-              <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>
-                    </div>
-                  </div>
-                </div>
-              </div>
-            </details>
             <div class="full-row label-below-row">
               <div class="label"><span>Signal</span></div>
               <div class="signal" style="gap: 1rem;">
@@ -426,13 +413,51 @@ SPDX-License-Identifier: GPL-2.0-or-later
                   <div class="inline" style="gap: 0.6rem; flex-wrap: wrap; align-items: center;">
                     <button id="rx-audio-btn" type="button">Play Audio</button>
                     <button id="tx-audio-btn" type="button">Transmit Audio</button>
+                    <span class="audio-group audio-volume-group">
+                      <span class="audio-group-label">Volume</span>
                       <label class="vol-label">RX<input type="range" id="rx-vol" min="0" max="100" value="80" class="vol-slider" /><small class="vol-pct" id="rx-vol-pct">80%</small></label>
                       <label class="vol-label">TX<input type="range" id="tx-vol" min="0" max="100" value="80" class="vol-slider" /><small class="vol-pct" id="tx-vol-pct">80%</small></label>
-                    <label class="vol-label" id="sdr-squelch-wrap" style="display:none;">SQL<input type="range" id="sdr-squelch" min="0" max="100" value="0" class="vol-slider" /><small class="vol-pct" id="sdr-squelch-pct">Open</small><button id="sdr-squelch-auto" type="button" class="sql-auto-btn" title="Set squelch to current noise level">Auto</button></label>
+                    </span>
+                    <span class="sql-control" id="sdr-squelch-wrap" style="display:none;">
+                      <button id="sdr-squelch-toggle" type="button" class="sql-toggle" aria-pressed="false" title="Turn the squelch on or off"><span class="sql-state" id="sdr-squelch-state" data-state="off" aria-hidden="true"></span>SQL</button>
+                      <label class="sql-db"><input type="number" id="sdr-squelch-db" min="-120" max="-30" step="1" value="-95" inputmode="numeric" aria-label="Squelch threshold in dB" /><span class="sql-db-unit">dB</span></label>
+                      <button id="sdr-squelch-auto" type="button" class="sql-auto-btn" title="Set the threshold just above the noise floor">Auto</button>
+                    </span>
+                    <span class="audio-group audio-level-group">
+                      <span class="audio-group-label">Level</span>
                       <div id="audio-level">
                         <div id="audio-level-fill"></div>
                       </div>
-                    <small id="audio-status" style="min-width: 60px;">Off</small>
+                      <small id="audio-status">Off</small>
+                    </span>
+                  </div>
+                </div>
+              </div>
+            </details>
+            <details id="scheduler-controls" class="advanced-radio-controls scheduler-controls-section">
+              <summary>Scheduler controls</summary>
+              <div class="advanced-radio-body">
+                <div class="scheduler-control-row" style="display:none">
+                  <div class="scheduler-release-wrap">
+                    <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>
@@ -655,19 +680,12 @@ SPDX-License-Identifier: GPL-2.0-or-later
           <input id="ais-filter" class="ft8-filter" type="text" placeholder="Filter (e.g. MMSI, vessel, A)" />
           <small id="ais-status" style="color:var(--text-muted);">Waiting for server decode</small>
         </div>
-        <div class="ais-summary">
+        <div class="aprs-filter-row">
-          <div class="ais-summary-card">
+          <span class="aprs-counts">
-            <span class="ais-summary-label">Channels</span>
+            <span id="ais-vessel-count" class="aprs-counts-value">0 vessels</span>
-            <span id="ais-channel-summary" class="ais-summary-value">A 161.975 MHz · B 162.025 MHz</span>
+            <span id="ais-latest-seen" class="aprs-counts-value">No traffic yet</span>
-          </div>
+            <span id="ais-channel-summary" class="aprs-counts-value">A 161.975 MHz · B 162.025 MHz</span>
-          <div class="ais-summary-card">
+          </span>
-            <span class="ais-summary-label">Tracked</span>
-            <span id="ais-vessel-count" class="ais-summary-value">0 vessels</span>
-          </div>
-          <div class="ais-summary-card">
-            <span class="ais-summary-label">Latest</span>
-            <span id="ais-latest-seen" class="ais-summary-value">No traffic yet</span>
-          </div>
         </div>
         <div id="ais-messages"></div>
       </div>
@@ -697,20 +715,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
           <input id="aprs-filter" class="ft8-filter" type="text" placeholder="Filter (e.g. SP2, beacon)" />
           <small id="aprs-status" style="color:var(--text-muted);">Waiting for server decode</small>
         </div>
-        <div class="aprs-summary">
-          <div class="aprs-summary-card">
-            <span class="aprs-summary-label">Frames</span>
-            <span id="aprs-total-count" class="aprs-summary-value">0 total</span>
-          </div>
-          <div class="aprs-summary-card">
-            <span class="aprs-summary-label">Visible</span>
-            <span id="aprs-visible-count" class="aprs-summary-value">0 shown</span>
-          </div>
-          <div class="aprs-summary-card">
-            <span class="aprs-summary-label">Latest</span>
-            <span id="aprs-latest-seen" class="aprs-summary-value">No packets yet</span>
-          </div>
-        </div>
         <div class="aprs-filter-row">
           <button id="aprs-type-all" class="aprs-chip active" type="button">All</button>
           <button id="aprs-type-position" class="aprs-chip" type="button">Pos</button>
@@ -718,11 +722,15 @@ SPDX-License-Identifier: GPL-2.0-or-later
           <button id="aprs-type-weather" class="aprs-chip" type="button">Wx</button>
           <button id="aprs-type-telemetry" class="aprs-chip" type="button">Tlm</button>
           <button id="aprs-type-other" class="aprs-chip" type="button">Other</button>
-        </div>
+          <span class="aprs-filter-sep" aria-hidden="true"></span>
-        <div class="aprs-filter-row">
           <button id="aprs-only-pos-btn" class="aprs-chip" type="button">Pos Only</button>
           <button id="aprs-hide-crc-btn" class="aprs-chip" type="button">No CRC</button>
           <button id="aprs-collapse-dup-btn" class="aprs-chip" type="button">Dupes</button>
+          <span class="aprs-counts">
+            <span id="aprs-visible-count" class="aprs-counts-value">0 shown</span>
+            <span id="aprs-total-count" class="aprs-counts-value">0 total</span>
+            <span id="aprs-latest-seen" class="aprs-counts-value">No packets yet</span>
+          </span>
         </div>
         <div id="aprs-packets"></div>
       </div>
@@ -732,20 +740,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
           <input id="hf-aprs-filter" class="ft8-filter" type="text" placeholder="Filter (e.g. SP2, beacon)" />
           <small id="hf-aprs-status" style="color:var(--text-muted);">Waiting for server decode</small>
         </div>
-        <div class="aprs-summary">
-          <div class="aprs-summary-card">
-            <span class="aprs-summary-label">Frames</span>
-            <span id="hf-aprs-total-count" class="aprs-summary-value">0 total</span>
-          </div>
-          <div class="aprs-summary-card">
-            <span class="aprs-summary-label">Visible</span>
-            <span id="hf-aprs-visible-count" class="aprs-summary-value">0 shown</span>
-          </div>
-          <div class="aprs-summary-card">
-            <span class="aprs-summary-label">Latest</span>
-            <span id="hf-aprs-latest-seen" class="aprs-summary-value">No packets yet</span>
-          </div>
-        </div>
         <div class="aprs-filter-row">
           <button id="hf-aprs-type-all" class="aprs-chip active" type="button">All</button>
           <button id="hf-aprs-type-position" class="aprs-chip" type="button">Pos</button>
@@ -753,11 +747,15 @@ SPDX-License-Identifier: GPL-2.0-or-later
           <button id="hf-aprs-type-weather" class="aprs-chip" type="button">Wx</button>
           <button id="hf-aprs-type-telemetry" class="aprs-chip" type="button">Tlm</button>
           <button id="hf-aprs-type-other" class="aprs-chip" type="button">Other</button>
-        </div>
+          <span class="aprs-filter-sep" aria-hidden="true"></span>
-        <div class="aprs-filter-row">
           <button id="hf-aprs-only-pos-btn" class="aprs-chip" type="button">Pos Only</button>
           <button id="hf-aprs-hide-crc-btn" class="aprs-chip" type="button">No CRC</button>
           <button id="hf-aprs-collapse-dup-btn" class="aprs-chip" type="button">Dupes</button>
+          <span class="aprs-counts">
+            <span id="hf-aprs-visible-count" class="aprs-counts-value">0 shown</span>
+            <span id="hf-aprs-total-count" class="aprs-counts-value">0 total</span>
+            <span id="hf-aprs-latest-seen" class="aprs-counts-value">No packets yet</span>
+          </span>
         </div>
         <div id="hf-aprs-packets"></div>
       </div>
@@ -1003,8 +1001,9 @@ SPDX-License-Identifier: GPL-2.0-or-later
       <template id="tmpl-map">
       <div id="map-stage">
         <div class="map-overlay-panel">
+          <div class="map-overlay-filters">
             <div class="map-locator-filter-group">
-            <span class="map-locator-filter-label">Filter by</span>
+              <span class="map-locator-filter-label">Filter</span>
               <div id="map-locator-phase" class="map-locator-phase-row"></div>
             </div>
             <div class="map-locator-filter-group">
@@ -1017,10 +1016,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
                 <option value="">All</option>
               </select>
             </div>
-          <div class="map-locator-filter-group">
-            <span class="map-locator-filter-label">Search</span>
-            <input type="text" id="map-search-filter" class="map-search-input" placeholder="Callsign, MMSI, locator, message..." />
-          </div>
             <div class="map-locator-filter-group">
               <span class="map-locator-filter-label">History</span>
               <select id="map-history-limit" class="map-history-select" aria-label="Map history limit">
@@ -1036,22 +1031,30 @@ SPDX-License-Identifier: GPL-2.0-or-later
             <div class="map-locator-filter-group">
               <span class="map-locator-filter-label">Paths</span>
               <div class="map-locator-phase-row">
-              <button type="button" id="map-p2p-paths-toggle" class="map-locator-phase-btn">TRX Paths On</button>
+                <button type="button" id="map-p2p-paths-toggle" class="map-locator-phase-btn" aria-pressed="true" title="TRX paths are drawn from a station popup">TRX</button>
-              <button type="button" id="map-contact-paths-toggle" class="map-locator-phase-btn">Contact Paths On</button>
+                <button type="button" id="map-contact-paths-toggle" class="map-locator-phase-btn" aria-pressed="true" title="Directed decode paths are drawn when the target locator is known">Contact</button>
-              <span class="map-locator-empty">TRX paths on popup, directed decode paths when target locator is known</span>
+                <span class="map-paths-hint">TRX paths on popup, directed decode paths when target locator is known</span>
               </div>
             </div>
+            <!-- Last, so the search field takes whatever the fixed-width
+                 groups leave on the bar's final row rather than a sliver. -->
+            <div class="map-locator-filter-group map-filter-grow">
+              <span class="map-locator-filter-label">Search</span>
+              <input type="text" id="map-search-filter" class="map-search-input" placeholder="Callsign, MMSI, locator, message..." />
             </div>
-        <div class="map-corner-controls">
+          </div>
+          <div class="map-overlay-actions">
             <button type="button" id="map-fullscreen-btn" class="map-fullscreen-btn">Fullscreen</button>
             <button type="button" id="map-overlay-toggle-btn" class="map-overlay-toggle-btn">Hide Filters</button>
           </div>
+        </div>
         <div id="map-band-legend" class="map-band-legend" aria-label="Band color legend"></div>
         <div id="aprs-map"></div>
       </div>
       </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 +1195,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 +1491,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 +1597,13 @@ SPDX-License-Identifier: GPL-2.0-or-later
       </template>
     </div>
     <div class="footer">
-      <div class="copyright">
+      <div class="footer-meta">
-        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>
+        <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">
@@ -1629,20 +1637,16 @@ SPDX-License-Identifier: GPL-2.0-or-later
       <div class="shortcut-overlay-hint">Press <kbd>F1</kbd> or <kbd>Esc</kbd> to close</div>
     </div>
   </div>
-  <div id="decode-history-overlay" class="decode-history-overlay is-hidden" aria-live="polite" aria-atomic="true">
+  <div id="decode-history-overlay" class="history-progress is-hidden" role="status" aria-live="polite" aria-atomic="true">
-    <div class="decode-history-overlay-card">
+    <div class="history-progress-text">
-      <div id="decode-history-overlay-title" class="decode-history-overlay-title">Loading decode history…</div>
+      <span id="decode-history-overlay-title" class="history-progress-title">Loading decode history…</span>
-      <div id="decode-history-overlay-sub" class="decode-history-overlay-sub">Preparing recent decodes for the UI</div>
+      <span id="decode-history-overlay-sub" class="history-progress-sub">Preparing recent decodes for the UI</span>
     </div>
+    <span class="history-progress-track"><span id="decode-history-progress-bar" class="history-progress-bar"></span></span>
   </div>
   <script defer src="/vendor/opus-decoder-0.7.11.min.js" charset="UTF-8"></script>
   <script defer src="/vendor/leaflet.js"></script>
-  <script defer src="/leaflet-ais-tracksymbol.js"></script>
+  <script type="module" src="/app.js"></script>
-  <script defer src="/webgl-renderer.js"></script>
+  <!-- Template cloning is handled by the typed application bundle. -->
-  <script defer src="/ui-core.js"></script>
-  <script defer src="/plugin-runtime.js"></script>
-  <script defer src="/plugin-loader.js"></script>
-  <script defer src="/app.js"></script>
-  <!-- Template cloning is handled by navigateToTab() in app.js -->
 </body>
 </html>

src/trx-client/trx-frontend/trx-frontend-http/assets/web/leaflet-ais-tracksymbol.js

@@ -1,120 +0,0 @@
-(function() {
-  if (typeof L === "undefined") return;
-
-  function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-  }
-
-  function finiteAngle(value) {
-    if (!Number.isFinite(value)) return null;
-    const normalized = ((Number(value) % 360) + 360) % 360;
-    return normalized;
-  }
-
-  function svgColor(value, fallback) {
-    const text = String(value || fallback || "");
-    return text.replace(/"/g, """);
-  }
-
-  function buildSymbolHtml(options, zoom) {
-    const heading = finiteAngle(options.heading);
-    const course = finiteAngle(options.course);
-    const angle = heading != null ? heading : course;
-    const speed = Number.isFinite(options.speed) ? Math.max(0, Number(options.speed)) : 0;
-    const sizeBase = Number.isFinite(options.size) ? Number(options.size) : 22;
-    const zoomBoost = zoom >= 12 ? 4 : zoom >= 9 ? 2 : 0;
-    const size = clamp(sizeBase + zoomBoost, 16, 32);
-    const courseLen = course != null ? clamp(size * (0.55 + Math.min(speed, 30) / 30), size * 0.55, size * 1.2) : 0;
-    const color = svgColor(options.color, "#ff7559");
-    const outline = svgColor(options.outline, "#6b2118");
-
-    const body = angle != null
-      ? `<g transform="translate(${size / 2} ${size / 2}) rotate(${angle}) translate(${-size / 2} ${-size / 2})">` +
-          `<path d="M ${size * 0.5} ${size * 0.06} L ${size * 0.82} ${size * 0.78} L ${size * 0.5} ${size * 0.62} L ${size * 0.18} ${size * 0.78} Z" fill="${color}" stroke="${outline}" stroke-width="1.2" stroke-linejoin="round" />` +
-        `</g>`
-      : `<path d="M ${size * 0.5} ${size * 0.12} L ${size * 0.88} ${size * 0.5} L ${size * 0.5} ${size * 0.88} L ${size * 0.12} ${size * 0.5} Z" fill="${color}" stroke="${outline}" stroke-width="1.2" stroke-linejoin="round" />`;
-
-    const courseLine = course != null
-      ? `<g transform="translate(${size / 2} ${size / 2}) rotate(${course})">` +
-          `<line x1="0" y1="${-size * 0.22}" x2="0" y2="${-(size * 0.22 + courseLen)}" stroke="${color}" stroke-width="1.4" stroke-linecap="round" opacity="0.75" />` +
-        `</g>`
-      : "";
-
-    return (
-      `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" aria-hidden="true">` +
-        courseLine +
-        body +
-      `</svg>`
-    );
-  }
-
-  L.TrxAisTrackSymbol = L.Marker.extend({
-    options: {
-      heading: null,
-      course: null,
-      speed: null,
-      color: "#ff7559",
-      outline: "#6b2118",
-      size: 22,
-      interactive: true,
-      keyboard: true,
-      riseOnHover: true,
-    },
-
-    initialize: function(latlng, options) {
-      const merged = L.Util.extend({}, this.options, options || {});
-      merged.icon = L.divIcon({
-        className: "trx-ais-track-symbol-icon",
-        html: "",
-        iconSize: [merged.size, merged.size],
-        iconAnchor: [merged.size / 2, merged.size / 2],
-      });
-      L.Marker.prototype.initialize.call(this, latlng, merged);
-    },
-
-    onAdd: function(map) {
-      L.Marker.prototype.onAdd.call(this, map);
-      this._refreshIcon();
-      this._boundZoomRefresh = this._refreshIcon.bind(this);
-      map.on("zoomend", this._boundZoomRefresh);
-    },
-
-    onRemove: function(map) {
-      if (this._boundZoomRefresh) {
-        map.off("zoomend", this._boundZoomRefresh);
-        this._boundZoomRefresh = null;
-      }
-      L.Marker.prototype.onRemove.call(this, map);
-    },
-
-    setAisState: function(next) {
-      if (next && typeof next === "object") {
-        if ("heading" in next) this.options.heading = next.heading;
-        if ("course" in next) this.options.course = next.course;
-        if ("speed" in next) this.options.speed = next.speed;
-        if ("color" in next) this.options.color = next.color;
-        if ("outline" in next) this.options.outline = next.outline;
-      }
-      this._refreshIcon();
-      return this;
-    },
-
-    _refreshIcon: function() {
-      if (!this._icon) return;
-      const zoom = this._map && typeof this._map.getZoom === "function" ? this._map.getZoom() : 0;
-      const html = buildSymbolHtml(this.options, zoom);
-      this._icon.innerHTML = html;
-      const sizeBase = Number.isFinite(this.options.size) ? Number(this.options.size) : 22;
-      const zoomBoost = zoom >= 12 ? 4 : zoom >= 9 ? 2 : 0;
-      const size = clamp(sizeBase + zoomBoost, 16, 32);
-      this._icon.style.width = `${size}px`;
-      this._icon.style.height = `${size}px`;
-      this._icon.style.marginLeft = `${-size / 2}px`;
-      this._icon.style.marginTop = `${-size / 2}px`;
-    },
-  });
-
-  L.trxAisTrackSymbol = function(latlng, options) {
-    return new L.TrxAisTrackSymbol(latlng, options);
-  };
-})();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/ais.js

@@ -1,407 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- AIS Decoder Plugin (server-side decode) ---
-const aisStatus = document.getElementById("ais-status");
-const aisMessagesEl = document.getElementById("ais-messages");
-const aisFilterInput = document.getElementById("ais-filter");
-const aisBarOverlay = document.getElementById("ais-bar-overlay");
-const aisChannelSummaryEl = document.getElementById("ais-channel-summary");
-const aisVesselCountEl = document.getElementById("ais-vessel-count");
-const aisLatestSeenEl = document.getElementById("ais-latest-seen");
-const AIS_BAR_WINDOW_MS = 15 * 60 * 1000;
-const AIS_DEFAULT_A_HZ = 161_975_000;
-const AIS_CHANNEL_SPACING_HZ = 50_000;
-let aisFilterText = "";
-let aisMessageHistory = [];
-
-function currentAisHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneAisMessageHistory() {
-  const cutoffMs = Date.now() - currentAisHistoryRetentionMs();
-  aisMessageHistory = aisMessageHistory.filter((msg) => Number(msg?._tsMs) >= cutoffMs);
-}
-
-function scheduleAisUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-function scheduleAisHistoryRender() {
-  scheduleAisUi("ais-history", () => renderAisHistory());
-}
-
-function scheduleAisBarUpdate() {
-  scheduleAisUi("ais-bar", () => updateAisBar());
-}
-
-function formatAisMhz(freqHz) {
-  return `${(freqHz / 1_000_000).toFixed(3)} MHz`;
-}
-
-function currentAisChannelPlan() {
-  const raw = (document.getElementById("freq")?.value || "").replace(/[^\d]/g, "");
-  const aHz = raw ? Number(raw) : AIS_DEFAULT_A_HZ;
-  const safeAHz = Number.isFinite(aHz) && aHz > 0 ? aHz : AIS_DEFAULT_A_HZ;
-  return {
-    aHz: safeAHz,
-    bHz: safeAHz + AIS_CHANNEL_SPACING_HZ,
-  };
-}
-
-function aisChannelInfo(channel) {
-  const plan = currentAisChannelPlan();
-  const ch = String(channel || "").trim().toUpperCase();
-  if (ch === "B") {
-    return {
-      label: "AIS-B",
-      badgeClass: "ais-badge ais-badge-channel-b",
-      freqText: formatAisMhz(plan.bHz),
-    };
-  }
-  return {
-    label: "AIS-A",
-    badgeClass: "ais-badge ais-badge-channel-a",
-    freqText: formatAisMhz(plan.aHz),
-  };
-}
-
-function aisDisplayName(msg) {
-  return msg.vessel_name || msg.callsign || `MMSI ${msg.mmsi}`;
-}
-
-function aisDisplayNameHtml(msg) {
-  const label = escapeMapHtml(aisDisplayName(msg));
-  const url = window.buildAisVesselUrl ? window.buildAisVesselUrl(msg?.mmsi) : null;
-  if (!url) return label;
-  return `<a class="title-link" href="${escapeMapHtml(url)}" target="_blank" rel="noopener">${label}</a>`;
-}
-
-function aisTypeLabel(type) {
-  switch (Number(type)) {
-    case 1:
-    case 2:
-    case 3:
-      return "Class A Position";
-    case 4:
-      return "Base Station";
-    case 5:
-      return "Static/Voyage";
-    case 18:
-      return "Class B Position";
-    case 19:
-      return "Class B Extended";
-    case 21:
-      return "Aid to Nav";
-    case 24:
-      return "Class B Static";
-    default:
-      return `Type ${type ?? "--"}`;
-  }
-}
-
-function aisAgeText(tsMs) {
-  if (!Number.isFinite(tsMs)) return "just now";
-  const deltaMs = Math.max(0, Date.now() - tsMs);
-  const seconds = Math.round(deltaMs / 1000);
-  if (seconds < 5) return "just now";
-  if (seconds < 60) return `${seconds}s ago`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${minutes}m ago`;
-  const hours = Math.round(minutes / 60);
-  return `${hours}h ago`;
-}
-
-function aisMotionText(msg) {
-  const parts = [
-    msg.sog_knots != null ? `${Number(msg.sog_knots).toFixed(1)} kn` : null,
-    msg.cog_deg != null ? `${Number(msg.cog_deg).toFixed(1)}° COG` : null,
-    msg.heading_deg != null ? `${Number(msg.heading_deg).toFixed(0)}° HDG` : null,
-  ].filter(Boolean);
-  return parts.join(" · ");
-}
-
-function aisRouteText(msg) {
-  return [msg.callsign, msg.destination].filter(Boolean).join(" -> ");
-}
-
-function aisDistanceText(msg) {
-  if (serverLat == null || serverLon == null || msg?.lat == null || msg?.lon == null) {
-    return "";
-  }
-  const distKm = haversineKm(serverLat, serverLon, msg.lat, msg.lon);
-  if (!Number.isFinite(distKm)) return "";
-  if (distKm < 1) return `${Math.round(distKm * 1000)} m from TRX`;
-  return `${distKm.toFixed(1)} km from TRX`;
-}
-
-function aisLatestByVessel(messages) {
-  const byMmsi = new Map();
-  for (const msg of messages) {
-    const key = Number.isFinite(msg.mmsi) ? String(msg.mmsi) : `${msg.channel || "?"}:${msg._tsMs || 0}`;
-    if (!byMmsi.has(key)) byMmsi.set(key, msg);
-  }
-  return Array.from(byMmsi.values());
-}
-
-function updateAisSummary() {
-  const plan = currentAisChannelPlan();
-  if (aisChannelSummaryEl) {
-    aisChannelSummaryEl.textContent = `A ${formatAisMhz(plan.aHz)} · B ${formatAisMhz(plan.bHz)}`;
-  }
-
-  const vessels = aisLatestByVessel(aisMessageHistory);
-  if (aisVesselCountEl) {
-    const count = vessels.length;
-    aisVesselCountEl.textContent = `${count} vessel${count === 1 ? "" : "s"}`;
-  }
-
-  if (aisLatestSeenEl) {
-    const latest = aisMessageHistory[0];
-    if (!latest) {
-      aisLatestSeenEl.textContent = "No traffic yet";
-    } else {
-      const channel = aisChannelInfo(latest.channel);
-      aisLatestSeenEl.textContent = `${channel.label} ${aisAgeText(latest._tsMs)}`;
-    }
-  }
-}
-
-function renderAisRow(msg) {
-  const row = document.createElement("div");
-  row.className = "ais-message";
-  const ts = msg._ts || new Date().toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-  });
-  const name = aisDisplayName(msg);
-  const nameHtml = aisDisplayNameHtml(msg);
-  const channel = aisChannelInfo(msg.channel);
-  const motion = aisMotionText(msg);
-  const route = aisRouteText(msg);
-  const distance = aisDistanceText(msg);
-  const pos = msg.lat != null && msg.lon != null
-    ? `<a class="ais-pos-link" href="javascript:void(0)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>`
-    : "";
-  row.dataset.filterText = [
-    name,
-    msg.mmsi,
-    msg.channel,
-    channel.label,
-    msg.vessel_name,
-    msg.callsign,
-    msg.destination,
-    aisTypeLabel(msg.message_type),
-  ]
-    .filter(Boolean)
-    .join(" ")
-    .toUpperCase();
-  row.innerHTML =
-    `<div class="ais-row-head">` +
-      `<span class="ais-time">${ts}</span>` +
-      `<span class="ais-call">${nameHtml}</span>` +
-      `<span class="${channel.badgeClass}">${escapeMapHtml(channel.label)}</span>` +
-      `<span class="ais-badge ais-badge-type">${escapeMapHtml(aisTypeLabel(msg.message_type))}</span>` +
-    `</div>` +
-    `<div class="ais-row-meta">` +
-      `<span>MMSI ${escapeMapHtml(String(msg.mmsi))}</span>` +
-      (route ? `<span class="ais-meta-text">${escapeMapHtml(route)}</span>` : "") +
-      `<span class="ais-meta-text">${escapeMapHtml(channel.freqText)}</span>` +
-    `</div>` +
-    `<div class="ais-row-detail">` +
-      (motion ? `<span>${escapeMapHtml(motion)}</span>` : `<span>No motion data</span>`) +
-      (distance ? `<span>${escapeMapHtml(distance)}</span>` : "") +
-      (pos ? `<span>${pos}</span>` : "") +
-      `<span>${escapeMapHtml(aisAgeText(msg._tsMs))}</span>` +
-    `</div>`;
-  applyAisFilterToRow(row);
-  return row;
-}
-
-function applyAisFilterToRow(row) {
-  if (!aisFilterText) {
-    row.style.display = "";
-    return;
-  }
-  const message = row.dataset.filterText || "";
-  row.style.display = message.includes(aisFilterText) ? "" : "none";
-}
-
-function applyAisFilterToAll() {
-  if (!aisMessagesEl) return;
-  const rows = aisMessagesEl.querySelectorAll(".ais-message");
-  rows.forEach((row) => applyAisFilterToRow(row));
-}
-
-function updateAisBar() {
-  if (!aisBarOverlay) return;
-  updateAisSummary();
-
-  const isAis = (document.getElementById("mode")?.value || "").toUpperCase() === "AIS";
-  const cutoffMs = Date.now() - AIS_BAR_WINDOW_MS;
-  const recent = aisMessageHistory.filter((msg) => msg._tsMs >= cutoffMs);
-  const messages = aisLatestByVessel(recent).slice(0, 8);
-  if (!isAis || messages.length === 0) {
-    aisBarOverlay.style.display = "none";
-    aisBarOverlay.innerHTML = "";
-    return;
-  }
-
-  let html = '<div class="aprs-bar-header"><span class="aprs-bar-title"><span class="aprs-bar-title-word">AIS</span><span class="aprs-bar-title-word">Live</span></span><span class="aprs-bar-clear-wrap"><span class="aprs-bar-clear" role="button" tabindex="0" onclick="window.clearAisBar()" onkeydown="if(event.key===\'Enter\'||event.key===\' \'){event.preventDefault();window.clearAisBar();}" aria-label="Clear AIS overlay">Clear</span></span><span class="aprs-bar-window">Last 15 minutes</span></div>';
-  for (const msg of messages) {
-    const ts = msg._ts ? `<span class="aprs-bar-time">${msg._ts}</span>` : "";
-    const pin = msg.lat != null && msg.lon != null
-      ? `<button class="aprs-bar-pin" title="${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">📍</button>`
-      : "";
-    const name = `<span class="ais-call">${aisDisplayNameHtml(msg)}</span>`;
-    const channel = aisChannelInfo(msg.channel);
-    const distance = aisDistanceText(msg);
-    const details = [
-      `MMSI ${escapeMapHtml(String(msg.mmsi))}`,
-      escapeMapHtml(channel.label),
-      msg.sog_knots != null ? `${Number(msg.sog_knots).toFixed(1)} kn` : null,
-      msg.cog_deg != null ? `${Number(msg.cog_deg).toFixed(1)}°` : null,
-      distance ? escapeMapHtml(distance) : null,
-      escapeMapHtml(aisAgeText(msg._tsMs)),
-    ]
-      .filter(Boolean)
-      .join(" · ");
-    html += `<div class="aprs-bar-frame">` +
-      `<div class="aprs-bar-frame-main">${ts}${pin}${name}: ${details}</div>` +
-      `</div>`;
-  }
-  aisBarOverlay.innerHTML = html;
-  aisBarOverlay.style.display = "flex";
-}
-window.updateAisBar = updateAisBar;
-window.clearAisBar = function() {
-  window.resetAisHistoryView();
-};
-
-window.resetAisHistoryView = function() {
-  if (aisMessagesEl) aisMessagesEl.innerHTML = "";
-  aisMessageHistory = [];
-  updateAisBar();
-  renderAisHistory();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("ais");
-};
-
-function renderAisHistory() {
-  pruneAisMessageHistory();
-  if (!aisMessagesEl) {
-    updateAisSummary();
-    return;
-  }
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < aisMessageHistory.length; i += 1) {
-    fragment.appendChild(renderAisRow(aisMessageHistory[i]));
-  }
-  aisMessagesEl.replaceChildren(fragment);
-  updateAisSummary();
-}
-
-function addAisMessage(msg) {
-  const tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  msg._tsMs = tsMs;
-  msg._ts = new Date(tsMs).toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-  });
-
-  aisMessageHistory.unshift(msg);
-  pruneAisMessageHistory();
-  scheduleAisBarUpdate();
-  scheduleAisHistoryRender();
-
-  if (msg.lat != null && msg.lon != null && window.aisMapAddVessel) {
-    window.aisMapAddVessel(msg);
-  }
-}
-
-function normalizeServerAisMessage(msg) {
-  return {
-    rig_id: msg.rig_id || null,
-    channel: msg.channel,
-    message_type: msg.message_type,
-    mmsi: msg.mmsi,
-    lat: msg.lat,
-    lon: msg.lon,
-    sog_knots: msg.sog_knots,
-    cog_deg: msg.cog_deg,
-    heading_deg: msg.heading_deg,
-    vessel_name: msg.vessel_name,
-    callsign: msg.callsign,
-    destination: msg.destination,
-    ts_ms: msg.ts_ms,
-  };
-}
-
-window.onServerAisBatch = function(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  if (aisStatus) aisStatus.textContent = "Receiving";
-  const normalized = [];
-  for (const msg of messages) {
-    const next = normalizeServerAisMessage(msg);
-    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
-    next._tsMs = tsMs;
-    next._ts = new Date(tsMs).toLocaleTimeString([], {
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-    });
-    if (next.lat != null && next.lon != null && window.aisMapAddVessel) {
-      window.aisMapAddVessel(next);
-    }
-    normalized.push(next);
-  }
-  normalized.reverse();
-  aisMessageHistory = normalized.concat(aisMessageHistory);
-  pruneAisMessageHistory();
-  scheduleAisBarUpdate();
-  scheduleAisHistoryRender();
-};
-
-window.restoreAisHistory = function(messages) {
-  window.onServerAisBatch(messages);
-};
-
-window.pruneAisHistoryView = function() {
-  pruneAisMessageHistory();
-  updateAisBar();
-  renderAisHistory();
-};
-
-document.getElementById("settings-clear-ais-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear AIS history?", message: "All stored AIS messages will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_ais_decode");
-    window.resetAisHistoryView();
-  } catch (e) {
-    console.error("AIS history clear failed", e);
-  }
-});
-
-if (aisFilterInput) {
-  aisFilterInput.addEventListener("input", () => {
-    aisFilterText = aisFilterInput.value.trim().toUpperCase();
-    renderAisHistory();
-  });
-}
-
-window.onServerAis = function(msg) {
-  if (aisStatus) aisStatus.textContent = "Receiving";
-  addAisMessage(normalizeServerAisMessage(msg));
-};
-
-updateAisSummary();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("ais");

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

@@ -1,498 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- APRS Decoder Plugin (server-side decode) ---
-const aprsStatus = document.getElementById("aprs-status");
-const aprsPacketsEl = document.getElementById("aprs-packets");
-const aprsFilterInput = document.getElementById("aprs-filter");
-const aprsBarOverlay = document.getElementById("aprs-bar-overlay");
-const aprsOnlyPosBtn = document.getElementById("aprs-only-pos-btn");
-const aprsHideCrcBtn = document.getElementById("aprs-hide-crc-btn");
-const aprsCollapseDupBtn = document.getElementById("aprs-collapse-dup-btn");
-const aprsTotalCountEl = document.getElementById("aprs-total-count");
-const aprsVisibleCountEl = document.getElementById("aprs-visible-count");
-const aprsLatestSeenEl = document.getElementById("aprs-latest-seen");
-const APRS_BAR_WINDOW_MS = 15 * 60 * 1000;
-let aprsFilterText = "";
-let aprsPacketHistory = [];
-let aprsBarDismissedAtMs = 0;
-let aprsOnlyPos = false;
-let aprsHideCrc = false;
-let aprsCollapseDup = false;
-let aprsTypeFilter = "all";
-
-function currentAprsHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneAprsPacketHistory() {
-  const cutoffMs = Date.now() - currentAprsHistoryRetentionMs();
-  aprsPacketHistory = aprsPacketHistory.filter((pkt) => Number(pkt?._tsMs) >= cutoffMs);
-}
-
-function scheduleAprsUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-function scheduleAprsHistoryRender() {
-  scheduleAprsUi("aprs-history", () => renderAprsHistory());
-}
-
-function scheduleAprsBarUpdate() {
-  scheduleAprsUi("aprs-bar", () => updateAprsBar());
-}
-
-function renderAprsInfo(pkt) {
-  const bytes = Array.isArray(pkt.info_bytes) ? pkt.info_bytes : null;
-  if (bytes && bytes.length > 0) {
-    let out = "";
-    for (let i = 0; i < bytes.length; i++) {
-      const b = bytes[i];
-      if (b >= 0x20 && b <= 0x7e) {
-        const ch = String.fromCharCode(b);
-        if (ch === "<") out += "&lt;";
-        else if (ch === ">") out += "&gt;";
-        else if (ch === "&") out += "&amp;";
-        else if (ch === '"') out += "&quot;";
-        else out += ch;
-      } else {
-        const hex = b.toString(16).toUpperCase().padStart(2, "0");
-        out += `<span class="aprs-byte">0x${hex}</span>`;
-      }
-    }
-    return out;
-  }
-  const str = pkt.info || "";
-  let out = "";
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    if (code >= 0x20 && code <= 0x7e) {
-      const ch = str[i];
-      if (ch === "<") out += "&lt;";
-      else if (ch === ">") out += "&gt;";
-      else if (ch === "&") out += "&amp;";
-      else if (ch === '"') out += "&quot;";
-      else out += ch;
-    } else {
-      const hex = code.toString(16).toUpperCase().padStart(2, "0");
-      out += `<span class="aprs-byte">0x${hex}</span>`;
-    }
-  }
-  return out;
-}
-
-function aprsPacketCategory(pkt) {
-  const type = String(pkt.type || "").toLowerCase();
-  const info = String(pkt.info || "").toLowerCase();
-  if (pkt.lat != null && pkt.lon != null || type.includes("position")) return "position";
-  if (type.includes("message") || info.startsWith(":")) return "message";
-  if (type.includes("weather") || info.startsWith("_")) return "weather";
-  if (type.includes("telemetry") || info.startsWith("t#")) return "telemetry";
-  return "other";
-}
-
-function aprsCategoryLabel(category) {
-  switch (category) {
-    case "position": return "Position";
-    case "message": return "Message";
-    case "weather": return "Weather";
-    case "telemetry": return "Telemetry";
-    default: return "Other";
-  }
-}
-
-function aprsAgeText(tsMs) {
-  if (!Number.isFinite(tsMs)) return "just now";
-  const deltaMs = Math.max(0, Date.now() - tsMs);
-  const seconds = Math.round(deltaMs / 1000);
-  if (seconds < 5) return "just now";
-  if (seconds < 60) return `${seconds}s ago`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${minutes}m ago`;
-  const hours = Math.round(minutes / 60);
-  return `${hours}h ago`;
-}
-
-function aprsDistanceText(pkt) {
-  if (serverLat == null || serverLon == null || pkt.lat == null || pkt.lon == null) return "";
-  const distKm = haversineKm(serverLat, serverLon, pkt.lat, pkt.lon);
-  if (!Number.isFinite(distKm)) return "";
-  if (distKm < 1) return `${Math.round(distKm * 1000)} m from TRX`;
-  return `${distKm.toFixed(1)} km from TRX`;
-}
-
-function aprsPacketSignature(pkt) {
-  return [
-    pkt.srcCall || "",
-    pkt.destCall || "",
-    pkt.path || "",
-    pkt.info || "",
-    pkt.type || "",
-    pkt.lat != null ? pkt.lat.toFixed(4) : "",
-    pkt.lon != null ? pkt.lon.toFixed(4) : "",
-  ].join("|");
-}
-
-function aprsHexBytes(bytes) {
-  if (!Array.isArray(bytes) || bytes.length === 0) return "--";
-  return bytes.map((b) => Number(b).toString(16).toUpperCase().padStart(2, "0")).join(" ");
-}
-
-function aprsFilterMatch(pkt) {
-  if (aprsOnlyPos && (pkt.lat == null || pkt.lon == null)) return false;
-  if (aprsHideCrc && !pkt.crcOk) return false;
-  if (aprsTypeFilter !== "all" && aprsPacketCategory(pkt) !== aprsTypeFilter) return false;
-  if (!aprsFilterText) return true;
-  const haystack = [
-    pkt.srcCall,
-    pkt.destCall,
-    pkt.path,
-    pkt.info,
-    pkt.type,
-    pkt.lat != null ? pkt.lat.toFixed(4) : "",
-    pkt.lon != null ? pkt.lon.toFixed(4) : "",
-    aprsPacketCategory(pkt),
-  ]
-    .filter(Boolean)
-    .join(" ")
-    .toUpperCase();
-  return haystack.includes(aprsFilterText);
-}
-
-function aprsVisiblePackets() {
-  const packets = aprsCollapseDup ? collapseAprsDuplicates(aprsPacketHistory) : aprsPacketHistory;
-  return packets.filter(aprsFilterMatch);
-}
-
-function collapseAprsDuplicates(packets) {
-  const seen = new Set();
-  const out = [];
-  for (const pkt of packets) {
-    const key = aprsPacketSignature(pkt);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(pkt);
-  }
-  return out;
-}
-
-function updateAprsSummary() {
-  const visible = aprsVisiblePackets();
-  if (aprsTotalCountEl) {
-    aprsTotalCountEl.textContent = `${aprsPacketHistory.length} total`;
-  }
-  if (aprsVisibleCountEl) {
-    aprsVisibleCountEl.textContent = `${visible.length} shown`;
-  }
-  if (aprsLatestSeenEl) {
-    const latest = aprsPacketHistory[0];
-    if (!latest) {
-      aprsLatestSeenEl.textContent = "No packets yet";
-    } else {
-      aprsLatestSeenEl.textContent = `${latest.srcCall} ${aprsAgeText(latest._tsMs)}`;
-    }
-  }
-}
-
-function updateAprsChipState() {
-  document.querySelectorAll("[id^='aprs-type-']").forEach((btn) => {
-    btn.classList.toggle("active", btn.id === `aprs-type-${aprsTypeFilter}`);
-  });
-  aprsOnlyPosBtn?.classList.toggle("active", aprsOnlyPos);
-  aprsHideCrcBtn?.classList.toggle("active", aprsHideCrc);
-  aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
-}
-
-function renderAprsRow(pkt, isFresh) {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-
-  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  const age = aprsAgeText(pkt._tsMs);
-  const category = aprsPacketCategory(pkt);
-  const categoryLabel = aprsCategoryLabel(category);
-  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeMapHtml(pkt.path)}</span>` : "";
-  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-  let symbolHtml = "";
-  if (pkt.symbolTable && pkt.symbolCode) {
-    const sheet = pkt.symbolTable === "/" ? 0 : 1;
-    const code = pkt.symbolCode.charCodeAt(0) - 33;
-    const col = code % 16;
-    const row2 = Math.floor(code / 16);
-    const bgX = -(col * 24);
-    const bgY = -(row2 * 24);
-    symbolHtml = `<span class="aprs-symbol" style="background-image:url('https://raw.githubusercontent.com/hessu/aprs-symbols/master/png/aprs-symbols-24-${sheet}.png');background-position:${bgX}px ${bgY}px"></span>`;
-  }
-  const posLink = pkt.lat != null && pkt.lon != null
-    ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>`
-    : "";
-  const distance = aprsDistanceText(pkt);
-  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
-
-  row.innerHTML =
-    `<div class="aprs-row-head">` +
-      `<span class="aprs-time">${ts}</span>` +
-      symbolHtml +
-      `<span class="aprs-call">${escapeMapHtml(pkt.srcCall)}</span>` +
-      `<span>&gt;${escapeMapHtml(pkt.destCall || "")}</span>` +
-      `<span class="${categoryClass}">${escapeMapHtml(categoryLabel)}</span>` +
-      pathBadge +
-      crcBadge +
-    `</div>` +
-    `<div class="aprs-row-meta">` +
-      `<span class="aprs-meta-text">${escapeMapHtml(age)}</span>` +
-      (distance ? `<span class="aprs-meta-text">${escapeMapHtml(distance)}</span>` : "") +
-      `<span class="aprs-meta-text">${escapeMapHtml(pkt.type || "--")}</span>` +
-    `</div>` +
-    `<div class="aprs-row-detail">` +
-      `<span title="${escapeMapHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
-      (posLink ? `<span>${posLink}</span>` : "") +
-    `</div>` +
-    `<div class="aprs-row-actions">` +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") +
-      `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
-    `</div>` +
-    `<details class="aprs-details">` +
-      `<summary>Details</summary>` +
-      `<div class="aprs-details-grid">` +
-        `<span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeMapHtml(pkt.srcCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeMapHtml(pkt.destCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeMapHtml(pkt.type || "--")}</span>` +
-        `<span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeMapHtml(pkt.path || "--")}</span>` +
-        `<span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeMapHtml(age)}</span>` +
-        `<span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span>` +
-        `<span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span>` +
-        `<span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeMapHtml(pkt.info || "--")}</span>` +
-        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeMapHtml(aprsHexBytes(pkt.info_bytes))}</span>` +
-      `</div>` +
-    `</details>`;
-
-  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
-    el.addEventListener("click", (evt) => {
-      evt.preventDefault();
-      const raw = String(el.dataset.aprsMap || "");
-      const [lat, lon] = raw.split(",").map(Number);
-      if (window.navigateToAprsMap && Number.isFinite(lat) && Number.isFinite(lon)) {
-        window.navigateToAprsMap(lat, lon);
-      }
-    });
-  });
-
-  const copyBtn = row.querySelector("[data-aprs-copy]");
-  if (copyBtn) {
-    copyBtn.addEventListener("click", async () => {
-      const raw = String(copyBtn.dataset.aprsCopy || "");
-      try {
-        if (navigator.clipboard?.writeText) {
-          await navigator.clipboard.writeText(raw);
-          showHint("Coordinates copied", 1200);
-        }
-      } catch (_e) {
-        showHint("Copy failed", 1500);
-      }
-    });
-  }
-
-  return row;
-}
-
-function renderAprsHistory() {
-  pruneAprsPacketHistory();
-  if (!aprsPacketsEl) {
-    updateAprsSummary();
-    updateAprsChipState();
-    return;
-  }
-  const visible = aprsVisiblePackets();
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < visible.length; i++) {
-    fragment.appendChild(renderAprsRow(visible[i], i === 0));
-  }
-  aprsPacketsEl.replaceChildren(fragment);
-  updateAprsSummary();
-  updateAprsChipState();
-}
-
-function updateAprsBar() {
-  if (!aprsBarOverlay) return;
-  const isPkt = (document.getElementById("mode")?.value || "").toUpperCase() === "PKT";
-  const cutoffMs = Date.now() - APRS_BAR_WINDOW_MS;
-  const okFrames = aprsPacketHistory.filter((p) => p.crcOk && p._tsMs >= cutoffMs);
-  const frames = collapseAprsDuplicates(okFrames).slice(0, 8);
-  const newestTsMs = frames.reduce((latest, pkt) => Math.max(latest, Number(pkt._tsMs) || 0), 0);
-  if (!isPkt || frames.length === 0 || newestTsMs <= aprsBarDismissedAtMs) {
-    aprsBarOverlay.style.display = "none";
-    aprsBarOverlay.innerHTML = "";
-    return;
-  }
-  let html = '<div class="aprs-bar-header"><span class="aprs-bar-title"><span class="aprs-bar-title-word">APRS</span><span class="aprs-bar-title-word">Live</span></span><span class="aprs-bar-actions"><span class="aprs-bar-window">Last 15 minutes</span><span class="aprs-bar-clear-wrap"><span class="aprs-bar-clear" role="button" tabindex="0" onclick="window.clearAprsBar()" onkeydown="if(event.key===\'Enter\'||event.key===\' \'){event.preventDefault();window.clearAprsBar();}" aria-label="Clear APRS overlay">Clear</span></span><button class="aprs-bar-close" type="button" onclick="window.closeAprsBar()" aria-label="Close APRS overlay">&times;</button></span></div>';
-  for (const pkt of frames) {
-    const ts = pkt._ts ? `<span class="aprs-bar-time">${pkt._ts}</span>` : "";
-    const call = `<span class="aprs-bar-call">${escapeMapHtml(pkt.srcCall)}</span>`;
-    const dest = escapeMapHtml(pkt.destCall || "");
-    const info = escapeMapHtml(pkt.info || "");
-    const pin = pkt.lat != null && pkt.lon != null
-      ? `<button class="aprs-bar-pin" title="${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}" onclick="window.navigateToAprsMap(${pkt.lat},${pkt.lon})">📍</button>`
-      : "";
-    html += `<div class="aprs-bar-frame">` +
-      `<div class="aprs-bar-frame-main">${ts}${pin}${call}>${dest}: ${info}</div>` +
-      `</div>`;
-  }
-  aprsBarOverlay.innerHTML = html;
-  aprsBarOverlay.style.display = "flex";
-}
-window.updateAprsBar = updateAprsBar;
-window.clearAprsBar = function() {
-  window.resetAprsHistoryView();
-};
-window.closeAprsBar = function() {
-  aprsBarDismissedAtMs = Date.now();
-  if (aprsBarOverlay) {
-    aprsBarOverlay.style.display = "none";
-    aprsBarOverlay.innerHTML = "";
-  }
-};
-
-window.resetAprsHistoryView = function() {
-  if (aprsPacketsEl) aprsPacketsEl.innerHTML = "";
-  aprsPacketHistory = [];
-  updateAprsBar();
-  renderAprsHistory();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("aprs");
-};
-
-window.pruneAprsHistoryView = function() {
-  pruneAprsPacketHistory();
-  updateAprsBar();
-  renderAprsHistory();
-};
-
-function addAprsPacket(pkt) {
-  const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
-  pkt._tsMs = tsMs;
-  pkt._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-
-  aprsPacketHistory.unshift(pkt);
-  pruneAprsPacketHistory();
-
-  if (pkt.lat != null && pkt.lon != null && window.aprsMapAddStation) {
-    window.aprsMapAddStation(pkt.srcCall, pkt.lat, pkt.lon, pkt.info, pkt.symbolTable, pkt.symbolCode, pkt);
-  }
-
-  if (pkt.crcOk) scheduleAprsBarUpdate();
-
-  scheduleAprsHistoryRender();
-}
-
-function normalizeServerAprsPacket(pkt) {
-  return {
-    rig_id: pkt.rig_id || null,
-    receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
-    srcCall: pkt.src_call,
-    destCall: pkt.dest_call,
-    path: pkt.path,
-    info: pkt.info,
-    info_bytes: pkt.info_bytes,
-    type: pkt.packet_type,
-    crcOk: pkt.crc_ok,
-    ts_ms: pkt.ts_ms,
-    lat: pkt.lat,
-    lon: pkt.lon,
-    symbolTable: pkt.symbol_table,
-    symbolCode: pkt.symbol_code,
-  };
-}
-
-window.onServerAprsBatch = function(packets) {
-  if (!Array.isArray(packets) || packets.length === 0) return;
-  aprsStatus.textContent = "Receiving";
-  const normalized = [];
-  let hasCrcOk = false;
-  for (const pkt of packets) {
-    const next = normalizeServerAprsPacket(pkt);
-    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
-    next._tsMs = tsMs;
-    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    if (next.lat != null && next.lon != null && window.aprsMapAddStation) {
-      window.aprsMapAddStation(next.srcCall, next.lat, next.lon, next.info, next.symbolTable, next.symbolCode, next);
-    }
-    if (next.crcOk) hasCrcOk = true;
-    normalized.push(next);
-  }
-  normalized.reverse();
-  aprsPacketHistory = normalized.concat(aprsPacketHistory);
-  pruneAprsPacketHistory();
-  if (hasCrcOk) scheduleAprsBarUpdate();
-  scheduleAprsHistoryRender();
-};
-
-window.restoreAprsHistory = function(packets) {
-  window.onServerAprsBatch(packets);
-};
-
-document.getElementById("settings-clear-aprs-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear APRS history?", message: "All stored APRS packets will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_aprs_decode");
-    window.resetAprsHistoryView();
-  } catch (e) {
-    console.error("APRS history clear failed", e);
-  }
-});
-
-if (aprsOnlyPosBtn) {
-  aprsOnlyPosBtn.addEventListener("click", () => {
-    aprsOnlyPos = !aprsOnlyPos;
-    renderAprsHistory();
-  });
-}
-
-if (aprsHideCrcBtn) {
-  aprsHideCrcBtn.addEventListener("click", () => {
-    aprsHideCrc = !aprsHideCrc;
-    renderAprsHistory();
-  });
-}
-
-if (aprsCollapseDupBtn) {
-  aprsCollapseDupBtn.addEventListener("click", () => {
-    aprsCollapseDup = !aprsCollapseDup;
-    renderAprsHistory();
-  });
-}
-
-["all", "position", "message", "weather", "telemetry", "other"].forEach((type) => {
-  const btn = document.getElementById(`aprs-type-${type}`);
-  if (!btn) return;
-  btn.addEventListener("click", () => {
-    aprsTypeFilter = type;
-    renderAprsHistory();
-  });
-});
-
-if (aprsFilterInput) {
-  aprsFilterInput.addEventListener("input", () => {
-    aprsFilterText = aprsFilterInput.value.trim().toUpperCase();
-    renderAprsHistory();
-  });
-}
-
-// --- Server-side APRS decode handler ---
-window.onServerAprs = function(pkt) {
-  aprsStatus.textContent = "Receiving";
-  addAprsPacket(normalizeServerAprsPacket(pkt));
-};
-
-renderAprsHistory();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("aprs");

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/background-decode.js

@@ -1,410 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-(function () {
-  "use strict";
-
-  function bgdSupportedIds() {
-    return (window.decoderRegistry || [])
-      .filter(function (d) { return d.background_decode; })
-      .map(function (d) { return d.id; });
-  }
-
-  let backgroundDecodeRole = null;
-  let currentRigId = null;
-  let currentConfig = null;
-  let bookmarkList = [];
-  let statusInterval = null;
-  let bgdDirty = false;
-
-  function initBackgroundDecode(rigId, role) {
-    backgroundDecodeRole = role;
-    currentRigId = rigId || null;
-    if (currentRigId) loadBackgroundDecode();
-    startStatusPolling();
-  }
-
-  function setBackgroundDecodeRig(rigId) {
-    const nextRigId = rigId || null;
-    if (nextRigId === currentRigId) return;
-    currentRigId = nextRigId;
-    if (!currentRigId) return;
-    loadBackgroundDecode();
-  }
-
-  function apiGetConfig(rigId) {
-    return fetch("/background-decode/" + encodeURIComponent(rigId)).then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
-    });
-  }
-
-  function apiPutConfig(rigId, config) {
-    return fetch("/background-decode/" + encodeURIComponent(rigId), {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(config),
-    }).then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
-    });
-  }
-
-  function apiResetConfig(rigId) {
-    return fetch("/background-decode/" + encodeURIComponent(rigId), {
-      method: "DELETE",
-    }).then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
-    });
-  }
-
-  function apiGetStatus(rigId) {
-    return fetch("/background-decode/" + encodeURIComponent(rigId) + "/status").then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
-    });
-  }
-
-  function apiGetBookmarks() {
-    return fetch("/bookmarks").then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
-    });
-  }
-
-  function loadBackgroundDecode() {
-    const rigId = currentRigId;
-    if (!rigId) return;
-    Promise.all([apiGetConfig(rigId), apiGetBookmarks()])
-      .then(function ([config, bookmarks]) {
-        currentConfig = config || { remote: rigId, enabled: false, bookmark_ids: [] };
-        bookmarkList = Array.isArray(bookmarks) ? bookmarks : [];
-        renderBackgroundDecode();
-        clearBgdDirty();
-        pollBackgroundDecodeStatus();
-      })
-      .catch(function (err) {
-        console.error("background decode load failed", err);
-      });
-  }
-
-  function supportedBookmarks() {
-    return bookmarkList.filter(function (bookmark) {
-      return bookmarkDecoderKinds(bookmark).length > 0;
-    });
-  }
-
-  function bookmarkDecoderKinds(bookmark) {
-    var ids = bgdSupportedIds();
-    var decoders = Array.isArray(bookmark && bookmark.decoders) ? bookmark.decoders : [];
-    var explicit = decoders
-      .map(function (item) { return String(item || "").trim().toLowerCase(); })
-      .filter(function (item, index, arr) {
-        return ids.indexOf(item) >= 0 && arr.indexOf(item) === index;
-      });
-    if (explicit.length > 0) return explicit;
-    // Fall back: infer from mode via mode-bound entries in the registry.
-    var mode = String(bookmark && bookmark.mode || "").trim().toUpperCase();
-    return (window.decoderRegistry || [])
-      .filter(function (d) {
-        return d.activation === "mode_bound" && d.background_decode
-          && d.active_modes.indexOf(mode) >= 0;
-      })
-      .map(function (d) { return d.id; });
-  }
-
-  function renderBackgroundDecode() {
-    if (!currentConfig) {
-      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
-    }
-    setCheckbox("background-decode-enabled", !!currentConfig.enabled);
-    renderBookmarkChecklist();
-
-    const isControl = backgroundDecodeRole === "control" || (typeof authEnabled !== "undefined" && !authEnabled);
-    const panel = document.getElementById("background-decode-panel");
-    if (panel) {
-      panel.querySelectorAll("input, select, button.sch-write").forEach(function (el) {
-        el.disabled = !isControl;
-      });
-    }
-    const saveBtn = document.getElementById("background-decode-save-btn");
-    const resetBtn = document.getElementById("background-decode-reset-btn");
-    if (saveBtn) saveBtn.style.display = isControl ? "" : "none";
-    if (resetBtn) resetBtn.style.display = isControl ? "" : "none";
-  }
-
-  function renderBookmarkChecklist(filterText) {
-    const container = document.getElementById("bgd-bookmark-checklist");
-    if (!container) return;
-    container.innerHTML = "";
-
-    const selectedIds = new Set(
-      currentConfig && Array.isArray(currentConfig.bookmark_ids) ? currentConfig.bookmark_ids : []
-    );
-    const all = supportedBookmarks();
-    const filter = (filterText || "").trim().toLowerCase();
-
-    const filtered = filter
-      ? all.filter(function (bm) {
-          var text = (bm.name + " " + formatFreq(bm.freq_hz) + " " + bm.mode).toLowerCase();
-          return text.indexOf(filter) >= 0;
-        })
-      : all;
-
-    if (filtered.length === 0) {
-      container.innerHTML = '<div class="bgd-checklist-empty">' +
-        (all.length === 0 ? "No supported bookmarks available." : "No bookmarks match filter.") +
-        '</div>';
-      return;
-    }
-
-    filtered.forEach(function (bookmark) {
-      var row = document.createElement("label");
-      row.className = "bgd-checklist-row";
-      var decoders = bookmarkDecoderKinds(bookmark);
-      var checked = selectedIds.has(bookmark.id) ? " checked" : "";
-      row.innerHTML =
-        '<input type="checkbox"' + checked + ' data-bm-id="' + escHtml(bookmark.id) + '" />' +
-        '<span class="bgd-checklist-name">' + escHtml(bookmark.name) + '</span>' +
-        '<span class="bgd-checklist-meta">' + escHtml(formatFreq(bookmark.freq_hz) + " " + bookmark.mode + " · " + decoders.join("/").toUpperCase()) + '</span>';
-      row.querySelector("input").addEventListener("change", function (e) {
-        onChecklistToggle(bookmark.id, e.target.checked);
-      });
-      container.appendChild(row);
-    });
-  }
-
-  function onChecklistToggle(bookmarkId, checked) {
-    if (!currentConfig) {
-      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
-    }
-    if (!Array.isArray(currentConfig.bookmark_ids)) currentConfig.bookmark_ids = [];
-    if (checked && !currentConfig.bookmark_ids.includes(bookmarkId)) {
-      currentConfig.bookmark_ids.push(bookmarkId);
-    } else if (!checked) {
-      currentConfig.bookmark_ids = currentConfig.bookmark_ids.filter(function (id) { return id !== bookmarkId; });
-    }
-    markBgdDirty();
-  }
-
-  function saveBackgroundDecode() {
-    const rigId = currentRigId;
-    if (!rigId) return;
-    const payload = {
-      remote: rigId,
-      enabled: !!document.getElementById("background-decode-enabled").checked,
-      bookmark_ids: Array.isArray(currentConfig && currentConfig.bookmark_ids) ? currentConfig.bookmark_ids.slice() : [],
-    };
-    const btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.disabled = true;
-    apiPutConfig(rigId, payload)
-      .then(function (saved) {
-        currentConfig = saved;
-        renderBackgroundDecode();
-        clearBgdDirty();
-        pollBackgroundDecodeStatus();
-        showToast("Background decode saved.");
-      })
-      .catch(function (err) {
-        showToast("Save failed: " + err.message, true);
-      })
-      .finally(function () {
-        if (btn) btn.disabled = false;
-      });
-  }
-
-  async function resetBackgroundDecode() {
-    const rigId = currentRigId;
-    if (!rigId) return;
-    if (!await window.trxUi.confirm({ title: "Reset background decoding?", message: "The current background decode configuration will be permanently reset.", confirmLabel: "Reset" })) return;
-    apiResetConfig(rigId)
-      .then(function (saved) {
-        currentConfig = saved;
-        renderBackgroundDecode();
-        clearBgdDirty();
-        pollBackgroundDecodeStatus();
-        showToast("Background decode reset.");
-      })
-      .catch(function (err) {
-        showToast("Reset failed: " + err.message, true);
-      });
-  }
-
-  function startStatusPolling() {
-    if (statusInterval) clearInterval(statusInterval);
-    statusInterval = setInterval(pollBackgroundDecodeStatus, 15000);
-  }
-
-  function pollBackgroundDecodeStatus() {
-    const rigId = currentRigId;
-    if (!rigId) return;
-    apiGetStatus(rigId)
-      .then(renderStatus)
-      .catch(function () {});
-  }
-
-  function renderStatus(status) {
-    const card = document.getElementById("background-decode-status-card");
-    if (!card) return;
-    const entries = Array.isArray(status && status.entries) ? status.entries : [];
-    if (!entries.length) {
-      card.textContent = "No background decode bookmarks configured.";
-      return;
-    }
-    const summary = [];
-    if (status.active_rig) {
-      if (Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
-      if (Number.isFinite(status.sample_rate) && status.sample_rate > 0) summary.push("Span ±" + formatFreq(status.sample_rate / 2));
-    } else {
-      summary.push("This rig is not currently selected for audio.");
-    }
-    let html = summary.length ? '<div style="margin-bottom:0.8rem;color:var(--text-muted);">' + escHtml(summary.join(" · ")) + "</div>" : "";
-    html += '<div class="bgd-status-list">';
-    entries.forEach(function (entry) {
-      const name = entry.bookmark_name || entry.bookmark_id || "Unknown bookmark";
-      const parts = [];
-      if (Number.isFinite(entry.freq_hz)) parts.push(formatFreq(entry.freq_hz));
-      if (entry.mode) parts.push(entry.mode);
-      if (Array.isArray(entry.decoder_kinds) && entry.decoder_kinds.length) {
-        parts.push(entry.decoder_kinds.join("/").toUpperCase());
-      }
-      html +=
-        '<div class="bgd-status-row">' +
-          '<div>' +
-            '<div class="bgd-status-name">' + escHtml(name) + '</div>' +
-            '<div class="bgd-status-meta">' + escHtml(parts.join(" · ")) + '</div>' +
-          '</div>' +
-          '<div class="bgd-status-state" data-state="' + escHtml(entry.state || "inactive") + '">' +
-            '<svg class="bgd-state-dot" viewBox="0 0 8 8"><circle cx="4" cy="4" r="3.5"/></svg>' +
-            escHtml(prettyState(entry.state)) + '</div>' +
-        '</div>';
-    });
-    html += "</div>";
-    card.innerHTML = html;
-  }
-
-  function prettyState(state) {
-    switch (state) {
-      case "active": return "\u2713 Active";
-      case "out_of_span": return "\u25B3 Out of span";
-      case "waiting_for_spectrum": return "\u25B3 Waiting";
-      case "waiting_for_user": return "\u25B3 No user";
-      case "missing_bookmark": return "\u2717 Missing";
-      case "no_supported_decoders": return "\u2717 Unsupported";
-      case "disabled": return "\u25B3 Disabled";
-      case "handled_by_scheduler": return "\u25B3 Scheduler";
-      case "scheduler_has_control": return "\u25B3 Scheduler";
-      case "handled_by_virtual_channel": return "\u25B3 VChan";
-      default: return "\u25B3 Inactive";
-    }
-  }
-
-  function setCheckbox(id, value) {
-    const el = document.getElementById(id);
-    if (el) el.checked = !!value;
-  }
-
-  function formatFreq(hz) {
-    if (!Number.isFinite(hz) || hz <= 0) return "--";
-    if (hz >= 1e6) return (hz / 1e6).toFixed(3).replace(/\.?0+$/, "") + " MHz";
-    if (hz >= 1e3) return (hz / 1e3).toFixed(1).replace(/\.?0+$/, "") + " kHz";
-    return hz + " Hz";
-  }
-
-  function escHtml(value) {
-    return String(value == null ? "" : value)
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;");
-  }
-
-  function markBgdDirty() {
-    if (bgdDirty) return;
-    bgdDirty = true;
-    var btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.classList.add("sch-dirty");
-  }
-
-  function clearBgdDirty() {
-    bgdDirty = false;
-    var btn = document.getElementById("background-decode-save-btn");
-    if (btn) btn.classList.remove("sch-dirty");
-  }
-
-  function showToast(msg, isError) {
-    const el = document.getElementById("background-decode-toast");
-    if (!el) return;
-    el.textContent = msg;
-    el.style.background = isError ? "var(--color-error, #c00)" : "var(--accent-green)";
-    el.style.display = "block";
-    setTimeout(function () {
-      el.style.display = "none";
-    }, 3000);
-  }
-
-  function selectAllBookmarks() {
-    if (!currentConfig) {
-      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
-    }
-    var ids = supportedBookmarks().map(function (bm) { return bm.id; });
-    currentConfig.bookmark_ids = ids;
-    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
-    markBgdDirty();
-  }
-
-  function deselectAllBookmarks() {
-    if (!currentConfig) {
-      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
-    }
-    currentConfig.bookmark_ids = [];
-    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
-    markBgdDirty();
-  }
-
-  function wireBackgroundDecodeEvents() {
-    const filterInput = document.getElementById("bgd-bookmark-filter");
-    if (filterInput && !filterInput._wired) {
-      filterInput._wired = true;
-      filterInput.addEventListener("input", function () {
-        renderBookmarkChecklist(filterInput.value);
-      });
-    }
-
-    const enabledCb = document.getElementById("background-decode-enabled");
-    if (enabledCb && !enabledCb._wired) {
-      enabledCb._wired = true;
-      enabledCb.addEventListener("change", function () { markBgdDirty(); });
-    }
-
-    const selectAllBtn = document.getElementById("bgd-select-all-btn");
-    if (selectAllBtn && !selectAllBtn._wired) {
-      selectAllBtn._wired = true;
-      selectAllBtn.addEventListener("click", selectAllBookmarks);
-    }
-
-    const deselectAllBtn = document.getElementById("bgd-deselect-all-btn");
-    if (deselectAllBtn && !deselectAllBtn._wired) {
-      deselectAllBtn._wired = true;
-      deselectAllBtn.addEventListener("click", deselectAllBookmarks);
-    }
-
-    const saveBtn = document.getElementById("background-decode-save-btn");
-    if (saveBtn && !saveBtn._wired) {
-      saveBtn._wired = true;
-      saveBtn.addEventListener("click", saveBackgroundDecode);
-    }
-
-    const resetBtn = document.getElementById("background-decode-reset-btn");
-    if (resetBtn && !resetBtn._wired) {
-      resetBtn._wired = true;
-      resetBtn.addEventListener("click", resetBackgroundDecode);
-    }
-  }
-
-  window.initBackgroundDecode = initBackgroundDecode;
-  window.wireBackgroundDecodeEvents = wireBackgroundDecodeEvents;
-  window.setBackgroundDecodeRig = setBackgroundDecodeRig;
-})();

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

@@ -1,807 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- Bookmarks Tab ---
-
-/** Current bookmark scope: "general" or a rig remote name. */
-let bmScope = "general";
-
-/** Build the ?scope= query string for a given or current bookmark scope. */
-function bmScopeParam(prefix, scope) {
-  const sep = prefix ? "&" : "?";
-  return sep + "scope=" + encodeURIComponent(scope != null ? scope : bmScope);
-}
-
-var bmList = [];
-var bmRevision = 0;
-/** Overlay list: always merged general + active rig bookmarks (for spectrum/map). */
-var bmOverlayList = [];
-var bmOverlayRevision = 0;
-let bmFilteredList = [];
-let bmEditId = null;
-let bmEditScope = null;
-let bmCurrentPage = 1;
-const BM_PAGE_SIZE = 25;
-const bmSelected = new Set();
-
-function bmFmtFreq(hz) {
-  if (!Number.isFinite(hz) || hz <= 0) return "--";
-  if (hz >= 1e9) return (hz / 1e9).toFixed(6).replace(/\.?0+$/, "") + "\u202fGHz";
-  if (hz >= 1e6) return (hz / 1e6).toFixed(6).replace(/\.?0+$/, "") + "\u202fMHz";
-  if (hz >= 1e3) return (hz / 1e3).toFixed(3).replace(/\.?0+$/, "") + "\u202fkHz";
-  return hz + "\u202fHz";
-}
-
-function bmEsc(str) {
-  const d = document.createElement("div");
-  d.appendChild(document.createTextNode(String(str)));
-  return d.innerHTML;
-}
-
-function bmCanControl() {
-  return (
-    (typeof authEnabled !== "undefined" && !authEnabled) ||
-    (typeof authRole !== "undefined" && authRole === "control")
-  );
-}
-
-// Show/hide the Add Bookmark / Select All buttons based on the current auth role.
-function bmSyncAccess() {
-  const canCtrl = bmCanControl();
-  const addBtn = document.getElementById("bm-add-btn");
-  const selectAllBtn = document.getElementById("bm-select-all-btn");
-  if (addBtn) addBtn.style.display = canCtrl ? "" : "none";
-  if (selectAllBtn) selectAllBtn.style.display = canCtrl ? "" : "none";
-}
-
-/** The listing scope: always the active rig (to merge general + rig bookmarks). */
-function bmListScope() {
-  const rig = (typeof lastActiveRigId !== "undefined") ? lastActiveRigId : null;
-  return rig || "general";
-}
-
-async function bmFetchOverlay() {
-  const overlayScope = bmListScope();
-  try {
-    const resp = await fetch("/bookmarks" + bmScopeParam(false, overlayScope));
-    if (!resp.ok) throw new Error("HTTP " + resp.status);
-    bmOverlayList = await resp.json();
-  } catch (e) {
-    console.error("Failed to fetch overlay bookmarks:", e);
-    bmOverlayList = [];
-  }
-  bmOverlayRevision++;
-  if (typeof window.syncBookmarkMapLocators === "function") {
-    window.syncBookmarkMapLocators(bmOverlayList);
-  }
-  if (typeof scheduleSpectrumDraw === "function") scheduleSpectrumDraw();
-}
-
-async function bmFetch(categoryFilter) {
-  let url = "/bookmarks";
-  let hasQuery = false;
-  if (categoryFilter && categoryFilter !== "") {
-    url += "?category=" + encodeURIComponent(categoryFilter);
-    hasQuery = true;
-  }
-  url += bmScopeParam(hasQuery);
-  const overlayPromise = bmFetchOverlay();
-  try {
-    const resp = await fetch(url);
-    if (!resp.ok) throw new Error("HTTP " + resp.status);
-    bmList = await resp.json();
-  } catch (e) {
-    console.error("Failed to fetch bookmarks:", e);
-    bmList = [];
-  }
-  bmRevision++;
-  bmSelected.clear();
-  bmUpdateSelectionUi();
-  bmSyncAccess();
-  bmApplyFilters();
-  bmRefreshCategoryFilter(categoryFilter);
-  await overlayPromise;
-}
-
-function bmApplyFilters() {
-  const text = (document.getElementById("bm-text-filter")?.value || "").trim().toLowerCase();
-  const modeFilter = (document.getElementById("bm-mode-filter")?.value || "").trim().toUpperCase();
-  let filtered = modeFilter
-    ? bmList.filter((bm) => String(bm.mode || "").toUpperCase() === modeFilter)
-    : bmList;
-  filtered = text
-    ? filtered.filter((bm) =>
-        (bm.name || "").toLowerCase().includes(text) ||
-        (bm.locator || "").toLowerCase().includes(text) ||
-        (bm.category || "").toLowerCase().includes(text) ||
-        (bm.comment || "").toLowerCase().includes(text)
-      )
-    : filtered;
-  bmFilteredList = filtered;
-  bmCurrentPage = 1;
-  bmRender(filtered);
-}
-
-async function bmRefreshCategoryFilter(keepValue) {
-  const sel = document.getElementById("bm-category-filter");
-  const modeSel = document.getElementById("bm-mode-filter");
-  if (!sel && !modeSel) return;
-  try {
-    const resp = await fetch("/bookmarks" + bmScopeParam(false));
-    if (!resp.ok) return;
-    const all = await resp.json();
-    if (sel) {
-      const cats = [...new Set(all.map((b) => b.category || "").filter(Boolean))].sort();
-      while (sel.options.length > 1) sel.remove(1);
-      cats.forEach((cat) => {
-        const opt = document.createElement("option");
-        opt.value = cat;
-        opt.textContent = cat;
-        sel.add(opt);
-      });
-      if (keepValue && cats.includes(keepValue)) sel.value = keepValue;
-    }
-    if (modeSel) {
-      const keepMode = modeSel.value;
-      const modes = [...new Set(all.map((b) => String(b.mode || "").trim().toUpperCase()).filter(Boolean))].sort();
-      while (modeSel.options.length > 1) modeSel.remove(1);
-      modes.forEach((mode) => {
-        const opt = document.createElement("option");
-        opt.value = mode;
-        opt.textContent = mode;
-        modeSel.add(opt);
-      });
-      if (keepMode && modes.includes(keepMode)) modeSel.value = keepMode;
-    }
-  } catch (_) {}
-}
-
-function bmRender(list) {
-  const tbody = document.getElementById("bm-tbody");
-  const emptyEl = document.getElementById("bm-empty");
-  const paginatorEl = document.getElementById("bm-paginator");
-  const pageSummaryEl = document.getElementById("bm-page-summary");
-  const pageIndicatorEl = document.getElementById("bm-page-indicator");
-  const prevBtn = document.getElementById("bm-page-prev");
-  const nextBtn = document.getElementById("bm-page-next");
-  if (!tbody) return;
-  tbody.innerHTML = "";
-
-  if (list.length === 0) {
-    if (emptyEl) emptyEl.style.display = "";
-    if (paginatorEl) paginatorEl.style.display = "none";
-    return;
-  }
-  if (emptyEl) emptyEl.style.display = "none";
-
-  const canControl = bmCanControl();
-  const totalPages = Math.max(1, Math.ceil(list.length / BM_PAGE_SIZE));
-  const page = Math.min(Math.max(bmCurrentPage, 1), totalPages);
-  bmCurrentPage = page;
-  const startIndex = (page - 1) * BM_PAGE_SIZE;
-  const endIndex = Math.min(startIndex + BM_PAGE_SIZE, list.length);
-  const pageItems = list.slice(startIndex, endIndex);
-
-  const showScope = bmScope !== "general";
-  pageItems.forEach((bm) => {
-    const tr = document.createElement("tr");
-    tr.dataset.bmId = bm.id;
-    const bwCell = bm.bandwidth_hz ? bmFmtFreq(bm.bandwidth_hz) : "--";
-    const locatorCell = bm.locator || "--";
-    const catCell = bm.category || "Uncategorised";
-    const decoderCell = (bm.decoders || []).join(", ").toUpperCase() || "--";
-    const commentCell = bm.comment || "";
-    const checked = bmSelected.has(bm.id) ? " checked" : "";
-    const scopeBadge = showScope && bm.scope === "general" ? ' <span class="bm-scope-badge">G</span>' : "";
-    tr.innerHTML =
-      `<td class="bm-col-sel"><input type="checkbox" class="bm-row-sel" data-bm-id="${bmEsc(bm.id)}"${checked} aria-label="Select ${bmEsc(bm.name)}" /></td>` +
-      `<td class="bm-col-name">${bmEsc(bm.name)}${scopeBadge}</td>` +
-      `<td class="bm-col-freq">${bmFmtFreq(bm.freq_hz)}</td>` +
-      `<td class="bm-col-mode">${bmEsc(bm.mode)}</td>` +
-      `<td class="bm-col-bw">${bwCell}</td>` +
-      `<td class="bm-col-loc">${bmEsc(locatorCell)}</td>` +
-      `<td class="bm-col-cat">${bmEsc(catCell)}</td>` +
-      `<td class="bm-col-dec">${bmEsc(decoderCell)}</td>` +
-      `<td class="bm-col-cmt">${bmEsc(commentCell)}</td>` +
-      `<td class="bm-col-act">` +
-        `<button class="bm-tune-btn" type="button" data-bm-id="${bmEsc(bm.id)}">Tune</button>` +
-        (canControl
-          ? `<button class="bm-edit-btn" type="button" data-bm-id="${bmEsc(bm.id)}">Edit</button>` +
-            `<button class="bm-del-btn" type="button" data-bm-id="${bmEsc(bm.id)}">Delete</button>`
-          : "") +
-      `</td>`;
-    tbody.appendChild(tr);
-  });
-  bmSyncSelectAllCheckbox();
-
-  if (paginatorEl) paginatorEl.style.display = totalPages > 1 ? "flex" : "";
-  if (pageSummaryEl) pageSummaryEl.textContent = `Showing ${startIndex + 1}-${endIndex} of ${list.length}`;
-  if (pageIndicatorEl) pageIndicatorEl.textContent = `Page ${page} of ${totalPages}`;
-  if (prevBtn) prevBtn.disabled = page <= 1;
-  if (nextBtn) nextBtn.disabled = page >= totalPages;
-}
-
-function bmChangePage(delta) {
-  const totalPages = Math.max(1, Math.ceil(bmFilteredList.length / BM_PAGE_SIZE));
-  const nextPage = Math.min(Math.max(bmCurrentPage + delta, 1), totalPages);
-  if (nextPage === bmCurrentPage) return;
-  bmCurrentPage = nextPage;
-  bmRender(bmFilteredList);
-}
-
-// Read decoder checkboxes and return an array of selected decoder names.
-function bmReadDecoders() {
-  return (window.decoderRegistry || [])
-    .filter(d => d.bookmark_selectable)
-    .filter(d => document.getElementById("bm-dec-" + d.id)?.checked)
-    .map(d => d.id);
-}
-
-// Set decoder checkboxes to match the given array.
-function bmWriteDecoders(decoders) {
-  const set = new Set(decoders || []);
-  (window.decoderRegistry || [])
-    .filter(d => d.bookmark_selectable)
-    .forEach(d => {
-      const el = document.getElementById("bm-dec-" + d.id);
-      if (el) el.checked = set.has(d.id);
-    });
-}
-
-// Build decoder checkboxes dynamically from the registry.
-function bmBuildDecoderCheckboxes() {
-  const container = document.getElementById("bm-decoder-checkboxes");
-  if (!container) return;
-  container.innerHTML = "";
-  (window.decoderRegistry || [])
-    .filter(d => d.bookmark_selectable)
-    .forEach(d => {
-      const label = document.createElement("label");
-      label.className = "bm-decoder-check";
-      label.innerHTML = '<input type="checkbox" id="bm-dec-' + d.id + '" value="' + d.id + '" /> ' + d.label;
-      container.appendChild(label);
-    });
-}
-
-function bmOpenForm(bm) {
-  const wrap = document.getElementById("bm-form-wrap");
-  if (!wrap) return;
-  bmEditId = bm ? bm.id : null;
-  bmEditScope = bm ? (bm.scope || bmScope) : null;
-
-  // Rebuild decoder checkboxes from registry (handles race where registry
-  // loaded after initial build).
-  bmBuildDecoderCheckboxes();
-
-  document.getElementById("bm-id").value = bm ? bm.id : "";
-  document.getElementById("bm-name").value = bm ? bm.name : "";
-  document.getElementById("bm-freq").value = bm ? bm.freq_hz : "";
-  document.getElementById("bm-mode").value = bm ? bm.mode : "";
-  document.getElementById("bm-bw").value = bm && bm.bandwidth_hz ? bm.bandwidth_hz : "";
-  document.getElementById("bm-locator").value = bm ? (bm.locator || "") : "";
-  document.getElementById("bm-category-input").value = bm ? (bm.category || "") : "";
-  document.getElementById("bm-comment").value = bm ? (bm.comment || "") : "";
-  bmWriteDecoders(bm ? bm.decoders : []);
-  document.getElementById("bm-form-title").textContent = bm ? "Edit Bookmark" : "Add Bookmark";
-
-  wrap.style.display = "flex";
-  document.getElementById("bm-name").focus();
-}
-
-function bmCloseForm() {
-  const wrap = document.getElementById("bm-form-wrap");
-  if (wrap) wrap.style.display = "none";
-  bmEditId = null;
-}
-
-function bmPrefillFromStatus() {
-  // Use globals maintained by app.js (updated by SSE stream)
-  if (typeof lastFreqHz === "number" && Number.isFinite(lastFreqHz)) {
-    document.getElementById("bm-freq").value = Math.round(lastFreqHz);
-  }
-  if (typeof lastModeName === "string" && lastModeName) {
-    document.getElementById("bm-mode").value = lastModeName;
-  }
-  if (typeof currentBandwidthHz === "number" && currentBandwidthHz > 0) {
-    document.getElementById("bm-bw").value = Math.round(currentBandwidthHz);
-  }
-  // Prefill decoder checkboxes from current toggle button state.
-  const activeDecoders = (window.decoderRegistry || [])
-    .filter(d => d.bookmark_selectable && d.activation === "toggle")
-    .filter(d => {
-      const btn = document.getElementById(d.id + "-decode-toggle-btn");
-      return btn && btn.dataset.enabled === "true";
-    })
-    .map(d => d.id);
-  bmWriteDecoders(activeDecoders);
-}
-
-async function bmSave(e) {
-  e.preventDefault();
-  const id = document.getElementById("bm-id").value;
-  const name = document.getElementById("bm-name").value.trim();
-  const freqStr = document.getElementById("bm-freq").value;
-  const freq_hz = parseInt(freqStr, 10);
-  const mode = document.getElementById("bm-mode").value.trim();
-  const bwStr = document.getElementById("bm-bw").value;
-  const bandwidth_hz = bwStr ? parseInt(bwStr, 10) : null;
-  const locator = document.getElementById("bm-locator").value.trim().toUpperCase();
-  const category = document.getElementById("bm-category-input").value.trim();
-  const comment = document.getElementById("bm-comment").value.trim();
-  const decoders = bmReadDecoders();
-
-  const formError = document.getElementById("bm-form-error");
-  if (formError) formError.textContent = "";
-  if (!name || !Number.isFinite(freq_hz) || !mode) {
-    if (formError) formError.textContent = "Enter a name, a valid frequency, and a mode.";
-    const invalid = !name ? document.getElementById("bm-name")
-      : !Number.isFinite(freq_hz) ? document.getElementById("bm-freq") : document.getElementById("bm-mode");
-    invalid?.focus();
-    return;
-  }
-
-  const body = {
-    name,
-    freq_hz,
-    mode,
-    bandwidth_hz,
-    locator: locator || null,
-    category,
-    comment,
-    decoders,
-  };
-
-  try {
-    let resp;
-    if (id) {
-      resp = await fetch("/bookmarks/" + encodeURIComponent(id) + bmScopeParam(false, bmEditScope), {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-      });
-    } else {
-      resp = await fetch("/bookmarks" + bmScopeParam(false), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-      });
-    }
-    if (!resp.ok) {
-      const text = await resp.text();
-      if (resp.status === 409) {
-        throw new Error("A bookmark for that frequency already exists.");
-      }
-      throw new Error(text || "HTTP " + resp.status);
-    }
-    bmCloseForm();
-    await bmFetch(document.getElementById("bm-category-filter").value);
-  } catch (err) {
-    console.error("Failed to save bookmark:", err);
-    if (formError) formError.textContent = "Failed to save bookmark: " + err.message;
-    window.trxUi?.notify("Bookmark could not be saved", { kind: "error" });
-  }
-}
-
-async function bmDelete(id) {
-  if (!await window.trxUi.confirm({ title: "Delete bookmark?", message: "This bookmark will be permanently removed.", confirmLabel: "Delete" })) return;
-  const bm = bmList.find((b) => b.id === id);
-  const scope = bm ? bm.scope : undefined;
-  try {
-    const resp = await fetch("/bookmarks/" + encodeURIComponent(id) + bmScopeParam(false, scope), {
-      method: "DELETE",
-    });
-    if (!resp.ok) throw new Error("HTTP " + resp.status);
-    await bmFetch(document.getElementById("bm-category-filter").value);
-  } catch (err) {
-    console.error("Failed to delete bookmark:", err);
-    window.trxUi?.notify("Failed to delete bookmark: " + err.message, { kind: "error" });
-  }
-}
-
-async function bmApply(bm) {
-  try {
-    // --- Optimistic UI updates (instant, before any network round-trips) ---
-    if (typeof modeEl !== "undefined" && modeEl) {
-      modeEl.value = String(bm.mode || "").toUpperCase();
-    }
-    if (bm.bandwidth_hz) {
-      if (typeof currentBandwidthHz !== "undefined") {
-        currentBandwidthHz = bm.bandwidth_hz;
-      }
-      window.currentBandwidthHz = bm.bandwidth_hz;
-      if (typeof syncBandwidthInput === "function") {
-        syncBandwidthInput(bm.bandwidth_hz);
-      }
-    }
-    if (typeof applyLocalTunedFrequency === "function") {
-      // Set optimistic guard before applying so SSE cannot snap back.
-      if (typeof _freqOptimisticSeq !== "undefined") {
-        ++_freqOptimisticSeq;
-        _freqOptimisticHz = bm.freq_hz;
-      }
-      // Force display so the BW overlay is repositioned even when freq is unchanged.
-      applyLocalTunedFrequency(bm.freq_hz, true);
-    }
-    if (typeof scheduleSpectrumDraw === "function" && typeof lastSpectrumData !== "undefined" && lastSpectrumData) {
-      scheduleSpectrumDraw();
-    }
-
-    // Take scheduler control up front, then apply mode before bandwidth so a
-    // late SetMode cannot revert a saved WFM bookmark bandwidth to 180 kHz.
-    const tunePromise = (async () => {
-      if (typeof vchanTakeSchedulerControl === "function") {
-        await vchanTakeSchedulerControl();
-      }
-
-      const onVirtual = typeof vchanInterceptMode === "function"
-        && await vchanInterceptMode(bm.mode);
-      if (!onVirtual) {
-        await postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
-      }
-
-      if (bm.bandwidth_hz) {
-        const bwHandledByVchan = typeof vchanInterceptBandwidth === "function"
-          && await vchanInterceptBandwidth(bm.bandwidth_hz);
-        if (!bwHandledByVchan) {
-          await postPath("/set_bandwidth?hz=" + bm.bandwidth_hz);
-        }
-      }
-
-      // setRigFrequency is wrapped by vchan.js to redirect to the channel API
-      // when on a virtual channel, so this call works correctly in both cases.
-      // It also does its own optimistic update (applyLocalTunedFrequency) but
-      // that's a no-op since we already set the same value above.
-      if (typeof setRigFrequency === "function") {
-        await setRigFrequency(bm.freq_hz);
-      } else {
-        await postPath("/set_freq?hz=" + bm.freq_hz);
-      }
-    })();
-    // Decoder toggles — fire-and-forget.
-    //  - Decoders incompatible with the new mode are always turned off
-    //    (even when the bookmark has no explicit decoder selection).
-    //  - For compatible decoders, if the bookmark specifies a set, the
-    //    toggles are driven to match that set; otherwise they're left
-    //    alone.
-    const hasDecoders = Array.isArray(bm.decoders) && bm.decoders.length > 0;
-    const modeUp = (bm.mode || "").toUpperCase();
-    const allToggleDecoders = (window.decoderRegistry || []).filter(d =>
-      d.activation === "toggle"
-    );
-    const decoderPromise = allToggleDecoders.length ? (async () => {
-      let statusUrl = "/status";
-      if (typeof lastActiveRigId !== "undefined" && lastActiveRigId) {
-        statusUrl += "?remote=" + encodeURIComponent(lastActiveRigId);
-      }
-      const statusResp = await fetch(statusUrl);
-      if (!statusResp.ok) return;
-      const st = await statusResp.json();
-      const toggles = [];
-      for (const d of allToggleDecoders) {
-        const statusKey = d.id.replace(/-/g, "_") + "_decode_enabled";
-        const currentlyOn = !!st[statusKey];
-        const compatible = Array.isArray(d.active_modes)
-          && d.active_modes.includes(modeUp);
-        let wanted;
-        if (!compatible) {
-          // Always disable decoders that don't apply to the new mode.
-          wanted = false;
-        } else if (hasDecoders) {
-          wanted = bm.decoders.includes(d.id);
-        } else {
-          // Mode-compatible and no bookmark selection: leave as-is.
-          wanted = currentlyOn;
-        }
-        if (wanted !== currentlyOn) {
-          toggles.push(postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
-        }
-      }
-      if (toggles.length) await Promise.all(toggles);
-    })() : Promise.resolve();
-    // Don't await — let the network calls settle in the background.
-    // Errors are logged but don't block the UI.
-    Promise.all([tunePromise, decoderPromise]).catch(
-      (err) => console.error("Bookmark apply background error:", err)
-    );
-  } catch (err) {
-    console.error("Failed to apply bookmark:", err);
-  }
-}
-
-function bmUpdateSelectionUi() {
-  const count = bmSelected.size;
-  const canCtrl = bmCanControl();
-  const visible = count > 0 && canCtrl;
-  const btn = document.getElementById("bm-del-selected-btn");
-  const countEl = document.getElementById("bm-del-selected-count");
-  if (btn) btn.style.display = visible ? "" : "none";
-  if (countEl) countEl.textContent = count;
-  const moveWrap = document.getElementById("bm-move-selected-wrap");
-  const moveCountEl = document.getElementById("bm-move-selected-count");
-  if (moveWrap) moveWrap.style.display = visible ? "" : "none";
-  if (moveCountEl) moveCountEl.textContent = count;
-  if (visible) bmPopulateMoveTarget();
-  const selectAllBtn = document.getElementById("bm-select-all-btn");
-  if (selectAllBtn && bmCanControl()) {
-    const allSelected = bmFilteredList.length > 0 && bmFilteredList.every((bm) => bmSelected.has(bm.id));
-    selectAllBtn.textContent = allSelected ? "Deselect All" : "Select All";
-  }
-}
-
-/** Populate the move-target dropdown with all scopes except the current one. */
-function bmPopulateMoveTarget() {
-  const sel = document.getElementById("bm-move-target");
-  if (!sel) return;
-  const rigIds = (typeof lastRigIds !== "undefined" && Array.isArray(lastRigIds)) ? lastRigIds : [];
-  const displayNames = (typeof lastRigDisplayNames !== "undefined") ? lastRigDisplayNames : {};
-  const prev = sel.value;
-  sel.innerHTML = "";
-  if (bmScope !== "general") {
-    const opt = document.createElement("option");
-    opt.value = "general";
-    opt.textContent = "General";
-    sel.appendChild(opt);
-  }
-  rigIds.forEach((id) => {
-    if (id === bmScope) return;
-    const opt = document.createElement("option");
-    opt.value = id;
-    opt.textContent = displayNames[id] || id;
-    sel.appendChild(opt);
-  });
-  if (prev && sel.querySelector(`option[value="${CSS.escape(prev)}"]`)) {
-    sel.value = prev;
-  }
-}
-
-async function bmMoveSelected() {
-  const ids = Array.from(bmSelected);
-  if (ids.length === 0) return;
-  const target = document.getElementById("bm-move-target")?.value;
-  if (!target) return;
-  const targetLabel = document.getElementById("bm-move-target")?.selectedOptions[0]?.textContent || target;
-  if (!await window.trxUi.confirm({
-    title: "Move selected bookmarks?",
-    message: `${ids.length} bookmark${ids.length > 1 ? "s" : ""} will move to “${targetLabel}”.`,
-    confirmLabel: "Move",
-    danger: false,
-  })) return;
-  try {
-    // Group selected IDs by their owning scope (skip if already in target).
-    const byScope = {};
-    for (const id of ids) {
-      const bm = bmList.find((b) => b.id === id);
-      const scope = bm?.scope || bmScope;
-      if (scope === target) continue;
-      (byScope[scope] ||= []).push(id);
-    }
-    await Promise.all(Object.entries(byScope).map(([scope, scopeIds]) =>
-      fetch("/bookmarks/batch_move" + bmScopeParam(false, scope), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ ids: scopeIds, to: target }),
-      }).then((r) => { if (!r.ok) throw new Error("HTTP " + r.status); })
-    ));
-    bmSelected.clear();
-    bmUpdateSelectionUi();
-    await bmFetch(document.getElementById("bm-category-filter").value);
-  } catch (err) {
-    console.error("Failed to move bookmarks:", err);
-    window.trxUi?.notify("Failed to move bookmarks: " + err.message, { kind: "error" });
-  }
-}
-
-function bmSyncSelectAllCheckbox() {
-  const selectAll = document.getElementById("bm-select-all");
-  if (!selectAll) return;
-  const checkboxes = document.querySelectorAll(".bm-row-sel");
-  if (checkboxes.length === 0) {
-    selectAll.checked = false;
-    selectAll.indeterminate = false;
-    return;
-  }
-  const checkedCount = Array.from(checkboxes).filter((cb) => cb.checked).length;
-  selectAll.checked = checkedCount === checkboxes.length;
-  selectAll.indeterminate = checkedCount > 0 && checkedCount < checkboxes.length;
-}
-
-async function bmDeleteSelected() {
-  const ids = Array.from(bmSelected);
-  if (ids.length === 0) return;
-  if (!await window.trxUi.confirm({
-    title: "Delete selected bookmarks?",
-    message: `${ids.length} bookmark${ids.length > 1 ? "s" : ""} will be permanently removed.`,
-    confirmLabel: "Delete",
-  })) return;
-  try {
-    // Group selected IDs by their owning scope.
-    const byScope = {};
-    for (const id of ids) {
-      const bm = bmList.find((b) => b.id === id);
-      const scope = bm?.scope || bmScope;
-      (byScope[scope] ||= []).push(id);
-    }
-    await Promise.all(Object.entries(byScope).map(([scope, scopeIds]) =>
-      fetch("/bookmarks/batch_delete" + bmScopeParam(false, scope), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ ids: scopeIds }),
-      }).then((r) => { if (!r.ok) throw new Error("HTTP " + r.status); })
-    ));
-    bmSelected.clear();
-    bmUpdateSelectionUi();
-    await bmFetch(document.getElementById("bm-category-filter").value);
-  } catch (err) {
-    console.error("Failed to delete bookmarks:", err);
-    window.trxUi?.notify("Failed to delete bookmarks: " + err.message, { kind: "error" });
-  }
-}
-
-/** Populate the scope picker with "General" + one option per rig. */
-function bmPopulateScopePicker() {
-  const picker = document.getElementById("bm-scope-picker");
-  if (!picker) return;
-  const rigIds = (typeof lastRigIds !== "undefined" && Array.isArray(lastRigIds)) ? lastRigIds : [];
-  const displayNames = (typeof lastRigDisplayNames !== "undefined") ? lastRigDisplayNames : {};
-  // Preserve current selection if still valid.
-  const prev = picker.value;
-  while (picker.options.length > 1) picker.remove(1);
-  rigIds.forEach((id) => {
-    const opt = document.createElement("option");
-    opt.value = id;
-    opt.textContent = displayNames[id] || id;
-    picker.appendChild(opt);
-  });
-  if (prev && (prev === "general" || rigIds.includes(prev))) {
-    picker.value = prev;
-  } else {
-    picker.value = "general";
-  }
-  bmScope = picker.value;
-}
-
-// --- Event wiring ---
-(function initBookmarks() {
-  // Set initial button visibility (auth may already be resolved by the time
-  // scripts run if auth is disabled; otherwise bmFetch() will sync it).
-  bmSyncAccess();
-
-  // Build decoder checkboxes from registry.  The registry is fetched async
-  // so we rebuild once it arrives to ensure checkboxes are present.
-  bmBuildDecoderCheckboxes();
-  if (typeof window.onDecoderRegistryReady === "function") {
-    window.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
-  }
-
-  // Scope picker
-  bmPopulateScopePicker();
-  const scopePicker = document.getElementById("bm-scope-picker");
-  if (scopePicker) {
-    scopePicker.addEventListener("change", (e) => {
-      bmScope = e.target.value;
-      bmFetch(document.getElementById("bm-category-filter")?.value || "");
-    });
-  }
-
-  // Refresh list and sync access when the Bookmarks tab is activated
-  document.querySelector(".tab-bar").addEventListener("click", (e) => {
-    const btn = e.target.closest('.tab[data-tab="bookmarks"]');
-    if (!btn) return;
-    bmFetch(document.getElementById("bm-category-filter").value);
-  });
-
-  // Add Bookmark button — open form and prefill from current rig state
-  document.getElementById("bm-add-btn").addEventListener("click", () => {
-    bmOpenForm(null);
-    bmPrefillFromStatus();
-  });
-
-  // Category filter dropdown
-  document.getElementById("bm-category-filter").addEventListener("change", (e) => {
-    bmFetch(e.target.value);
-  });
-
-  // Mode filter dropdown (client-side, no re-fetch)
-  document.getElementById("bm-mode-filter").addEventListener("change", () => {
-    bmApplyFilters();
-  });
-
-  // Text search filter (client-side, no re-fetch)
-  document.getElementById("bm-text-filter").addEventListener("input", () => {
-    bmApplyFilters();
-  });
-
-  document.getElementById("bm-page-prev").addEventListener("click", () => {
-    bmChangePage(-1);
-  });
-
-  document.getElementById("bm-page-next").addEventListener("click", () => {
-    bmChangePage(1);
-  });
-
-  // Form submit
-  document.getElementById("bm-form").addEventListener("submit", bmSave);
-
-  // Form cancel
-  document.getElementById("bm-form-cancel").addEventListener("click", bmCloseForm);
-
-  const formWrap = document.getElementById("bm-form-wrap");
-  if (formWrap) {
-    formWrap.addEventListener("click", (e) => {
-      if (e.target === formWrap) bmCloseForm();
-    });
-  }
-
-  document.addEventListener("keydown", (e) => {
-    if (e.key === "Escape" && document.getElementById("bm-form-wrap")?.style.display === "flex") {
-      bmCloseForm();
-    }
-  });
-
-  // Select-all checkbox
-  document.getElementById("bm-select-all").addEventListener("change", (e) => {
-    const checked = e.target.checked;
-    document.querySelectorAll(".bm-row-sel").forEach((cb) => {
-      cb.checked = checked;
-      if (checked) bmSelected.add(cb.dataset.bmId);
-      else bmSelected.delete(cb.dataset.bmId);
-    });
-    bmUpdateSelectionUi();
-  });
-
-  // Select All (across all pages) button
-  document.getElementById("bm-select-all-btn").addEventListener("click", () => {
-    const allSelected = bmFilteredList.length > 0 && bmFilteredList.every((bm) => bmSelected.has(bm.id));
-    if (allSelected) {
-      bmSelected.clear();
-    } else {
-      bmFilteredList.forEach((bm) => bmSelected.add(bm.id));
-    }
-    // Sync visible page checkboxes
-    document.querySelectorAll(".bm-row-sel").forEach((cb) => {
-      cb.checked = bmSelected.has(cb.dataset.bmId);
-    });
-    bmSyncSelectAllCheckbox();
-    bmUpdateSelectionUi();
-  });
-
-  // Delete Selected button
-  document.getElementById("bm-del-selected-btn").addEventListener("click", () => {
-    bmDeleteSelected();
-  });
-
-  // Move Selected button
-  document.getElementById("bm-move-selected-btn").addEventListener("click", () => {
-    bmMoveSelected();
-  });
-
-  // Table action buttons and row checkboxes (event delegation)
-  document.getElementById("bm-tbody").addEventListener("click", async (e) => {
-    const checkbox = e.target.closest(".bm-row-sel");
-    if (checkbox) {
-      if (checkbox.checked) bmSelected.add(checkbox.dataset.bmId);
-      else bmSelected.delete(checkbox.dataset.bmId);
-      bmSyncSelectAllCheckbox();
-      bmUpdateSelectionUi();
-      return;
-    }
-
-    const tuneBtn = e.target.closest(".bm-tune-btn");
-    const editBtn = e.target.closest(".bm-edit-btn");
-    const delBtn = e.target.closest(".bm-del-btn");
-
-    if (tuneBtn) {
-      const bm = bmList.find((b) => b.id === tuneBtn.dataset.bmId);
-      if (bm) await bmApply(bm);
-    } else if (editBtn) {
-      const bm = bmList.find((b) => b.id === editBtn.dataset.bmId);
-      if (bm) bmOpenForm(bm);
-    } else if (delBtn) {
-      await bmDelete(delBtn.dataset.bmId);
-    }
-  });
-
-  // Pre-load bookmarks so spectrum markers are visible immediately.
-  bmFetch("");
-})();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/cw.js

@@ -1,451 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- CW (Morse) Decoder Plugin (server-side decode) ---
-const cwStatusEl = document.getElementById("cw-status");
-const cwOutputEl = document.getElementById("cw-output");
-const cwAutoInput = document.getElementById("cw-auto");
-const cwWpmInput = document.getElementById("cw-wpm");
-const cwToneInput = document.getElementById("cw-tone");
-const cwSignalIndicator = document.getElementById("cw-signal-indicator");
-const cwToneCanvas = document.getElementById("cw-tone-waterfall");
-const cwToneGl = typeof createTrxWebGlRenderer === "function"
-  ? createTrxWebGlRenderer(cwToneCanvas, { alpha: true })
-  : null;
-const cwTonePickerEl = document.querySelector(".cw-tone-picker");
-const cwToneRangeEl = document.getElementById("cw-tone-range");
-const cwBarOverlay = document.getElementById("cw-bar-overlay");
-const CW_MAX_LINES = 200;
-const CW_TONE_MIN_HZ = 100;
-const CW_TONE_MAX_HZ = 10_000;
-const CW_WPM_MIN = 5;
-const CW_WPM_MAX = 40;
-const CW_BAR_WINDOW_MS = 15 * 60 * 1000;
-const CW_BAR_LINE_GAP_MS = 5000;
-let cwLastAppendTime = 0;
-let cwTonePickerRaf = null;
-let cwBarHistory = [];     // [{tsMs, ts, text, wpm, tone_hz}]
-let cwBarCurrentLine = null; // accumulates chars until gap/newline
-let cwBarDismissedAtMs = 0;
-// Tracks a user-initiated auto toggle that is in-flight (POST not yet
-// acknowledged).  While set, server-state updates must not override the
-// checkbox so that a concurrent SSE event carrying the *old* cw_auto value
-// does not immediately undo the user's choice.
-let cwAutoLocalOverride = null;
-
-function applyCwAutoUi(enabled) {
-  if (cwAutoInput) cwAutoInput.checked = enabled;
-  if (cwWpmInput) {
-    cwWpmInput.disabled = enabled;
-    cwWpmInput.readOnly = enabled;
-  }
-  if (cwToneInput) {
-    cwToneInput.disabled = enabled;
-    cwToneInput.readOnly = enabled;
-  }
-  if (cwTonePickerEl) {
-    cwTonePickerEl.classList.toggle("is-auto", enabled);
-  }
-}
-window.applyCwAutoUi = applyCwAutoUi;
-
-// Called by app.js render() when a server-state snapshot arrives.  Ignores
-// the update while cwAutoLocalOverride is set (user change still in-flight).
-window.applyCwAutoUiFromServer = function(enabled) {
-  if (cwAutoLocalOverride !== null) return;
-  applyCwAutoUi(enabled);
-};
-
-function cwBarFlushCurrentLine() {
-  if (cwBarCurrentLine && cwBarCurrentLine.text.trim()) {
-    cwBarHistory.unshift(cwBarCurrentLine);
-    if (cwBarHistory.length > 50) cwBarHistory.length = 50;
-  }
-  cwBarCurrentLine = null;
-}
-
-function updateCwBar() {
-  if (!cwBarOverlay) return;
-  const mode = (document.getElementById("mode")?.value || "").toUpperCase();
-  const isCw = mode === "CW" || mode === "CWR";
-  const cutoffMs = Date.now() - CW_BAR_WINDOW_MS;
-  const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs);
-  // Prepend the in-progress line so characters appear immediately
-  const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
-  const newestTsMs = liveLines.reduce((latest, line) => Math.max(latest, Number(line.tsMs) || 0), 0);
-  if (!isCw || liveLines.length === 0 || newestTsMs <= cwBarDismissedAtMs) {
-    cwBarOverlay.style.display = "none";
-    cwBarOverlay.innerHTML = "";
-    return;
-  }
-  let html =
-    '<div class="aprs-bar-header">' +
-      '<span class="aprs-bar-title"><span class="aprs-bar-title-word">CW</span><span class="aprs-bar-title-word">Live</span></span>' +
-      '<span class="aprs-bar-actions">' +
-        '<span class="aprs-bar-window">Last 15 minutes</span>' +
-        '<span class="aprs-bar-clear-wrap"><span class="aprs-bar-clear" role="button" tabindex="0"' +
-          ' onclick="window.clearCwBar()"' +
-          ' onkeydown="if(event.key===\'Enter\'||event.key===\' \'){event.preventDefault();window.clearCwBar();}"' +
-          ' aria-label="Clear CW overlay">Clear</span></span>' +
-        '<button class="aprs-bar-close" type="button" onclick="window.closeCwBar()" aria-label="Close CW overlay">&times;</button>' +
-      '</span>' +
-    '</div>';
-  for (const line of liveLines.slice(0, 8)) {
-    const ts = line.ts ? `<span class="aprs-bar-time">${line.ts}</span>` : "";
-    const meta = [
-      line.wpm ? `${line.wpm} WPM` : null,
-      line.tone_hz ? `${line.tone_hz} Hz` : null,
-    ].filter(Boolean).join(" · ");
-    html += `<div class="aprs-bar-frame">` +
-      `<div class="aprs-bar-frame-main">${ts}${escapeMapHtml(line.text)}` +
-      (meta ? ` <span class="aprs-bar-time">${escapeMapHtml(meta)}</span>` : "") +
-      `</div></div>`;
-  }
-  cwBarOverlay.innerHTML = html;
-  cwBarOverlay.style.display = "flex";
-}
-window.updateCwBar = updateCwBar;
-window.clearCwBar = function() {
-  window.resetCwHistoryView();
-};
-window.closeCwBar = function() {
-  cwBarDismissedAtMs = Date.now();
-  if (cwBarOverlay) {
-    cwBarOverlay.style.display = "none";
-    cwBarOverlay.innerHTML = "";
-  }
-};
-
-function clampCwWpm(wpm) {
-  const numeric = Number(wpm);
-  if (!Number.isFinite(numeric)) return 15;
-  return Math.round(Math.max(CW_WPM_MIN, Math.min(CW_WPM_MAX, numeric)));
-}
-
-function clampCwTone(tone) {
-  const numeric = Number(tone);
-  if (!Number.isFinite(numeric)) return 700;
-  return Math.round(Math.max(CW_TONE_MIN_HZ, Math.min(CW_TONE_MAX_HZ, numeric)));
-}
-
-function currentCwToneRange() {
-  const tunedHz = Number.isFinite(window.lastFreqHz) ? Number(window.lastFreqHz) : NaN;
-  const bandwidthHz = Number.isFinite(window.currentBandwidthHz) ? Number(window.currentBandwidthHz) : NaN;
-  if (!Number.isFinite(tunedHz) || !Number.isFinite(bandwidthHz) || bandwidthHz <= 0) {
-    return null;
-  }
-  const mode = String(document.getElementById("mode")?.value || "").toUpperCase();
-  const lowerSideband = mode === "CWR";
-  const upperSideband = mode === "CW";
-  if (!lowerSideband && !upperSideband) return null;
-
-  const toneMinHz = CW_TONE_MIN_HZ;
-  const toneMaxHz = CW_TONE_MAX_HZ;
-  if (toneMaxHz < toneMinHz) {
-    return null;
-  }
-  return {
-    tunedHz,
-    bandwidthHz,
-    toneMinHz,
-    toneMaxHz,
-    toneSpanHz: Math.max(1, toneMaxHz - toneMinHz),
-    lowerSideband,
-    mode,
-  };
-}
-
-function cwToneToRfHz(range, toneHz) {
-  if (!range) return NaN;
-  return range.lowerSideband
-    ? range.tunedHz - toneHz
-    : range.tunedHz + toneHz;
-}
-
-function toneClampForRange(tone, range) {
-  const clamped = clampCwTone(tone);
-  if (!range) return clamped;
-  return Math.max(range.toneMinHz, Math.min(range.toneMaxHz, clamped));
-}
-
-function ensureCwToneCanvasResolution() {
-  if (!cwToneCanvas || !cwToneGl || !cwToneGl.ready) return false;
-  const rect = cwToneCanvas.getBoundingClientRect();
-  const cssWidth = Math.round(rect.width);
-  const cssHeight = Math.round(rect.height);
-  if (cssWidth < 8 || cssHeight < 8) {
-    return false;
-  }
-  const dpr = window.devicePixelRatio || 1;
-  return cwToneGl.ensureSize(cssWidth, cssHeight, dpr);
-}
-
-function drawCwTonePicker() {
-  if (!cwToneCanvas || !cwToneGl || !cwToneGl.ready) return;
-  ensureCwToneCanvasResolution();
-  if (cwToneCanvas.width < 8 || cwToneCanvas.height < 8) return;
-  const width = cwToneCanvas.width;
-  const height = cwToneCanvas.height;
-  cwToneGl.clear([0, 0, 0, 0]);
-
-  const range = currentCwToneRange();
-  if (!window.lastSpectrumData || !Array.isArray(window.lastSpectrumData.bins) || !window.lastSpectrumData.bins.length || !range) {
-    if (cwToneRangeEl) {
-      const mode = String(document.getElementById("mode")?.value || "").toUpperCase();
-      if (mode !== "CW" && mode !== "CWR") {
-        cwToneRangeEl.textContent = "CW/CWR mode required";
-      } else if (!window.lastSpectrumData || !Array.isArray(window.lastSpectrumData.bins) || !window.lastSpectrumData.bins.length) {
-        cwToneRangeEl.textContent = "Waiting for spectrum";
-      }
-    }
-    cwToneGl.fillRect(0, 0, width, height, [130 / 255, 150 / 255, 165 / 255, 0.22]);
-    return;
-  }
-
-  if (cwToneRangeEl) {
-    const side = range.lowerSideband ? "Lower side" : "Upper side";
-    cwToneRangeEl.textContent = `Audio ${range.toneMinHz}-${range.toneMaxHz} Hz · ${side}`;
-  }
-
-  const bins = window.lastSpectrumData.bins;
-  const sampleRate = Number(window.lastSpectrumData.sample_rate);
-  const centerHz = Number(window.lastSpectrumData.center_hz);
-  const maxIdx = Math.max(1, bins.length - 1);
-  const fullLoHz = centerHz - sampleRate / 2;
-  const tones = new Array(width).fill(-140);
-  for (let x = 0; x < width; x += 1) {
-    const frac = width <= 1 ? 0 : x / (width - 1);
-    const toneHz = range.toneMinHz + frac * range.toneSpanHz;
-    const rfHz = cwToneToRfHz(range, toneHz);
-    const idx = Math.max(0, Math.min(maxIdx, Math.round((((rfHz - fullLoHz) / sampleRate) * maxIdx))));
-    const power = Number.isFinite(Number(bins[idx])) ? Number(bins[idx]) : -140;
-    tones[x] = power;
-  }
-
-  const smoothed = new Array(width).fill(-140);
-  const smoothRadius = Math.max(1, Math.round(width / 180));
-  for (let x = 0; x < width; x += 1) {
-    let sum = 0;
-    let count = 0;
-    for (let i = x - smoothRadius; i <= x + smoothRadius; i += 1) {
-      if (i < 0 || i >= width) continue;
-      sum += tones[i];
-      count += 1;
-    }
-    smoothed[x] = count > 0 ? sum / count : tones[x];
-  }
-
-  const sorted = smoothed.slice().sort((a, b) => a - b);
-  const q20 = sorted[Math.floor((sorted.length - 1) * 0.2)] ?? -120;
-  const q95 = sorted[Math.floor((sorted.length - 1) * 0.95)] ?? -70;
-  const floorDb = Math.min(q20 - 2, q95 - 10);
-  const ceilDb = Math.max(floorDb + 18, q95 + 2);
-  const dbSpan = Math.max(1, ceilDb - floorDb);
-  const yForDb = (db) => {
-    const n = Math.max(0, Math.min(1, (db - floorDb) / dbSpan));
-    return Math.round((1 - n) * (height - 1));
-  };
-
-  const rootStyle = getComputedStyle(document.documentElement);
-  const accent = (rootStyle.getPropertyValue("--accent-green") || "").trim() || "#00d17f";
-  const parseColor = typeof window.trxParseCssColor === "function"
-    ? window.trxParseCssColor
-    : null;
-  const accentRgba = parseColor ? parseColor(accent) : [0, 0.82, 0.5, 1];
-  const axisColor = [230 / 255, 235 / 255, 245 / 255, 0.15];
-
-  cwToneGl.fillRect(0, 0, width, height, [7 / 255, 12 / 255, 18 / 255, 0.94]);
-
-  const hGridCount = 4;
-  const gridSegments = [];
-  for (let i = 1; i <= hGridCount; i += 1) {
-    const y = Math.round((i / (hGridCount + 1)) * (height - 1));
-    gridSegments.push(0, y, width, y);
-  }
-  cwToneGl.drawSegments(gridSegments, axisColor, 1);
-
-  const toneStep = range.toneSpanHz <= 500 ? 50 : range.toneSpanHz <= 1000 ? 100 : 200;
-  const firstTick = Math.ceil(range.toneMinHz / toneStep) * toneStep;
-  const tickSegments = [];
-  for (let tone = firstTick; tone <= range.toneMaxHz; tone += toneStep) {
-    const frac = (tone - range.toneMinHz) / range.toneSpanHz;
-    const x = Math.max(0, Math.min(width - 1, Math.round(frac * (width - 1))));
-    tickSegments.push(x, 0, x, height);
-  }
-  cwToneGl.drawSegments(tickSegments, axisColor, 1);
-
-  const linePoints = [];
-  for (let x = 0; x < width; x += 1) {
-    linePoints.push(x, yForDb(smoothed[x]));
-  }
-  cwToneGl.drawFilledArea(linePoints, height, [accentRgba[0], accentRgba[1], accentRgba[2], 0.24]);
-  cwToneGl.drawPolyline(linePoints, accentRgba, Math.max(1.2, (window.devicePixelRatio || 1) * 1.2));
-
-  const currentTone = toneClampForRange(cwToneInput ? cwToneInput.value : 700, range);
-  const markerFrac = (currentTone - range.toneMinHz) / range.toneSpanHz;
-  const markerX = Math.max(0, Math.min(width - 1, Math.round(markerFrac * (width - 1))));
-  const markerY = yForDb(smoothed[Math.max(0, Math.min(width - 1, markerX))]);
-  cwToneGl.drawSegments([markerX, 0, markerX, height], [1, 1, 1, 0.9], 1.5);
-  cwToneGl.drawPoints([markerX, markerY], Math.max(2, Math.round(height * 0.055)), [1, 1, 1, 0.9]);
-
-  if (cwAutoInput?.checked) {
-    cwToneGl.fillRect(0, 0, width, height, [0, 0, 0, 0.22]);
-  }
-}
-
-async function setCwTone(tone, { syncInput = true } = {}) {
-  const range = currentCwToneRange();
-  const clamped = toneClampForRange(tone, range);
-  if (cwToneInput && syncInput) {
-    cwToneInput.value = clamped;
-  }
-  try {
-    await postPath(`/set_cw_tone?tone_hz=${encodeURIComponent(clamped)}`);
-  } catch (e) {
-    console.error("CW tone set failed", e);
-  }
-  drawCwTonePicker();
-}
-
-if (cwAutoInput) {
-  cwAutoInput.addEventListener("change", async () => {
-    const enabled = cwAutoInput.checked;
-    cwAutoLocalOverride = enabled;
-    applyCwAutoUi(enabled);
-    try {
-      await postPath(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
-      drawCwTonePicker();
-    } catch (e) {
-      console.error("CW auto toggle failed", e);
-    } finally {
-      cwAutoLocalOverride = null;
-    }
-  });
-}
-
-if (cwWpmInput) {
-  cwWpmInput.addEventListener("change", async () => {
-    if (cwAutoInput && cwAutoInput.checked) return;
-    const wpm = clampCwWpm(cwWpmInput.value);
-    cwWpmInput.value = wpm;
-    try { await postPath(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`); }
-    catch (e) { console.error("CW WPM set failed", e); }
-  });
-}
-
-if (cwToneInput) {
-  cwToneInput.addEventListener("change", async () => {
-    if (cwAutoInput?.checked) return;
-    await setCwTone(cwToneInput.value);
-  });
-}
-
-if (cwToneCanvas) {
-  cwToneCanvas.addEventListener("click", async (event) => {
-    if (cwAutoInput?.checked) return;
-    const rect = cwToneCanvas.getBoundingClientRect();
-    if (rect.width <= 0) return;
-    const range = currentCwToneRange();
-    if (!range) return;
-    const frac = Math.max(0, Math.min(1, (event.clientX - rect.left) / rect.width));
-    const tone = range.toneMinHz + frac * range.toneSpanHz;
-    await setCwTone(tone);
-  });
-}
-
-window.resetCwHistoryView = function() {
-  if (cwOutputEl) cwOutputEl.innerHTML = "";
-  cwLastAppendTime = 0;
-  cwBarHistory = [];
-  cwBarCurrentLine = null;
-  updateCwBar();
-  drawCwTonePicker();
-};
-
-document.getElementById("settings-clear-cw-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear CW history?", message: "All stored CW decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_cw_decode");
-    window.resetCwHistoryView();
-  } catch (e) {
-    console.error("CW history clear failed", e);
-  }
-});
-
-// --- Server-side CW decode handler ---
-window.onServerCw = function(evt) {
-  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
-  if (evt.text && cwOutputEl) {
-    // Append decoded text to output
-    const now = Date.now();
-    if (!cwOutputEl.lastElementChild || now - cwLastAppendTime > 10000 || evt.text === "\n") {
-      const line = document.createElement("div");
-      line.className = "cw-line";
-      cwOutputEl.appendChild(line);
-    }
-    cwLastAppendTime = now;
-    const lastLine = cwOutputEl.lastElementChild;
-    if (lastLine) {
-      lastLine.textContent += evt.text;
-    }
-    while (cwOutputEl.children.length > CW_MAX_LINES) {
-      cwOutputEl.removeChild(cwOutputEl.firstChild);
-    }
-    cwOutputEl.scrollTop = cwOutputEl.scrollHeight;
-  }
-  // Bar history accumulation (regardless of pause state)
-  if (evt.text) {
-    const now = Date.now();
-    if (evt.text === "\n") {
-      cwBarFlushCurrentLine();
-    } else {
-      if (!cwBarCurrentLine || now - cwBarCurrentLine.lastMs > CW_BAR_LINE_GAP_MS) {
-        cwBarFlushCurrentLine();
-        const ts = new Date(now).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-        cwBarCurrentLine = { tsMs: now, ts, text: "", wpm: null, tone_hz: null, lastMs: now };
-      }
-      cwBarCurrentLine.text += evt.text;
-      cwBarCurrentLine.lastMs = now;
-      if (Number.isFinite(Number(evt.wpm))) cwBarCurrentLine.wpm = clampCwWpm(evt.wpm);
-      if (Number.isFinite(Number(evt.tone_hz))) cwBarCurrentLine.tone_hz = Math.round(Number(evt.tone_hz));
-    }
-    updateCwBar();
-  }
-  if (cwSignalIndicator) {
-    cwSignalIndicator.className = evt.signal_on ? "cw-signal-on" : "cw-signal-off";
-  }
-  if (!cwAutoInput || cwAutoInput.checked) {
-    if (cwWpmInput && Number.isFinite(Number(evt.wpm))) {
-      cwWpmInput.value = clampCwWpm(evt.wpm);
-    }
-    if (cwToneInput && Number.isFinite(Number(evt.tone_hz))) {
-      cwToneInput.value = toneClampForRange(evt.tone_hz, currentCwToneRange());
-    }
-  }
-  if (cwTonePickerRaf != null) return;
-  cwTonePickerRaf = requestAnimationFrame(() => {
-    cwTonePickerRaf = null;
-    drawCwTonePicker();
-  });
-};
-
-window.restoreCwHistory = function(events) {
-  if (!Array.isArray(events) || events.length === 0) return;
-  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
-  for (const evt of events) {
-    window.onServerCw(evt);
-  }
-};
-
-window.refreshCwTonePicker = function refreshCwTonePicker() {
-  ensureCwToneCanvasResolution();
-  drawCwTonePicker();
-};
-window.addEventListener("resize", () => {
-  if (ensureCwToneCanvasResolution()) drawCwTonePicker();
-});
-applyCwAutoUi(!!cwAutoInput?.checked);
-updateCwBar();
-ensureCwToneCanvasResolution();
-drawCwTonePicker();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/ft2.js

@@ -1,207 +0,0 @@
-// --- FT2 Decoder Plugin (server-side decode) ---
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-function ft8RenderMessageFt2(message) {
-  if (typeof renderFt8Message === "function") return renderFt8Message(message);
-  if (typeof ft8EscapeHtml === "function") return ft8EscapeHtml(message);
-  return message;
-}
-
-const ft2Status = document.getElementById("ft2-status");
-const ft2PeriodEl = document.getElementById("ft2-period");
-const ft2MessagesEl = document.getElementById("ft2-messages");
-const ft2FilterInput = document.getElementById("ft2-filter");
-const FT2_PERIOD_MS = 3750;
-const FT2_MAX_DOM_ROWS = 200;
-let ft2FilterText = "";
-let ft2MessageHistory = [];
-
-function currentFt2HistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneFt2MessageHistory() {
-  const cutoffMs = Date.now() - currentFt2HistoryRetentionMs();
-  ft2MessageHistory = ft2MessageHistory.filter((msg) => Number(msg?._tsMs ?? msg?.ts_ms) >= cutoffMs);
-}
-
-function scheduleFt2Ui(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-function scheduleFt2HistoryRender() { scheduleFt2Ui("ft2-history", () => renderFt2History()); }
-
-function normalizeFt2DisplayFreqHz(freqHz) {
-  const rawHz = Number(freqHz);
-  if (!Number.isFinite(rawHz)) return null;
-  const baseHz = Number.isFinite(window.ft8BaseHz) ? Number(window.ft8BaseHz) : null;
-  if (Number.isFinite(baseHz) && baseHz > 0 && rawHz >= 0 && rawHz < 100000) {
-    return baseHz + rawHz;
-  }
-  return rawHz;
-}
-
-function updateFt2PeriodTimer() {
-  if (!ft2PeriodEl) return;
-  const nowMs = Date.now();
-  const remaining = (FT2_PERIOD_MS - nowMs % FT2_PERIOD_MS) / 1000;
-  ft2PeriodEl.textContent = `Next slot ${remaining.toFixed(1)}s`;
-}
-
-updateFt2PeriodTimer();
-setInterval(updateFt2PeriodTimer, 250);
-
-function renderFt2Row(msg) {
-  const row = document.createElement("div");
-  row.className = "ft8-row";
-  const rawMessage = (msg.message || "").toString();
-  row.dataset.message = rawMessage.toUpperCase();
-  row.dataset.decoder = "ft2";
-  row.dataset.storedFreqHz = Number.isFinite(msg.freq_hz) ? String(msg.freq_hz) : "";
-  const snr = Number.isFinite(msg.snr_db) ? msg.snr_db.toFixed(1) : "--";
-  const dt = Number.isFinite(msg.dt_s) ? msg.dt_s.toFixed(2) : "--";
-  const displayFreqHz = normalizeFt2DisplayFreqHz(msg.freq_hz);
-  const freq = Number.isFinite(displayFreqHz) ? displayFreqHz.toFixed(0) : "--";
-  const renderedMessage = ft8RenderMessageFt2(rawMessage);
-  const tsMs = msg._tsMs ?? msg.ts_ms;
-  const timeStr = tsMs ? new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" }) : "--:--:--";
-  row.innerHTML = `<span class="ft8-time">${timeStr}</span><span class="ft8-snr">${snr}</span><span class="ft8-dt">${dt}</span><span class="ft8-freq">${freq}</span><span class="ft8-msg">${renderedMessage}</span>`;
-  return row;
-}
-
-function renderFt2History() {
-  pruneFt2MessageHistory();
-  if (!ft2MessagesEl) return;
-  const filter = ft2FilterText;
-  const fragment = document.createDocumentFragment();
-  let rendered = 0;
-  for (let i = 0; i < ft2MessageHistory.length && rendered < FT2_MAX_DOM_ROWS; i++) {
-    const msg = ft2MessageHistory[i];
-    if (filter && !(msg.message || "").toString().toUpperCase().includes(filter)) continue;
-    fragment.appendChild(renderFt2Row(msg));
-    rendered++;
-  }
-  ft2MessagesEl.replaceChildren(fragment);
-}
-
-function addFt2Message(msg) {
-  msg._tsMs = Number.isFinite(msg?.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  ft2MessageHistory.unshift(msg);
-  pruneFt2MessageHistory();
-  window.setFt8FamilyBarDecoder?.("ft2");
-  window.updateFt8Bar?.();
-  scheduleFt2HistoryRender();
-}
-
-function normalizeServerFt2Message(msg) {
-  const raw = (msg.message || "").toString();
-  const locatorDetails = typeof ft8ExtractLocatorDetails === "function" ? ft8ExtractLocatorDetails(raw) : [];
-  const grids = locatorDetails.length > 0
-    ? locatorDetails.map((d) => d.grid)
-    : (typeof ft8ExtractAllGrids === "function" ? ft8ExtractAllGrids(raw) : []);
-  const station = typeof ft8ExtractLikelyCallsign === "function" ? ft8ExtractLikelyCallsign(raw) : null;
-  const rfHz = normalizeFt2DisplayFreqHz(msg.freq_hz);
-  return {
-    raw, grids, station, rfHz, locatorDetails,
-    history: {
-      receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
-      ts_ms: msg.ts_ms, snr_db: msg.snr_db, dt_s: msg.dt_s,
-      freq_hz: Number.isFinite(rfHz) ? rfHz : msg.freq_hz,
-      message: msg.message,
-    },
-  };
-}
-
-window.onServerFt2Batch = function(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  if (ft2Status) ft2Status.textContent = "Receiving";
-  const normalized = [];
-  for (const msg of messages) {
-    const next = normalizeServerFt2Message(msg);
-    if (next.grids.length > 0 && window.mapAddLocator) {
-      window.mapAddLocator(next.raw, next.grids, "ft2", next.station, { ...msg, freq_hz: next.rfHz, locator_details: next.locatorDetails });
-    }
-    next.history._tsMs = Number.isFinite(next.history?.ts_ms) ? Number(next.history.ts_ms) : Date.now();
-    normalized.push(next.history);
-  }
-  normalized.reverse();
-  ft2MessageHistory = normalized.concat(ft2MessageHistory);
-  pruneFt2MessageHistory();
-  window.setFt8FamilyBarDecoder?.("ft2");
-  window.updateFt8Bar?.();
-  scheduleFt2HistoryRender();
-};
-
-window.restoreFt2History = function(messages) { window.onServerFt2Batch(messages); };
-window.pruneFt2HistoryView = function() { pruneFt2MessageHistory(); renderFt2History(); };
-
-window.resetFt2HistoryView = function() {
-  if (ft2MessagesEl) ft2MessagesEl.innerHTML = "";
-  ft2MessageHistory = [];
-  window.updateFt8Bar?.();
-  renderFt2History();
-};
-
-function buildFt2BarFrames() {
-  const cutoffMs = Date.now() - 15 * 60 * 1000;
-  const messages = ft2MessageHistory.filter((msg) => Number(msg._tsMs ?? msg.ts_ms) >= cutoffMs).slice(0, 8);
-  const newestTsMs = messages.reduce((latest, msg) => Math.max(latest, Number(msg._tsMs ?? msg.ts_ms) || 0), 0);
-  if (messages.length === 0) {
-    return { count: 0, newestTsMs: 0, html: "" };
-  }
-  let html = "";
-  for (const msg of messages) {
-    const tsMs = msg._tsMs ?? msg.ts_ms;
-    const ts = tsMs ? `<span class="aprs-bar-time">${fmtTime(tsMs)}</span>` : "";
-    const snr = Number.isFinite(msg.snr_db) ? `${msg.snr_db.toFixed(1)} dB` : "-- dB";
-    const dt = Number.isFinite(msg.dt_s) ? `dt ${msg.dt_s.toFixed(2)}` : null;
-    const displayFreqHz = normalizeFt2DisplayFreqHz(msg.freq_hz);
-    const rf = Number.isFinite(displayFreqHz) ? `${displayFreqHz.toFixed(0)} Hz` : null;
-    const detail = [snr, dt, rf].filter(Boolean).join(" · ");
-    const text = ft8RenderMessageFt2((msg.message || "").toString());
-    html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${ts}<span class="aprs-bar-call">${text}</span>${detail ? ` · ${detail}` : ""}</div></div>`;
-  }
-  return { count: messages.length, newestTsMs, html };
-}
-window.registerFt8FamilyBarRenderer?.("ft2", buildFt2BarFrames);
-
-if (ft2FilterInput) {
-  ft2FilterInput.addEventListener("input", () => {
-    ft2FilterText = ft2FilterInput.value.trim().toUpperCase();
-    renderFt2History();
-  });
-}
-
-const ft2DecodeToggleBtn = document.getElementById("ft2-decode-toggle-btn");
-ft2DecodeToggleBtn?.addEventListener("click", async () => {
-  try {
-    await window.takeSchedulerControlForDecoderDisable?.(ft2DecodeToggleBtn);
-    await postPath("/toggle_ft2_decode");
-  } catch (e) {
-    console.error("FT2 toggle failed", e);
-  }
-});
-
-document.getElementById("settings-clear-ft2-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear FT2 history?", message: "All stored FT2 decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_ft2_decode");
-    window.resetFt2HistoryView();
-  } catch (e) { console.error("FT2 history clear failed", e); }
-});
-
-window.onServerFt2 = function(msg) {
-  if (ft2Status) ft2Status.textContent = "Receiving";
-  const next = normalizeServerFt2Message(msg);
-  if (next.grids.length > 0 && window.mapAddLocator) {
-    window.mapAddLocator(next.raw, next.grids, "ft2", next.station, { ...msg, freq_hz: next.rfHz, locator_details: next.locatorDetails });
-  }
-  addFt2Message(next.history);
-};

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/ft4.js

@@ -1,207 +0,0 @@
-// --- FT4 Decoder Plugin (server-side decode) ---
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-function ft8RenderMessage(message) {
-  if (typeof renderFt8Message === "function") return renderFt8Message(message);
-  if (typeof ft8EscapeHtml === "function") return ft8EscapeHtml(message);
-  return message;
-}
-
-const ft4Status = document.getElementById("ft4-status");
-const ft4PeriodEl = document.getElementById("ft4-period");
-const ft4MessagesEl = document.getElementById("ft4-messages");
-const ft4FilterInput = document.getElementById("ft4-filter");
-const FT4_PERIOD_MS = 7500;
-const FT4_MAX_DOM_ROWS = 200;
-let ft4FilterText = "";
-let ft4MessageHistory = [];
-
-function currentFt4HistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneFt4MessageHistory() {
-  const cutoffMs = Date.now() - currentFt4HistoryRetentionMs();
-  ft4MessageHistory = ft4MessageHistory.filter((msg) => Number(msg?._tsMs ?? msg?.ts_ms) >= cutoffMs);
-}
-
-function scheduleFt4Ui(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-function scheduleFt4HistoryRender() { scheduleFt4Ui("ft4-history", () => renderFt4History()); }
-
-function normalizeFt4DisplayFreqHz(freqHz) {
-  const rawHz = Number(freqHz);
-  if (!Number.isFinite(rawHz)) return null;
-  const baseHz = Number.isFinite(window.ft8BaseHz) ? Number(window.ft8BaseHz) : null;
-  if (Number.isFinite(baseHz) && baseHz > 0 && rawHz >= 0 && rawHz < 100000) {
-    return baseHz + rawHz;
-  }
-  return rawHz;
-}
-
-function updateFt4PeriodTimer() {
-  if (!ft4PeriodEl) return;
-  const nowMs = Date.now();
-  const remaining = (FT4_PERIOD_MS - nowMs % FT4_PERIOD_MS) / 1000;
-  ft4PeriodEl.textContent = `Next slot ${remaining.toFixed(1)}s`;
-}
-
-updateFt4PeriodTimer();
-setInterval(updateFt4PeriodTimer, 250);
-
-function renderFt4Row(msg) {
-  const row = document.createElement("div");
-  row.className = "ft8-row";
-  const rawMessage = (msg.message || "").toString();
-  row.dataset.message = rawMessage.toUpperCase();
-  row.dataset.decoder = "ft4";
-  row.dataset.storedFreqHz = Number.isFinite(msg.freq_hz) ? String(msg.freq_hz) : "";
-  const snr = Number.isFinite(msg.snr_db) ? msg.snr_db.toFixed(1) : "--";
-  const dt = Number.isFinite(msg.dt_s) ? msg.dt_s.toFixed(2) : "--";
-  const displayFreqHz = normalizeFt4DisplayFreqHz(msg.freq_hz);
-  const freq = Number.isFinite(displayFreqHz) ? displayFreqHz.toFixed(0) : "--";
-  const renderedMessage = ft8RenderMessage(rawMessage);
-  const tsMs = msg._tsMs ?? msg.ts_ms;
-  const timeStr = tsMs ? new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" }) : "--:--:--";
-  row.innerHTML = `<span class="ft8-time">${timeStr}</span><span class="ft8-snr">${snr}</span><span class="ft8-dt">${dt}</span><span class="ft8-freq">${freq}</span><span class="ft8-msg">${renderedMessage}</span>`;
-  return row;
-}
-
-function renderFt4History() {
-  pruneFt4MessageHistory();
-  if (!ft4MessagesEl) return;
-  const filter = ft4FilterText;
-  const fragment = document.createDocumentFragment();
-  let rendered = 0;
-  for (let i = 0; i < ft4MessageHistory.length && rendered < FT4_MAX_DOM_ROWS; i++) {
-    const msg = ft4MessageHistory[i];
-    if (filter && !(msg.message || "").toString().toUpperCase().includes(filter)) continue;
-    fragment.appendChild(renderFt4Row(msg));
-    rendered++;
-  }
-  ft4MessagesEl.replaceChildren(fragment);
-}
-
-function addFt4Message(msg) {
-  msg._tsMs = Number.isFinite(msg?.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  ft4MessageHistory.unshift(msg);
-  pruneFt4MessageHistory();
-  window.setFt8FamilyBarDecoder?.("ft4");
-  window.updateFt8Bar?.();
-  scheduleFt4HistoryRender();
-}
-
-function normalizeServerFt4Message(msg) {
-  const raw = (msg.message || "").toString();
-  const locatorDetails = typeof ft8ExtractLocatorDetails === "function" ? ft8ExtractLocatorDetails(raw) : [];
-  const grids = locatorDetails.length > 0
-    ? locatorDetails.map((d) => d.grid)
-    : (typeof ft8ExtractAllGrids === "function" ? ft8ExtractAllGrids(raw) : []);
-  const station = typeof ft8ExtractLikelyCallsign === "function" ? ft8ExtractLikelyCallsign(raw) : null;
-  const rfHz = normalizeFt4DisplayFreqHz(msg.freq_hz);
-  return {
-    raw, grids, station, rfHz, locatorDetails,
-    history: {
-      receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
-      ts_ms: msg.ts_ms, snr_db: msg.snr_db, dt_s: msg.dt_s,
-      freq_hz: Number.isFinite(rfHz) ? rfHz : msg.freq_hz,
-      message: msg.message,
-    },
-  };
-}
-
-window.onServerFt4Batch = function(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  if (ft4Status) ft4Status.textContent = "Receiving";
-  const normalized = [];
-  for (const msg of messages) {
-    const next = normalizeServerFt4Message(msg);
-    if (next.grids.length > 0 && window.mapAddLocator) {
-      window.mapAddLocator(next.raw, next.grids, "ft4", next.station, { ...msg, freq_hz: next.rfHz, locator_details: next.locatorDetails });
-    }
-    next.history._tsMs = Number.isFinite(next.history?.ts_ms) ? Number(next.history.ts_ms) : Date.now();
-    normalized.push(next.history);
-  }
-  normalized.reverse();
-  ft4MessageHistory = normalized.concat(ft4MessageHistory);
-  pruneFt4MessageHistory();
-  window.setFt8FamilyBarDecoder?.("ft4");
-  window.updateFt8Bar?.();
-  scheduleFt4HistoryRender();
-};
-
-window.restoreFt4History = function(messages) { window.onServerFt4Batch(messages); };
-window.pruneFt4HistoryView = function() { pruneFt4MessageHistory(); renderFt4History(); };
-
-window.resetFt4HistoryView = function() {
-  if (ft4MessagesEl) ft4MessagesEl.innerHTML = "";
-  ft4MessageHistory = [];
-  window.updateFt8Bar?.();
-  renderFt4History();
-};
-
-function buildFt4BarFrames() {
-  const cutoffMs = Date.now() - 15 * 60 * 1000;
-  const messages = ft4MessageHistory.filter((msg) => Number(msg._tsMs ?? msg.ts_ms) >= cutoffMs).slice(0, 8);
-  const newestTsMs = messages.reduce((latest, msg) => Math.max(latest, Number(msg._tsMs ?? msg.ts_ms) || 0), 0);
-  if (messages.length === 0) {
-    return { count: 0, newestTsMs: 0, html: "" };
-  }
-  let html = "";
-  for (const msg of messages) {
-    const tsMs = msg._tsMs ?? msg.ts_ms;
-    const ts = tsMs ? `<span class="aprs-bar-time">${fmtTime(tsMs)}</span>` : "";
-    const snr = Number.isFinite(msg.snr_db) ? `${msg.snr_db.toFixed(1)} dB` : "-- dB";
-    const dt = Number.isFinite(msg.dt_s) ? `dt ${msg.dt_s.toFixed(2)}` : null;
-    const displayFreqHz = normalizeFt4DisplayFreqHz(msg.freq_hz);
-    const rf = Number.isFinite(displayFreqHz) ? `${displayFreqHz.toFixed(0)} Hz` : null;
-    const detail = [snr, dt, rf].filter(Boolean).join(" · ");
-    const text = ft8RenderMessage((msg.message || "").toString());
-    html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${ts}<span class="aprs-bar-call">${text}</span>${detail ? ` · ${detail}` : ""}</div></div>`;
-  }
-  return { count: messages.length, newestTsMs, html };
-}
-window.registerFt8FamilyBarRenderer?.("ft4", buildFt4BarFrames);
-
-if (ft4FilterInput) {
-  ft4FilterInput.addEventListener("input", () => {
-    ft4FilterText = ft4FilterInput.value.trim().toUpperCase();
-    renderFt4History();
-  });
-}
-
-const ft4DecodeToggleBtn = document.getElementById("ft4-decode-toggle-btn");
-ft4DecodeToggleBtn?.addEventListener("click", async () => {
-  try {
-    await window.takeSchedulerControlForDecoderDisable?.(ft4DecodeToggleBtn);
-    await postPath("/toggle_ft4_decode");
-  } catch (e) {
-    console.error("FT4 toggle failed", e);
-  }
-});
-
-document.getElementById("settings-clear-ft4-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear FT4 history?", message: "All stored FT4 decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_ft4_decode");
-    window.resetFt4HistoryView();
-  } catch (e) { console.error("FT4 history clear failed", e); }
-});
-
-window.onServerFt4 = function(msg) {
-  if (ft4Status) ft4Status.textContent = "Receiving";
-  const next = normalizeServerFt4Message(msg);
-  if (next.grids.length > 0 && window.mapAddLocator) {
-    window.mapAddLocator(next.raw, next.grids, "ft4", next.station, { ...msg, freq_hz: next.rfHz, locator_details: next.locatorDetails });
-  }
-  addFt4Message(next.history);
-};

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/ft8.js

@@ -1,486 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- FT8 Decoder Plugin (server-side decode) ---
-const ft8Status = document.getElementById("ft8-status");
-const ft8PeriodEl = document.getElementById("ft8-period");
-const ft8MessagesEl = document.getElementById("ft8-messages");
-const ft8FilterInput = document.getElementById("ft8-filter");
-const ft8BarOverlay = document.getElementById("ft8-bar-overlay");
-const FT8_BAR_WINDOW_MS = 15 * 60 * 1000;
-const FT8_PERIOD_SECONDS = 15;
-const FT8_MAX_DOM_ROWS = 200;
-const FT8_BAR_DECODER_LABELS = {
-  ft8: "FT8",
-  ft4: "FT4",
-  ft2: "FT2",
-};
-let ft8FilterText = "";
-let ft8MessageHistory = [];
-let ft8BarActiveDecoder = "ft8";
-const ft8BarBuilders = {};
-const ft8BarDismissedAtMsByDecoder = {
-  ft8: 0,
-  ft4: 0,
-  ft2: 0,
-};
-
-function currentFt8HistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneFt8MessageHistory() {
-  const cutoffMs = Date.now() - currentFt8HistoryRetentionMs();
-  ft8MessageHistory = ft8MessageHistory.filter((msg) => Number(msg?._tsMs ?? msg?.ts_ms) >= cutoffMs);
-}
-
-function scheduleFt8Ui(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-function scheduleFt8HistoryRender() {
-  scheduleFt8Ui("ft8-history", () => renderFt8History());
-}
-
-function scheduleFt8BarUpdate() {
-  scheduleFt8Ui("ft8-bar", () => updateFt8Bar());
-}
-
-window.registerFt8FamilyBarRenderer = function(decoder, builder) {
-  if (!FT8_BAR_DECODER_LABELS[decoder] || typeof builder !== "function") return;
-  ft8BarBuilders[decoder] = builder;
-};
-
-window.setFt8FamilyBarDecoder = function(decoder) {
-  if (!FT8_BAR_DECODER_LABELS[decoder]) return;
-  ft8BarActiveDecoder = decoder;
-  scheduleFt8BarUpdate();
-};
-
-function normalizeFt8DisplayFreqHz(freqHz) {
-  const rawHz = Number(freqHz);
-  if (!Number.isFinite(rawHz)) return null;
-  const baseHz = Number.isFinite(window.ft8BaseHz) ? Number(window.ft8BaseHz) : null;
-  if (Number.isFinite(baseHz) && baseHz > 0 && rawHz >= 0 && rawHz < 100000) {
-    return baseHz + rawHz;
-  }
-  return rawHz;
-}
-
-function fmtTime(tsMs) {
-  if (!tsMs) return "--:--:--";
-  return new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-}
-
-function updateFt8PeriodTimer() {
-  if (!ft8PeriodEl) return;
-  const nowSec = Math.floor(Date.now() / 1000);
-  const remaining = FT8_PERIOD_SECONDS - (nowSec % FT8_PERIOD_SECONDS);
-  ft8PeriodEl.textContent = `Next slot ${String(remaining).padStart(2, "0")}s`;
-}
-
-updateFt8PeriodTimer();
-setInterval(updateFt8PeriodTimer, 500);
-
-function renderFt8Row(msg) {
-  const row = document.createElement("div");
-  row.className = "ft8-row";
-  const rawMessage = (msg.message || "").toString();
-  row.dataset.message = rawMessage.toUpperCase();
-  row.dataset.decoder = "ft8";
-  row.dataset.storedFreqHz = Number.isFinite(msg.freq_hz) ? String(msg.freq_hz) : "";
-  const snr = Number.isFinite(msg.snr_db) ? msg.snr_db.toFixed(1) : "--";
-  const dt = Number.isFinite(msg.dt_s) ? msg.dt_s.toFixed(2) : "--";
-  const displayFreqHz = normalizeFt8DisplayFreqHz(msg.freq_hz);
-  const freq = Number.isFinite(displayFreqHz) ? displayFreqHz.toFixed(0) : "--";
-  const renderedMessage = renderFt8Message(rawMessage);
-  row.innerHTML = `<span class="ft8-time">${fmtTime(msg.ts_ms)}</span><span class="ft8-snr">${snr}</span><span class="ft8-dt">${dt}</span><span class="ft8-freq">${freq}</span><span class="ft8-msg">${renderedMessage}</span>`;
-  applyFt8FilterToRow(row);
-  return row;
-}
-
-function renderFt8History() {
-  pruneFt8MessageHistory();
-  if (!ft8MessagesEl) return;
-  const fragment = document.createDocumentFragment();
-  const limit = Math.min(ft8MessageHistory.length, FT8_MAX_DOM_ROWS);
-  for (let i = 0; i < limit; i += 1) {
-    fragment.appendChild(renderFt8Row(ft8MessageHistory[i]));
-  }
-  ft8MessagesEl.replaceChildren(fragment);
-}
-
-function addFt8Message(msg) {
-  msg._tsMs = Number.isFinite(msg?.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  ft8MessageHistory.unshift(msg);
-  pruneFt8MessageHistory();
-  ft8BarActiveDecoder = "ft8";
-  scheduleFt8BarUpdate();
-  scheduleFt8HistoryRender();
-}
-
-function normalizeServerFt8Message(msg) {
-  const raw = (msg.message || "").toString();
-  const locatorDetails = ft8ExtractLocatorDetails(raw);
-  const grids = locatorDetails.length > 0
-    ? locatorDetails.map((detail) => detail.grid)
-    : ft8ExtractAllGrids(raw);
-  const station = ft8ExtractLikelyCallsign(raw);
-  const rfHz = normalizeFt8DisplayFreqHz(msg.freq_hz);
-  return {
-    raw,
-    grids,
-    station,
-    rfHz,
-    locatorDetails,
-    history: {
-      receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
-      ts_ms: msg.ts_ms,
-      snr_db: msg.snr_db,
-      dt_s: msg.dt_s,
-      freq_hz: Number.isFinite(rfHz) ? rfHz : msg.freq_hz,
-      message: msg.message,
-    },
-  };
-}
-
-window.onServerFt8Batch = function(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  ft8Status.textContent = "Receiving";
-  const normalized = [];
-  for (const msg of messages) {
-    const next = normalizeServerFt8Message(msg);
-    if (next.grids.length > 0 && window.mapAddLocator) {
-      window.mapAddLocator(next.raw, next.grids, "ft8", next.station, {
-        ...msg,
-        freq_hz: next.rfHz,
-        locator_details: next.locatorDetails,
-      });
-    }
-    next.history._tsMs = Number.isFinite(next.history?.ts_ms) ? Number(next.history.ts_ms) : Date.now();
-    normalized.push(next.history);
-  }
-  normalized.reverse();
-  ft8MessageHistory = normalized.concat(ft8MessageHistory);
-  pruneFt8MessageHistory();
-  ft8BarActiveDecoder = "ft8";
-  scheduleFt8BarUpdate();
-  scheduleFt8HistoryRender();
-};
-
-window.restoreFt8History = function(messages) {
-  window.onServerFt8Batch(messages);
-};
-
-window.pruneFt8HistoryView = function() {
-  pruneFt8MessageHistory();
-  updateFt8Bar();
-  renderFt8History();
-};
-
-function ft8BarRfText(msg) {
-  const displayFreqHz = normalizeFt8DisplayFreqHz(msg.freq_hz);
-  if (!Number.isFinite(displayFreqHz)) return null;
-  return `${displayFreqHz.toFixed(0)} Hz`;
-}
-
-function buildFt8BarFrames() {
-  const cutoffMs = Date.now() - FT8_BAR_WINDOW_MS;
-  const messages = ft8MessageHistory.filter((msg) => Number(msg.ts_ms) >= cutoffMs).slice(0, 8);
-  const newestTsMs = messages.reduce((latest, msg) => Math.max(latest, Number(msg.ts_ms) || 0), 0);
-  if (messages.length === 0) {
-    return { count: 0, newestTsMs: 0, html: "" };
-  }
-  let html = "";
-  for (const msg of messages) {
-    const ts = msg.ts_ms ? `<span class="aprs-bar-time">${fmtTime(msg.ts_ms)}</span>` : "";
-    const snr = Number.isFinite(msg.snr_db) ? `${msg.snr_db.toFixed(1)} dB` : "-- dB";
-    const dt = Number.isFinite(msg.dt_s) ? `dt ${msg.dt_s.toFixed(2)}` : null;
-    const rf = ft8BarRfText(msg);
-    const detail = [snr, dt, rf].filter(Boolean).join(" · ");
-    const text = ft8EscapeHtml((msg.message || "").toString());
-    html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${ts}<span class="aprs-bar-call">${text}</span>${detail ? ` · ${detail}` : ""}</div></div>`;
-  }
-  return { count: messages.length, newestTsMs, html };
-}
-
-function updateFt8Bar() {
-  if (!ft8BarOverlay) return;
-  const modeUpper = (document.getElementById("mode")?.value || "").toUpperCase();
-  const isFt8Mode = modeUpper === "DIG" || modeUpper === "USB";
-  const decoder = ft8BarActiveDecoder;
-  const builder = ft8BarBuilders[decoder];
-  const label = FT8_BAR_DECODER_LABELS[decoder] || "FT8";
-  const result = typeof builder === "function" ? builder() : null;
-  const newestTsMs = Number(result?.newestTsMs) || 0;
-  if (!isFt8Mode || !result || result.count === 0 || newestTsMs <= (ft8BarDismissedAtMsByDecoder[decoder] || 0)) {
-    ft8BarOverlay.style.display = "none";
-    ft8BarOverlay.innerHTML = "";
-    return;
-  }
-
-  ft8BarOverlay.innerHTML = `<div class="aprs-bar-header"><span class="aprs-bar-title"><span class="aprs-bar-title-word">${label}</span><span class="aprs-bar-title-word">Live</span></span><span class="aprs-bar-actions"><span class="aprs-bar-window">Last 15 minutes</span><span class="aprs-bar-clear-wrap"><span class="aprs-bar-clear" role="button" tabindex="0" onclick="window.clearFt8Bar()" onkeydown="if(event.key===\'Enter\'||event.key===\' \'){event.preventDefault();window.clearFt8Bar();}" aria-label="Clear ${label} overlay">Clear</span></span><button class="aprs-bar-close" type="button" onclick="window.closeFt8Bar()" aria-label="Close ${label} overlay">&times;</button></span></div>${result.html}`;
-  ft8BarOverlay.style.display = "flex";
-}
-window.updateFt8Bar = updateFt8Bar;
-window.clearFt8Bar = function() {
-  const decoder = ft8BarActiveDecoder;
-  if (decoder === "ft4") {
-    window.resetFt4HistoryView?.();
-    return;
-  }
-  if (decoder === "ft2") {
-    window.resetFt2HistoryView?.();
-    return;
-  }
-  window.resetFt8HistoryView?.();
-};
-window.closeFt8Bar = function() {
-  ft8BarDismissedAtMsByDecoder[ft8BarActiveDecoder] = Date.now();
-  if (ft8BarOverlay) {
-    ft8BarOverlay.style.display = "none";
-    ft8BarOverlay.innerHTML = "";
-  }
-};
-window.registerFt8FamilyBarRenderer("ft8", buildFt8BarFrames);
-
-function renderFt8Message(message) {
-  let out = "";
-  let i = 0;
-  while (i < message.length) {
-    const ch = message[i];
-    if (ft8IsAlphaNum(ch)) {
-      let j = i + 1;
-      while (j < message.length && ft8IsAlphaNum(message[j])) j++;
-      const token = message.slice(i, j);
-      const grid = token.toUpperCase();
-      if (ft8IsMaidenheadGridToken(grid)) {
-        out += `<span class="ft8-locator" data-locator-grid="${grid}" role="button" tabindex="0" aria-label="Show locator ${grid} on map">${grid}</span>`;
-      } else {
-        out += ft8EscapeHtml(token);
-      }
-      i = j;
-    } else {
-      out += ft8EscapeHtml(ch);
-      i += 1;
-    }
-  }
-  return out;
-}
-
-function ft8TokenizeMessage(message) {
-  return String(message || "")
-    .toUpperCase()
-    .split(/[^A-Z0-9/]+/)
-    .filter(Boolean);
-}
-
-function ft8ExtractAllGrids(message) {
-  const out = [];
-  const seen = new Set();
-  let i = 0;
-  while (i < message.length) {
-    if (ft8IsAlphaNum(message[i])) {
-      let j = i + 1;
-      while (j < message.length && ft8IsAlphaNum(message[j])) j++;
-      const token = message.slice(i, j);
-      const grid = token.toUpperCase();
-      if (ft8IsMaidenheadGridToken(grid) && !seen.has(grid)) {
-        seen.add(grid);
-        out.push(grid);
-      }
-      i = j;
-    } else {
-      i += 1;
-    }
-  }
-  return out;
-}
-
-function ft8ExtractLocatorDetails(message) {
-  const tokens = ft8TokenizeMessage(message);
-  const grids = ft8ExtractAllGrids(String(message || ""));
-  if (tokens.length === 0 || grids.length === 0) return [];
-  const firstGridIdx = tokens.findIndex((token) => ft8IsMaidenheadGridToken(token));
-  const limit = firstGridIdx >= 0 ? firstGridIdx : tokens.length;
-  const callsigns = [];
-  for (let i = 0; i < limit; i += 1) {
-    if (ft8IsLikelyCallsignToken(tokens[i])) callsigns.push(tokens[i]);
-  }
-
-  let source = null;
-  let target = null;
-  const head = tokens[0];
-  if (callsigns.length > 0) {
-    if (head === "CQ" || head === "DE" || head === "QRZ") {
-      source = callsigns[0];
-    } else if (callsigns.length >= 2) {
-      target = callsigns[0];
-      source = callsigns[1];
-    } else {
-      source = callsigns[0];
-    }
-  }
-
-  return grids.map((grid) => ({
-    grid,
-    station: source || null,
-    source: source || null,
-    target: target || null,
-  }));
-}
-
-function ft8ExtractLikelyCallsign(message) {
-  const locatorDetails = ft8ExtractLocatorDetails(message);
-  if (locatorDetails.length > 0 && locatorDetails[0].station) {
-    return locatorDetails[0].station;
-  }
-  const tokens = ft8TokenizeMessage(message);
-  for (const token of tokens) {
-    if (ft8IsLikelyCallsignToken(token)) return token;
-  }
-  return null;
-}
-
-function ft8IsLikelyCallsignToken(token) {
-  if (!token) return false;
-  if (token.length < 3 || token.length > 12) return false;
-  if (token === "CQ" || token === "DE" || token === "QRZ" || token === "DX") return false;
-  if (ft8IsMaidenheadGridToken(token)) return false;
-  return /^[A-Z0-9/]{1,5}\d[A-Z0-9/]{1,6}$/.test(token);
-}
-
-function ft8IsFarewellToken(token) {
-  const normalized = String(token || "").trim().toUpperCase();
-  return normalized === "RR73" || normalized === "73" || normalized === "RR";
-}
-
-function ft8IsMaidenheadGridToken(token) {
-  const normalized = String(token || "").trim().toUpperCase();
-  return /^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalized) && !ft8IsFarewellToken(normalized);
-}
-
-function ft8EscapeHtml(input) {
-  return input
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll("\"", "&quot;");
-}
-
-function ft8IsAlphaNum(ch) {
-  return /[A-Za-z0-9]/.test(ch);
-}
-
-function activateFt8HistoryLocator(targetEl) {
-  const locatorEl = targetEl?.closest?.(".ft8-locator[data-locator-grid]");
-  if (!locatorEl) return false;
-  const grid = String(locatorEl.dataset.locatorGrid || "").toUpperCase();
-  if (!grid) return false;
-  if (typeof window.navigateToMapLocator === "function") {
-    window.navigateToMapLocator(grid, "ft8");
-  }
-  return true;
-}
-
-function applyFt8FilterToRow(row) {
-  if (!ft8FilterText) {
-    row.style.display = "";
-    return;
-  }
-  const message = row.dataset.message || "";
-  row.style.display = message.includes(ft8FilterText) ? "" : "none";
-}
-
-function applyFt8FilterToAll() {
-  const rows = ft8MessagesEl.querySelectorAll(".ft8-row");
-  rows.forEach((row) => applyFt8FilterToRow(row));
-}
-
-function updateFt8RowRf(row) {
-  const freqEl = row.querySelector(".ft8-freq");
-  if (!freqEl) return;
-  const storedFreqHz = row.dataset.storedFreqHz ? Number(row.dataset.storedFreqHz) : NaN;
-  const displayFreqHz = normalizeFt8DisplayFreqHz(storedFreqHz);
-  if (Number.isFinite(displayFreqHz)) {
-    freqEl.textContent = displayFreqHz.toFixed(0);
-  } else {
-    freqEl.textContent = "--";
-  }
-}
-
-window.updateFt8RfDisplay = function() {
-  const rows = ft8MessagesEl.querySelectorAll(".ft8-row");
-  rows.forEach((row) => updateFt8RowRf(row));
-  updateFt8Bar();
-};
-
-window.resetFt8HistoryView = function() {
-  ft8MessagesEl.innerHTML = "";
-  ft8MessageHistory = [];
-  updateFt8Bar();
-  renderFt8History();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("ft8");
-};
-
-if (ft8FilterInput) {
-  ft8FilterInput.addEventListener("input", () => {
-    ft8FilterText = ft8FilterInput.value.trim().toUpperCase();
-    renderFt8History();
-  });
-}
-
-if (ft8MessagesEl) {
-  ft8MessagesEl.addEventListener("click", (event) => {
-    if (!activateFt8HistoryLocator(event.target)) return;
-    event.preventDefault();
-    event.stopPropagation();
-  });
-  ft8MessagesEl.addEventListener("keydown", (event) => {
-    if (event.key !== "Enter" && event.key !== " ") return;
-    if (!activateFt8HistoryLocator(event.target)) return;
-    event.preventDefault();
-    event.stopPropagation();
-  });
-}
-
-const ft8DecodeToggleBtn = document.getElementById("ft8-decode-toggle-btn");
-ft8DecodeToggleBtn?.addEventListener("click", async () => {
-  try {
-    await window.takeSchedulerControlForDecoderDisable?.(ft8DecodeToggleBtn);
-    await postPath("/toggle_ft8_decode");
-  } catch (e) {
-    console.error("FT8 toggle failed", e);
-  }
-});
-
-document.getElementById("settings-clear-ft8-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear FT8 history?", message: "All stored FT8 decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_ft8_decode");
-    window.resetFt8HistoryView();
-  } catch (e) {
-    console.error("FT8 history clear failed", e);
-  }
-});
-
-// --- Server-side FT8 decode handler ---
-window.onServerFt8 = function(msg) {
-  ft8Status.textContent = "Receiving";
-  const next = normalizeServerFt8Message(msg);
-  if (next.grids.length > 0 && window.mapAddLocator) {
-    window.mapAddLocator(next.raw, next.grids, "ft8", next.station, {
-      ...msg,
-      freq_hz: next.rfHz,
-      locator_details: next.locatorDetails,
-    });
-  }
-  addFt8Message(next.history);
-};

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

@@ -1,444 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- HF APRS Decoder Plugin (server-side decode, 300 baud) ---
-const hfAprsStatus = document.getElementById("hf-aprs-status");
-const hfAprsPacketsEl = document.getElementById("hf-aprs-packets");
-const hfAprsFilterInput = document.getElementById("hf-aprs-filter");
-const hfAprsOnlyPosBtn = document.getElementById("hf-aprs-only-pos-btn");
-const hfAprsHideCrcBtn = document.getElementById("hf-aprs-hide-crc-btn");
-const hfAprsCollapseDupBtn = document.getElementById("hf-aprs-collapse-dup-btn");
-const hfAprsTotalCountEl = document.getElementById("hf-aprs-total-count");
-const hfAprsVisibleCountEl = document.getElementById("hf-aprs-visible-count");
-const hfAprsLatestSeenEl = document.getElementById("hf-aprs-latest-seen");
-let hfAprsFilterText = "";
-let hfAprsPacketHistory = [];
-let hfAprsOnlyPos = false;
-let hfAprsHideCrc = false;
-let hfAprsCollapseDup = false;
-let hfAprsTypeFilter = "all";
-
-function currentHfAprsHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneHfAprsPacketHistory() {
-  const cutoffMs = Date.now() - currentHfAprsHistoryRetentionMs();
-  hfAprsPacketHistory = hfAprsPacketHistory.filter((pkt) => Number(pkt?._tsMs) >= cutoffMs);
-}
-
-function scheduleHfAprsHistoryRender() {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob("hf-aprs-history", () => renderHfAprsHistory());
-    return;
-  }
-  renderHfAprsHistory();
-}
-
-function hfAprsPacketCategory(pkt) {
-  const type = String(pkt.type || "").toLowerCase();
-  const info = String(pkt.info || "").toLowerCase();
-  if (pkt.lat != null && pkt.lon != null || type.includes("position")) return "position";
-  if (type.includes("message") || info.startsWith(":")) return "message";
-  if (type.includes("weather") || info.startsWith("_")) return "weather";
-  if (type.includes("telemetry") || info.startsWith("t#")) return "telemetry";
-  return "other";
-}
-
-function hfAprsCategoryLabel(category) {
-  switch (category) {
-    case "position": return "Position";
-    case "message": return "Message";
-    case "weather": return "Weather";
-    case "telemetry": return "Telemetry";
-    default: return "Other";
-  }
-}
-
-function hfAprsAgeText(tsMs) {
-  if (!Number.isFinite(tsMs)) return "just now";
-  const deltaMs = Math.max(0, Date.now() - tsMs);
-  const seconds = Math.round(deltaMs / 1000);
-  if (seconds < 5) return "just now";
-  if (seconds < 60) return `${seconds}s ago`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${minutes}m ago`;
-  const hours = Math.round(minutes / 60);
-  return `${hours}h ago`;
-}
-
-function hfAprsDistanceText(pkt) {
-  if (serverLat == null || serverLon == null || pkt.lat == null || pkt.lon == null) return "";
-  const distKm = haversineKm(serverLat, serverLon, pkt.lat, pkt.lon);
-  if (!Number.isFinite(distKm)) return "";
-  if (distKm < 1) return `${Math.round(distKm * 1000)} m from TRX`;
-  return `${distKm.toFixed(1)} km from TRX`;
-}
-
-function hfAprsPacketSignature(pkt) {
-  return [
-    pkt.srcCall || "",
-    pkt.destCall || "",
-    pkt.path || "",
-    pkt.info || "",
-    pkt.type || "",
-    pkt.lat != null ? pkt.lat.toFixed(4) : "",
-    pkt.lon != null ? pkt.lon.toFixed(4) : "",
-  ].join("|");
-}
-
-function hfAprsHexBytes(bytes) {
-  if (!Array.isArray(bytes) || bytes.length === 0) return "--";
-  return bytes.map((b) => Number(b).toString(16).toUpperCase().padStart(2, "0")).join(" ");
-}
-
-function hfAprsFilterMatch(pkt) {
-  if (hfAprsOnlyPos && (pkt.lat == null || pkt.lon == null)) return false;
-  if (hfAprsHideCrc && !pkt.crcOk) return false;
-  if (hfAprsTypeFilter !== "all" && hfAprsPacketCategory(pkt) !== hfAprsTypeFilter) return false;
-  if (!hfAprsFilterText) return true;
-  const haystack = [
-    pkt.srcCall,
-    pkt.destCall,
-    pkt.path,
-    pkt.info,
-    pkt.type,
-    pkt.lat != null ? pkt.lat.toFixed(4) : "",
-    pkt.lon != null ? pkt.lon.toFixed(4) : "",
-    hfAprsPacketCategory(pkt),
-  ]
-    .filter(Boolean)
-    .join(" ")
-    .toUpperCase();
-  return haystack.includes(hfAprsFilterText);
-}
-
-function hfAprsVisiblePackets() {
-  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(hfAprsPacketHistory) : hfAprsPacketHistory;
-  return packets.filter(hfAprsFilterMatch);
-}
-
-function collapseHfAprsDuplicates(packets) {
-  const seen = new Set();
-  const out = [];
-  for (const pkt of packets) {
-    const key = hfAprsPacketSignature(pkt);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(pkt);
-  }
-  return out;
-}
-
-function updateHfAprsSummary() {
-  const visible = hfAprsVisiblePackets();
-  if (hfAprsTotalCountEl) {
-    hfAprsTotalCountEl.textContent = `${hfAprsPacketHistory.length} total`;
-  }
-  if (hfAprsVisibleCountEl) {
-    hfAprsVisibleCountEl.textContent = `${visible.length} shown`;
-  }
-  if (hfAprsLatestSeenEl) {
-    const latest = hfAprsPacketHistory[0];
-    if (!latest) {
-      hfAprsLatestSeenEl.textContent = "No packets yet";
-    } else {
-      hfAprsLatestSeenEl.textContent = `${latest.srcCall} ${hfAprsAgeText(latest._tsMs)}`;
-    }
-  }
-}
-
-function updateHfAprsChipState() {
-  document.querySelectorAll("[id^='hf-aprs-type-']").forEach((btn) => {
-    btn.classList.toggle("active", btn.id === `hf-aprs-type-${hfAprsTypeFilter}`);
-  });
-  hfAprsOnlyPosBtn?.classList.toggle("active", hfAprsOnlyPos);
-  hfAprsHideCrcBtn?.classList.toggle("active", hfAprsHideCrc);
-  hfAprsCollapseDupBtn?.classList.toggle("active", hfAprsCollapseDup);
-}
-
-function renderHfAprsInfo(pkt) {
-  const bytes = Array.isArray(pkt.info_bytes) ? pkt.info_bytes : null;
-  if (bytes && bytes.length > 0) {
-    let out = "";
-    for (let i = 0; i < bytes.length; i++) {
-      const b = bytes[i];
-      if (b >= 0x20 && b <= 0x7e) {
-        const ch = String.fromCharCode(b);
-        if (ch === "<") out += "&lt;";
-        else if (ch === ">") out += "&gt;";
-        else if (ch === "&") out += "&amp;";
-        else if (ch === '"') out += "&quot;";
-        else out += ch;
-      } else {
-        const hex = b.toString(16).toUpperCase().padStart(2, "0");
-        out += `<span class="aprs-byte">0x${hex}</span>`;
-      }
-    }
-    return out;
-  }
-  const str = pkt.info || "";
-  let out = "";
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    if (code >= 0x20 && code <= 0x7e) {
-      const ch = str[i];
-      if (ch === "<") out += "&lt;";
-      else if (ch === ">") out += "&gt;";
-      else if (ch === "&") out += "&amp;";
-      else if (ch === '"') out += "&quot;";
-      else out += ch;
-    } else {
-      const hex = code.toString(16).toUpperCase().padStart(2, "0");
-      out += `<span class="aprs-byte">0x${hex}</span>`;
-    }
-  }
-  return out;
-}
-
-function renderHfAprsRow(pkt, isFresh) {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-
-  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  const age = hfAprsAgeText(pkt._tsMs);
-  const category = hfAprsPacketCategory(pkt);
-  const categoryLabel = hfAprsCategoryLabel(category);
-  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeMapHtml(pkt.path)}</span>` : "";
-  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-  const hfBadge = '<span class="aprs-badge" style="background:var(--accent-alt,#f59e0b);color:#000">HF</span>';
-  let symbolHtml = "";
-  if (pkt.symbolTable && pkt.symbolCode) {
-    const sheet = pkt.symbolTable === "/" ? 0 : 1;
-    const code = pkt.symbolCode.charCodeAt(0) - 33;
-    const col = code % 16;
-    const row2 = Math.floor(code / 16);
-    const bgX = -(col * 24);
-    const bgY = -(row2 * 24);
-    symbolHtml = `<span class="aprs-symbol" style="background-image:url('https://raw.githubusercontent.com/hessu/aprs-symbols/master/png/aprs-symbols-24-${sheet}.png');background-position:${bgX}px ${bgY}px"></span>`;
-  }
-  const posLink = pkt.lat != null && pkt.lon != null
-    ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>`
-    : "";
-  const distance = hfAprsDistanceText(pkt);
-  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
-
-  row.innerHTML =
-    `<div class="aprs-row-head">` +
-      `<span class="aprs-time">${ts}</span>` +
-      hfBadge +
-      symbolHtml +
-      `<span class="aprs-call">${escapeMapHtml(pkt.srcCall)}</span>` +
-      `<span>&gt;${escapeMapHtml(pkt.destCall || "")}</span>` +
-      `<span class="${categoryClass}">${escapeMapHtml(categoryLabel)}</span>` +
-      pathBadge +
-      crcBadge +
-    `</div>` +
-    `<div class="aprs-row-meta">` +
-      `<span class="aprs-meta-text">${escapeMapHtml(age)}</span>` +
-      (distance ? `<span class="aprs-meta-text">${escapeMapHtml(distance)}</span>` : "") +
-      `<span class="aprs-meta-text">${escapeMapHtml(pkt.type || "--")}</span>` +
-    `</div>` +
-    `<div class="aprs-row-detail">` +
-      `<span title="${escapeMapHtml(pkt.type || "")}">${renderHfAprsInfo(pkt)}</span>` +
-      (posLink ? `<span>${posLink}</span>` : "") +
-    `</div>` +
-    `<div class="aprs-row-actions">` +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") +
-      `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
-    `</div>` +
-    `<details class="aprs-details">` +
-      `<summary>Details</summary>` +
-      `<div class="aprs-details-grid">` +
-        `<span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeMapHtml(pkt.srcCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeMapHtml(pkt.destCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeMapHtml(pkt.type || "--")}</span>` +
-        `<span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeMapHtml(pkt.path || "--")}</span>` +
-        `<span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeMapHtml(age)}</span>` +
-        `<span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span>` +
-        `<span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span>` +
-        `<span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeMapHtml(pkt.info || "--")}</span>` +
-        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeMapHtml(hfAprsHexBytes(pkt.info_bytes))}</span>` +
-      `</div>` +
-    `</details>`;
-
-  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
-    el.addEventListener("click", (evt) => {
-      evt.preventDefault();
-      const raw = String(el.dataset.aprsMap || "");
-      const [lat, lon] = raw.split(",").map(Number);
-      if (window.navigateToAprsMap && Number.isFinite(lat) && Number.isFinite(lon)) {
-        window.navigateToAprsMap(lat, lon);
-      }
-    });
-  });
-
-  const copyBtn = row.querySelector("[data-aprs-copy]");
-  if (copyBtn) {
-    copyBtn.addEventListener("click", async () => {
-      const raw = String(copyBtn.dataset.aprsCopy || "");
-      try {
-        if (navigator.clipboard?.writeText) {
-          await navigator.clipboard.writeText(raw);
-          showHint("Coordinates copied", 1200);
-        }
-      } catch (_e) {
-        showHint("Copy failed", 1500);
-      }
-    });
-  }
-
-  return row;
-}
-
-function renderHfAprsHistory() {
-  pruneHfAprsPacketHistory();
-  if (!hfAprsPacketsEl) {
-    updateHfAprsSummary();
-    updateHfAprsChipState();
-    return;
-  }
-  const visible = hfAprsVisiblePackets();
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < visible.length; i++) {
-    fragment.appendChild(renderHfAprsRow(visible[i], i === 0));
-  }
-  hfAprsPacketsEl.replaceChildren(fragment);
-  updateHfAprsSummary();
-  updateHfAprsChipState();
-}
-
-window.resetHfAprsHistoryView = function() {
-  if (hfAprsPacketsEl) hfAprsPacketsEl.innerHTML = "";
-  hfAprsPacketHistory = [];
-  renderHfAprsHistory();
-};
-
-window.pruneHfAprsHistoryView = function() {
-  pruneHfAprsPacketHistory();
-  renderHfAprsHistory();
-};
-
-function addHfAprsPacket(pkt) {
-  const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
-  pkt._tsMs = tsMs;
-  pkt._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-
-  hfAprsPacketHistory.unshift(pkt);
-  pruneHfAprsPacketHistory();
-
-  scheduleHfAprsHistoryRender();
-}
-
-function normalizeServerHfAprsPacket(pkt) {
-  return {
-    rig_id: pkt.rig_id || null,
-    receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
-    srcCall: pkt.src_call,
-    destCall: pkt.dest_call,
-    path: pkt.path,
-    info: pkt.info,
-    info_bytes: pkt.info_bytes,
-    type: pkt.packet_type,
-    crcOk: pkt.crc_ok,
-    ts_ms: pkt.ts_ms,
-    lat: pkt.lat,
-    lon: pkt.lon,
-    symbolTable: pkt.symbol_table,
-    symbolCode: pkt.symbol_code,
-  };
-}
-
-window.onServerHfAprsBatch = function(packets) {
-  if (!Array.isArray(packets) || packets.length === 0) return;
-  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  const normalized = [];
-  for (const pkt of packets) {
-    const next = normalizeServerHfAprsPacket(pkt);
-    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
-    next._tsMs = tsMs;
-    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    normalized.push(next);
-  }
-  normalized.reverse();
-  hfAprsPacketHistory = normalized.concat(hfAprsPacketHistory);
-  pruneHfAprsPacketHistory();
-  scheduleHfAprsHistoryRender();
-};
-
-window.restoreHfAprsHistory = function(packets) {
-  window.onServerHfAprsBatch(packets);
-};
-
-const hfAprsDecodeToggleBtn = document.getElementById("hf-aprs-decode-toggle-btn");
-hfAprsDecodeToggleBtn?.addEventListener("click", async () => {
-  try {
-    await window.takeSchedulerControlForDecoderDisable?.(hfAprsDecodeToggleBtn);
-    await postPath("/toggle_hf_aprs_decode");
-  } catch (e) {
-    console.error("HF APRS toggle failed", e);
-  }
-});
-
-document.getElementById("settings-clear-hf-aprs-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear HF APRS history?", message: "All stored HF APRS packets will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_hf_aprs_decode");
-    window.resetHfAprsHistoryView();
-  } catch (e) {
-    console.error("HF APRS history clear failed", e);
-  }
-});
-
-if (hfAprsOnlyPosBtn) {
-  hfAprsOnlyPosBtn.addEventListener("click", () => {
-    hfAprsOnlyPos = !hfAprsOnlyPos;
-    renderHfAprsHistory();
-  });
-}
-
-if (hfAprsHideCrcBtn) {
-  hfAprsHideCrcBtn.addEventListener("click", () => {
-    hfAprsHideCrc = !hfAprsHideCrc;
-    renderHfAprsHistory();
-  });
-}
-
-if (hfAprsCollapseDupBtn) {
-  hfAprsCollapseDupBtn.addEventListener("click", () => {
-    hfAprsCollapseDup = !hfAprsCollapseDup;
-    renderHfAprsHistory();
-  });
-}
-
-["all", "position", "message", "weather", "telemetry", "other"].forEach((type) => {
-  const btn = document.getElementById(`hf-aprs-type-${type}`);
-  if (!btn) return;
-  btn.addEventListener("click", () => {
-    hfAprsTypeFilter = type;
-    renderHfAprsHistory();
-  });
-});
-
-if (hfAprsFilterInput) {
-  hfAprsFilterInput.addEventListener("input", () => {
-    hfAprsFilterText = hfAprsFilterInput.value.trim().toUpperCase();
-    renderHfAprsHistory();
-  });
-}
-
-// --- Server-side HF APRS decode handler ---
-window.onServerHfAprs = function(pkt) {
-  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
-};
-
-renderHfAprsHistory();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("hf_aprs");

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/sat-scheduler.js

@@ -1,321 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// Satellite Pass Scheduling UI
-// Manages the satellite overlay section within the background decoding scheduler.
-// Communicates with scheduler.js via a thin window API for shared state access.
-
-(function () {
-  "use strict";
-
-  // ── DOM references (cached once) ──────────────────────────────────
-  const dom = {
-    enabled:    document.getElementById("scheduler-sat-enabled"),
-    pretune:    document.getElementById("scheduler-sat-pretune"),
-    body:       document.getElementById("scheduler-sat-body"),
-    tbody:      document.getElementById("scheduler-sat-tbody"),
-    addBtn:     document.getElementById("scheduler-sat-add-btn"),
-    passStatus: document.getElementById("scheduler-sat-pass-status"),
-    formWrap:   document.getElementById("sch-sat-form-wrap"),
-    formTitle:  document.getElementById("sch-sat-form-title"),
-    form:       document.getElementById("sch-sat-form"),
-    formCancel: document.getElementById("sch-sat-form-cancel"),
-    preset:     document.getElementById("scheduler-sat-preset"),
-    name:       document.getElementById("scheduler-sat-name"),
-    norad:      document.getElementById("scheduler-sat-norad"),
-    bookmark:   document.getElementById("scheduler-sat-bookmark"),
-    minEl:      document.getElementById("scheduler-sat-min-el"),
-    priority:   document.getElementById("scheduler-sat-priority"),
-    centerHz:   document.getElementById("scheduler-sat-center-hz"),
-  };
-
-  // ── Local state ───────────────────────────────────────────────────
-  let editIdx = null; // null = adding, number = editing
-
-  // ── Scheduler bridge ──────────────────────────────────────────────
-  // These accessors call into scheduler.js via window.schedulerBridge,
-  // which is set up by scheduler.js after it initializes.
-  function getBridge() {
-    return window.schedulerBridge || {};
-  }
-
-  function getConfig() {
-    const b = getBridge();
-    return typeof b.getConfig === "function" ? b.getConfig() : null;
-  }
-
-  function getStatus() {
-    const b = getBridge();
-    return typeof b.getStatus === "function" ? b.getStatus() : null;
-  }
-
-  function getBookmarks() {
-    const b = getBridge();
-    return typeof b.getBookmarks === "function" ? b.getBookmarks() : [];
-  }
-
-  function markDirty() {
-    var b = getBridge();
-    if (typeof b.markDirty === "function") b.markDirty();
-  }
-
-  function bmName(id) {
-    const bm = getBookmarks().find(function (b) { return b.id === id; });
-    return bm ? bm.name : String(id || "");
-  }
-
-  function escHtml(s) {
-    return String(s)
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;");
-  }
-
-  function formatFreq(hz) {
-    if (hz >= 1e6) return (hz / 1e6).toFixed(3) + " MHz";
-    if (hz >= 1e3) return (hz / 1e3).toFixed(1) + " kHz";
-    return hz + " Hz";
-  }
-
-  // ── Satellite config helpers ──────────────────────────────────────
-  function getSatelliteEntries() {
-    var config = getConfig();
-    return (config && config.satellites && Array.isArray(config.satellites.entries))
-      ? config.satellites.entries
-      : [];
-  }
-
-  function ensureSatelliteConfig() {
-    var config = getConfig();
-    if (!config) return { enabled: false, pretune_secs: 60, entries: [] };
-    if (!config.satellites) config.satellites = { enabled: false, pretune_secs: 60, entries: [] };
-    if (!config.satellites.entries) config.satellites.entries = [];
-    return config.satellites;
-  }
-
-  function collectSatelliteConfig() {
-    var enabled = dom.enabled ? dom.enabled.checked : false;
-    var pretune = dom.pretune ? parseInt(dom.pretune.value, 10) : 60;
-    return {
-      enabled: enabled,
-      pretune_secs: isNaN(pretune) || pretune < 0 ? 60 : pretune,
-      entries: getSatelliteEntries(),
-    };
-  }
-
-  // ── Render: section ───────────────────────────────────────────────
-  function renderSection() {
-    var config = getConfig();
-    var satCfg = (config && config.satellites) || {};
-    var enabled = !!satCfg.enabled;
-
-    if (dom.enabled) dom.enabled.checked = enabled;
-    if (dom.pretune) dom.pretune.value = satCfg.pretune_secs != null ? satCfg.pretune_secs : 60;
-    if (dom.body) dom.body.style.display = enabled ? "" : "none";
-
-    renderEntries();
-    renderPassStatus();
-  }
-
-  // ── Render: entries table ─────────────────────────────────────────
-  function renderEntries() {
-    if (!dom.tbody) return;
-    var entries = getSatelliteEntries();
-    var frag = document.createDocumentFragment();
-
-    entries.forEach(function (entry, idx) {
-      var tr = document.createElement("tr");
-
-      var tdSat = document.createElement("td");
-      tdSat.textContent = entry.satellite || "";
-      tr.appendChild(tdSat);
-
-      var tdNorad = document.createElement("td");
-      tdNorad.textContent = entry.norad_id || "";
-      tr.appendChild(tdNorad);
-
-      var tdBm = document.createElement("td");
-      tdBm.textContent = bmName(entry.bookmark_id);
-      tr.appendChild(tdBm);
-
-      var tdEl = document.createElement("td");
-      tdEl.textContent = (entry.min_elevation_deg != null ? entry.min_elevation_deg + "\u00B0" : "5\u00B0");
-      tr.appendChild(tdEl);
-
-      var tdPrio = document.createElement("td");
-      tdPrio.textContent = entry.priority || 0;
-      tr.appendChild(tdPrio);
-
-      var tdActions = document.createElement("td");
-
-      var editBtn = document.createElement("button");
-      editBtn.className = "sch-write";
-      editBtn.type = "button";
-      editBtn.textContent = "Edit";
-      editBtn.addEventListener("click", function () {
-        openForm(entry, idx);
-      });
-      tdActions.appendChild(editBtn);
-
-      var removeBtn = document.createElement("button");
-      removeBtn.className = "sch-write";
-      removeBtn.type = "button";
-      removeBtn.textContent = "Remove";
-      removeBtn.addEventListener("click", function () {
-        removeEntry(idx);
-      });
-      tdActions.appendChild(removeBtn);
-
-      tr.appendChild(tdActions);
-      frag.appendChild(tr);
-    });
-
-    dom.tbody.replaceChildren(frag);
-  }
-
-  // ── Render: pass status ───────────────────────────────────────────
-  function renderPassStatus() {
-    if (!dom.passStatus) return;
-    var entries = getSatelliteEntries();
-    if (entries.length === 0) {
-      dom.passStatus.innerHTML = "";
-      return;
-    }
-    var status = getStatus();
-    if (status && status.active_satellite) {
-      dom.passStatus.innerHTML =
-        '<span class="sch-sat-active-badge">PASS ACTIVE: ' +
-        escHtml(status.active_satellite) +
-        '</span>';
-    } else {
-      dom.passStatus.innerHTML =
-        '<span style="color:var(--text-muted);font-size:0.8rem;">No satellite pass active. Predictions available in the SAT tab.</span>';
-    }
-  }
-
-  // ── Render: bookmark dropdown ─────────────────────────────────────
-  function renderBookmarkSelect(selectedId) {
-    if (!dom.bookmark) return;
-    dom.bookmark.innerHTML = '<option value="">— none —</option>';
-    getBookmarks().forEach(function (bm) {
-      var opt = document.createElement("option");
-      opt.value = bm.id;
-      opt.textContent = bm.name + " (" + formatFreq(bm.freq_hz) + " " + bm.mode + ")";
-      if (bm.id === selectedId) opt.selected = true;
-      dom.bookmark.appendChild(opt);
-    });
-  }
-
-  // ── Entry management ──────────────────────────────────────────────
-  function removeEntry(idx) {
-    var sat = ensureSatelliteConfig();
-    sat.entries.splice(idx, 1);
-    renderEntries();
-    markDirty();
-  }
-
-  // ── Form: open ────────────────────────────────────────────────────
-  function openForm(entry, idx) {
-    editIdx = (idx != null) ? idx : null;
-
-    if (dom.formTitle) dom.formTitle.textContent = entry ? "Edit Satellite" : "Add Satellite";
-    if (dom.preset)   dom.preset.value = "";
-    if (dom.name)     dom.name.value = entry ? (entry.satellite || "") : "";
-    if (dom.norad)    dom.norad.value = entry ? (entry.norad_id || "") : "";
-    if (dom.minEl)    dom.minEl.value = entry && entry.min_elevation_deg != null ? entry.min_elevation_deg : 5;
-    if (dom.priority) dom.priority.value = entry && entry.priority != null ? entry.priority : 0;
-    if (dom.centerHz) dom.centerHz.value = entry && entry.center_hz ? entry.center_hz : "";
-
-    renderBookmarkSelect(entry ? entry.bookmark_id : null);
-
-    if (dom.formWrap) {
-      dom.formWrap.style.display = "flex";
-      if (dom.name) dom.name.focus();
-    }
-  }
-
-  // ── Form: close ───────────────────────────────────────────────────
-  function closeForm() {
-    if (dom.formWrap) dom.formWrap.style.display = "none";
-    editIdx = null;
-  }
-
-  // ── Form: submit ──────────────────────────────────────────────────
-  function onFormSubmit(e) {
-    e.preventDefault();
-
-    var satellite = dom.name ? dom.name.value.trim() : "";
-    var noradId = dom.norad ? parseInt(dom.norad.value, 10) : NaN;
-    var bmId = dom.bookmark ? dom.bookmark.value : "";
-
-    if (!satellite) { window.trxUi?.notify("Enter a satellite name.", { kind: "error" }); document.getElementById("scheduler-sat-name")?.focus(); return; }
-    if (isNaN(noradId) || noradId <= 0) { window.trxUi?.notify("Enter a valid NORAD catalog number.", { kind: "error" }); document.getElementById("scheduler-sat-norad")?.focus(); return; }
-    if (!bmId) { window.trxUi?.notify("Select a bookmark.", { kind: "error" }); document.getElementById("scheduler-sat-bookmark")?.focus(); return; }
-
-    var minEl = dom.minEl ? parseFloat(dom.minEl.value) : 5;
-    var prio = dom.priority ? parseInt(dom.priority.value, 10) : 0;
-    var centerHzRaw = dom.centerHz ? parseInt(dom.centerHz.value, 10) : NaN;
-
-    var sat = ensureSatelliteConfig();
-
-    var entryData = {
-      satellite: satellite,
-      norad_id: noradId,
-      bookmark_id: bmId,
-      min_elevation_deg: isNaN(minEl) ? 5 : minEl,
-      priority: isNaN(prio) ? 0 : prio,
-      center_hz: !isNaN(centerHzRaw) && centerHzRaw > 0 ? centerHzRaw : null,
-      bookmark_ids: [],
-    };
-
-    if (editIdx !== null) {
-      var existing = sat.entries[editIdx];
-      entryData.id = existing ? existing.id : ("sat_" + Date.now().toString(36));
-      sat.entries[editIdx] = entryData;
-    } else {
-      entryData.id = "sat_" + Date.now().toString(36);
-      sat.entries.push(entryData);
-    }
-
-    closeForm();
-    renderEntries();
-    markDirty();
-  }
-
-  // ── Preset change handler ─────────────────────────────────────────
-  function onPresetChange() {
-    if (!dom.preset || !dom.preset.value) return;
-    var parts = dom.preset.value.split("|");
-    if (dom.name)  dom.name.value = parts[0] || "";
-    if (dom.norad) dom.norad.value = parts[1] || "";
-  }
-
-  // ── Wire all events ───────────────────────────────────────────────
-  function wireEvents() {
-    if (dom.enabled) {
-      dom.enabled.addEventListener("change", function () {
-        if (dom.body) dom.body.style.display = dom.enabled.checked ? "" : "none";
-        markDirty();
-      });
-    }
-    if (dom.pretune) {
-      dom.pretune.addEventListener("input", function () {
-        markDirty();
-      });
-    }
-    if (dom.addBtn)     dom.addBtn.addEventListener("click", function () { openForm(null, null); });
-    if (dom.form)       dom.form.addEventListener("submit", onFormSubmit);
-    if (dom.formCancel) dom.formCancel.addEventListener("click", closeForm);
-    if (dom.preset)     dom.preset.addEventListener("change", onPresetChange);
-  }
-
-  // ── Public API ────────────────────────────────────────────────────
-  window.satScheduler = {
-    wireEvents:              wireEvents,
-    renderSection:           renderSection,
-    renderPassStatus:        renderPassStatus,
-    collectSatelliteConfig:  collectSatelliteConfig,
-  };
-})();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/sat.js

@@ -1,546 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- SAT Plugin ---
-// Live view: decoder state, latest image card
-// History view: filterable table of all decoded images
-// Predictions view: next 24 h passes for ham satellites
-
-// ── DOM references (cached once) ───────────────────────────────────
-const satDom = {
-  status:           document.getElementById("sat-status"),
-  liveView:         document.getElementById("sat-live-view"),
-  historyView:      document.getElementById("sat-history-view"),
-  predictionsView:  document.getElementById("sat-predictions-view"),
-  liveLatest:       document.getElementById("sat-live-latest"),
-  historyList:      document.getElementById("sat-history-list"),
-  historyCount:     document.getElementById("sat-history-count"),
-  filterInput:      document.getElementById("sat-filter"),
-  sortSelect:       document.getElementById("sat-sort"),
-  typeFilter:       document.getElementById("sat-type-filter"),
-  lrptState:        document.getElementById("sat-lrpt-state"),
-  viewLiveBtn:      document.getElementById("sat-view-live"),
-  viewHistoryBtn:   document.getElementById("sat-view-history"),
-  viewPredBtn:      document.getElementById("sat-view-predictions"),
-  predFilter:       document.getElementById("sat-pred-filter"),
-  predMinEl:        document.getElementById("sat-pred-min-el"),
-  predCategory:     document.getElementById("sat-pred-category"),
-  predCurrentList:  document.getElementById("sat-pred-current-list"),
-  predUpcomingList: document.getElementById("sat-pred-list"),
-  predCurrentSec:   document.getElementById("sat-pred-current-section"),
-  predUpcomingSec:  document.getElementById("sat-pred-upcoming-section"),
-  predStatus:       document.getElementById("sat-pred-status"),
-};
-
-// ── State ───────────────────────────────────────────────────────────
-let satImageHistory = [];
-const SAT_MAX_IMAGES = 100;
-const SAT_PRED_PAGE_SIZE = 50;
-let satPredShowAll = false;
-let satFilterText = "";
-let satActiveView = "live"; // "live" | "history" | "predictions"
-let satPredData = [];
-let satPredFilterText = "";
-let satPredMinEl = 0;
-let satPredCategory = "all";
-let satPredSatCount = 0;
-let satPredCountdownTimer = null;
-
-// ── UI scheduler helper ─────────────────────────────────────────────
-function scheduleSatUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-// ── View switching ──────────────────────────────────────────────────
-function switchSatView(view) {
-  const leavingPredictions = satActiveView === "predictions" && view !== "predictions";
-  satActiveView = view;
-  if (satDom.liveView)        satDom.liveView.style.display = view === "live" ? "" : "none";
-  if (satDom.historyView)     satDom.historyView.style.display = view === "history" ? "" : "none";
-  if (satDom.predictionsView) satDom.predictionsView.style.display = view === "predictions" ? "" : "none";
-  if (satDom.viewLiveBtn)     satDom.viewLiveBtn.classList.toggle("sat-view-active", view === "live");
-  if (satDom.viewHistoryBtn)  satDom.viewHistoryBtn.classList.toggle("sat-view-active", view === "history");
-  if (satDom.viewPredBtn)     satDom.viewPredBtn.classList.toggle("sat-view-active", view === "predictions");
-  if (leavingPredictions) clearPredictionDom();
-  if (view === "history") {
-    renderSatHistoryTable();
-  } else if (view === "predictions") {
-    satPredShowAll = false;
-    loadSatPredictions();
-  }
-}
-
-function clearPredictionDom() {
-  stopCountdownTimer();
-  if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
-  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
-}
-window.clearSatPredictionDom = clearPredictionDom;
-
-satDom.viewLiveBtn?.addEventListener("click", () => switchSatView("live"));
-satDom.viewHistoryBtn?.addEventListener("click", () => switchSatView("history"));
-satDom.viewPredBtn?.addEventListener("click", () => switchSatView("predictions"));
-
-// ── Live view: decoder state ────────────────────────────────────────
-let _lastSatLrptOn = null;
-window.updateSatLiveState = function (update) {
-  if (!satDom.lrptState) return;
-  const lrptOn = !!update.lrpt_decode_enabled;
-  if (lrptOn !== _lastSatLrptOn) {
-    _lastSatLrptOn = lrptOn;
-    satDom.lrptState.textContent = lrptOn ? "Listening" : "Idle";
-    satDom.lrptState.className = "sat-live-value " + (lrptOn ? "sat-state-listening" : "sat-state-idle");
-    if (satDom.status) {
-      if (lrptOn) {
-        satDom.status.textContent = "Decoder active \u2014 waiting for signal";
-      } else {
-        satDom.status.textContent = "Decoder idle";
-      }
-    }
-  }
-};
-
-function renderSatLatestCard() {
-  if (!satDom.liveLatest) return;
-  if (satImageHistory.length === 0) {
-    satDom.liveLatest.innerHTML =
-      '<div style="color:var(--text-muted);font-size:0.82rem;">No images decoded yet. Enable a decoder and wait for a satellite pass.</div>';
-    return;
-  }
-
-  const img = satImageHistory[0];
-  const decoder = img._decoder || "unknown";
-  const typeName = "Meteor LRPT";
-  const satellite = img.satellite || "";
-  const channels = img.channels || img.channel_a || "";
-  const lines = img.mcu_count || img.line_count || 0;
-  const unit = "MCU rows";
-  const ts = img._ts || "--";
-  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : "";
-
-  let meta = [typeName];
-  if (satellite) meta.push(satellite);
-  if (channels) meta.push(channels);
-  meta.push(`${lines} ${unit}`);
-  meta.push(`${date} ${ts}`);
-
-  let html = `<div class="sat-latest-card">`;
-  html += `<div class="sat-latest-title">Latest decoded image</div>`;
-  html += `<div class="sat-latest-meta">${meta.join(" &middot; ")}</div>`;
-  if (img.path) {
-    html += `<a href="${img.path}" target="_blank" style="font-size:0.8rem;color:var(--accent);display:inline-block;margin-top:0.25rem;">Download PNG</a>`;
-  }
-  if (img.geo_bounds) {
-    html += ` <button type="button" class="sat-map-btn" onclick="window.satShowOnMap(${img.geo_bounds[0]},${img.geo_bounds[1]},${img.geo_bounds[2]},${img.geo_bounds[3]})" style="font-size:0.8rem;margin-top:0.25rem;margin-left:0.5rem;cursor:pointer;background:none;border:1px solid var(--accent);color:var(--accent);border-radius:3px;padding:1px 6px;">Show on Map</button>`;
-  }
-  html += `</div>`;
-  satDom.liveLatest.innerHTML = html;
-}
-
-// ── History view: table ─────────────────────────────────────────────
-function getSatFilteredHistory() {
-  let items = satImageHistory;
-
-  const typeVal = satDom.typeFilter ? satDom.typeFilter.value : "all";
-  if (typeVal === "lrpt") items = items.filter((i) => i._decoder === "lrpt");
-
-  if (satFilterText) {
-    items = items.filter((i) => {
-      const haystack = [
-        "meteor lrpt",
-        i.satellite || "",
-        i.channels || "",
-        i.channel_a || "",
-        i.channel_b || "",
-      ].join(" ").toUpperCase();
-      return haystack.includes(satFilterText);
-    });
-  }
-
-  const sortVal = satDom.sortSelect ? satDom.sortSelect.value : "newest";
-  if (sortVal === "oldest") items = items.slice().reverse();
-
-  return items;
-}
-
-function renderSatHistoryRow(img) {
-  const row = document.createElement("div");
-  row.className = "sat-history-row";
-
-  const decoder = img._decoder || "unknown";
-  const typeName = "Meteor LRPT";
-  const typeClass = "sat-type-lrpt";
-  const ts = img._ts || "--";
-  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString([], { month: "short", day: "numeric" }) : "";
-  const satellite = img.satellite || "--";
-  const channels = img.channels || "--";
-  const lines = img.mcu_count || img.line_count || 0;
-  const unit = "MCU";
-  let link = img.path
-    ? `<a href="${img.path}" target="_blank" style="color:var(--accent);">PNG</a>`
-    : "--";
-  if (img.geo_bounds) {
-    link += ` <a href="javascript:void(0)" onclick="window.satShowOnMap(${img.geo_bounds[0]},${img.geo_bounds[1]},${img.geo_bounds[2]},${img.geo_bounds[3]})" style="color:var(--accent);">Map</a>`;
-  }
-
-  row.innerHTML = [
-    `<span>${date} ${ts}</span>`,
-    `<span class="sat-col-type ${typeClass}">${typeName}</span>`,
-    `<span>${satellite}</span>`,
-    `<span>${channels}</span>`,
-    `<span>${lines} ${unit}</span>`,
-    `<span>${link}</span>`,
-  ].join("");
-
-  return row;
-}
-
-function renderSatHistoryTable() {
-  if (!satDom.historyList) return;
-  const items = getSatFilteredHistory();
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < items.length; i += 1) {
-    fragment.appendChild(renderSatHistoryRow(items[i]));
-  }
-  satDom.historyList.replaceChildren(fragment);
-
-  if (satDom.historyCount) {
-    const total = satImageHistory.length;
-    const shown = items.length;
-    satDom.historyCount.textContent =
-      total === 0
-        ? "No images yet"
-        : shown === total
-          ? `${total} image${total === 1 ? "" : "s"}`
-          : `${shown} of ${total} images`;
-  }
-}
-
-// ── Add image to history ────────────────────────────────────────────
-function addSatImage(img, decoder) {
-  const tsMs = Number.isFinite(img.ts_ms) ? Number(img.ts_ms) : Date.now();
-  img._tsMs = tsMs;
-  img._ts = new Date(tsMs).toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-  });
-  img._decoder = decoder;
-
-  satImageHistory.unshift(img);
-  if (satImageHistory.length > SAT_MAX_IMAGES) {
-    satImageHistory = satImageHistory.slice(0, SAT_MAX_IMAGES);
-  }
-
-  scheduleSatUi("sat-latest", () => renderSatLatestCard());
-  if (satActiveView === "history") {
-    scheduleSatUi("sat-history", () => renderSatHistoryTable());
-  }
-}
-
-// ── Server callbacks ────────────────────────────────────────────────
-window.onServerLrptProgress = function (msg) {
-  if (satDom.status && msg.mcu_count > 0) {
-    satDom.status.textContent = "Receiving \u2014 " + msg.mcu_count + " MCU rows decoded";
-  }
-};
-
-window.onServerLrptImage = function (msg) {
-  if (satDom.status) satDom.status.textContent = "Image received (Meteor LRPT)";
-  addSatImage(msg, "lrpt");
-  if (msg.geo_bounds && msg.path && window.addSatMapOverlay) {
-    window.addSatMapOverlay(msg);
-  }
-};
-
-window.resetSatHistoryView = function () {
-  satImageHistory = [];
-  if (satDom.historyList) satDom.historyList.innerHTML = "";
-  renderSatLatestCard();
-  renderSatHistoryTable();
-  if (window.clearSatMapOverlays) window.clearSatMapOverlays();
-};
-
-window.pruneSatHistoryView = function () {
-  renderSatHistoryTable();
-  renderSatLatestCard();
-};
-
-// ── Toggle buttons ──────────────────────────────────────────────────
-const lrptDecodeToggleBtn = document.getElementById("lrpt-decode-toggle-btn");
-lrptDecodeToggleBtn?.addEventListener("click", async () => {
-  try {
-    await window.takeSchedulerControlForDecoderDisable?.(lrptDecodeToggleBtn);
-    await postPath("/toggle_lrpt_decode");
-  } catch (e) {
-    console.error("LRPT toggle failed", e);
-  }
-});
-
-// ── Filter / sort event listeners ───────────────────────────────────
-satDom.filterInput?.addEventListener("input", () => {
-  satFilterText = satDom.filterInput.value.trim().toUpperCase();
-  renderSatHistoryTable();
-});
-
-satDom.sortSelect?.addEventListener("change", () => renderSatHistoryTable());
-satDom.typeFilter?.addEventListener("change", () => renderSatHistoryTable());
-
-// ── Settings: clear history ─────────────────────────────────────────
-document
-  .getElementById("settings-clear-sat-history")
-  ?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear satellite history?", message: "All stored satellite decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-    try {
-      await postPath("/clear_lrpt_decode");
-      window.resetSatHistoryView();
-    } catch (e) {
-      console.error("Weather satellite history clear failed", e);
-    }
-  });
-
-// ── Predictions: helpers ────────────────────────────────────────────
-function azToCardinal(deg) {
-  const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
-  return dirs[Math.round(deg / 45) % 8];
-}
-
-function formatPredTime(ms) {
-  const d = new Date(ms);
-  const now = new Date();
-  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-  const day = d.getUTCDay() !== now.getUTCDay() ? dayNames[d.getUTCDay()] + " " : "";
-  const hh = String(d.getUTCHours()).padStart(2, "0");
-  const mm = String(d.getUTCMinutes()).padStart(2, "0");
-  return `${day}${hh}:${mm}`;
-}
-
-function formatPredDuration(s) {
-  if (s >= 60) return `${Math.round(s / 60)} min`;
-  return `${s}s`;
-}
-
-function formatCountdown(ms) {
-  const totalSec = Math.max(0, Math.floor(ms / 1000));
-  const m = Math.floor(totalSec / 60);
-  const s = totalSec % 60;
-  return `${m}:${String(s).padStart(2, "0")}`;
-}
-
-function elevationClass(deg) {
-  if (deg >= 45) return "sat-pred-el-high";
-  if (deg >= 10) return "sat-pred-el-mid";
-  return "sat-pred-el-low";
-}
-
-// ── Predictions: countdown timer management ─────────────────────────
-function stopCountdownTimer() {
-  if (satPredCountdownTimer) {
-    clearInterval(satPredCountdownTimer);
-    satPredCountdownTimer = null;
-  }
-}
-
-function startCountdownTimer(container) {
-  const countdownEls = container ? container.querySelectorAll(".sat-pred-col-countdown") : [];
-  if (countdownEls.length === 0) return;
-
-  satPredCountdownTimer = setInterval(() => {
-    if (satActiveView !== "predictions") {
-      stopCountdownTimer();
-      return;
-    }
-    const n = Date.now();
-    let anyActive = false;
-    for (const el of countdownEls) {
-      const los = parseInt(el.dataset.los, 10);
-      const rem = los - n;
-      if (rem > 0) {
-        el.textContent = formatCountdown(rem);
-        anyActive = true;
-      } else {
-        el.textContent = "0:00";
-      }
-    }
-    if (!anyActive) {
-      stopCountdownTimer();
-      renderSatPredictions(getFilteredPredictions());
-    }
-  }, 1000);
-}
-
-// ── Predictions: row builders ───────────────────────────────────────
-function buildCurrentPassRow(pass, now) {
-  const row = document.createElement("div");
-  row.className = "sat-pred-row-current";
-  const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
-  const remaining = Math.max(0, pass.los_ms - now);
-  row.innerHTML = [
-    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
-    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}\u00B0</span>`,
-    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
-    `<span class="sat-pred-col-time">${formatPredTime(pass.los_ms)}</span>`,
-    `<span class="sat-pred-col-countdown" data-los="${pass.los_ms}">${formatCountdown(remaining)}</span>`,
-    `<span class="sat-pred-col-dir">${dir}</span>`,
-  ].join("");
-  return row;
-}
-
-function buildUpcomingPassRow(pass) {
-  const row = document.createElement("div");
-  row.className = "sat-pred-row";
-  const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
-  row.innerHTML = [
-    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
-    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
-    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}\u00B0</span>`,
-    `<span class="sat-pred-col-dur">${formatPredDuration(pass.duration_s)}</span>`,
-    `<span class="sat-pred-col-dir">${dir}</span>`,
-  ].join("");
-  return row;
-}
-
-// ── Predictions: filter state ───────────────────────────────────────
-function getFilteredPredictions() {
-  let items = satPredData;
-  if (satPredCategory !== "all") items = items.filter((p) => p.category === satPredCategory);
-  if (satPredMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= satPredMinEl);
-  if (satPredFilterText) items = items.filter((p) => p.satellite.toUpperCase().includes(satPredFilterText));
-  return items;
-}
-
-function applyPredFilters() {
-  renderSatPredictions(getFilteredPredictions());
-}
-
-satDom.predFilter?.addEventListener("input", () => {
-  satPredFilterText = satDom.predFilter.value.trim().toUpperCase();
-  applyPredFilters();
-});
-
-satDom.predMinEl?.addEventListener("change", () => {
-  satPredMinEl = parseInt(satDom.predMinEl.value, 10) || 0;
-  applyPredFilters();
-});
-
-satDom.predCategory?.addEventListener("change", () => {
-  satPredCategory = satDom.predCategory.value;
-  applyPredFilters();
-});
-
-// ── Predictions: main render ────────────────────────────────────────
-function renderSatPredictions(passes, error) {
-  stopCountdownTimer();
-
-  if (error) {
-    if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
-    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
-    if (satDom.predCurrentSec)   satDom.predCurrentSec.style.display = "none";
-    if (satDom.predUpcomingSec)  satDom.predUpcomingSec.style.display = "none";
-    if (satDom.predStatus)       satDom.predStatus.textContent = error;
-    return;
-  }
-
-  if (!Array.isArray(passes) || passes.length === 0) {
-    if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
-    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
-    if (satDom.predCurrentSec)   satDom.predCurrentSec.style.display = "none";
-    if (satDom.predUpcomingSec)  satDom.predUpcomingSec.style.display = "none";
-    if (satDom.predStatus)       satDom.predStatus.textContent = "No passes found in the next 24 hours.";
-    return;
-  }
-
-  const now = Date.now();
-  const current = passes.filter((p) => p.aos_ms <= now && p.los_ms > now);
-  const upcoming = passes.filter((p) => p.aos_ms > now);
-
-  // ── Current passes ──
-  if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = current.length > 0 ? "" : "none";
-  if (satDom.predCurrentList) {
-    if (current.length === 0) {
-      satDom.predCurrentList.innerHTML = "";
-    } else {
-      const frag = document.createDocumentFragment();
-      for (const pass of current) frag.appendChild(buildCurrentPassRow(pass, now));
-      satDom.predCurrentList.replaceChildren(frag);
-    }
-  }
-
-  // ── Upcoming passes ──
-  const upcomingLimit = satPredShowAll ? upcoming.length : SAT_PRED_PAGE_SIZE;
-  const visibleUpcoming = upcoming.slice(0, upcomingLimit);
-  const hiddenCount = upcoming.length - visibleUpcoming.length;
-  if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = upcoming.length > 0 ? "" : "none";
-  if (satDom.predUpcomingList) {
-    const frag = document.createDocumentFragment();
-    for (const pass of visibleUpcoming) frag.appendChild(buildUpcomingPassRow(pass));
-    if (hiddenCount > 0) {
-      const moreRow = document.createElement("div");
-      moreRow.className = "sat-pred-row";
-      moreRow.style.cursor = "pointer";
-      moreRow.style.textAlign = "center";
-      moreRow.innerHTML = `<span style="grid-column:1/-1;color:var(--accent);font-size:0.82rem;">Show ${hiddenCount} more passes\u2026</span>`;
-      moreRow.addEventListener("click", () => {
-        satPredShowAll = true;
-        renderSatPredictions(getFilteredPredictions());
-      });
-      frag.appendChild(moreRow);
-    }
-    satDom.predUpcomingList.replaceChildren(frag);
-  }
-
-  // ── Status ──
-  if (satDom.predStatus) {
-    let text = `${current.length} active \u00B7 ${upcoming.length} upcoming \u00B7 times in UTC`;
-    if (satPredSatCount > 0) text += ` \u00B7 ${satPredSatCount} satellites tracked`;
-    satDom.predStatus.textContent = text;
-  }
-
-  // ── Countdown timer ──
-  if (current.length > 0 && satActiveView === "predictions") {
-    startCountdownTimer(satDom.predCurrentList);
-  }
-}
-
-// ── Predictions: data loading ───────────────────────────────────────
-async function loadSatPredictions() {
-  if (satDom.predStatus)       satDom.predStatus.textContent = "Loading predictions\u2026";
-  if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
-  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
-  try {
-    const resp = await fetch("/sat_passes");
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    const data = await resp.json();
-    satPredSatCount = data.satellite_count || 0;
-    if (data.error) {
-      satPredData = [];
-      renderSatPredictions([], data.error);
-    } else {
-      satPredData = data.passes || [];
-      renderSatPredictions(getFilteredPredictions());
-    }
-  } catch (e) {
-    renderSatPredictions([], `Failed to load predictions: ${e.message}`);
-  }
-}
-
-// ── Navigate to map centered on satellite image bounds ──────────────
-window.satShowOnMap = function (south, west, north, east) {
-  if (typeof window.enableMapSourceFilter === "function") {
-    window.enableMapSourceFilter("sat");
-  }
-  const lat = (south + north) / 2;
-  const lon = (west + east) / 2;
-  if (window.navigateToAprsMap) {
-    window.navigateToAprsMap(lat, lon);
-  }
-};
-
-// ── Initial render ──────────────────────────────────────────────────
-renderSatLatestCard();
-renderSatHistoryTable();

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

@@ -1,565 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- Virtual Channels Plugin ---
-//
-// Handles the `session` and `channels` SSE events emitted by /events and
-// provides the channel picker UI (SDR-only, shown when filter_controls is set).
-
-let vchanSessionId = null;
-let vchanRigId = null;
-let vchanChannels = [];
-let vchanActiveId = null;
-let schedulerReleaseState = null;
-let schedulerReleasePollTimer = null;
-
-function vchanFmtFreq(hz) {
-  if (!Number.isFinite(hz) || hz <= 0) return "--";
-  if (hz >= 1e9) return (hz / 1e9).toFixed(4).replace(/\.?0+$/, "") + "\u202fGHz";
-  if (hz >= 1e6) return (hz / 1e6).toFixed(4).replace(/\.?0+$/, "") + "\u202fMHz";
-  if (hz >= 1e3) return (hz / 1e3).toFixed(1).replace(/\.?0+$/, "") + "\u202fkHz";
-  return hz + "\u202fHz";
-}
-
-function schedulerReleaseSummaryText(state) {
-  if (!state) return "Scheduler is controlling the rig.";
-  const connected = Number(state.connected_sessions) || 0;
-  const released = Number(state.released_sessions) || 0;
-  if (connected === 0) return "Scheduler can control the rig.";
-  if (state.all_released) {
-    return connected === 1
-      ? "Scheduler is controlling the rig."
-      : `Scheduler is controlling the rig for all ${connected} users.`;
-  }
-  if (!state.current_session_released) {
-    const othersReleased = Math.max(released, 0);
-    return othersReleased > 0
-      ? `You are holding control. ${othersReleased} other user${othersReleased === 1 ? "" : "s"} already released it.`
-      : "You are holding control. Release it to return control to the scheduler.";
-  }
-  const blocking = Math.max(connected - released, 0);
-  return blocking > 0
-    ? `Scheduler is waiting for ${blocking} user${blocking === 1 ? "" : "s"} to stop manual tuning.`
-    : "Scheduler can control the rig.";
-}
-
-function vchanRenderSchedulerRelease() {
-  const btn = document.getElementById("scheduler-release-btn");
-  const status = document.getElementById("scheduler-release-status");
-  if (!btn || !status) return;
-  const currentReleased = !!(schedulerReleaseState && schedulerReleaseState.current_session_released);
-  btn.disabled = !vchanSessionId || currentReleased;
-  btn.classList.toggle("active", !currentReleased);
-  btn.textContent = "Release to Scheduler";
-  status.textContent = schedulerReleaseSummaryText(schedulerReleaseState);
-}
-
-async function vchanPollSchedulerRelease() {
-  if (!vchanSessionId) {
-    schedulerReleaseState = null;
-    vchanRenderSchedulerRelease();
-    return;
-  }
-  try {
-    const resp = await fetch(`/scheduler-control?session_id=${encodeURIComponent(vchanSessionId)}`);
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    schedulerReleaseState = await resp.json();
-    vchanRenderSchedulerRelease();
-  } catch (e) {
-    console.error("scheduler release status failed", e);
-  }
-}
-
-function vchanStartSchedulerReleasePolling() {
-  if (schedulerReleasePollTimer) {
-    clearInterval(schedulerReleasePollTimer);
-  }
-  schedulerReleasePollTimer = setInterval(vchanPollSchedulerRelease, 10000);
-}
-
-async function vchanToggleSchedulerRelease() {
-  if (!vchanSessionId) return;
-  const rigId = vchanRigId || (typeof lastActiveRigId !== "undefined" ? lastActiveRigId : null);
-  try {
-    const resp = await fetch("/scheduler-control", {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: vchanSessionId, released: true, remote: rigId }),
-    });
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    schedulerReleaseState = await resp.json();
-    vchanRenderSchedulerRelease();
-  } catch (e) {
-    console.error("scheduler release toggle failed", e);
-  }
-}
-
-async function vchanTakeSchedulerControl() {
-  if (!vchanSessionId) return;
-  if (schedulerReleaseState && !schedulerReleaseState.current_session_released) return;
-  try {
-    const resp = await fetch("/scheduler-control", {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: vchanSessionId, released: false }),
-    });
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    schedulerReleaseState = await resp.json();
-    vchanRenderSchedulerRelease();
-  } catch (e) {
-    console.error("scheduler control takeover failed", e);
-  }
-}
-window.vchanTakeSchedulerControl = vchanTakeSchedulerControl;
-
-// Called by app.js when the SSE `session` event arrives.
-function vchanHandleSession(data) {
-  try {
-    const d = JSON.parse(data);
-    vchanSessionId = d.session_id || null;
-    vchanPollSchedulerRelease();
-  } catch (e) {
-    console.warn("vchan: bad session event", e);
-  }
-}
-
-// Called by app.js when the SSE `channels` event arrives.
-function vchanHandleChannels(data) {
-  try {
-    const d = JSON.parse(data);
-    vchanRigId = d.remote || null;
-    vchanChannels = d.channels || [];
-    const ids = new Set(vchanChannels.map(c => c.id));
-    if (!vchanActiveId && vchanChannels.length > 0 && vchanSessionId) {
-      // First channels event for this session — auto-subscribe to channel 0
-      // so we join the same tuned channel as other users on this rig.
-      // Use a direct subscribe (no scheduler control takeover) to avoid
-      // side-effects on initial connect.
-      vchanAutoJoinPrimary(vchanChannels[0].id);
-    } else if (vchanActiveId && !ids.has(vchanActiveId)) {
-      // Active channel was evicted — fall back to channel 0 and reconnect audio.
-      vchanActiveId = vchanChannels.length > 0 ? vchanChannels[0].id : null;
-      vchanReconnectAudio();
-    }
-    vchanRender();
-    vchanRenderSchedulerRelease();
-    if (typeof renderRdsOverlays === "function") renderRdsOverlays();
-  } catch (e) {
-    console.warn("vchan: bad channels event", e);
-  }
-}
-
-function vchanRender() {
-  const picker = document.getElementById("vchan-picker");
-  if (!picker) return;
-  picker.innerHTML = "";
-
-  vchanChannels.forEach(ch => {
-    const btn = document.createElement("button");
-    btn.type = "button";
-    btn.title = `Ch ${ch.index}: ${vchanFmtFreq(ch.freq_hz)} ${ch.mode} · ${ch.subscribers} subscriber${ch.subscribers !== 1 ? "s" : ""}`;
-    if (ch.id === vchanActiveId) btn.classList.add("active");
-
-    const label = document.createElement("span");
-    label.className = "vchan-label";
-    label.textContent = `${ch.index}: ${vchanFmtFreq(ch.freq_hz)} ${ch.mode}`;
-    btn.appendChild(label);
-
-    if (!ch.permanent) {
-      const del = document.createElement("span");
-      del.className = "vchan-del";
-      del.textContent = "\u00d7";
-      del.title = "Delete channel";
-      del.addEventListener("click", e => {
-        e.stopPropagation();
-        vchanDelete(ch.id);
-      });
-      btn.appendChild(del);
-    }
-
-    btn.addEventListener("click", () => {
-      if (ch.id !== vchanActiveId) vchanSubscribe(ch.id);
-    });
-
-    picker.appendChild(btn);
-  });
-
-  // "+" button — allocate a new channel at the current VFO frequency.
-  const addBtn = document.createElement("button");
-  addBtn.type = "button";
-  addBtn.className = "vchan-add";
-  addBtn.textContent = "+";
-  addBtn.title = "Allocate new virtual channel at current frequency";
-  addBtn.addEventListener("click", vchanAllocate);
-  picker.appendChild(addBtn);
-
-  vchanSyncAccentUI();
-  if (typeof updateDocumentTitle === "function" && typeof activeChannelRds === "function") {
-    updateDocumentTitle(activeChannelRds());
-  }
-  vchanRenderSchedulerRelease();
-}
-
-async function vchanAllocate() {
-  if (!vchanSessionId || !vchanRigId) return;
-
-  // Use the last known rig frequency and mode as the starting point.
-  const freqHz = (typeof lastFreqHz === "number" && lastFreqHz > 0)
-    ? lastFreqHz
-    : 0;
-  const modeEl = document.getElementById("mode");
-  const mode = modeEl ? (modeEl.value || "USB") : "USB";
-
-  try {
-    const resp = await fetch(`/channels/${encodeURIComponent(vchanRigId)}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: vchanSessionId, freq_hz: freqHz, mode }),
-    });
-    if (!resp.ok) {
-      const msg = await resp.text().catch(() => String(resp.status));
-      console.warn("vchan: allocate failed —", msg);
-      return;
-    }
-    const ch = await resp.json();
-    vchanActiveId = ch.id;
-    // The SSE `channels` event will trigger vchanRender(); optimistically
-    // mark active so the picker feels responsive even before the event arrives.
-    vchanRender();
-    vchanReconnectAudio();
-  } catch (e) {
-    console.error("vchan: allocate error", e);
-  }
-}
-
-async function vchanDelete(channelId) {
-  if (!vchanRigId) return;
-  try {
-    const resp = await fetch(
-      `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(channelId)}`,
-      { method: "DELETE" }
-    );
-    if (!resp.ok) {
-      console.warn("vchan: delete failed", resp.status);
-    }
-    // Channel list updates via SSE `channels` event.
-  } catch (e) {
-    console.error("vchan: delete error", e);
-  }
-}
-
-// Lightweight auto-join for initial connect: registers the session on
-// channel 0 without taking scheduler control or reconnecting audio
-// (audio isn't started yet at this point).
-async function vchanAutoJoinPrimary(channelId) {
-  if (!vchanSessionId || !vchanRigId) return;
-  try {
-    const resp = await fetch(
-      `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(channelId)}/subscribe`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ session_id: vchanSessionId }),
-      }
-    );
-    if (!resp.ok) {
-      console.warn("vchan: auto-join primary failed", resp.status);
-      return;
-    }
-    vchanActiveId = channelId;
-    vchanRender();
-  } catch (e) {
-    console.error("vchan: auto-join error", e);
-  }
-}
-
-async function vchanSubscribe(channelId) {
-  if (!vchanSessionId || !vchanRigId) return;
-  try {
-    await vchanTakeSchedulerControl();
-    const resp = await fetch(
-      `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(channelId)}/subscribe`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ session_id: vchanSessionId }),
-      }
-    );
-    if (!resp.ok) {
-      console.warn("vchan: subscribe failed", resp.status);
-      return;
-    }
-    vchanActiveId = channelId;
-    vchanRender();
-    vchanSyncModeDisplay();
-    vchanReconnectAudio();
-  } catch (e) {
-    console.error("vchan: subscribe error", e);
-  }
-}
-
-// Reconnect the audio WebSocket to the appropriate endpoint:
-// - virtual channel: /audio?channel_id=<uuid>
-// - primary channel: /audio (no param)
-// Always updates _audioChannelOverride so that starting audio later
-// connects to the correct channel. Only reconnects if RX audio is active.
-function vchanReconnectAudio() {
-  // Always update the override so startRxAudio picks up the right URL,
-  // even when audio isn't currently running.
-  const ch = vchanIsOnVirtual() ? vchanActiveChannel() : null;
-  if (typeof _audioChannelOverride !== "undefined") {
-    _audioChannelOverride = ch ? ch.id : null;
-  }
-  if (typeof rxActive === "undefined" || !rxActive) return;
-  if (typeof stopRxAudio === "function") stopRxAudio();
-  // Delay so the server has time to set up the per-channel encoder.
-  // The server-side audio_ws handler also polls for up to 2 s, so this
-  // just needs to be long enough for the WS upgrade to reach the server.
-  setTimeout(() => {
-    if (typeof startRxAudio === "function") startRxAudio();
-  }, 300);
-}
-
-// Called by app.js from applyCapabilities().
-// Shows the channel picker only for SDR rigs.
-function vchanApplyCapabilities(caps) {
-  const picker = document.getElementById("vchan-picker");
-  if (!picker) return;
-  picker.style.display = (caps && caps.filter_controls) ? "" : "none";
-  vchanRenderSchedulerRelease();
-}
-
-// ---------------------------------------------------------------------------
-// Freq / mode interception + UI accent
-// ---------------------------------------------------------------------------
-
-// Returns true when the active channel is a non-primary (virtual) channel.
-function vchanIsOnVirtual() {
-  if (!vchanActiveId || vchanChannels.length === 0) return false;
-  return vchanActiveId !== vchanChannels[0].id;
-}
-
-function vchanActiveChannel() {
-  return vchanChannels.find(c => c.id === vchanActiveId) || null;
-}
-
-// Update the main freq input to show the virtual channel's frequency.
-function vchanUpdateFreqDisplay() {
-  const ch = vchanActiveChannel();
-  if (!ch) return;
-  const el = document.getElementById("freq");
-  if (!el) return;
-  if (typeof formatFreqForStep === "function" && typeof jogUnit !== "undefined") {
-    el.value = formatFreqForStep(ch.freq_hz, jogUnit);
-  } else {
-    el.value = (ch.freq_hz / 1e6).toFixed(6).replace(/\.?0+$/, "");
-  }
-}
-
-// Sync the mode picker to the active virtual channel's mode.
-// Called whenever the active channel changes or the channel list is refreshed.
-function vchanSyncModeDisplay() {
-  const modeEl = document.getElementById("mode");
-  if (!modeEl) return;
-  if (vchanIsOnVirtual()) {
-    const ch = vchanActiveChannel();
-    if (ch && ch.mode) modeEl.value = ch.mode.toUpperCase();
-  }
-  // When on primary channel, app.js rig-state updates handle the picker.
-  const modeUpper = (modeEl.value || "").toUpperCase();
-  if (typeof lastModeName !== "undefined") {
-    if (modeUpper === "WFM" && lastModeName !== "WFM") {
-      if (typeof setJogDivisor === "function") setJogDivisor(10);
-      if (typeof resetRdsDisplay === "function") resetRdsDisplay();
-    } else if (modeUpper !== "WFM" && lastModeName === "WFM") {
-      if (typeof resetRdsDisplay === "function") resetRdsDisplay();
-    }
-    lastModeName = modeUpper;
-  }
-  if (typeof updateWfmControls === "function") updateWfmControls();
-  if (typeof updateSdrSquelchControlVisibility === "function") {
-    updateSdrSquelchControlVisibility();
-  }
-  if (typeof refreshRdsUi === "function") {
-    refreshRdsUi();
-  } else if (typeof positionRdsPsOverlay === "function") {
-    positionRdsPsOverlay();
-  }
-}
-
-// Sync the BW input to the active virtual channel's bandwidth.
-function vchanSyncBwDisplay() {
-  if (!vchanIsOnVirtual()) return;
-  const ch = vchanActiveChannel();
-  if (!ch) return;
-  const bwEl = document.getElementById("spectrum-bw-input");
-  if (!bwEl) return;
-  // bandwidth_hz == 0 means mode-default; derive it from the channel mode.
-  let bwHz = ch.bandwidth_hz || 0;
-  if (bwHz === 0 && typeof mwDefaultsForMode === "function") {
-    bwHz = mwDefaultsForMode(ch.mode)[0] || 0;
-  }
-  if (bwHz > 0) {
-    bwEl.value = (bwHz / 1000).toFixed(3).replace(/\.?0+$/, "");
-    if (typeof currentBandwidthHz !== "undefined") {
-      currentBandwidthHz = bwHz;
-      window.currentBandwidthHz = bwHz;
-    } else {
-      window.currentBandwidthHz = bwHz;
-    }
-  }
-}
-
-// Add / remove the vchan accent class from the freq and BW inputs.
-function vchanSyncAccentUI() {
-  const onVirtual = vchanIsOnVirtual();
-  const freqEl = document.getElementById("freq");
-  const bwEl   = document.getElementById("spectrum-bw-input");
-  if (freqEl) freqEl.classList.toggle("vchan-ch-active", onVirtual);
-  if (bwEl)   bwEl.classList.toggle("vchan-ch-active", onVirtual);
-  if (onVirtual) {
-    vchanUpdateFreqDisplay();
-    vchanSyncModeDisplay();
-    vchanSyncBwDisplay();
-  } else if (typeof _origRefreshFreqDisplay === "function") {
-    _origRefreshFreqDisplay();
-  }
-  if (typeof updateDocumentTitle === "function" && typeof activeChannelRds === "function") {
-    updateDocumentTitle(activeChannelRds());
-  }
-}
-
-// Saved reference to the original refreshFreqDisplay from app.js.
-let _origRefreshFreqDisplay = null;
-
-function vchanSetChannelFreq(freqHz) {
-  if (!vchanRigId || !vchanActiveId) return;
-  // Validate against current SDR capture window.
-  if (typeof lastSpectrumData !== "undefined" && lastSpectrumData &&
-      lastSpectrumData.sample_rate > 0) {
-    const halfSpan = Number(lastSpectrumData.sample_rate) / 2;
-    const center   = Number(lastSpectrumData.center_hz);
-    if (Math.abs(freqHz - center) > halfSpan) {
-      if (typeof showHint === "function") {
-        showHint(
-          `Out of SDR bandwidth (center ${(center / 1e6).toFixed(3)} MHz ±${(halfSpan / 1e3).toFixed(0)} kHz)`,
-          3000
-        );
-      }
-      return;
-    }
-  }
-  // Fire-and-forget: scheduler control + channel freq PUT run in background.
-  vchanTakeSchedulerControl();
-  fetch(
-    `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(vchanActiveId)}/freq`,
-    {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ freq_hz: Math.round(freqHz) }),
-    }
-  ).catch(e => console.error("vchan: set freq error", e));
-}
-
-async function vchanSetChannelBandwidth(bwHz) {
-  if (!vchanRigId || !vchanActiveId) return;
-  try {
-    await vchanTakeSchedulerControl();
-    const resp = await fetch(
-      `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(vchanActiveId)}/bw`,
-      {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ bandwidth_hz: Math.round(bwHz) }),
-      }
-    );
-    if (!resp.ok) console.warn("vchan: set bw failed", resp.status);
-  } catch (e) {
-    console.error("vchan: set bw error", e);
-  }
-}
-
-async function vchanSetChannelMode(mode) {
-  if (!vchanRigId || !vchanActiveId) return;
-  try {
-    await vchanTakeSchedulerControl();
-    const resp = await fetch(
-      `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(vchanActiveId)}/mode`,
-      {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ mode }),
-      }
-    );
-    if (!resp.ok) console.warn("vchan: set mode failed", resp.status);
-  } catch (e) {
-    console.error("vchan: set mode error", e);
-  }
-}
-
-// Called by app.js (applyModeFromPicker) and bookmarks.js (bmApply) before
-// sending /set_mode to the server.  Returns true if the change was handled
-// by the virtual channel (caller should skip the server request).
-window.vchanInterceptMode = async function(mode) {
-  if (!vchanIsOnVirtual()) return false;
-  await vchanSetChannelMode(mode);
-  return true;
-};
-
-// Called by app.js bandwidth setters before sending /set_bandwidth to the
-// server.  Returns true if the change was handled by the virtual channel.
-window.vchanInterceptBandwidth = async function(bwHz) {
-  if (!vchanIsOnVirtual()) return false;
-  await vchanSetChannelBandwidth(bwHz);
-  return true;
-};
-
-// Wrap setRigFrequency (defined in app.js, loaded before this file) so that
-// frequency changes are redirected to the active virtual channel instead of
-// the server when on a non-primary channel.
-(function() {
-  const _orig = window.setRigFrequency;
-  window.setRigFrequency = function(freqHz) {
-    if (vchanIsOnVirtual()) {
-      // Optimistic local update first, then fire-and-forget channel API.
-      if (typeof applyLocalTunedFrequency === "function") {
-        if (typeof _freqOptimisticSeq !== "undefined") {
-          ++_freqOptimisticSeq;
-          _freqOptimisticHz = Math.round(freqHz);
-        }
-        applyLocalTunedFrequency(Math.round(freqHz));
-      }
-      vchanSetChannelFreq(freqHz);
-      return;
-    }
-    // Scheduler control is fire-and-forget — don't block the freq change.
-    vchanTakeSchedulerControl();
-    if (typeof _orig === "function") _orig(freqHz);
-  };
-})();
-
-(function initSchedulerReleaseControl() {
-  const btn = document.getElementById("scheduler-release-btn");
-  if (btn) {
-    btn.addEventListener("click", () => {
-      vchanToggleSchedulerRelease();
-    });
-  }
-  vchanStartSchedulerReleasePolling();
-  vchanRenderSchedulerRelease();
-})();
-
-// Wrap refreshFreqDisplay so the main freq field stays in sync with the
-// active virtual channel's frequency (SSE rig-state updates would otherwise
-// constantly overwrite it with channel 0's freq).
-(function() {
-  _origRefreshFreqDisplay = window.refreshFreqDisplay;
-  window.refreshFreqDisplay = function() {
-    if (vchanIsOnVirtual()) {
-      vchanUpdateFreqDisplay();
-      return;
-    }
-    if (typeof _origRefreshFreqDisplay === "function") _origRefreshFreqDisplay();
-  };
-})();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/vdes.js

@@ -1,352 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- VDES Decoder Plugin (server-side decode) ---
-const vdesStatus = document.getElementById("vdes-status");
-const vdesMessagesEl = document.getElementById("vdes-messages");
-const vdesFilterInput = document.getElementById("vdes-filter");
-const vdesBarOverlay = document.getElementById("vdes-bar-overlay");
-const vdesChannelSummaryEl = document.getElementById("vdes-channel-summary");
-const vdesFrameCountEl = document.getElementById("vdes-frame-count");
-const vdesLatestSeenEl = document.getElementById("vdes-latest-seen");
-const VDES_BAR_WINDOW_MS = 15 * 60 * 1000;
-let vdesFilterText = "";
-let vdesMessageHistory = [];
-
-function currentVdesHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneVdesMessageHistory() {
-  const cutoffMs = Date.now() - currentVdesHistoryRetentionMs();
-  vdesMessageHistory = vdesMessageHistory.filter((msg) => Number(msg?._tsMs) >= cutoffMs);
-}
-
-function scheduleVdesUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-function scheduleVdesHistoryRender() {
-  scheduleVdesUi("vdes-history", () => renderVdesHistory());
-}
-
-function scheduleVdesBarUpdate() {
-  scheduleVdesUi("vdes-bar", () => updateVdesBar());
-}
-
-function currentVdesCenterText() {
-  const raw = (document.getElementById("freq")?.value || "").replace(/[^\d]/g, "");
-  const hz = raw ? Number(raw) : 0;
-  if (!Number.isFinite(hz) || hz <= 0) return "100 kHz centered on tuned frequency";
-  return `100 kHz @ ${(hz / 1_000_000).toFixed(3)} MHz`;
-}
-
-function vdesAgeText(tsMs) {
-  if (!Number.isFinite(tsMs)) return "just now";
-  const deltaMs = Math.max(0, Date.now() - tsMs);
-  const seconds = Math.round(deltaMs / 1000);
-  if (seconds < 5) return "just now";
-  if (seconds < 60) return `${seconds}s ago`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${minutes}m ago`;
-  const hours = Math.round(minutes / 60);
-  return `${hours}h ago`;
-}
-
-function vdesHexPreview(rawBytes) {
-  if (!Array.isArray(rawBytes) || rawBytes.length === 0) return "--";
-  return rawBytes
-    .slice(0, 20)
-    .map((value) => Number(value).toString(16).padStart(2, "0"))
-    .join(" ")
-    .toUpperCase();
-}
-
-function updateVdesSummary() {
-  pruneVdesMessageHistory();
-  if (vdesChannelSummaryEl) {
-    vdesChannelSummaryEl.textContent = currentVdesCenterText();
-  }
-  if (vdesFrameCountEl) {
-    const count = vdesMessageHistory.length;
-    vdesFrameCountEl.textContent = `${count} burst${count === 1 ? "" : "s"}`;
-  }
-  if (vdesLatestSeenEl) {
-    const latest = vdesMessageHistory[0];
-    vdesLatestSeenEl.textContent = latest ? vdesAgeText(latest._tsMs) : "No traffic yet";
-  }
-}
-
-function applyVdesFilterToRow(row) {
-  if (!vdesFilterText) {
-    row.style.display = "";
-    return;
-  }
-  const text = row.dataset.filterText || "";
-  row.style.display = text.includes(vdesFilterText) ? "" : "none";
-}
-
-function applyVdesFilterToAll() {
-  if (!vdesMessagesEl) return;
-  vdesMessagesEl.querySelectorAll(".vdes-message").forEach((row) => applyVdesFilterToRow(row));
-}
-
-function renderVdesRow(msg) {
-  const row = document.createElement("div");
-  row.className = "vdes-message";
-  const ts = msg._ts || new Date().toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-  });
-  const title = msg.vessel_name || "VDES Burst";
-  const label = msg.callsign || "VDES";
-  const info = msg.destination || "";
-  const labelText = msg.message_label || "";
-  const linkText = Number.isFinite(msg.link_id) ? `LID ${msg.link_id}` : "";
-  const syncText = Number.isFinite(msg.sync_score) ? `Sync ${(Number(msg.sync_score) * 100).toFixed(0)}%` : "";
-  const phaseText = Number.isFinite(msg.phase_rotation) ? `R${Number(msg.phase_rotation)}` : "";
-  const fecText = msg.fec_state || "";
-  const srcText = Number.isFinite(msg.source_id) ? `SRC ${Number(msg.source_id)}` : "";
-  const dstText = Number.isFinite(msg.destination_id) ? `DST ${Number(msg.destination_id)}` : "";
-  const sessionText = Number.isFinite(msg.session_id) ? `S${Number(msg.session_id)}` : "";
-  const asmText = Number.isFinite(msg.asm_identifier) ? `ASM ${Number(msg.asm_identifier)}` : "";
-  const countText = Number.isFinite(msg.data_count) ? `${Number(msg.data_count)} data bits` : "";
-  const ackText = Number.isFinite(msg.ack_nack_mask) ? `ACK 0x${Number(msg.ack_nack_mask).toString(16).toUpperCase().padStart(4, "0")}` : "";
-  const cqiText = Number.isFinite(msg.channel_quality) ? `CQ ${Number(msg.channel_quality)}` : "";
-  const previewText = msg.payload_preview || "";
-  const rawHex = vdesHexPreview(msg.raw_bytes);
-  row.dataset.filterText = [
-    title,
-    label,
-    labelText,
-    info,
-    srcText,
-    dstText,
-    sessionText,
-    asmText,
-    countText,
-    ackText,
-    cqiText,
-    previewText,
-    linkText,
-    syncText,
-    phaseText,
-    fecText,
-    rawHex,
-    msg.message_type,
-    msg.bit_len,
-  ]
-    .filter(Boolean)
-    .join(" ")
-    .toUpperCase();
-  row.innerHTML =
-    `<div class="vdes-row-head">` +
-      `<span class="vdes-time">${ts}</span>` +
-      `<span class="vdes-call">${escapeMapHtml(title)}</span>` +
-      `<span class="vdes-badge">${escapeMapHtml(label)}</span>` +
-      (labelText ? `<span class="vdes-badge">${escapeMapHtml(labelText)}</span>` : "") +
-      (linkText ? `<span class="vdes-badge">${escapeMapHtml(linkText)}</span>` : "") +
-      (srcText ? `<span class="vdes-badge">${escapeMapHtml(srcText)}</span>` : "") +
-      (dstText ? `<span class="vdes-badge">${escapeMapHtml(dstText)}</span>` : "") +
-      (syncText ? `<span class="vdes-badge">${escapeMapHtml(syncText)}</span>` : "") +
-      (phaseText ? `<span class="vdes-badge">${escapeMapHtml(phaseText)}</span>` : "") +
-      `<span class="vdes-badge">T${escapeMapHtml(String(msg.message_type ?? "--"))}</span>` +
-    `</div>` +
-    `<div class="vdes-row-meta">` +
-      `<span>${escapeMapHtml(currentVdesCenterText())}</span>` +
-      `<span>${escapeMapHtml(`${msg.bit_len || 0} bits`)}</span>` +
-      (sessionText ? `<span>${escapeMapHtml(sessionText)}</span>` : "") +
-      (asmText ? `<span>${escapeMapHtml(asmText)}</span>` : "") +
-      (countText ? `<span>${escapeMapHtml(countText)}</span>` : "") +
-      (ackText ? `<span>${escapeMapHtml(ackText)}</span>` : "") +
-      (cqiText ? `<span>${escapeMapHtml(cqiText)}</span>` : "") +
-      (info ? `<span>${escapeMapHtml(info)}</span>` : "") +
-      (fecText ? `<span>${escapeMapHtml(fecText)}</span>` : "") +
-      `<span>${escapeMapHtml(vdesAgeText(msg._tsMs))}</span>` +
-    `</div>` +
-    `<div class="vdes-row-detail">` +
-      (previewText ? `<span>${escapeMapHtml(previewText)}</span>` : "") +
-      (previewText ? `<span>·</span>` : "") +
-      `<span class="vdes-raw">${escapeMapHtml(rawHex)}</span>` +
-    `</div>`;
-  applyVdesFilterToRow(row);
-  return row;
-}
-
-function updateVdesBar() {
-  if (!vdesBarOverlay) return;
-  updateVdesSummary();
-  const isVdes = (document.getElementById("mode")?.value || "").toUpperCase() === "VDES";
-  const cutoffMs = Date.now() - VDES_BAR_WINDOW_MS;
-  const messages = vdesMessageHistory.filter((msg) => msg._tsMs >= cutoffMs).slice(0, 6);
-  if (!isVdes || messages.length === 0) {
-    vdesBarOverlay.style.display = "none";
-    vdesBarOverlay.innerHTML = "";
-    return;
-  }
-
-  let html = '<div class="aprs-bar-header"><span class="aprs-bar-title"><span class="aprs-bar-title-word">VDES</span><span class="aprs-bar-title-word">Live</span></span><span class="aprs-bar-clear-wrap"><span class="aprs-bar-clear" role="button" tabindex="0" onclick="window.clearVdesBar()" onkeydown="if(event.key===\'Enter\'||event.key===\' \'){event.preventDefault();window.clearVdesBar();}" aria-label="Clear VDES overlay">Clear</span></span><span class="aprs-bar-window">Last 15 minutes</span></div>';
-  for (const msg of messages) {
-    const ts = msg._ts ? `<span class="aprs-bar-time">${msg._ts}</span>` : "";
-    const label = escapeMapHtml(msg.callsign || "VDES");
-    const title = escapeMapHtml(msg.vessel_name || "Burst");
-    const detail = [
-      `${msg.bit_len || 0} bits`,
-      msg.message_label ? escapeMapHtml(msg.message_label) : null,
-      Number.isFinite(msg.source_id) ? `src ${Number(msg.source_id)}` : null,
-      Number.isFinite(msg.destination_id) ? `dst ${Number(msg.destination_id)}` : null,
-      Number.isFinite(msg.link_id) ? `LID ${Number(msg.link_id)}` : null,
-      Number.isFinite(msg.asm_identifier) ? `ASM ${Number(msg.asm_identifier)}` : null,
-      Number.isFinite(msg.sync_score) ? `sync ${(Number(msg.sync_score) * 100).toFixed(0)}%` : null,
-      Number.isFinite(msg.phase_rotation) ? `rot ${Number(msg.phase_rotation)}` : null,
-      msg.destination ? escapeMapHtml(msg.destination) : null,
-      escapeMapHtml(vdesAgeText(msg._tsMs)),
-    ]
-      .filter(Boolean)
-      .join(" · ");
-    html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${ts}<span class="vdes-call">${title}</span> <span class="vdes-badge">${label}</span>: ${detail}</div></div>`;
-  }
-  vdesBarOverlay.innerHTML = html;
-  vdesBarOverlay.style.display = "flex";
-}
-window.updateVdesBar = updateVdesBar;
-window.clearVdesBar = function() {
-  window.resetVdesHistoryView();
-};
-
-window.resetVdesHistoryView = function() {
-  if (vdesMessagesEl) vdesMessagesEl.innerHTML = "";
-  vdesMessageHistory = [];
-  updateVdesBar();
-  renderVdesHistory();
-};
-
-function renderVdesHistory() {
-  pruneVdesMessageHistory();
-  if (!vdesMessagesEl) {
-    updateVdesSummary();
-    return;
-  }
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < vdesMessageHistory.length; i += 1) {
-    fragment.appendChild(renderVdesRow(vdesMessageHistory[i]));
-  }
-  vdesMessagesEl.replaceChildren(fragment);
-  updateVdesSummary();
-}
-
-function addVdesMessage(msg) {
-  const tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  msg._tsMs = tsMs;
-  msg._ts = new Date(tsMs).toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-  });
-
-  vdesMessageHistory.unshift(msg);
-  pruneVdesMessageHistory();
-  scheduleVdesBarUpdate();
-  scheduleVdesHistoryRender();
-}
-
-function normalizeServerVdesMessage(msg) {
-  return {
-    rig_id: msg.rig_id || null,
-    message_type: msg.message_type,
-    bit_len: msg.bit_len,
-    raw_bytes: msg.raw_bytes,
-    lat: msg.lat,
-    lon: msg.lon,
-    vessel_name: msg.vessel_name,
-    callsign: msg.callsign,
-    destination: msg.destination,
-    message_label: msg.message_label,
-    session_id: msg.session_id,
-    source_id: msg.source_id,
-    destination_id: msg.destination_id,
-    data_count: msg.data_count,
-    asm_identifier: msg.asm_identifier,
-    ack_nack_mask: msg.ack_nack_mask,
-    channel_quality: msg.channel_quality,
-    payload_preview: msg.payload_preview,
-    link_id: msg.link_id,
-    sync_score: msg.sync_score,
-    sync_errors: msg.sync_errors,
-    phase_rotation: msg.phase_rotation,
-    fec_state: msg.fec_state,
-    ts_ms: msg.ts_ms,
-  };
-}
-
-window.onServerVdesBatch = function(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  if (vdesStatus) vdesStatus.textContent = "Receiving";
-  const normalized = [];
-  for (const msg of messages) {
-    const next = normalizeServerVdesMessage(msg);
-    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
-    next._tsMs = tsMs;
-    next._ts = new Date(tsMs).toLocaleTimeString([], {
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-    });
-    if (next.lat != null && next.lon != null && window.vdesMapAddPoint) {
-      window.vdesMapAddPoint(next);
-    }
-    normalized.push(next);
-  }
-  normalized.reverse();
-  vdesMessageHistory = normalized.concat(vdesMessageHistory);
-  pruneVdesMessageHistory();
-  scheduleVdesBarUpdate();
-  scheduleVdesHistoryRender();
-};
-
-window.restoreVdesHistory = function(messages) {
-  window.onServerVdesBatch(messages);
-};
-
-document.getElementById("settings-clear-vdes-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear VDES history?", message: "All stored VDES decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_vdes_decode");
-    window.resetVdesHistoryView();
-  } catch (e) {
-    console.error("VDES history clear failed", e);
-  }
-});
-
-if (vdesFilterInput) {
-  vdesFilterInput.addEventListener("input", () => {
-    vdesFilterText = vdesFilterInput.value.trim().toUpperCase();
-    renderVdesHistory();
-  });
-}
-
-window.onServerVdes = function(msg) {
-  if (vdesStatus) vdesStatus.textContent = "Receiving";
-  const next = normalizeServerVdesMessage(msg);
-  addVdesMessage(next);
-  if (next.lat != null && next.lon != null && window.vdesMapAddPoint) {
-    window.vdesMapAddPoint(next);
-  }
-};
-
-window.pruneVdesHistoryView = function() {
-  pruneVdesMessageHistory();
-  updateVdesBar();
-  renderVdesHistory();
-};
-
-updateVdesSummary();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("vdes");

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/wefax.js

@@ -1,386 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// ---------------------------------------------------------------------------
-// wefax.js — WEFAX decoder plugin for trx-frontend-http
-// Live view: decoder state, live canvas, latest image card
-// History view: filterable table of all decoded images
-// ---------------------------------------------------------------------------
-
-// ── DOM references (cached once) ───────────────────────────────────
-var wefaxDom = {
-  status:         document.getElementById('wefax-status'),
-  liveView:       document.getElementById('wefax-live-view'),
-  historyView:    document.getElementById('wefax-history-view'),
-  liveContainer:  document.getElementById('wefax-live-container'),
-  liveInfo:       document.getElementById('wefax-live-info'),
-  liveCanvas:     document.getElementById('wefax-live-canvas'),
-  liveLatest:     document.getElementById('wefax-live-latest'),
-  historyList:    document.getElementById('wefax-history-list'),
-  historyCount:   document.getElementById('wefax-history-count'),
-  filterInput:    document.getElementById('wefax-filter'),
-  sortSelect:     document.getElementById('wefax-sort'),
-  toggleBtn:      document.getElementById('wefax-decode-toggle-btn'),
-  clearBtn:       document.getElementById('wefax-clear-btn'),
-  viewLiveBtn:    document.getElementById('wefax-view-live'),
-  viewHistoryBtn: document.getElementById('wefax-view-history'),
-};
-
-// ── State ───────────────────────────────────────────────────────────
-var wefaxImageHistory = [];
-var WEFAX_MAX_IMAGES  = 100;
-var wefaxLiveCtx      = null;
-var wefaxLiveLineCount = 0;
-var wefaxLivePixelsPerLine = 1809;
-var wefaxActiveView   = 'live';
-var wefaxFilterText   = '';
-
-// ── Helpers ─────────────────────────────────────────────────────────
-function currentWefaxHistoryRetentionMs() {
-  return window.getDecodeHistoryRetentionMs ? window.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1000;
-}
-
-function pruneWefaxHistory() {
-  var cutoff = Date.now() - currentWefaxHistoryRetentionMs();
-  wefaxImageHistory = wefaxImageHistory.filter(function (m) { return (m._tsMs || 0) > cutoff; });
-}
-
-function escapeHtml(s) {
-  return String(s)
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
-}
-
-function scheduleWefaxUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === 'function') {
-    window.trxScheduleUiFrameJob(key, job);
-    return;
-  }
-  job();
-}
-
-// ── View switching ──────────────────────────────────────────────────
-function switchWefaxView(view) {
-  wefaxActiveView = view;
-  if (wefaxDom.liveView)    wefaxDom.liveView.style.display = view === 'live' ? '' : 'none';
-  if (wefaxDom.historyView) wefaxDom.historyView.style.display = view === 'history' ? '' : 'none';
-
-  [wefaxDom.viewLiveBtn, wefaxDom.viewHistoryBtn].forEach(function (btn) {
-    if (btn) btn.classList.remove('sat-view-active');
-  });
-  if (view === 'live' && wefaxDom.viewLiveBtn)       wefaxDom.viewLiveBtn.classList.add('sat-view-active');
-  if (view === 'history' && wefaxDom.viewHistoryBtn)  wefaxDom.viewHistoryBtn.classList.add('sat-view-active');
-
-  if (view === 'history') renderWefaxHistoryTable();
-}
-
-if (wefaxDom.viewLiveBtn)    wefaxDom.viewLiveBtn.addEventListener('click', function () { switchWefaxView('live'); });
-if (wefaxDom.viewHistoryBtn) wefaxDom.viewHistoryBtn.addEventListener('click', function () { switchWefaxView('history'); });
-
-// ── Live canvas rendering ───────────────────────────────────────────
-function resetLiveCanvas(pixelsPerLine) {
-  wefaxLivePixelsPerLine = pixelsPerLine;
-  wefaxLiveLineCount = 0;
-  wefaxDom.liveCanvas.width = pixelsPerLine;
-  wefaxDom.liveCanvas.height = 800;
-  wefaxLiveCtx = wefaxDom.liveCanvas.getContext('2d');
-  wefaxLiveCtx.fillStyle = '#000';
-  wefaxLiveCtx.fillRect(0, 0, wefaxDom.liveCanvas.width, wefaxDom.liveCanvas.height);
-  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = '';
-}
-
-function paintLine(lineBytes) {
-  if (!wefaxLiveCtx) return;
-  var y = wefaxLiveLineCount;
-
-  if (y >= wefaxDom.liveCanvas.height) {
-    var old = wefaxLiveCtx.getImageData(0, 0, wefaxDom.liveCanvas.width, wefaxDom.liveCanvas.height);
-    wefaxDom.liveCanvas.height *= 2;
-    wefaxLiveCtx.putImageData(old, 0, 0);
-  }
-
-  var w = wefaxLivePixelsPerLine;
-  var imgData = wefaxLiveCtx.createImageData(w, 1);
-  var d = imgData.data;
-  for (var x = 0; x < w; x++) {
-    var v = x < lineBytes.length ? lineBytes[x] : 0;
-    var i = x * 4;
-    d[i] = v; d[i + 1] = v; d[i + 2] = v; d[i + 3] = 255;
-  }
-  wefaxLiveCtx.putImageData(imgData, 0, y);
-  wefaxLiveLineCount++;
-}
-
-// ── Live view: latest image card ────────────────────────────────────
-function renderWefaxLatestCard() {
-  if (!wefaxDom.liveLatest) return;
-  if (wefaxImageHistory.length === 0) {
-    wefaxDom.liveLatest.innerHTML =
-      '<div style="color:var(--text-muted);font-size:0.82rem;">No images decoded yet. Enable the decoder and tune to a WEFAX station.</div>';
-    return;
-  }
-
-  var img = wefaxImageHistory[0];
-  var ts = img._ts || '--';
-  var date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : '';
-  var meta = [
-    img.ioc + ' IOC',
-    img.lpm + ' LPM',
-    img.line_count + ' lines',
-    date + ' ' + ts,
-  ].join(' \u00b7 ');
-
-  var imgSrc = img._dataUrl
-    ? img._dataUrl
-    : img.path
-      ? '/images/' + escapeHtml(img.path.split('/').pop())
-      : null;
-
-  var html = '<div class="sat-latest-card">';
-  html += '<div class="sat-latest-title">Latest decoded image</div>';
-  html += '<div class="sat-latest-meta">' + escapeHtml(meta) + '</div>';
-  if (imgSrc) {
-    html += '<a href="' + imgSrc + '" target="_blank" style="font-size:0.8rem;color:var(--accent);display:inline-block;margin-top:0.25rem;">View full image</a>';
-  }
-  html += '</div>';
-  wefaxDom.liveLatest.innerHTML = html;
-}
-
-// ── History view: table ─────────────────────────────────────────────
-function getWefaxFilteredHistory() {
-  var items = wefaxImageHistory;
-
-  if (wefaxFilterText) {
-    items = items.filter(function (i) {
-      var haystack = [
-        String(i.ioc || ''),
-        String(i.lpm || ''),
-        String(i.line_count || ''),
-      ].join(' ').toUpperCase();
-      return haystack.indexOf(wefaxFilterText) >= 0;
-    });
-  }
-
-  var sortVal = wefaxDom.sortSelect ? wefaxDom.sortSelect.value : 'newest';
-  if (sortVal === 'oldest') items = items.slice().reverse();
-
-  return items;
-}
-
-function renderWefaxHistoryRow(img) {
-  var row = document.createElement('div');
-  row.className = 'sat-history-row';
-
-  var ts = img._ts || '--';
-  var date = img._tsMs ? new Date(img._tsMs).toLocaleDateString([], { month: 'short', day: 'numeric' }) : '';
-  var ioc = img.ioc || '--';
-  var lpm = img.lpm || '--';
-  var lines = img.line_count || 0;
-
-  var imgSrc = img._dataUrl
-    ? img._dataUrl
-    : img.path
-      ? '/images/' + escapeHtml(img.path.split('/').pop())
-      : null;
-  var link = imgSrc
-    ? '<a href="' + imgSrc + '" target="_blank" style="color:var(--accent);">View</a>'
-    : '--';
-
-  row.innerHTML = [
-    '<span>' + escapeHtml(date + ' ' + ts) + '</span>',
-    '<span>' + escapeHtml(String(ioc)) + '</span>',
-    '<span>' + escapeHtml(String(lpm)) + '</span>',
-    '<span>' + lines + '</span>',
-    '<span>' + link + '</span>',
-  ].join('');
-
-  return row;
-}
-
-function renderWefaxHistoryTable() {
-  if (!wefaxDom.historyList) return;
-  pruneWefaxHistory();
-  var items = getWefaxFilteredHistory();
-  var fragment = document.createDocumentFragment();
-  for (var i = 0; i < items.length; i++) {
-    fragment.appendChild(renderWefaxHistoryRow(items[i]));
-  }
-  wefaxDom.historyList.replaceChildren(fragment);
-
-  if (wefaxDom.historyCount) {
-    var total = wefaxImageHistory.length;
-    var shown = items.length;
-    wefaxDom.historyCount.textContent =
-      total === 0
-        ? 'No images yet'
-        : shown === total
-          ? total + ' image' + (total === 1 ? '' : 's')
-          : shown + ' of ' + total + ' images';
-  }
-}
-
-// ── Add image to history ────────────────────────────────────────────
-function addWefaxImage(msg) {
-  var tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  msg._tsMs = tsMs;
-  msg._ts = new Date(tsMs).toLocaleTimeString([], {
-    hour: '2-digit',
-    minute: '2-digit',
-    second: '2-digit',
-  });
-
-  // Capture the live canvas as a data URI for thumbnails.
-  if (wefaxLiveCtx && wefaxLiveLineCount > 0) {
-    var trimmed = wefaxLiveCtx.getImageData(0, 0, wefaxDom.liveCanvas.width, wefaxLiveLineCount);
-    wefaxDom.liveCanvas.height = wefaxLiveLineCount;
-    wefaxLiveCtx.putImageData(trimmed, 0, 0);
-    try { msg._dataUrl = wefaxDom.liveCanvas.toDataURL('image/png'); } catch (e) {}
-  }
-
-  wefaxImageHistory.unshift(msg);
-  if (wefaxImageHistory.length > WEFAX_MAX_IMAGES) {
-    wefaxImageHistory = wefaxImageHistory.slice(0, WEFAX_MAX_IMAGES);
-  }
-
-  scheduleWefaxUi('wefax-latest', renderWefaxLatestCard);
-  if (wefaxActiveView === 'history') {
-    scheduleWefaxUi('wefax-history', renderWefaxHistoryTable);
-  }
-}
-
-// ── SSE event handlers (public API) ─────────────────────────────────
-window.onServerWefaxProgress = function (msg) {
-  // State-only update (no image data): show decoder state in status.
-  if (msg.state && !msg.line_data) {
-    if (wefaxDom.status) {
-      wefaxDom.status.textContent = msg.state;
-      // Highlight active states, dim idle/scanning.
-      wefaxDom.status.style.color = msg.state.indexOf('Idle') === 0 ? '' : 'var(--text-accent)';
-    }
-    return;
-  }
-
-  if (msg.line_count <= 1 || !wefaxLiveCtx) {
-    resetLiveCanvas(msg.pixels_per_line || 1809);
-  }
-
-  if (msg.line_data) {
-    var binary = atob(msg.line_data);
-    var bytes = new Uint8Array(binary.length);
-    for (var i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    paintLine(bytes);
-  }
-
-  if (wefaxDom.liveInfo) {
-    wefaxDom.liveInfo.textContent =
-      'Line ' + msg.line_count + ' \u00b7 ' + msg.ioc + ' IOC \u00b7 ' + msg.lpm + ' LPM';
-  }
-  if (wefaxDom.status) {
-    wefaxDom.status.textContent = 'Receiving \u2014 line ' + msg.line_count;
-    wefaxDom.status.style.color = 'var(--text-accent)';
-  }
-};
-
-window.onServerWefax = function (msg) {
-  addWefaxImage(msg);
-
-  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = 'none';
-  if (wefaxDom.status) {
-    wefaxDom.status.textContent = 'Complete \u2014 ' + msg.line_count + ' lines';
-    wefaxDom.status.style.color = '';
-  }
-};
-
-window.restoreWefaxHistory = function (messages) {
-  if (!messages || !messages.length) return;
-  for (var i = 0; i < messages.length; i++) {
-    var tsMs = Number.isFinite(messages[i].ts_ms) ? Number(messages[i].ts_ms) : Date.now();
-    messages[i]._tsMs = tsMs;
-    messages[i]._ts = new Date(tsMs).toLocaleTimeString([], {
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-    });
-  }
-  wefaxImageHistory = messages.concat(wefaxImageHistory);
-  pruneWefaxHistory();
-  scheduleWefaxUi('wefax-latest', renderWefaxLatestCard);
-  if (wefaxActiveView === 'history') {
-    scheduleWefaxUi('wefax-history', renderWefaxHistoryTable);
-  }
-};
-
-window.pruneWefaxHistoryView = function () {
-  pruneWefaxHistory();
-  renderWefaxHistoryTable();
-  renderWefaxLatestCard();
-};
-
-window.resetWefaxHistoryView = function () {
-  wefaxImageHistory = [];
-  if (wefaxDom.historyList) wefaxDom.historyList.innerHTML = '';
-  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = 'none';
-  wefaxLiveCtx = null;
-  wefaxLiveLineCount = 0;
-  renderWefaxLatestCard();
-  renderWefaxHistoryTable();
-  if (wefaxDom.status) {
-    wefaxDom.status.textContent = 'Idle';
-    wefaxDom.status.style.color = '';
-  }
-};
-
-// ── Filter / sort handlers ──────────────────────────────────────────
-if (wefaxDom.filterInput) {
-  wefaxDom.filterInput.addEventListener('input', function () {
-    wefaxFilterText = wefaxDom.filterInput.value.trim().toUpperCase();
-    scheduleWefaxUi('wefax-history', renderWefaxHistoryTable);
-  });
-}
-if (wefaxDom.sortSelect) {
-  wefaxDom.sortSelect.addEventListener('change', function () {
-    scheduleWefaxUi('wefax-history', renderWefaxHistoryTable);
-  });
-}
-
-// ── Toggle button sync ──────────────────────────────────────────────
-// Sync the Enable/Disable button from the SSE state update.  This is
-// belt-and-suspenders alongside app.js _decoderToggles — guarantees the
-// WEFAX button always reflects the server state.
-window.syncWefaxToggle = function (enabled) {
-  if (!wefaxDom.toggleBtn) return;
-  wefaxDom.toggleBtn.dataset.enabled = enabled ? 'true' : 'false';
-  wefaxDom.toggleBtn.textContent = enabled ? 'Disable WEFAX' : 'Enable WEFAX';
-  wefaxDom.toggleBtn.style.borderColor = enabled ? '#00d17f' : '';
-  wefaxDom.toggleBtn.style.color = enabled ? '#00d17f' : '';
-};
-
-// ── Button handlers ─────────────────────────────────────────────────
-if (wefaxDom.toggleBtn) {
-  wefaxDom.toggleBtn.addEventListener('click', async function () {
-    try {
-      if (window.takeSchedulerControlForDecoderDisable) {
-        await window.takeSchedulerControlForDecoderDisable(wefaxDom.toggleBtn);
-      }
-      await postPath('/toggle_wefax_decode');
-    } catch (e) {
-      console.error('WEFAX toggle failed', e);
-    }
-  });
-}
-if (wefaxDom.clearBtn) {
-  wefaxDom.clearBtn.addEventListener('click', async function () {
-    try {
-      await postPath('/clear_wefax_decode');
-      window.resetWefaxHistoryView();
-    } catch (e) {
-      console.error('WEFAX clear failed', e);
-    }
-  });
-}
-
-// ── Initial render ──────────────────────────────────────────────────
-renderWefaxLatestCard();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/plugins/wspr.js

@@ -1,292 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// --- WSPR Decoder Plugin (server-side decode) ---
-const wsprStatus = document.getElementById("wspr-status");
-const wsprPeriodEl = document.getElementById("wspr-period");
-const wsprMessagesEl = document.getElementById("wspr-messages");
-const wsprFilterInput = document.getElementById("wspr-filter");
-const WSPR_PERIOD_SECONDS = 120;
-let wsprFilterText = "";
-let wsprMessageHistory = [];
-
-function currentWsprHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
-}
-
-function pruneWsprMessageHistory() {
-  const cutoffMs = Date.now() - currentWsprHistoryRetentionMs();
-  wsprMessageHistory = wsprMessageHistory.filter((msg) => Number(msg?._tsMs ?? msg?.ts_ms) >= cutoffMs);
-}
-
-function scheduleWsprHistoryRender() {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob("wspr-history", () => renderWsprHistory());
-    return;
-  }
-  renderWsprHistory();
-}
-
-function fmtWsprTime(tsMs) {
-  if (!tsMs) return "--:--:--";
-  return new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-}
-
-function updateWsprPeriodTimer() {
-  if (!wsprPeriodEl) return;
-  const nowSec = Math.floor(Date.now() / 1000);
-  const remaining = WSPR_PERIOD_SECONDS - (nowSec % WSPR_PERIOD_SECONDS);
-  const mm = String(Math.floor(remaining / 60)).padStart(2, "0");
-  const ss = String(remaining % 60).padStart(2, "0");
-  wsprPeriodEl.textContent = `Next slot ${mm}:${ss}`;
-}
-
-updateWsprPeriodTimer();
-setInterval(updateWsprPeriodTimer, 500);
-
-function renderWsprRow(msg) {
-  const row = document.createElement("div");
-  row.className = "ft8-row";
-  row.dataset.decoder = "wspr";
-  const snr = Number.isFinite(msg.snr_db) ? msg.snr_db.toFixed(1) : "--";
-  const dt = Number.isFinite(msg.dt_s) ? msg.dt_s.toFixed(2) : "--";
-  const baseHz = Number.isFinite(window.ft8BaseHz) ? window.ft8BaseHz : null;
-  const rfHz = Number.isFinite(msg.freq_hz) && Number.isFinite(baseHz) ? (baseHz + msg.freq_hz) : null;
-  const freq = Number.isFinite(rfHz) ? rfHz.toFixed(0) : "--";
-  const message = (msg.message || "").toString();
-  row.dataset.message = message.toUpperCase();
-  row.innerHTML = `<span class="ft8-time">${fmtWsprTime(msg.ts_ms)}</span><span class="ft8-snr">${snr}</span><span class="ft8-dt">${dt}</span><span class="ft8-freq">${freq}</span><span class="ft8-msg">${renderWsprMessage(message)}</span>`;
-  applyWsprFilterToRow(row);
-  return row;
-}
-
-function renderWsprHistory() {
-  pruneWsprMessageHistory();
-  if (!wsprMessagesEl) return;
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < wsprMessageHistory.length; i += 1) {
-    fragment.appendChild(renderWsprRow(wsprMessageHistory[i]));
-  }
-  wsprMessagesEl.replaceChildren(fragment);
-}
-
-function addWsprMessage(msg) {
-  msg._tsMs = Number.isFinite(msg?.ts_ms) ? Number(msg.ts_ms) : Date.now();
-  wsprMessageHistory.unshift(msg);
-  pruneWsprMessageHistory();
-  scheduleWsprHistoryRender();
-}
-
-function normalizeServerWsprMessage(msg) {
-  const raw = (msg.message || "").toString();
-  const grids = extractAllGrids(raw);
-  const station = extractLikelyCallsign(raw);
-  const baseHz = Number.isFinite(window.ft8BaseHz) ? Number(window.ft8BaseHz) : null;
-  const rfHz = Number.isFinite(msg.freq_hz) && Number.isFinite(baseHz)
-    ? (baseHz + Number(msg.freq_hz))
-    : (Number.isFinite(msg.freq_hz) ? Number(msg.freq_hz) : null);
-  return {
-    raw,
-    grids,
-    station,
-    rfHz,
-    history: {
-      receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
-      ts_ms: msg.ts_ms,
-      snr_db: msg.snr_db,
-      dt_s: msg.dt_s,
-      freq_hz: msg.freq_hz,
-      message: raw,
-    },
-  };
-}
-
-window.onServerWsprBatch = function(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  wsprStatus.textContent = "Receiving";
-  const normalized = [];
-  for (const msg of messages) {
-    const next = normalizeServerWsprMessage(msg);
-    if (next.grids.length > 0 && window.mapAddLocator) {
-      window.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
-        ...msg,
-        freq_hz: next.rfHz,
-      });
-    }
-    next.history._tsMs = Number.isFinite(next.history?.ts_ms) ? Number(next.history.ts_ms) : Date.now();
-    normalized.push(next.history);
-  }
-  normalized.reverse();
-  wsprMessageHistory = normalized.concat(wsprMessageHistory);
-  pruneWsprMessageHistory();
-  scheduleWsprHistoryRender();
-};
-
-window.restoreWsprHistory = function(messages) {
-  window.onServerWsprBatch(messages);
-};
-
-window.pruneWsprHistoryView = function() {
-  pruneWsprMessageHistory();
-  renderWsprHistory();
-};
-
-function escapeWsprHtml(input) {
-  return input
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll("\"", "&quot;");
-}
-
-function renderWsprMessage(message) {
-  let out = "";
-  let i = 0;
-  while (i < message.length) {
-    const ch = message[i];
-    if (isAlphaNum(ch)) {
-      let j = i + 1;
-      while (j < message.length && isAlphaNum(message[j])) j++;
-      const token = message.slice(i, j);
-      const grid = token.toUpperCase();
-      if (isMaidenheadGridToken(grid)) {
-        out += `<span class="ft8-locator" data-locator-grid="${grid}" role="button" tabindex="0" aria-label="Show locator ${grid} on map">${grid}</span>`;
-      } else {
-        out += escapeWsprHtml(token);
-      }
-      i = j;
-    } else {
-      out += escapeWsprHtml(ch);
-      i += 1;
-    }
-  }
-  return out;
-}
-
-function extractAllGrids(message) {
-  const out = [];
-  const seen = new Set();
-  const parts = message.toUpperCase().split(/[^A-Z0-9]+/);
-  for (const token of parts) {
-    if (!token) continue;
-    if (isMaidenheadGridToken(token) && !seen.has(token)) {
-      seen.add(token);
-      out.push(token);
-    }
-  }
-  return out;
-}
-
-function extractLikelyCallsign(message) {
-  const parts = String(message || "").toUpperCase().split(/[^A-Z0-9/]+/);
-  for (const token of parts) {
-    if (!token) continue;
-    if (token.length < 3 || token.length > 12) continue;
-    if (token === "CQ" || token === "DE" || token === "QRZ" || token === "DX") continue;
-    if (isMaidenheadGridToken(token)) continue;
-    if (/^[A-Z0-9/]{1,5}\d[A-Z0-9/]{1,6}$/.test(token)) return token;
-  }
-  return null;
-}
-
-function isFtxFarewellToken(token) {
-  const normalized = String(token || "").trim().toUpperCase();
-  return normalized === "RR73" || normalized === "73" || normalized === "RR";
-}
-
-function isMaidenheadGridToken(token) {
-  const normalized = String(token || "").trim().toUpperCase();
-  return /^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalized) && !isFtxFarewellToken(normalized);
-}
-
-function isAlphaNum(ch) {
-  return /[A-Za-z0-9]/.test(ch);
-}
-
-function activateWsprHistoryLocator(targetEl) {
-  const locatorEl = targetEl?.closest?.(".ft8-locator[data-locator-grid]");
-  if (!locatorEl) return false;
-  const grid = String(locatorEl.dataset.locatorGrid || "").toUpperCase();
-  if (!grid) return false;
-  if (typeof window.navigateToMapLocator === "function") {
-    window.navigateToMapLocator(grid, "wspr");
-  }
-  return true;
-}
-
-function applyWsprFilterToRow(row) {
-  if (!wsprFilterText) {
-    row.style.display = "";
-    return;
-  }
-  const message = row.dataset.message || "";
-  row.style.display = message.includes(wsprFilterText) ? "" : "none";
-}
-
-function applyWsprFilterToAll() {
-  const rows = wsprMessagesEl.querySelectorAll(".ft8-row");
-  rows.forEach((row) => applyWsprFilterToRow(row));
-}
-
-window.resetWsprHistoryView = function() {
-  wsprMessagesEl.innerHTML = "";
-  wsprMessageHistory = [];
-  renderWsprHistory();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("wspr");
-};
-
-if (wsprFilterInput) {
-  wsprFilterInput.addEventListener("input", () => {
-    wsprFilterText = wsprFilterInput.value.trim().toUpperCase();
-    renderWsprHistory();
-  });
-}
-
-if (wsprMessagesEl) {
-  wsprMessagesEl.addEventListener("click", (event) => {
-    if (!activateWsprHistoryLocator(event.target)) return;
-    event.preventDefault();
-    event.stopPropagation();
-  });
-  wsprMessagesEl.addEventListener("keydown", (event) => {
-    if (event.key !== "Enter" && event.key !== " ") return;
-    if (!activateWsprHistoryLocator(event.target)) return;
-    event.preventDefault();
-    event.stopPropagation();
-  });
-}
-
-const wsprDecodeToggleBtn = document.getElementById("wspr-decode-toggle-btn");
-wsprDecodeToggleBtn?.addEventListener("click", async () => {
-  try {
-    await window.takeSchedulerControlForDecoderDisable?.(wsprDecodeToggleBtn);
-    await postPath("/toggle_wspr_decode");
-  } catch (e) {
-    console.error("WSPR toggle failed", e);
-  }
-});
-
-document.getElementById("settings-clear-wspr-history")?.addEventListener("click", async () => {
-  if (!await window.trxUi.confirm({ title: "Clear WSPR history?", message: "All stored WSPR decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
-  try {
-    await postPath("/clear_wspr_decode");
-    window.resetWsprHistoryView();
-  } catch (e) {
-    console.error("WSPR history clear failed", e);
-  }
-});
-
-window.onServerWspr = function(msg) {
-  wsprStatus.textContent = "Receiving";
-  const next = normalizeServerWsprMessage(msg);
-  if (next.grids.length > 0 && window.mapAddLocator) {
-    window.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
-      ...msg,
-      freq_hz: next.rfHz,
-    });
-  }
-  addWsprMessage(next.history);
-};

src/trx-client/trx-frontend/trx-frontend-http/assets/web/screenshot.js

@@ -1,265 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// Spectrum screenshot module (loaded on demand when user triggers screenshot).
-// Communicates with app.js core via window.trx namespace.
-(function () {
-  "use strict";
-  const T = window.trx;
-
-  function isVisibleForSnapshot(el) {
-    if (!el) return false;
-    const style = getComputedStyle(el);
-    if (style.display === "none" || style.visibility === "hidden") return false;
-    const opacity = Number(style.opacity);
-    if (Number.isFinite(opacity) && opacity <= 0) return false;
-    const rect = el.getBoundingClientRect();
-    return rect.width > 0 && rect.height > 0;
-  }
-
-  function drawRoundedRectPath(ctx, x, y, w, h, r) {
-    const radius = Math.max(0, Math.min(r, Math.min(w, h) / 2));
-    ctx.beginPath();
-    ctx.moveTo(x + radius, y);
-    ctx.lineTo(x + w - radius, y);
-    ctx.quadraticCurveTo(x + w, y, x + w, y + radius);
-    ctx.lineTo(x + w, y + h - radius);
-    ctx.quadraticCurveTo(x + w, y + h, x + w - radius, y + h);
-    ctx.lineTo(x + radius, y + h);
-    ctx.quadraticCurveTo(x, y + h, x, y + h - radius);
-    ctx.lineTo(x, y + radius);
-    ctx.quadraticCurveTo(x, y, x + radius, y);
-    ctx.closePath();
-  }
-
-  function drawElementChrome(ctx, el, rootRect, maxAlpha = 1) {
-    if (!isVisibleForSnapshot(el)) return null;
-    const rect = el.getBoundingClientRect();
-    const style = getComputedStyle(el);
-    const x = rect.left - rootRect.left;
-    const y = rect.top - rootRect.top;
-    const w = rect.width;
-    const h = rect.height;
-    const radius = parseFloat(style.borderTopLeftRadius) || 0;
-    const bg = T.cssColorToRgba(style.backgroundColor || "rgba(0,0,0,0)");
-    const borderWidth = Math.max(0, parseFloat(style.borderTopWidth) || 0);
-    const border = T.cssColorToRgba(style.borderTopColor || "rgba(0,0,0,0)");
-
-    const bgAlpha = Math.min(bg[3], maxAlpha);
-    if (bgAlpha > 0.01) {
-      drawRoundedRectPath(ctx, x, y, w, h, radius);
-      ctx.fillStyle = `rgba(${Math.round(bg[0])}, ${Math.round(bg[1])}, ${Math.round(bg[2])}, ${bgAlpha})`;
-      ctx.fill();
-    }
-    const borderAlpha = Math.min(border[3], maxAlpha);
-    if (borderWidth > 0 && borderAlpha > 0.01) {
-      drawRoundedRectPath(ctx, x + borderWidth * 0.5, y + borderWidth * 0.5, w - borderWidth, h - borderWidth, Math.max(0, radius - borderWidth * 0.5));
-      ctx.lineWidth = borderWidth;
-      ctx.strokeStyle = `rgba(${Math.round(border[0])}, ${Math.round(border[1])}, ${Math.round(border[2])}, ${borderAlpha})`;
-      ctx.stroke();
-    }
-    return { x, y, w, h, style };
-  }
-
-  function drawWrappedText(ctx, text, x, y, maxWidth, lineHeight, maxLines) {
-    const words = String(text || "").split(/\s+/).filter(Boolean);
-    if (!words.length) return;
-    let line = "";
-    let lineIdx = 0;
-    for (let i = 0; i < words.length; i += 1) {
-      const candidate = line ? `${line} ${words[i]}` : words[i];
-      if (ctx.measureText(candidate).width <= maxWidth || !line) {
-        line = candidate;
-        continue;
-      }
-      ctx.fillText(line, x, y + lineIdx * lineHeight);
-      lineIdx += 1;
-      if (lineIdx >= maxLines) return;
-      line = words[i];
-    }
-    if (line && lineIdx < maxLines) {
-      ctx.fillText(line, x, y + lineIdx * lineHeight);
-    }
-  }
-
-  function drawElementTextBlock(ctx, el, rootRect, fallbackText = null, maxAlpha = 1) {
-    const chrome = drawElementChrome(ctx, el, rootRect, maxAlpha);
-    if (!chrome) return;
-    const text = (fallbackText == null ? el.innerText : fallbackText) || "";
-    const clean = text.replace(/\s+\n/g, "\n").replace(/\n\s+/g, "\n").trim();
-    if (!clean) return;
-    const style = chrome.style;
-    const fontSize = parseFloat(style.fontSize) || 12;
-    const lineHeight = (parseFloat(style.lineHeight) || fontSize * 1.25);
-    const padX = 6;
-    const padY = 4;
-    const maxWidth = Math.max(20, chrome.w - padX * 2);
-    const maxLines = Math.max(1, Math.floor((chrome.h - padY * 2) / lineHeight));
-    ctx.fillStyle = style.color || "#ffffff";
-    ctx.font = `${style.fontStyle || "normal"} ${style.fontWeight || "400"} ${style.fontSize || "12px"} ${style.fontFamily || "sans-serif"}`;
-    ctx.textBaseline = "top";
-    const lines = clean.split(/\n+/);
-    let lineCursor = 0;
-    for (const line of lines) {
-      if (lineCursor >= maxLines) break;
-      drawWrappedText(
-        ctx,
-        line,
-        chrome.x + padX,
-        chrome.y + padY + lineCursor * lineHeight,
-        maxWidth,
-        lineHeight,
-        maxLines - lineCursor,
-      );
-      lineCursor += 1;
-    }
-  }
-
-  function drawAxisLabels(ctx, axisEl, rootRect) {
-    if (!isVisibleForSnapshot(axisEl)) return;
-    for (const node of axisEl.children) {
-      if (!(node instanceof HTMLElement)) continue;
-      if (!(node.matches("span") || node.matches("button"))) continue;
-      if (!isVisibleForSnapshot(node)) continue;
-      const chrome = drawElementChrome(ctx, node, rootRect);
-      const text = (node.textContent || "").trim();
-      if (!chrome || !text) continue;
-      const style = chrome.style;
-      ctx.fillStyle = style.color || "#ffffff";
-      ctx.font = `${style.fontStyle || "normal"} ${style.fontWeight || "400"} ${style.fontSize || "12px"} ${style.fontFamily || "sans-serif"}`;
-      ctx.textBaseline = "middle";
-      ctx.fillText(text, chrome.x + 4, chrome.y + chrome.h / 2);
-    }
-  }
-
-  function buildSpectrumSnapshotCanvas() {
-    const rootEl = document.querySelector(".signal-visual-block");
-    const spectrumPanelEl = document.getElementById("spectrum-panel");
-    if (!rootEl || !isVisibleForSnapshot(rootEl) || !isVisibleForSnapshot(spectrumPanelEl)) {
-      return null;
-    }
-    for (const renderer of [T.overviewGl, T.spectrumGl, T.signalOverlayGl]) {
-      const gl = renderer?.gl;
-      if (!gl) continue;
-      try {
-        if (typeof gl.flush === "function") gl.flush();
-        if (typeof gl.finish === "function") gl.finish();
-      } catch (_) {
-        // Ignore transient WebGL state errors and capture the last good frame.
-      }
-    }
-    const rootRect = rootEl.getBoundingClientRect();
-    const dpr = window.devicePixelRatio || 1;
-    const out = document.createElement("canvas");
-    out.width = Math.max(1, Math.round(rootRect.width * dpr));
-    out.height = Math.max(1, Math.round(rootRect.height * dpr));
-    const ctx = out.getContext("2d");
-    if (!ctx) return null;
-    ctx.scale(dpr, dpr);
-
-    const bg = getComputedStyle(document.documentElement).getPropertyValue("--bg").trim() || getComputedStyle(document.body).backgroundColor || "#000";
-    ctx.fillStyle = bg;
-    ctx.fillRect(0, 0, rootRect.width, rootRect.height);
-
-    const signalOverlayCanvas = document.getElementById("signal-overlay-canvas");
-    const canvases = [T.overviewCanvas, T.spectrumCanvas, signalOverlayCanvas];
-    for (const canvas of canvases) {
-      if (!canvas || !isVisibleForSnapshot(canvas)) continue;
-      const rect = canvas.getBoundingClientRect();
-      ctx.drawImage(
-        canvas,
-        rect.left - rootRect.left,
-        rect.top - rootRect.top,
-        rect.width,
-        rect.height,
-      );
-    }
-
-    // Decoder overlays over the signal view.
-    // Cap background alpha to avoid opaque blocks (backdrop-filter can't be
-    // replicated on canvas, so frosted-glass overlays would otherwise obscure
-    // the spectrum).
-    const decoderOverlayIds = [
-      "ais-bar-overlay",
-      "vdes-bar-overlay",
-      "ft8-bar-overlay",
-      "aprs-bar-overlay",
-      "rds-ps-overlay",
-    ];
-    for (const id of decoderOverlayIds) {
-      const overlayEl = document.getElementById(id);
-      if (!overlayEl || !isVisibleForSnapshot(overlayEl)) continue;
-      drawElementTextBlock(ctx, overlayEl, rootRect, null, 0.35);
-    }
-
-    // Spectrum axis labels and bookmark chips (includes freq bar).
-    const spectrumFreqAxis = document.getElementById("spectrum-freq-axis");
-    const spectrumDbAxis = document.getElementById("spectrum-db-axis");
-    drawAxisLabels(ctx, spectrumFreqAxis, rootRect);
-    drawAxisLabels(ctx, spectrumDbAxis, rootRect);
-    drawAxisLabels(ctx, document.getElementById("spectrum-bookmark-axis"), rootRect);
-    drawAxisLabels(ctx, document.getElementById("spectrum-bookmark-side-left"), rootRect);
-    drawAxisLabels(ctx, document.getElementById("spectrum-bookmark-side-right"), rootRect);
-
-    return out;
-  }
-
-  function clickCanvasDownload(href, fileName) {
-    const a = document.createElement("a");
-    a.href = href;
-    a.download = fileName;
-    a.rel = "noopener";
-    a.style.display = "none";
-    document.body.appendChild(a);
-    a.click();
-    requestAnimationFrame(() => a.remove());
-  }
-
-  function saveCanvasAsPng(canvas, fileName) {
-    if (!canvas) return Promise.resolve(false);
-    if (typeof canvas.toBlob === "function") {
-      return new Promise((resolve) => {
-        try {
-          canvas.toBlob((blob) => {
-            if (!blob) {
-              resolve(false);
-              return;
-            }
-            const url = URL.createObjectURL(blob);
-            clickCanvasDownload(url, fileName);
-            setTimeout(() => URL.revokeObjectURL(url), 1000);
-            resolve(true);
-          }, "image/png");
-        } catch (_) {
-          resolve(false);
-        }
-      });
-    }
-    try {
-      clickCanvasDownload(canvas.toDataURL("image/png"), fileName);
-      return Promise.resolve(true);
-    } catch (_) {
-      return Promise.resolve(false);
-    }
-  }
-
-  async function captureSpectrumScreenshot() {
-    const snapshotCanvas = buildSpectrumSnapshotCanvas();
-    if (!snapshotCanvas) {
-      T.showHint("Spectrum view not ready", 1300);
-      return false;
-    }
-    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const saved = await saveCanvasAsPng(snapshotCanvas, `trx-spectrum-${stamp}.png`);
-    T.showHint(saved ? "Spectrum screenshot saved" : "Spectrum screenshot failed", saved ? 1500 : 1800);
-    return saved;
-  }
-
-  // Register module API
-  window.trx.modules.screenshot = {
-    captureSpectrumScreenshot,
-    buildSpectrumSnapshotCanvas,
-    saveCanvasAsPng,
-  };
-})();

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

@@ -1,355 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-"use strict";
-
-// Shared UI primitives. Keeping these outside app.js prevents navigation,
-// feedback, dialogs, and layout preferences from growing separate state models.
-(function initUiCore() {
-  const api = window.trxUi = window.trxUi || {};
-
-  function ensureLiveRegions() {
-    if (!document.getElementById("toast-region")) {
-      const region = document.createElement("div");
-      region.id = "toast-region";
-      region.className = "toast-region";
-      region.setAttribute("aria-live", "polite");
-      region.setAttribute("aria-atomic", "false");
-      document.body.appendChild(region);
-    }
-    if (!document.getElementById("ui-confirm-dialog")) {
-      const dialog = document.createElement("dialog");
-      dialog.id = "ui-confirm-dialog";
-      dialog.className = "ui-dialog";
-      dialog.innerHTML = `
-        <form method="dialog" class="ui-dialog-card">
-          <h2 id="ui-confirm-title">Confirm action</h2>
-          <p id="ui-confirm-message"></p>
-          <div class="ui-dialog-actions">
-            <button value="cancel" type="submit">Cancel</button>
-            <button value="confirm" type="submit" class="danger">Confirm</button>
-          </div>
-        </form>`;
-      document.body.appendChild(dialog);
-    }
-  }
-
-  api.notify = function notify(message, options = {}) {
-    ensureLiveRegions();
-    const { kind = "info", duration = kind === "error" ? 7000 : 3200, action = null } = options;
-    const toast = document.createElement("div");
-    toast.className = `toast toast-${kind}`;
-    toast.setAttribute("role", kind === "error" ? "alert" : "status");
-    const text = document.createElement("span");
-    text.textContent = message;
-    toast.appendChild(text);
-    if (action && typeof action.run === "function") {
-      const button = document.createElement("button");
-      button.type = "button";
-      button.textContent = action.label || "Retry";
-      button.addEventListener("click", () => { action.run(); toast.remove(); });
-      toast.appendChild(button);
-    }
-    document.getElementById("toast-region").appendChild(toast);
-    requestAnimationFrame(() => toast.classList.add("toast-visible"));
-    if (duration > 0) setTimeout(() => toast.remove(), duration);
-    return toast;
-  };
-
-  api.confirm = function confirmAction(options = {}) {
-    ensureLiveRegions();
-    const dialog = document.getElementById("ui-confirm-dialog");
-    document.getElementById("ui-confirm-title").textContent = options.title || "Confirm action";
-    document.getElementById("ui-confirm-message").textContent = options.message || "Continue?";
-    const confirmButton = dialog.querySelector('[value="confirm"]');
-    confirmButton.textContent = options.confirmLabel || "Confirm";
-    confirmButton.classList.toggle("danger", options.danger !== false);
-    return new Promise((resolve) => {
-      const finish = () => resolve(dialog.returnValue === "confirm");
-      dialog.addEventListener("close", finish, { once: true });
-      dialog.showModal();
-    });
-  };
-
-  api.setButtonState = function setButtonState(button, options = {}) {
-    if (!button) return;
-    const { active = false, activeLabel, inactiveLabel, busy = false, disabled = false } = options;
-    button.classList.toggle("is-active", active);
-    button.classList.toggle("is-busy", busy);
-    button.setAttribute("aria-pressed", String(active));
-    button.setAttribute("aria-busy", String(busy));
-    button.disabled = disabled || busy;
-    const label = active ? activeLabel : inactiveLabel;
-    if (label) button.textContent = label;
-  };
-
-  api.prepareTabList = function prepareTabList(bar, kind = "primary") {
-    if (!bar) return;
-    if (bar._accessibleTabsPrepared) return;
-    bar._accessibleTabsPrepared = true;
-    const selector = kind === "primary" ? ".tab[data-tab]" : ".sub-tab[data-subtab]";
-    const buttons = Array.from(bar.querySelectorAll(selector));
-    bar.setAttribute("role", "tablist");
-    buttons.forEach((button, index) => {
-      button.setAttribute("role", "tab");
-      button.setAttribute("aria-selected", String(button.classList.contains("active")));
-      button.tabIndex = button.classList.contains("active") || (!buttons.some(b => b.classList.contains("active")) && index === 0) ? 0 : -1;
-      const key = button.dataset.tab || button.dataset.subtab;
-      button.setAttribute("aria-controls", `${kind === "primary" ? "tab-" : "subtab-"}${key}`);
-      const panel = document.getElementById(`${kind === "primary" ? "tab-" : "subtab-"}${key}`);
-      if (panel) {
-        if (!button.id) button.id = `${kind}-tab-${key}`;
-        panel.setAttribute("role", "tabpanel");
-        panel.setAttribute("aria-labelledby", button.id);
-      }
-    });
-    bar.addEventListener("keydown", (event) => {
-      if (!buttons.includes(event.target)) return;
-      const direction = event.key === "ArrowRight" || event.key === "ArrowDown" ? 1
-        : event.key === "ArrowLeft" || event.key === "ArrowUp" ? -1 : 0;
-      if (!direction) return;
-      event.preventDefault();
-      const next = buttons[(buttons.indexOf(event.target) + direction + buttons.length) % buttons.length];
-      next.focus();
-      next.click();
-    });
-  };
-
-  api.syncSelectedTab = function syncSelectedTab(bar, selected) {
-    if (!bar) return;
-    bar.querySelectorAll('[role="tab"]').forEach((tab) => {
-      const active = tab === selected;
-      tab.setAttribute("aria-selected", String(active));
-      tab.tabIndex = active ? 0 : -1;
-    });
-  };
-
-  const layouts = {
-    compact: { label: "Compact", advanced: false, audio: false, scheduler: false, preferredTab: "main" },
-    broadcast: { label: "Broadcast", unavailable: "Broadcast requires an enumerated WFM-capable receiver", advanced: false, audio: true, scheduler: false, preferredTab: "main", capability: "broadcast" },
-    digital: { label: "Digital", unavailable: "Digital requires a compatible rig mode and an available decoder", advanced: false, audio: false, scheduler: false, preferredTab: "digital-modes", capability: "digital" },
-    full: { label: "Full controls", advanced: true, audio: true, scheduler: true, preferredTab: "main" },
-  };
-  const layoutCapabilities = { broadcast: false, digital: false };
-  let activeRigId = null;
-
-  function layoutStorageKey() {
-    return activeRigId ? `trxOperatorLayout:${activeRigId}` : "trxOperatorLayout";
-  }
-
-  function savedLayoutName() {
-    return localStorage.getItem(layoutStorageKey()) || localStorage.getItem("trxOperatorLayout") || "compact";
-  }
-
-  function layoutAvailable(layout) {
-    return !layout.capability || layoutCapabilities[layout.capability] === true;
-  }
-
-  function unavailableLayoutMessage() {
-    const unavailable = Object.values(layouts).filter(layout => !layoutAvailable(layout) && layout.unavailable);
-    return unavailable.length ? `Unavailable: ${unavailable.map(layout => layout.unavailable).join("; ")}.` : "";
-  }
-
-  function refreshLayoutOptions() {
-    const select = document.getElementById("operator-layout-select");
-    if (!select) return;
-    const previous = select.value || document.body.dataset.operatorLayout || "compact";
-    select.replaceChildren();
-    Object.entries(layouts).forEach(([value, layout]) => {
-      if (!layoutAvailable(layout)) return;
-      select.add(new Option(layout.label, value));
-    });
-    const available = Array.from(select.options).some(option => option.value === previous);
-    select.value = available ? previous : "compact";
-    if (!available && previous !== "compact") api.applyLayout("compact", { persist: false });
-    select.title = unavailableLayoutMessage();
-  }
-
-  api.setLayoutCapabilities = function setLayoutCapabilities(capabilities = {}) {
-    Object.keys(layoutCapabilities).forEach((name) => {
-      if (name in capabilities) layoutCapabilities[name] = Boolean(capabilities[name]);
-    });
-    refreshLayoutOptions();
-    const select = document.getElementById("operator-layout-select");
-    const saved = savedLayoutName();
-    if (select && Array.from(select.options).some(option => option.value === saved)) {
-      select.value = saved;
-      api.applyLayout(saved, { persist: false });
-    }
-  };
-
-  api.setActiveRig = function setActiveRig(rigId) {
-    activeRigId = typeof rigId === "string" && rigId ? rigId : null;
-    const saved = savedLayoutName();
-    const select = document.getElementById("operator-layout-select");
-    if (select) select.value = Array.from(select.options).some(option => option.value === saved) ? saved : "compact";
-    api.applyLayout(select?.value || saved, { persist: false });
-  };
-
-  api.applyLayout = function applyLayout(name, options = {}) {
-    const requestedLayout = layouts[name];
-    const permittedName = requestedLayout && layoutAvailable(requestedLayout) ? name : "compact";
-    const layout = layouts[permittedName];
-    document.body.dataset.operatorLayout = permittedName in layouts ? permittedName : "compact";
-    if (options.persist !== false) localStorage.setItem(layoutStorageKey(), document.body.dataset.operatorLayout);
-    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;
-    if (options.navigate && typeof window.navigateToTab === "function") {
-      window.navigateToTab(layout.preferredTab);
-    }
-  };
-
-  function installLayoutControls() {
-    const actions = document.querySelector(".top-bar-actions");
-    if (actions && !document.getElementById("operator-layout-select")) {
-      const label = document.createElement("label");
-      label.className = "operator-layout-picker";
-      label.innerHTML = '<span class="visually-hidden">Operator layout</span><select id="operator-layout-select" aria-label="Operator layout"></select>';
-      const select = label.querySelector("select");
-      const savedLayout = savedLayoutName();
-      actions.insertBefore(label, actions.firstChild);
-      select.value = savedLayout;
-      refreshLayoutOptions();
-      if (savedLayout !== "broadcast" && layouts[savedLayout]) select.value = savedLayout;
-      select.addEventListener("change", () => api.applyLayout(select.value, { navigate: true }));
-      api.applyLayout(select.value);
-    }
-
-    const tray = document.querySelector(".controls-tray");
-    if (tray && !document.getElementById("advanced-radio-controls")) {
-      const details = document.createElement("details");
-      details.id = "advanced-radio-controls";
-      details.className = "advanced-radio-controls";
-      details.innerHTML = '<summary>Advanced radio controls</summary><div class="advanced-radio-body"></div>';
-      const body = details.querySelector(".advanced-radio-body");
-      ["sdr-settings-row", "vchan-row", "tx-limit-row"].forEach((id) => {
-        const element = document.getElementById(id);
-        if (element) body.appendChild(element);
-      });
-      tray.appendChild(details);
-      api.applyLayout(savedLayoutName(), { persist: false });
-    }
-  }
-
-  function installMobileMore() {
-    const nav = document.querySelector(".tab-bar-nav");
-    if (!nav || document.getElementById("mobile-more-btn")) return;
-    const more = document.createElement("button");
-    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.setAttribute("aria-haspopup", "menu");
-    more.setAttribute("aria-expanded", "false");
-    const menu = document.createElement("div");
-    menu.id = "mobile-more-menu";
-    menu.className = "mobile-more-menu";
-    menu.setAttribute("role", "menu");
-    more.setAttribute("aria-controls", menu.id);
-    const closeMore = (restoreFocus = false) => {
-      if (!menu.classList.contains("is-open")) return;
-      menu.classList.remove("is-open");
-      more.setAttribute("aria-expanded", "false");
-      if (restoreFocus) more.focus();
-    };
-    api.closeMobileOverlays = closeMore;
-    ["statistics", "recorder", "settings", "about"].forEach((tabName) => {
-      const source = nav.querySelector(`[data-tab="${tabName}"]`);
-      if (!source) return;
-      const item = document.createElement("button");
-      item.type = "button";
-      item.setAttribute("role", "menuitem");
-      item.dataset.navigateTab = tabName;
-      item.textContent = source.textContent.trim();
-      item.addEventListener("click", () => {
-        if (typeof window.navigateToTab === "function") window.navigateToTab(tabName);
-        closeMore();
-      });
-      menu.appendChild(item);
-    });
-    more.addEventListener("click", () => {
-      const open = menu.classList.toggle("is-open");
-      more.setAttribute("aria-expanded", String(open));
-      if (open) menu.querySelector('[role="menuitem"]')?.focus();
-    });
-    document.addEventListener("click", (event) => {
-      if (!menu.contains(event.target) && !more.contains(event.target)) closeMore();
-    });
-    document.addEventListener("keydown", (event) => {
-      if (event.key === "Escape") closeMore(true);
-    });
-    window.addEventListener("resize", () => closeMore());
-    window.addEventListener("popstate", () => closeMore());
-    nav.append(more, menu);
-  }
-
-  function installDecoderPicker() {
-    const bar = document.querySelector("#tab-digital-modes > .sub-tab-bar");
-    if (!bar || document.getElementById("decoder-tab-select")) return;
-    const select = document.createElement("select");
-    select.id = "decoder-tab-select";
-    select.className = "decoder-tab-select";
-    select.setAttribute("aria-label", "Decoder view");
-    const groups = [
-      ["Overview", ["overview"]], ["Marine & packet", ["ais", "vdes", "aprs", "hf-aprs"]],
-      ["Weak signal", ["cw", "ft8", "ft4", "ft2", "wspr"]], ["Broadcast & images", ["rds", "sat", "wefax"]],
-    ];
-    groups.forEach(([label, ids]) => {
-      const group = document.createElement("optgroup");
-      group.label = label;
-      ids.forEach((id) => {
-        const button = bar.querySelector(`[data-subtab="${id}"]`);
-        if (button) group.appendChild(new Option(button.textContent.trim(), id));
-      });
-      select.appendChild(group);
-    });
-    select.addEventListener("change", () => bar.querySelector(`[data-subtab="${select.value}"]`)?.click());
-    bar.insertAdjacentElement("afterend", select);
-  }
-
-  function installDecoderBadges() {
-    const bar = document.querySelector("#tab-digital-modes > .sub-tab-bar");
-    if (!bar) return;
-    bar.querySelectorAll(".sub-tab[data-subtab]").forEach((button) => {
-      const id = button.dataset.subtab;
-      if (id === "overview" || button.querySelector(".decoder-state-dot")) return;
-      const dot = document.createElement("span");
-      dot.className = "decoder-state-dot";
-      dot.setAttribute("aria-hidden", "true");
-      button.appendChild(dot);
-      const status = document.getElementById(`${id}-status`);
-      if (!status) return;
-      const sync = () => {
-        const value = status.textContent.toLowerCase();
-        const state = /receiv|decod|connected|listening/.test(value) ? "active"
-          : /error|fail|disconnected/.test(value) ? "error" : "idle";
-        dot.dataset.state = state;
-        button.title = `${button.childNodes[0]?.textContent?.trim() || id}: ${status.textContent.trim()}`;
-      };
-      new MutationObserver(sync).observe(status, { childList: true, characterData: true, subtree: true });
-      sync();
-    });
-  }
-
-  api.init = function init() {
-    ensureLiveRegions();
-    installLayoutControls();
-    installMobileMore();
-    installDecoderPicker();
-    installDecoderBadges();
-    api.prepareTabList(document.querySelector(".tab-bar-nav"), "primary");
-    document.querySelectorAll(".sub-tab-bar").forEach(bar => api.prepareTabList(bar, "secondary"));
-    window.addEventListener("unhandledrejection", (event) => {
-      const message = event.reason?.message || "An operation failed unexpectedly";
-      api.notify(message, { kind: "error" });
-    });
-  };
-
-  if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", api.init, { once: true });
-  else api.init();
-})();

src/trx-client/trx-frontend/trx-frontend-http/assets/web/webgl-renderer.js

@@ -1,535 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-(function initTrxWebGl(global) {
-  "use strict";
-
-  const cssColorCache = new Map();
-  let cssColorProbe = null;
-
-  function clearCssColorCache() {
-    cssColorCache.clear();
-  }
-
-  function ensureCssColorProbe() {
-    if (cssColorProbe) return cssColorProbe;
-    const el = document.createElement("span");
-    el.style.position = "absolute";
-    el.style.left = "-9999px";
-    el.style.top = "-9999px";
-    el.style.pointerEvents = "none";
-    el.style.opacity = "0";
-    document.body.appendChild(el);
-    cssColorProbe = el;
-    return cssColorProbe;
-  }
-
-  function parseRgbString(value) {
-    const m = /^rgba?\(([^)]+)\)$/.exec(String(value || "").trim());
-    if (!m) return null;
-    const parts = m[1].split(",").map((p) => p.trim());
-    if (parts.length < 3) return null;
-    const r = Number(parts[0]);
-    const g = Number(parts[1]);
-    const b = Number(parts[2]);
-    const a = parts.length > 3 ? Number(parts[3]) : 1;
-    if (![r, g, b, a].every(Number.isFinite)) return null;
-    return [
-      Math.max(0, Math.min(1, r / 255)),
-      Math.max(0, Math.min(1, g / 255)),
-      Math.max(0, Math.min(1, b / 255)),
-      Math.max(0, Math.min(1, a)),
-    ];
-  }
-
-  function parseHexColor(value) {
-    const raw = String(value || "").trim();
-    if (!/^#([0-9a-f]{3,8})$/i.test(raw)) return null;
-    let hex = raw.slice(1);
-    if (hex.length === 3 || hex.length === 4) {
-      hex = hex.split("").map((ch) => ch + ch).join("");
-    }
-    if (!(hex.length === 6 || hex.length === 8)) return null;
-    const r = parseInt(hex.slice(0, 2), 16) / 255;
-    const g = parseInt(hex.slice(2, 4), 16) / 255;
-    const b = parseInt(hex.slice(4, 6), 16) / 255;
-    const a = hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1;
-    return [r, g, b, a];
-  }
-
-  function parseCssColor(value) {
-    const key = String(value ?? "");
-    if (cssColorCache.has(key)) return cssColorCache.get(key).slice();
-
-    let parsed = parseHexColor(key) || parseRgbString(key);
-    if (!parsed) {
-      const probe = ensureCssColorProbe();
-      probe.style.color = "";
-      probe.style.color = key;
-      const computed = getComputedStyle(probe).color;
-      parsed = parseRgbString(computed) || [0, 0, 0, 1];
-    }
-    cssColorCache.set(key, parsed.slice());
-    return parsed.slice();
-  }
-
-  function hslToRgba(h, s, l, a = 1) {
-    const hue = ((((Number(h) || 0) % 360) + 360) % 360) / 360;
-    const sat = Math.max(0, Math.min(1, (Number(s) || 0) / 100));
-    const lig = Math.max(0, Math.min(1, (Number(l) || 0) / 100));
-
-    const q = lig < 0.5 ? lig * (1 + sat) : lig + sat - lig * sat;
-    const p = 2 * lig - q;
-    const hueToRgb = (t) => {
-      let tt = t;
-      if (tt < 0) tt += 1;
-      if (tt > 1) tt -= 1;
-      if (tt < 1 / 6) return p + (q - p) * 6 * tt;
-      if (tt < 1 / 2) return q;
-      if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
-      return p;
-    };
-
-    const r = sat === 0 ? lig : hueToRgb(hue + 1 / 3);
-    const g = sat === 0 ? lig : hueToRgb(hue);
-    const b = sat === 0 ? lig : hueToRgb(hue - 1 / 3);
-    return [r, g, b, Math.max(0, Math.min(1, Number(a)))];
-  }
-
-  function normalizeColor(input, alphaMul = 1) {
-    let rgba;
-    if (Array.isArray(input)) {
-      const arr = input.map((v) => Number(v));
-      if (arr.length >= 4) {
-        rgba = [arr[0], arr[1], arr[2], arr[3]];
-      } else {
-        rgba = [0, 0, 0, 1];
-      }
-    } else if (typeof input === "string") {
-      rgba = parseCssColor(input);
-    } else if (input && typeof input === "object") {
-      rgba = [
-        Number(input.r) || 0,
-        Number(input.g) || 0,
-        Number(input.b) || 0,
-        Number(input.a ?? 1),
-      ];
-    } else {
-      rgba = [0, 0, 0, 1];
-    }
-    const out = [
-      Math.max(0, Math.min(1, rgba[0])),
-      Math.max(0, Math.min(1, rgba[1])),
-      Math.max(0, Math.min(1, rgba[2])),
-      Math.max(0, Math.min(1, rgba[3] * alphaMul)),
-    ];
-    return out;
-  }
-
-  function compileShader(gl, type, source) {
-    const shader = gl.createShader(type);
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-      const log = gl.getShaderInfoLog(shader) || "shader compile error";
-      gl.deleteShader(shader);
-      throw new Error(log);
-    }
-    return shader;
-  }
-
-  function createProgram(gl, vertexSrc, fragmentSrc) {
-    const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);
-    const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
-    const program = gl.createProgram();
-    gl.attachShader(program, vs);
-    gl.attachShader(program, fs);
-    gl.linkProgram(program);
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-      const log = gl.getProgramInfoLog(program) || "program link error";
-      gl.deleteProgram(program);
-      throw new Error(log);
-    }
-    return program;
-  }
-
-  function pushColoredVertex(target, x, y, rgba) {
-    target.push(x, y, rgba[0], rgba[1], rgba[2], rgba[3]);
-  }
-
-  function segmentToQuadVertices(out, x0, y0, x1, y1, halfW, rgba) {
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    const len = Math.hypot(dx, dy);
-    if (!(len > 0.0001)) return;
-    const nx = (-dy / len) * halfW;
-    const ny = (dx / len) * halfW;
-
-    const ax = x0 - nx, ay = y0 - ny;
-    const bx = x0 + nx, by = y0 + ny;
-    const cx = x1 + nx, cy = y1 + ny;
-    const dx2 = x1 - nx, dy2 = y1 - ny;
-
-    pushColoredVertex(out, ax, ay, rgba);
-    pushColoredVertex(out, bx, by, rgba);
-    pushColoredVertex(out, cx, cy, rgba);
-
-    pushColoredVertex(out, ax, ay, rgba);
-    pushColoredVertex(out, cx, cy, rgba);
-    pushColoredVertex(out, dx2, dy2, rgba);
-  }
-
-  class TrxWebGlRenderer {
-    constructor(canvas, options = {}) {
-      this.canvas = canvas;
-      this.options = { alpha: true, premultipliedAlpha: false, ...options };
-      this.gl =
-        canvas?.getContext("webgl", this.options) ||
-        canvas?.getContext("experimental-webgl", this.options) ||
-        null;
-      this.ready = !!this.gl;
-      this.textures = new Map();
-      // Reusable scratch buffers — avoids per-draw-call Float32Array allocation
-      // and lets us use bufferSubData instead of bufferData (no GPU realloc).
-      this._colorScratch = new Float32Array(4096 * 6); // grows as needed
-      this._colorGpuSize = 0;                          // current GPU buffer size (floats)
-      this._texScratch = new Float32Array(6 * 4);      // fixed: 6 verts × (xy+uv)
-      if (!this.ready) return;
-
-      const gl = this.gl;
-      gl.disable(gl.DEPTH_TEST);
-      gl.disable(gl.CULL_FACE);
-      gl.enable(gl.BLEND);
-      gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-
-      const colorVertexSrc =
-        "attribute vec2 a_pos;\n" +
-        "attribute vec4 a_color;\n" +
-        "uniform vec2 u_resolution;\n" +
-        "varying vec4 v_color;\n" +
-        "void main() {\n" +
-        "  vec2 zeroToOne = a_pos / u_resolution;\n" +
-        "  vec2 clip = zeroToOne * 2.0 - 1.0;\n" +
-        "  gl_Position = vec4(clip * vec2(1.0, -1.0), 0.0, 1.0);\n" +
-        "  v_color = a_color;\n" +
-        "}\n";
-      const colorFragmentSrc =
-        "precision mediump float;\n" +
-        "varying vec4 v_color;\n" +
-        "void main() {\n" +
-        "  gl_FragColor = v_color;\n" +
-        "}\n";
-
-      const textureVertexSrc =
-        "attribute vec2 a_pos;\n" +
-        "attribute vec2 a_uv;\n" +
-        "uniform vec2 u_resolution;\n" +
-        "varying vec2 v_uv;\n" +
-        "void main() {\n" +
-        "  vec2 zeroToOne = a_pos / u_resolution;\n" +
-        "  vec2 clip = zeroToOne * 2.0 - 1.0;\n" +
-        "  gl_Position = vec4(clip * vec2(1.0, -1.0), 0.0, 1.0);\n" +
-        "  v_uv = a_uv;\n" +
-        "}\n";
-      const textureFragmentSrc =
-        "precision mediump float;\n" +
-        "varying vec2 v_uv;\n" +
-        "uniform sampler2D u_tex;\n" +
-        "uniform float u_alpha;\n" +
-        "void main() {\n" +
-        "  vec4 c = texture2D(u_tex, v_uv);\n" +
-        "  gl_FragColor = vec4(c.rgb, c.a * u_alpha);\n" +
-        "}\n";
-
-      this.colorProgram = createProgram(gl, colorVertexSrc, colorFragmentSrc);
-      this.colorBuffer = gl.createBuffer();
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.colorBuffer);
-      gl.bufferData(gl.ARRAY_BUFFER, this._colorScratch, gl.DYNAMIC_DRAW);
-      this._colorGpuSize = this._colorScratch.length;
-      this.colorLoc = {
-        pos: gl.getAttribLocation(this.colorProgram, "a_pos"),
-        color: gl.getAttribLocation(this.colorProgram, "a_color"),
-        resolution: gl.getUniformLocation(this.colorProgram, "u_resolution"),
-      };
-
-      this.textureProgram = createProgram(gl, textureVertexSrc, textureFragmentSrc);
-      this.textureBuffer = gl.createBuffer();
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.textureBuffer);
-      gl.bufferData(gl.ARRAY_BUFFER, this._texScratch, gl.DYNAMIC_DRAW);
-      this.textureLoc = {
-        pos: gl.getAttribLocation(this.textureProgram, "a_pos"),
-        uv: gl.getAttribLocation(this.textureProgram, "a_uv"),
-        resolution: gl.getUniformLocation(this.textureProgram, "u_resolution"),
-        alpha: gl.getUniformLocation(this.textureProgram, "u_alpha"),
-        tex: gl.getUniformLocation(this.textureProgram, "u_tex"),
-      };
-    }
-
-    ensureSize(cssWidth, cssHeight, dpr = (window.devicePixelRatio || 1)) {
-      if (!this.ready) return false;
-      const nextW = Math.max(1, Math.round(cssWidth * dpr));
-      const nextH = Math.max(1, Math.round(cssHeight * dpr));
-      const changed = this.canvas.width !== nextW || this.canvas.height !== nextH;
-      if (changed) {
-        this.canvas.width = nextW;
-        this.canvas.height = nextH;
-      }
-      this.gl.viewport(0, 0, this.canvas.width, this.canvas.height);
-      return changed;
-    }
-
-    clear(color) {
-      if (!this.ready) return;
-      const gl = this.gl;
-      const rgba = normalizeColor(color);
-      gl.clearColor(rgba[0], rgba[1], rgba[2], rgba[3]);
-      gl.clear(gl.COLOR_BUFFER_BIT);
-    }
-
-    drawTriangles(vertices) {
-      this._drawColorGeometry(vertices, this.gl.TRIANGLES);
-    }
-
-    drawTriangleStrip(vertices) {
-      this._drawColorGeometry(vertices, this.gl.TRIANGLE_STRIP);
-    }
-
-    _drawColorGeometry(vertices, mode) {
-      if (!this.ready || !vertices || vertices.length === 0) return;
-      const gl = this.gl;
-      const count = vertices.length;
-
-      // Grow scratch buffer if needed (doubles each time to amortise copies).
-      if (count > this._colorScratch.length) {
-        let newLen = this._colorScratch.length;
-        while (newLen < count) newLen *= 2;
-        this._colorScratch = new Float32Array(newLen);
-      }
-
-      // Copy into scratch (set() is a fast typed memcpy; avoids new allocation).
-      this._colorScratch.set(vertices);
-      const view = this._colorScratch.subarray(0, count);
-
-      gl.useProgram(this.colorProgram);
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.colorBuffer);
-
-      // Only reallocate the GPU buffer when it is too small; otherwise use
-      // bufferSubData which avoids a GPU reallocation (Safari is sensitive to this).
-      if (count > this._colorGpuSize) {
-        gl.bufferData(gl.ARRAY_BUFFER, this._colorScratch, gl.DYNAMIC_DRAW);
-        this._colorGpuSize = this._colorScratch.length;
-      } else {
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, view);
-      }
-
-      gl.enableVertexAttribArray(this.colorLoc.pos);
-      gl.vertexAttribPointer(this.colorLoc.pos, 2, gl.FLOAT, false, 24, 0);
-      gl.enableVertexAttribArray(this.colorLoc.color);
-      gl.vertexAttribPointer(this.colorLoc.color, 4, gl.FLOAT, false, 24, 8);
-      gl.uniform2f(this.colorLoc.resolution, this.canvas.width, this.canvas.height);
-      gl.drawArrays(mode, 0, count / 6);
-    }
-
-    fillRect(x, y, w, h, color) {
-      if (w <= 0 || h <= 0) return;
-      const rgba = normalizeColor(color);
-      const v = [];
-      pushColoredVertex(v, x, y, rgba);
-      pushColoredVertex(v, x + w, y, rgba);
-      pushColoredVertex(v, x + w, y + h, rgba);
-      pushColoredVertex(v, x, y, rgba);
-      pushColoredVertex(v, x + w, y + h, rgba);
-      pushColoredVertex(v, x, y + h, rgba);
-      this._drawColorGeometry(v, this.gl.TRIANGLES);
-    }
-
-    fillGradientRect(x, y, w, h, colorTL, colorTR, colorBR, colorBL) {
-      if (w <= 0 || h <= 0) return;
-      const tl = normalizeColor(colorTL);
-      const tr = normalizeColor(colorTR);
-      const br = normalizeColor(colorBR);
-      const bl = normalizeColor(colorBL);
-      const v = [];
-      pushColoredVertex(v, x, y, tl);
-      pushColoredVertex(v, x + w, y, tr);
-      pushColoredVertex(v, x + w, y + h, br);
-      pushColoredVertex(v, x, y, tl);
-      pushColoredVertex(v, x + w, y + h, br);
-      pushColoredVertex(v, x, y + h, bl);
-      this._drawColorGeometry(v, this.gl.TRIANGLES);
-    }
-
-    drawPolyline(points, color, width = 1) {
-      if (!Array.isArray(points) || points.length < 4) return;
-      const rgba = normalizeColor(color);
-      const halfW = Math.max(0.5, Number(width) || 1) / 2;
-      const verts = [];
-      for (let i = 0; i < points.length - 2; i += 2) {
-        segmentToQuadVertices(
-          verts,
-          points[i], points[i + 1],
-          points[i + 2], points[i + 3],
-          halfW,
-          rgba,
-        );
-      }
-      this._drawColorGeometry(verts, this.gl.TRIANGLES);
-    }
-
-    drawSegments(segments, color, width = 1) {
-      if (!Array.isArray(segments) || segments.length < 4) return;
-      const rgba = normalizeColor(color);
-      const halfW = Math.max(0.5, Number(width) || 1) / 2;
-      const verts = [];
-      for (let i = 0; i < segments.length - 3; i += 4) {
-        segmentToQuadVertices(
-          verts,
-          segments[i], segments[i + 1],
-          segments[i + 2], segments[i + 3],
-          halfW,
-          rgba,
-        );
-      }
-      this._drawColorGeometry(verts, this.gl.TRIANGLES);
-    }
-
-    drawFilledArea(points, baselineY, color) {
-      if (!Array.isArray(points) || points.length < 4) return;
-      const rgba = normalizeColor(color);
-      const verts = [];
-      for (let i = 0; i < points.length; i += 2) {
-        pushColoredVertex(verts, points[i], baselineY, rgba);
-        pushColoredVertex(verts, points[i], points[i + 1], rgba);
-      }
-      this._drawColorGeometry(verts, this.gl.TRIANGLE_STRIP);
-    }
-
-    drawPoints(points, size, color) {
-      if (!Array.isArray(points) || points.length < 2) return;
-      const radius = Math.max(1, Number(size) || 1);
-      const rgba = normalizeColor(color);
-      const verts = [];
-      for (let i = 0; i < points.length; i += 2) {
-        const x = points[i] - radius;
-        const y = points[i + 1] - radius;
-        const w = radius * 2;
-        const h = radius * 2;
-        pushColoredVertex(verts, x, y, rgba);
-        pushColoredVertex(verts, x + w, y, rgba);
-        pushColoredVertex(verts, x + w, y + h, rgba);
-        pushColoredVertex(verts, x, y, rgba);
-        pushColoredVertex(verts, x + w, y + h, rgba);
-        pushColoredVertex(verts, x, y + h, rgba);
-      }
-      this._drawColorGeometry(verts, this.gl.TRIANGLES);
-    }
-
-    drawDashedVerticalLine(x, y0, y1, dashLen, gapLen, color, width = 1) {
-      const dash = Math.max(1, Number(dashLen) || 1);
-      const gap = Math.max(1, Number(gapLen) || 1);
-      const top = Math.min(y0, y1);
-      const bottom = Math.max(y0, y1);
-      const segments = [];
-      for (let y = top; y < bottom; y += dash + gap) {
-        const segEnd = Math.min(bottom, y + dash);
-        segments.push(x, y, x, segEnd);
-      }
-      this.drawSegments(segments, color, width);
-    }
-
-    uploadRgbaTexture(name, width, height, data, filter = "linear") {
-      if (!this.ready || !name || !data) return null;
-      const gl = this.gl;
-      let entry = this.textures.get(name);
-      if (!entry) {
-        const texture = gl.createTexture();
-        entry = { texture, width: 0, height: 0 };
-        this.textures.set(name, entry);
-      }
-      gl.bindTexture(gl.TEXTURE_2D, entry.texture);
-      gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
-      const mode = filter === "nearest" ? gl.NEAREST : gl.LINEAR;
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, mode);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, mode);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-      if (entry.width !== width || entry.height !== height) {
-        gl.texImage2D(
-          gl.TEXTURE_2D,
-          0,
-          gl.RGBA,
-          width,
-          height,
-          0,
-          gl.RGBA,
-          gl.UNSIGNED_BYTE,
-          data,
-        );
-        entry.width = width;
-        entry.height = height;
-      } else {
-        gl.texSubImage2D(
-          gl.TEXTURE_2D,
-          0,
-          0,
-          0,
-          width,
-          height,
-          gl.RGBA,
-          gl.UNSIGNED_BYTE,
-          data,
-        );
-      }
-      return entry.texture;
-    }
-
-    drawTexture(name, x, y, w, h, alpha = 1, flipY = true) {
-      if (!this.ready || !name || w <= 0 || h <= 0) return;
-      const entry = this.textures.get(name);
-      if (!entry) return;
-      const gl = this.gl;
-      const s = this._texScratch;
-      const x2 = x + w, y2 = y + h;
-      if (flipY) {
-        s[0]=x;  s[1]=y;  s[2]=0; s[3]=1;
-        s[4]=x2; s[5]=y;  s[6]=1; s[7]=1;
-        s[8]=x2; s[9]=y2; s[10]=1;s[11]=0;
-        s[12]=x; s[13]=y; s[14]=0;s[15]=1;
-        s[16]=x2;s[17]=y2;s[18]=1;s[19]=0;
-        s[20]=x; s[21]=y2;s[22]=0;s[23]=0;
-      } else {
-        s[0]=x;  s[1]=y;  s[2]=0; s[3]=0;
-        s[4]=x2; s[5]=y;  s[6]=1; s[7]=0;
-        s[8]=x2; s[9]=y2; s[10]=1;s[11]=1;
-        s[12]=x; s[13]=y; s[14]=0;s[15]=0;
-        s[16]=x2;s[17]=y2;s[18]=1;s[19]=1;
-        s[20]=x; s[21]=y2;s[22]=0;s[23]=1;
-      }
-      gl.useProgram(this.textureProgram);
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.textureBuffer);
-      gl.bufferSubData(gl.ARRAY_BUFFER, 0, s);
-      gl.enableVertexAttribArray(this.textureLoc.pos);
-      gl.vertexAttribPointer(this.textureLoc.pos, 2, gl.FLOAT, false, 16, 0);
-      gl.enableVertexAttribArray(this.textureLoc.uv);
-      gl.vertexAttribPointer(this.textureLoc.uv, 2, gl.FLOAT, false, 16, 8);
-      gl.uniform2f(this.textureLoc.resolution, this.canvas.width, this.canvas.height);
-      gl.uniform1f(this.textureLoc.alpha, Math.max(0, Math.min(1, Number(alpha) || 0)));
-      gl.activeTexture(gl.TEXTURE0);
-      gl.bindTexture(gl.TEXTURE_2D, entry.texture);
-      gl.uniform1i(this.textureLoc.tex, 0);
-      gl.drawArrays(gl.TRIANGLES, 0, 6);
-    }
-  }
-
-  function createRenderer(canvas, options) {
-    return new TrxWebGlRenderer(canvas, options);
-  }
-
-  global.trxParseCssColor = parseCssColor;
-  global.trxHslToRgba = hslToRgba;
-  global.createTrxWebGlRenderer = createRenderer;
-  global.trxClearCssColorCache = clearCssColorCache;
-})(window);

src/trx-client/trx-frontend/trx-frontend-http/examples/generate_typescript.rs

@@ -14,16 +14,18 @@ use trx_core::rig::{
 };
 use trx_core::{DecoderConfig, RdsData, RigFilterState, RigMode, RigSnapshot, WfmDenoiseLevel};
 use trx_frontend_http::server::api::rig::{RigListItem, RigListResponse};
+use trx_frontend_http::server::api::FrontendMeta;
 use trx_protocol::{DecoderActivation, DecoderDescriptor};
 use ts_rs::{Config, TS};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut output = String::from(
+    let mut output = format!(
         "// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>\n\
          //\n\
-         // SPDX-License-Identifier: GPL-2.0-or-later\n\n\
+         // SPDX-License-{}: GPL-2.0-or-later\n\n\
          // Generated by `cargo run -p trx-frontend-http --example generate_typescript`.\n\
          // Do not edit manually.\n\n",
+        "Identifier",
     );
     let config = Config::default();
 
@@ -53,6 +55,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     export!(RigSnapshot);
     export!(RigListItem);
     export!(RigListResponse);
+    export!(FrontendMeta);
     export!(DecoderActivation);
     export!(DecoderDescriptor);
 

src/trx-client/trx-frontend/trx-frontend-http/frontend/build.mjs

@@ -15,43 +15,12 @@ await rm(outputDir, { recursive: true, force: true });
 
 await build({
   entryPoints: {
-    "api-client": path.join(sourceDir, "api", "client.ts"),
+    app: path.join(sourceDir, "bootstrap.ts"),
-    "ui-core": path.join(sourceDir, "ui-core.ts"),
-    "plugin-loader": path.join(sourceDir, "plugin-loader.ts"),
-    "plugin-runtime": path.join(sourceDir, "plugin-runtime.ts"),
-    screenshot: path.join(sourceDir, "screenshot.ts"),
-    "webgl-renderer": path.join(sourceDir, "webgl-renderer.ts"),
-  },
-  outdir: outputDir,
-  bundle: false,
-  target: "es2022",
-  sourcemap: false,
-  legalComments: "inline",
-  charset: "utf8",
-  logLevel: "info",
-});
-
-await build({
-  entryPoints: { app: path.join(sourceDir, "bootstrap.ts") },
-  outdir: outputDir,
-  bundle: true,
-  format: "iife",
-  platform: "browser",
-  target: "es2022",
-  sourcemap: false,
-  legalComments: "inline",
-  charset: "utf8",
-  logLevel: "info",
-});
-
-await build({
-  entryPoints: {
     ft2: path.join(sourceDir, "plugins", "ft2.ts"),
     ft4: path.join(sourceDir, "plugins", "ft4.ts"),
     wspr: path.join(sourceDir, "plugins", "wspr.ts"),
     cw: path.join(sourceDir, "plugins", "cw.ts"),
     ft8: path.join(sourceDir, "plugins", "ft8.ts"),
-    "leaflet-ais-tracksymbol": path.join(sourceDir, "leaflet-ais-tracksymbol.ts"),
     vdes: path.join(sourceDir, "plugins", "vdes.ts"),
     wefax: path.join(sourceDir, "plugins", "wefax.ts"),
     "background-decode": path.join(sourceDir, "plugins", "background-decode.ts"),
@@ -64,6 +33,7 @@ await build({
     bookmarks: path.join(sourceDir, "plugins", "bookmarks.ts"),
     scheduler: path.join(sourceDir, "plugins", "scheduler.ts"),
     "map-core": path.join(sourceDir, "map-core.ts"),
+    screenshot: path.join(sourceDir, "screenshot.ts"),
   },
   outdir: outputDir,
   bundle: true,

src/trx-client/trx-frontend/trx-frontend-http/frontend/eslint.config.js

@@ -10,8 +10,6 @@ export default tseslint.config(
   {
     ignores: [
       "../assets/web/generated/**",
-      // Removed file-by-file as the legacy sources are converted to TypeScript.
-      "src/**/*.js",
     ],
   },
   {
@@ -21,7 +19,7 @@ export default tseslint.config(
       globals: globals.node,
     },
   },
-  ...tseslint.configs.strictTypeChecked.map((config) => ({
+  ...tseslint.configs.recommendedTypeChecked.map((config) => ({
     ...config,
     files: ["src/**/*.ts", "tests/**/*.ts"],
   })),
@@ -38,6 +36,15 @@ export default tseslint.config(
     rules: {
       "no-undef": "off",
       "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-unused-vars": ["error", {
+        argsIgnorePattern: "^_",
+        caughtErrors: "none",
+        varsIgnorePattern: "^_",
+      }],
+      // DOM event targets intentionally ignore listener return values. Async
+      // listeners handle their own failures; keep the rule for all other
+      // promise misuse sites.
+      "@typescript-eslint/no-misused-promises": ["error", { checksVoidReturn: false }],
       "@typescript-eslint/restrict-template-expressions": ["error", { allowNumber: true }],
     },
   },

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

@@ -13,6 +13,7 @@
         "esbuild": "0.25.12",
         "eslint": "9.39.2",
         "globals": "16.5.0",
+        "playwright-core": "1.62.1",
         "typescript": "5.9.3",
         "typescript-eslint": "8.51.0"
       },
@@ -1763,6 +1764,19 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/playwright-core": {
+      "version": "1.62.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.62.1.tgz",
+      "integrity": "sha512-wPYSwEBJY9GHraISXqyqtx0na0LpO3XEX7jNDhntbex7tzUS7kLnZsOlFruFJB4Hi/rhDMjXGqHewDZ68nYZVw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",

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

@@ -12,6 +12,7 @@
     "typecheck": "tsc --project tsconfig.json && tsc --project tsconfig.worker.json",
     "lint": "eslint \"src/**/*.ts\" \"tests/**/*.mjs\" build.mjs --no-error-on-unmatched-pattern",
     "test": "node --test tests/*.test.mjs",
+    "test:browser": "node tests/browser-smoke.mjs && node tests/spectrum-layout.mjs && node tests/decode-flow.mjs",
     "verify-generated": "npm run generate-types && npm run build && git diff --exit-code -- ../assets/web/generated src/api/generated.ts"
   },
   "devDependencies": {
@@ -20,6 +21,7 @@
     "esbuild": "0.25.12",
     "eslint": "9.39.2",
     "globals": "16.5.0",
+    "playwright-core": "1.62.1",
     "typescript": "5.9.3",
     "typescript-eslint": "8.51.0"
   }

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/README.md

@@ -6,7 +6,48 @@ SPDX-License-Identifier: GPL-2.0-or-later
 
 # Frontend source
 
-This directory is the source of the browser assets embedded by
+This directory contains the strict TypeScript source for the browser assets
-`trx-frontend-http`. Run `npm run build` from the parent `frontend` directory
+embedded by `trx-frontend-http`. `bootstrap.ts` is the production entry point;
-after changing a source file. Cargo consumes the committed output under
+esbuild follows its imports and emits `/app.js`. Feature plugins are ESM entry
-`../assets/web/generated` and does not invoke Node.js.
+points loaded on demand by `plugin-loader.ts`, and the decode-history worker is
+built with its own Web Worker TypeScript configuration.
+
+Run all frontend commands from the parent `frontend` directory:
+
+```sh
+npm ci
+npm run typecheck
+npm run lint
+npm test
+npm run test:browser
+npm run build
+npm run verify-generated
+```
+
+`npm run verify-generated` regenerates Rust wire contracts and browser bundles,
+then rejects drift from the committed files. The browser smoke test needs a
+local Chromium-family executable; set `PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH`
+when it is not installed at `/usr/bin/chromium`.
+
+Cargo consumes committed output under `../assets/web/generated`. It never
+invokes Node.js, installs packages, or accesses the network. After changing a
+source file, commit the deterministic generated asset changes together with the
+source change.
+
+## Boundaries
+
+- `api/generated.ts` is generated from Rust and must not be edited manually.
+- `api/client.ts` owns runtime validation at version-sensitive HTTP and SSE
+  boundaries.
+- `core/` contains dependency-light shared helpers.
+- `features/` contains application behavior grouped by responsibility.
+- `plugins/` contains lazy decoder and high-coupling feature entries.
+- `plugins/host.ts` declares the typed `window.trx` state and services that
+  feature bundles read; feature entries import it rather than reaching for bare
+  `window` properties, which the module graph does not publish.
+- Files under `assets/web/vendor/` are vendored JavaScript and are not part of
+  the TypeScript migration.
+
+First-party features communicate through imports, the typed plugin runtime, or
+the documented `window.trx` host interface. New standalone `window` callbacks
+are not permitted.

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/api/generated.ts

@@ -117,6 +117,8 @@ export type RigListItem = { remote: string, display_name: string | null, manufac
 
 export type RigListResponse = { active_remote: string | null, rigs: Array<RigListItem>, };
 
+export type FrontendMeta = { clients: number, rigctl_clients: number, audio_clients: number, rigctl_addr: string | null, active_remote: string | null, remotes: Array<string>, owner_callsign: string | null, owner_website_url: string | null, owner_website_name: string | null, ais_vessel_url_base: string | null, show_sdr_gain_control: boolean, initial_map_zoom: number, spectrum_coverage_margin_hz: number, spectrum_usable_span_ratio: number, bandplan_enabled: boolean, bandplan_region: string, decode_history_retention_min: bigint, server_connected: boolean, };
+
 export type DecoderActivation = "mode_bound" | "toggle";
 
 export type DecoderDescriptor = { 

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

@@ -2,4 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import "./webgl-renderer.js";
+import "./ui-core.js";
+import "./plugin-runtime.js";
+import "./leaflet-ais-tracksymbol.js";
 import "./app.js";

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/core/decoder-registry.ts

@@ -11,7 +11,7 @@ export interface DecoderDescriptor {
   bookmark_selectable: boolean;
 }
 
-interface DecoderRegistryBridge extends Window {
+interface DecoderRegistryBridge {
   decoderRegistry?: DecoderDescriptor[];
   onDecoderRegistryReady?: (callback: () => void) => void;
 }

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/features/spectrum/math.ts

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export type NumericBins = number[] | Int8Array | Uint8Array | Float32Array | Float64Array;
+
+export function isNumericBins(value: unknown): value is NumericBins {
+  return Array.isArray(value)
+    ? value.every((item) => typeof item === "number")
+    : ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+
+const base64Lookup = new Uint8Array(128).fill(255);
+const base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let index = 0; index < base64Alphabet.length; index += 1) {
+  base64Lookup[base64Alphabet.charCodeAt(index)] = index;
+}
+let spectrumBinBuffer = new Int8Array(0);
+
+export function decodeBase64Int8(value: string): Int8Array {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 61) end -= 1;
+  const outputLength = end * 3 >>> 2;
+  if (spectrumBinBuffer.length !== outputLength) spectrumBinBuffer = new Int8Array(outputLength);
+  let outputIndex = 0;
+  for (let index = 0; index < end;) {
+    const sextets = [0, 0, 0, 0];
+    for (let offset = 0; offset < 4 && index < end; offset += 1, index += 1) {
+      const code = value.charCodeAt(index);
+      const decoded = code < base64Lookup.length ? base64Lookup[code] : undefined;
+      if (decoded === undefined || decoded === 255) throw new TypeError("Invalid base64 spectrum frame");
+      sextets[offset] = decoded;
+    }
+    const packed = ((sextets[0] ?? 0) << 18) | ((sextets[1] ?? 0) << 12)
+      | ((sextets[2] ?? 0) << 6) | (sextets[3] ?? 0);
+    if (outputIndex < outputLength) spectrumBinBuffer[outputIndex++] = packed >> 16 & 0xff;
+    if (outputIndex < outputLength) spectrumBinBuffer[outputIndex++] = packed >> 8 & 0xff;
+    if (outputIndex < outputLength) spectrumBinBuffer[outputIndex++] = packed & 0xff;
+  }
+  return spectrumBinBuffer;
+}
+
+let nthScratch = new Float64Array(0);
+
+export function nthElement(values: NumericBins, target: number): number | null {
+  if (values.length === 0 || target < 0 || target >= values.length) return null;
+  if (nthScratch.length < values.length) nthScratch = new Float64Array(values.length);
+  for (let index = 0; index < values.length; index += 1) nthScratch[index] = values[index] ?? 0;
+  let low = 0;
+  let high = values.length - 1;
+  while (low < high) {
+    const pivot = nthScratch[low + ((high - low) >> 1)] ?? 0;
+    let left = low;
+    let right = high;
+    while (left <= right) {
+      while ((nthScratch[left] ?? Infinity) < pivot) left += 1;
+      while ((nthScratch[right] ?? -Infinity) > pivot) right -= 1;
+      if (left <= right) {
+        const temporary = nthScratch[left] ?? 0;
+        nthScratch[left] = nthScratch[right] ?? 0;
+        nthScratch[right] = temporary;
+        left += 1;
+        right -= 1;
+      }
+    }
+    if (right < target) low = left;
+    if (target < left) high = right;
+  }
+  return nthScratch[target] ?? null;
+}
+
+export function estimateNoiseFloorDb(bins: unknown): number | null {
+  if (!isNumericBins(bins) || bins.length === 0) return null;
+  return nthElement(bins, Math.floor(bins.length * 0.15));
+}

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

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 import type * as Leaflet from "leaflet";
+import { aprsSymbolSprite } from "./plugins/aprs-shared";
+import type { PluginRuntimeWindow } from "./plugins/runtime-contract";
 
 export {};
 
@@ -13,11 +15,10 @@ interface TrackSymbolFactory {
 declare const L: typeof Leaflet & TrackSymbolFactory;
 
 /* Map controls are server-rendered and required while this feature is active. */
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
 /* The transition bridge exposes stateless core helpers as object methods. */
 /* eslint-disable @typescript-eslint/unbound-method */
 /* Wire payload values are normalized deliberately at display boundaries. */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-conversion, @typescript-eslint/no-base-to-string */
+/* eslint-disable @typescript-eslint/no-base-to-string */
 type MapElement = HTMLElement & HTMLInputElement & HTMLSelectElement & HTMLCanvasElement;
 type WebkitDocument = Document & {
   webkitFullscreenElement?: Element | null;
@@ -157,7 +158,7 @@ interface MapCore {
   updateDocumentTitle?(): void;
 }
 
-interface MapWindow extends Window {
+interface MapWindow {
   trx: { state: MapState; core: MapCore; modules: { map?: unknown } };
   ft8BaseHz?: number;
   refreshCwTonePicker?(): void;
@@ -229,6 +230,8 @@ const mapWindow = window as unknown as MapWindow;
   const mapMarkers = new Set<TrxLayer>();
   const DEFAULT_MAP_SOURCE_FILTER: Record<MapFilterKey, boolean> = { ais: true, vdes: true, aprs: true, bookmark: false, ft8: true, ft4: true, ft2: true, wspr: true, sat: false };
   const mapFilter: Record<MapFilterKey, boolean> = { ...DEFAULT_MAP_SOURCE_FILTER };
+  /** Chip key that clears a selection rather than naming a band or a source. */
+  const MAP_FILTER_ALL_KEY = "__all";
   const mapLocatorFilter: { phase: "band" | "type"; bands: Set<string> } = { phase: "band", bands: new Set() };
   let mapSearchFilter = "";
   let mapRigFilter = ""; // "" = all rigs
@@ -1078,38 +1081,42 @@ const mapWindow = window as unknown as MapWindow;
       container.innerHTML = `<span class="map-locator-empty">No ${kind === "band" ? "bands" : "sources"} available</span>`;
       return;
     }
-    let helperText = "";
+    const noun = kind === "band" ? "bands" : "sources";
     const sourceKeys = kind === "source" ? Object.keys(DEFAULT_MAP_SOURCE_FILTER) as MapFilterKey[] : [];
-    const noneSelected = kind === "source" && sourceKeys.every((k) => !mapFilter[k]);
+    // Selecting nothing selects everything, for both kinds.
-    if (kind === "source") {
+    const showingAll = kind === "source"
-      if (noneSelected) {
+      ? sourceKeys.every((k) => !mapFilter[k])
-        helperText = "All sources visible \u2014 click to filter";
+      : !(selectedSet instanceof Set) || selectedSet.size === 0;
-      }
+    // An "All" chip carries what a sentence of helper text used to say, in a
-    } else if (!(selectedSet instanceof Set) || selectedSet.size === 0) {
+    // width the bar can afford, and gives the selection somewhere to be undone.
-      helperText = `All ${kind === "band" ? "bands" : "sources"} visible by default`;
+    const allChip = document.createElement("button");
-    }
+    allChip.type = "button";
+    allChip.className = "map-locator-chip map-locator-chip-all";
+    if (showingAll) allChip.classList.add("is-active");
+    allChip.dataset.filterKind = kind;
+    allChip.dataset.filterKey = MAP_FILTER_ALL_KEY;
+    allChip.setAttribute("aria-pressed", showingAll ? "true" : "false");
+    allChip.title = showingAll ? `All ${noun} shown` : `Show all ${noun}`;
+    allChip.innerHTML = `<span class="map-locator-chip-text">All</span>`;
+    container.appendChild(allChip);
     for (const item of items) {
       const btn = document.createElement("button");
       btn.type = "button";
       btn.className = "map-locator-chip";
       const isActive = kind === "source" ? !!mapFilter[item.key as MapFilterKey] : !!selectedSet?.has(item.key);
-      if (kind === "source" && noneSelected) {
+      // Nothing is filtered out yet, so no chip is dimmed as if it were.
+      if (showingAll) {
         btn.classList.add("is-default");
       } else if (!isActive) {
         btn.classList.add("is-inactive");
       }
+      btn.setAttribute("aria-pressed", !showingAll && isActive ? "true" : "false");
       btn.dataset.filterKind = kind;
       btn.dataset.filterKey = item.key;
       btn.style.setProperty("--chip-color", item.color);
       btn.innerHTML = `<span class="map-locator-chip-text">${escapeMapHtml(item.label)}</span>`;
       container.appendChild(btn);
     }
-    if (helperText) {
-      const hint = document.createElement("span");
-      hint.className = "map-locator-empty";
-      hint.textContent = helperText;
-      container.appendChild(hint);
-    }
   }
 
   function renderMapLocatorPhaseRow(container: HTMLElement, phase: "band" | "type"): void {
@@ -1233,11 +1240,12 @@ const mapWindow = window as unknown as MapWindow;
     if (!phaseEl || !choiceEl || !choiceLabelEl) return;
 
     renderMapLocatorPhaseRow(phaseEl, mapLocatorFilter.phase);
+    // The phase buttons next door already name the dimension; "Show" is the
+    // rest of the sentence, and it keeps the bar's labels a uniform width.
+    choiceLabelEl.textContent = "Show";
     if (mapLocatorFilter.phase === "band") {
-      choiceLabelEl.textContent = "Visible Bands";
       renderMapLocatorChipRow(choiceEl, bandItems, mapLocatorFilter.bands, "band");
     } else {
-      choiceLabelEl.textContent = "Visible Sources";
       renderMapLocatorChipRow(choiceEl, sourceItems, null, "source");
     }
     syncLocatorMarkerStyles();
@@ -1636,7 +1644,10 @@ const mapWindow = window as unknown as MapWindow;
   function applyMapOverlayPanelVisibility() {
     const panel = document.querySelector("#map-stage .map-overlay-panel");
     if (!panel) return;
-    panel.classList.toggle("is-hidden", !mapOverlayPanelVisible);
+    // Only the filters collapse. The bar itself stays, because it carries the
+    // button that brings them back.
+    panel.classList.toggle("filters-hidden", !mapOverlayPanelVisible);
+    panel.querySelector(".map-overlay-filters")?.classList.toggle("is-hidden", !mapOverlayPanelVisible);
   }
 
   function updateMapOverlayToggleButton() {
@@ -1859,7 +1870,14 @@ const mapWindow = window as unknown as MapWindow;
         const kind = String(chip.dataset.filterKind || "");
         const key = String(chip.dataset.filterKey || "");
         if (!key) return;
-        if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
+        if (key === MAP_FILTER_ALL_KEY) {
+          // Back to no selection at all, which is what shows everything.
+          if (kind === "source") {
+            for (const srcKey of Object.keys(DEFAULT_MAP_SOURCE_FILTER) as MapFilterKey[]) mapFilter[srcKey] = false;
+          } else {
+            mapLocatorFilter.bands.clear();
+          }
+        } else if (kind === "source" && Object.prototype.hasOwnProperty.call(mapFilter, key)) {
           // toggle the clicked source; when none are selected everything is shown
           const sourceKey = key as MapFilterKey;
           mapFilter[sourceKey] = !mapFilter[sourceKey];
@@ -1980,48 +1998,43 @@ const mapWindow = window as unknown as MapWindow;
       if (aprsMap) aprsMap.invalidateSize();
       return;
     }
+    // Everything below is the windowed path — the fullscreen branch returned.
+    // The map tab is a whole page, so the stage fills the column down to the
+    // footer.  Capping it at a fraction of the viewport, or at a width-derived
+    // aspect ratio, left a dead band under the map that grew with the window
+    // (and on narrow screens made the map barely a third of the page).
     const mapRect = mapContainer.getBoundingClientRect();
-    const width = mapContainer.clientWidth || mapRect.width;
     const footer = document.querySelector(".footer");
-    let bottom = mapIsFullscreen() && stage
+    let bottom = window.innerHeight;
-      ? stage.getBoundingClientRect().bottom
+    if (footer) {
-      : window.innerHeight;
-    if (!mapIsFullscreen() && 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 target = Math.max(0, Math.floor(bottom - mapRect.top - 8));
-    const widthDriven = width > 0 ? Math.floor(width / 1.55) : available;
-    const viewportCap = mapIsFullscreen()
-      ? Math.floor(window.innerHeight * 0.9)
-      : Math.floor(window.innerHeight * 0.75);
-    const minHeight = Math.min(260, available);
-    const target = Math.max(minHeight, Math.min(available, viewportCap, widthDriven));
     mapContainer.style.height = `${target}px`;
     if (aprsMap) aprsMap.invalidateSize();
   }
 
   function aprsSymbolIcon(symbolTable: string, symbolCode: string): Leaflet.DivIcon | null {
     if (!symbolTable || !symbolCode) return null;
-    const table = symbolTable === "/" ? "primary" : "alternate";
+    const sprite = aprsSymbolSprite(symbolTable, symbolCode);
+    const html = sprite
+      ? `<div class="aprs-symbol aprs-symbol-marker ${sprite.className}" role="img"` +
+        ` style="background-position:${sprite.backgroundPosition}"` +
+        ` title="${escapeMapHtml(sprite.label)}" aria-label="${escapeMapHtml(sprite.label)}"></div>`
+      : `<div class="aprs-symbol aprs-symbol-marker aprs-symbol-local" title="${symbolTable === "/" ? "primary" : "alternate"} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`;
     return L.divIcon({
       className: "",
-      html: `<div class="aprs-symbol-local" title="${table} APRS symbol ${escapeMapHtml(symbolCode)}">${escapeMapHtml(symbolCode)}</div>`,
+      html,
       iconSize: [24, 24],
       iconAnchor: [12, 12],
       popupAnchor: [0, -12]
     });
   }
 
-  mapWindow.navigateToAprsMap = function(lat, lon) {
+  function focusMapPosition(lat: number, lon: number) {
-    // Activate the map tab
-    T._activeTab = "map";
-    document.querySelectorAll(".tab-bar .tab").forEach((t) => { t.classList.remove("active"); });
-    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
-    if (mapTabBtn) mapTabBtn.classList.add("active");
-    document.querySelectorAll<HTMLElement>(".tab-panel").forEach((p) => (p.style.display = "none"));
-    const mapPanel = mapEl("tab-map");
-    if (mapPanel) mapPanel.style.display = "";
     initAprsMap();
     sizeAprsMapToViewport();
     if (aprsMap) {
@@ -2033,20 +2046,12 @@ const mapWindow = window as unknown as MapWindow;
         });
       });
     }
-  };
+  }
 
-  mapWindow.navigateToMapLocator = function(grid, preferredType = null) {
+  function focusMapLocator(grid: string, preferredType: string | null = null) {
     const normalizedGrid = String(grid || "").trim().toUpperCase();
     if (!/^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalizedGrid)) return false;
 
-    T._activeTab = "map";
-    document.querySelectorAll(".tab-bar .tab").forEach((t) => { t.classList.remove("active"); });
-    const mapTabBtn = document.querySelector(".tab-bar .tab[data-tab='map']");
-    if (mapTabBtn) mapTabBtn.classList.add("active");
-    document.querySelectorAll<HTMLElement>(".tab-panel").forEach((p) => (p.style.display = "none"));
-    const mapPanel = mapEl("tab-map");
-    if (mapPanel) mapPanel.style.display = "";
-
     initAprsMap();
     sizeAprsMapToViewport();
     if (!aprsMap) return false;
@@ -2096,7 +2101,7 @@ const mapWindow = window as unknown as MapWindow;
       requestAnimationFrame(focusMarker);
     });
     return true;
-  };
+  }
 
 
 
@@ -2593,18 +2598,26 @@ const mapWindow = window as unknown as MapWindow;
     syncDecodeContactPathVisibility();
   }
 
+  // The buttons light up when they are on, so the label need not repeat it —
+  // an "On"/"Off" suffix on each cost the bar most of a row.
   function updateMapContactPathsToggle() {
     const btn = mapEl("map-contact-paths-toggle");
     if (!btn) return;
-    btn.textContent = mapDecodeContactPathsEnabled ? "Contact Paths On" : "Contact Paths Off";
     btn.classList.toggle("is-active", mapDecodeContactPathsEnabled);
+    btn.setAttribute("aria-pressed", mapDecodeContactPathsEnabled ? "true" : "false");
+    btn.title = mapDecodeContactPathsEnabled
+      ? "Directed decode paths are drawn when the target locator is known"
+      : "Directed decode paths are hidden";
   }
 
   function updateMapP2pPathsToggle() {
     const btn = mapEl("map-p2p-paths-toggle");
     if (!btn) return;
-    btn.textContent = mapP2pRadioPathsEnabled ? "TRX Paths On" : "TRX Paths Off";
     btn.classList.toggle("is-active", mapP2pRadioPathsEnabled);
+    btn.setAttribute("aria-pressed", mapP2pRadioPathsEnabled ? "true" : "false");
+    btn.title = mapP2pRadioPathsEnabled
+      ? "TRX paths are drawn from a station popup"
+      : "TRX paths are hidden";
   }
 
   function scheduleDecodeMapMaintenance() {
@@ -2807,7 +2820,7 @@ const mapWindow = window as unknown as MapWindow;
         selectedMapQsoKey = selectedMapQsoKey === entry.pathKey ? null : entry.pathKey ?? null;
         syncDecodeContactPathVisibility();
         if (selectedMapQsoKey && entry.sourceGrid) {
-          mapWindow.navigateToMapLocator?.(entry.sourceGrid, entry.sourceType);
+          focusMapLocator(entry.sourceGrid, entry.sourceType);
         }
       });
 
@@ -2934,7 +2947,7 @@ const mapWindow = window as unknown as MapWindow;
       card.className = "map-qso-card";
       if (entry.grid) {
         card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
         });
       }
 
@@ -3060,7 +3073,7 @@ const mapWindow = window as unknown as MapWindow;
       card.className = "map-qso-card";
       if (entry.grid) {
         card.addEventListener("click", () => {
-          mapWindow.navigateToMapLocator?.(entry.grid ?? "", entry.sourceType);
+          focusMapLocator(entry.grid ?? "", entry.sourceType);
         });
       }
 
@@ -3624,6 +3637,8 @@ const mapWindow = window as unknown as MapWindow;
   // Register module API for core to call
   modules.map = {
     initAprsMap,
+    focusMapPosition,
+    focusMapLocator,
     sizeAprsMapToViewport,
     syncAprsReceiverMarker,
     updateMapRigFilter,
@@ -3673,6 +3688,18 @@ const mapWindow = window as unknown as MapWindow;
     reverseGeocodeLocation,
   };
 
+  // Everything the decoders already hold goes onto the map now. This module is
+  // lazy -- it arrives when the Map tab is first opened, long after startup
+  // restored the decode history -- and until it does, aprsMapAddStation and
+  // friends are undefined, so every restored position was dropped on the floor.
+  // The map then showed only what arrived live after it loaded, which is why it
+  // took a second reload (with the module cached, and so loaded early enough to
+  // win the race against the history fetch) for the stations to appear.
+  //
+  // The add functions are keyed by callsign/MMSI/point, so replaying costs
+  // nothing on a second call and cannot duplicate a marker.
+  (window as unknown as PluginRuntimeWindow).trxPluginRuntime.syncMapAll();
+
   // If the map tab is already visible (direct /map URL), init immediately.
   autoInitIfVisible();
 })();

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugin-loader.ts

@@ -5,7 +5,14 @@
 type PluginGroup = "digital-modes" | "map-data" | "map" | "statistics" | "bookmarks" | "recorder" | "settings";
 
 const pluginGroups: Readonly<Record<PluginGroup, readonly string[]>> = {
-  "digital-modes": ["/ft8.js", "/ft4.js", "/ft2.js", "/wspr.js", "/cw.js", "/background-decode.js", "/sat.js", "/wefax.js"],
+  // AIS, VDES and the two APRS decoders have panels on this tab, so they load
+  // with it. They used to come only with the map group, which left their
+  // sub-tabs empty — decodes queueing in the runtime — until something opened
+  // the Map tab. Their map calls are optional, so map-core stays lazy.
+  "digital-modes": [
+    "/ft8.js", "/ft4.js", "/ft2.js", "/wspr.js", "/cw.js", "/background-decode.js",
+    "/sat.js", "/wefax.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js",
+  ],
   "map-data": ["/map-core.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js"],
   map: ["/map-core.js", "/ais.js", "/vdes.js", "/aprs.js", "/hf-aprs.js", "/sat.js", "/sat-scheduler.js"],
   statistics: ["/map-core.js"],
@@ -36,21 +43,10 @@ async function loadPlugins(group: string): Promise<void> {
   for (const path of pluginGroups[group as PluginGroup]) await loadPlugin(path);
 }
 
-function requestPlugins(group: string): void {
+export async function loadEagerPlugins(): Promise<void> {
-  void loadPlugins(group).catch((error: unknown) => { console.error(error); });
+  await Promise.all(["digital-modes", "bookmarks", "settings"].map(loadPlugins));
 }
 
-const loaderWindow = window as typeof window & {
+export async function loadPluginsForTab(tab: string): Promise<void> {
-  loadEagerPlugins?: () => Promise<void>;
+  await loadPlugins(tab);
-  loadPluginsForTab?: (tab: string) => Promise<void>;
+}
-};
-loaderWindow.loadEagerPlugins = async () => {
-  await Promise.all(["digital-modes", "map-data", "bookmarks", "settings"].map(loadPlugins));
-};
-loaderWindow.loadPluginsForTab = loadPlugins;
-
-document.addEventListener("click", (event) => {
-  if (!(event.target instanceof Element)) return;
-  const tab = event.target.closest<HTMLElement>("[data-tab]")?.dataset.tab;
-  if (tab) requestPlugins(tab);
-});

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugin-runtime.ts

@@ -81,6 +81,7 @@ const runtime: TrxPluginRuntime = {
     plugin.prune();
     return true;
   },
+  syncMapAll() { for (const plugin of decoders.values()) plugin.syncMap?.(); },
   clearQueued() { queued.clear(); },
   hasDecoder: (id) => decoders.has(id),
 };

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

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
 export {};
 
 import type { PluginRuntimeWindow } from "./runtime-contract";
@@ -25,24 +27,18 @@ interface AisMessage {
 }
 interface AisChannelInfo { label: string; badgeClass: string; freqText: string }
 interface AisBridge {
+  navigateToAprsMap?: (lat: number, lon: number) => void;
   getDecodeHistoryRetentionMs?: () => number;
   trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
-  escapeMapHtml?: (input: string) => string;
   buildAisVesselUrl?: (mmsi: number | null | undefined) => string | null;
-  serverLat?: number | null;
-  serverLon?: number | null;
-  haversineKm?: (lat1: number, lon1: number, lat2: number, lon2: number) => number;
   aisMapAddVessel?: (message: AisMessage) => void;
   clearMapMarkersByType?: (type: string) => void;
-  postPath?: (path: string) => Promise<unknown>;
   trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
   updateAisBar?: () => void;
   clearAisBar?: () => void;
 }
 const aisWindow = window as unknown as AisBridge;
-const escapeAisHtml = (input: string): string => aisWindow.escapeMapHtml?.(input) ?? input
+const escapeAisHtml = (input: string): string => hostCore.escapeMapHtml(input);
-  .replaceAll("&", "&amp;").replaceAll("<", "&lt;")
-  .replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 
 // --- AIS Decoder Plugin (server-side decode) ---
 const aisStatus = document.getElementById("ais-status");
@@ -176,10 +172,10 @@ function aisRouteText(msg: AisMessage): string {
 }
 
 function aisDistanceText(msg: AisMessage): string {
-  if (aisWindow.serverLat == null || aisWindow.serverLon == null || msg.lat == null || msg.lon == null || !aisWindow.haversineKm) {
+  if (hostState.serverLat == null || hostState.serverLon == null || msg.lat == null || msg.lon == null) {
     return "";
   }
-  const distKm = aisWindow.haversineKm(aisWindow.serverLat, aisWindow.serverLon, msg.lat, msg.lon);
+  const distKm = hostCore.haversineKm(hostState.serverLat, hostState.serverLon, msg.lat, msg.lon);
   if (!Number.isFinite(distKm)) return "";
   if (distKm < 1) return `${Math.round(distKm * 1000)} m from TRX`;
   return `${distKm.toFixed(1)} km from TRX`;
@@ -217,8 +213,21 @@ function updateAisSummary() {
   }
 }
 
+/** What the message says, in one line: where the vessel is and what it is
+ *  doing, or — for the static reports that carry no fix — where it is going. */
+function aisSummaryText(msg: AisMessage): string {
+  const parts: string[] = [];
+  if (msg.lat != null && msg.lon != null) parts.push(`${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}`);
+  const motion = aisMotionText(msg);
+  if (motion) parts.push(motion);
+  const route = aisRouteText(msg);
+  if (route && parts.length < 2) parts.push(route);
+  if (!parts.length) return route || "no position reported";
+  return parts.join(" · ");
+}
+
 function renderAisRow(msg: AisMessage): HTMLElement {
-  const row = document.createElement("div");
+  const row = document.createElement("details");
   row.className = "ais-message";
   const ts = msg._ts || new Date().toLocaleTimeString([], {
     hour: "2-digit",
@@ -232,8 +241,9 @@ function renderAisRow(msg: AisMessage): HTMLElement {
   const route = aisRouteText(msg);
   const distance = aisDistanceText(msg);
   const pos = msg.lat != null && msg.lon != null
-    ? `<a class="ais-pos-link" href="javascript:void(0)" onclick="window.navigateToAprsMap(${msg.lat},${msg.lon})">${msg.lat.toFixed(4)}, ${msg.lon.toFixed(4)}</a>`
+    ? `<a class="ais-pos-link" href="javascript:void(0)" data-ais-map="${msg.lat},${msg.lon}">${msg.lat.toFixed(5)}, ${msg.lon.toFixed(5)}</a>`
     : "";
+  const vesselUrl = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
   row.dataset.filterText = [
     name,
     msg.mmsi,
@@ -248,23 +258,43 @@ function renderAisRow(msg: AisMessage): HTMLElement {
     .join(" ")
     .toUpperCase();
   row.innerHTML =
-    `<div class="ais-row-head">` +
+    `<summary class="decode-line">` +
-      `<span class="ais-time">${ts}</span>` +
+      `<span class="ais-time">${escapeAisHtml(ts)}</span>` +
       `<span class="ais-call">${nameHtml}</span>` +
-      `<span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span>` +
       `<span class="ais-badge ais-badge-type">${escapeAisHtml(aisTypeLabel(msg.message_type))}</span>` +
-    `</div>` +
+      `<span class="decode-line-summary">${escapeAisHtml(aisSummaryText(msg))}</span>` +
-    `<div class="ais-row-meta">` +
+      `<span class="${channel.badgeClass}">${escapeAisHtml(channel.label)}</span>` +
+      (distance ? `<span class="decode-line-distance">${escapeAisHtml(distance)}</span>` : "") +
+    `</summary>` +
+    `<div class="decode-expanded">` +
+      `<div class="decode-expanded-meta">` +
         `<span>MMSI ${escapeAisHtml(String(msg.mmsi))}</span>` +
-      (route ? `<span class="ais-meta-text">${escapeAisHtml(route)}</span>` : "") +
+        `<span>${escapeAisHtml(channel.freqText)}</span>` +
-      `<span class="ais-meta-text">${escapeAisHtml(channel.freqText)}</span>` +
+        (route ? `<span>${escapeAisHtml(route)}</span>` : "") +
-    `</div>` +
+        (motion ? `<span>${escapeAisHtml(motion)}</span>` : "") +
-    `<div class="ais-row-detail">` +
-      (motion ? `<span>${escapeAisHtml(motion)}</span>` : `<span>No motion data</span>`) +
-      (distance ? `<span>${escapeAisHtml(distance)}</span>` : "") +
-      (pos ? `<span>${pos}</span>` : "") +
         `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span>` +
+        (pos ? `<span>${pos}</span>` : "") +
+      `</div>` +
+      `<div class="aprs-row-actions">` +
+        (msg.lat != null && msg.lon != null
+          ? `<button class="aprs-inline-btn" type="button" data-ais-map="${msg.lat},${msg.lon}">Map</button>`
+          : "") +
+        (vesselUrl
+          ? `<a class="aprs-inline-btn" href="${escapeAisHtml(vesselUrl)}" target="_blank" rel="noopener">Vessel</a>`
+          : "") +
+      `</div>` +
     `</div>`;
+
+  row.querySelectorAll<HTMLElement>("[data-ais-map]").forEach((element) => {
+    element.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const [lat, lon] = (element.dataset.aisMap ?? "").split(",").map(Number);
+      if (lat == null || lon == null || !Number.isFinite(lat) || !Number.isFinite(lon)) return;
+      aisWindow.navigateToAprsMap?.(lat, lon);
+    });
+  });
+
   applyAisFilterToRow(row);
   return row;
 }
@@ -359,9 +389,13 @@ function addAisMessage(msg: AisMessage): void {
   scheduleAisBarUpdate();
   scheduleAisHistoryRender();
 
-  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
+  plotAisMessage(msg);
-    aisWindow.aisMapAddVessel(msg);
 }
+
+/** Hands a positioned message to the map, if the map module is loaded yet. */
+function plotAisMessage(msg: AisMessage): void {
+  if (msg.lat == null || msg.lon == null || !aisWindow.aisMapAddVessel) return;
+  aisWindow.aisMapAddVessel(msg);
 }
 
 function normalizeServerAisMessage(msg: AisMessage): AisMessage {
@@ -384,9 +418,7 @@ function onServerAisBatch(messages: AisMessage[]): void {
       minute: "2-digit",
       second: "2-digit",
     });
-    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
+    plotAisMessage(next);
-      aisWindow.aisMapAddVessel(next);
-    }
     normalized.push(next);
   }
   normalized.reverse();
@@ -405,7 +437,7 @@ function pruneAisHistoryView(): void {
 document.getElementById("settings-clear-ais-history")?.addEventListener("click", () => { void (async () => {
   if (!await aisWindow.trxUi.confirm({ title: "Clear AIS history?", message: "All stored AIS messages will be permanently removed.", confirmLabel: "Clear history" })) return;
   try {
-    await aisWindow.postPath?.("/clear_ais_decode");
+    await hostCore.postPath("/clear_ais_decode");
     resetAisHistoryView();
   } catch (e) {
     console.error("AIS history clear failed", e);
@@ -432,4 +464,6 @@ updateAisSummary();
   restore: onServerAisBatch,
   reset: resetAisHistoryView,
   prune: pruneAisHistoryView,
+  // Oldest first, so vessel tracks are rebuilt in the order they happened.
+  syncMap: () => { for (const entry of [...aisMessageHistory].reverse()) plotAisMessage(entry); },
 });

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

@@ -30,6 +30,14 @@ export interface AprsPacket {
   symbol_code?: string | null;
 }
 
+function escapeAprsHtml(value: string): string {
+  return String(value ?? "")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
 export function aprsPacketCategory(packet: AprsPacket): AprsCategory {
   const type = (packet.type ?? "").toLowerCase();
   const info = (packet.info ?? "").toLowerCase();
@@ -108,8 +116,87 @@ function escapeAprsCharacter(character: string): string {
   return character;
 }
 
+// The vendored sprite sheets (assets/web/vendor/aprs-symbols-24-*.png) are
+// 16x6 grids of 24px cells covering the printable codes 0x21..0x7E, so a
+// symbol's cell index is simply `code - 0x21`.  The sheet URLs live in CSS so
+// the retina variants can be picked up by a media query; only the cell offsets
+// are computed here.
+const APRS_SPRITE_COLUMNS = 16;
+const APRS_SPRITE_CELL_PX = 24;
+const APRS_SPRITE_FIRST_CODE = 0x21;
+const APRS_SPRITE_LAST_CODE = 0x7e;
+
+export interface AprsSymbolSprite {
+  /** Sheet modifier class appended to `.aprs-symbol`. */
+  className: string;
+  /** `background-position` covering the overlay layer first, if any. */
+  backgroundPosition: string;
+  /** Human-readable description for the tooltip. */
+  label: string;
+}
+
+function aprsSpriteOffset(code: string): string | null {
+  if (code.length !== 1) return null;
+  const point = code.charCodeAt(0);
+  if (point < APRS_SPRITE_FIRST_CODE || point > APRS_SPRITE_LAST_CODE) return null;
+  const index = point - APRS_SPRITE_FIRST_CODE;
+  const column = index % APRS_SPRITE_COLUMNS;
+  const row = Math.floor(index / APRS_SPRITE_COLUMNS);
+  return `${String(-column * APRS_SPRITE_CELL_PX)}px ${String(-row * APRS_SPRITE_CELL_PX)}px`;
+}
+
+/**
+ * Resolve an APRS table/code pair to a sprite cell.  A table identifier of `/`
+ * selects the primary sheet and `\` the alternate one; any other character is
+ * an overlay, which draws that character from the overlay sheet on top of the
+ * alternate symbol.  Returns null when the pair is outside the sprite sheets,
+ * leaving callers to fall back to the raw character.
+ */
+export function aprsSymbolSprite(
+  symbolTable: string | null | undefined,
+  symbolCode: string | null | undefined,
+): AprsSymbolSprite | null {
+  if (!symbolTable || !symbolCode) return null;
+  const symbolOffset = aprsSpriteOffset(symbolCode);
+  if (!symbolOffset) return null;
+  if (symbolTable === "/") {
+    return {
+      className: "aprs-symbol-primary",
+      backgroundPosition: symbolOffset,
+      label: `Primary APRS symbol ${symbolTable}${symbolCode}`,
+    };
+  }
+  if (symbolTable === "\\") {
+    return {
+      className: "aprs-symbol-alternate",
+      backgroundPosition: symbolOffset,
+      label: `Alternate APRS symbol ${symbolTable}${symbolCode}`,
+    };
+  }
+  const overlayOffset = aprsSpriteOffset(symbolTable);
+  if (!overlayOffset) return null;
+  return {
+    className: "aprs-symbol-overlaid",
+    backgroundPosition: `${overlayOffset}, ${symbolOffset}`,
+    label: `Alternate APRS symbol \\${symbolCode} with overlay ${symbolTable}`,
+  };
+}
+
+/** An empty slot of the symbol's size, so a frame without one still lines up
+ *  with the frames around it in the list. */
+export function renderAprsSymbolSlot(packet: AprsPacket, escapeHtml: (value: string) => string): string {
+  return renderLocalAprsSymbol(packet, escapeHtml)
+    || '<span class="aprs-symbol aprs-symbol-empty" aria-hidden="true"></span>';
+}
+
 export function renderLocalAprsSymbol(packet: AprsPacket, escapeHtml: (value: string) => string): string {
   if (!packet.symbolTable || !packet.symbolCode) return "";
+  const sprite = aprsSymbolSprite(packet.symbolTable, packet.symbolCode);
+  if (sprite) {
+    return `<span class="aprs-symbol ${sprite.className}" role="img"` +
+      ` style="background-position:${sprite.backgroundPosition}"` +
+      ` title="${escapeHtml(sprite.label)}" aria-label="${escapeHtml(sprite.label)}"></span>`;
+  }
   const symbol = escapeHtml(packet.symbolCode);
   const table = packet.symbolTable === "/" ? "Primary" : "Alternate";
   return `<span class="aprs-symbol aprs-symbol-local" title="${table} APRS symbol ${symbol}">${symbol}</span>`;
@@ -133,3 +220,174 @@ export function normalizeAprsPacket(packet: AprsPacket, receiver: unknown): Aprs
     symbolCode: packet.symbol_code ?? null,
   };
 }
+
+// ── Payload summaries ──────────────────────────────────────────────────────
+// APRS packs its meaning into the information field with a set of one-character
+// type identifiers and fixed-width encodings (APRS 1.0.1, chapters 6-15).  The
+// list showed that field as it arrives on the air, so reading a weather report
+// meant decoding "_10090556c220s004g005t077..." by eye.  These produce a line
+// of plain text for the common types and leave the raw field to the expanded
+// view, which is still the authority when a summary cannot be made.
+
+/** `t077` → 25.0 °C. APRS carries temperature in whole degrees Fahrenheit. */
+function fahrenheitToCelsius(fahrenheit: number): number {
+  return Math.round(((fahrenheit - 32) * 5 / 9) * 10) / 10;
+}
+
+/** Weather report fields: wind, gust, temperature, rain, humidity, pressure. */
+function summarizeAprsWeather(info: string): string | null {
+  const parts: string[] = [];
+  const temperature = /t(-?\d{2,3})/.exec(info);
+  if (temperature) parts.push(`${fahrenheitToCelsius(Number(temperature[1]))} °C`);
+  const wind = /(\d{3})\/(\d{3})/.exec(info) ?? /c(\d{3}).*?s(\d{3})/.exec(info);
+  if (wind) {
+    const gust = /g(\d{3})/.exec(info);
+    const knots = Number(wind[2]);
+    parts.push(`wind ${Number(wind[1])}° ${knots} kt${gust ? ` gust ${Number(gust[1])}` : ""}`);
+  }
+  const humidity = /h(\d{2})/.exec(info);
+  if (humidity) {
+    const value = Number(humidity[1]);
+    parts.push(`${value === 0 ? 100 : value}% RH`);
+  }
+  const pressure = /b(\d{5})/.exec(info);
+  if (pressure) parts.push(`${(Number(pressure[1]) / 10).toFixed(1)} hPa`);
+  const rain = /r(\d{3})/.exec(info);
+  if (rain && Number(rain[1]) > 0) parts.push(`rain ${(Number(rain[1]) / 100).toFixed(2)}"`);
+  return parts.length ? parts.join(" · ") : null;
+}
+
+/** `T#005,199,000,255,073,123,01101001` → sequence, five channels, eight bits. */
+function summarizeAprsTelemetry(info: string): string | null {
+  const match = /^T#(\d+|MIC)((?:,-?[\d.]*)+)(?:,([01]{8}))?/.exec(info.trim());
+  if (!match?.[2]) return null;
+  const channels = match[2].split(",").filter((value) => value.length > 0);
+  const bits = match[3] ? ` · bits ${match[3]}` : "";
+  return `#${match[1]} · ${channels.join(" ")}${bits}`;
+}
+
+/** `:DEST     :text{01` → addressed message text. */
+function summarizeAprsMessage(info: string): string | null {
+  const match = /^:([^:]{9}):(.*)$/.exec(info);
+  if (!match?.[1] || match[2] == null) return null;
+  const addressee = match[1].trim();
+  const text = match[2].replace(/\{\d+\s*$/, "").trim();
+  return `→ ${addressee}: ${text}`;
+}
+
+/** Course/speed appended to a position, as `088/036`. */
+function summarizeAprsCourseSpeed(info: string): string | null {
+  const match = /(\d{3})\/(\d{3})/.exec(info);
+  if (!match) return null;
+  const knots = Number(match[2]);
+  if (knots === 0) return null;
+  return `${Number(match[1])}° ${knots} kt`;
+}
+
+/** Whatever a frame is worth saying in one line, or null to fall back to raw. */
+export function summarizeAprsPayload(packet: AprsPacket): string | null {
+  const info = packet.info ?? "";
+  if (!info) return null;
+  const category = aprsPacketCategory(packet);
+  if (category === "message") return summarizeAprsMessage(info);
+  if (category === "weather") return summarizeAprsWeather(info);
+  if (category === "telemetry") return summarizeAprsTelemetry(info);
+  if (category === "position") {
+    const parts: string[] = [];
+    if (packet.lat != null && packet.lon != null) {
+      parts.push(`${packet.lat.toFixed(4)}, ${packet.lon.toFixed(4)}`);
+    }
+    const courseSpeed = summarizeAprsCourseSpeed(info);
+    if (courseSpeed) parts.push(courseSpeed);
+    // Whatever the station wrote after the position report.
+    const comment = info.replace(/^[!=@/][^>]*[>_]?/, "").replace(/\d{3}\/\d{3}/, "").trim();
+    if (comment && comment.length <= 60) parts.push(comment);
+    return parts.length ? parts.join(" · ") : null;
+  }
+  // Status and anything else: the text it carries, minus its type character.
+  const text = info.replace(/^[>;<?]/, "").trim();
+  return text.length ? text : null;
+}
+
+// ── Frame row ──────────────────────────────────────────────────────────────
+// Shared by the APRS and HF APRS lists, which had a copy each of the same
+// forty lines of markup and drifted only by one badge.
+
+export interface AprsRowOptions {
+  /** Marks the newest frame so it can flash on arrival. */
+  fresh?: boolean;
+  /** Leading badge, e.g. the band a copy of this list is dedicated to. */
+  badge?: string;
+  /** Distance from the receiver, already formatted, or "" to leave it out. */
+  distance?: string;
+  /** Opens the map on a frame's position. */
+  onMap?: (lat: number, lon: number) => void;
+  /** Puts a frame's coordinates on the clipboard. */
+  onCopy?: (text: string, button: HTMLElement) => void;
+}
+
+export function renderAprsPacketRow(packet: AprsPacket, options: AprsRowOptions = {}): HTMLElement {
+  const row = document.createElement("details");
+  row.className = "aprs-packet";
+  if (!packet.crcOk) row.classList.add("aprs-packet-crc");
+  if (options.fresh) row.classList.add("aprs-packet-new");
+
+  const time = packet._ts
+    || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  const category = aprsPacketCategory(packet);
+  const summary = summarizeAprsPayload(packet);
+  const hasPosition = packet.lat != null && packet.lon != null;
+  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(packet.srcCall || "")}`;
+
+  row.innerHTML =
+    `<summary class="decode-line">` +
+      `<span class="aprs-time">${escapeAprsHtml(time)}</span>` +
+      (options.badge ? `<span class="aprs-badge aprs-badge-band">${escapeAprsHtml(options.badge)}</span>` : "") +
+      renderAprsSymbolSlot(packet, escapeAprsHtml) +
+      `<span class="aprs-call">${escapeAprsHtml(packet.srcCall ?? "")}</span>` +
+      `<span class="aprs-badge aprs-badge-type aprs-badge-type-${category}">` +
+        `${escapeAprsHtml(aprsCategoryLabel(category))}</span>` +
+      `<span class="decode-line-summary">${summary ? escapeAprsHtml(summary) : renderAprsInfo(packet)}</span>` +
+      (packet.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC</span>') +
+      (options.distance ? `<span class="decode-line-distance">${escapeAprsHtml(options.distance)}</span>` : "") +
+    `</summary>` +
+    `<div class="decode-expanded">` +
+      `<div class="decode-expanded-meta">` +
+        `<span>&gt;${escapeAprsHtml(packet.destCall || "--")}</span>` +
+        `<span>${escapeAprsHtml(packet.path || "no path")}</span>` +
+        `<span>${escapeAprsHtml(aprsAgeText(packet._tsMs))}</span>` +
+        `<span>CRC ${packet.crcOk ? "ok" : "failed"}</span>` +
+        (hasPosition
+          ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${packet.lat},${packet.lon}">`
+            + `${packet.lat?.toFixed(5)}, ${packet.lon?.toFixed(5)}</a>`
+          : "") +
+      `</div>` +
+      `<div class="decode-expanded-raw">${renderAprsInfo(packet)}</div>` +
+      (packet.info_bytes?.length
+        ? `<div class="decode-expanded-bytes">${escapeAprsHtml(aprsHexBytes(packet.info_bytes))}</div>`
+        : "") +
+      `<div class="aprs-row-actions">` +
+        (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${packet.lat},${packet.lon}">Map</button>` : "") +
+        (hasPosition ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${packet.lat},${packet.lon}">Copy Coords</button>` : "") +
+        `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
+      `</div>` +
+    `</div>`;
+
+  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((element) => {
+    element.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const [lat, lon] = (element.dataset.aprsMap ?? "").split(",").map(Number);
+      if (Number.isFinite(lat) && Number.isFinite(lon)) options.onMap?.(lat as number, lon as number);
+    });
+  });
+  const copyButton = row.querySelector<HTMLElement>("[data-aprs-copy]");
+  if (copyButton) {
+    copyButton.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      options.onCopy?.(copyButton.dataset.aprsCopy ?? "", copyButton);
+    });
+  }
+  return row;
+}

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

@@ -2,15 +2,14 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
 import {
   aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
   aprsPacketCategory,
   collapseAprsDuplicates,
   normalizeAprsPacket,
-  renderAprsInfo,
+  renderAprsPacketRow,
-  renderLocalAprsSymbol,
   type AprsPacket,
   type AprsTypeFilter,
 } from "./aprs-shared";
@@ -18,26 +17,18 @@ import type { PluginRuntimeWindow } from "./runtime-contract";
 interface AprsBridge {
   getDecodeHistoryRetentionMs?: () => number;
   trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
-  serverLat?: number | null;
-  serverLon?: number | null;
-  haversineKm?: (lat1: number, lon1: number, lat2: number, lon2: number) => number;
-  escapeMapHtml?: (input: string) => string;
   navigateToAprsMap?: (lat: number, lon: number) => void;
-  showHint?: (message: string, durationMs: number) => void;
   clearMapMarkersByType?: (type: string) => void;
   aprsMapAddStation?: (call: string, lat: number, lon: number, info: string, symbolTable: string | null | undefined, symbolCode: string | null | undefined, packet: AprsPacket) => void;
   getDecodeRigMeta?: () => unknown;
-  postPath?: (path: string) => Promise<unknown>;
   trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
   updateAprsBar?: () => void;
   clearAprsBar?: () => void;
   closeAprsBar?: () => void;
 }
 const aprsWindow = window as unknown as AprsBridge;
-const escapeAprsHtml = (input: string): string => aprsWindow.escapeMapHtml?.(input) ?? input
+const escapeAprsHtml = (input: string): string => hostCore.escapeMapHtml(input);
-  .replaceAll("&", "&amp;").replaceAll("<", "&lt;")
+const showAprsHint = (message: string, durationMs: number): void => { hostCore.showHint(message, durationMs); };
-  .replaceAll(">", "&gt;").replaceAll('"', "&quot;");
-const showAprsHint = (message: string, durationMs: number): void => { aprsWindow.showHint?.(message, durationMs); };
 
 // --- APRS Decoder Plugin (server-side decode) ---
 const aprsStatus = document.getElementById("aprs-status");
@@ -87,8 +78,8 @@ function scheduleAprsBarUpdate() {
 }
 
 function aprsDistanceText(pkt: AprsPacket): string {
-  if (aprsWindow.serverLat == null || aprsWindow.serverLon == null || pkt.lat == null || pkt.lon == null || !aprsWindow.haversineKm) return "";
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
-  const distKm = aprsWindow.haversineKm(aprsWindow.serverLat, aprsWindow.serverLon, pkt.lat, pkt.lon);
+  const distKm = hostCore.haversineKm(hostState.serverLat, hostState.serverLon, pkt.lat, pkt.lon);
   if (!Number.isFinite(distKm)) return "";
   if (distKm < 1) return `${Math.round(distKm * 1000)} m from TRX`;
   return `${distKm.toFixed(1)} km from TRX`;
@@ -147,93 +138,24 @@ function updateAprsChipState() {
   aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }
 
-function renderAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
+async function copyAprsCoords(text: string): Promise<void> {
-  const row = document.createElement("div");
-  row.className = "aprs-packet";
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
-  if (isFresh) row.classList.add("aprs-packet-new");
-
-  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  const age = aprsAgeText(pkt._tsMs);
-  const category = aprsPacketCategory(pkt);
-  const categoryLabel = aprsCategoryLabel(category);
-  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeAprsHtml(pkt.path)}</span>` : "";
-  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-  const symbolHtml = renderLocalAprsSymbol(pkt, escapeAprsHtml);
-  const posLink = pkt.lat != null && pkt.lon != null
-    ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>`
-    : "";
-  const distance = aprsDistanceText(pkt);
-  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
-
-  row.innerHTML =
-    `<div class="aprs-row-head">` +
-      `<span class="aprs-time">${ts}</span>` +
-      symbolHtml +
-      `<span class="aprs-call">${escapeAprsHtml(pkt.srcCall ?? "")}</span>` +
-      `<span>&gt;${escapeAprsHtml(pkt.destCall || "")}</span>` +
-      `<span class="${categoryClass}">${escapeAprsHtml(categoryLabel)}</span>` +
-      pathBadge +
-      crcBadge +
-    `</div>` +
-    `<div class="aprs-row-meta">` +
-      `<span class="aprs-meta-text">${escapeAprsHtml(age)}</span>` +
-      (distance ? `<span class="aprs-meta-text">${escapeAprsHtml(distance)}</span>` : "") +
-      `<span class="aprs-meta-text">${escapeAprsHtml(pkt.type || "--")}</span>` +
-    `</div>` +
-    `<div class="aprs-row-detail">` +
-      `<span title="${escapeAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
-      (posLink ? `<span>${posLink}</span>` : "") +
-    `</div>` +
-    `<div class="aprs-row-actions">` +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") +
-      `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
-    `</div>` +
-    `<details class="aprs-details">` +
-      `<summary>Details</summary>` +
-      `<div class="aprs-details-grid">` +
-        `<span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.srcCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.destCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.type || "--")}</span>` +
-        `<span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.path || "--")}</span>` +
-        `<span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeAprsHtml(age)}</span>` +
-        `<span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span>` +
-        `<span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span>` +
-        `<span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.info || "--")}</span>` +
-        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeAprsHtml(aprsHexBytes(pkt.info_bytes))}</span>` +
-      `</div>` +
-    `</details>`;
-
-  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((el) => {
-    el.addEventListener("click", (evt) => {
-      evt.preventDefault();
-      const raw = el.dataset.aprsMap ?? "";
-      const [lat, lon] = raw.split(",").map(Number);
-      if (aprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
-        aprsWindow.navigateToAprsMap(lat, lon);
-      }
-    });
-  });
-
-  const copyBtn = row.querySelector<HTMLElement>("[data-aprs-copy]");
-  if (copyBtn) {
-    copyBtn.addEventListener("click", () => { void (async () => {
-      const raw = copyBtn.dataset.aprsCopy ?? "";
   try {
     const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
-        if (clipboard) {
+    if (!clipboard) return;
-          await clipboard.writeText(raw);
+    await clipboard.writeText(text);
     showAprsHint("Coordinates copied", 1200);
-        }
   } catch {
     showAprsHint("Copy failed", 1500);
   }
-    })(); });
 }
 
-  return row;
+function renderAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
+  return renderAprsPacketRow(pkt, {
+    fresh: isFresh,
+    distance: aprsDistanceText(pkt),
+    onMap: (lat, lon) => { aprsWindow.navigateToAprsMap?.(lat, lon); },
+    onCopy: (text) => { void copyAprsCoords(text); },
+  });
 }
 
 function renderAprsHistory() {
@@ -307,6 +229,12 @@ function pruneAprsHistoryView(): void {
   renderAprsHistory();
 }
 
+/** Hands a positioned packet to the map, if the map module is loaded yet. */
+function plotAprsPacket(pkt: AprsPacket): void {
+  if (pkt.lat == null || pkt.lon == null || !aprsWindow.aprsMapAddStation) return;
+  aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
+}
+
 function addAprsPacket(pkt: AprsPacket): void {
   const tsMs = Number.isFinite(pkt.ts_ms) ? Number(pkt.ts_ms) : Date.now();
   pkt._tsMs = tsMs;
@@ -315,9 +243,7 @@ function addAprsPacket(pkt: AprsPacket): void {
   aprsPacketHistory.unshift(pkt);
   pruneAprsPacketHistory();
 
-  if (pkt.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
+  plotAprsPacket(pkt);
-    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
-  }
 
   if (pkt.crcOk) scheduleAprsBarUpdate();
 
@@ -338,9 +264,7 @@ function onServerAprsBatch(packets: AprsPacket[]): void {
     const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
     next._tsMs = tsMs;
     next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
+    plotAprsPacket(next);
-      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
-    }
     if (next.crcOk) hasCrcOk = true;
     normalized.push(next);
   }
@@ -354,7 +278,7 @@ function onServerAprsBatch(packets: AprsPacket[]): void {
 document.getElementById("settings-clear-aprs-history")?.addEventListener("click", () => { void (async () => {
   if (!await aprsWindow.trxUi.confirm({ title: "Clear APRS history?", message: "All stored APRS packets will be permanently removed.", confirmLabel: "Clear history" })) return;
   try {
-    await aprsWindow.postPath?.("/clear_aprs_decode");
+    await hostCore.postPath("/clear_aprs_decode");
     resetAprsHistoryView();
   } catch (e) {
     console.error("APRS history clear failed", e);
@@ -412,4 +336,6 @@ renderAprsHistory();
   restore: onServerAprsBatch,
   reset: resetAprsHistoryView,
   prune: pruneAprsHistoryView,
+  // Oldest first, so station tracks are rebuilt in the order they happened.
+  syncMap: () => { for (const entry of [...aprsPacketHistory].reverse()) plotAprsPacket(entry); },
 });

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/background-decode.ts

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostState } from "./host.js";
+
 export {};
 
 interface DecoderDescriptor {
@@ -38,7 +40,6 @@ interface BackgroundDecodeStatus {
 }
 interface BackgroundBridge {
   decoderRegistry?: DecoderDescriptor[];
-  authEnabled?: boolean;
   trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
   trx?: { modules?: { backgroundDecode?: BackgroundDecodeService } };
 }
@@ -170,7 +171,7 @@ const bgdWindow = window as unknown as BackgroundBridge;
     setCheckbox("background-decode-enabled", currentConfig.enabled);
     renderBookmarkChecklist();
 
-    const isControl = backgroundDecodeRole === "control" || bgdWindow.authEnabled === false;
+    const isControl = backgroundDecodeRole === "control" || hostState.authEnabled === false;
     const panel = document.getElementById("background-decode-panel");
     if (panel) {
         panel.querySelectorAll<HTMLInputElement | HTMLSelectElement | HTMLButtonElement>("input, select, button.sch-write").forEach(function (el) {

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

@@ -2,12 +2,12 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
 export {};
 
 /* DOM IDs in the server-owned page are required by this feature; bmEl throws
  * during initialization if that contract is broken. */
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-
 interface Bookmark {
   id: string;
   name: string;
@@ -21,14 +21,6 @@ interface Bookmark {
   scope?: string;
 }
 
-interface DecoderDescriptor {
-  id: string;
-  label: string;
-  activation?: string;
-  active_modes?: string[];
-  bookmark_selectable?: boolean;
-}
-
 interface BookmarkService {
   readonly overlayList: readonly Bookmark[];
   readonly overlayRevision: number;
@@ -45,32 +37,13 @@ interface VirtualChannelService {
   takeSchedulerControl(): Promise<void>;
 }
 
-interface BookmarkBridge extends Window {
+interface BookmarkBridge {
-  authEnabled?: boolean;
+  trx: { modules: { bookmarks?: BookmarkService; vchan?: VirtualChannelService } };
-  authRole?: string | null;
-  lastActiveRigId?: string | null;
-  lastRigIds?: string[];
-  lastRigDisplayNames?: Record<string, string>;
-  lastFreqHz?: number;
-  lastModeName?: string;
-  lastSpectrumData?: unknown;
-  currentBandwidthHz?: number;
-  modeEl?: HTMLSelectElement | null;
-  decoderRegistry?: DecoderDescriptor[];
-  trx?: { modules?: { bookmarks?: BookmarkService; vchan?: VirtualChannelService } };
   trxUi: {
     confirm(options: { title: string; message: string; confirmLabel: string; danger?: boolean }): Promise<boolean>;
     notify?(message: string, options: { kind: "error" }): void;
   };
   syncBookmarkMapLocators?(bookmarks: readonly Bookmark[]): void;
-  scheduleSpectrumDraw?(): void;
-  syncBandwidthInput?(bandwidthHz: number): void;
-  applyLocalTunedFrequency?(frequencyHz: number, force?: boolean): void;
-  setRigFrequency?(frequencyHz: number): Promise<unknown>;
-  postPath(path: string): Promise<unknown>;
-  onDecoderRegistryReady?(callback: () => void): void;
-  _freqOptimisticSeq?: number;
-  _freqOptimisticHz?: number;
 }
 
 type BookmarkElement = HTMLElement & HTMLInputElement & HTMLSelectElement;
@@ -81,6 +54,12 @@ function bmEl(id: string): BookmarkElement {
   return element as BookmarkElement;
 }
 
+/* Decoder checkboxes and decoder toggle buttons are built from the runtime
+ * registry, so their elements are legitimately absent for unbuilt decoders. */
+function bmOptionalEl(id: string): BookmarkElement | null {
+  return document.getElementById(id) as BookmarkElement | null;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
@@ -121,10 +100,7 @@ function bmEsc(str: unknown): string {
 }
 
 function bmCanControl() {
-  return (
+  return !hostState.authEnabled || hostState.authRole === "control";
-    (typeof bridge.authEnabled !== "undefined" && !bridge.authEnabled) ||
-    (typeof bridge.authRole !== "undefined" && bridge.authRole === "control")
-  );
 }
 
 // Show/hide the Add Bookmark / Select All buttons based on the current auth role.
@@ -138,8 +114,7 @@ function bmSyncAccess() {
 
 /** The listing scope: always the active rig (to merge general + rig bookmarks). */
 function bmListScope() {
-  const rig = (typeof bridge.lastActiveRigId !== "undefined") ? bridge.lastActiveRigId : null;
+  return hostState.lastActiveRigId || "general";
-  return rig || "general";
 }
 
 async function bmFetchOverlay() {
@@ -156,7 +131,7 @@ async function bmFetchOverlay() {
   if (typeof bridge.syncBookmarkMapLocators === "function") {
     bridge.syncBookmarkMapLocators(bmOverlayList);
   }
-  if (typeof bridge.scheduleSpectrumDraw === "function") bridge.scheduleSpectrumDraw();
+  hostCore.scheduleSpectrumDraw();
 }
 
 async function bmFetch(categoryFilter: string): Promise<void> {
@@ -312,19 +287,19 @@ function bmChangePage(delta: number): void {
 
 // Read decoder checkboxes and return an array of selected decoder names.
 function bmReadDecoders(): string[] {
-  return (bridge.decoderRegistry || [])
+  return hostState.decoderRegistry
     .filter(d => d.bookmark_selectable)
-    .filter(d => bmEl("bm-dec-" + d.id)?.checked)
+    .filter(d => bmOptionalEl("bm-dec-" + d.id)?.checked)
     .map(d => d.id);
 }
 
 // Set decoder checkboxes to match the given array.
 function bmWriteDecoders(decoders: readonly string[]): void {
   const set = new Set(decoders || []);
-  (bridge.decoderRegistry || [])
+  hostState.decoderRegistry
     .filter(d => d.bookmark_selectable)
     .forEach(d => {
-      const el = bmEl("bm-dec-" + d.id);
+      const el = bmOptionalEl("bm-dec-" + d.id);
       if (el) el.checked = set.has(d.id);
     });
 }
@@ -334,7 +309,7 @@ function bmBuildDecoderCheckboxes() {
   const container = bmEl("bm-decoder-checkboxes");
   if (!container) return;
   container.innerHTML = "";
-  (bridge.decoderRegistry || [])
+  hostState.decoderRegistry
     .filter(d => d.bookmark_selectable)
     .forEach(d => {
       const label = document.createElement("label");
@@ -374,23 +349,21 @@ function bmCloseForm() {
 }
 
 function bmPrefillFromStatus() {
-  // Use globals maintained by app.js (updated by SSE stream)
+  // Read live rig state from the host contract (updated by the SSE stream).
-  if (typeof bridge.lastFreqHz === "number" && Number.isFinite(bridge.lastFreqHz)) {
+  const freqHz = hostState.lastFreqHz;
-    bmEl("bm-freq").value = String(Math.round(bridge.lastFreqHz));
+  if (freqHz != null && Number.isFinite(freqHz)) {
+    bmEl("bm-freq").value = String(Math.round(freqHz));
   }
-  if (typeof bridge.lastModeName === "string" && bridge.lastModeName) {
+  if (hostState.lastModeName) {
-    bmEl("bm-mode").value = bridge.lastModeName;
+    bmEl("bm-mode").value = hostState.lastModeName;
   }
-  if (typeof bridge.currentBandwidthHz === "number" && bridge.currentBandwidthHz > 0) {
+  if (hostState.currentBandwidthHz > 0) {
-    bmEl("bm-bw").value = String(Math.round(bridge.currentBandwidthHz));
+    bmEl("bm-bw").value = String(Math.round(hostState.currentBandwidthHz));
   }
   // Prefill decoder checkboxes from current toggle button state.
-  const activeDecoders = (bridge.decoderRegistry || [])
+  const activeDecoders = hostState.decoderRegistry
     .filter(d => d.bookmark_selectable && d.activation === "toggle")
-    .filter(d => {
+    .filter(d => bmOptionalEl(d.id + "-decode-toggle-btn")?.dataset.enabled === "true")
-      const btn = bmEl(d.id + "-decode-toggle-btn");
-      return btn && btn.dataset.enabled === "true";
-    })
     .map(d => d.id);
   bmWriteDecoders(activeDecoders);
 }
@@ -480,58 +453,45 @@ async function bmDelete(id: string): Promise<void> {
 function bmApply(bm: Bookmark): void {
   try {
     // --- Optimistic UI updates (instant, before any network round-trips) ---
-    if (typeof bridge.modeEl !== "undefined" && bridge.modeEl) {
+    const modeEl = document.getElementById("mode") as HTMLSelectElement | null;
-      bridge.modeEl.value = (bm.mode || "").toUpperCase();
+    if (modeEl) {
+      modeEl.value = (bm.mode || "").toUpperCase();
+      hostCore.syncModePicker();
     }
     if (bm.bandwidth_hz) {
-      if (typeof bridge.currentBandwidthHz !== "undefined") {
+      hostState.currentBandwidthHz = bm.bandwidth_hz;
-        bridge.currentBandwidthHz = bm.bandwidth_hz;
+      hostCore.syncBandwidthInput(bm.bandwidth_hz);
     }
-      bridge.currentBandwidthHz = bm.bandwidth_hz;
-      if (typeof bridge.syncBandwidthInput === "function") {
-        bridge.syncBandwidthInput(bm.bandwidth_hz);
-      }
-    }
-    if (typeof bridge.applyLocalTunedFrequency === "function") {
     // Set optimistic guard before applying so SSE cannot snap back.
-      if (typeof bridge._freqOptimisticSeq !== "undefined") {
+    hostCore.armOptimisticFrequency(bm.freq_hz);
-        ++bridge._freqOptimisticSeq;
-        bridge._freqOptimisticHz = bm.freq_hz;
-      }
     // Force display so the BW overlay is repositioned even when freq is unchanged.
-      bridge.applyLocalTunedFrequency(bm.freq_hz, true);
+    hostCore.applyLocalTunedFrequency(bm.freq_hz, true);
-    }
+    if (hostState.lastSpectrumData) {
-    if (typeof bridge.scheduleSpectrumDraw === "function" && typeof bridge.lastSpectrumData !== "undefined" && bridge.lastSpectrumData) {
+      hostCore.scheduleSpectrumDraw();
-      bridge.scheduleSpectrumDraw();
     }
 
     // Take scheduler control up front, then apply mode before bandwidth so a
     // late SetMode cannot revert a saved WFM bookmark bandwidth to 180 kHz.
     const tunePromise = (async () => {
-      await bridge.trx?.modules?.vchan?.takeSchedulerControl();
+      await bridge.trx.modules.vchan?.takeSchedulerControl();
 
-      const onVirtual = await bridge.trx?.modules?.vchan?.interceptMode(bm.mode) ?? false;
+      const onVirtual = await bridge.trx.modules.vchan?.interceptMode(bm.mode) ?? false;
       if (!onVirtual) {
-        await bridge.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
+        await hostCore.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
       }
 
       if (bm.bandwidth_hz) {
         const bwHandledByVchan =
-          await bridge.trx?.modules?.vchan?.interceptBandwidth(bm.bandwidth_hz) ?? false;
+          await bridge.trx.modules.vchan?.interceptBandwidth(bm.bandwidth_hz) ?? false;
         if (!bwHandledByVchan) {
-          await bridge.postPath(`/set_bandwidth?hz=${bm.bandwidth_hz}`);
+          await hostCore.postPath(`/set_bandwidth?hz=${bm.bandwidth_hz}`);
         }
       }
 
-      // bridge.setRigFrequency is wrapped by vchan.js to redirect to the channel API
+      // setRigFrequency redirects to the channel API when a virtual channel is
-      // when on a virtual channel, so this call works correctly in both cases.
+      // active.  It repeats the optimistic update applied above, which is a
-      // It also does its own optimistic update (bridge.applyLocalTunedFrequency) but
+      // no-op because the value is unchanged.
-      // that's a no-op since we already set the same value above.
+      hostCore.setRigFrequency(bm.freq_hz);
-      if (typeof bridge.setRigFrequency === "function") {
-        await bridge.setRigFrequency(bm.freq_hz);
-      } else {
-        await bridge.postPath(`/set_freq?hz=${bm.freq_hz}`);
-      }
     })();
     // Decoder toggles — fire-and-forget.
     //  - Decoders incompatible with the new mode are always turned off
@@ -541,13 +501,14 @@ function bmApply(bm: Bookmark): void {
     //    alone.
     const hasDecoders = Array.isArray(bm.decoders) && bm.decoders.length > 0;
     const modeUp = (bm.mode || "").toUpperCase();
-    const allToggleDecoders = (bridge.decoderRegistry || []).filter(d =>
+    const allToggleDecoders = hostState.decoderRegistry.filter(d =>
       d.activation === "toggle"
     );
     const decoderPromise = allToggleDecoders.length ? (async () => {
       let statusUrl = "/status";
-      if (typeof bridge.lastActiveRigId !== "undefined" && bridge.lastActiveRigId) {
+      const rigId = hostState.lastActiveRigId;
-        statusUrl += "?remote=" + encodeURIComponent(bridge.lastActiveRigId);
+      if (rigId) {
+        statusUrl += "?remote=" + encodeURIComponent(rigId);
       }
       const statusResp = await fetch(statusUrl);
       if (!statusResp.ok) return;
@@ -569,7 +530,7 @@ function bmApply(bm: Bookmark): void {
           wanted = currentlyOn;
         }
         if (wanted !== currentlyOn) {
-          toggles.push(bridge.postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
+          toggles.push(hostCore.postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
         }
       }
       if (toggles.length) await Promise.all(toggles);
@@ -584,8 +545,6 @@ function bmApply(bm: Bookmark): void {
   }
 }
 
-bridge.trx ??= {};
-bridge.trx.modules ??= {};
 bridge.trx.modules.bookmarks = {
   get overlayList() { return bmOverlayList; },
   get overlayRevision() { return bmOverlayRevision; },
@@ -621,8 +580,8 @@ function bmUpdateSelectionUi() {
 function bmPopulateMoveTarget() {
   const sel = bmEl("bm-move-target");
   if (!sel) return;
-  const rigIds = (typeof bridge.lastRigIds !== "undefined" && Array.isArray(bridge.lastRigIds)) ? bridge.lastRigIds : [];
+  const rigIds = hostState.lastRigIds;
-  const displayNames = (typeof bridge.lastRigDisplayNames !== "undefined") ? bridge.lastRigDisplayNames : {};
+  const displayNames = hostState.lastRigDisplayNames;
   const prev = sel.value;
   sel.innerHTML = "";
   if (bmScope !== "general") {
@@ -730,8 +689,8 @@ async function bmDeleteSelected() {
 function bmPopulateScopePicker() {
   const picker = bmEl("bm-scope-picker");
   if (!picker) return;
-  const rigIds = (typeof bridge.lastRigIds !== "undefined" && Array.isArray(bridge.lastRigIds)) ? bridge.lastRigIds : [];
+  const rigIds = hostState.lastRigIds;
-  const displayNames = (typeof bridge.lastRigDisplayNames !== "undefined") ? bridge.lastRigDisplayNames : {};
+  const displayNames = hostState.lastRigDisplayNames;
   // Preserve current selection if still valid.
   const prev = picker.value;
   while (picker.options.length > 1) picker.remove(1);
@@ -758,9 +717,7 @@ function bmPopulateScopePicker() {
   // Build decoder checkboxes from registry.  The registry is fetched async
   // so we rebuild once it arrives to ensure checkboxes are present.
   bmBuildDecoderCheckboxes();
-  if (typeof bridge.onDecoderRegistryReady === "function") {
+  hostCore.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
-    bridge.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
-  }
 
   // Scope picker
   bmPopulateScopePicker();

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

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore } from "./host.js";
+
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
 
 export {};
@@ -30,8 +32,6 @@ interface CwBridge {
   lastFreqHz?: number;
   currentBandwidthHz?: number;
   lastSpectrumData?: CwSpectrum;
-  escapeMapHtml?: (input: string) => string;
-  postPath?: (path: string) => Promise<unknown>;
   trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
   applyCwAutoUi?: (enabled: boolean) => void;
   applyCwAutoUiFromServer?: (enabled: boolean) => void;
@@ -75,9 +75,7 @@ let cwBarDismissedAtMs = 0;
 let cwAutoLocalOverride: boolean | null = null;
 
 function escapeCwHtml(input: string): string {
-  return cwWindow.escapeMapHtml?.(input) ?? input
+  return hostCore.escapeMapHtml(input);
-    .replaceAll("&", "&amp;").replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 
 function applyCwAutoUi(enabled: boolean): void {
@@ -344,7 +342,7 @@ async function setCwTone(tone: unknown, { syncInput = true }: { syncInput?: bool
     cwToneInput.value = String(clamped);
   }
   try {
-    await cwWindow.postPath?.(`/set_cw_tone?tone_hz=${encodeURIComponent(clamped)}`);
+    await hostCore.postPath(`/set_cw_tone?tone_hz=${encodeURIComponent(clamped)}`);
   } catch (e) {
     console.error("CW tone set failed", e);
   }
@@ -358,7 +356,7 @@ if (cwAutoInput) {
       cwAutoLocalOverride = enabled;
       applyCwAutoUi(enabled);
       try {
-        await cwWindow.postPath?.(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
+        await hostCore.postPath(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
         drawCwTonePicker();
       } catch (error: unknown) {
         console.error("CW auto toggle failed", error);
@@ -375,7 +373,7 @@ if (cwWpmInput) {
       if (cwAutoInput?.checked) return;
       const wpm = clampCwWpm(cwWpmInput.value);
       cwWpmInput.value = String(wpm);
-      try { await cwWindow.postPath?.(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`); }
+      try { await hostCore.postPath(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`); }
       catch (error: unknown) { console.error("CW WPM set failed", error); }
     })();
   });
@@ -413,7 +411,7 @@ document.getElementById("settings-clear-cw-history")?.addEventListener("click",
   void (async () => {
     if (!await cwWindow.trxUi.confirm({ title: "Clear CW history?", message: "All stored CW decodes will be permanently removed.", confirmLabel: "Clear history" })) return;
     try {
-      await cwWindow.postPath?.("/clear_cw_decode");
+      await hostCore.postPath("/clear_cw_decode");
       resetCwHistoryView();
     } catch (error: unknown) {
       console.error("CW history clear failed", error);

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/ftx-family.ts

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore } from "./host.js";
+
 import type { PluginRuntimeWindow } from "./runtime-contract.js";
 
 export type FtxDecoderId = "ft2" | "ft4" | "ft8";
@@ -45,8 +47,6 @@ interface FtxBridge {
   updateFt8Bar?: () => void;
   registerFt8FamilyBarRenderer?: (decoder: FtxDecoderId, renderer: () => BarFrames) => void;
   takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<void>;
-  postPath?: (path: string) => Promise<unknown>;
-  fmtTime?: (timestampMs: number) => string;
   trxUi: ConfirmApi;
   clearFt8Bar?: () => void;
   closeFt8Bar?: () => void;
@@ -62,6 +62,14 @@ interface FtxConfig {
 
 const bridge = window as unknown as FtxBridge & PluginRuntimeWindow;
 
+// Legacy ft8.js owned this formatter locally; the shared module kept reading it
+// off `window`, where nothing published it, so bar timestamps rendered empty.
+function formatBarTime(timestampMs: number): string {
+  if (!timestampMs) return "--:--:--";
+  return new Date(timestampMs)
+    .toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
 function finiteNumber(value: unknown): number | null {
   const number = typeof value === "number" ? value : Number(value);
   return Number.isFinite(number) ? number : null;
@@ -274,7 +282,7 @@ export function initializeFtxDecoder(config: FtxConfig): void {
     let html = "";
     for (const message of recent) {
       const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
-      const time = timestamp === null ? "" : `<span class="aprs-bar-time">${bridge.fmtTime?.(timestamp) ?? ""}</span>`;
+      const time = timestamp === null ? "" : `<span class="aprs-bar-time">${formatBarTime(timestamp)}</span>`;
       const snr = finiteNumber(message.snr_db);
       const delta = finiteNumber(message.dt_s);
       const frequency = displayFrequency(message.freq_hz);
@@ -309,12 +317,12 @@ export function initializeFtxDecoder(config: FtxConfig): void {
   toggle?.addEventListener("click", () => { void (async () => {
     try {
       await bridge.takeSchedulerControlForDecoderDisable?.(toggle);
-      await bridge.postPath?.(`/toggle_${id}_decode`);
+      await hostCore.postPath(`/toggle_${id}_decode`);
     } catch (error: unknown) { console.error(`${label} toggle failed`, error); }
   })(); });
   document.getElementById(`settings-clear-${id}-history`)?.addEventListener("click", () => { void (async () => {
     if (!await bridge.trxUi.confirm({ title: `Clear ${label} history?`, message: `All stored ${label} decodes will be permanently removed.`, confirmLabel: "Clear history" })) return;
-    try { await bridge.postPath?.(`/clear_${id}_decode`); reset(); }
+    try { await hostCore.postPath(`/clear_${id}_decode`); reset(); }
     catch (error: unknown) { console.error(`${label} history clear failed`, error); }
   })(); });
 }

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

@@ -2,15 +2,14 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
 import {
   aprsAgeText,
-  aprsCategoryLabel,
-  aprsHexBytes,
   aprsPacketCategory,
   collapseAprsDuplicates,
   normalizeAprsPacket,
-  renderAprsInfo,
+  renderAprsPacketRow,
-  renderLocalAprsSymbol,
   type AprsPacket,
   type AprsTypeFilter,
 } from "./aprs-shared";
@@ -19,21 +18,12 @@ import type { PluginRuntimeWindow } from "./runtime-contract";
 interface HfAprsBridge {
   getDecodeHistoryRetentionMs?: () => number;
   trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
-  serverLat?: number | null;
-  serverLon?: number | null;
-  haversineKm?: (lat1: number, lon1: number, lat2: number, lon2: number) => number;
-  escapeMapHtml?: (input: string) => string;
   navigateToAprsMap?: (lat: number, lon: number) => void;
-  showHint?: (message: string, durationMs: number) => void;
   getDecodeRigMeta?: () => unknown;
   takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<unknown>;
-  postPath?: (path: string) => Promise<unknown>;
   trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
 }
 const hfAprsWindow = window as unknown as HfAprsBridge;
-const escapeHfAprsHtml = (input: string): string => hfAprsWindow.escapeMapHtml?.(input) ?? input
-  .replaceAll("&", "&amp;").replaceAll("<", "&lt;")
-  .replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 
 // --- HF APRS Decoder Plugin (server-side decode, 300 baud) ---
 const hfAprsStatus = document.getElementById("hf-aprs-status");
@@ -72,8 +62,8 @@ function scheduleHfAprsHistoryRender() {
 }
 
 function hfAprsDistanceText(pkt: AprsPacket): string {
-  if (hfAprsWindow.serverLat == null || hfAprsWindow.serverLon == null || pkt.lat == null || pkt.lon == null || !hfAprsWindow.haversineKm) return "";
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
-  const distKm = hfAprsWindow.haversineKm(hfAprsWindow.serverLat, hfAprsWindow.serverLon, pkt.lat, pkt.lon);
+  const distKm = hostCore.haversineKm(hostState.serverLat, hostState.serverLon, pkt.lat, pkt.lon);
   if (!Number.isFinite(distKm)) return "";
   if (distKm < 1) return `${Math.round(distKm * 1000)} m from TRX`;
   return `${distKm.toFixed(1)} km from TRX`;
@@ -134,95 +124,27 @@ function updateHfAprsChipState() {
   hfAprsCollapseDupBtn?.classList.toggle("active", hfAprsCollapseDup);
 }
 
+// HF traffic goes in the same row as VHF, marked with the band it came in on.
+// This was a second copy of the same forty lines of markup.
 function renderHfAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
-  const row = document.createElement("div");
+  return renderAprsPacketRow(pkt, {
-  row.className = "aprs-packet";
+    fresh: isFresh,
-  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
+    badge: "HF",
-  if (isFresh) row.classList.add("aprs-packet-new");
+    distance: hfAprsDistanceText(pkt),
-
+    onMap: (lat: number, lon: number) => { hfAprsWindow.navigateToAprsMap?.(lat, lon); },
-  const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    onCopy: (text: string) => { void copyHfAprsCoords(text); },
-  const age = aprsAgeText(pkt._tsMs);
+  });
-  const category = aprsPacketCategory(pkt);
-  const categoryLabel = aprsCategoryLabel(category);
-  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
-  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeHfAprsHtml(pkt.path)}</span>` : "";
-  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
-  const hfBadge = '<span class="aprs-badge" style="background:var(--accent-alt,#f59e0b);color:#000">HF</span>';
-  const symbolHtml = renderLocalAprsSymbol(pkt, escapeHfAprsHtml);
-  const posLink = pkt.lat != null && pkt.lon != null
-    ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>`
-    : "";
-  const distance = hfAprsDistanceText(pkt);
-  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
-
-  row.innerHTML =
-    `<div class="aprs-row-head">` +
-      `<span class="aprs-time">${ts}</span>` +
-      hfBadge +
-      symbolHtml +
-      `<span class="aprs-call">${escapeHfAprsHtml(pkt.srcCall ?? "")}</span>` +
-      `<span>&gt;${escapeHfAprsHtml(pkt.destCall || "")}</span>` +
-      `<span class="${categoryClass}">${escapeHfAprsHtml(categoryLabel)}</span>` +
-      pathBadge +
-      crcBadge +
-    `</div>` +
-    `<div class="aprs-row-meta">` +
-      `<span class="aprs-meta-text">${escapeHfAprsHtml(age)}</span>` +
-      (distance ? `<span class="aprs-meta-text">${escapeHfAprsHtml(distance)}</span>` : "") +
-      `<span class="aprs-meta-text">${escapeHfAprsHtml(pkt.type || "--")}</span>` +
-    `</div>` +
-    `<div class="aprs-row-detail">` +
-      `<span title="${escapeHfAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
-      (posLink ? `<span>${posLink}</span>` : "") +
-    `</div>` +
-    `<div class="aprs-row-actions">` +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") +
-      (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") +
-      `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a>` +
-    `</div>` +
-    `<details class="aprs-details">` +
-      `<summary>Details</summary>` +
-      `<div class="aprs-details-grid">` +
-        `<span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.srcCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.destCall || "--")}</span>` +
-        `<span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.type || "--")}</span>` +
-        `<span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.path || "--")}</span>` +
-        `<span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeHfAprsHtml(age)}</span>` +
-        `<span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span>` +
-        `<span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span>` +
-        `<span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.info || "--")}</span>` +
-        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeHfAprsHtml(aprsHexBytes(pkt.info_bytes))}</span>` +
-      `</div>` +
-    `</details>`;
-
-  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((el) => {
-    el.addEventListener("click", (evt) => {
-      evt.preventDefault();
-      const raw = el.dataset.aprsMap ?? "";
-      const [lat, lon] = raw.split(",").map(Number);
-      if (hfAprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
-        hfAprsWindow.navigateToAprsMap(lat, lon);
 }
-    });
-  });
 
-  const copyBtn = row.querySelector<HTMLElement>("[data-aprs-copy]");
+async function copyHfAprsCoords(text: string): Promise<void> {
-  if (copyBtn) {
-    copyBtn.addEventListener("click", () => { void (async () => {
-      const raw = copyBtn.dataset.aprsCopy ?? "";
   try {
     const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
-        if (clipboard) {
+    if (!clipboard) return;
-          await clipboard.writeText(raw);
+    await clipboard.writeText(text);
-          hfAprsWindow.showHint?.("Coordinates copied", 1200);
+    hostCore.showHint("Coordinates copied", 1200);
-        }
   } catch {
-        hfAprsWindow.showHint?.("Copy failed", 1500);
+    hostCore.showHint("Copy failed", 1500);
   }
-    })(); });
-  }
-
-  return row;
 }
 
 function renderHfAprsHistory() {
@@ -289,7 +211,7 @@ const hfAprsDecodeToggleBtn = document.getElementById("hf-aprs-decode-toggle-btn
 hfAprsDecodeToggleBtn?.addEventListener("click", () => { void (async () => {
   try {
     await hfAprsWindow.takeSchedulerControlForDecoderDisable?.(hfAprsDecodeToggleBtn);
-    await hfAprsWindow.postPath?.("/toggle_hf_aprs_decode");
+    await hostCore.postPath("/toggle_hf_aprs_decode");
   } catch (e) {
     console.error("HF APRS toggle failed", e);
   }
@@ -298,7 +220,7 @@ hfAprsDecodeToggleBtn?.addEventListener("click", () => { void (async () => {
 document.getElementById("settings-clear-hf-aprs-history")?.addEventListener("click", () => { void (async () => {
   if (!await hfAprsWindow.trxUi.confirm({ title: "Clear HF APRS history?", message: "All stored HF APRS packets will be permanently removed.", confirmLabel: "Clear history" })) return;
   try {
-    await hfAprsWindow.postPath?.("/clear_hf_aprs_decode");
+    await hostCore.postPath("/clear_hf_aprs_decode");
     resetHfAprsHistoryView();
   } catch (e) {
     console.error("HF APRS history clear failed", e);

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

@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Typed view of the `window.trx` host contract for lazy feature bundles.
+//
+// Feature entries are separate esbuild bundles, so they cannot share module
+// instances with the application entry and must reach application state and
+// services through the host namespace documented in
+// `docs/frontend-architecture.md`.  Declaring that contract once here keeps the
+// feature bundles from re-deriving it — and from drifting back to bare `window`
+// properties, which the module graph no longer publishes.
+
+export interface HostDecoderDescriptor {
+  id: string;
+  label: string;
+  activation?: string;
+  active_modes?: string[];
+  bookmark_selectable?: boolean;
+}
+
+export interface HostState {
+  readonly serverLat: number | null;
+  readonly serverLon: number | null;
+  readonly authEnabled: boolean;
+  readonly authRole: string | null;
+  readonly lastActiveRigId: string | null;
+  readonly lastRigIds: string[];
+  readonly lastRigDisplayNames: Record<string, string>;
+  readonly lastFreqHz: number | null;
+  readonly lastSpectrumData: { sample_rate: number; center_hz: number } | null;
+  readonly jogUnit: number;
+  readonly rxActive: boolean;
+  readonly decoderRegistry: readonly HostDecoderDescriptor[];
+  lastModeName: string;
+  currentBandwidthHz: number;
+  audioChannelOverride: string | null;
+}
+
+export interface HostCore {
+  postPath(path: string): Promise<unknown>;
+  applyLocalTunedFrequency(frequencyHz: number, forceDisplay?: boolean): void;
+  armOptimisticFrequency(frequencyHz: number): void;
+  escapeMapHtml(value: string): string;
+  haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number;
+  showHint(message: string, durationMs?: number): void;
+  formatFreqForStep(frequencyHz: number, stepHz: number): string;
+  refreshFreqDisplay(): void;
+  setJogDivisor(divisor: number): void;
+  mwDefaultsForMode(mode: string): [number, number, number, number];
+  resetRdsDisplay(): void;
+  positionRdsPsOverlay(): void;
+  updateWfmControls(): void;
+  updateSdrSquelchControlVisibility(): void;
+  updateDocumentTitle(rds: unknown): void;
+  activeChannelRds(): unknown;
+  startRxAudio(): void;
+  stopRxAudio(): void;
+  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;
+}
+
+interface HostWindow {
+  trx: { state: HostState; core: HostCore };
+}
+
+const host = window as unknown as HostWindow;
+
+export const hostState: HostState = host.trx.state;
+export const hostCore: HostCore = host.trx.core;