[fix](trx-frontend-http): route feature bundles through the host contract

The bookmark fix addressed one instance of a defect the TypeScript
migration left across the feature entries.  app.js stopped being a
classic script, so its top-level declarations are no longer shared
globals, but the converted entries kept reading them as window
properties that nothing publishes.

Restore the broken behavior:

- ais, aprs, hf-aprs read serverLat, serverLon and haversineKm as
  undefined, so every positioned packet rendered an empty distance.
- ais, aprs, hf-aprs, cw, sat, vdes, wefax, wspr called an undefined
  postPath, so clear-history and decoder toggles threw.
- scheduler read authRole as undefined, so the lazy-load path never
  self-initialized and the Settings tab opened an inert scheduler.
- background-decode read authEnabled as undefined, so control gating
  fell back to role-only.
- vchan read fifteen application values and services as undefined:
  mode and bandwidth sync, the out-of-band hint, RX audio restart, and
  the frequency field all silently no-opped on a virtual channel.
- vchan wrapped window.refreshFreqDisplay, capturing an undefined
  original exactly as it did for setRigFrequency, so leaving a channel
  never restored the application's own frequency display.
- _audioChannelOverride was a const that nothing could assign, so RX
  audio always subscribed to the primary channel.
- ftx-family read fmtTime, a helper legacy ft8.js owned locally, so
  decode bar timestamps rendered empty.

Declare the contract once in plugins/host.ts and import it from the
feature entries, rather than restoring globals that
docs/frontend-architecture.md excludes.  trx.state gains jogUnit,
rxActive and audioChannelOverride, and makes lastModeName writable;
trx.core gains the tuning, RDS, WFM, jog and RX audio services the
entries need.  vchan interception moves to an interceptFreqDisplay
service method that refreshFreqDisplay calls, matching the frequency,
mode and bandwidth interception it already registers.

Reading registry-built elements through a strict lookup is the same
defect as in bookmarks: renderTimelineNeedle guards its result, but
schedulerEl throws, so the now-initializing scheduler crashed on the
timeline needle group that its own SVG creates.

Feature tests move onto a shared host fixture, and entries that now
import a common module are bundled through bundleEntry like the other
shared-module entries.  Covers scheduler self-initialization and the
distance path that the bare window reads broke.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GdyUjuXejCEfiub675z6cz
Signed-off-by: Stan Grams <sjg@haxx.space>

.gitea/workflows/ci.yml

@@ -36,6 +36,38 @@ jobs:
       - name: Test
         run: cargo test --workspace --locked
 
+  frontend:
+    runs-on: ubuntu-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
+        run: npm run typecheck
+      - name: Lint
+        run: npm run lint
+      - name: Test
+        run: npm test
+      - name: Install browser smoke dependency
+        run: command -v chromium >/dev/null || (sudo apt-get update && sudo apt-get install -y --no-install-recommends chromium)
+      - name: Browser smoke test
+        run: npm run test:browser
+      - name: Verify generated assets
+        run: npm run verify-generated
+      - name: Verify generated-file licensing
+        working-directory: .
+        run: reuse lint
+
   reuse:
     runs-on: ubuntu-latest
     steps:

.gitignore

@@ -21,6 +21,9 @@ Cargo.lock
 coverage/
 benchmarks/
 
+# Frontend dependencies
+**/node_modules/
+
 # Env
 .env
 .env.*

Cargo.lock

@@ -2645,6 +2645,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3137,6 +3146,7 @@ dependencies = [
  "sgp4",
  "tokio",
  "tracing",
+ "ts-rs",
  "uuid",
 ]
 
@@ -3195,6 +3205,7 @@ dependencies = [
  "trx-core",
  "trx-frontend",
  "trx-protocol",
+ "ts-rs",
  "uuid",
 ]
 
@@ -3238,6 +3249,7 @@ dependencies = [
  "serde",
  "serde_json",
  "trx-core",
+ "ts-rs",
 ]
 
 [[package]]
@@ -3333,6 +3345,29 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "ts-rs"
+version = "12.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "756050066659291d47a554a9f558125db17428b073c5ffce1daf5dcb0f7231d8"
+dependencies = [
+ "thiserror 2.0.18",
+ "ts-rs-macros",
+ "uuid",
+]
+
+[[package]]
+name = "ts-rs-macros"
+version = "12.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d90eea51bc7988ef9e674bf80a85ba6804739e535e9cab48e4bb34a8b652aa"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "termcolor",
+]
+
 [[package]]
 name = "typenum"
 version = "1.20.0"

LICENSES/MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -142,6 +142,6 @@ a unified set of frontends.
 ## License
 
 GPL-2.0-or-later. See [`LICENSES`](LICENSES) for the full license text and
-bundled third-party license files. Bundled third-party components (Leaflet and
-the Leaflet AIS tracksymbol plugin under `assets/web/vendor/`) retain their
-original BSD-2-Clause license.
+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.

REUSE.toml

@@ -18,7 +18,11 @@ path = [
     "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"
@@ -42,3 +46,11 @@ SPDX-License-Identifier = "BSD-2-Clause"
 path = ["src/trx-client/trx-frontend/trx-frontend-http/assets/web/vendor/dseg14-classic-latin-400-normal.woff2"]
 SPDX-FileCopyrightText = "2020 The DSEG Authors (https://github.com/keshikan/DSEG)"
 SPDX-License-Identifier = "OFL-1.1"
+
+# Vendored opus-decoder 0.7.11 browser build
+# (https://github.com/eshaz/wasm-audio-decoders), MIT.
+# SHA-256: fd73ee0a9c8a5e233c0b88234df14f46003ad89bb4ba27435bc8714db2a6dc62
+[[annotations]]
+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"

container/Containerfile

@@ -23,7 +23,7 @@ ENV DEBIAN_FRONTEND=noninteractive \
 RUN apt-get update && apt-get install -y --no-install-recommends \
         ca-certificates curl xz-utils git sudo pipx \
         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).

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-baseline.md

@@ -0,0 +1,50 @@
+<!--
+SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+
+SPDX-License-Identifier: GPL-2.0-or-later
+-->
+
+# TypeScript migration baseline
+
+This baseline records the browser architecture at the start of the migration.
+It is intentionally historical; generated output sizes are tracked separately
+by the deterministic frontend build.
+
+## Startup order
+
+The initial document loads these scripts in order:
+
+1. `/vendor/opus-decoder-0.7.11.min.js`
+2. `/vendor/leaflet.js`
+3. `/leaflet-ais-tracksymbol.js`
+4. `/webgl-renderer.js`
+5. `/ui-core.js`
+6. `/app.js`
+
+Decoder and feature scripts are then loaded lazily by the inline loader in
+`index.html`. The frontend smoke test locks the core ordering and rejects
+remote script or stylesheet URLs.
+
+## Source measurements
+
+At baseline, first-party JavaScript comprised 23 files and approximately
+776 KiB. The largest sources were:
+
+| Source | Bytes |
+|---|---:|
+| `app.js` | 337,111 |
+| `map-core.js` | 131,899 |
+| `plugins/scheduler.js` | 60,883 |
+| `plugins/bookmarks.js` | 30,543 |
+| `plugins/sat.js` | 22,541 |
+| `plugins/vchan.js` | 20,195 |
+| `webgl-renderer.js` | 18,993 |
+
+The migrated source snapshot contained 123 distinct direct `window.*`
+assignments. These are compatibility callbacks, shared state, and plugin entry
+points. New TypeScript code must not add to that set; the typed plugin registry
+and explicit services replace it over the course of the migration.
+
+All production scripts, stylesheets, fonts, icons, and map assets were already
+served from local embedded routes. The automated startup test ensures no
+remote runtime script or stylesheet dependency is introduced.

docs/ts-migration-plan.md

@@ -0,0 +1,586 @@
+<!--
+SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+
+SPDX-License-Identifier: GPL-2.0-or-later
+-->
+
+# TypeScript Migration Plan
+
+> **Scope**: `src/trx-client/trx-frontend/trx-frontend-http/`
+>
+> **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
+
+Migrating the web frontend to TypeScript is worthwhile, provided it is used to
+remove implicit contracts and global coupling. Renaming JavaScript files to
+`.ts` without changing their boundaries would add tooling without delivering
+the main safety benefits.
+
+The migration must be incremental. Every intermediate commit and pull request
+must leave the frontend buildable and usable.
+
+## 2. Baseline State
+
+The frontend currently contains roughly 21,700 lines of first-party
+JavaScript. Its largest components include:
+
+- `app.js`: approximately 8,900 lines;
+- `map-core.js`: approximately 3,500 lines;
+- `plugins/scheduler.js`: approximately 1,500 lines;
+- `plugins/bookmarks.js`: approximately 800 lines;
+- `plugins/vchan.js`: approximately 560 lines.
+
+Important characteristics of the current architecture are:
+
+- scripts are embedded individually into the Rust binary with `include_str!`;
+- the Rust HTTP server exposes an explicit route for each asset;
+- plugins are loaded dynamically as classic scripts;
+- script order is significant;
+- modules communicate through `window.*`, `window.trx`, callbacks, and shared
+  mutable state;
+- the main HTML file contains the plugin loader;
+- a Web Worker is loaded through a fixed URL;
+- Cargo builds do not require Node.js;
+- CI images contain Node.js, but CI currently runs only Rust and REUSE checks;
+- Leaflet, Opus decoder, fonts, images, and other vendored assets are local.
+
+These constraints make a big-bang rewrite unnecessarily risky.
+
+## 3. Goals
+
+The migration should:
+
+1. Create checked contracts between Rust responses and browser code.
+2. Replace global callbacks with explicit module interfaces.
+3. Split `app.js` by responsibility.
+4. Make rig, capability, decoder, scheduler, audio, and spectrum state explicit.
+5. Preserve lazy loading for expensive features.
+6. Add frontend type checking, linting, and automated tests to CI.
+7. Keep ordinary Cargo builds independent of Node.js and network access.
+8. Preserve existing browser behavior throughout the migration.
+
+## 4. Non-Goals
+
+The migration will not initially:
+
+- introduce a UI framework;
+- redesign the user interface;
+- convert vendored JavaScript to TypeScript;
+- change REST, SSE, WebSocket, or worker protocols unless required to make an
+  existing contract unambiguous;
+- make `build.rs` install packages or download frontend dependencies;
+- convert all of `app.js` in one pull request.
+
+## 5. Target Layout
+
+```text
+trx-frontend-http/
+├── frontend/
+│   ├── package.json
+│   ├── package-lock.json
+│   ├── tsconfig.json
+│   ├── tsconfig.worker.json
+│   ├── build.mjs
+│   ├── src/
+│   │   ├── bootstrap.ts
+│   │   ├── api/
+│   │   │   ├── client.ts
+│   │   │   └── generated.ts
+│   │   ├── core/
+│   │   │   ├── dom.ts
+│   │   │   ├── events.ts
+│   │   │   ├── settings.ts
+│   │   │   └── state.ts
+│   │   ├── features/
+│   │   │   ├── audio/
+│   │   │   ├── bookmarks/
+│   │   │   ├── map/
+│   │   │   ├── navigation/
+│   │   │   ├── radio/
+│   │   │   ├── recorder/
+│   │   │   ├── scheduler/
+│   │   │   └── spectrum/
+│   │   ├── decoders/
+│   │   ├── workers/
+│   │   └── legacy/
+│   │       └── global-bridge.ts
+│   └── tests/
+└── assets/web/
+    ├── generated/
+    ├── vendor/
+    ├── index.html
+    ├── style.css
+    └── themes.css
+```
+
+The exact feature directories may evolve, but dependencies should point from
+features toward `core` and `api`, never from `core` back into features.
+
+## 6. Tooling
+
+Use TypeScript for type checking and esbuild for bundling. A framework-specific
+development server is not needed.
+
+Recommended compiler baseline:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "useUnknownInCatchVariables": true,
+    "noEmit": true,
+    "lib": ["ES2022", "DOM"]
+  }
+}
+```
+
+Worker code should use a separate configuration with `WebWorker` rather than
+`DOM` globals.
+
+The package scripts should provide at least:
+
+```text
+npm run typecheck
+npm run lint
+npm test
+npm run build
+npm run verify-generated
+```
+
+Pin dependencies in `package-lock.json`. New package and generated files must
+carry or inherit valid REUSE licensing information.
+
+## 7. Cargo and Asset Integration
+
+Cargo must remain usable on machines without Node.js. Do not invoke `npm`
+automatically from `build.rs`.
+
+The initial integration should work as follows:
+
+1. TypeScript and JavaScript sources live under `frontend/src`.
+2. esbuild writes browser-ready output under `assets/web/generated`.
+3. Generated browser output is committed to the repository.
+4. Rust embeds generated output, not TypeScript source.
+5. CI rebuilds the frontend and fails if committed output is stale.
+
+During early phases, retain the existing public URLs, including:
+
+```text
+/app.js
+/ui-core.js
+/map-core.js
+/scheduler.js
+/decode-history-worker.js
+```
+
+Keeping these URLs stable avoids coupling the first migration phases to changes
+in HTML loading, authentication rules, caching, or Rust routing.
+
+After modules and code splitting are established, replace the explicit list of
+Rust constants and handlers with an embedded generated-asset directory. The
+server must still enforce an allowlist, correct MIME types, cache headers, and
+path traversal protection.
+
+## 8. Rust-to-TypeScript Contracts
+
+Generate TypeScript definitions from Rust wire types instead of maintaining
+parallel handwritten representations.
+
+Initial candidates include:
+
+- `RigState`, `RigInfo`, and `RigCapabilities`;
+- the `/rigs` response;
+- decoder registry entries;
+- scheduler configuration and status;
+- filter and spectrum state;
+- recorder responses;
+- SSE update payloads;
+- decoded-message variants;
+- WebSocket control and status messages.
+
+A generator such as `ts-rs` can produce
+`frontend/src/api/generated.ts`. Generated definitions should describe only
+wire formats. UI state and view models should remain handwritten.
+
+CI must regenerate these definitions and fail when the working tree changes.
+Serde renames, tagged enums, optional fields, flattened values, and numeric
+ranges must be checked explicitly during the initial generator integration.
+
+TypeScript types do not validate data at runtime. Critical compatibility
+boundaries should retain focused runtime checks for missing or malformed data,
+particularly when clients and servers may run different versions.
+
+## 9. Target Module Contracts
+
+Plugins should eventually implement an explicit interface rather than assigning
+callbacks to `window`:
+
+```ts
+interface TrxPlugin {
+  readonly id: string;
+  initialize(context: PluginContext): void | Promise<void>;
+  dispose?(): void;
+}
+
+interface PluginContext {
+  api: TrxApi;
+  events: TrxEventBus;
+  navigation: NavigationService;
+  notifications: NotificationService;
+  state: ReadonlyRadioState;
+}
+```
+
+During the transition, `legacy/global-bridge.ts` may expose the minimum globals
+required by unmigrated scripts. The bridge must shrink as migration progresses;
+new feature code must not add new global callbacks.
+
+State should be divided by responsibility rather than replaced by one large
+typed global:
+
+```ts
+interface RadioState {
+  activeRigId: string | null;
+  capabilities: RigCapabilities | null;
+  connection: ConnectionState;
+  frequencyHz: number | null;
+  mode: RigMode | null;
+  bandwidthHz: number | null;
+}
+
+interface AudioState {
+  rx: AudioStreamState;
+  tx: AudioStreamState;
+  volume: VolumeState;
+}
+
+interface DecoderState {
+  registry: DecoderDescriptor[];
+  status: ReadonlyMap<DecoderId, DecoderStatus>;
+}
+```
+
+Commands should receive a rig ID explicitly. They must not infer their target
+from mutable global selection state after an asynchronous operation begins.
+
+## 10. Migration Phases
+
+### Phase 0: Baseline and Measurements
+
+- Record current asset names, sizes, and load order.
+- Add a browser startup smoke test.
+- Record existing global symbols and plugin callbacks.
+- Confirm that generated bundles do not introduce remote runtime dependencies.
+
+**Exit criterion:** current behavior and asset loading have an automated
+baseline.
+
+### Phase 1: Tooling Scaffold
+
+- Add the frontend package, lockfile, TypeScript configuration, and esbuild.
+- Allow existing JavaScript as build input without type checking it globally.
+- Produce fixed-name outputs matching current URLs.
+- Add frontend commands and CI checks.
+- Document local frontend development commands.
+
+**Exit criterion:** existing JavaScript passes through the frontend build with
+no runtime changes, and CI detects stale generated output.
+
+### Phase 2: Generated API Types
+
+- Add Rust-to-TypeScript type generation.
+- Generate the first status, rig, capability, and decoder contracts.
+- Introduce a typed fetch/post client and typed SSE decoding boundary.
+- Keep narrow runtime guards at compatibility boundaries.
+
+**Exit criterion:** new API consumers cannot use untyped response objects.
+
+### Phase 3: Core Browser Services
+
+Convert or create:
+
+- DOM lookup helpers;
+- notifications and confirmations;
+- settings and per-rig preferences;
+- navigation;
+- the event bus;
+- application state stores;
+- plugin registry and loader.
+
+Convert `ui-core.js` as the first strict TypeScript entry.
+
+**Exit criterion:** shared UI behavior is TypeScript, tested, and does not add
+new globals.
+
+### Phase 4: Independent Leaf Modules
+
+Convert lower-coupling code first:
+
+1. WebGL renderer;
+2. decode-history worker;
+3. screenshot support;
+4. FT2 and FT4;
+5. WSPR;
+6. CW and other decoder views.
+
+Workers must be separate build entries.
+
+**Exit criterion:** each converted module has typed inputs, outputs, and tests.
+
+### Phase 5: Plugin Loading
+
+- Move the inline loader out of `index.html`.
+- Replace classic-script injection with typed dynamic imports.
+- Register plugins through `TrxPlugin`.
+- Preserve lazy loading by tab and feature.
+- Remove the corresponding global callbacks after each plugin migrates.
+
+**Exit criterion:** plugin dependencies and loading order are represented by the
+module graph rather than implicit script order.
+
+### Phase 6: Split the Main Application
+
+Extract `app.js` by responsibility:
+
+1. authentication and API transport;
+2. rig enumeration and switching;
+3. radio commands and capabilities;
+4. audio streaming;
+5. spectrum state and rendering;
+6. decode history;
+7. recorder;
+8. keyboard shortcuts;
+9. application bootstrap.
+
+Do not split by arbitrary line ranges. Each extraction must establish an
+explicit interface and remove the corresponding globals.
+
+**Exit criterion:** the bootstrap file composes services and features but does
+not contain their implementations.
+
+### Phase 7: High-Coupling Features
+
+Convert the remaining large features after the core contracts are stable:
+
+- scheduler and satellite scheduler;
+- bookmarks;
+- virtual channels;
+- map and map-backed statistics;
+- remaining decoder plugins.
+
+**Exit criterion:** no first-party classic scripts or untyped plugin callbacks
+remain.
+
+### Phase 8: Asset-Server Consolidation
+
+- Enable code splitting and hashed chunks.
+- Embed the generated asset directory in Rust.
+- Serve generated assets through a generic, allowlisted handler.
+- Add appropriate immutable caching for hashed output.
+- Retain stable handling for HTML and version metadata.
+- Remove obsolete fixed-asset constants and handlers.
+
+**Exit criterion:** Rust no longer needs a source edit for every generated
+frontend chunk.
+
+### Phase 9: Strictness and Cleanup
+
+- Remove `allowJs`.
+- Remove the legacy global bridge.
+- Enable all selected strict compiler and lint rules.
+- Remove obsolete generated compatibility bundles.
+- Update architecture and contributor documentation.
+
+**Exit criterion:** all first-party frontend source is strict TypeScript and the
+browser runtime exposes only intentionally documented globals.
+
+## 11. Testing Strategy
+
+Frontend CI should run:
+
+```sh
+npm ci
+npm run typecheck
+npm run lint
+npm test
+npm run build
+git diff --exit-code -- assets/web/generated frontend/src/api/generated.ts
+```
+
+Testing should cover four layers:
+
+1. **Pure unit tests** for bandwidth calculations, formatting, state changes,
+   capability decisions, and message routing.
+2. **DOM component tests** for dialogs, tabs, workspace selection, rig
+   switching, and collapsible control sections.
+3. **Worker tests** for decode-history pruning, batching, and message formats.
+4. **Browser smoke tests** for startup, authentication gating, plugin loading,
+   navigation, rig switching, audio controls, and map initialization.
+
+The existing dependency-free `ui-core` test can remain during the scaffold
+phase. It should be moved to the standard TypeScript test runner once that
+runner is established.
+
+## 12. CI Changes
+
+Add a dedicated frontend job rather than hiding frontend work inside the Cargo
+jobs. The job should:
+
+- use the Node.js version provided by the runner image;
+- run with `npm ci`, never a mutable install;
+- cache the npm download cache, not `node_modules`;
+- type-check, lint, test, and build;
+- verify generated artifacts and Rust-generated types are current;
+- run REUSE validation after generated files are produced.
+
+Rust lint and test jobs should continue to consume committed generated assets.
+
+## 13. Pull Request Strategy
+
+Use small, independently reversible pull requests. A recommended sequence is:
+
+1. tooling and unchanged JavaScript build;
+2. generated Rust wire types and typed API client;
+3. `ui-core` conversion;
+4. worker and WebGL conversion;
+5. decoder plugin conversions in small groups;
+6. plugin registry and dynamic imports;
+7. one `app.js` responsibility per PR;
+8. scheduler, bookmarks, and map conversions;
+9. generic embedded asset serving;
+10. removal of JavaScript compatibility mode.
+
+Every PR should include:
+
+- runtime behavior preserved or intentionally documented;
+- frontend type checking and tests;
+- strict Rust formatting and Clippy;
+- generated-artifact drift verification;
+- no newly introduced undocumented `window` globals;
+- no remote runtime asset dependency.
+
+## 14. Risks and Mitigations
+
+### Superficial Conversion
+
+**Risk:** globals receive declarations but remain coupled and mutable.
+
+**Mitigation:** require every converted module to expose explicit inputs and
+outputs and remove at least the globals it replaces.
+
+### Cargo Becomes Dependent on Node
+
+**Risk:** builds fail on systems without Node or network access.
+
+**Mitigation:** commit deterministic generated output and keep npm outside
+`build.rs`.
+
+### Script-Order Regressions
+
+**Risk:** switching to modules changes execution timing and scope.
+
+**Mitigation:** retain current public entries initially, then replace script
+loading only after the plugin registry is in place.
+
+### Unreviewable `app.js` Rewrite
+
+**Risk:** a large conversion is difficult to review, test, or bisect.
+
+**Mitigation:** extract one responsibility at a time and keep bootstrap working
+after every extraction.
+
+### Rust and Browser Contracts Drift
+
+**Risk:** TypeScript compiles against stale wire definitions.
+
+**Mitigation:** generate types from Rust and enforce a clean working tree after
+generation in CI.
+
+### Generated Asset Noise
+
+**Risk:** committed bundles make reviews noisy.
+
+**Mitigation:** separate source and generated commits when useful, include
+source maps, and require deterministic output.
+
+### Bundle or Startup Regression
+
+**Risk:** bundling loads too much code eagerly.
+
+**Mitigation:** record the current baseline, preserve feature-level lazy loads,
+and track entry/chunk sizes in CI.
+
+## 15. Initial Proof of Concept
+
+The first implementation PR should be deliberately limited to:
+
+1. adding the frontend package and locked toolchain;
+2. building existing JavaScript to fixed-name generated output;
+3. adding frontend CI and drift checks;
+4. generating initial rig/status TypeScript definitions;
+5. introducing the typed API client;
+6. converting `ui-core.js` to strict TypeScript;
+7. preserving every existing asset URL and observable behavior.
+
+This proof of concept is the decision gate for the remainder of the migration.
+If it materially improves contract safety without making Cargo development
+unwieldy, continue with the phased plan. If it does not, the repository can
+retain the tooling and the converted core without committing to a full rewrite.
+
+## 16. Completion Criteria
+
+The migration is complete when:
+
+- all first-party browser source is strict TypeScript;
+- vendor files remain isolated and declared through narrow type adapters;
+- Rust wire types generate their browser contracts;
+- no feature depends on accidental script ordering;
+- no undocumented mutable `window` callbacks remain;
+- `app.js` has been replaced by a small typed bootstrap and feature modules;
+- frontend type checking, linting, unit tests, component tests, browser smoke
+  tests, and generated-output checks run in CI;
+- Cargo builds remain possible without Node.js or network access;
+- production assets remain local, embedded, cacheable, and reproducible.

src/decoders/trx-wefax/src/image.rs

@@ -274,7 +274,8 @@ mod tests {
 
         // Pseudo-random noise vs gradient — correlation should be low.
         let noise: Vec<u8> = (0..256)
-            .map(|i| ((i * 1103515245 + 12345) as u32 >> 8 & 0xff) as u8)
+            .map(|i| (i as u32).wrapping_mul(1_103_515_245).wrapping_add(12_345))
+            .map(|value| ((value >> 8) & 0xff) as u8)
             .collect();
         let r = asm.correlation_with_last(&noise).expect("r");
         assert!(

src/trx-client/trx-frontend/trx-frontend-http/Cargo.toml

@@ -29,3 +29,4 @@ hex = "0.4"
 pickledb = "0.5"
 dirs = "6"
 uuid = { workspace = true }
+ts-rs = "12.0.1"

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

@@ -0,0 +1,336 @@
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/ais.ts
+var aisWindow = window;
+var escapeAisHtml = (input) => hostCore.escapeMapHtml(input);
+var aisStatus = document.getElementById("ais-status");
+var aisMessagesEl = document.getElementById("ais-messages");
+var aisFilterInput = document.getElementById("ais-filter");
+var aisBarOverlay = document.getElementById("ais-bar-overlay");
+var aisChannelSummaryEl = document.getElementById("ais-channel-summary");
+var aisVesselCountEl = document.getElementById("ais-vessel-count");
+var aisLatestSeenEl = document.getElementById("ais-latest-seen");
+var AIS_BAR_WINDOW_MS = 15 * 60 * 1e3;
+var AIS_DEFAULT_A_HZ = 161975e3;
+var AIS_CHANNEL_SPACING_HZ = 5e4;
+var aisFilterText = "";
+var aisMessageHistory = [];
+function currentAisHistoryRetentionMs() {
+  return typeof aisWindow.getDecodeHistoryRetentionMs === "function" ? aisWindow.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1e3;
+}
+function pruneAisMessageHistory() {
+  const cutoffMs = Date.now() - currentAisHistoryRetentionMs();
+  aisMessageHistory = aisMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
+}
+function scheduleAisUi(key, job) {
+  if (typeof aisWindow.trxScheduleUiFrameJob === "function") {
+    aisWindow.trxScheduleUiFrameJob(key, job);
+    return;
+  }
+  job();
+}
+function scheduleAisHistoryRender() {
+  scheduleAisUi("ais-history", () => {
+    renderAisHistory();
+  });
+}
+function scheduleAisBarUpdate() {
+  scheduleAisUi("ais-bar", () => {
+    updateAisBar();
+  });
+}
+function formatAisMhz(freqHz) {
+  return `${(freqHz / 1e6).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 = (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 = escapeAisHtml(aisDisplayName(msg));
+  const url = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
+  if (!url) return label;
+  return `<a class="title-link" href="${escapeAisHtml(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 (typeof tsMs !== "number" || !Number.isFinite(tsMs)) return "just now";
+  const deltaMs = Math.max(0, Date.now() - tsMs);
+  const seconds = Math.round(deltaMs / 1e3);
+  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 ? `${msg.sog_knots.toFixed(1)} kn` : null,
+    msg.cog_deg != null ? `${msg.cog_deg.toFixed(1)}° COG` : null,
+    msg.heading_deg != null ? `${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 (hostState.serverLat == null || hostState.serverLon == null || msg.lat == null || msg.lon == null) {
+    return "";
+  }
+  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`;
+}
+function aisLatestByVessel(messages) {
+  const byMmsi = /* @__PURE__ */ 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 || (/* @__PURE__ */ 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}">${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>`;
+  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 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 ?? 0) >= 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 ${escapeAisHtml(String(msg.mmsi))}`,
+      escapeAisHtml(channel.label),
+      msg.sog_knots != null ? `${msg.sog_knots.toFixed(1)} kn` : null,
+      msg.cog_deg != null ? `${msg.cog_deg.toFixed(1)}°` : null,
+      distance ? escapeAisHtml(distance) : null,
+      escapeAisHtml(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";
+}
+aisWindow.updateAisBar = updateAisBar;
+aisWindow.clearAisBar = function() {
+  resetAisHistoryView();
+};
+function resetAisHistoryView() {
+  if (aisMessagesEl) aisMessagesEl.innerHTML = "";
+  aisMessageHistory = [];
+  updateAisBar();
+  renderAisHistory();
+  aisWindow.clearMapMarkersByType?.("ais");
+}
+function renderAisHistory() {
+  pruneAisMessageHistory();
+  if (!aisMessagesEl) {
+    updateAisSummary();
+    return;
+  }
+  const fragment = document.createDocumentFragment();
+  for (const message of aisMessageHistory) {
+    fragment.appendChild(renderAisRow(message));
+  }
+  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 && aisWindow.aisMapAddVessel) {
+    aisWindow.aisMapAddVessel(msg);
+  }
+}
+function normalizeServerAisMessage(msg) {
+  return {
+    ...msg,
+    rig_id: msg.rig_id || null
+  };
+}
+function onServerAisBatch(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return;
+  if (aisStatus) aisStatus.textContent = "Receiving";
+  const normalized = [];
+  for (const msg of messages) {
+    const next = normalizeServerAisMessage(msg);
+    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 && aisWindow.aisMapAddVessel) {
+      aisWindow.aisMapAddVessel(next);
+    }
+    normalized.push(next);
+  }
+  normalized.reverse();
+  aisMessageHistory = normalized.concat(aisMessageHistory);
+  pruneAisMessageHistory();
+  scheduleAisBarUpdate();
+  scheduleAisHistoryRender();
+}
+function pruneAisHistoryView() {
+  pruneAisMessageHistory();
+  updateAisBar();
+  renderAisHistory();
+}
+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 hostCore.postPath("/clear_ais_decode");
+      resetAisHistoryView();
+    } catch (e) {
+      console.error("AIS history clear failed", e);
+    }
+  })();
+});
+if (aisFilterInput) {
+  aisFilterInput.addEventListener("input", () => {
+    aisFilterText = aisFilterInput.value.trim().toUpperCase();
+    renderAisHistory();
+  });
+}
+function onServerAis(msg) {
+  if (aisStatus) aisStatus.textContent = "Receiving";
+  addAisMessage(normalizeServerAisMessage(msg));
+}
+updateAisSummary();
+window.trxPluginRuntime.registerDecoder({
+  id: "ais",
+  onMessage: onServerAis,
+  onBatch: onServerAisBatch,
+  restore: onServerAisBatch,
+  reset: resetAisHistoryView,
+  prune: pruneAisHistoryView
+});

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

@@ -0,0 +1,318 @@
+import {
+  aprsAgeText,
+  aprsCategoryLabel,
+  aprsHexBytes,
+  aprsPacketCategory,
+  collapseAprsDuplicates,
+  normalizeAprsPacket,
+  renderAprsInfo,
+  renderLocalAprsSymbol
+} from "./chunk-M2I6DH4X.js";
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/aprs.ts
+var aprsWindow = window;
+var escapeAprsHtml = (input) => hostCore.escapeMapHtml(input);
+var showAprsHint = (message, durationMs) => {
+  hostCore.showHint(message, durationMs);
+};
+var aprsStatus = document.getElementById("aprs-status");
+var aprsPacketsEl = document.getElementById("aprs-packets");
+var aprsFilterInput = document.getElementById("aprs-filter");
+var aprsBarOverlay = document.getElementById("aprs-bar-overlay");
+var aprsOnlyPosBtn = document.getElementById("aprs-only-pos-btn");
+var aprsHideCrcBtn = document.getElementById("aprs-hide-crc-btn");
+var aprsCollapseDupBtn = document.getElementById("aprs-collapse-dup-btn");
+var aprsTotalCountEl = document.getElementById("aprs-total-count");
+var aprsVisibleCountEl = document.getElementById("aprs-visible-count");
+var aprsLatestSeenEl = document.getElementById("aprs-latest-seen");
+var APRS_BAR_WINDOW_MS = 15 * 60 * 1e3;
+var aprsFilterText = "";
+var aprsPacketHistory = [];
+var aprsBarDismissedAtMs = 0;
+var aprsOnlyPos = false;
+var aprsHideCrc = false;
+var aprsCollapseDup = false;
+var aprsTypeFilter = "all";
+function currentAprsHistoryRetentionMs() {
+  return typeof aprsWindow.getDecodeHistoryRetentionMs === "function" ? aprsWindow.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1e3;
+}
+function pruneAprsPacketHistory() {
+  const cutoffMs = Date.now() - currentAprsHistoryRetentionMs();
+  aprsPacketHistory = aprsPacketHistory.filter((pkt) => (pkt._tsMs ?? 0) >= cutoffMs);
+}
+function scheduleAprsUi(key, job) {
+  if (typeof aprsWindow.trxScheduleUiFrameJob === "function") {
+    aprsWindow.trxScheduleUiFrameJob(key, job);
+    return;
+  }
+  job();
+}
+function scheduleAprsHistoryRender() {
+  scheduleAprsUi("aprs-history", () => {
+    renderAprsHistory();
+  });
+}
+function scheduleAprsBarUpdate() {
+  scheduleAprsUi("aprs-bar", () => {
+    updateAprsBar();
+  });
+}
+function aprsDistanceText(pkt) {
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
+  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`;
+}
+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 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 || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  const age = aprsAgeText(pkt._tsMs);
+  const category = aprsPacketCategory(pkt);
+  const categoryLabel = aprsCategoryLabel(category);
+  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
+  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeAprsHtml(pkt.path)}</span>` : "";
+  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
+  const symbolHtml = renderLocalAprsSymbol(pkt, escapeAprsHtml);
+  const posLink = pkt.lat != null && pkt.lon != null ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>` : "";
+  const distance = aprsDistanceText(pkt);
+  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
+  row.innerHTML = `<div class="aprs-row-head"><span class="aprs-time">${ts}</span>` + symbolHtml + `<span class="aprs-call">${escapeAprsHtml(pkt.srcCall ?? "")}</span><span>&gt;${escapeAprsHtml(pkt.destCall || "")}</span><span class="${categoryClass}">${escapeAprsHtml(categoryLabel)}</span>` + pathBadge + crcBadge + `</div><div class="aprs-row-meta"><span class="aprs-meta-text">${escapeAprsHtml(age)}</span>` + (distance ? `<span class="aprs-meta-text">${escapeAprsHtml(distance)}</span>` : "") + `<span class="aprs-meta-text">${escapeAprsHtml(pkt.type || "--")}</span></div><div class="aprs-row-detail"><span title="${escapeAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` + (posLink ? `<span>${posLink}</span>` : "") + `</div><div class="aprs-row-actions">` + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div><details class="aprs-details"><summary>Details</summary><div class="aprs-details-grid"><span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.srcCall || "--")}</span><span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.destCall || "--")}</span><span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.type || "--")}</span><span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.path || "--")}</span><span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeAprsHtml(age)}</span><span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span><span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span><span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeAprsHtml(pkt.info || "--")}</span><span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeAprsHtml(aprsHexBytes(pkt.info_bytes))}</span></div></details>`;
+  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
+    el.addEventListener("click", (evt) => {
+      evt.preventDefault();
+      const raw = el.dataset.aprsMap ?? "";
+      const [lat, lon] = raw.split(",").map(Number);
+      if (aprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
+        aprsWindow.navigateToAprsMap(lat, lon);
+      }
+    });
+  });
+  const copyBtn = row.querySelector("[data-aprs-copy]");
+  if (copyBtn) {
+    copyBtn.addEventListener("click", () => {
+      void (async () => {
+        const raw = copyBtn.dataset.aprsCopy ?? "";
+        try {
+          const clipboard = Reflect.get(navigator, "clipboard");
+          if (clipboard) {
+            await clipboard.writeText(raw);
+            showAprsHint("Coordinates copied", 1200);
+          }
+        } catch {
+          showAprsHint("Copy failed", 1500);
+        }
+      })();
+    });
+  }
+  return row;
+}
+function renderAprsHistory() {
+  pruneAprsPacketHistory();
+  if (!aprsPacketsEl) {
+    updateAprsSummary();
+    updateAprsChipState();
+    return;
+  }
+  const visible = aprsVisiblePackets();
+  const fragment = document.createDocumentFragment();
+  for (const [index, packet] of visible.entries()) {
+    fragment.appendChild(renderAprsRow(packet, index === 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 ?? 0) >= 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">${escapeAprsHtml(pkt.srcCall ?? "")}</span>`;
+    const dest = escapeAprsHtml(pkt.destCall || "");
+    const info = escapeAprsHtml(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";
+}
+aprsWindow.updateAprsBar = updateAprsBar;
+aprsWindow.clearAprsBar = function() {
+  resetAprsHistoryView();
+};
+aprsWindow.closeAprsBar = function() {
+  aprsBarDismissedAtMs = Date.now();
+  if (aprsBarOverlay) {
+    aprsBarOverlay.style.display = "none";
+    aprsBarOverlay.innerHTML = "";
+  }
+};
+function resetAprsHistoryView() {
+  if (aprsPacketsEl) aprsPacketsEl.innerHTML = "";
+  aprsPacketHistory = [];
+  updateAprsBar();
+  renderAprsHistory();
+  aprsWindow.clearMapMarkersByType?.("aprs");
+}
+function pruneAprsHistoryView() {
+  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 && aprsWindow.aprsMapAddStation) {
+    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
+  }
+  if (pkt.crcOk) scheduleAprsBarUpdate();
+  scheduleAprsHistoryRender();
+}
+function normalizeServerAprsPacket(pkt) {
+  return normalizeAprsPacket(pkt, aprsWindow.getDecodeRigMeta?.() ?? null);
+}
+function onServerAprsBatch(packets) {
+  if (!Array.isArray(packets) || packets.length === 0) return;
+  if (aprsStatus) aprsStatus.textContent = "Receiving";
+  const normalized = [];
+  let hasCrcOk = false;
+  for (const pkt of packets) {
+    const next = normalizeServerAprsPacket(pkt);
+    const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
+    next._tsMs = tsMs;
+    next._ts = new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    if (next.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
+      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
+    }
+    if (next.crcOk) hasCrcOk = true;
+    normalized.push(next);
+  }
+  normalized.reverse();
+  aprsPacketHistory = normalized.concat(aprsPacketHistory);
+  pruneAprsPacketHistory();
+  if (hasCrcOk) scheduleAprsBarUpdate();
+  scheduleAprsHistoryRender();
+}
+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 hostCore.postPath("/clear_aprs_decode");
+      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();
+  });
+}
+function onServerAprs(pkt) {
+  if (aprsStatus) aprsStatus.textContent = "Receiving";
+  addAprsPacket(normalizeServerAprsPacket(pkt));
+}
+renderAprsHistory();
+window.trxPluginRuntime.registerDecoder({
+  id: "aprs",
+  onMessage: onServerAprs,
+  onBatch: onServerAprsBatch,
+  restore: onServerAprsBatch,
+  reset: resetAprsHistoryView,
+  prune: pruneAprsHistoryView
+});

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

@@ -0,0 +1,370 @@
+import {
+  hostState
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/background-decode.ts
+var bgdWindow = window;
+(function() {
+  "use strict";
+  function bgdSupportedIds() {
+    return (bgdWindow.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 ${String(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 ${String(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 ${String(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 ${String(r.status)}`);
+      return r.json();
+    });
+  }
+  function apiGetBookmarks() {
+    return fetch("/bookmarks").then(function(r) {
+      if (!r.ok) throw new Error(`HTTP ${String(r.status)}`);
+      return r.json();
+    });
+  }
+  function loadBackgroundDecode() {
+    const rigId = currentRigId;
+    if (!rigId) return;
+    Promise.all([apiGetConfig(rigId), apiGetBookmarks()]).then(function([config, bookmarks]) {
+      currentConfig = config;
+      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) {
+    const ids = bgdSupportedIds();
+    const decoders = bookmark.decoders ?? [];
+    const explicit = decoders.map(function(item) {
+      return item.trim().toLowerCase();
+    }).filter(function(item, index, arr) {
+      return ids.indexOf(item) >= 0 && arr.indexOf(item) === index;
+    });
+    if (explicit.length > 0) return explicit;
+    const mode = bookmark.mode.trim().toUpperCase();
+    return (bgdWindow.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" || hostState.authEnabled === false;
+    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) {
+      const 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) {
+      const row = document.createElement("label");
+      row.className = "bgd-checklist-row";
+      const decoders = bookmarkDecoderKinds(bookmark);
+      const checked = selectedIds.has(bookmark.id) ? " checked" : "";
+      row.innerHTML = '<input type="checkbox"' + checked + ' data-bm-id="' + escHtml(bookmark.id) + '" /><span class="bgd-checklist-name">' + escHtml(bookmark.name) + '</span><span class="bgd-checklist-meta">' + escHtml(formatFreq(bookmark.freq_hz) + " " + bookmark.mode + " · " + decoders.join("/").toUpperCase()) + "</span>";
+      row.querySelector("input")?.addEventListener("change", function(e) {
+        onChecklistToggle(bookmark.id, e.currentTarget.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 ?? false,
+      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.", false);
+    }).catch(function(err) {
+      showToast(`Save failed: ${errorMessage(err)}`, true);
+    }).finally(function() {
+      if (btn) btn.disabled = false;
+    });
+  }
+  async function resetBackgroundDecode() {
+    const rigId = currentRigId;
+    if (!rigId) return;
+    if (!await bgdWindow.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.", false);
+    }).catch(function(err) {
+      showToast(`Reset failed: ${errorMessage(err)}`, true);
+    });
+  }
+  function startStatusPolling() {
+    if (statusInterval) clearInterval(statusInterval);
+    statusInterval = setInterval(pollBackgroundDecodeStatus, 15e3);
+  }
+  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 = status.entries ?? [];
+    if (!entries.length) {
+      card.textContent = "No background decode bookmarks configured.";
+      return;
+    }
+    const summary = [];
+    if (status.active_rig) {
+      if (typeof status.center_hz === "number" && Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
+      if (typeof status.sample_rate === "number" && Number.isFinite(status.sample_rate) && status.sample_rate > 0) summary.push("Span ±" + formatFreq(status.sample_rate / 2));
+    } else {
+      summary.push("This rig is not currently selected for audio.");
+    }
+    let html = summary.length ? '<div style="margin-bottom:0.8rem;color:var(--text-muted);">' + escHtml(summary.join(" · ")) + "</div>" : "";
+    html += '<div class="bgd-status-list">';
+    entries.forEach(function(entry) {
+      const name = entry.bookmark_name || entry.bookmark_id || "Unknown bookmark";
+      const parts = [];
+      if (typeof entry.freq_hz === "number" && Number.isFinite(entry.freq_hz)) parts.push(formatFreq(entry.freq_hz));
+      if (entry.mode) parts.push(entry.mode);
+      if (Array.isArray(entry.decoder_kinds) && entry.decoder_kinds.length) {
+        parts.push(entry.decoder_kinds.join("/").toUpperCase());
+      }
+      html += '<div class="bgd-status-row"><div><div class="bgd-status-name">' + escHtml(name) + '</div><div class="bgd-status-meta">' + escHtml(parts.join(" · ")) + '</div></div><div class="bgd-status-state" data-state="' + escHtml(entry.state || "inactive") + '"><svg class="bgd-state-dot" viewBox="0 0 8 8"><circle cx="4" cy="4" r="3.5"/></svg>' + escHtml(prettyState(entry.state)) + "</div></div>";
+    });
+    html += "</div>";
+    card.innerHTML = html;
+  }
+  function prettyState(state) {
+    switch (state) {
+      case "active":
+        return "✓ Active";
+      case "out_of_span":
+        return "△ Out of span";
+      case "waiting_for_spectrum":
+        return "△ Waiting";
+      case "waiting_for_user":
+        return "△ No user";
+      case "missing_bookmark":
+        return "✗ Missing";
+      case "no_supported_decoders":
+        return "✗ Unsupported";
+      case "disabled":
+        return "△ Disabled";
+      case "handled_by_scheduler":
+        return "△ Scheduler";
+      case "scheduler_has_control":
+        return "△ Scheduler";
+      case "handled_by_virtual_channel":
+        return "△ VChan";
+      default:
+        return "△ 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 `${String(hz)} Hz`;
+  }
+  function escHtml(value) {
+    const text = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : "";
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  function markBgdDirty() {
+    if (bgdDirty) return;
+    bgdDirty = true;
+    const btn = document.getElementById("background-decode-save-btn");
+    if (btn) btn.classList.add("sch-dirty");
+  }
+  function clearBgdDirty() {
+    bgdDirty = false;
+    const 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";
+    }, 3e3);
+  }
+  function selectAllBookmarks() {
+    if (!currentConfig) {
+      currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
+    }
+    const 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", () => {
+        void resetBackgroundDecode();
+      });
+    }
+  }
+  bgdWindow.trx ??= {};
+  bgdWindow.trx.modules ??= {};
+  bgdWindow.trx.modules.backgroundDecode = {
+    initialize: initBackgroundDecode,
+    wireEvents: wireBackgroundDecodeEvents,
+    setRig: setBackgroundDecodeRig
+  };
+})();

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

@@ -0,0 +1,666 @@
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/bookmarks.ts
+var bridge = window;
+function bmEl(id) {
+  const element = document.getElementById(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);
+}
+var bmScope = "general";
+function bmScopeParam(prefix, scope) {
+  const sep = prefix ? "&" : "?";
+  return sep + "scope=" + encodeURIComponent(scope != null ? scope : bmScope);
+}
+var bmList = [];
+var bmOverlayList = [];
+var bmOverlayRevision = 0;
+var bmFilteredList = [];
+var bmEditScope = null;
+var bmCurrentPage = 1;
+var BM_PAGE_SIZE = 25;
+var bmSelected = /* @__PURE__ */ new Set();
+function bmFmtFreq(hz) {
+  if (!Number.isFinite(hz) || hz <= 0) return "--";
+  if (hz >= 1e9) return (hz / 1e9).toFixed(6).replace(/\.?0+$/, "") + " GHz";
+  if (hz >= 1e6) return (hz / 1e6).toFixed(6).replace(/\.?0+$/, "") + " MHz";
+  if (hz >= 1e3) return (hz / 1e3).toFixed(3).replace(/\.?0+$/, "") + " kHz";
+  return `${hz} Hz`;
+}
+function bmEsc(str) {
+  const d = document.createElement("div");
+  d.appendChild(document.createTextNode(String(str)));
+  return d.innerHTML;
+}
+function bmCanControl() {
+  return !hostState.authEnabled || hostState.authRole === "control";
+}
+function bmSyncAccess() {
+  const canCtrl = bmCanControl();
+  const addBtn = bmEl("bm-add-btn");
+  const selectAllBtn = bmEl("bm-select-all-btn");
+  if (addBtn) addBtn.style.display = canCtrl ? "" : "none";
+  if (selectAllBtn) selectAllBtn.style.display = canCtrl ? "" : "none";
+}
+function bmListScope() {
+  return hostState.lastActiveRigId || "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 bridge.syncBookmarkMapLocators === "function") {
+    bridge.syncBookmarkMapLocators(bmOverlayList);
+  }
+  hostCore.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 = [];
+  }
+  bmSelected.clear();
+  bmUpdateSelectionUi();
+  bmSyncAccess();
+  bmApplyFilters();
+  void bmRefreshCategoryFilter(categoryFilter);
+  await overlayPromise;
+}
+function bmApplyFilters() {
+  const text = (bmEl("bm-text-filter")?.value || "").trim().toLowerCase();
+  const modeFilter = (bmEl("bm-mode-filter")?.value || "").trim().toUpperCase();
+  let filtered = modeFilter ? bmList.filter((bm) => (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 = bmEl("bm-category-filter");
+  const modeSel = bmEl("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) => (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 = bmEl("bm-tbody");
+  const emptyEl = bmEl("bm-empty");
+  const paginatorEl = bmEl("bm-paginator");
+  const pageSummaryEl = bmEl("bm-page-summary");
+  const pageIndicatorEl = bmEl("bm-page-indicator");
+  const prevBtn = bmEl("bm-page-prev");
+  const nextBtn = bmEl("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);
+}
+function bmReadDecoders() {
+  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 || []);
+  hostState.decoderRegistry.filter((d) => d.bookmark_selectable).forEach((d) => {
+    const el = bmOptionalEl("bm-dec-" + d.id);
+    if (el) el.checked = set.has(d.id);
+  });
+}
+function bmBuildDecoderCheckboxes() {
+  const container = bmEl("bm-decoder-checkboxes");
+  if (!container) return;
+  container.innerHTML = "";
+  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;
+    container.appendChild(label);
+  });
+}
+function bmOpenForm(bm) {
+  const wrap = bmEl("bm-form-wrap");
+  if (!wrap) return;
+  bmEditScope = bm ? bm.scope || bmScope : null;
+  bmBuildDecoderCheckboxes();
+  bmEl("bm-id").value = bm ? bm.id : "";
+  bmEl("bm-name").value = bm ? bm.name : "";
+  bmEl("bm-freq").value = bm ? String(bm.freq_hz) : "";
+  bmEl("bm-mode").value = bm ? bm.mode : "";
+  bmEl("bm-bw").value = bm?.bandwidth_hz ? String(bm.bandwidth_hz) : "";
+  bmEl("bm-locator").value = bm ? bm.locator || "" : "";
+  bmEl("bm-category-input").value = bm ? bm.category || "" : "";
+  bmEl("bm-comment").value = bm ? bm.comment || "" : "";
+  bmWriteDecoders(bm?.decoders ?? []);
+  bmEl("bm-form-title").textContent = bm ? "Edit Bookmark" : "Add Bookmark";
+  wrap.style.display = "flex";
+  bmEl("bm-name").focus();
+}
+function bmCloseForm() {
+  const wrap = bmEl("bm-form-wrap");
+  if (wrap) wrap.style.display = "none";
+}
+function bmPrefillFromStatus() {
+  const freqHz = hostState.lastFreqHz;
+  if (freqHz != null && Number.isFinite(freqHz)) {
+    bmEl("bm-freq").value = String(Math.round(freqHz));
+  }
+  if (hostState.lastModeName) {
+    bmEl("bm-mode").value = hostState.lastModeName;
+  }
+  if (hostState.currentBandwidthHz > 0) {
+    bmEl("bm-bw").value = String(Math.round(hostState.currentBandwidthHz));
+  }
+  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);
+  bmWriteDecoders(activeDecoders);
+}
+async function bmSave(e) {
+  e.preventDefault();
+  const id = bmEl("bm-id").value;
+  const name = bmEl("bm-name").value.trim();
+  const freqStr = bmEl("bm-freq").value;
+  const freq_hz = parseInt(freqStr, 10);
+  const mode = bmEl("bm-mode").value.trim();
+  const bwStr = bmEl("bm-bw").value;
+  const bandwidth_hz = bwStr ? parseInt(bwStr, 10) : null;
+  const locator = bmEl("bm-locator").value.trim().toUpperCase();
+  const category = bmEl("bm-category-input").value.trim();
+  const comment = bmEl("bm-comment").value.trim();
+  const decoders = bmReadDecoders();
+  const formError = bmEl("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 ? bmEl("bm-name") : !Number.isFinite(freq_hz) ? bmEl("bm-freq") : bmEl("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(bmEl("bm-category-filter").value);
+  } catch (err) {
+    console.error("Failed to save bookmark:", err);
+    if (formError) formError.textContent = "Failed to save bookmark: " + errorMessage(err);
+    bridge.trxUi.notify?.("Bookmark could not be saved", { kind: "error" });
+  }
+}
+async function bmDelete(id) {
+  if (!await bridge.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 : void 0;
+  try {
+    const resp = await fetch("/bookmarks/" + encodeURIComponent(id) + bmScopeParam(false, scope), {
+      method: "DELETE"
+    });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    await bmFetch(bmEl("bm-category-filter").value);
+  } catch (err) {
+    console.error("Failed to delete bookmark:", err);
+    bridge.trxUi.notify?.("Failed to delete bookmark: " + errorMessage(err), { kind: "error" });
+  }
+}
+function bmApply(bm) {
+  try {
+    const modeEl = document.getElementById("mode");
+    if (modeEl) {
+      modeEl.value = (bm.mode || "").toUpperCase();
+    }
+    if (bm.bandwidth_hz) {
+      hostState.currentBandwidthHz = bm.bandwidth_hz;
+      hostCore.syncBandwidthInput(bm.bandwidth_hz);
+    }
+    hostCore.armOptimisticFrequency(bm.freq_hz);
+    hostCore.applyLocalTunedFrequency(bm.freq_hz, true);
+    if (hostState.lastSpectrumData) {
+      hostCore.scheduleSpectrumDraw();
+    }
+    const tunePromise = (async () => {
+      await bridge.trx.modules.vchan?.takeSchedulerControl();
+      const onVirtual = await bridge.trx.modules.vchan?.interceptMode(bm.mode) ?? false;
+      if (!onVirtual) {
+        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;
+        if (!bwHandledByVchan) {
+          await hostCore.postPath(`/set_bandwidth?hz=${bm.bandwidth_hz}`);
+        }
+      }
+      hostCore.setRigFrequency(bm.freq_hz);
+    })();
+    const hasDecoders = Array.isArray(bm.decoders) && bm.decoders.length > 0;
+    const modeUp = (bm.mode || "").toUpperCase();
+    const allToggleDecoders = hostState.decoderRegistry.filter(
+      (d) => d.activation === "toggle"
+    );
+    const decoderPromise = allToggleDecoders.length ? (async () => {
+      let statusUrl = "/status";
+      const rigId = hostState.lastActiveRigId;
+      if (rigId) {
+        statusUrl += "?remote=" + encodeURIComponent(rigId);
+      }
+      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) {
+          wanted = false;
+        } else if (hasDecoders) {
+          wanted = bm.decoders?.includes(d.id) ?? false;
+        } else {
+          wanted = currentlyOn;
+        }
+        if (wanted !== currentlyOn) {
+          toggles.push(hostCore.postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
+        }
+      }
+      if (toggles.length) await Promise.all(toggles);
+    })() : Promise.resolve();
+    void Promise.all([tunePromise, decoderPromise]).catch((error) => {
+      console.error("Bookmark apply background error:", error);
+    });
+  } catch (err) {
+    console.error("Failed to apply bookmark:", err);
+  }
+}
+bridge.trx.modules.bookmarks = {
+  get overlayList() {
+    return bmOverlayList;
+  },
+  get overlayRevision() {
+    return bmOverlayRevision;
+  },
+  refreshOverlay: bmFetchOverlay,
+  invalidateColors() {
+    bmOverlayRevision += 1;
+  },
+  apply: bmApply,
+  formatFrequency: bmFmtFreq,
+  fetch: bmFetch,
+  populateScopePicker: bmPopulateScopePicker
+};
+function bmUpdateSelectionUi() {
+  const count = bmSelected.size;
+  const canCtrl = bmCanControl();
+  const visible = count > 0 && canCtrl;
+  const btn = bmEl("bm-del-selected-btn");
+  const countEl = bmEl("bm-del-selected-count");
+  if (btn) btn.style.display = visible ? "" : "none";
+  if (countEl) countEl.textContent = String(count);
+  const moveWrap = bmEl("bm-move-selected-wrap");
+  const moveCountEl = bmEl("bm-move-selected-count");
+  if (moveWrap) moveWrap.style.display = visible ? "" : "none";
+  if (moveCountEl) moveCountEl.textContent = String(count);
+  if (visible) bmPopulateMoveTarget();
+  const selectAllBtn = bmEl("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";
+  }
+}
+function bmPopulateMoveTarget() {
+  const sel = bmEl("bm-move-target");
+  if (!sel) return;
+  const rigIds = hostState.lastRigIds;
+  const displayNames = hostState.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 = bmEl("bm-move-target")?.value;
+  if (!target) return;
+  const targetLabel = bmEl("bm-move-target")?.selectedOptions[0]?.textContent || target;
+  if (!await bridge.trxUi.confirm({
+    title: "Move selected bookmarks?",
+    message: `${ids.length} bookmark${ids.length > 1 ? "s" : ""} will move to “${targetLabel}”.`,
+    confirmLabel: "Move",
+    danger: false
+  })) return;
+  try {
+    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(bmEl("bm-category-filter").value);
+  } catch (err) {
+    console.error("Failed to move bookmarks:", err);
+    bridge.trxUi.notify?.("Failed to move bookmarks: " + errorMessage(err), { kind: "error" });
+  }
+}
+function bmSyncSelectAllCheckbox() {
+  const selectAll = bmEl("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 bridge.trxUi.confirm({
+    title: "Delete selected bookmarks?",
+    message: `${ids.length} bookmark${ids.length > 1 ? "s" : ""} will be permanently removed.`,
+    confirmLabel: "Delete"
+  })) return;
+  try {
+    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(bmEl("bm-category-filter").value);
+  } catch (err) {
+    console.error("Failed to delete bookmarks:", err);
+    bridge.trxUi.notify?.("Failed to delete bookmarks: " + errorMessage(err), { kind: "error" });
+  }
+}
+function bmPopulateScopePicker() {
+  const picker = bmEl("bm-scope-picker");
+  if (!picker) return;
+  const rigIds = hostState.lastRigIds;
+  const displayNames = hostState.lastRigDisplayNames;
+  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;
+}
+(function initBookmarks() {
+  bmSyncAccess();
+  bmBuildDecoderCheckboxes();
+  hostCore.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
+  bmPopulateScopePicker();
+  const scopePicker = bmEl("bm-scope-picker");
+  if (scopePicker) {
+    scopePicker.addEventListener("change", (e) => {
+      bmScope = e.currentTarget.value;
+      void bmFetch(bmEl("bm-category-filter").value || "");
+    });
+  }
+  document.querySelector(".tab-bar")?.addEventListener("click", (e) => {
+    const btn = e.target instanceof Element ? e.target.closest('.tab[data-tab="bookmarks"]') : null;
+    if (!btn) return;
+    void bmFetch(bmEl("bm-category-filter").value);
+  });
+  bmEl("bm-add-btn").addEventListener("click", () => {
+    bmOpenForm(null);
+    bmPrefillFromStatus();
+  });
+  bmEl("bm-category-filter").addEventListener("change", (e) => {
+    void bmFetch(e.currentTarget.value);
+  });
+  bmEl("bm-mode-filter").addEventListener("change", () => {
+    bmApplyFilters();
+  });
+  bmEl("bm-text-filter").addEventListener("input", () => {
+    bmApplyFilters();
+  });
+  bmEl("bm-page-prev").addEventListener("click", () => {
+    bmChangePage(-1);
+  });
+  bmEl("bm-page-next").addEventListener("click", () => {
+    bmChangePage(1);
+  });
+  bmEl("bm-form").addEventListener("submit", (event) => {
+    void bmSave(event);
+  });
+  bmEl("bm-form-cancel").addEventListener("click", bmCloseForm);
+  const formWrap = bmEl("bm-form-wrap");
+  if (formWrap) {
+    formWrap.addEventListener("click", (e) => {
+      if (e.target === formWrap) bmCloseForm();
+    });
+  }
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && bmEl("bm-form-wrap")?.style.display === "flex") {
+      bmCloseForm();
+    }
+  });
+  bmEl("bm-select-all").addEventListener("change", (e) => {
+    const checked = e.currentTarget.checked;
+    document.querySelectorAll(".bm-row-sel").forEach((cb) => {
+      cb.checked = checked;
+      const id = cb.dataset.bmId;
+      if (!id) return;
+      if (checked) bmSelected.add(id);
+      else bmSelected.delete(id);
+    });
+    bmUpdateSelectionUi();
+  });
+  bmEl("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));
+    }
+    document.querySelectorAll(".bm-row-sel").forEach((cb) => {
+      cb.checked = !!cb.dataset.bmId && bmSelected.has(cb.dataset.bmId);
+    });
+    bmSyncSelectAllCheckbox();
+    bmUpdateSelectionUi();
+  });
+  bmEl("bm-del-selected-btn").addEventListener("click", () => {
+    void bmDeleteSelected();
+  });
+  bmEl("bm-move-selected-btn").addEventListener("click", () => {
+    void bmMoveSelected();
+  });
+  bmEl("bm-tbody").addEventListener("click", (e) => {
+    void (async () => {
+      if (!(e.target instanceof Element)) return;
+      const checkbox = e.target.closest(".bm-row-sel");
+      if (checkbox) {
+        const id = checkbox.dataset.bmId;
+        if (!id) return;
+        if (checkbox.checked) bmSelected.add(id);
+        else bmSelected.delete(id);
+        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) bmApply(bm);
+      } else if (editBtn) {
+        const bm = bmList.find((b) => b.id === editBtn.dataset.bmId);
+        if (bm) bmOpenForm(bm);
+      } else if (delBtn) {
+        const id = delBtn.dataset.bmId;
+        if (id) await bmDelete(id);
+      }
+    })();
+  });
+  void bmFetch("");
+})();

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

@@ -0,0 +1,112 @@
+// 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

@@ -0,0 +1,277 @@
+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;
+}
+function isAlphaNumeric(value) {
+  return value !== void 0 && /[A-Za-z0-9]/.test(value);
+}
+function isGrid(value) {
+  const normalized = value.trim().toUpperCase();
+  return /^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalized) && normalized !== "RR73" && normalized !== "73" && normalized !== "RR";
+}
+function escapeFtxHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function extractFtxGrids(message) {
+  return [...new Set(message.toUpperCase().split(/[^A-Z0-9]+/).filter(isGrid))];
+}
+function tokenize(message) {
+  return message.toUpperCase().split(/[^A-Z0-9/]+/).filter(Boolean);
+}
+function isCallsign(token) {
+  return token !== void 0 && token.length >= 3 && token.length <= 12 && !["CQ", "DE", "QRZ", "DX"].includes(token) && !isGrid(token) && /^[A-Z0-9/]{1,5}\d[A-Z0-9/]{1,6}$/.test(token);
+}
+function extractFtxLocatorDetails(message) {
+  const tokens = tokenize(message);
+  const grids = extractFtxGrids(message);
+  const gridIndex = tokens.findIndex(isGrid);
+  const callsigns = tokens.slice(0, gridIndex < 0 ? tokens.length : gridIndex).filter(isCallsign);
+  const directed = callsigns.length >= 2 && !["CQ", "DE", "QRZ"].includes(tokens[0] ?? "");
+  const source = directed ? callsigns[1] ?? null : callsigns[0] ?? null;
+  const target = directed ? callsigns[0] ?? null : null;
+  return grids.map((grid) => ({ grid, station: source, source, target }));
+}
+function extractFtxCallsign(message) {
+  return extractFtxLocatorDetails(message)[0]?.station ?? tokenize(message).find(isCallsign) ?? null;
+}
+function renderFtxMessage(message) {
+  let html = "";
+  let index = 0;
+  while (index < message.length) {
+    if (!isAlphaNumeric(message[index])) {
+      html += escapeFtxHtml(message[index] ?? "");
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < message.length && isAlphaNumeric(message[end])) end += 1;
+    const token = message.slice(index, end);
+    const grid = token.toUpperCase();
+    html += isGrid(grid) ? `<span class="ft8-locator" data-locator-grid="${grid}" role="button" tabindex="0" aria-label="Show locator ${grid} on map">${grid}</span>` : escapeFtxHtml(token);
+    index = end;
+  }
+  return html;
+}
+function installFtxCompatibilityHelpers() {
+  bridge.renderFt8Message = renderFtxMessage;
+  bridge.ft8EscapeHtml = escapeFtxHtml;
+  bridge.ft8ExtractLocatorDetails = extractFtxLocatorDetails;
+  bridge.ft8ExtractAllGrids = extractFtxGrids;
+  bridge.ft8ExtractLikelyCallsign = extractFtxCallsign;
+}
+function initializeFt8FamilyBar() {
+  const labels = { ft8: "FT8", ft4: "FT4", ft2: "FT2" };
+  const builders = {};
+  const dismissed = { ft8: 0, ft4: 0, ft2: 0 };
+  const overlay = document.getElementById("ft8-bar-overlay");
+  let active = "ft8";
+  const update = () => {
+    if (!overlay) return;
+    const mode = (document.getElementById("mode")?.value ?? "").toUpperCase();
+    const result = builders[active]?.();
+    if (mode !== "DIG" && mode !== "USB" || !result || result.count === 0 || result.newestTsMs <= dismissed[active]) {
+      overlay.style.display = "none";
+      overlay.innerHTML = "";
+      return;
+    }
+    const label = labels[active];
+    overlay.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}`;
+    overlay.style.display = "flex";
+  };
+  bridge.registerFt8FamilyBarRenderer = (decoder, builder) => {
+    builders[decoder] = builder;
+  };
+  bridge.setFt8FamilyBarDecoder = (decoder) => {
+    active = decoder;
+    update();
+  };
+  bridge.updateFt8Bar = update;
+  bridge.clearFt8Bar = () => {
+    bridge.trxPluginRuntime.reset(active);
+  };
+  bridge.closeFt8Bar = () => {
+    dismissed[active] = Date.now();
+    update();
+  };
+}
+function initializeFtxDecoder(config) {
+  const { id, label, periodMs, periodDigits = 1 } = config;
+  const status = document.getElementById(`${id}-status`);
+  const period = document.getElementById(`${id}-period`);
+  const messagesElement = document.getElementById(`${id}-messages`);
+  const filterInput = document.getElementById(`${id}-filter`);
+  let filterText = "";
+  let history = [];
+  const renderMessage = (message) => {
+    return bridge.renderFt8Message?.(message) ?? renderFtxMessage(message);
+  };
+  const retentionMs = () => bridge.getDecodeHistoryRetentionMs?.() ?? 864e5;
+  const prune = () => {
+    const cutoff = Date.now() - retentionMs();
+    history = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= cutoff);
+  };
+  const schedule = (job) => {
+    if (bridge.trxScheduleUiFrameJob) bridge.trxScheduleUiFrameJob(`${id}-history`, job);
+    else job();
+  };
+  const displayFrequency = (value) => {
+    const raw = finiteNumber(value);
+    if (raw === null) return null;
+    const base = finiteNumber(bridge.ft8BaseHz);
+    return base !== null && base > 0 && raw >= 0 && raw < 1e5 ? base + raw : raw;
+  };
+  const renderRow = (message) => {
+    const row = document.createElement("div");
+    row.className = "ft8-row";
+    const raw = message.message ?? "";
+    row.dataset.message = raw.toUpperCase();
+    row.dataset.decoder = id;
+    const storedFrequency = finiteNumber(message.freq_hz);
+    row.dataset.storedFreqHz = storedFrequency === null ? "" : String(storedFrequency);
+    const snr = finiteNumber(message.snr_db);
+    const delta = finiteNumber(message.dt_s);
+    const frequency = displayFrequency(message.freq_hz);
+    const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
+    const time = timestamp === null ? "--:--:--" : new Date(timestamp).toLocaleTimeString([], {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    row.innerHTML = `<span class="ft8-time">${time}</span><span class="ft8-snr">${snr?.toFixed(1) ?? "--"}</span><span class="ft8-dt">${delta?.toFixed(2) ?? "--"}</span><span class="ft8-freq">${frequency?.toFixed(0) ?? "--"}</span><span class="ft8-msg">${renderMessage(raw)}</span>`;
+    return row;
+  };
+  const render = () => {
+    prune();
+    if (!messagesElement) return;
+    const fragment = document.createDocumentFragment();
+    let count = 0;
+    for (const message of history) {
+      if (count >= 200) break;
+      if (filterText && !(message.message ?? "").toUpperCase().includes(filterText)) continue;
+      fragment.appendChild(renderRow(message));
+      count += 1;
+    }
+    messagesElement.replaceChildren(fragment);
+  };
+  const normalize = (message) => {
+    const raw = message.message ?? "";
+    const locatorDetails = bridge.ft8ExtractLocatorDetails?.(raw) ?? extractFtxLocatorDetails(raw);
+    const grids = locatorDetails.length > 0 ? locatorDetails.map(({ grid }) => grid) : bridge.ft8ExtractAllGrids?.(raw) ?? extractFtxGrids(raw);
+    const station = bridge.ft8ExtractLikelyCallsign?.(raw) ?? extractFtxCallsign(raw);
+    const frequency = displayFrequency(message.freq_hz);
+    if (grids.length > 0) {
+      bridge.mapAddLocator?.(raw, grids, id, station, {
+        ...message,
+        freq_hz: frequency ?? message.freq_hz,
+        locator_details: locatorDetails
+      });
+    }
+    return {
+      receiver: bridge.getDecodeRigMeta?.() ?? null,
+      ts_ms: message.ts_ms,
+      snr_db: message.snr_db,
+      dt_s: message.dt_s,
+      freq_hz: frequency ?? message.freq_hz,
+      message: message.message,
+      _tsMs: finiteNumber(message.ts_ms) ?? Date.now()
+    };
+  };
+  const receiveBatch = (messages) => {
+    if (messages.length === 0) return;
+    if (status) status.textContent = "Receiving";
+    history = messages.map(normalize).reverse().concat(history);
+    prune();
+    bridge.setFt8FamilyBarDecoder?.(id);
+    bridge.updateFt8Bar?.();
+    schedule(render);
+  };
+  const reset = () => {
+    history = [];
+    bridge.updateFt8Bar?.();
+    render();
+    bridge.clearMapMarkersByType?.(id);
+  };
+  const barFrames = () => {
+    const recent = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 9e5).slice(0, 8);
+    let html = "";
+    for (const message of recent) {
+      const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
+      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);
+      const detail = [snr === null ? "-- dB" : `${snr.toFixed(1)} dB`, delta === null ? null : `dt ${delta.toFixed(2)}`, frequency === null ? null : `${frequency.toFixed(0)} Hz`].filter((part) => part !== null).join(" · ");
+      html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${time}<span class="aprs-bar-call">${renderMessage(message.message ?? "")}</span>${detail ? ` · ${detail}` : ""}</div></div>`;
+    }
+    return { count: recent.length, newestTsMs: recent.reduce((latest, message) => Math.max(latest, finiteNumber(message._tsMs ?? message.ts_ms) ?? 0), 0), html };
+  };
+  bridge.trxPluginRuntime.registerDecoder({
+    id,
+    onMessage: (message) => {
+      receiveBatch([message]);
+    },
+    onBatch: receiveBatch,
+    restore: receiveBatch,
+    prune: () => {
+      prune();
+      render();
+    },
+    reset
+  });
+  bridge.registerFt8FamilyBarRenderer?.(id, barFrames);
+  const updatePeriod = () => {
+    if (period) period.textContent = `Next slot ${((periodMs - Date.now() % periodMs) / 1e3).toFixed(periodDigits)}s`;
+  };
+  updatePeriod();
+  window.setInterval(updatePeriod, 250);
+  filterInput?.addEventListener("input", () => {
+    filterText = filterInput.value.trim().toUpperCase();
+    render();
+  });
+  messagesElement?.addEventListener("click", (event) => {
+    if (!(event.target instanceof Element)) return;
+    const grid = event.target.closest(".ft8-locator[data-locator-grid]")?.dataset.locatorGrid;
+    if (grid) {
+      bridge.navigateToMapLocator?.(grid.toUpperCase(), id);
+      event.preventDefault();
+    }
+  });
+  const toggle = document.getElementById(`${id}-decode-toggle-btn`);
+  toggle?.addEventListener("click", () => {
+    void (async () => {
+      try {
+        await bridge.takeSchedulerControlForDecoderDisable?.(toggle);
+        await hostCore.postPath(`/toggle_${id}_decode`);
+      } catch (error) {
+        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 hostCore.postPath(`/clear_${id}_decode`);
+        reset();
+      } catch (error) {
+        console.error(`${label} history clear failed`, error);
+      }
+    })();
+  });
+}
+
+export {
+  installFtxCompatibilityHelpers,
+  initializeFt8FamilyBar,
+  initializeFtxDecoder
+};

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

@@ -0,0 +1,404 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/cw.ts
+var cwWindow = window;
+var cwStatusEl = document.getElementById("cw-status");
+var cwOutputEl = document.getElementById("cw-output");
+var cwAutoInput = document.getElementById("cw-auto");
+var cwWpmInput = document.getElementById("cw-wpm");
+var cwToneInput = document.getElementById("cw-tone");
+var cwSignalIndicator = document.getElementById("cw-signal-indicator");
+var cwToneCanvas = document.getElementById("cw-tone-waterfall");
+var cwToneGl = cwToneCanvas && cwWindow.createTrxWebGlRenderer ? cwWindow.createTrxWebGlRenderer(cwToneCanvas, { alpha: true }) : null;
+var cwTonePickerEl = document.querySelector(".cw-tone-picker");
+var cwToneRangeEl = document.getElementById("cw-tone-range");
+var cwBarOverlay = document.getElementById("cw-bar-overlay");
+var CW_MAX_LINES = 200;
+var CW_TONE_MIN_HZ = 100;
+var CW_TONE_MAX_HZ = 1e4;
+var CW_WPM_MIN = 5;
+var CW_WPM_MAX = 40;
+var CW_BAR_WINDOW_MS = 15 * 60 * 1e3;
+var CW_BAR_LINE_GAP_MS = 5e3;
+var cwLastAppendTime = 0;
+var cwTonePickerRaf = null;
+var cwBarHistory = [];
+var cwBarCurrentLine = null;
+var cwBarDismissedAtMs = 0;
+var cwAutoLocalOverride = null;
+function escapeCwHtml(input) {
+  return hostCore.escapeMapHtml(input);
+}
+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);
+  }
+}
+cwWindow.applyCwAutoUi = applyCwAutoUi;
+cwWindow.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);
+  const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
+  const newestTsMs = liveLines.reduce((latest, line) => Math.max(latest, line.tsMs || 0), 0);
+  if (!isCw || liveLines.length === 0 || newestTsMs <= cwBarDismissedAtMs) {
+    cwBarOverlay.style.display = "none";
+    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 ? `${String(line.wpm)} WPM` : null,
+      line.tone_hz ? `${String(line.tone_hz)} Hz` : null
+    ].filter(Boolean).join(" · ");
+    html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${ts}${escapeCwHtml(line.text)}` + (meta ? ` <span class="aprs-bar-time">${escapeCwHtml(meta)}</span>` : "") + `</div></div>`;
+  }
+  cwBarOverlay.innerHTML = html;
+  cwBarOverlay.style.display = "flex";
+}
+cwWindow.updateCwBar = updateCwBar;
+cwWindow.clearCwBar = function() {
+  resetCwHistoryView();
+};
+cwWindow.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(cwWindow.lastFreqHz) ? Number(cwWindow.lastFreqHz) : NaN;
+  const bandwidthHz = Number.isFinite(cwWindow.currentBandwidthHz) ? Number(cwWindow.currentBandwidthHz) : NaN;
+  if (!Number.isFinite(tunedHz) || !Number.isFinite(bandwidthHz) || bandwidthHz <= 0) {
+    return null;
+  }
+  const mode = (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;
+  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 (!cwWindow.lastSpectrumData || !Array.isArray(cwWindow.lastSpectrumData.bins) || !cwWindow.lastSpectrumData.bins.length || !range) {
+    if (cwToneRangeEl) {
+      const mode = (document.getElementById("mode")?.value || "").toUpperCase();
+      if (mode !== "CW" && mode !== "CWR") {
+        cwToneRangeEl.textContent = "CW/CWR mode required";
+      } else if (!cwWindow.lastSpectrumData || !Array.isArray(cwWindow.lastSpectrumData.bins) || !cwWindow.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 ${String(range.toneMinHz)}-${String(range.toneMaxHz)} Hz · ${side}`;
+  }
+  const bins = cwWindow.lastSpectrumData.bins;
+  const sampleRate = cwWindow.lastSpectrumData.sample_rate;
+  const centerHz = cwWindow.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] ?? -140;
+      count += 1;
+    }
+    smoothed[x] = count > 0 ? sum / count : tones[x] ?? -140;
+  }
+  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 cwWindow.trxParseCssColor === "function" ? cwWindow.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 <= 1e3 ? 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] ?? -140));
+  }
+  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))] ?? -140);
+  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 = String(clamped);
+  }
+  try {
+    await hostCore.postPath(`/set_cw_tone?tone_hz=${encodeURIComponent(clamped)}`);
+  } catch (e) {
+    console.error("CW tone set failed", e);
+  }
+  drawCwTonePicker();
+}
+if (cwAutoInput) {
+  cwAutoInput.addEventListener("change", () => {
+    void (async () => {
+      const enabled = cwAutoInput.checked;
+      cwAutoLocalOverride = enabled;
+      applyCwAutoUi(enabled);
+      try {
+        await hostCore.postPath(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
+        drawCwTonePicker();
+      } catch (error) {
+        console.error("CW auto toggle failed", error);
+      } finally {
+        cwAutoLocalOverride = null;
+      }
+    })();
+  });
+}
+if (cwWpmInput) {
+  cwWpmInput.addEventListener("change", () => {
+    void (async () => {
+      if (cwAutoInput?.checked) return;
+      const wpm = clampCwWpm(cwWpmInput.value);
+      cwWpmInput.value = String(wpm);
+      try {
+        await hostCore.postPath(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`);
+      } catch (error) {
+        console.error("CW WPM set failed", error);
+      }
+    })();
+  });
+}
+if (cwToneInput) {
+  cwToneInput.addEventListener("change", () => {
+    if (!cwAutoInput?.checked) void setCwTone(cwToneInput.value);
+  });
+}
+if (cwToneCanvas) {
+  cwToneCanvas.addEventListener("click", (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;
+    void setCwTone(tone);
+  });
+}
+function resetCwHistoryView() {
+  if (cwOutputEl) cwOutputEl.innerHTML = "";
+  cwLastAppendTime = 0;
+  cwBarHistory = [];
+  cwBarCurrentLine = null;
+  updateCwBar();
+  drawCwTonePicker();
+}
+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 hostCore.postPath("/clear_cw_decode");
+      resetCwHistoryView();
+    } catch (error) {
+      console.error("CW history clear failed", error);
+    }
+  })();
+});
+function onServerCw(evt) {
+  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
+  if (evt.text && cwOutputEl) {
+    const now = Date.now();
+    if (!cwOutputEl.lastElementChild || now - cwLastAppendTime > 1e4 || 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) {
+      const firstChild = cwOutputEl.firstChild;
+      if (!firstChild) break;
+      cwOutputEl.removeChild(firstChild);
+    }
+    cwOutputEl.scrollTop = cwOutputEl.scrollHeight;
+  }
+  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 = String(clampCwWpm(evt.wpm));
+    }
+    if (cwToneInput && Number.isFinite(Number(evt.tone_hz))) {
+      cwToneInput.value = String(toneClampForRange(evt.tone_hz, currentCwToneRange()));
+    }
+  }
+  if (cwTonePickerRaf != null) return;
+  cwTonePickerRaf = requestAnimationFrame(() => {
+    cwTonePickerRaf = null;
+    drawCwTonePicker();
+  });
+}
+function restoreCwHistory(events) {
+  if (!Array.isArray(events) || events.length === 0) return;
+  if (cwStatusEl) cwStatusEl.textContent = "Receiving";
+  for (const evt of events) {
+    onServerCw(evt);
+  }
+}
+cwWindow.trxPluginRuntime.registerDecoder({
+  id: "cw",
+  onMessage: onServerCw,
+  restore: restoreCwHistory,
+  reset: resetCwHistoryView
+});
+cwWindow.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/generated/decode-history-worker.js

@@ -0,0 +1,179 @@
+"use strict";
+(() => {
+  // src/decode-history-worker.ts
+  var textDecoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
+  var HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax"];
+  var workerScope = self;
+  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] ?? 0;
+    }
+    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 & 32768 ? -1 : 1;
+    const exponent = bits >> 10 & 31;
+    const fraction = bits & 1023;
+    if (exponent === 0) {
+      return fraction === 0 ? sign * 0 : sign * Math.pow(2, -14) * (fraction / 1024);
+    }
+    if (exponent === 31) {
+      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++];
+    if (initial === void 0) throw new Error("CBOR payload truncated");
+    const major = initial >> 5;
+    const additional = initial & 31;
+    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);
+        const property = typeof key === "string" || typeof key === "number" || typeof key === "boolean" ? String(key) : JSON.stringify(key);
+        value[property] = 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 void 0;
+      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;
+  }
+  function isHistory(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  async function fetchAndDecodeHistory(url, batchLimit) {
+    workerScope.postMessage({ type: "status", phase: "fetching" });
+    const resp = await fetch(url, { credentials: "same-origin" });
+    if (!resp.ok) throw new Error(`History fetch failed: ${String(resp.status)}`);
+    const payload = await resp.arrayBuffer();
+    if (payload.byteLength === 0) {
+      workerScope.postMessage({ type: "start", total: 0 });
+      workerScope.postMessage({ type: "done", total: 0 });
+      return;
+    }
+    workerScope.postMessage({ type: "status", phase: "decoding" });
+    const history = decodeCborPayload(payload);
+    const total = HISTORY_GROUP_KEYS.reduce((sum, key) => {
+      const items = isHistory(history) && Array.isArray(history[key]) ? history[key] : [];
+      return sum + items.length;
+    }, 0);
+    workerScope.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 = isHistory(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;
+        workerScope.postMessage({
+          type: "group",
+          kind,
+          messages,
+          processed,
+          total
+        });
+      }
+    }
+    workerScope.postMessage({ type: "done", total });
+  }
+  function isFetchHistoryRequest(value) {
+    return typeof value === "object" && value !== null && "type" in value && value.type === "fetch-history";
+  }
+  workerScope.onmessage = (event) => {
+    const data = event.data;
+    if (!isFetchHistoryRequest(data)) return;
+    fetchAndDecodeHistory(data.url || "/decode/history", data.batchLimit).catch((error) => {
+      workerScope.postMessage({
+        type: "error",
+        message: error instanceof Error ? error.message : typeof error === "string" ? error : "unknown worker failure"
+      });
+    });
+  };
+})();

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

@@ -0,0 +1,7 @@
+import {
+  initializeFtxDecoder
+} 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

@@ -0,0 +1,7 @@
+import {
+  initializeFtxDecoder
+} 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

@@ -0,0 +1,11 @@
+import {
+  initializeFt8FamilyBar,
+  initializeFtxDecoder,
+  installFtxCompatibilityHelpers
+} from "./chunk-O2Y7YEVQ.js";
+import "./chunk-KL66PICH.js";
+
+// src/plugins/ft8.ts
+installFtxCompatibilityHelpers();
+initializeFt8FamilyBar();
+initializeFtxDecoder({ id: "ft8", label: "FT8", periodMs: 15e3, periodDigits: 0 });

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

@@ -0,0 +1,269 @@
+import {
+  aprsAgeText,
+  aprsCategoryLabel,
+  aprsHexBytes,
+  aprsPacketCategory,
+  collapseAprsDuplicates,
+  normalizeAprsPacket,
+  renderAprsInfo,
+  renderLocalAprsSymbol
+} from "./chunk-M2I6DH4X.js";
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/hf-aprs.ts
+var hfAprsWindow = window;
+var escapeHfAprsHtml = (input) => hostCore.escapeMapHtml(input);
+var hfAprsStatus = document.getElementById("hf-aprs-status");
+var hfAprsPacketsEl = document.getElementById("hf-aprs-packets");
+var hfAprsFilterInput = document.getElementById("hf-aprs-filter");
+var hfAprsOnlyPosBtn = document.getElementById("hf-aprs-only-pos-btn");
+var hfAprsHideCrcBtn = document.getElementById("hf-aprs-hide-crc-btn");
+var hfAprsCollapseDupBtn = document.getElementById("hf-aprs-collapse-dup-btn");
+var hfAprsTotalCountEl = document.getElementById("hf-aprs-total-count");
+var hfAprsVisibleCountEl = document.getElementById("hf-aprs-visible-count");
+var hfAprsLatestSeenEl = document.getElementById("hf-aprs-latest-seen");
+var hfAprsFilterText = "";
+var hfAprsPacketHistory = [];
+var hfAprsOnlyPos = false;
+var hfAprsHideCrc = false;
+var hfAprsCollapseDup = false;
+var hfAprsTypeFilter = "all";
+function currentHfAprsHistoryRetentionMs() {
+  return typeof hfAprsWindow.getDecodeHistoryRetentionMs === "function" ? hfAprsWindow.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1e3;
+}
+function pruneHfAprsPacketHistory() {
+  const cutoffMs = Date.now() - currentHfAprsHistoryRetentionMs();
+  hfAprsPacketHistory = hfAprsPacketHistory.filter((pkt) => (pkt._tsMs ?? 0) >= cutoffMs);
+}
+function scheduleHfAprsHistoryRender() {
+  if (typeof hfAprsWindow.trxScheduleUiFrameJob === "function") {
+    hfAprsWindow.trxScheduleUiFrameJob("hf-aprs-history", () => {
+      renderHfAprsHistory();
+    });
+    return;
+  }
+  renderHfAprsHistory();
+}
+function hfAprsDistanceText(pkt) {
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
+  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`;
+}
+function hfAprsFilterMatch(pkt) {
+  if (hfAprsOnlyPos && (pkt.lat == null || pkt.lon == null)) return false;
+  if (hfAprsHideCrc && !pkt.crcOk) return false;
+  if (hfAprsTypeFilter !== "all" && aprsPacketCategory(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) : "",
+    aprsPacketCategory(pkt)
+  ].filter(Boolean).join(" ").toUpperCase();
+  return haystack.includes(hfAprsFilterText);
+}
+function hfAprsVisiblePackets() {
+  const packets = hfAprsCollapseDup ? collapseHfAprsDuplicates(hfAprsPacketHistory) : hfAprsPacketHistory;
+  return packets.filter(hfAprsFilterMatch);
+}
+var collapseHfAprsDuplicates = collapseAprsDuplicates;
+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} ${aprsAgeText(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 renderHfAprsRow(pkt, isFresh) {
+  const row = document.createElement("div");
+  row.className = "aprs-packet";
+  if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
+  if (isFresh) row.classList.add("aprs-packet-new");
+  const ts = pkt._ts || (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  const age = aprsAgeText(pkt._tsMs);
+  const category = aprsPacketCategory(pkt);
+  const categoryLabel = aprsCategoryLabel(category);
+  const categoryClass = `aprs-badge aprs-badge-type aprs-badge-type-${category}`;
+  const pathBadge = pkt.path ? `<span class="aprs-badge">${escapeHfAprsHtml(pkt.path)}</span>` : "";
+  const crcBadge = pkt.crcOk ? "" : '<span class="aprs-badge aprs-badge-crc">CRC Fail</span>';
+  const hfBadge = '<span class="aprs-badge" style="background:var(--accent-alt,#f59e0b);color:#000">HF</span>';
+  const symbolHtml = renderLocalAprsSymbol(pkt, escapeHfAprsHtml);
+  const posLink = pkt.lat != null && pkt.lon != null ? `<a class="aprs-pos" href="javascript:void(0)" data-aprs-map="${pkt.lat},${pkt.lon}">${pkt.lat.toFixed(4)}, ${pkt.lon.toFixed(4)}</a>` : "";
+  const distance = hfAprsDistanceText(pkt);
+  const qrzHref = `https://qrzcq.com/call/${encodeURIComponent(pkt.srcCall || "")}`;
+  row.innerHTML = `<div class="aprs-row-head"><span class="aprs-time">${ts}</span>` + hfBadge + symbolHtml + `<span class="aprs-call">${escapeHfAprsHtml(pkt.srcCall ?? "")}</span><span>&gt;${escapeHfAprsHtml(pkt.destCall || "")}</span><span class="${categoryClass}">${escapeHfAprsHtml(categoryLabel)}</span>` + pathBadge + crcBadge + `</div><div class="aprs-row-meta"><span class="aprs-meta-text">${escapeHfAprsHtml(age)}</span>` + (distance ? `<span class="aprs-meta-text">${escapeHfAprsHtml(distance)}</span>` : "") + `<span class="aprs-meta-text">${escapeHfAprsHtml(pkt.type || "--")}</span></div><div class="aprs-row-detail"><span title="${escapeHfAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` + (posLink ? `<span>${posLink}</span>` : "") + `</div><div class="aprs-row-actions">` + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-map="${pkt.lat},${pkt.lon}">Map</button>` : "") + (pkt.lat != null && pkt.lon != null ? `<button class="aprs-inline-btn" type="button" data-aprs-copy="${pkt.lat},${pkt.lon}">Copy Coords</button>` : "") + `<a class="aprs-inline-btn" href="${qrzHref}" target="_blank" rel="noopener">QRZ</a></div><details class="aprs-details"><summary>Details</summary><div class="aprs-details-grid"><span class="aprs-detail-label">Source</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.srcCall || "--")}</span><span class="aprs-detail-label">Destination</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.destCall || "--")}</span><span class="aprs-detail-label">Type</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.type || "--")}</span><span class="aprs-detail-label">Path</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.path || "--")}</span><span class="aprs-detail-label">Age</span><span class="aprs-detail-value">${escapeHfAprsHtml(age)}</span><span class="aprs-detail-label">CRC</span><span class="aprs-detail-value">${pkt.crcOk ? "OK" : "Failed"}</span><span class="aprs-detail-label">Position</span><span class="aprs-detail-value">${pkt.lat != null && pkt.lon != null ? `${pkt.lat.toFixed(5)}, ${pkt.lon.toFixed(5)}` : "--"}</span><span class="aprs-detail-label">Info</span><span class="aprs-detail-value">${escapeHfAprsHtml(pkt.info || "--")}</span><span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeHfAprsHtml(aprsHexBytes(pkt.info_bytes))}</span></div></details>`;
+  row.querySelectorAll("[data-aprs-map]").forEach((el) => {
+    el.addEventListener("click", (evt) => {
+      evt.preventDefault();
+      const raw = el.dataset.aprsMap ?? "";
+      const [lat, lon] = raw.split(",").map(Number);
+      if (hfAprsWindow.navigateToAprsMap && typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
+        hfAprsWindow.navigateToAprsMap(lat, lon);
+      }
+    });
+  });
+  const copyBtn = row.querySelector("[data-aprs-copy]");
+  if (copyBtn) {
+    copyBtn.addEventListener("click", () => {
+      void (async () => {
+        const raw = copyBtn.dataset.aprsCopy ?? "";
+        try {
+          const clipboard = Reflect.get(navigator, "clipboard");
+          if (clipboard) {
+            await clipboard.writeText(raw);
+            hostCore.showHint("Coordinates copied", 1200);
+          }
+        } catch {
+          hostCore.showHint("Copy failed", 1500);
+        }
+      })();
+    });
+  }
+  return row;
+}
+function renderHfAprsHistory() {
+  pruneHfAprsPacketHistory();
+  if (!hfAprsPacketsEl) {
+    updateHfAprsSummary();
+    updateHfAprsChipState();
+    return;
+  }
+  const visible = hfAprsVisiblePackets();
+  const fragment = document.createDocumentFragment();
+  for (const [index, packet] of visible.entries()) {
+    fragment.appendChild(renderHfAprsRow(packet, index === 0));
+  }
+  hfAprsPacketsEl.replaceChildren(fragment);
+  updateHfAprsSummary();
+  updateHfAprsChipState();
+}
+function resetHfAprsHistoryView() {
+  if (hfAprsPacketsEl) hfAprsPacketsEl.innerHTML = "";
+  hfAprsPacketHistory = [];
+  renderHfAprsHistory();
+}
+function pruneHfAprsHistoryView() {
+  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 normalizeAprsPacket(pkt, hfAprsWindow.getDecodeRigMeta?.() ?? null);
+}
+function onServerHfAprsBatch(packets) {
+  if (!Array.isArray(packets) || packets.length === 0) return;
+  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
+  const normalized = [];
+  for (const pkt of packets) {
+    const next = normalizeServerHfAprsPacket(pkt);
+    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();
+}
+var hfAprsDecodeToggleBtn = document.getElementById("hf-aprs-decode-toggle-btn");
+hfAprsDecodeToggleBtn?.addEventListener("click", () => {
+  void (async () => {
+    try {
+      await hfAprsWindow.takeSchedulerControlForDecoderDisable?.(hfAprsDecodeToggleBtn);
+      await hostCore.postPath("/toggle_hf_aprs_decode");
+    } catch (e) {
+      console.error("HF APRS toggle failed", e);
+    }
+  })();
+});
+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 hostCore.postPath("/clear_hf_aprs_decode");
+      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();
+  });
+}
+function onServerHfAprs(pkt) {
+  if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
+  addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
+}
+renderHfAprsHistory();
+window.trxPluginRuntime.registerDecoder({
+  id: "hf_aprs",
+  onMessage: onServerHfAprs,
+  onBatch: onServerHfAprsBatch,
+  restore: onServerHfAprsBatch,
+  reset: resetHfAprsHistoryView,
+  prune: pruneHfAprsHistoryView
+});

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

@@ -0,0 +1,263 @@
+// src/plugins/sat-scheduler.ts
+var satSchedulerWindow = window;
+(function() {
+  "use strict";
+  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")
+  };
+  let editIdx = null;
+  let eventsWired = false;
+  function getBridge() {
+    return satSchedulerWindow.trx?.modules?.scheduler ?? null;
+  }
+  function getConfig() {
+    const b = getBridge();
+    return b?.getConfig() ?? null;
+  }
+  function getStatus() {
+    const b = getBridge();
+    return b?.getStatus() ?? null;
+  }
+  function getBookmarks() {
+    const b = getBridge();
+    return b?.getBookmarks() ?? [];
+  }
+  function markDirty() {
+    getBridge()?.markDirty();
+  }
+  function bmName(id) {
+    const bm = getBookmarks().find(function(b) {
+      return b.id === id;
+    });
+    return bm ? bm.name : id;
+  }
+  function escHtml(s) {
+    return 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 `${String(hz)} Hz`;
+  }
+  function getSatelliteEntries() {
+    const config = getConfig();
+    return config && config.satellites && Array.isArray(config.satellites.entries) ? config.satellites.entries : [];
+  }
+  function ensureSatelliteConfig() {
+    const config = getConfig();
+    if (!config) return { enabled: false, pretune_secs: 60, entries: [] };
+    if (!config.satellites) config.satellites = { enabled: false, pretune_secs: 60, entries: [] };
+    return config.satellites;
+  }
+  function collectSatelliteConfig() {
+    const enabled = dom.enabled ? dom.enabled.checked : false;
+    const pretune = dom.pretune ? parseInt(dom.pretune.value, 10) : 60;
+    return {
+      enabled,
+      pretune_secs: isNaN(pretune) || pretune < 0 ? 60 : pretune,
+      entries: getSatelliteEntries()
+    };
+  }
+  function renderSection() {
+    const config = getConfig();
+    const satCfg = config?.satellites;
+    const enabled = satCfg?.enabled ?? false;
+    if (dom.enabled) dom.enabled.checked = enabled;
+    if (dom.pretune) dom.pretune.value = String(satCfg?.pretune_secs ?? 60);
+    if (dom.body) dom.body.style.display = enabled ? "" : "none";
+    renderEntries();
+    renderPassStatus();
+  }
+  function renderEntries() {
+    if (!dom.tbody) return;
+    const entries = getSatelliteEntries();
+    const frag = document.createDocumentFragment();
+    entries.forEach(function(entry, idx) {
+      const tr = document.createElement("tr");
+      const tdSat = document.createElement("td");
+      tdSat.textContent = entry.satellite || "";
+      tr.appendChild(tdSat);
+      const tdNorad = document.createElement("td");
+      tdNorad.textContent = String(entry.norad_id || "");
+      tr.appendChild(tdNorad);
+      const tdBm = document.createElement("td");
+      tdBm.textContent = bmName(entry.bookmark_id);
+      tr.appendChild(tdBm);
+      const tdEl = document.createElement("td");
+      tdEl.textContent = `${String(entry.min_elevation_deg)}°`;
+      tr.appendChild(tdEl);
+      const tdPrio = document.createElement("td");
+      tdPrio.textContent = String(entry.priority || 0);
+      tr.appendChild(tdPrio);
+      const tdActions = document.createElement("td");
+      const editBtn = document.createElement("button");
+      editBtn.className = "sch-write";
+      editBtn.type = "button";
+      editBtn.textContent = "Edit";
+      editBtn.addEventListener("click", function() {
+        openForm(entry, idx);
+      });
+      tdActions.appendChild(editBtn);
+      const 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);
+  }
+  function renderPassStatus() {
+    if (!dom.passStatus) return;
+    const entries = getSatelliteEntries();
+    if (entries.length === 0) {
+      dom.passStatus.innerHTML = "";
+      return;
+    }
+    const 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>';
+    }
+  }
+  function renderBookmarkSelect(selectedId) {
+    const bookmarkSelect = dom.bookmark;
+    if (!bookmarkSelect) return;
+    bookmarkSelect.innerHTML = '<option value="">— none —</option>';
+    getBookmarks().forEach(function(bm) {
+      const 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;
+      bookmarkSelect.appendChild(opt);
+    });
+  }
+  function removeEntry(idx) {
+    const sat = ensureSatelliteConfig();
+    sat.entries.splice(idx, 1);
+    renderEntries();
+    markDirty();
+  }
+  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 ? String(entry.norad_id || "") : "";
+    if (dom.minEl) dom.minEl.value = String(entry?.min_elevation_deg ?? 5);
+    if (dom.priority) dom.priority.value = String(entry?.priority ?? 0);
+    if (dom.centerHz) dom.centerHz.value = entry?.center_hz ? String(entry.center_hz) : "";
+    renderBookmarkSelect(entry ? entry.bookmark_id : null);
+    if (dom.formWrap) {
+      dom.formWrap.style.display = "flex";
+      if (dom.name) dom.name.focus();
+    }
+  }
+  function closeForm() {
+    if (dom.formWrap) dom.formWrap.style.display = "none";
+    editIdx = null;
+  }
+  function onFormSubmit(e) {
+    e.preventDefault();
+    const satellite = dom.name ? dom.name.value.trim() : "";
+    const noradId = dom.norad ? parseInt(dom.norad.value, 10) : NaN;
+    const bmId = dom.bookmark ? dom.bookmark.value : "";
+    if (!satellite) {
+      satSchedulerWindow.trxUi?.notify("Enter a satellite name.", { kind: "error" });
+      dom.name?.focus();
+      return;
+    }
+    if (isNaN(noradId) || noradId <= 0) {
+      satSchedulerWindow.trxUi?.notify("Enter a valid NORAD catalog number.", { kind: "error" });
+      dom.norad?.focus();
+      return;
+    }
+    if (!bmId) {
+      satSchedulerWindow.trxUi?.notify("Select a bookmark.", { kind: "error" });
+      dom.bookmark?.focus();
+      return;
+    }
+    const minEl = dom.minEl ? parseFloat(dom.minEl.value) : 5;
+    const prio = dom.priority ? parseInt(dom.priority.value, 10) : 0;
+    const centerHzRaw = dom.centerHz ? parseInt(dom.centerHz.value, 10) : NaN;
+    const sat = ensureSatelliteConfig();
+    const existing = editIdx !== null ? sat.entries[editIdx] : void 0;
+    const entryData = {
+      id: existing?.id ?? `sat_${Date.now().toString(36)}`,
+      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) {
+      sat.entries[editIdx] = entryData;
+    } else {
+      sat.entries.push(entryData);
+    }
+    closeForm();
+    renderEntries();
+    markDirty();
+  }
+  function onPresetChange() {
+    if (!dom.preset || !dom.preset.value) return;
+    const parts = dom.preset.value.split("|");
+    if (dom.name) dom.name.value = parts[0] || "";
+    if (dom.norad) dom.norad.value = parts[1] || "";
+  }
+  function wireEvents() {
+    if (eventsWired) return;
+    eventsWired = true;
+    if (dom.enabled) {
+      const enabledInput = dom.enabled;
+      dom.enabled.addEventListener("change", function() {
+        if (dom.body) dom.body.style.display = enabledInput.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);
+  }
+  satSchedulerWindow.satScheduler = {
+    wireEvents,
+    renderSection,
+    renderPassStatus,
+    collectSatelliteConfig
+  };
+  if (getBridge()) {
+    wireEvents();
+    renderSection();
+  }
+})();

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

@@ -0,0 +1,483 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/sat.ts
+var satWindow = window;
+var satDom = {
+  status: document.getElementById("sat-status"),
+  liveView: document.getElementById("sat-live-view"),
+  historyView: document.getElementById("sat-history-view"),
+  predictionsView: document.getElementById("sat-predictions-view"),
+  liveLatest: document.getElementById("sat-live-latest"),
+  historyList: document.getElementById("sat-history-list"),
+  historyCount: document.getElementById("sat-history-count"),
+  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")
+};
+var satImageHistory = [];
+var SAT_MAX_IMAGES = 100;
+var SAT_PRED_PAGE_SIZE = 50;
+var satPredShowAll = false;
+var satFilterText = "";
+var satActiveView = "live";
+var satPredData = [];
+var satPredFilterText = "";
+var satPredMinEl = 0;
+var satPredCategory = "all";
+var satPredSatCount = 0;
+var satPredCountdownTimer = null;
+function scheduleSatUi(key, job) {
+  if (typeof satWindow.trxScheduleUiFrameJob === "function") {
+    satWindow.trxScheduleUiFrameJob(key, job);
+    return;
+  }
+  job();
+}
+function switchSatView(view) {
+  const leavingPredictions = satActiveView === "predictions" && view !== "predictions";
+  satActiveView = view;
+  if (satDom.liveView) satDom.liveView.style.display = view === "live" ? "" : "none";
+  if (satDom.historyView) satDom.historyView.style.display = view === "history" ? "" : "none";
+  if (satDom.predictionsView) satDom.predictionsView.style.display = view === "predictions" ? "" : "none";
+  if (satDom.viewLiveBtn) satDom.viewLiveBtn.classList.toggle("sat-view-active", view === "live");
+  if (satDom.viewHistoryBtn) satDom.viewHistoryBtn.classList.toggle("sat-view-active", view === "history");
+  if (satDom.viewPredBtn) satDom.viewPredBtn.classList.toggle("sat-view-active", view === "predictions");
+  if (leavingPredictions) clearPredictionDom();
+  if (view === "history") {
+    renderSatHistoryTable();
+  } else if (view === "predictions") {
+    satPredShowAll = false;
+    void loadSatPredictions();
+  }
+}
+function clearPredictionDom() {
+  stopCountdownTimer();
+  if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
+  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
+}
+satWindow.clearSatPredictionDom = clearPredictionDom;
+satDom.viewLiveBtn?.addEventListener("click", () => {
+  switchSatView("live");
+});
+satDom.viewHistoryBtn?.addEventListener("click", () => {
+  switchSatView("history");
+});
+satDom.viewPredBtn?.addEventListener("click", () => {
+  switchSatView("predictions");
+});
+var lastSatLrptOn = null;
+satWindow.updateSatLiveState = function(update) {
+  if (!satDom.lrptState) return;
+  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 — 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];
+  if (!img) return;
+  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() : "";
+  const 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;
+}
+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 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 (const image of items) {
+    fragment.appendChild(renderSatHistoryRow(image));
+  }
+  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`;
+  }
+}
+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();
+    });
+  }
+}
+function onServerLrptProgress(msg) {
+  if (satDom.status && (msg.mcu_count ?? 0) > 0) {
+    satDom.status.textContent = `Receiving — ${String(msg.mcu_count ?? 0)} MCU rows decoded`;
+  }
+}
+function onServerLrptImage(msg) {
+  if (satDom.status) satDom.status.textContent = "Image received (Meteor LRPT)";
+  addSatImage(msg, "lrpt");
+  if (msg.geo_bounds && msg.path && satWindow.addSatMapOverlay) {
+    satWindow.addSatMapOverlay(msg);
+  }
+}
+function resetSatHistoryView() {
+  satImageHistory = [];
+  if (satDom.historyList) satDom.historyList.innerHTML = "";
+  renderSatLatestCard();
+  renderSatHistoryTable();
+  satWindow.clearSatMapOverlays?.();
+}
+function pruneSatHistoryView() {
+  renderSatHistoryTable();
+  renderSatLatestCard();
+}
+satWindow.trxPluginRuntime.registerDecoder({
+  id: "lrpt_image",
+  onMessage: onServerLrptImage,
+  reset: resetSatHistoryView,
+  prune: pruneSatHistoryView
+});
+satWindow.trxPluginRuntime.registerDecoder({
+  id: "lrpt_progress",
+  onMessage: onServerLrptProgress
+});
+var lrptDecodeToggleBtn = document.getElementById("lrpt-decode-toggle-btn");
+lrptDecodeToggleBtn?.addEventListener("click", () => {
+  void (async () => {
+    try {
+      await satWindow.takeSchedulerControlForDecoderDisable?.(lrptDecodeToggleBtn);
+      await hostCore.postPath("/toggle_lrpt_decode");
+    } catch (e) {
+      console.error("LRPT toggle failed", e);
+    }
+  })();
+});
+var satFilterInput = satDom.filterInput;
+satFilterInput?.addEventListener("input", () => {
+  satFilterText = satFilterInput.value.trim().toUpperCase();
+  renderSatHistoryTable();
+});
+satDom.sortSelect?.addEventListener("change", () => {
+  renderSatHistoryTable();
+});
+satDom.typeFilter?.addEventListener("change", () => {
+  renderSatHistoryTable();
+});
+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 hostCore.postPath("/clear_lrpt_decode");
+      resetSatHistoryView();
+    } catch (e) {
+      console.error("Weather satellite history clear failed", e);
+    }
+  })();
+});
+function azToCardinal(deg) {
+  const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
+  return dirs[Math.round(deg / 45) % 8] ?? "N";
+}
+function formatPredTime(ms) {
+  const d = new Date(ms);
+  const now = /* @__PURE__ */ new Date();
+  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const day = d.getUTCDay() !== now.getUTCDay() ? `${dayNames[d.getUTCDay()] ?? ""} ` : "";
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${day}${hh}:${mm}`;
+}
+function formatPredDuration(s) {
+  if (s >= 60) return `${Math.round(s / 60)} min`;
+  return `${s}s`;
+}
+function formatCountdown(ms) {
+  const totalSec = Math.max(0, Math.floor(ms / 1e3));
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+function elevationClass(deg) {
+  if (deg >= 45) return "sat-pred-el-high";
+  if (deg >= 10) return "sat-pred-el-mid";
+  return "sat-pred-el-low";
+}
+function stopCountdownTimer() {
+  if (satPredCountdownTimer) {
+    clearInterval(satPredCountdownTimer);
+    satPredCountdownTimer = null;
+  }
+}
+function startCountdownTimer(container) {
+  const countdownEls = container?.querySelectorAll(".sat-pred-col-countdown") ?? [];
+  if (countdownEls.length === 0) return;
+  satPredCountdownTimer = setInterval(() => {
+    if (satActiveView !== "predictions") {
+      stopCountdownTimer();
+      return;
+    }
+    const n = Date.now();
+    let anyActive = false;
+    for (const el of countdownEls) {
+      const los = Number.parseInt(el.dataset.los ?? "0", 10);
+      const rem = los - n;
+      if (rem > 0) {
+        el.textContent = formatCountdown(rem);
+        anyActive = true;
+      } else {
+        el.textContent = "0:00";
+      }
+    }
+    if (!anyActive) {
+      stopCountdownTimer();
+      renderSatPredictions(getFilteredPredictions());
+    }
+  }, 1e3);
+}
+function buildCurrentPassRow(pass, now) {
+  const row = document.createElement("div");
+  row.className = "sat-pred-row-current";
+  const dir = `${azToCardinal(pass.azimuth_aos_deg)} → ${azToCardinal(pass.azimuth_los_deg)}`;
+  const remaining = Math.max(0, pass.los_ms - now);
+  row.innerHTML = [
+    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
+    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}°</span>`,
+    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
+    `<span class="sat-pred-col-time">${formatPredTime(pass.los_ms)}</span>`,
+    `<span class="sat-pred-col-countdown" data-los="${pass.los_ms}">${formatCountdown(remaining)}</span>`,
+    `<span class="sat-pred-col-dir">${dir}</span>`
+  ].join("");
+  return row;
+}
+function buildUpcomingPassRow(pass) {
+  const row = document.createElement("div");
+  row.className = "sat-pred-row";
+  const dir = `${azToCardinal(pass.azimuth_aos_deg)} → ${azToCardinal(pass.azimuth_los_deg)}`;
+  row.innerHTML = [
+    `<span class="sat-pred-col-time">${formatPredTime(pass.aos_ms)}</span>`,
+    `<span class="sat-pred-col-sat">${pass.satellite}</span>`,
+    `<span class="sat-pred-col-el ${elevationClass(pass.max_elevation_deg)}">${pass.max_elevation_deg.toFixed(1)}°</span>`,
+    `<span class="sat-pred-col-dur">${formatPredDuration(pass.duration_s)}</span>`,
+    `<span class="sat-pred-col-dir">${dir}</span>`
+  ].join("");
+  return row;
+}
+function getFilteredPredictions() {
+  let items = satPredData;
+  if (satPredCategory !== "all") items = items.filter((p) => p.category === satPredCategory);
+  if (satPredMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= satPredMinEl);
+  if (satPredFilterText) items = items.filter((p) => p.satellite.toUpperCase().includes(satPredFilterText));
+  return items;
+}
+function applyPredFilters() {
+  renderSatPredictions(getFilteredPredictions());
+}
+var satPredictionFilter = satDom.predFilter;
+satPredictionFilter?.addEventListener("input", () => {
+  satPredFilterText = satPredictionFilter.value.trim().toUpperCase();
+  applyPredFilters();
+});
+var satPredictionMinElevation = satDom.predMinEl;
+satPredictionMinElevation?.addEventListener("change", () => {
+  satPredMinEl = Number.parseInt(satPredictionMinElevation.value, 10) || 0;
+  applyPredFilters();
+});
+var satPredictionCategory = satDom.predCategory;
+satPredictionCategory?.addEventListener("change", () => {
+  satPredCategory = satPredictionCategory.value;
+  applyPredFilters();
+});
+function renderSatPredictions(passes, error) {
+  stopCountdownTimer();
+  if (error) {
+    if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
+    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
+    if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = "none";
+    if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = "none";
+    if (satDom.predStatus) satDom.predStatus.textContent = error;
+    return;
+  }
+  if (!Array.isArray(passes) || passes.length === 0) {
+    if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
+    if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
+    if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = "none";
+    if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = "none";
+    if (satDom.predStatus) satDom.predStatus.textContent = "No passes found in the next 24 hours.";
+    return;
+  }
+  const now = Date.now();
+  const current = passes.filter((p) => p.aos_ms <= now && p.los_ms > now);
+  const upcoming = passes.filter((p) => p.aos_ms > now);
+  if (satDom.predCurrentSec) satDom.predCurrentSec.style.display = current.length > 0 ? "" : "none";
+  if (satDom.predCurrentList) {
+    if (current.length === 0) {
+      satDom.predCurrentList.innerHTML = "";
+    } else {
+      const frag = document.createDocumentFragment();
+      for (const pass of current) frag.appendChild(buildCurrentPassRow(pass, now));
+      satDom.predCurrentList.replaceChildren(frag);
+    }
+  }
+  const upcomingLimit = satPredShowAll ? upcoming.length : SAT_PRED_PAGE_SIZE;
+  const visibleUpcoming = upcoming.slice(0, upcomingLimit);
+  const hiddenCount = upcoming.length - visibleUpcoming.length;
+  if (satDom.predUpcomingSec) satDom.predUpcomingSec.style.display = upcoming.length > 0 ? "" : "none";
+  if (satDom.predUpcomingList) {
+    const frag = document.createDocumentFragment();
+    for (const pass of visibleUpcoming) frag.appendChild(buildUpcomingPassRow(pass));
+    if (hiddenCount > 0) {
+      const moreRow = document.createElement("div");
+      moreRow.className = "sat-pred-row";
+      moreRow.style.cursor = "pointer";
+      moreRow.style.textAlign = "center";
+      moreRow.innerHTML = `<span style="grid-column:1/-1;color:var(--accent);font-size:0.82rem;">Show ${hiddenCount} more passes…</span>`;
+      moreRow.addEventListener("click", () => {
+        satPredShowAll = true;
+        renderSatPredictions(getFilteredPredictions());
+      });
+      frag.appendChild(moreRow);
+    }
+    satDom.predUpcomingList.replaceChildren(frag);
+  }
+  if (satDom.predStatus) {
+    let text = `${current.length} active · ${upcoming.length} upcoming · times in UTC`;
+    if (satPredSatCount > 0) text += ` · ${satPredSatCount} satellites tracked`;
+    satDom.predStatus.textContent = text;
+  }
+  if (current.length > 0 && satActiveView === "predictions") {
+    startCountdownTimer(satDom.predCurrentList);
+  }
+}
+async function loadSatPredictions() {
+  if (satDom.predStatus) satDom.predStatus.textContent = "Loading predictions…";
+  if (satDom.predCurrentList) satDom.predCurrentList.innerHTML = "";
+  if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
+  try {
+    const resp = await fetch("/sat_passes");
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const data = await resp.json();
+    satPredSatCount = data.satellite_count || 0;
+    if (data.error) {
+      satPredData = [];
+      renderSatPredictions([], data.error);
+    } else {
+      satPredData = data.passes || [];
+      renderSatPredictions(getFilteredPredictions());
+    }
+  } catch (error) {
+    renderSatPredictions([], `Failed to load predictions: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+satWindow.satShowOnMap = function(south, west, north, east) {
+  if (typeof satWindow.enableMapSourceFilter === "function") {
+    satWindow.enableMapSourceFilter("sat");
+  }
+  const lat = (south + north) / 2;
+  const lon = (west + east) / 2;
+  if (satWindow.navigateToAprsMap) {
+    satWindow.navigateToAprsMap(lat, lon);
+  }
+};
+renderSatLatestCard();
+renderSatHistoryTable();

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

@@ -1,13 +1,8 @@
-// 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 () {
+// src/screenshot.ts
+var screenshotWindow = window;
+(function() {
   "use strict";
-  const T = window.trx;
-
+  const T = screenshotWindow.trx;
   function isVisibleForSnapshot(el) {
     if (!el) return false;
     const style = getComputedStyle(el);
@@ -17,7 +12,6 @@
     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();
@@ -32,7 +26,6 @@
     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();
@@ -45,30 +38,29 @@
     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.fillStyle = `rgba(${String(Math.round(bg[0]))}, ${String(Math.round(bg[1]))}, ${String(Math.round(bg[2]))}, ${String(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.strokeStyle = `rgba(${String(Math.round(border[0]))}, ${String(Math.round(border[1]))}, ${String(Math.round(border[2]))}, ${String(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);
+    const words = (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];
+      const word = words[i] ?? "";
+      const candidate = line ? `${line} ${word}` : word;
       if (ctx.measureText(candidate).width <= maxWidth || !line) {
         line = candidate;
         continue;
@@ -76,13 +68,12 @@
       ctx.fillText(line, x, y + lineIdx * lineHeight);
       lineIdx += 1;
       if (lineIdx >= maxLines) return;
-      line = words[i];
+      line = word;
     }
     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;
@@ -91,7 +82,7 @@
     if (!clean) return;
     const style = chrome.style;
     const fontSize = parseFloat(style.fontSize) || 12;
-    const lineHeight = (parseFloat(style.lineHeight) || fontSize * 1.25);
+    const lineHeight = parseFloat(style.lineHeight) || fontSize * 1.25;
     const padX = 6;
     const padY = 4;
     const maxWidth = Math.max(20, chrome.w - padX * 2);
@@ -110,12 +101,11 @@
         chrome.y + padY + lineCursor * lineHeight,
         maxWidth,
         lineHeight,
-        maxLines - lineCursor,
+        maxLines - lineCursor
       );
       lineCursor += 1;
     }
   }
-
   function drawAxisLabels(ctx, axisEl, rootRect) {
     if (!isVisibleForSnapshot(axisEl)) return;
     for (const node of axisEl.children) {
@@ -132,7 +122,6 @@
       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");
@@ -145,8 +134,7 @@
       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.
+      } catch {
       }
     }
     const rootRect = rootEl.getBoundingClientRect();
@@ -157,11 +145,9 @@
     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) {
@@ -172,28 +158,21 @@
         rect.left - rootRect.left,
         rect.top - rootRect.top,
         rect.width,
-        rect.height,
+        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",
+      "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);
@@ -201,10 +180,8 @@
     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;
@@ -213,9 +190,10 @@
     a.style.display = "none";
     document.body.appendChild(a);
     a.click();
-    requestAnimationFrame(() => a.remove());
+    requestAnimationFrame(() => {
+      a.remove();
+    });
   }
-
   function saveCanvasAsPng(canvas, fileName) {
     if (!canvas) return Promise.resolve(false);
     if (typeof canvas.toBlob === "function") {
@@ -228,10 +206,12 @@
             }
             const url = URL.createObjectURL(blob);
             clickCanvasDownload(url, fileName);
-            setTimeout(() => URL.revokeObjectURL(url), 1000);
+            setTimeout(() => {
+              URL.revokeObjectURL(url);
+            }, 1e3);
             resolve(true);
           }, "image/png");
-        } catch (_) {
+        } catch {
           resolve(false);
         }
       });
@@ -239,27 +219,24 @@
     try {
       clickCanvasDownload(canvas.toDataURL("image/png"), fileName);
       return Promise.resolve(true);
-    } catch (_) {
+    } 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 stamp = (/* @__PURE__ */ 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.screenshot = {
+  screenshotWindow.trx.modules.screenshot = {
     captureSpectrumScreenshot,
     buildSpectrumSnapshotCanvas,
-    saveCanvasAsPng,
+    saveCanvasAsPng
   };
 })();

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

@@ -0,0 +1,451 @@
+import {
+  hostCore,
+  hostState
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/vchan.ts
+var vchanWindow = window;
+var vchanSessionId = null;
+var vchanRigId = null;
+var vchanChannels = [];
+var vchanActiveId = null;
+var schedulerReleaseState = null;
+var schedulerReleasePollTimer = null;
+function vchanFmtFreq(hz) {
+  if (!Number.isFinite(hz) || hz <= 0) return "--";
+  if (hz >= 1e9) return (hz / 1e9).toFixed(4).replace(/\.?0+$/, "") + " GHz";
+  if (hz >= 1e6) return (hz / 1e6).toFixed(4).replace(/\.?0+$/, "") + " MHz";
+  if (hz >= 1e3) return (hz / 1e3).toFixed(1).replace(/\.?0+$/, "") + " kHz";
+  return `${String(hz)} Hz`;
+}
+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(() => {
+    void vchanPollSchedulerRelease();
+  }, 1e4);
+}
+async function vchanToggleSchedulerRelease() {
+  if (!vchanSessionId) return;
+  const rigId = vchanRigId || hostState.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);
+  }
+}
+function vchanHandleSession(data) {
+  try {
+    const d = JSON.parse(data);
+    vchanSessionId = d.session_id || null;
+    void vchanPollSchedulerRelease();
+  } catch (e) {
+    console.warn("vchan: bad session event", e);
+  }
+}
+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));
+    const primaryChannel = vchanChannels[0];
+    if (!vchanActiveId && primaryChannel && vchanSessionId) {
+      void vchanAutoJoinPrimary(primaryChannel.id);
+    } else if (vchanActiveId && !ids.has(vchanActiveId)) {
+      vchanActiveId = vchanChannels[0]?.id ?? null;
+      vchanReconnectAudio();
+    }
+    vchanRender();
+    vchanRenderSchedulerRelease();
+    vchanWindow.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 = "×";
+      del.title = "Delete channel";
+      del.addEventListener("click", (e) => {
+        e.stopPropagation();
+        void vchanDelete(ch.id);
+      });
+      btn.appendChild(del);
+    }
+    btn.addEventListener("click", () => {
+      if (ch.id !== vchanActiveId) void vchanSubscribe(ch.id);
+    });
+    picker.appendChild(btn);
+  });
+  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", () => {
+    void vchanAllocate();
+  });
+  picker.appendChild(addBtn);
+  vchanSyncAccentUI();
+  hostCore.updateDocumentTitle(hostCore.activeChannelRds());
+  vchanRenderSchedulerRelease();
+}
+async function vchanAllocate() {
+  if (!vchanSessionId || !vchanRigId) return;
+  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 {
+    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;
+    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);
+    }
+  } catch (e) {
+    console.error("vchan: delete error", e);
+  }
+}
+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);
+  }
+}
+function vchanReconnectAudio() {
+  const ch = vchanIsOnVirtual() ? vchanActiveChannel() : null;
+  hostState.audioChannelOverride = ch?.id ?? null;
+  if (!hostState.rxActive) return;
+  hostCore.stopRxAudio();
+  setTimeout(() => {
+    hostCore.startRxAudio();
+  }, 300);
+}
+function vchanApplyCapabilities(caps) {
+  const picker = document.getElementById("vchan-picker");
+  if (!picker) return;
+  picker.style.display = caps && caps.filter_controls ? "" : "none";
+  vchanRenderSchedulerRelease();
+}
+function vchanIsOnVirtual() {
+  if (!vchanActiveId || vchanChannels.length === 0) return false;
+  return vchanActiveId !== vchanChannels[0]?.id;
+}
+function vchanActiveChannel() {
+  return vchanChannels.find((c) => c.id === vchanActiveId) || null;
+}
+function vchanUpdateFreqDisplay() {
+  const ch = vchanActiveChannel();
+  if (!ch) return;
+  const el = document.getElementById("freq");
+  if (!el) return;
+  el.value = hostCore.formatFreqForStep(ch.freq_hz, hostState.jogUnit);
+}
+function vchanSyncModeDisplay() {
+  const modeEl = document.getElementById("mode");
+  if (!modeEl) return;
+  if (vchanIsOnVirtual()) {
+    const ch = vchanActiveChannel();
+    if (ch && ch.mode) modeEl.value = ch.mode.toUpperCase();
+  }
+  const modeUpper = (modeEl.value || "").toUpperCase();
+  if (typeof hostState.lastModeName === "string") {
+    if (modeUpper === "WFM" && hostState.lastModeName !== "WFM") {
+      hostCore.setJogDivisor(10);
+      hostCore.resetRdsDisplay();
+    } else if (modeUpper !== "WFM" && hostState.lastModeName === "WFM") {
+      hostCore.resetRdsDisplay();
+    }
+    hostState.lastModeName = modeUpper;
+  }
+  hostCore.updateWfmControls();
+  hostCore.updateSdrSquelchControlVisibility();
+  if (vchanWindow.refreshRdsUi) {
+    vchanWindow.refreshRdsUi();
+  } else {
+    hostCore.positionRdsPsOverlay();
+  }
+}
+function vchanSyncBwDisplay() {
+  if (!vchanIsOnVirtual()) return;
+  const ch = vchanActiveChannel();
+  if (!ch) return;
+  const bwEl = document.getElementById("spectrum-bw-input");
+  if (!bwEl) return;
+  let bwHz = ch.bandwidth_hz || 0;
+  if (bwHz === 0) {
+    bwHz = hostCore.mwDefaultsForMode(ch.mode)[0] || 0;
+  }
+  if (bwHz > 0) {
+    bwEl.value = (bwHz / 1e3).toFixed(3).replace(/\.?0+$/, "");
+    hostState.currentBandwidthHz = bwHz;
+  }
+}
+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 {
+    hostCore.refreshFreqDisplay();
+  }
+  hostCore.updateDocumentTitle(hostCore.activeChannelRds());
+}
+function vchanSetChannelFreq(freqHz) {
+  if (!vchanRigId || !vchanActiveId) return;
+  if (hostState.lastSpectrumData && hostState.lastSpectrumData.sample_rate > 0) {
+    const halfSpan = hostState.lastSpectrumData.sample_rate / 2;
+    const center = hostState.lastSpectrumData.center_hz;
+    if (Math.abs(freqHz - center) > halfSpan) {
+      hostCore.showHint(
+        `Out of SDR bandwidth (center ${(center / 1e6).toFixed(3)} MHz ±${(halfSpan / 1e3).toFixed(0)} kHz)`,
+        3e3
+      );
+      return;
+    }
+  }
+  void vchanTakeSchedulerControl();
+  void fetch(
+    `/channels/${encodeURIComponent(vchanRigId)}/${encodeURIComponent(vchanActiveId)}/freq`,
+    {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ freq_hz: Math.round(freqHz) })
+    }
+  ).catch((error) => {
+    console.error("vchan: set freq error", error);
+  });
+}
+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);
+  }
+}
+async function vchanInterceptMode(mode) {
+  if (!vchanIsOnVirtual()) return false;
+  await vchanSetChannelMode(mode);
+  return true;
+}
+async function vchanInterceptBandwidth(bwHz) {
+  if (!vchanIsOnVirtual()) return false;
+  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 = {
+  get channels() {
+    return vchanChannels;
+  },
+  get activeId() {
+    return vchanActiveId;
+  },
+  activeChannel: vchanActiveChannel,
+  applyCapabilities: vchanApplyCapabilities,
+  handleSession: vchanHandleSession,
+  handleChannels: vchanHandleChannels,
+  isOnVirtual: vchanIsOnVirtual,
+  interceptMode: vchanInterceptMode,
+  interceptBandwidth: vchanInterceptBandwidth,
+  interceptFrequency: vchanInterceptFrequency,
+  interceptFreqDisplay: vchanInterceptFreqDisplay,
+  takeSchedulerControl: vchanTakeSchedulerControl,
+  releaseToScheduler: vchanToggleSchedulerRelease
+};
+(function initSchedulerReleaseControl() {
+  const btn = document.getElementById("scheduler-release-btn");
+  if (btn) {
+    btn.addEventListener("click", () => {
+      void vchanToggleSchedulerRelease();
+    });
+  }
+  vchanStartSchedulerReleasePolling();
+  vchanRenderSchedulerRelease();
+})();

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

@@ -0,0 +1,272 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/vdes.ts
+var vdesWindow = window;
+var escapeVdesHtml = (input) => hostCore.escapeMapHtml(input);
+var vdesStatus = document.getElementById("vdes-status");
+var vdesMessagesEl = document.getElementById("vdes-messages");
+var vdesFilterInput = document.getElementById("vdes-filter");
+var vdesBarOverlay = document.getElementById("vdes-bar-overlay");
+var vdesChannelSummaryEl = document.getElementById("vdes-channel-summary");
+var vdesFrameCountEl = document.getElementById("vdes-frame-count");
+var vdesLatestSeenEl = document.getElementById("vdes-latest-seen");
+var VDES_BAR_WINDOW_MS = 15 * 60 * 1e3;
+var vdesFilterText = "";
+var vdesMessageHistory = [];
+function currentVdesHistoryRetentionMs() {
+  return typeof vdesWindow.getDecodeHistoryRetentionMs === "function" ? vdesWindow.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1e3;
+}
+function pruneVdesMessageHistory() {
+  const cutoffMs = Date.now() - currentVdesHistoryRetentionMs();
+  vdesMessageHistory = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
+}
+function scheduleVdesUi(key, job) {
+  if (typeof vdesWindow.trxScheduleUiFrameJob === "function") {
+    vdesWindow.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 / 1e6).toFixed(3)} MHz`;
+}
+function vdesAgeText(tsMs) {
+  if (typeof tsMs !== "number" || !Number.isFinite(tsMs)) return "just now";
+  const deltaMs = Math.max(0, Date.now() - tsMs);
+  const seconds = Math.round(deltaMs / 1e3);
+  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) => 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 renderVdesRow(msg) {
+  const row = document.createElement("div");
+  row.className = "vdes-message";
+  const ts = msg._ts || (/* @__PURE__ */ 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">${escapeVdesHtml(title)}</span><span class="vdes-badge">${escapeVdesHtml(label)}</span>` + (labelText ? `<span class="vdes-badge">${escapeVdesHtml(labelText)}</span>` : "") + (linkText ? `<span class="vdes-badge">${escapeVdesHtml(linkText)}</span>` : "") + (srcText ? `<span class="vdes-badge">${escapeVdesHtml(srcText)}</span>` : "") + (dstText ? `<span class="vdes-badge">${escapeVdesHtml(dstText)}</span>` : "") + (syncText ? `<span class="vdes-badge">${escapeVdesHtml(syncText)}</span>` : "") + (phaseText ? `<span class="vdes-badge">${escapeVdesHtml(phaseText)}</span>` : "") + `<span class="vdes-badge">T${escapeVdesHtml(String(msg.message_type ?? "--"))}</span></div><div class="vdes-row-meta"><span>${escapeVdesHtml(currentVdesCenterText())}</span><span>${escapeVdesHtml(`${msg.bit_len || 0} bits`)}</span>` + (sessionText ? `<span>${escapeVdesHtml(sessionText)}</span>` : "") + (asmText ? `<span>${escapeVdesHtml(asmText)}</span>` : "") + (countText ? `<span>${escapeVdesHtml(countText)}</span>` : "") + (ackText ? `<span>${escapeVdesHtml(ackText)}</span>` : "") + (cqiText ? `<span>${escapeVdesHtml(cqiText)}</span>` : "") + (info ? `<span>${escapeVdesHtml(info)}</span>` : "") + (fecText ? `<span>${escapeVdesHtml(fecText)}</span>` : "") + `<span>${escapeVdesHtml(vdesAgeText(msg._tsMs))}</span></div><div class="vdes-row-detail">` + (previewText ? `<span>${escapeVdesHtml(previewText)}</span>` : "") + (previewText ? `<span>·</span>` : "") + `<span class="vdes-raw">${escapeVdesHtml(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 ?? 0) >= 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 = escapeVdesHtml(msg.callsign || "VDES");
+    const title = escapeVdesHtml(msg.vessel_name || "Burst");
+    const detail = [
+      `${msg.bit_len || 0} bits`,
+      msg.message_label ? escapeVdesHtml(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 ? escapeVdesHtml(msg.destination) : null,
+      escapeVdesHtml(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";
+}
+vdesWindow.updateVdesBar = updateVdesBar;
+vdesWindow.clearVdesBar = function() {
+  resetVdesHistoryView();
+};
+function resetVdesHistoryView() {
+  if (vdesMessagesEl) vdesMessagesEl.innerHTML = "";
+  vdesMessageHistory = [];
+  updateVdesBar();
+  renderVdesHistory();
+}
+function renderVdesHistory() {
+  pruneVdesMessageHistory();
+  if (!vdesMessagesEl) {
+    updateVdesSummary();
+    return;
+  }
+  const fragment = document.createDocumentFragment();
+  for (const message of vdesMessageHistory) {
+    fragment.appendChild(renderVdesRow(message));
+  }
+  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 {
+    ...msg,
+    rig_id: msg.rig_id || null
+  };
+}
+function onServerVdesBatch(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return;
+  if (vdesStatus) vdesStatus.textContent = "Receiving";
+  const normalized = [];
+  for (const msg of messages) {
+    const next = normalizeServerVdesMessage(msg);
+    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 && vdesWindow.vdesMapAddPoint) {
+      vdesWindow.vdesMapAddPoint(next);
+    }
+    normalized.push(next);
+  }
+  normalized.reverse();
+  vdesMessageHistory = normalized.concat(vdesMessageHistory);
+  pruneVdesMessageHistory();
+  scheduleVdesBarUpdate();
+  scheduleVdesHistoryRender();
+}
+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 hostCore.postPath("/clear_vdes_decode");
+      resetVdesHistoryView();
+    } catch (e) {
+      console.error("VDES history clear failed", e);
+    }
+  })();
+});
+if (vdesFilterInput) {
+  vdesFilterInput.addEventListener("input", () => {
+    vdesFilterText = vdesFilterInput.value.trim().toUpperCase();
+    renderVdesHistory();
+  });
+}
+function onServerVdes(msg) {
+  if (vdesStatus) vdesStatus.textContent = "Receiving";
+  const next = normalizeServerVdesMessage(msg);
+  addVdesMessage(next);
+  if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
+    vdesWindow.vdesMapAddPoint(next);
+  }
+}
+function pruneVdesHistoryView() {
+  pruneVdesMessageHistory();
+  updateVdesBar();
+  renderVdesHistory();
+}
+updateVdesSummary();
+window.trxPluginRuntime.registerDecoder({
+  id: "vdes",
+  onMessage: onServerVdes,
+  onBatch: onServerVdesBatch,
+  restore: onServerVdesBatch,
+  reset: resetVdesHistoryView,
+  prune: pruneVdesHistoryView
+});

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

@@ -0,0 +1,336 @@
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
+
+// src/plugins/wefax.ts
+var wefaxWindow = window;
+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")
+};
+var wefaxImageHistory = [];
+var WEFAX_MAX_IMAGES = 100;
+var wefaxLiveCtx = null;
+var wefaxLiveLineCount = 0;
+var wefaxLivePixelsPerLine = 1809;
+var wefaxActiveView = "live";
+var wefaxFilterText = "";
+function currentWefaxHistoryRetentionMs() {
+  return wefaxWindow.getDecodeHistoryRetentionMs?.() ?? 24 * 60 * 60 * 1e3;
+}
+function pruneWefaxHistory() {
+  const 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 wefaxWindow.trxScheduleUiFrameJob === "function") {
+    wefaxWindow.trxScheduleUiFrameJob(key, job);
+    return;
+  }
+  job();
+}
+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");
+});
+function resetLiveCanvas(pixelsPerLine) {
+  const canvas = wefaxDom.liveCanvas;
+  if (!canvas) return;
+  wefaxLivePixelsPerLine = pixelsPerLine;
+  wefaxLiveLineCount = 0;
+  canvas.width = pixelsPerLine;
+  canvas.height = 800;
+  wefaxLiveCtx = canvas.getContext("2d");
+  if (!wefaxLiveCtx) return;
+  wefaxLiveCtx.fillStyle = "#000";
+  wefaxLiveCtx.fillRect(0, 0, canvas.width, canvas.height);
+  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = "";
+}
+function paintLine(lineBytes) {
+  const canvas = wefaxDom.liveCanvas;
+  if (!wefaxLiveCtx || !canvas) return;
+  const y = wefaxLiveLineCount;
+  if (y >= canvas.height) {
+    const old = wefaxLiveCtx.getImageData(0, 0, canvas.width, canvas.height);
+    canvas.height *= 2;
+    wefaxLiveCtx = canvas.getContext("2d");
+    if (!wefaxLiveCtx) return;
+    wefaxLiveCtx.putImageData(old, 0, 0);
+  }
+  const w = wefaxLivePixelsPerLine;
+  const imgData = wefaxLiveCtx.createImageData(w, 1);
+  const d = imgData.data;
+  for (let x = 0; x < w; x++) {
+    const v = lineBytes[x] ?? 0;
+    const i = x * 4;
+    d[i] = v;
+    d[i + 1] = v;
+    d[i + 2] = v;
+    d[i + 3] = 255;
+  }
+  wefaxLiveCtx.putImageData(imgData, 0, y);
+  wefaxLiveLineCount++;
+}
+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;
+  }
+  const img = wefaxImageHistory[0];
+  if (!img) return;
+  const ts = img._ts || "--";
+  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : "";
+  const meta = [
+    `${String(img.ioc ?? "--")} IOC`,
+    `${String(img.lpm ?? "--")} LPM`,
+    `${String(img.line_count ?? 0)} lines`,
+    `${date} ${ts}`
+  ].join(" · ");
+  const imgSrc = img._dataUrl ? img._dataUrl : img.path ? "/images/" + escapeHtml(img.path.split("/").pop()) : null;
+  let 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;
+}
+function getWefaxFilteredHistory() {
+  let items = wefaxImageHistory;
+  if (wefaxFilterText) {
+    items = items.filter(function(i) {
+      const haystack = [
+        String(i.ioc || ""),
+        String(i.lpm || ""),
+        String(i.line_count || "")
+      ].join(" ").toUpperCase();
+      return haystack.indexOf(wefaxFilterText) >= 0;
+    });
+  }
+  const sortVal = wefaxDom.sortSelect ? wefaxDom.sortSelect.value : "newest";
+  if (sortVal === "oldest") items = items.slice().reverse();
+  return items;
+}
+function renderWefaxHistoryRow(img) {
+  const row = document.createElement("div");
+  row.className = "sat-history-row";
+  const ts = img._ts || "--";
+  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString([], { month: "short", day: "numeric" }) : "";
+  const ioc = img.ioc || "--";
+  const lpm = img.lpm || "--";
+  const lines = img.line_count || 0;
+  const imgSrc = img._dataUrl ? img._dataUrl : img.path ? "/images/" + escapeHtml(img.path.split("/").pop()) : null;
+  const 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>${String(lines)}</span>`,
+    "<span>" + link + "</span>"
+  ].join("");
+  return row;
+}
+function renderWefaxHistoryTable() {
+  if (!wefaxDom.historyList) return;
+  pruneWefaxHistory();
+  const items = getWefaxFilteredHistory();
+  const fragment = document.createDocumentFragment();
+  for (const item of items) {
+    fragment.appendChild(renderWefaxHistoryRow(item));
+  }
+  wefaxDom.historyList.replaceChildren(fragment);
+  if (wefaxDom.historyCount) {
+    const total = wefaxImageHistory.length;
+    const shown = items.length;
+    wefaxDom.historyCount.textContent = total === 0 ? "No images yet" : shown === total ? `${String(total)} image${total === 1 ? "" : "s"}` : `${String(shown)} of ${String(total)} images`;
+  }
+}
+function addWefaxImage(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"
+  });
+  const canvas = wefaxDom.liveCanvas;
+  if (wefaxLiveCtx && canvas && wefaxLiveLineCount > 0) {
+    const trimmed = wefaxLiveCtx.getImageData(0, 0, canvas.width, wefaxLiveLineCount);
+    canvas.height = wefaxLiveLineCount;
+    wefaxLiveCtx = canvas.getContext("2d");
+    if (!wefaxLiveCtx) return;
+    wefaxLiveCtx.putImageData(trimmed, 0, 0);
+    try {
+      msg._dataUrl = canvas.toDataURL("image/png");
+    } catch {
+    }
+  }
+  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);
+  }
+}
+function onServerWefaxProgress(msg) {
+  if (msg.state && !msg.line_data) {
+    if (wefaxDom.status) {
+      wefaxDom.status.textContent = msg.state;
+      wefaxDom.status.style.color = msg.state.indexOf("Idle") === 0 ? "" : "var(--text-accent)";
+    }
+    return;
+  }
+  if ((msg.line_count ?? 0) <= 1 || !wefaxLiveCtx) {
+    resetLiveCanvas(msg.pixels_per_line || 1809);
+  }
+  if (msg.line_data) {
+    const binary = atob(msg.line_data);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    paintLine(bytes);
+  }
+  if (wefaxDom.liveInfo) {
+    wefaxDom.liveInfo.textContent = `Line ${String(msg.line_count ?? 0)} · ${String(msg.ioc ?? "--")} IOC · ${String(msg.lpm ?? "--")} LPM`;
+  }
+  if (wefaxDom.status) {
+    wefaxDom.status.textContent = `Receiving — line ${String(msg.line_count ?? 0)}`;
+    wefaxDom.status.style.color = "var(--text-accent)";
+  }
+}
+function onServerWefax(msg) {
+  addWefaxImage(msg);
+  if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = "none";
+  if (wefaxDom.status) {
+    wefaxDom.status.textContent = `Complete — ${String(msg.line_count ?? 0)} lines`;
+    wefaxDom.status.style.color = "";
+  }
+}
+function restoreWefaxHistory(messages) {
+  if (!messages.length) return;
+  for (const message of messages) {
+    const tsMs = Number.isFinite(message.ts_ms) ? Number(message.ts_ms) : Date.now();
+    message._tsMs = tsMs;
+    message._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);
+  }
+}
+function pruneWefaxHistoryView() {
+  pruneWefaxHistory();
+  renderWefaxHistoryTable();
+  renderWefaxLatestCard();
+}
+function resetWefaxHistoryView() {
+  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 = "";
+  }
+}
+if (wefaxDom.filterInput) {
+  const filterInput = wefaxDom.filterInput;
+  wefaxDom.filterInput.addEventListener("input", function() {
+    wefaxFilterText = filterInput.value.trim().toUpperCase();
+    scheduleWefaxUi("wefax-history", renderWefaxHistoryTable);
+  });
+}
+if (wefaxDom.sortSelect) {
+  wefaxDom.sortSelect.addEventListener("change", function() {
+    scheduleWefaxUi("wefax-history", renderWefaxHistoryTable);
+  });
+}
+wefaxWindow.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" : "";
+};
+if (wefaxDom.toggleBtn) {
+  const toggleButton = wefaxDom.toggleBtn;
+  wefaxDom.toggleBtn.addEventListener("click", () => {
+    void (async () => {
+      try {
+        if (wefaxWindow.takeSchedulerControlForDecoderDisable) {
+          await wefaxWindow.takeSchedulerControlForDecoderDisable(toggleButton);
+        }
+        await hostCore.postPath("/toggle_wefax_decode");
+      } catch (e) {
+        console.error("WEFAX toggle failed", e);
+      }
+    })();
+  });
+}
+if (wefaxDom.clearBtn) {
+  wefaxDom.clearBtn.addEventListener("click", () => {
+    void (async () => {
+      try {
+        await hostCore.postPath("/clear_wefax_decode");
+        resetWefaxHistoryView();
+      } catch (e) {
+        console.error("WEFAX clear failed", e);
+      }
+    })();
+  });
+}
+renderWefaxLatestCard();
+wefaxWindow.trxPluginRuntime.registerDecoder({
+  id: "wefax",
+  onMessage: onServerWefax,
+  restore: restoreWefaxHistory,
+  prune: pruneWefaxHistoryView,
+  reset: resetWefaxHistoryView
+});
+wefaxWindow.trxPluginRuntime.registerDecoder({
+  id: "wefax_progress",
+  onMessage: onServerWefaxProgress
+});

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

@@ -1,147 +1,131 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
+import {
+  hostCore
+} from "./chunk-KL66PICH.js";
 
-// --- 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 = [];
-
+// src/plugins/wspr.ts
+var wsprWindow = window;
+var wsprStatus = document.getElementById("wspr-status");
+var wsprPeriodEl = document.getElementById("wspr-period");
+var wsprMessagesEl = document.getElementById("wspr-messages");
+var wsprFilterInput = document.getElementById("wspr-filter");
+var WSPR_PERIOD_SECONDS = 120;
+var wsprFilterText = "";
+var wsprMessageHistory = [];
+function finiteNumber(value) {
+  const number = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(number) ? number : null;
+}
 function currentWsprHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
-    : 24 * 60 * 60 * 1000;
+  return typeof wsprWindow.getDecodeHistoryRetentionMs === "function" ? wsprWindow.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1e3;
 }
-
 function pruneWsprMessageHistory() {
   const cutoffMs = Date.now() - currentWsprHistoryRetentionMs();
-  wsprMessageHistory = wsprMessageHistory.filter((msg) => Number(msg?._tsMs ?? msg?.ts_ms) >= cutoffMs);
+  wsprMessageHistory = wsprMessageHistory.filter((msg) => Number(msg._tsMs ?? msg.ts_ms) >= cutoffMs);
 }
-
 function scheduleWsprHistoryRender() {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob("wspr-history", () => renderWsprHistory());
+  if (typeof wsprWindow.trxScheduleUiFrameJob === "function") {
+    wsprWindow.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 nowSec = Math.floor(Date.now() / 1e3);
+  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();
+  const snr = finiteNumber(msg.snr_db);
+  const delta = finiteNumber(msg.dt_s);
+  const baseHz = finiteNumber(wsprWindow.ft8BaseHz);
+  const offsetHz = finiteNumber(msg.freq_hz);
+  const rfHz = offsetHz !== null && baseHz !== null ? baseHz + offsetHz : null;
+  const freq = rfHz?.toFixed(0) ?? "--";
+  const message = msg.message ?? "";
   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>`;
+  row.innerHTML = `<span class="ft8-time">${fmtWsprTime(msg.ts_ms)}</span><span class="ft8-snr">${snr?.toFixed(1) ?? "--"}</span><span class="ft8-dt">${delta?.toFixed(2) ?? "--"}</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]));
+    const message = wsprMessageHistory[i];
+    if (message) fragment.appendChild(renderWsprRow(message));
   }
   wsprMessagesEl.replaceChildren(fragment);
 }
-
 function addWsprMessage(msg) {
-  msg._tsMs = Number.isFinite(msg?.ts_ms) ? Number(msg.ts_ms) : Date.now();
+  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 raw = msg.message ?? "";
   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);
+  const baseHz = finiteNumber(wsprWindow.ft8BaseHz);
+  const offsetHz = finiteNumber(msg.freq_hz);
+  const rfHz = offsetHz !== null && baseHz !== null ? baseHz + offsetHz : offsetHz;
   return {
     raw,
     grids,
     station,
     rfHz,
     history: {
-      receiver: window.getDecodeRigMeta ? window.getDecodeRigMeta() : null,
+      receiver: wsprWindow.getDecodeRigMeta ? wsprWindow.getDecodeRigMeta() : null,
       ts_ms: msg.ts_ms,
       snr_db: msg.snr_db,
       dt_s: msg.dt_s,
       freq_hz: msg.freq_hz,
-      message: raw,
-    },
+      message: raw
+    }
   };
 }
-
-window.onServerWsprBatch = function(messages) {
+function onServerWsprBatch(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return;
-  wsprStatus.textContent = "Receiving";
+  if (wsprStatus) 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, {
+    if (next.grids.length > 0 && wsprWindow.mapAddLocator) {
+      wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
         ...msg,
-        freq_hz: next.rfHz,
+        ...next.rfHz === null ? {} : { freq_hz: next.rfHz }
       });
     }
-    next.history._tsMs = Number.isFinite(next.history?.ts_ms) ? Number(next.history.ts_ms) : Date.now();
+    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() {
+}
+function pruneWsprHistoryView() {
   pruneWsprMessageHistory();
   renderWsprHistory();
-};
-
-function escapeWsprHtml(input) {
-  return input
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll("\"", "&quot;");
 }
-
+function escapeWsprHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
 function renderWsprMessage(message) {
   let out = "";
   let i = 0;
@@ -159,16 +143,15 @@ function renderWsprMessage(message) {
       }
       i = j;
     } else {
-      out += escapeWsprHtml(ch);
+      out += escapeWsprHtml(ch ?? "");
       i += 1;
     }
   }
   return out;
 }
-
 function extractAllGrids(message) {
   const out = [];
-  const seen = new Set();
+  const seen = /* @__PURE__ */ new Set();
   const parts = message.toUpperCase().split(/[^A-Z0-9]+/);
   for (const token of parts) {
     if (!token) continue;
@@ -179,9 +162,8 @@ function extractAllGrids(message) {
   }
   return out;
 }
-
 function extractLikelyCallsign(message) {
-  const parts = String(message || "").toUpperCase().split(/[^A-Z0-9/]+/);
+  const parts = message.toUpperCase().split(/[^A-Z0-9/]+/);
   for (const token of parts) {
     if (!token) continue;
     if (token.length < 3 || token.length > 12) continue;
@@ -191,32 +173,28 @@ function extractLikelyCallsign(message) {
   }
   return null;
 }
-
 function isFtxFarewellToken(token) {
-  const normalized = String(token || "").trim().toUpperCase();
+  const normalized = token.trim().toUpperCase();
   return normalized === "RR73" || normalized === "73" || normalized === "RR";
 }
-
 function isMaidenheadGridToken(token) {
-  const normalized = String(token || "").trim().toUpperCase();
+  const normalized = 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);
+  return ch !== void 0 && /[A-Za-z0-9]/.test(ch);
 }
-
-function activateWsprHistoryLocator(targetEl) {
-  const locatorEl = targetEl?.closest?.(".ft8-locator[data-locator-grid]");
+function activateWsprHistoryLocator(target) {
+  if (!(target instanceof Element)) return false;
+  const locatorEl = target.closest(".ft8-locator[data-locator-grid]");
   if (!locatorEl) return false;
-  const grid = String(locatorEl.dataset.locatorGrid || "").toUpperCase();
+  const grid = (locatorEl.dataset.locatorGrid || "").toUpperCase();
   if (!grid) return false;
-  if (typeof window.navigateToMapLocator === "function") {
-    window.navigateToMapLocator(grid, "wspr");
+  if (typeof wsprWindow.navigateToMapLocator === "function") {
+    wsprWindow.navigateToMapLocator(grid, "wspr");
   }
   return true;
 }
-
 function applyWsprFilterToRow(row) {
   if (!wsprFilterText) {
     row.style.display = "";
@@ -225,26 +203,18 @@ function applyWsprFilterToRow(row) {
   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 = "";
+function resetWsprHistoryView() {
+  if (wsprMessagesEl) wsprMessagesEl.innerHTML = "";
   wsprMessageHistory = [];
   renderWsprHistory();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("wspr");
-};
-
+  if (wsprWindow.clearMapMarkersByType) wsprWindow.clearMapMarkersByType("wspr");
+}
 if (wsprFilterInput) {
   wsprFilterInput.addEventListener("input", () => {
     wsprFilterText = wsprFilterInput.value.trim().toUpperCase();
     renderWsprHistory();
   });
 }
-
 if (wsprMessagesEl) {
   wsprMessagesEl.addEventListener("click", (event) => {
     if (!activateWsprHistoryLocator(event.target)) return;
@@ -258,35 +228,44 @@ if (wsprMessagesEl) {
     event.stopPropagation();
   });
 }
-
-const wsprDecodeToggleBtn = document.getElementById("wspr-decode-toggle-btn");
-wsprDecodeToggleBtn?.addEventListener("click", async () => {
+var wsprDecodeToggleBtn = document.getElementById("wspr-decode-toggle-btn");
+wsprDecodeToggleBtn?.addEventListener("click", () => {
+  void (async () => {
     try {
-    await window.takeSchedulerControlForDecoderDisable?.(wsprDecodeToggleBtn);
-    await postPath("/toggle_wspr_decode");
-  } catch (e) {
-    console.error("WSPR toggle failed", e);
+      await wsprWindow.takeSchedulerControlForDecoderDisable?.(wsprDecodeToggleBtn);
+      await hostCore.postPath("/toggle_wspr_decode");
+    } catch (error) {
+      console.error("WSPR toggle failed", error);
     }
+  })();
 });
-
-document.getElementById("settings-clear-wspr-history")?.addEventListener("click", async () => {
-  if (!confirm("Clear all WSPR decode history? This cannot be undone.")) return;
+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 postPath("/clear_wspr_decode");
-    window.resetWsprHistoryView();
-  } catch (e) {
-    console.error("WSPR history clear failed", e);
+      await hostCore.postPath("/clear_wspr_decode");
+      resetWsprHistoryView();
+    } catch (error) {
+      console.error("WSPR history clear failed", error);
     }
+  })();
 });
-
-window.onServerWspr = function(msg) {
-  wsprStatus.textContent = "Receiving";
+function onServerWspr(msg) {
+  if (wsprStatus) wsprStatus.textContent = "Receiving";
   const next = normalizeServerWsprMessage(msg);
-  if (next.grids.length > 0 && window.mapAddLocator) {
-    window.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
+  if (next.grids.length > 0 && wsprWindow.mapAddLocator) {
+    wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
       ...msg,
-      freq_hz: next.rfHz,
+      ...next.rfHz === null ? {} : { freq_hz: next.rfHz }
     });
   }
   addWsprMessage(next.history);
-};
+}
+wsprWindow.trxPluginRuntime.registerDecoder({
+  id: "wspr",
+  onMessage: onServerWspr,
+  onBatch: onServerWsprBatch,
+  restore: onServerWsprBatch,
+  prune: pruneWsprHistoryView,
+  reset: resetWsprHistoryView
+});

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

@@ -43,7 +43,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
             <div class="subtitle" id="location-subtitle" style="display:none;"></div>
           </div>
         </div>
-        <div class="tab-bar-nav">
+        <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>
@@ -85,6 +85,7 @@ 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">
@@ -140,13 +141,14 @@ SPDX-License-Identifier: GPL-2.0-or-later
         <div class="spectrum-wrap">
           <div id="spectrum-bookmark-axis"></div>
           <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"></canvas>
+          <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-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>
           <div id="spectrum-bookmark-side-right" class="spectrum-bookmark-side spectrum-bookmark-side-right" aria-hidden="true"></div>
           <div id="spectrum-tooltip"></div>
-          <canvas id="spectrum-waterfall-canvas" tabindex="0" role="img" aria-label="Waterfall display" style="display:none;"></canvas>
+          <canvas id="spectrum-waterfall-canvas" tabindex="0" role="img" aria-label="Waterfall display" aria-describedby="spectrum-text-summary" style="display:none;"></canvas>
           <div id="spectrum-freq-axis">
             <button id="spectrum-center-left-btn" class="spectrum-edge-shift spectrum-edge-shift-left" type="button" aria-label="Shift spectrum center left">&lsaquo;</button>
             <button id="spectrum-center-right-btn" class="spectrum-edge-shift spectrum-edge-shift-right" type="button" aria-label="Shift spectrum center right">&rsaquo;</button>
@@ -204,12 +206,12 @@ 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="--" />
-            <div class="label"><span>Frequency</span></div>
+            <input class="status-input" id="freq" type="text" value="--" aria-describedby="freq-label" aria-label="Tuned frequency" />
+            <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="--" />
-            <div class="label"><span>Center Frequency</span></div>
+            <input class="status-input" id="center-freq" type="text" value="--" aria-describedby="center-freq-label" aria-label="SDR center frequency" />
+            <div class="label" id="center-freq-label"><span>Center Frequency</span></div>
           </div>
           <div class="freq-field unit-col">
             <div class="jog-step" id="jog-step">
@@ -235,7 +237,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
               <div class="controls-col label-below-col">
                 <div class="label"><span>Mode</span></div>
                 <div class="inline">
-                  <select class="status-input" id="mode"></select>
+                  <select class="status-input" id="mode" aria-label="Demodulation mode"></select>
                 </div>
               </div>
               <div class="controls-col controls-col-center">
@@ -307,9 +309,9 @@ SPDX-License-Identifier: GPL-2.0-or-later
               <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">Toggle PTT</button>
-                  <button id="power-btn" type="button">Toggle Power</button>
-                  <button id="lock-btn" type="button">Lock</button>
+                  <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>
@@ -356,9 +358,14 @@ SPDX-License-Identifier: GPL-2.0-or-later
               </div>
             </div>
             <div class="full-row label-below-row" id="vchan-row">
-              <div class="label"><span>Channels / Scheduler</span></div>
+              <div class="label"><span>Channels</span></div>
               <div class="channel-scheduler-controls">
                 <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>
@@ -381,7 +388,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
                   </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;">
@@ -412,8 +419,10 @@ SPDX-License-Identifier: GPL-2.0-or-later
                 <button id="tx-limit-btn" type="button">Set</button>
               </div>
             </div>
-            <div class="full-row label-below-row" id="audio-row">
-              <div class="label"><span>Audio</span></div>
+            <details id="audio-controls" class="advanced-radio-controls audio-controls-section">
+              <summary>Audio controls</summary>
+              <div class="advanced-radio-body">
+                <div class="full-row" id="audio-row">
                   <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>
@@ -427,6 +436,8 @@ SPDX-License-Identifier: GPL-2.0-or-later
                   </div>
                 </div>
               </div>
+            </details>
+          </div>
         </div>
       </div>
     </div>
@@ -495,6 +506,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
             </label>
           </div>
           <div class="bm-form-actions">
+            <div id="bm-form-error" class="form-error" role="alert" aria-live="polite"></div>
             <button type="submit" class="bm-save-btn">Save</button>
             <button type="button" id="bm-form-cancel">Cancel</button>
           </div>
@@ -530,7 +542,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
       </div>
     </div>
     <div id="tab-digital-modes" class="tab-panel" style="display:none;">
-      <div class="sub-tab-bar">
+      <div class="sub-tab-bar" aria-label="Decoder views">
         <button class="sub-tab active" data-subtab="overview">Overview</button>
         <button class="sub-tab" data-subtab="ais">AIS</button>
         <button class="sub-tab" data-subtab="vdes">VDES</button>
@@ -1623,51 +1635,9 @@ SPDX-License-Identifier: GPL-2.0-or-later
       <div id="decode-history-overlay-sub" class="decode-history-overlay-sub">Preparing recent decodes for the UI</div>
     </div>
   </div>
-  <script defer src="https://cdn.jsdelivr.net/npm/opus-decoder@0.7.11/dist/opus-decoder.min.js" charset="UTF-8"></script>
+  <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 defer src="/webgl-renderer.js"></script>
-  <script defer src="/app.js"></script>
-  <script>
-// Lazy plugin loader: loads plugin scripts when their tab/feature is first activated
-(function() {
-  var pluginScripts = {
-    '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']
-  };
-  var loaded = new Set();
-  function loadPlugins(tab) {
-    var scripts = pluginScripts[tab];
-    if (!scripts) return;
-    scripts.forEach(function(src) {
-      if (loaded.has(src)) return;
-      loaded.add(src);
-      var s = document.createElement('script');
-      s.src = src;
-      s.defer = true;
-      document.body.appendChild(s);
-    });
-  }
-  // Eager plugin loading is triggered by app.js (after window.trx is set up)
-  // via window.loadEagerPlugins().  Dynamic scripts are effectively async, so
-  // loading them before app.js would cause map-core.js to crash when
-  // window.trx is not yet defined.
-  window.loadEagerPlugins = function() {
-    ['digital-modes', 'map-data', 'bookmarks', 'settings'].forEach(loadPlugins);
-  };
-  // Load others on tab switch
-  document.addEventListener('click', function(e) {
-    var tab = e.target.closest('[data-tab]');
-    if (tab) loadPlugins(tab.dataset.tab);
-  });
-  window.loadPluginsForTab = loadPlugins;
-})();
-  </script>
-  <!-- Template cloning is handled by navigateToTab() in app.js -->
+  <script type="module" src="/app.js"></script>
+  <!-- Template cloning is handled by the typed application bundle. -->
 </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/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 (!confirm("Clear all FT2 decode history? This cannot be undone.")) 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 (!confirm("Clear all FT4 decode history? This cannot be undone.")) 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 (!confirm("Clear all FT8 decode history? This cannot be undone.")) 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/style.css

@@ -1231,7 +1231,7 @@ small { color: var(--text-muted); }
 }
 .top-bar-actions {
   display: flex;
-  align-items: center;
+  align-items: flex-start;
   gap: 0.45rem 0.6rem;
   min-width: 0;
   flex-wrap: wrap;
@@ -1404,10 +1404,21 @@ small { color: var(--text-muted); }
   padding: 0.9rem 0.2rem 0;
 }
 .header-rig-switch {
-  display: flex;
-  align-items: center;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  align-items: start;
   gap: 0.35rem;
 }
+.header-rig-summary {
+  display: block;
+  max-width: 20rem;
+  color: var(--text-muted);
+  font-size: var(--fs-xs);
+  line-height: 1.35;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
 .header-rig-switch select {
   min-width: 8rem;
   height: 2rem;
@@ -1417,6 +1428,7 @@ small { color: var(--text-muted); }
   background: var(--input-bg);
   color: var(--text);
   font-size: 0.85rem;
+  align-self: start;
 }
 .header-rig-switch button {
   height: 2rem;
@@ -2509,6 +2521,7 @@ body.map-fake-fullscreen-active {
   word-break: break-all;
 }
 .aprs-symbol { display: inline-block; width: 24px; height: 24px; background-size: 384px 192px; vertical-align: middle; margin-right: 0.3rem; }
+.aprs-symbol-local { border: 1px solid var(--border); border-radius: 4px; background: var(--surface-raised); color: var(--text); font: 700 0.8rem/22px ui-monospace, monospace; text-align: center; }
 .aprs-pos { color: var(--accent-green); text-decoration: none; margin-left: 0.3rem; font-size: 0.8rem; }
 .aprs-pos:hover { text-decoration: underline; }
 .leaflet-popup-content-wrapper, .leaflet-popup-tip { background: color-mix(in srgb, var(--card-bg) 84%, transparent) !important; color: var(--text) !important; box-shadow: 0 3px 14px rgba(0,0,0,0.45) !important; }
@@ -2839,6 +2852,256 @@ canvas:focus-visible, [tabindex]:focus-visible {
   outline-offset: 2px;
 }
 
+/* ── Shared interaction primitives ───────────────────────────────────── */
+.visually-hidden {
+  position: absolute !important;
+  width: 1px; height: 1px; padding: 0; margin: -1px;
+  overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0;
+}
+.toast-region {
+  position: fixed;
+  z-index: 120;
+  right: var(--space-4);
+  bottom: var(--space-4);
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+  width: min(28rem, calc(100vw - 2rem));
+  pointer-events: none;
+}
+.toast {
+  --toast-accent: var(--accent-yellow);
+  position: relative;
+  display: grid;
+  grid-template-columns: 1.25rem minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--space-3);
+  min-height: 3rem;
+  padding: 0.7rem 0.75rem;
+  border: 1px solid color-mix(in srgb, var(--toast-accent) 35%, var(--border-light));
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--card-bg) 96%, var(--toast-accent) 4%);
+  color: var(--text);
+  box-shadow: 0 14px 38px color-mix(in srgb, #000 38%, transparent), inset 3px 0 0 var(--toast-accent);
+  opacity: 0;
+  transform: translateY(0.65rem) scale(0.98);
+  transition: opacity var(--dur-base) var(--ease-out), transform var(--dur-base) var(--ease-out);
+  pointer-events: auto;
+}
+.toast::before {
+  display: grid;
+  place-items: center;
+  width: 1.25rem;
+  height: 1.25rem;
+  border-radius: var(--radius-pill);
+  background: color-mix(in srgb, var(--toast-accent) 18%, transparent);
+  color: var(--toast-accent);
+  content: "i";
+  font-size: var(--fs-xs);
+  font-weight: 800;
+}
+.toast > span { min-width: 0; line-height: 1.35; }
+.toast-visible { opacity: 1; transform: translateY(0); }
+.toast-success { --toast-accent: var(--accent-green); }
+.toast-success::before { content: "✓"; }
+.toast-error { --toast-accent: var(--accent-red); }
+.toast-error::before { content: "!"; }
+.toast button {
+  width: auto;
+  min-height: 2rem;
+  height: 2rem;
+  padding: 0 var(--space-3);
+  border-color: color-mix(in srgb, var(--toast-accent) 55%, var(--btn-border));
+  color: var(--toast-accent);
+  font-size: var(--fs-sm);
+  font-weight: 700;
+}
+.ui-dialog {
+  max-width: none;
+  border: 0;
+  padding: 0;
+  border-radius: var(--radius-lg);
+  color: var(--text);
+  background: transparent;
+  box-shadow: 0 24px 70px color-mix(in srgb, #000 55%, transparent);
+}
+.ui-dialog::backdrop { background: rgba(3, 8, 18, 0.72); backdrop-filter: blur(5px); }
+.ui-dialog-card {
+  width: min(29rem, calc(100vw - 2rem));
+  margin: 0;
+  padding: var(--space-6);
+  border: 1px solid var(--border-light);
+  border-radius: var(--radius-lg);
+  background: linear-gradient(145deg, color-mix(in srgb, var(--card-bg) 94%, var(--text) 6%), var(--card-bg));
+  box-sizing: border-box;
+}
+.ui-dialog-card h2 { margin: 0 0 var(--space-2); color: var(--text-heading); font-size: var(--fs-md); line-height: 1.3; }
+.ui-dialog-card p { margin: 0; color: var(--text-muted); line-height: 1.55; }
+.ui-dialog-actions { display: flex; justify-content: flex-end; gap: var(--space-2); margin-top: var(--space-6); }
+.ui-dialog-actions button { min-width: 6rem; }
+.ui-dialog-actions .danger { background: var(--accent-red); border-color: var(--accent-red); color: #fff; font-weight: 700; }
+.ui-dialog-actions .danger:hover:not(:disabled) { background: color-mix(in srgb, var(--accent-red) 82%, #fff); border-color: color-mix(in srgb, var(--accent-red) 82%, #fff); }
+.form-error { flex: 1 1 100%; min-height: 1.2em; color: var(--accent-red); font-size: var(--fs-sm); font-weight: 600; }
+button.is-active {
+  border-color: var(--accent-green);
+  background: color-mix(in srgb, var(--btn-bg) 82%, var(--accent-green) 18%);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--accent-green) 32%, transparent), 0 0 0 1px color-mix(in srgb, var(--accent-green) 12%, transparent);
+}
+#ptt-btn.is-active { background: var(--accent-red) !important; border-color: var(--accent-red) !important; color: white !important; }
+.is-busy { cursor: progress !important; opacity: 0.68; }
+.operator-layout-picker {
+  display: inline-flex;
+  align-items: center;
+  min-height: 2rem;
+  padding-left: 0.6rem;
+  border: 1px solid var(--border-light);
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--input-bg) 88%, transparent);
+  color: var(--text-muted);
+  font-size: var(--fs-xs);
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  overflow: visible;
+}
+.operator-layout-picker::before { content: "Layout"; }
+.operator-layout-picker select {
+  width: auto;
+  min-height: 2rem;
+  max-width: 9rem;
+  padding: 0 1.75rem 0 0.45rem;
+  border: 0;
+  background-color: transparent;
+  color: var(--text);
+  font-size: var(--fs-sm);
+  font-weight: 600;
+  text-transform: none;
+  cursor: pointer;
+}
+.operator-layout-picker:focus-within { border-color: var(--accent-green); box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent-green) 20%, transparent); }
+.operator-layout-picker select:focus-visible { outline: 0; }
+.advanced-radio-controls {
+  margin-top: var(--space-3);
+  border: 1px solid color-mix(in srgb, var(--border-light) 75%, transparent);
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--input-bg) 68%, transparent);
+  overflow: clip;
+  transition: border-color var(--dur-fast) var(--ease-standard), background-color var(--dur-fast) var(--ease-standard);
+}
+.advanced-radio-controls:hover { border-color: var(--border-light); }
+.advanced-radio-controls[open] { background: color-mix(in srgb, var(--surface) 86%, transparent); }
+.advanced-radio-controls summary {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  padding: 0.65rem 0.75rem;
+  color: var(--text-heading);
+  font-size: var(--fs-sm);
+  font-weight: 700;
+  cursor: pointer;
+  list-style: none;
+  user-select: none;
+}
+.advanced-radio-controls summary::-webkit-details-marker { display: none; }
+.advanced-radio-controls summary::before {
+  content: "›";
+  color: var(--accent-text);
+  font-size: 1.2rem;
+  line-height: 1;
+  transform: rotate(0deg);
+  transition: transform var(--dur-base) var(--ease-standard);
+}
+.advanced-radio-controls[open] summary::before { transform: rotate(90deg); }
+.advanced-radio-controls[open] summary { border-bottom: 1px solid color-mix(in srgb, var(--border) 70%, transparent); }
+.advanced-radio-body { display: grid; gap: var(--space-3); padding: var(--space-3); }
+.advanced-radio-body > * { margin: 0; }
+body[data-operator-layout="digital"] .controls-col-wfm { display: none !important; }
+body[data-operator-layout="broadcast"] #tx-power-col,
+body[data-operator-layout="broadcast"] #tx-meters,
+body[data-operator-layout="broadcast"] #tx-limit-row,
+body[data-operator-layout="broadcast"] #vfo-row,
+body[data-operator-layout="broadcast"] #sam-controls-col,
+body[data-operator-layout="broadcast"] #advanced-radio-controls {
+  display: none !important;
+}
+body[data-operator-layout="broadcast"] .controls-row {
+  grid-template-columns: minmax(8rem, 0.65fr) auto minmax(20rem, 2fr);
+}
+body[data-operator-layout="broadcast"] #wfm-controls-col,
+body[data-operator-layout="broadcast"] #audio-row,
+body[data-operator-layout="broadcast"] #spectrum-bw-row {
+  border-color: color-mix(in srgb, var(--accent-green) 42%, var(--border-light));
+  background: color-mix(in srgb, var(--accent-green) 7%, transparent);
+}
+body[data-operator-layout="broadcast"] #wfm-controls-col {
+  padding: var(--space-2) var(--space-3);
+  border: 1px solid color-mix(in srgb, var(--accent-green) 42%, var(--border-light));
+  border-radius: var(--radius-md);
+}
+body[data-operator-layout="broadcast"] #audio-row {
+  padding: var(--space-3);
+  border: 1px solid color-mix(in srgb, var(--accent-green) 42%, var(--border-light));
+  border-radius: var(--radius-md);
+}
+body[data-operator-layout="broadcast"] #spectrum-bw-row {
+  padding: var(--space-2);
+  border: 1px solid color-mix(in srgb, var(--accent-green) 42%, var(--border-light));
+  border-radius: var(--radius-sm);
+}
+body[data-operator-layout="broadcast"] #ais-bar-overlay,
+body[data-operator-layout="broadcast"] #vdes-bar-overlay,
+body[data-operator-layout="broadcast"] #ft8-bar-overlay,
+body[data-operator-layout="broadcast"] #aprs-bar-overlay,
+body[data-operator-layout="broadcast"] #hf-aprs-bar-overlay,
+body[data-operator-layout="broadcast"] #cw-bar-overlay {
+  display: none !important;
+}
+@media (max-width: 760px) {
+  body[data-operator-layout="broadcast"] .controls-row { grid-template-columns: 1fr auto; }
+  body[data-operator-layout="broadcast"] #wfm-controls-col { grid-column: 1 / -1; }
+}
+.mobile-more-btn, .mobile-more-menu, .decoder-tab-select { display: none; }
+.mobile-more-menu {
+  position: fixed;
+  right: max(0.75rem, env(safe-area-inset-right));
+  bottom: calc(5.4rem + env(safe-area-inset-bottom));
+  z-index: 80;
+  min-width: 12rem;
+  padding: var(--space-2);
+  border: 1px solid var(--border-light);
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--card-bg) 97%, transparent);
+  box-shadow: 0 18px 45px color-mix(in srgb, #000 42%, transparent);
+}
+.mobile-more-menu.is-open { display: grid; gap: 0.2rem; animation: trx-menu-in var(--dur-base) var(--ease-out); }
+.mobile-more-menu button {
+  justify-content: flex-start;
+  width: 100%;
+  height: 2.65rem;
+  padding: 0 var(--space-3);
+  border-color: transparent;
+  background: transparent;
+  text-align: left;
+}
+.mobile-more-menu button:hover { background: var(--btn-hover-bg); border-color: transparent; }
+.decoder-state-dot {
+  display: inline-block;
+  width: 0.45rem;
+  height: 0.45rem;
+  margin-left: 0.4rem;
+  border: 1px solid color-mix(in srgb, var(--text-muted) 70%, transparent);
+  border-radius: 50%;
+  background: color-mix(in srgb, var(--text-muted) 60%, transparent);
+  vertical-align: middle;
+}
+.decoder-state-dot[data-state="active"] { background: var(--accent-green); box-shadow: 0 0 0.35rem color-mix(in srgb, var(--accent-green) 65%, transparent); }
+.decoder-state-dot[data-state="error"] { background: var(--accent-red); }
+@keyframes trx-menu-in { from { opacity: 0; transform: translateY(0.4rem) scale(0.98); } to { opacity: 1; transform: none; } }
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after { scroll-behavior: auto !important; animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; transition-duration: 0.01ms !important; }
+}
+
 /* ── Scrollbars ───────────────────────────────────────────────────────── */
 ::-webkit-scrollbar { width: 6px; height: 6px; }
 ::-webkit-scrollbar-track { background: transparent; }
@@ -2953,7 +3216,7 @@ canvas:focus-visible, [tabindex]:focus-visible {
     bottom: calc(0.55rem + env(safe-area-inset-bottom));
     z-index: 30;
     display: grid;
-    grid-template-columns: repeat(6, minmax(0, 1fr));
+    grid-template-columns: repeat(5, minmax(0, 1fr));
     gap: 0.25rem;
     padding: 0.38rem;
     border: 1px solid color-mix(in srgb, var(--border-light) 82%, transparent);
@@ -2993,12 +3256,38 @@ canvas:focus-visible, [tabindex]:focus-visible {
   .tab[data-tab="bookmarks"] .tab-label { font-size: 0.6rem; }
   .tab[data-tab="digital-modes"] .tab-label  { font-size: 0.6rem; }
   .tab[data-tab="statistics"] .tab-label { font-size: 0.6rem; }
+  .tab[data-tab="statistics"], .tab[data-tab="recorder"],
+  .tab[data-tab="settings"], .tab[data-tab="about"] { display: none; }
+  .mobile-more-btn { display: flex; }
+  .mobile-more-btn[aria-expanded="true"] {
+    color: var(--accent-text);
+    background: color-mix(in srgb, var(--accent-green) 10%, transparent);
+  }
+  .tab .tab-label, .tab[data-tab] .tab-label { font-size: 0.75rem; }
+  .decoder-tab-select {
+    display: block;
+    width: 100%;
+    min-height: 2.8rem;
+    margin-bottom: var(--space-3);
+    padding: 0 var(--space-3);
+    border: 1px solid var(--border-light);
+    border-radius: var(--radius-md);
+    background: color-mix(in srgb, var(--input-bg) 90%, var(--card-bg));
+    color: var(--text);
+    font-size: 1rem;
+    font-weight: 600;
+    box-shadow: inset 0 1px 0 color-mix(in srgb, #fff 5%, transparent);
+  }
+  #tab-digital-modes > .sub-tab-bar { display: none; }
+  .toast-region { bottom: calc(5.7rem + env(safe-area-inset-bottom)); }
   .top-bar-actions {
     width: 100%;
     justify-content: flex-start;
     flex-wrap: wrap;
     gap: 0.45rem;
   }
+  .operator-layout-picker { max-width: 100%; }
+  .operator-layout-picker select { max-width: 10rem; }
   .header-rig-switch,
   .header-style-pick {
     flex: 1 1 12rem;
@@ -3910,6 +4199,27 @@ canvas:focus-visible, [tabindex]:focus-visible {
   }
 }
 
+@media (max-width: 480px) {
+  .toast-region {
+    right: max(0.65rem, env(safe-area-inset-right));
+    width: calc(100vw - max(1.3rem, env(safe-area-inset-left) + env(safe-area-inset-right)));
+  }
+  .toast { grid-template-columns: 1.25rem minmax(0, 1fr); }
+  .toast button { grid-column: 2; justify-self: start; }
+  .ui-dialog-card { padding: var(--space-5); }
+  .ui-dialog-actions { flex-direction: column-reverse; }
+  .ui-dialog-actions button { width: 100%; }
+}
+
+/* Preserve legibility after the component-specific compact-mobile rules. */
+@media (max-width: 640px) {
+  button, input, select, textarea, .tab-label, .sub-tab,
+  .label, .hint, .subtitle, .wfm-control-label, .wfm-intf-val,
+  .ft8-header, .ft8-message, .aprs-packet, .ais-message, .vdes-message {
+    font-size: max(0.75rem, 12px);
+  }
+}
+
 /* Theme styles have been moved to themes.css */
 
 
@@ -5061,3 +5371,11 @@ canvas:focus-visible, [tabindex]:focus-visible {
   from { opacity: 0; }
   to   { opacity: 1; }
 }
+
+@media (max-width: 640px) {
+  button, input, select, textarea, .tab-label, .sub-tab,
+  .label, .hint, .subtitle, .wfm-control-label, .wfm-intf-val,
+  .ft8-header, .ft8-message, .aprs-packet, .ais-message, .vdes-message {
+    font-size: max(0.75rem, 12px);
+  }
+}

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

@@ -0,0 +1,144 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import vm from "node:vm";
+
+class ClassList {
+  constructor() { this.values = new Set(); }
+  add(...names) { names.forEach(name => this.values.add(name)); }
+  remove(...names) { names.forEach(name => this.values.delete(name)); }
+  contains(name) { return this.values.has(name); }
+  toggle(name, force) {
+    const enabled = force === undefined ? !this.contains(name) : force;
+    if (enabled) this.add(name); else this.remove(name);
+    return enabled;
+  }
+}
+
+class Element {
+  constructor(tagName, document) {
+    this.tagName = tagName.toUpperCase();
+    this.ownerDocument = document;
+    this.children = [];
+    this.dataset = {};
+    this.attributes = new Map();
+    this.classList = new ClassList();
+    this.listeners = new Map();
+    this.style = {};
+    this.options = [];
+    this.value = "";
+    this.textContent = "";
+  }
+  set id(value) { this._id = value; if (value) this.ownerDocument.elements.set(value, this); }
+  get id() { return this._id || ""; }
+  set className(value) { this.classList = new ClassList(); value.split(/\s+/).filter(Boolean).forEach(name => this.classList.add(name)); }
+  set innerHTML(value) {
+    this._innerHTML = value;
+    if (value.includes('value="confirm"')) {
+      const title = new Element("h2", this.ownerDocument); title.id = "ui-confirm-title";
+      const message = new Element("p", this.ownerDocument); message.id = "ui-confirm-message";
+      const confirm = new Element("button", this.ownerDocument); confirm.value = "confirm";
+      this.append(title, message, confirm);
+      this._confirmButton = confirm;
+    }
+  }
+  get innerHTML() { return this._innerHTML || ""; }
+  appendChild(child) { this.children.push(child); child.parentElement = this; return child; }
+  append(...children) { children.forEach(child => this.appendChild(child)); }
+  insertBefore(child) { return this.appendChild(child); }
+  remove() { if (this.parentElement) this.parentElement.children = this.parentElement.children.filter(child => child !== this); }
+  replaceChildren(...children) { this.children = []; this.options = []; this.append(...children); }
+  setAttribute(name, value) { this.attributes.set(name, String(value)); }
+  getAttribute(name) { return this.attributes.get(name); }
+  addEventListener(type, listener) { this.listeners.set(type, listener); }
+  dispatch(type, event = {}) { this.listeners.get(type)?.({ target: this, preventDefault() {}, ...event }); }
+  querySelector(selector) {
+    if (selector === '[value="confirm"]') return this._confirmButton || null;
+    return null;
+  }
+  querySelectorAll(selector) {
+    if (selector === ".tab[data-tab]") return this.children.filter(child => child.dataset.tab);
+    if (selector === ".sub-tab[data-subtab]") return this.children.filter(child => child.dataset.subtab);
+    if (selector === '[role="tab"]') return this.children.filter(child => child.getAttribute("role") === "tab");
+    return [];
+  }
+  add(option) { this.options.push(option); if (!this.value) this.value = option.value; }
+  showModal() { this.open = true; }
+  close(value) { this.returnValue = value; this.open = false; this.dispatch("close"); }
+  focus() { this.focused = true; }
+  click() { this.clicked = true; }
+}
+
+class DocumentFixture {
+  constructor() {
+    this.readyState = "loading";
+    this.elements = new Map();
+    this.body = new Element("body", this);
+  }
+  createElement(tagName) { return new Element(tagName, this); }
+  getElementById(id) { return this.elements.get(id) || null; }
+  querySelector() { return null; }
+  querySelectorAll() { return []; }
+  addEventListener() {}
+}
+
+const document = new DocumentFixture();
+const storage = new Map();
+const localStorage = {
+  getItem(key) { return storage.has(key) ? storage.get(key) : null; },
+  setItem(key, value) { storage.set(key, String(value)); },
+};
+const window = { document, localStorage, addEventListener() {} };
+const context = vm.createContext({
+  window, document, localStorage,
+  Option: class Option { constructor(label, value) { this.label = label; this.value = value; } },
+  MutationObserver: class MutationObserver { observe() {} },
+  requestAnimationFrame(callback) { callback(); },
+  setTimeout() { return 1; },
+  clearTimeout() {},
+  console,
+});
+
+const source = await readFile(new URL("../ui-core.js", import.meta.url), "utf8");
+new vm.Script(source, { filename: "ui-core.js" }).runInContext(context);
+const ui = window.trxUi;
+
+const toast = ui.notify("Saved", { kind: "success" });
+assert.equal(toast.getAttribute("role"), "status");
+assert.equal(toast.classList.contains("toast-success"), true);
+assert.equal(document.getElementById("toast-region").children.length, 1);
+
+const confirmation = ui.confirm({ title: "Delete?", message: "Permanent", confirmLabel: "Delete" });
+const dialog = document.getElementById("ui-confirm-dialog");
+assert.equal(dialog.open, true);
+assert.equal(document.getElementById("ui-confirm-title").textContent, "Delete?");
+dialog.close("confirm");
+assert.equal(await confirmation, true);
+
+const tabBar = new Element("div", document);
+const firstTab = new Element("button", document); firstTab.dataset.tab = "main"; firstTab.classList.add("active");
+const secondTab = new Element("button", document); secondTab.dataset.tab = "map";
+tabBar.append(firstTab, secondTab);
+const mainPanel = new Element("section", document); mainPanel.id = "tab-main";
+const mapPanel = new Element("section", document); mapPanel.id = "tab-map";
+ui.prepareTabList(tabBar, "primary");
+assert.equal(firstTab.getAttribute("aria-selected"), "true");
+tabBar.dispatch("keydown", { target: firstTab, key: "ArrowRight" });
+assert.equal(secondTab.focused, true);
+assert.equal(secondTab.clicked, true);
+
+localStorage.setItem("trxOperatorLayout:rig-a", "broadcast");
+ui.setActiveRig("rig-a");
+assert.equal(document.body.dataset.operatorLayout, "compact");
+ui.setLayoutCapabilities({ broadcast: true });
+ui.setActiveRig("rig-a");
+assert.equal(document.body.dataset.operatorLayout, "broadcast");
+ui.setActiveRig("rig-b");
+ui.applyLayout("digital");
+assert.equal(document.body.dataset.operatorLayout, "compact");
+assert.equal(localStorage.getItem("trxOperatorLayout:rig-b"), "compact");
+
+console.log("ui-core component tests passed");

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

@@ -2,8 +2,53 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+use std::fmt::Write as _;
+use std::fs;
+use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
+fn generate_asset_manifest() {
+    let manifest_dir = PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").expect("manifest dir"));
+    let generated_dir = manifest_dir.join("assets/web/generated");
+    println!("cargo:rerun-if-changed={}", generated_dir.display());
+
+    let mut filenames = fs::read_dir(&generated_dir)
+        .expect("read generated frontend assets")
+        .map(|entry| entry.expect("read generated asset entry"))
+        .filter(|entry| entry.file_type().is_ok_and(|kind| kind.is_file()))
+        .map(|entry| {
+            entry
+                .file_name()
+                .into_string()
+                .expect("UTF-8 asset filename")
+        })
+        .collect::<Vec<_>>();
+    filenames.sort();
+
+    let mut output = String::from(
+        "// Generated by build.rs from committed frontend output.\n\
+         pub const GENERATED_ASSETS: &[(&str, &[u8])] = &[\n",
+    );
+    for filename in filenames {
+        assert!(
+            filename
+                .bytes()
+                .all(|byte| byte.is_ascii_alphanumeric() || b"._-".contains(&byte)),
+            "unsupported generated asset filename: {filename}"
+        );
+        writeln!(
+            output,
+            "    ({filename:?}, include_bytes!(concat!(env!(\"CARGO_MANIFEST_DIR\"), \"/assets/web/generated/\", {filename:?}))),"
+        )
+        .expect("write asset manifest");
+    }
+    output.push_str("];\n");
+
+    let output_path =
+        PathBuf::from(std::env::var_os("OUT_DIR").expect("out dir")).join("generated_assets.rs");
+    fs::write(output_path, output).expect("write generated asset manifest");
+}
+
 fn utc_ymd_from_unix_secs(secs: i64) -> (i32, u32, u32) {
     let days = secs.div_euclid(86_400);
     let z = days + 719_468;
@@ -20,6 +65,7 @@ fn utc_ymd_from_unix_secs(secs: i64) -> (i32, u32, u32) {
 }
 
 fn main() {
+    generate_asset_manifest();
     let secs = match SystemTime::now().duration_since(UNIX_EPOCH) {
         Ok(d) => d.as_secs() as i64,
         Err(_) => 0,

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

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+use std::fmt::Write as _;
+use std::fs;
+use std::path::PathBuf;
+
+use trx_core::radio::freq::{Band, Freq};
+use trx_core::rig::state::{SpectrumData, VchanRdsEntry};
+use trx_core::rig::{
+    RigAccessMethod, RigCapabilities, RigInfo, RigRxStatus, RigStatus, RigTxStatus, RigVfo,
+    RigVfoEntry,
+};
+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 = format!(
+        "// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>\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();
+
+    macro_rules! export {
+        ($type:ty) => {
+            writeln!(output, "export {}\n", <$type as TS>::decl(&config))?;
+        };
+    }
+
+    export!(Band);
+    export!(Freq);
+    export!(RigMode);
+    export!(RigAccessMethod);
+    export!(RigCapabilities);
+    export!(RigInfo);
+    export!(RigVfoEntry);
+    export!(RigVfo);
+    export!(RigTxStatus);
+    export!(RigRxStatus);
+    export!(RigStatus);
+    export!(DecoderConfig);
+    export!(WfmDenoiseLevel);
+    export!(RigFilterState);
+    export!(RdsData);
+    export!(SpectrumData);
+    export!(VchanRdsEntry);
+    export!(RigSnapshot);
+    export!(RigListItem);
+    export!(RigListResponse);
+    export!(FrontendMeta);
+    export!(DecoderActivation);
+    export!(DecoderDescriptor);
+
+    let output_path =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("frontend/src/api/generated.ts");
+    fs::create_dir_all(output_path.parent().expect("generated file has a parent"))?;
+    fs::write(output_path, output)?;
+    Ok(())
+}

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

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { build } from "esbuild";
+import { rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const frontendDir = path.dirname(fileURLToPath(import.meta.url));
+const sourceDir = path.join(frontendDir, "src");
+const outputDir = path.join(frontendDir, "..", "assets", "web", "generated");
+
+await rm(outputDir, { recursive: true, force: true });
+
+await build({
+  entryPoints: {
+    app: path.join(sourceDir, "bootstrap.ts"),
+    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"),
+    vdes: path.join(sourceDir, "plugins", "vdes.ts"),
+    wefax: path.join(sourceDir, "plugins", "wefax.ts"),
+    "background-decode": path.join(sourceDir, "plugins", "background-decode.ts"),
+    ais: path.join(sourceDir, "plugins", "ais.ts"),
+    aprs: path.join(sourceDir, "plugins", "aprs.ts"),
+    "hf-aprs": path.join(sourceDir, "plugins", "hf-aprs.ts"),
+    sat: path.join(sourceDir, "plugins", "sat.ts"),
+    "sat-scheduler": path.join(sourceDir, "plugins", "sat-scheduler.ts"),
+    vchan: path.join(sourceDir, "plugins", "vchan.ts"),
+    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,
+  format: "esm",
+  splitting: true,
+  entryNames: "[name]",
+  chunkNames: "chunk-[hash]",
+  platform: "browser",
+  target: "es2022",
+  sourcemap: false,
+  legalComments: "inline",
+  charset: "utf8",
+  logLevel: "info",
+});
+
+await build({
+  entryPoints: [path.join(sourceDir, "decode-history-worker.ts")],
+  outfile: path.join(outputDir, "decode-history-worker.js"),
+  bundle: true,
+  format: "iife",
+  platform: "browser",
+  target: "es2022",
+  sourcemap: false,
+  legalComments: "inline",
+  charset: "utf8",
+  logLevel: "info",
+});

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

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import eslint from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  {
+    ignores: [
+      "../assets/web/generated/**",
+    ],
+  },
+  {
+    files: ["**/*.mjs"],
+    ...eslint.configs.recommended,
+    languageOptions: {
+      globals: globals.node,
+    },
+  },
+  ...tseslint.configs.recommendedTypeChecked.map((config) => ({
+    ...config,
+    files: ["src/**/*.ts", "tests/**/*.ts"],
+  })),
+  {
+    files: ["src/**/*.ts", "tests/**/*.ts"],
+    ignores: ["src/decode-history-worker.ts"],
+    languageOptions: {
+      globals: globals.browser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    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 }],
+    },
+  },
+  {
+    files: ["src/decode-history-worker.ts"],
+    languageOptions: {
+      globals: globals.worker,
+      parserOptions: {
+        project: "./tsconfig.worker.json",
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      "no-undef": "off",
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/restrict-template-expressions": ["error", { allowNumber: true }],
+    },
+  },
+);

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

@@ -0,0 +1,28 @@
+{
+  "name": "trx-frontend-http-web",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "generate-types": "cargo run -p trx-frontend-http --example generate_typescript",
+    "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",
+    "verify-generated": "npm run generate-types && npm run build && git diff --exit-code -- ../assets/web/generated src/api/generated.ts"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.2",
+    "@types/leaflet": "1.9.22",
+    "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

@@ -0,0 +1,53 @@
+<!--
+SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+
+SPDX-License-Identifier: GPL-2.0-or-later
+-->
+
+# Frontend source
+
+This directory contains the strict TypeScript source for the browser assets
+embedded by `trx-frontend-http`. `bootstrap.ts` is the production entry point;
+esbuild follows its imports and emits `/app.js`. Feature plugins are ESM entry
+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/auth.ts

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export type AuthRole = "rx" | "control";
+
+export interface AuthSession {
+  authenticated: boolean;
+  role?: AuthRole;
+  auth_disabled?: boolean;
+}
+
+function decodeAuthSession(value: unknown): AuthSession {
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError("The authentication response is malformed");
+  }
+  const session = value as Record<string, unknown>;
+  if (typeof session.authenticated !== "boolean") {
+    throw new TypeError("The authentication response has no authenticated flag");
+  }
+  if (session.role !== undefined && session.role !== "rx" && session.role !== "control") {
+    throw new TypeError("The authentication response has an invalid role");
+  }
+  if (session.auth_disabled !== undefined && typeof session.auth_disabled !== "boolean") {
+    throw new TypeError("The authentication response has an invalid auth_disabled flag");
+  }
+  const decoded: AuthSession = { authenticated: session.authenticated };
+  if (session.role !== undefined) decoded.role = session.role;
+  if (session.auth_disabled !== undefined) decoded.auth_disabled = session.auth_disabled;
+  return decoded;
+}
+
+const authDisabledSession: AuthSession = {
+  authenticated: true,
+  role: "control",
+  auth_disabled: true,
+};
+
+export async function fetchAuthSession(): Promise<AuthSession> {
+  try {
+    const response = await fetch("/auth/session");
+    if (response.status === 404) return authDisabledSession;
+    if (!response.ok) return { authenticated: false };
+    return decodeAuthSession(await response.json());
+  } catch (error: unknown) {
+    console.error("Auth check failed:", error);
+    return { authenticated: false };
+  }
+}
+
+export async function login(passphrase: string): Promise<AuthSession> {
+  const response = await fetch("/auth/login", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ passphrase }),
+  });
+  if (response.status === 404) return authDisabledSession;
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(message || "Login failed");
+  }
+  return decodeAuthSession(await response.json());
+}
+
+export async function logout(): Promise<void> {
+  const response = await fetch("/auth/logout", { method: "POST" });
+  if (response.status !== 404 && !response.ok) throw new Error("Logout failed");
+}

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

@@ -0,0 +1,134 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type {
+  DecoderDescriptor,
+  RigListResponse,
+  RigSnapshot,
+} from "./generated";
+
+export class ApiError extends Error {
+  public constructor(
+    public readonly status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+type Validator<T> = (value: unknown) => value is T;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isRigSnapshot(value: unknown): value is RigSnapshot {
+  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: unknown): value is RigListResponse {
+  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: unknown): value is DecoderDescriptor[] {
+  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 {
+  public constructor(private readonly baseUrl = "") {}
+
+  public async get<T>(path: string, validate: Validator<T>): Promise<T> {
+    return this.request(path, { cache: "no-store" }, validate);
+  }
+
+  public async post<T>(
+    path: string,
+    body: unknown,
+    validate: Validator<T>,
+  ): Promise<T> {
+    return this.request(
+      path,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      },
+      validate,
+    );
+  }
+
+  private async request<T>(
+    path: string,
+    init: RequestInit,
+    validate: Validator<T>,
+  ): Promise<T> {
+    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: unknown = await response.json();
+    if (!validate(value)) {
+      throw new ApiError(response.status, `Malformed response from ${path}`);
+    }
+    return value;
+  }
+}
+
+export function decodeServerEvent<T>(
+  event: MessageEvent<string>,
+  validate: Validator<T>,
+): T {
+  let value: unknown;
+  try {
+    value = JSON.parse(event.data) as unknown;
+  } catch (error: unknown) {
+    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/frontend/src/api/generated.ts

@@ -0,0 +1,150 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated by `cargo run -p trx-frontend-http --example generate_typescript`.
+// Do not edit manually.
+
+export type Band = { low_hz: number, high_hz: number, tx_allowed: boolean, };
+
+export type Freq = { hz: number, };
+
+export type RigMode = "LSB" | "USB" | "CW" | "CWR" | "AM" | "SAM" | "WFM" | "FM" | "AIS" | "VDES" | "DIG" | "PKT" | { "Other": string };
+
+export type RigAccessMethod = { "Serial": { path: string, baud: number, } } | { "Tcp": { addr: string, } };
+
+export type RigCapabilities = { min_freq_step_hz: number, supported_bands: Array<Band>, supported_modes: Array<RigMode>, num_vfos: number, lock: boolean, lockable: boolean, attenuator: boolean, preamp: boolean, rit: boolean, rpt: boolean, split: boolean, 
+/**
+ * Backend supports transmit: PTT, power on/off, TX meters, TX audio.
+ */
+tx: boolean, 
+/**
+ * Backend supports get_tx_limit / set_tx_limit.
+ */
+tx_limit: boolean, 
+/**
+ * Backend supports toggle_vfo.
+ */
+vfo_switch: boolean, 
+/**
+ * Backend supports runtime filter adjustment (bandwidth).
+ */
+filter_controls: boolean, 
+/**
+ * Backend returns a meaningful RX signal strength value.
+ */
+signal_meter: boolean, };
+
+export type RigInfo = { manufacturer: string, model: string, revision: string, capabilities: RigCapabilities, access: RigAccessMethod, };
+
+export type RigVfoEntry = { name: string, freq: Freq, mode: RigMode | null, };
+
+export type RigVfo = { entries: Array<RigVfoEntry>, 
+/**
+ * Index into `entries` for the active VFO, if known.
+ */
+active: number | null, };
+
+export type RigTxStatus = { power: number | null, limit: number | null, swr: number | null, alc: number | null, };
+
+export type RigRxStatus = { sig: number | null, };
+
+export type RigStatus = { freq: Freq, mode: RigMode, tx_en: boolean, vfo: RigVfo | null, tx: RigTxStatus | null, rx: RigRxStatus | null, lock: boolean | null, };
+
+export type DecoderConfig = { aprs_decode_enabled: boolean, hf_aprs_decode_enabled: boolean, cw_decode_enabled: boolean, ft8_decode_enabled: boolean, ft4_decode_enabled: boolean, ft2_decode_enabled: boolean, wspr_decode_enabled: boolean, lrpt_decode_enabled: boolean, wefax_decode_enabled: boolean, recorder_enabled: boolean, };
+
+export type WfmDenoiseLevel = "off" | "auto" | "low" | "medium" | "high";
+
+export type RigFilterState = { bandwidth_hz: number, cw_center_hz: number, sdr_gain_db?: number | null, sdr_lna_gain_db?: number | null, sdr_agc_enabled?: boolean | null, sdr_squelch_enabled?: boolean | null, sdr_squelch_threshold_db?: number | null, sdr_nb_enabled?: boolean | null, sdr_nb_threshold?: number | null, wfm_deemphasis_us: number, wfm_stereo: boolean, wfm_stereo_detected: boolean, wfm_denoise: WfmDenoiseLevel, 
+/**
+ * Co-Channel Interference level (0–100 scale).
+ */
+wfm_cci: number, 
+/**
+ * Adjacent Channel Interference level (0–100 scale).
+ */
+wfm_aci: number, 
+/**
+ * SAM stereo width (0.0 = mono, 1.0 = full stereo).
+ */
+sam_stereo_width: number, 
+/**
+ * SAM carrier synchronization enabled.
+ */
+sam_carrier_sync: boolean, };
+
+export type RdsData = { pi?: number | null, program_service?: string | null, radio_text?: string | null, program_type_name_long?: string | null, pty?: number | null, pty_name?: string | null, traffic_program?: boolean | null, traffic_announcement?: boolean | null, music?: boolean | null, stereo?: boolean | null, artificial_head?: boolean | null, compressed?: boolean | null, dynamic_pty?: boolean | null, alternative_frequencies_hz?: Array<number> | null, };
+
+export type SpectrumData = { 
+/**
+ * FFT magnitude bins in dBFS, FFT-shifted so DC (centre frequency) is at index N/2.
+ */
+bins: Array<number>, 
+/**
+ * Centre frequency of the SDR capture in Hz.
+ */
+center_hz: number, 
+/**
+ * SDR capture sample rate in Hz; the displayed span is ±sample_rate/2.
+ */
+sample_rate: number, 
+/**
+ * Decoded Radio Data System state, when available for WFM.
+ */
+rds?: RdsData | null, };
+
+export type VchanRdsEntry = { 
+/**
+ * Virtual channel UUID.
+ */
+id: string, 
+/**
+ * Latest RDS data, if decoded.
+ */
+rds?: RdsData | null, 
+/**
+ * Channel signal level in dBFS.
+ */
+signal_db?: number | null, };
+
+export type RigSnapshot = { info: RigInfo, status: RigStatus, band: string | null, enabled: boolean | null, initialized: boolean, server_callsign?: string | null, server_version?: string | null, server_build_date?: string | null, server_latitude?: number | null, server_longitude?: number | null, pskreporter_status?: string | null, aprs_is_status?: string | null, cw_auto: boolean, cw_wpm: number, cw_tone_hz: number, filter?: RigFilterState | null, spectrum?: SpectrumData | null, 
+/**
+ * Per-virtual-channel RDS snapshots, when available.
+ */
+vchan_rds?: Array<VchanRdsEntry> | null, aprs_decode_enabled: boolean, hf_aprs_decode_enabled: boolean, cw_decode_enabled: boolean, ft8_decode_enabled: boolean, ft4_decode_enabled: boolean, ft2_decode_enabled: boolean, wspr_decode_enabled: boolean, lrpt_decode_enabled: boolean, wefax_decode_enabled: boolean, recorder_enabled: boolean, };
+
+export type RigListItem = { remote: string, display_name: string | null, manufacturer: string, model: string, supported_modes: Array<RigMode>, tx: boolean, filter_controls: boolean, initialized: boolean, latitude: number | null, longitude: number | null, };
+
+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 = { 
+/**
+ * Machine identifier, e.g. `"ft8"`, `"aprs"`.
+ */
+id: string, 
+/**
+ * Human-readable label, e.g. `"FT8"`, `"APRS"`.
+ */
+label: string, 
+/**
+ * How the decoder is activated.
+ */
+activation: DecoderActivation, 
+/**
+ * Rig modes where this decoder operates (upper-case).
+ */
+active_modes: Array<string>, 
+/**
+ * Whether the decoder can run on SDR virtual channels
+ * (background-decode / scheduler).
+ */
+background_decode: boolean, 
+/**
+ * Whether this decoder should appear in bookmark forms.
+ */
+bookmark_selectable: boolean, };
+

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

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// 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/cbor.ts

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export type CborValue = number | string | boolean | null | undefined
+  | CborValue[] | { [key: string]: CborValue };
+
+interface DecodeState { offset: number }
+
+const textDecoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
+
+function decodeUint(
+  view: DataView,
+  bytes: Uint8Array,
+  state: DecodeState,
+  additional: number,
+): number {
+  const offset = state.offset;
+  if (additional < 24) return additional;
+  const widths: Partial<Record<number, number>> = { 24: 1, 25: 2, 26: 4, 27: 8 };
+  const width = widths[additional];
+  if (width === undefined) throw new Error("Unsupported CBOR additional info");
+  if (offset + width > bytes.length) throw new Error("CBOR payload truncated");
+  state.offset += width;
+  if (additional === 24) return bytes[offset] ?? 0;
+  if (additional === 25) return view.getUint16(offset);
+  if (additional === 26) return view.getUint32(offset);
+  const numeric = Number(view.getBigUint64(offset));
+  if (!Number.isSafeInteger(numeric)) throw new Error("CBOR integer exceeds JS safe range");
+  return numeric;
+}
+
+function decodeFloat16(bits: number): number {
+  const sign = (bits & 0x8000) ? -1 : 1;
+  const exponent = (bits >> 10) & 0x1f;
+  const fraction = bits & 0x03ff;
+  if (exponent === 0) return fraction === 0 ? sign * 0 : sign * 2 ** -14 * (fraction / 1024);
+  if (exponent === 0x1f) return fraction === 0 ? sign * Infinity : Number.NaN;
+  return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
+}
+
+function decodeItem(view: DataView, bytes: Uint8Array, state: DecodeState): CborValue {
+  if (state.offset >= bytes.length) throw new Error("CBOR payload truncated");
+  const initial = bytes[state.offset++];
+  if (initial === undefined) throw new Error("CBOR payload truncated");
+  const major = initial >> 5;
+  const additional = initial & 0x1f;
+  if (major === 0) return decodeUint(view, bytes, state, additional);
+  if (major === 1) return -1 - decodeUint(view, bytes, state, additional);
+  if (major === 2 || major === 3) {
+    const length = decodeUint(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;
+    if (major === 2) return Array.from(chunk);
+    return textDecoder ? textDecoder.decode(chunk) : String.fromCharCode(...chunk);
+  }
+  if (major === 4) {
+    const length = decodeUint(view, bytes, state, additional);
+    return Array.from({ length }, () => decodeItem(view, bytes, state));
+  }
+  if (major === 5) {
+    const length = decodeUint(view, bytes, state, additional);
+    const value: Record<string, CborValue> = {};
+    for (let index = 0; index < length; index += 1) {
+      const key = decodeItem(view, bytes, state);
+      if (typeof key !== "string" && typeof key !== "number" && typeof key !== "boolean"
+        && key !== null) {
+        throw new Error("Unsupported composite CBOR map key");
+      }
+      value[String(key)] = decodeItem(view, bytes, state);
+    }
+    return value;
+  }
+  if (major === 6) {
+    decodeUint(view, bytes, state, additional);
+    return decodeItem(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;
+    const widths: Partial<Record<number, number>> = { 25: 2, 26: 4, 27: 8 };
+    const width = widths[additional];
+    if (width === undefined) throw new Error("Unsupported CBOR major type");
+    if (state.offset + width > bytes.length) throw new Error("CBOR payload truncated");
+    const offset = state.offset;
+    state.offset += width;
+    if (additional === 25) return decodeFloat16(view.getUint16(offset));
+    if (additional === 26) return view.getFloat32(offset);
+    return view.getFloat64(offset);
+  }
+  throw new Error("Unsupported CBOR major type");
+}
+
+export function decodeCbor(buffer: ArrayBuffer | Uint8Array): CborValue {
+  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 = decodeItem(view, bytes, state);
+  if (state.offset !== bytes.length) throw new Error("Unexpected trailing bytes in CBOR payload");
+  return value;
+}

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

@@ -0,0 +1,100 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export interface DecoderDescriptor {
+  id: string;
+  label: string;
+  activation: string;
+  active_modes: string[];
+  background_decode: boolean;
+  bookmark_selectable: boolean;
+}
+
+interface DecoderRegistryBridge {
+  decoderRegistry?: DecoderDescriptor[];
+  onDecoderRegistryReady?: (callback: () => void) => void;
+}
+
+const bridge = window as DecoderRegistryBridge;
+const readyCallbacks: Array<() => void> = [];
+
+export let decoderRegistry: DecoderDescriptor[] = [];
+
+export function onDecoderRegistryReady(callback: () => void): void {
+  if (decoderRegistry.length > 0) callback();
+  else readyCallbacks.push(callback);
+}
+
+export function applyDecoderRegistryVisibility(): void {
+  const knownIds = new Set(decoderRegistry.map(({ id }) => id));
+  const alwaysShow = new Set(["overview", "rds", "sat"]);
+
+  document.querySelectorAll<HTMLElement>(
+    "#tab-digital-modes > .sub-tab-bar > .sub-tab[data-subtab]",
+  ).forEach((button) => {
+    const id = button.dataset.subtab;
+    if (!id || alwaysShow.has(id) || knownIds.has(id)) return;
+    button.style.display = "none";
+    const panel = document.getElementById(`subtab-${id}`);
+    if (panel) panel.style.display = "none";
+  });
+
+  document.querySelectorAll<HTMLElement>('[id^="about-dec-"]').forEach((element) => {
+    const id = element.id.replace("about-dec-", "");
+    if (alwaysShow.has(id) || knownIds.has(id)) return;
+    const row = element.closest<HTMLElement>("tr");
+    if (row) row.style.display = "none";
+  });
+
+  document.querySelectorAll<HTMLElement>('[id^="settings-clear-"][id$="-history"]')
+    .forEach((element) => {
+      const match = /^settings-clear-(.+)-history$/.exec(element.id);
+      const id = match?.[1];
+      if (id && !alwaysShow.has(id) && !knownIds.has(id)) element.style.display = "none";
+    });
+
+  document.querySelectorAll<HTMLElement>("#subtab-overview .plugin-item[data-decoder]")
+    .forEach((element) => {
+      const id = element.dataset.decoder;
+      if (id && !alwaysShow.has(id) && !knownIds.has(id)) element.style.display = "none";
+    });
+}
+
+function isDecoderDescriptor(value: unknown): value is DecoderDescriptor {
+  if (typeof value !== "object" || value === null) return false;
+  const item = value as Partial<DecoderDescriptor>;
+  return typeof item.id === "string"
+    && typeof item.label === "string"
+    && typeof item.activation === "string"
+    && Array.isArray(item.active_modes)
+    && item.active_modes.every((mode) => typeof mode === "string")
+    && typeof item.background_decode === "boolean"
+    && typeof item.bookmark_selectable === "boolean";
+}
+
+function decodeRegistry(value: unknown): DecoderDescriptor[] {
+  if (!Array.isArray(value) || !value.every(isDecoderDescriptor)) {
+    throw new TypeError("The decoder registry response is malformed");
+  }
+  return value;
+}
+
+export async function loadDecoderRegistry(onLoaded: () => void): Promise<void> {
+  try {
+    const response = await fetch("/decoders");
+    if (!response.ok) return;
+    decoderRegistry = decodeRegistry(await response.json());
+    bridge.decoderRegistry = decoderRegistry;
+    readyCallbacks.splice(0).forEach((callback) => { callback(); });
+    applyDecoderRegistryVisibility();
+    onLoaded();
+  } catch (error: unknown) {
+    console.error("Failed to fetch decoder registry:", error);
+  }
+}
+
+// Temporary compatibility boundary for lazy modules that have not yet been
+// changed to receive the registry service through their plugin context.
+bridge.decoderRegistry = decoderRegistry;
+bridge.onDecoderRegistryReady = onDecoderRegistryReady;

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

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export function escapeHtml(input: unknown): string {
+  return String(input)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll("\"", "&quot;");
+}

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

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export function formatDuration(milliseconds: number): string {
+  const seconds = Math.floor(milliseconds / 1000);
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainder = seconds % 60;
+  const parts: string[] = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0 || days > 0) parts.push(`${hours}h`);
+  parts.push(`${minutes}m`, `${remainder}s`);
+  return parts.join(" ");
+}
+
+export function formatFrequency(frequencyHz: number): string {
+  if (!Number.isFinite(frequencyHz)) return "--";
+  if (frequencyHz >= 1_000_000_000) return `${(frequencyHz / 1_000_000_000).toFixed(3)} GHz`;
+  if (frequencyHz >= 10_000_000) return `${(frequencyHz / 1_000_000).toFixed(3)} MHz`;
+  return `${(frequencyHz / 1_000).toFixed(1)} kHz`;
+}
+
+export function formatFrequencyForStep(frequencyHz: number, stepHz: number): string {
+  if (!Number.isFinite(frequencyHz)) return "--";
+  if (stepHz >= 1_000_000) return (frequencyHz / 1_000_000).toFixed(6);
+  if (stepHz >= 1_000) return (frequencyHz / 1_000).toFixed(3);
+  if (stepHz >= 1) return String(Math.round(frequencyHz));
+  return formatFrequency(frequencyHz);
+}
+
+export function formatFrequencyForHumans(frequencyHz: number): string {
+  if (!Number.isFinite(frequencyHz)) return "--";
+  if (frequencyHz >= 1_000_000_000) return `${(frequencyHz / 1_000_000_000).toFixed(3)} GHz`;
+  if (frequencyHz >= 1_000_000) return `${(frequencyHz / 1_000_000).toFixed(3)} MHz`;
+  if (frequencyHz >= 1_000) return `${(frequencyHz / 1_000).toFixed(3)} kHz`;
+  return `${Math.round(frequencyHz)} Hz`;
+}
+
+export function formatWavelength(frequencyHz: number): string {
+  if (!Number.isFinite(frequencyHz) || frequencyHz <= 0) return "--";
+  const meters = 299_792_458 / frequencyHz;
+  return meters >= 1 ? `${Math.round(meters)} m` : `${Math.round(meters * 100)} cm`;
+}
+
+export function parseFrequencyInput(
+  value: string,
+  defaultStepHz: number,
+  mode: string,
+): number | null {
+  if (!value) return null;
+  const match = /^([0-9]+(?:[.,][0-9]+)?)\s*([kmg]hz|[kmg]|hz)?$/
+    .exec(value.trim().toLowerCase());
+  if (!match?.[1]) return null;
+  const rawNumber = match[1];
+  let frequency = Number.parseFloat(rawNumber.replace(",", "."));
+  const unit = match[2] ?? "";
+  if (Number.isNaN(frequency)) return null;
+
+  if (unit.startsWith("gh") || unit === "g") frequency *= 1_000_000_000;
+  else if (unit.startsWith("mh") || unit === "m") frequency *= 1_000_000;
+  else if (unit.startsWith("kh") || unit === "k") frequency *= 1_000;
+  else if (!unit) {
+    const hasDecimalSeparator = rawNumber.includes(".") || rawNumber.includes(",");
+    if (mode.toUpperCase() === "WFM") {
+      if (hasDecimalSeparator && frequency >= 50 && frequency < 200) {
+        return Math.round(frequency * 1_000_000);
+      }
+      if (!hasDecimalSeparator && frequency >= 875 && frequency <= 1080) {
+        return Math.round((frequency / 10) * 1_000_000);
+      }
+    }
+    if (defaultStepHz >= 1_000_000) frequency *= 1_000_000;
+    else if (defaultStepHz >= 1_000) frequency *= 1_000;
+    else if (defaultStepHz < 1) {
+      if (frequency < 1_000) frequency *= 1_000_000;
+      else if (frequency < 1_000_000) frequency *= 1_000;
+    }
+  }
+  return Math.round(frequency);
+}
+
+export function formatByteSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1_048_576) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1_048_576).toFixed(1)} MB`;
+}

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

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export interface LatLon {
+  readonly lat: number;
+  readonly lon: number;
+}
+
+export function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
+  const radiusKm = 6371;
+  const dLat = (lat2 - lat1) * Math.PI / 180;
+  const dLon = (lon2 - lon1) * Math.PI / 180;
+  const a = Math.sin(dLat / 2) ** 2
+    + Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) * Math.sin(dLon / 2) ** 2;
+  return radiusKm * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+
+export function locatorToLatLon(locator: unknown): LatLon | null {
+  const raw = typeof locator === "string" ? locator.trim().toUpperCase() : "";
+  if (!/^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(raw)) return null;
+  let lon = -180 + (raw.charCodeAt(0) - 65) * 20 + Number(raw.slice(2, 3)) * 2;
+  let lat = -90 + (raw.charCodeAt(1) - 65) * 10 + Number(raw.slice(3, 4));
+  if (raw.length >= 6) {
+    lon += (raw.charCodeAt(4) - 65) * (5 / 60) + 2.5 / 60;
+    lat += (raw.charCodeAt(5) - 65) * (2.5 / 60) + 1.25 / 60;
+  } else {
+    lon += 1;
+    lat += 0.5;
+  }
+  return { lat, lon };
+}
+
+export function formatDistanceKm(distanceKm: number): string | null {
+  if (!Number.isFinite(distanceKm)) return null;
+  return distanceKm < 1 ? `${Math.round(distanceKm * 1000)} m` : `${distanceKm.toFixed(1)} km`;
+}
+
+export function formatTimeAgo(timestampMs: number): string | null {
+  if (!timestampMs) return null;
+  const seconds = Math.round((Date.now() - timestampMs) / 1000);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}min ago` : `${hours}h ago`;
+}
+
+export function latLonToMaidenhead(lat: number, lon: number): string {
+  const adjustedLon = lon + 180;
+  const adjustedLat = lat + 90;
+  const upperA = "A".charCodeAt(0);
+  const lowerA = "a".charCodeAt(0);
+  const field1 = String.fromCharCode(upperA + Math.floor(adjustedLon / 20));
+  const field2 = String.fromCharCode(upperA + Math.floor(adjustedLat / 10));
+  const square1 = Math.floor((adjustedLon % 20) / 2);
+  const square2 = Math.floor(adjustedLat % 10);
+  const sub1 = String.fromCharCode(lowerA + Math.floor((adjustedLon % 2) * 12));
+  const sub2 = String.fromCharCode(lowerA + Math.floor((adjustedLat % 1) * 24));
+  return `${field1}${field2}${square1}${square2}${sub1}${sub2}`;
+}

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

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+const STORAGE_PREFIX = "trx_";
+
+export function saveSetting(key: string, value: unknown): void {
+  try {
+    localStorage.setItem(`${STORAGE_PREFIX}${key}`, JSON.stringify(value));
+  } catch {
+    // Storage can be unavailable in private browsing or under a strict policy.
+  }
+}
+
+export function loadSetting<T>(key: string, fallback: T): T {
+  try {
+    const value = localStorage.getItem(`${STORAGE_PREFIX}${key}`);
+    return value === null ? fallback : JSON.parse(value) as T;
+  } catch {
+    return fallback;
+  }
+}

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/decode-history-worker.ts

@@ -2,16 +2,27 @@
 //
 // 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"];
+export {};
 
-function decodeCborUint(view, bytes, state, additional) {
+const textDecoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
+const HISTORY_GROUP_KEYS = ["ais", "vdes", "aprs", "hf_aprs", "cw", "ft8", "ft4", "ft2", "wspr", "wefax"] as const;
+type HistoryGroup = (typeof HISTORY_GROUP_KEYS)[number];
+type CborValue = number | string | boolean | null | undefined | CborValue[] | { [key: string]: CborValue };
+interface DecodeState { offset: number }
+interface FetchHistoryRequest { type: "fetch-history"; url?: string; batchLimit?: number }
+interface WorkerScope {
+  postMessage(message: unknown): void;
+  onmessage: ((event: MessageEvent<unknown>) => void) | null;
+}
+const workerScope = self as unknown as WorkerScope;
+
+function decodeCborUint(view: DataView, bytes: Uint8Array, state: DecodeState, additional: number): number {
   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];
+    return bytes[offset] ?? 0;
   }
   if (additional === 25) {
     if (offset + 2 > bytes.length) throw new Error("CBOR payload truncated");
@@ -34,7 +45,7 @@ function decodeCborUint(view, bytes, state, additional) {
   throw new Error("Unsupported CBOR additional info");
 }
 
-function decodeCborFloat16(bits) {
+function decodeCborFloat16(bits: number): number {
   const sign = (bits & 0x8000) ? -1 : 1;
   const exponent = (bits >> 10) & 0x1f;
   const fraction = bits & 0x03ff;
@@ -47,9 +58,10 @@ function decodeCborFloat16(bits) {
   return sign * Math.pow(2, exponent - 15) * (1 + (fraction / 1024));
 }
 
-function decodeCborItem(view, bytes, state) {
+function decodeCborItem(view: DataView, bytes: Uint8Array, state: DecodeState): CborValue {
   if (state.offset >= bytes.length) throw new Error("CBOR payload truncated");
   const initial = bytes[state.offset++];
+  if (initial === undefined) throw new Error("CBOR payload truncated");
   const major = initial >> 5;
   const additional = initial & 0x1f;
   if (major === 0) return decodeCborUint(view, bytes, state, additional);
@@ -70,7 +82,7 @@ function decodeCborItem(view, bytes, state) {
   }
   if (major === 4) {
     const length = decodeCborUint(view, bytes, state, additional);
-    const items = new Array(length);
+    const items: CborValue[] = new Array<CborValue>(length);
     for (let i = 0; i < length; i += 1) {
       items[i] = decodeCborItem(view, bytes, state);
     }
@@ -78,10 +90,13 @@ function decodeCborItem(view, bytes, state) {
   }
   if (major === 5) {
     const length = decodeCborUint(view, bytes, state, additional);
-    const value = {};
+    const value: Record<string, CborValue> = {};
     for (let i = 0; i < length; i += 1) {
       const key = decodeCborItem(view, bytes, state);
-      value[String(key)] = decodeCborItem(view, bytes, state);
+      const property = typeof key === "string" || typeof key === "number" || typeof key === "boolean"
+        ? String(key)
+        : JSON.stringify(key);
+      value[property] = decodeCborItem(view, bytes, state);
     }
     return value;
   }
@@ -116,7 +131,7 @@ function decodeCborItem(view, bytes, state) {
   throw new Error("Unsupported CBOR major type");
 }
 
-function decodeCborPayload(buffer) {
+function decodeCborPayload(buffer: ArrayBuffer | Uint8Array): CborValue {
   const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const state = { offset: 0 };
@@ -127,35 +142,39 @@ function decodeCborPayload(buffer) {
   return value;
 }
 
-async function fetchAndDecodeHistory(url, batchLimit) {
-  self.postMessage({ type: "status", phase: "fetching" });
+function isHistory(value: CborValue): value is Partial<Record<HistoryGroup, CborValue[]>> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function fetchAndDecodeHistory(url: string, batchLimit?: number) {
+  workerScope.postMessage({ type: "status", phase: "fetching" });
   const resp = await fetch(url, { credentials: "same-origin" });
-  if (!resp.ok) throw new Error(`History fetch failed: ${resp.status}`);
+  if (!resp.ok) throw new Error(`History fetch failed: ${String(resp.status)}`);
   const payload = await resp.arrayBuffer();
-  if (!payload || payload.byteLength === 0) {
-    self.postMessage({ type: "start", total: 0 });
-    self.postMessage({ type: "done", total: 0 });
+  if (payload.byteLength === 0) {
+    workerScope.postMessage({ type: "start", total: 0 });
+    workerScope.postMessage({ type: "done", total: 0 });
     return;
   }
 
-  self.postMessage({ type: "status", phase: "decoding" });
+  workerScope.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] : [];
+    const items = isHistory(history) && Array.isArray(history[key]) ? history[key] : [];
     return sum + items.length;
   }, 0);
-  self.postMessage({ type: "start", total });
+  workerScope.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] : [];
+    const items = isHistory(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({
+      workerScope.postMessage({
         type: "group",
         kind,
         messages,
@@ -164,17 +183,22 @@ async function fetchAndDecodeHistory(url, batchLimit) {
       });
     }
   }
-  self.postMessage({ type: "done", total });
+  workerScope.postMessage({ type: "done", total });
 }
 
-self.onmessage = (event) => {
-  const data = event?.data || {};
-  if (data?.type !== "fetch-history") return;
+function isFetchHistoryRequest(value: unknown): value is FetchHistoryRequest {
+  return typeof value === "object" && value !== null && "type" in value && value.type === "fetch-history";
+}
+
+workerScope.onmessage = (event) => {
+  const data = event.data;
+  if (!isFetchHistoryRequest(data)) return;
   fetchAndDecodeHistory(data.url || "/decode/history", data.batchLimit)
-    .catch((err) => {
-      self.postMessage({
+    .catch((error: unknown) => {
+      workerScope.postMessage({
         type: "error",
-        message: err && err.message ? err.message : String(err || "unknown worker failure"),
+        message: error instanceof Error ? error.message
+          : typeof error === "string" ? error : "unknown worker failure",
       });
     });
 };

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/features/navigation/routes.ts

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export const TAB_ORDER = [
+  "main", "bookmarks", "digital-modes", "map", "statistics", "recorder", "settings", "about",
+] as const;
+
+export type TabName = typeof TAB_ORDER[number];
+
+export const TAB_PATHS: Readonly<Record<TabName, string>> = {
+  main: "/",
+  bookmarks: "/bookmarks",
+  "digital-modes": "/digital-modes",
+  map: "/map",
+  statistics: "/statistics",
+  recorder: "/recorder",
+  settings: "/settings",
+  about: "/about",
+};
+
+export function normalizeTabPath(pathname: string): string {
+  const raw = pathname.length > 0 ? pathname : "/";
+  return raw === "/" ? "/" : raw.replace(/\/+$/, "") || "/";
+}
+
+export function tabFromPath(pathname: string): TabName {
+  const normalized = normalizeTabPath(pathname);
+  const match = Object.entries(TAB_PATHS).find(([, path]) => path === normalized);
+  return match ? match[0] as TabName : "main";
+}
+
+export function updateTabHistory(name: TabName, replace = false): void {
+  const targetPath = TAB_PATHS[name];
+  if (normalizeTabPath(window.location.pathname) === targetPath) return;
+  const nextUrl = `${targetPath}${window.location.search}${window.location.hash}`;
+  if (replace) window.history.replaceState({}, "", nextUrl);
+  else window.history.pushState({}, "", nextUrl);
+}

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/features/radio/auto-bandwidth.ts

@@ -0,0 +1,97 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export interface SpectrumFrame {
+  bins: readonly number[] | ArrayBufferView;
+  center_hz: number;
+  sample_rate: number;
+}
+
+export interface InterferenceLevels { aci?: number; cci?: number }
+export type BandwidthLimits = readonly [defaultHz: number, minHz: number, maxHz: number, stepHz: number];
+
+function clampPercent(value: unknown): number {
+  const numeric = Number(value) || 0;
+  return Math.max(0, Math.min(100, numeric)) / 100;
+}
+
+export function estimateOccupiedBandwidth(
+  data: SpectrumFrame | null,
+  centerHz: number,
+  mode: string,
+  limits: BandwidthLimits,
+  interference: InterferenceLevels = {},
+): number | null {
+  if (!data || !Array.isArray(data.bins) && !ArrayBuffer.isView(data.bins)
+    || !Number.isFinite(centerHz)) return null;
+
+  const bins = Array.from(data.bins as ArrayLike<number>);
+  if (bins.length < 3) return null;
+  const maxIdx = bins.length - 1;
+  const hzPerBin = data.sample_rate / maxIdx;
+  const fullLoHz = data.center_hz - data.sample_rate / 2;
+  const centerIdx = Math.max(
+    1,
+    Math.min(maxIdx - 1, Math.round(((centerHz - fullLoHz) / data.sample_rate) * maxIdx)),
+  );
+  const normalizedMode = mode.toUpperCase();
+  const [defaultBw, minBw, maxBw, stepBw] = limits;
+  const oneSided = ["USB", "DIG", "CW"].includes(normalizedMode)
+    ? 1 : ["LSB", "CWR"].includes(normalizedMode) ? -1 : 0;
+  const isWfm = normalizedMode === "WFM";
+  const smoothRadius = isWfm ? 3 : 1;
+  const smoothed = bins.map((_, index) => {
+    let sum = 0;
+    let count = 0;
+    for (let adjacent = Math.max(0, index - smoothRadius);
+      adjacent <= Math.min(maxIdx, index + smoothRadius); adjacent += 1) {
+      sum += bins[adjacent] ?? 0;
+      count += 1;
+    }
+    return sum / count;
+  });
+  const sorted = [...bins].sort((left, right) => left - right);
+  const noise = sorted[Math.floor(sorted.length * 0.2)] ?? -Infinity;
+  const maxSpanBins = Math.max(2, Math.ceil(maxBw / hzPerBin));
+  const searchHalfBins = oneSided === 0 ? Math.ceil(maxSpanBins / 2) : maxSpanBins;
+  const searchLo = Math.max(1, centerIdx - (oneSided > 0 ? 2 : searchHalfBins));
+  const searchHi = Math.min(maxIdx - 1, centerIdx + (oneSided < 0 ? 2 : searchHalfBins));
+  let peak = -Infinity;
+  for (let index = searchLo; index <= searchHi; index += 1) {
+    peak = Math.max(peak, smoothed[index] ?? -Infinity);
+  }
+  const snr = peak - noise;
+  if (!Number.isFinite(snr) || snr < (isWfm ? 5 : 4)) return isWfm ? minBw : defaultBw;
+
+  const threshold = noise + Math.max(3, Math.min(isWfm ? 6 : 10, snr * (isWfm ? 0.18 : 0.28)));
+  const allowedGap = Math.max(isWfm ? 4 : 2, Math.ceil((isWfm ? 12_000 : stepBw) / hzPerBin));
+  const occupiedExtent = (direction: -1 | 1, limitBins: number): number => {
+    let lastOccupied = centerIdx;
+    let gap = 0;
+    for (let offset = 0; offset <= limitBins; offset += 1) {
+      const index = centerIdx + direction * offset;
+      if (index <= 0 || index >= maxIdx) break;
+      if ((smoothed[index] ?? -Infinity) >= threshold) {
+        lastOccupied = index;
+        gap = 0;
+      } else if (++gap > allowedGap) break;
+    }
+    return Math.abs(lastOccupied - centerIdx) * hzPerBin;
+  };
+
+  let rawBw = oneSided !== 0
+    ? occupiedExtent(oneSided, maxSpanBins)
+    : 2 * Math.max(occupiedExtent(-1, searchHalfBins), occupiedExtent(1, searchHalfBins));
+  rawBw *= isWfm ? 1.08 : 1.12;
+  if (isWfm) {
+    const aci = clampPercent(interference.aci);
+    const cci = clampPercent(interference.cci);
+    const aciCap = maxBw - (maxBw - minBw) * aci;
+    const cciFloor = minBw + (defaultBw - minBw) * 0.65;
+    const cciCap = maxBw - (maxBw - cciFloor) * cci;
+    rawBw = Math.min(rawBw, aciCap, cciCap);
+  }
+  const clamped = Math.max(minBw, Math.min(maxBw, rawBw));
+  return Math.max(stepBw, Math.round(clamped / stepBw) * stepBw);
+}

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/leaflet-ais-tracksymbol.ts

@@ -0,0 +1,163 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export {};
+
+interface AisSymbolOptions {
+  heading: number | null;
+  course: number | null;
+  speed: number | null;
+  color: string;
+  outline: string;
+  size: number;
+  interactive: boolean;
+  keyboard: boolean;
+  riseOnHover: boolean;
+  icon?: unknown;
+}
+interface LeafletMapAdapter { on(event: string, listener: () => void): void; off(event: string, listener: () => void): void; getZoom(): number }
+interface TrackSymbolInstance {
+  options: AisSymbolOptions;
+  _icon?: HTMLElement;
+  _map?: LeafletMapAdapter;
+  _boundZoomRefresh?: (() => void) | null;
+  _refreshIcon(): void;
+}
+interface TrackSymbolConstructor { new(latlng: unknown, options?: Partial<AisSymbolOptions>): TrackSymbolInstance }
+interface LeafletAdapter {
+  Marker: {
+    extend(definition: object & ThisType<TrackSymbolInstance>): TrackSymbolConstructor;
+    prototype: {
+      initialize(this: TrackSymbolInstance, latlng: unknown, options: AisSymbolOptions): void;
+      onAdd(this: TrackSymbolInstance, map: LeafletMapAdapter): void;
+      onRemove(this: TrackSymbolInstance, map: LeafletMapAdapter): void;
+    };
+  };
+  Util: { extend<T extends object>(target: T, ...sources: object[]): T };
+  divIcon(options: object): unknown;
+  TrxAisTrackSymbol?: TrackSymbolConstructor;
+  trxAisTrackSymbol?: (latlng: unknown, options?: Partial<AisSymbolOptions>) => TrackSymbolInstance;
+}
+
+(function() {
+  const leaflet = (globalThis as unknown as { L?: LeafletAdapter }).L;
+  if (!leaflet) return;
+
+  function clamp(value: number, min: number, max: number): number {
+    return Math.max(min, Math.min(max, value));
+  }
+
+  function finiteAngle(value: number | null): number | null {
+    if (value === null || !Number.isFinite(value)) return null;
+    const normalized = ((value % 360) + 360) % 360;
+    return normalized;
+  }
+
+  function svgColor(value: string, fallback: string): string {
+    const text = value || fallback || "";
+    return text.replace(/"/g, "&quot;");
+  }
+
+  function buildSymbolHtml(options: AisSymbolOptions, zoom: number): string {
+    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: unknown, options?: Partial<AisSymbolOptions>) {
+      const merged = leaflet.Util.extend({} as AisSymbolOptions, 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: LeafletMapAdapter) {
+      leaflet.Marker.prototype.onAdd.call(this, map);
+      this._refreshIcon();
+      this._boundZoomRefresh = this._refreshIcon.bind(this);
+      map.on("zoomend", this._boundZoomRefresh);
+    },
+
+    onRemove: function(map: LeafletMapAdapter) {
+      if (this._boundZoomRefresh) {
+        map.off("zoomend", this._boundZoomRefresh);
+        this._boundZoomRefresh = null;
+      }
+      leaflet.Marker.prototype.onRemove.call(this, map);
+    },
+
+    setAisState: function(next: Partial<AisSymbolOptions>) {
+      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: unknown, options?: Partial<AisSymbolOptions>) {
+    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/frontend/src/plugin-loader.ts

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+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"],
+  "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 = new Set<string>();
+const loading = new Map<string, Promise<void>>();
+async function loadPlugin(path: string): Promise<void> {
+  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: unknown) => {
+    loading.delete(path);
+    throw new Error(`Failed to load plugin module: ${path}`, { cause: error });
+  });
+  loading.set(path, request);
+  return request;
+}
+
+async function loadPlugins(group: string): Promise<void> {
+  if (!(group in pluginGroups)) return;
+  for (const path of pluginGroups[group as PluginGroup]) await loadPlugin(path);
+}
+
+export async function loadEagerPlugins(): Promise<void> {
+  await Promise.all(["digital-modes", "bookmarks", "settings"].map(loadPlugins));
+}
+
+export async function loadPluginsForTab(tab: string): Promise<void> {
+  await loadPlugins(tab);
+}

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

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { DecoderPlugin, PluginRuntimeWindow, TrxPluginRuntime } from "./plugins/runtime-contract";
+
+type QueuedAction =
+  | { kind: "message"; payload: unknown }
+  | { kind: "batch" | "restore"; payload: unknown[] };
+
+const decoders = new Map<string, DecoderPlugin>();
+const queued = new Map<string, QueuedAction[]>();
+const MAX_QUEUED_ACTIONS_PER_DECODER = 512;
+
+function enqueue(id: string, action: QueuedAction): void {
+  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: DecoderPlugin, action: QueuedAction): boolean {
+  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: string, action: QueuedAction): boolean {
+  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: TrxPluginRuntime = {
+  registerDecoder<TMessage>(plugin: DecoderPlugin<TMessage>): () => void {
+    if (decoders.has(plugin.id)) throw new Error(`Decoder plugin already registered: ${plugin.id}`);
+    const erased = plugin as DecoderPlugin;
+    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 as unknown as PluginRuntimeWindow).trxPluginRuntime = runtime;

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

@@ -2,10 +2,47 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
+export {};
+
+import type { PluginRuntimeWindow } from "./runtime-contract";
+
+interface AisMessage {
+  rig_id?: string | null;
+  channel?: string | null;
+  message_type?: number | null;
+  mmsi?: number | null;
+  lat?: number | null;
+  lon?: number | null;
+  sog_knots?: number | null;
+  cog_deg?: number | null;
+  heading_deg?: number | null;
+  vessel_name?: string | null;
+  callsign?: string | null;
+  destination?: string | null;
+  ts_ms?: number | null;
+  _tsMs?: number;
+  _ts?: string;
+}
+interface AisChannelInfo { label: string; badgeClass: string; freqText: string }
+interface AisBridge {
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  buildAisVesselUrl?: (mmsi: number | null | undefined) => string | null;
+  aisMapAddVessel?: (message: AisMessage) => void;
+  clearMapMarkersByType?: (type: string) => void;
+  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 => hostCore.escapeMapHtml(input);
+
 // --- 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 aisFilterInput = document.getElementById("ais-filter") as HTMLInputElement | null;
 const aisBarOverlay = document.getElementById("ais-bar-overlay");
 const aisChannelSummaryEl = document.getElementById("ais-channel-summary");
 const aisVesselCountEl = document.getElementById("ais-vessel-count");
@@ -14,41 +51,41 @@ 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 = [];
+let aisMessageHistory: AisMessage[] = [];
 
-function currentAisHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
+function currentAisHistoryRetentionMs(): number {
+  return typeof aisWindow.getDecodeHistoryRetentionMs === "function"
+    ? aisWindow.getDecodeHistoryRetentionMs()
     : 24 * 60 * 60 * 1000;
 }
 
 function pruneAisMessageHistory() {
   const cutoffMs = Date.now() - currentAisHistoryRetentionMs();
-  aisMessageHistory = aisMessageHistory.filter((msg) => Number(msg?._tsMs) >= cutoffMs);
+  aisMessageHistory = aisMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
 }
 
-function scheduleAisUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
+function scheduleAisUi(key: string, job: () => void): void {
+  if (typeof aisWindow.trxScheduleUiFrameJob === "function") {
+    aisWindow.trxScheduleUiFrameJob(key, job);
     return;
   }
   job();
 }
 
 function scheduleAisHistoryRender() {
-  scheduleAisUi("ais-history", () => renderAisHistory());
+  scheduleAisUi("ais-history", () => { renderAisHistory(); });
 }
 
 function scheduleAisBarUpdate() {
-  scheduleAisUi("ais-bar", () => updateAisBar());
+  scheduleAisUi("ais-bar", () => { updateAisBar(); });
 }
 
-function formatAisMhz(freqHz) {
+function formatAisMhz(freqHz: number): string {
   return `${(freqHz / 1_000_000).toFixed(3)} MHz`;
 }
 
-function currentAisChannelPlan() {
-  const raw = (document.getElementById("freq")?.value || "").replace(/[^\d]/g, "");
+function currentAisChannelPlan(): { aHz: number; bHz: number } {
+  const raw = ((document.getElementById("freq") as HTMLInputElement | null)?.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 {
@@ -57,9 +94,9 @@ function currentAisChannelPlan() {
   };
 }
 
-function aisChannelInfo(channel) {
+function aisChannelInfo(channel: string | null | undefined): AisChannelInfo {
   const plan = currentAisChannelPlan();
-  const ch = String(channel || "").trim().toUpperCase();
+  const ch = (channel ?? "").trim().toUpperCase();
   if (ch === "B") {
     return {
       label: "AIS-B",
@@ -74,18 +111,18 @@ function aisChannelInfo(channel) {
   };
 }
 
-function aisDisplayName(msg) {
+function aisDisplayName(msg: AisMessage): string {
   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;
+function aisDisplayNameHtml(msg: AisMessage): string {
+  const label = escapeAisHtml(aisDisplayName(msg));
+  const url = aisWindow.buildAisVesselUrl?.(msg.mmsi) ?? null;
   if (!url) return label;
-  return `<a class="title-link" href="${escapeMapHtml(url)}" target="_blank" rel="noopener">${label}</a>`;
+  return `<a class="title-link" href="${escapeAisHtml(url)}" target="_blank" rel="noopener">${label}</a>`;
 }
 
-function aisTypeLabel(type) {
+function aisTypeLabel(type: number | null | undefined): string {
   switch (Number(type)) {
     case 1:
     case 2:
@@ -108,8 +145,8 @@ function aisTypeLabel(type) {
   }
 }
 
-function aisAgeText(tsMs) {
-  if (!Number.isFinite(tsMs)) return "just now";
+function aisAgeText(tsMs: number | undefined): string {
+  if (typeof tsMs !== "number" || !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";
@@ -120,31 +157,31 @@ function aisAgeText(tsMs) {
   return `${hours}h ago`;
 }
 
-function aisMotionText(msg) {
+function aisMotionText(msg: AisMessage): string {
   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,
+    msg.sog_knots != null ? `${msg.sog_knots.toFixed(1)} kn` : null,
+    msg.cog_deg != null ? `${msg.cog_deg.toFixed(1)}° COG` : null,
+    msg.heading_deg != null ? `${msg.heading_deg.toFixed(0)}° HDG` : null,
   ].filter(Boolean);
   return parts.join(" · ");
 }
 
-function aisRouteText(msg) {
+function aisRouteText(msg: AisMessage): string {
   return [msg.callsign, msg.destination].filter(Boolean).join(" -> ");
 }
 
-function aisDistanceText(msg) {
-  if (serverLat == null || serverLon == null || msg?.lat == null || msg?.lon == null) {
+function aisDistanceText(msg: AisMessage): string {
+  if (hostState.serverLat == null || hostState.serverLon == null || msg.lat == null || msg.lon == null) {
     return "";
   }
-  const distKm = haversineKm(serverLat, 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`;
 }
 
-function aisLatestByVessel(messages) {
-  const byMmsi = new Map();
+function aisLatestByVessel(messages: AisMessage[]): AisMessage[] {
+  const byMmsi = new Map<string, AisMessage>();
   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);
@@ -175,7 +212,7 @@ function updateAisSummary() {
   }
 }
 
-function renderAisRow(msg) {
+function renderAisRow(msg: AisMessage): HTMLElement {
   const row = document.createElement("div");
   row.className = "ais-message";
   const ts = msg._ts || new Date().toLocaleTimeString([], {
@@ -209,25 +246,25 @@ function renderAisRow(msg) {
     `<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>` +
+      `<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 ${escapeMapHtml(String(msg.mmsi))}</span>` +
-      (route ? `<span class="ais-meta-text">${escapeMapHtml(route)}</span>` : "") +
-      `<span class="ais-meta-text">${escapeMapHtml(channel.freqText)}</span>` +
+      `<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>${escapeMapHtml(motion)}</span>` : `<span>No motion data</span>`) +
-      (distance ? `<span>${escapeMapHtml(distance)}</span>` : "") +
+      (motion ? `<span>${escapeAisHtml(motion)}</span>` : `<span>No motion data</span>`) +
+      (distance ? `<span>${escapeAisHtml(distance)}</span>` : "") +
       (pos ? `<span>${pos}</span>` : "") +
-      `<span>${escapeMapHtml(aisAgeText(msg._tsMs))}</span>` +
+      `<span>${escapeAisHtml(aisAgeText(msg._tsMs))}</span>` +
     `</div>`;
   applyAisFilterToRow(row);
   return row;
 }
 
-function applyAisFilterToRow(row) {
+function applyAisFilterToRow(row: HTMLElement): void {
   if (!aisFilterText) {
     row.style.display = "";
     return;
@@ -236,19 +273,13 @@ function applyAisFilterToRow(row) {
   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 isAis = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase() === "AIS";
   const cutoffMs = Date.now() - AIS_BAR_WINDOW_MS;
-  const recent = aisMessageHistory.filter((msg) => msg._tsMs >= cutoffMs);
+  const recent = aisMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
   const messages = aisLatestByVessel(recent).slice(0, 8);
   if (!isAis || messages.length === 0) {
     aisBarOverlay.style.display = "none";
@@ -266,12 +297,12 @@ function updateAisBar() {
     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)),
+      `MMSI ${escapeAisHtml(String(msg.mmsi))}`,
+      escapeAisHtml(channel.label),
+      msg.sog_knots != null ? `${msg.sog_knots.toFixed(1)} kn` : null,
+      msg.cog_deg != null ? `${msg.cog_deg.toFixed(1)}°` : null,
+      distance ? escapeAisHtml(distance) : null,
+      escapeAisHtml(aisAgeText(msg._tsMs)),
     ]
       .filter(Boolean)
       .join(" · ");
@@ -282,18 +313,18 @@ function updateAisBar() {
   aisBarOverlay.innerHTML = html;
   aisBarOverlay.style.display = "flex";
 }
-window.updateAisBar = updateAisBar;
-window.clearAisBar = function() {
-  window.resetAisHistoryView();
+aisWindow.updateAisBar = updateAisBar;
+aisWindow.clearAisBar = function() {
+  resetAisHistoryView();
 };
 
-window.resetAisHistoryView = function() {
+function resetAisHistoryView(): void {
   if (aisMessagesEl) aisMessagesEl.innerHTML = "";
   aisMessageHistory = [];
   updateAisBar();
   renderAisHistory();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("ais");
-};
+  aisWindow.clearMapMarkersByType?.("ais");
+}
 
 function renderAisHistory() {
   pruneAisMessageHistory();
@@ -302,14 +333,14 @@ function renderAisHistory() {
     return;
   }
   const fragment = document.createDocumentFragment();
-  for (let i = 0; i < aisMessageHistory.length; i += 1) {
-    fragment.appendChild(renderAisRow(aisMessageHistory[i]));
+  for (const message of aisMessageHistory) {
+    fragment.appendChild(renderAisRow(message));
   }
   aisMessagesEl.replaceChildren(fragment);
   updateAisSummary();
 }
 
-function addAisMessage(msg) {
+function addAisMessage(msg: AisMessage): void {
   const tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
   msg._tsMs = tsMs;
   msg._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -323,33 +354,22 @@ function addAisMessage(msg) {
   scheduleAisBarUpdate();
   scheduleAisHistoryRender();
 
-  if (msg.lat != null && msg.lon != null && window.aisMapAddVessel) {
-    window.aisMapAddVessel(msg);
+  if (msg.lat != null && msg.lon != null && aisWindow.aisMapAddVessel) {
+    aisWindow.aisMapAddVessel(msg);
   }
 }
 
-function normalizeServerAisMessage(msg) {
+function normalizeServerAisMessage(msg: AisMessage): AisMessage {
   return {
+    ...msg,
     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) {
+function onServerAisBatch(messages: AisMessage[]): void {
   if (!Array.isArray(messages) || messages.length === 0) return;
   if (aisStatus) aisStatus.textContent = "Receiving";
-  const normalized = [];
+  const normalized: AisMessage[] = [];
   for (const msg of messages) {
     const next = normalizeServerAisMessage(msg);
     const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
@@ -359,8 +379,8 @@ window.onServerAisBatch = function(messages) {
       minute: "2-digit",
       second: "2-digit",
     });
-    if (next.lat != null && next.lon != null && window.aisMapAddVessel) {
-      window.aisMapAddVessel(next);
+    if (next.lat != null && next.lon != null && aisWindow.aisMapAddVessel) {
+      aisWindow.aisMapAddVessel(next);
     }
     normalized.push(next);
   }
@@ -369,27 +389,23 @@ window.onServerAisBatch = function(messages) {
   pruneAisMessageHistory();
   scheduleAisBarUpdate();
   scheduleAisHistoryRender();
-};
+}
 
-window.restoreAisHistory = function(messages) {
-  window.onServerAisBatch(messages);
-};
-
-window.pruneAisHistoryView = function() {
+function pruneAisHistoryView(): void {
   pruneAisMessageHistory();
   updateAisBar();
   renderAisHistory();
-};
+}
 
-document.getElementById("settings-clear-ais-history")?.addEventListener("click", async () => {
-  if (!confirm("Clear all AIS decode history? This cannot be undone.")) return;
+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 postPath("/clear_ais_decode");
-    window.resetAisHistoryView();
+    await hostCore.postPath("/clear_ais_decode");
+    resetAisHistoryView();
   } catch (e) {
     console.error("AIS history clear failed", e);
   }
-});
+})(); });
 
 if (aisFilterInput) {
   aisFilterInput.addEventListener("input", () => {
@@ -398,10 +414,17 @@ if (aisFilterInput) {
   });
 }
 
-window.onServerAis = function(msg) {
+function onServerAis(msg: AisMessage): void {
   if (aisStatus) aisStatus.textContent = "Receiving";
   addAisMessage(normalizeServerAisMessage(msg));
-};
+}
 
 updateAisSummary();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("ais");
+(window as unknown as PluginRuntimeWindow).trxPluginRuntime.registerDecoder<AisMessage>({
+  id: "ais",
+  onMessage: onServerAis,
+  onBatch: onServerAisBatch,
+  restore: onServerAisBatch,
+  reset: resetAisHistoryView,
+  prune: pruneAisHistoryView,
+});

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

@@ -0,0 +1,135 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export type AprsCategory = "position" | "message" | "weather" | "telemetry" | "other";
+export type AprsTypeFilter = "all" | AprsCategory;
+
+export interface AprsPacket {
+  rig_id?: string | null;
+  receiver?: unknown;
+  srcCall?: string;
+  destCall?: string;
+  path?: string;
+  info?: string;
+  info_bytes?: number[];
+  type?: string;
+  crcOk?: boolean;
+  ts_ms?: number | null;
+  lat?: number | null;
+  lon?: number | null;
+  symbolTable?: string | null;
+  symbolCode?: string | null;
+  _tsMs?: number;
+  _ts?: string;
+  src_call?: string;
+  dest_call?: string;
+  packet_type?: string;
+  crc_ok?: boolean;
+  symbol_table?: string | null;
+  symbol_code?: string | null;
+}
+
+export function aprsPacketCategory(packet: AprsPacket): AprsCategory {
+  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";
+}
+
+export function aprsCategoryLabel(category: AprsCategory): string {
+  switch (category) {
+    case "position": return "Position";
+    case "message": return "Message";
+    case "weather": return "Weather";
+    case "telemetry": return "Telemetry";
+    default: return "Other";
+  }
+}
+
+export function aprsAgeText(timestampMs: number | undefined): string {
+  if (typeof timestampMs !== "number" || !Number.isFinite(timestampMs)) return "just now";
+  const seconds = Math.round(Math.max(0, Date.now() - timestampMs) / 1000);
+  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`;
+}
+
+export function aprsPacketSignature(packet: AprsPacket): string {
+  return [packet.srcCall ?? "", packet.destCall ?? "", packet.path ?? "", packet.info ?? "", packet.type ?? "",
+    packet.lat?.toFixed(4) ?? "", packet.lon?.toFixed(4) ?? ""].join("|");
+}
+
+export function collapseAprsDuplicates(packets: AprsPacket[]): AprsPacket[] {
+  const seen = new Set<string>();
+  return packets.filter((packet) => {
+    const signature = aprsPacketSignature(packet);
+    if (seen.has(signature)) return false;
+    seen.add(signature);
+    return true;
+  });
+}
+
+export function aprsHexBytes(bytes: number[] | undefined): string {
+  if (!bytes?.length) return "--";
+  return bytes.map((byte) => byte.toString(16).toUpperCase().padStart(2, "0")).join(" ");
+}
+
+export function renderAprsInfo(packet: AprsPacket): string {
+  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: number): string {
+  return byte >= 0x20 && byte <= 0x7e
+    ? escapeAprsCharacter(String.fromCharCode(byte))
+    : `<span class="aprs-byte">0x${byte.toString(16).toUpperCase().padStart(2, "0")}</span>`;
+}
+
+function renderAprsCharacter(character: string): string {
+  const code = character.charCodeAt(0);
+  return code >= 0x20 && code <= 0x7e
+    ? escapeAprsCharacter(character)
+    : `<span class="aprs-byte">0x${code.toString(16).toUpperCase().padStart(2, "0")}</span>`;
+}
+
+function escapeAprsCharacter(character: string): string {
+  if (character === "<") return "&lt;";
+  if (character === ">") return "&gt;";
+  if (character === "&") return "&amp;";
+  if (character === '"') return "&quot;";
+  return character;
+}
+
+export function renderLocalAprsSymbol(packet: AprsPacket, escapeHtml: (value: string) => string): string {
+  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>`;
+}
+
+export function normalizeAprsPacket(packet: AprsPacket, receiver: unknown): AprsPacket {
+  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,
+  };
+}

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

@@ -2,10 +2,41 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
+import {
+  aprsAgeText,
+  aprsCategoryLabel,
+  aprsHexBytes,
+  aprsPacketCategory,
+  collapseAprsDuplicates,
+  normalizeAprsPacket,
+  renderAprsInfo,
+  renderLocalAprsSymbol,
+  type AprsPacket,
+  type AprsTypeFilter,
+} from "./aprs-shared";
+import type { PluginRuntimeWindow } from "./runtime-contract";
+interface AprsBridge {
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  navigateToAprsMap?: (lat: number, lon: 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;
+  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 => hostCore.escapeMapHtml(input);
+const showAprsHint = (message: string, durationMs: number): void => { hostCore.showHint(message, durationMs); };
+
 // --- 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 aprsFilterInput = document.getElementById("aprs-filter") as HTMLInputElement | null;
 const aprsBarOverlay = document.getElementById("aprs-bar-overlay");
 const aprsOnlyPosBtn = document.getElementById("aprs-only-pos-btn");
 const aprsHideCrcBtn = document.getElementById("aprs-hide-crc-btn");
@@ -15,137 +46,49 @@ 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 aprsPacketHistory: AprsPacket[] = [];
 let aprsBarDismissedAtMs = 0;
 let aprsOnlyPos = false;
 let aprsHideCrc = false;
 let aprsCollapseDup = false;
-let aprsTypeFilter = "all";
+let aprsTypeFilter: AprsTypeFilter = "all";
 
-function currentAprsHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
+function currentAprsHistoryRetentionMs(): number {
+  return typeof aprsWindow.getDecodeHistoryRetentionMs === "function"
+    ? aprsWindow.getDecodeHistoryRetentionMs()
     : 24 * 60 * 60 * 1000;
 }
 
 function pruneAprsPacketHistory() {
   const cutoffMs = Date.now() - currentAprsHistoryRetentionMs();
-  aprsPacketHistory = aprsPacketHistory.filter((pkt) => Number(pkt?._tsMs) >= cutoffMs);
+  aprsPacketHistory = aprsPacketHistory.filter((pkt) => (pkt._tsMs ?? 0) >= cutoffMs);
 }
 
-function scheduleAprsUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
+function scheduleAprsUi(key: string, job: () => void): void {
+  if (typeof aprsWindow.trxScheduleUiFrameJob === "function") {
+    aprsWindow.trxScheduleUiFrameJob(key, job);
     return;
   }
   job();
 }
 
 function scheduleAprsHistoryRender() {
-  scheduleAprsUi("aprs-history", () => renderAprsHistory());
+  scheduleAprsUi("aprs-history", () => { renderAprsHistory(); });
 }
 
 function scheduleAprsBarUpdate() {
-  scheduleAprsUi("aprs-bar", () => updateAprsBar());
+  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);
+function aprsDistanceText(pkt: AprsPacket): string {
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
+  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`;
 }
 
-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) {
+function aprsFilterMatch(pkt: AprsPacket): boolean {
   if (aprsOnlyPos && (pkt.lat == null || pkt.lon == null)) return false;
   if (aprsHideCrc && !pkt.crcOk) return false;
   if (aprsTypeFilter !== "all" && aprsPacketCategory(pkt) !== aprsTypeFilter) return false;
@@ -166,23 +109,11 @@ function aprsFilterMatch(pkt) {
   return haystack.includes(aprsFilterText);
 }
 
-function aprsVisiblePackets() {
+function aprsVisiblePackets(): AprsPacket[] {
   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) {
@@ -210,7 +141,7 @@ function updateAprsChipState() {
   aprsCollapseDupBtn?.classList.toggle("active", aprsCollapseDup);
 }
 
-function renderAprsRow(pkt, isFresh) {
+function renderAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
   const row = document.createElement("div");
   row.className = "aprs-packet";
   if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
@@ -221,18 +152,9 @@ function renderAprsRow(pkt, isFresh) {
   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 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>';
-  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 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>`
     : "";
@@ -243,19 +165,19 @@ function renderAprsRow(pkt, isFresh) {
     `<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>` +
+      `<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">${escapeMapHtml(age)}</span>` +
-      (distance ? `<span class="aprs-meta-text">${escapeMapHtml(distance)}</span>` : "") +
-      `<span class="aprs-meta-text">${escapeMapHtml(pkt.type || "--")}</span>` +
+      `<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="${escapeMapHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
+      `<span title="${escapeAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
       (posLink ? `<span>${posLink}</span>` : "") +
     `</div>` +
     `<div class="aprs-row-actions">` +
@@ -266,42 +188,43 @@ function renderAprsRow(pkt, isFresh) {
     `<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">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">${escapeMapHtml(pkt.info || "--")}</span>` +
-        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeMapHtml(aprsHexBytes(pkt.info_bytes))}</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) => {
+  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((el) => {
     el.addEventListener("click", (evt) => {
       evt.preventDefault();
-      const raw = String(el.dataset.aprsMap || "");
+      const raw = el.dataset.aprsMap ?? "";
       const [lat, lon] = raw.split(",").map(Number);
-      if (window.navigateToAprsMap && Number.isFinite(lat) && Number.isFinite(lon)) {
-        window.navigateToAprsMap(lat, lon);
+      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]");
+  const copyBtn = row.querySelector<HTMLElement>("[data-aprs-copy]");
   if (copyBtn) {
-    copyBtn.addEventListener("click", async () => {
-      const raw = String(copyBtn.dataset.aprsCopy || "");
+    copyBtn.addEventListener("click", () => { void (async () => {
+      const raw = copyBtn.dataset.aprsCopy ?? "";
       try {
-        if (navigator.clipboard?.writeText) {
-          await navigator.clipboard.writeText(raw);
-          showHint("Coordinates copied", 1200);
+        const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
+        if (clipboard) {
+          await clipboard.writeText(raw);
+          showAprsHint("Coordinates copied", 1200);
         }
-      } catch (_e) {
-        showHint("Copy failed", 1500);
+      } catch {
+        showAprsHint("Copy failed", 1500);
       }
-    });
+    })(); });
   }
 
   return row;
@@ -316,8 +239,8 @@ function renderAprsHistory() {
   }
   const visible = aprsVisiblePackets();
   const fragment = document.createDocumentFragment();
-  for (let i = 0; i < visible.length; i++) {
-    fragment.appendChild(renderAprsRow(visible[i], i === 0));
+  for (const [index, packet] of visible.entries()) {
+    fragment.appendChild(renderAprsRow(packet, index === 0));
   }
   aprsPacketsEl.replaceChildren(fragment);
   updateAprsSummary();
@@ -326,9 +249,9 @@ function renderAprsHistory() {
 
 function updateAprsBar() {
   if (!aprsBarOverlay) return;
-  const isPkt = (document.getElementById("mode")?.value || "").toUpperCase() === "PKT";
+  const isPkt = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase() === "PKT";
   const cutoffMs = Date.now() - APRS_BAR_WINDOW_MS;
-  const okFrames = aprsPacketHistory.filter((p) => p.crcOk && p._tsMs >= cutoffMs);
+  const okFrames = aprsPacketHistory.filter((p) => p.crcOk && (p._tsMs ?? 0) >= 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) {
@@ -339,9 +262,9 @@ function updateAprsBar() {
   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 call = `<span class="aprs-bar-call">${escapeAprsHtml(pkt.srcCall ?? "")}</span>`;
+    const dest = escapeAprsHtml(pkt.destCall || "");
+    const info = escapeAprsHtml(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>`
       : "";
@@ -352,11 +275,11 @@ function updateAprsBar() {
   aprsBarOverlay.innerHTML = html;
   aprsBarOverlay.style.display = "flex";
 }
-window.updateAprsBar = updateAprsBar;
-window.clearAprsBar = function() {
-  window.resetAprsHistoryView();
+aprsWindow.updateAprsBar = updateAprsBar;
+aprsWindow.clearAprsBar = function() {
+  resetAprsHistoryView();
 };
-window.closeAprsBar = function() {
+aprsWindow.closeAprsBar = function() {
   aprsBarDismissedAtMs = Date.now();
   if (aprsBarOverlay) {
     aprsBarOverlay.style.display = "none";
@@ -364,21 +287,21 @@ window.closeAprsBar = function() {
   }
 };
 
-window.resetAprsHistoryView = function() {
+function resetAprsHistoryView(): void {
   if (aprsPacketsEl) aprsPacketsEl.innerHTML = "";
   aprsPacketHistory = [];
   updateAprsBar();
   renderAprsHistory();
-  if (window.clearMapMarkersByType) window.clearMapMarkersByType("aprs");
-};
+  aprsWindow.clearMapMarkersByType?.("aprs");
+}
 
-window.pruneAprsHistoryView = function() {
+function pruneAprsHistoryView(): void {
   pruneAprsPacketHistory();
   updateAprsBar();
   renderAprsHistory();
-};
+}
 
-function addAprsPacket(pkt) {
+function addAprsPacket(pkt: AprsPacket): void {
   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" });
@@ -386,8 +309,8 @@ function addAprsPacket(pkt) {
   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.lat != null && pkt.lon != null && aprsWindow.aprsMapAddStation) {
+    aprsWindow.aprsMapAddStation(pkt.srcCall ?? "", pkt.lat, pkt.lon, pkt.info ?? "", pkt.symbolTable, pkt.symbolCode, pkt);
   }
 
   if (pkt.crcOk) scheduleAprsBarUpdate();
@@ -395,37 +318,22 @@ function addAprsPacket(pkt) {
   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,
-  };
+function normalizeServerAprsPacket(pkt: AprsPacket): AprsPacket {
+  return normalizeAprsPacket(pkt, aprsWindow.getDecodeRigMeta?.() ?? null);
 }
 
-window.onServerAprsBatch = function(packets) {
+function onServerAprsBatch(packets: AprsPacket[]): void {
   if (!Array.isArray(packets) || packets.length === 0) return;
-  aprsStatus.textContent = "Receiving";
-  const normalized = [];
+  if (aprsStatus) aprsStatus.textContent = "Receiving";
+  const normalized: AprsPacket[] = [];
   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.lat != null && next.lon != null && aprsWindow.aprsMapAddStation) {
+      aprsWindow.aprsMapAddStation(next.srcCall ?? "", next.lat, next.lon, next.info ?? "", next.symbolTable, next.symbolCode, next);
     }
     if (next.crcOk) hasCrcOk = true;
     normalized.push(next);
@@ -435,21 +343,17 @@ window.onServerAprsBatch = function(packets) {
   pruneAprsPacketHistory();
   if (hasCrcOk) scheduleAprsBarUpdate();
   scheduleAprsHistoryRender();
-};
+}
 
-window.restoreAprsHistory = function(packets) {
-  window.onServerAprsBatch(packets);
-};
-
-document.getElementById("settings-clear-aprs-history")?.addEventListener("click", async () => {
-  if (!confirm("Clear all APRS decode history? This cannot be undone.")) return;
+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 postPath("/clear_aprs_decode");
-    window.resetAprsHistoryView();
+    await hostCore.postPath("/clear_aprs_decode");
+    resetAprsHistoryView();
   } catch (e) {
     console.error("APRS history clear failed", e);
   }
-});
+})(); });
 
 if (aprsOnlyPosBtn) {
   aprsOnlyPosBtn.addEventListener("click", () => {
@@ -472,7 +376,7 @@ if (aprsCollapseDupBtn) {
   });
 }
 
-["all", "position", "message", "weather", "telemetry", "other"].forEach((type) => {
+(["all", "position", "message", "weather", "telemetry", "other"] as const).forEach((type) => {
   const btn = document.getElementById(`aprs-type-${type}`);
   if (!btn) return;
   btn.addEventListener("click", () => {
@@ -489,10 +393,17 @@ if (aprsFilterInput) {
 }
 
 // --- Server-side APRS decode handler ---
-window.onServerAprs = function(pkt) {
-  aprsStatus.textContent = "Receiving";
+function onServerAprs(pkt: AprsPacket): void {
+  if (aprsStatus) aprsStatus.textContent = "Receiving";
   addAprsPacket(normalizeServerAprsPacket(pkt));
-};
+}
 
 renderAprsHistory();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("aprs");
+(window as unknown as PluginRuntimeWindow).trxPluginRuntime.registerDecoder<AprsPacket>({
+  id: "aprs",
+  onMessage: onServerAprs,
+  onBatch: onServerAprsBatch,
+  restore: onServerAprsBatch,
+  reset: resetAprsHistoryView,
+  prune: pruneAprsHistoryView,
+});

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

@@ -2,30 +2,79 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostState } from "./host.js";
+
+export {};
+
+interface DecoderDescriptor {
+  id: string;
+  background_decode?: boolean;
+  activation?: string;
+  active_modes: string[];
+}
+interface Bookmark {
+  id: string;
+  name: string;
+  freq_hz: number;
+  mode: string;
+  decoders?: string[];
+}
+interface BackgroundDecodeConfig {
+  remote: string | null;
+  enabled: boolean;
+  bookmark_ids: string[];
+}
+interface BackgroundStatusEntry {
+  bookmark_name?: string;
+  bookmark_id?: string;
+  freq_hz?: number;
+  mode?: string;
+  decoder_kinds?: string[];
+  state?: string;
+}
+interface BackgroundDecodeStatus {
+  entries?: BackgroundStatusEntry[];
+  active_rig?: boolean;
+  center_hz?: number;
+  sample_rate?: number;
+}
+interface BackgroundBridge {
+  decoderRegistry?: DecoderDescriptor[];
+  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
+  trx?: { modules?: { backgroundDecode?: BackgroundDecodeService } };
+}
+interface BackgroundDecodeService {
+  initialize(rigId: string | null, role: string | null): void;
+  wireEvents(): void;
+  setRig(rigId: string | null): void;
+}
+interface WiredElement extends HTMLElement { _wired?: boolean }
+const bgdWindow = window as unknown as BackgroundBridge;
+
 (function () {
   "use strict";
 
-  function bgdSupportedIds() {
-    return (window.decoderRegistry || [])
+  function bgdSupportedIds(): string[] {
+    return (bgdWindow.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 backgroundDecodeRole: string | null = null;
+  let currentRigId: string | null = null;
+  let currentConfig: BackgroundDecodeConfig | null = null;
+  let bookmarkList: Bookmark[] = [];
+  let statusInterval: ReturnType<typeof setInterval> | null = null;
   let bgdDirty = false;
 
-  function initBackgroundDecode(rigId, role) {
+  function initBackgroundDecode(rigId: string | null, role: string | null): void {
     backgroundDecodeRole = role;
     currentRigId = rigId || null;
     if (currentRigId) loadBackgroundDecode();
     startStatusPolling();
   }
 
-  function setBackgroundDecodeRig(rigId) {
+  function setBackgroundDecodeRig(rigId: string | null): void {
     const nextRigId = rigId || null;
     if (nextRigId === currentRigId) return;
     currentRigId = nextRigId;
@@ -33,44 +82,44 @@
     loadBackgroundDecode();
   }
 
-  function apiGetConfig(rigId) {
+  function apiGetConfig(rigId: string): Promise<BackgroundDecodeConfig> {
     return fetch("/background-decode/" + encodeURIComponent(rigId)).then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
+      if (!r.ok) throw new Error(`HTTP ${String(r.status)}`);
+      return r.json() as Promise<BackgroundDecodeConfig>;
     });
   }
 
-  function apiPutConfig(rigId, config) {
+  function apiPutConfig(rigId: string, config: BackgroundDecodeConfig): Promise<BackgroundDecodeConfig> {
     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();
+      if (!r.ok) throw new Error(`HTTP ${String(r.status)}`);
+      return r.json() as Promise<BackgroundDecodeConfig>;
     });
   }
 
-  function apiResetConfig(rigId) {
+  function apiResetConfig(rigId: string): Promise<BackgroundDecodeConfig> {
     return fetch("/background-decode/" + encodeURIComponent(rigId), {
       method: "DELETE",
     }).then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
+      if (!r.ok) throw new Error(`HTTP ${String(r.status)}`);
+      return r.json() as Promise<BackgroundDecodeConfig>;
     });
   }
 
-  function apiGetStatus(rigId) {
+  function apiGetStatus(rigId: string): Promise<BackgroundDecodeStatus> {
     return fetch("/background-decode/" + encodeURIComponent(rigId) + "/status").then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
+      if (!r.ok) throw new Error(`HTTP ${String(r.status)}`);
+      return r.json() as Promise<BackgroundDecodeStatus>;
     });
   }
 
-  function apiGetBookmarks() {
+  function apiGetBookmarks(): Promise<Bookmark[]> {
     return fetch("/bookmarks").then(function (r) {
-      if (!r.ok) throw new Error("HTTP " + r.status);
-      return r.json();
+      if (!r.ok) throw new Error(`HTTP ${String(r.status)}`);
+      return r.json() as Promise<Bookmark[]>;
     });
   }
 
@@ -79,35 +128,35 @@
     if (!rigId) return;
     Promise.all([apiGetConfig(rigId), apiGetBookmarks()])
       .then(function ([config, bookmarks]) {
-        currentConfig = config || { remote: rigId, enabled: false, bookmark_ids: [] };
+        currentConfig = config;
         bookmarkList = Array.isArray(bookmarks) ? bookmarks : [];
         renderBackgroundDecode();
         clearBgdDirty();
         pollBackgroundDecodeStatus();
       })
-      .catch(function (err) {
+      .catch(function (err: unknown) {
         console.error("background decode load failed", err);
       });
   }
 
-  function supportedBookmarks() {
+  function supportedBookmarks(): Bookmark[] {
     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(); })
+  function bookmarkDecoderKinds(bookmark: Bookmark): string[] {
+    const ids = bgdSupportedIds();
+    const decoders = bookmark.decoders ?? [];
+    const explicit = decoders
+      .map(function (item) { return 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 || [])
+    const mode = bookmark.mode.trim().toUpperCase();
+    return (bgdWindow.decoderRegistry || [])
       .filter(function (d) {
         return d.activation === "mode_bound" && d.background_decode
           && d.active_modes.indexOf(mode) >= 0;
@@ -119,13 +168,13 @@
     if (!currentConfig) {
       currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
     }
-    setCheckbox("background-decode-enabled", !!currentConfig.enabled);
+    setCheckbox("background-decode-enabled", currentConfig.enabled);
     renderBookmarkChecklist();
 
-    const isControl = backgroundDecodeRole === "control" || (typeof authEnabled !== "undefined" && !authEnabled);
+    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) {
+        panel.querySelectorAll<HTMLInputElement | HTMLSelectElement | HTMLButtonElement>("input, select, button.sch-write").forEach(function (el) {
         el.disabled = !isControl;
       });
     }
@@ -135,7 +184,7 @@
     if (resetBtn) resetBtn.style.display = isControl ? "" : "none";
   }
 
-  function renderBookmarkChecklist(filterText) {
+  function renderBookmarkChecklist(filterText = ""): void {
     const container = document.getElementById("bgd-bookmark-checklist");
     if (!container) return;
     container.innerHTML = "";
@@ -148,7 +197,7 @@
 
     const filtered = filter
       ? all.filter(function (bm) {
-          var text = (bm.name + " " + formatFreq(bm.freq_hz) + " " + bm.mode).toLowerCase();
+          const text = (bm.name + " " + formatFreq(bm.freq_hz) + " " + bm.mode).toLowerCase();
           return text.indexOf(filter) >= 0;
         })
       : all;
@@ -161,22 +210,22 @@
     }
 
     filtered.forEach(function (bookmark) {
-      var row = document.createElement("label");
+      const row = document.createElement("label");
       row.className = "bgd-checklist-row";
-      var decoders = bookmarkDecoderKinds(bookmark);
-      var checked = selectedIds.has(bookmark.id) ? " checked" : "";
+      const decoders = bookmarkDecoderKinds(bookmark);
+      const checked = selectedIds.has(bookmark.id) ? " checked" : "";
       row.innerHTML =
         '<input type="checkbox"' + checked + ' data-bm-id="' + escHtml(bookmark.id) + '" />' +
         '<span class="bgd-checklist-name">' + escHtml(bookmark.name) + '</span>' +
         '<span class="bgd-checklist-meta">' + escHtml(formatFreq(bookmark.freq_hz) + " " + bookmark.mode + " · " + decoders.join("/").toUpperCase()) + '</span>';
-      row.querySelector("input").addEventListener("change", function (e) {
-        onChecklistToggle(bookmark.id, e.target.checked);
+      row.querySelector<HTMLInputElement>("input")?.addEventListener("change", function (e) {
+        onChecklistToggle(bookmark.id, (e.currentTarget as HTMLInputElement).checked);
       });
       container.appendChild(row);
     });
   }
 
-  function onChecklistToggle(bookmarkId, checked) {
+  function onChecklistToggle(bookmarkId: string, checked: boolean): void {
     if (!currentConfig) {
       currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
     }
@@ -192,12 +241,12 @@
   function saveBackgroundDecode() {
     const rigId = currentRigId;
     if (!rigId) return;
-    const payload = {
+    const payload: BackgroundDecodeConfig = {
       remote: rigId,
-      enabled: !!document.getElementById("background-decode-enabled").checked,
-      bookmark_ids: Array.isArray(currentConfig && currentConfig.bookmark_ids) ? currentConfig.bookmark_ids.slice() : [],
+      enabled: (document.getElementById("background-decode-enabled") as HTMLInputElement | null)?.checked ?? false,
+      bookmark_ids: currentConfig?.bookmark_ids.slice() ?? [],
     };
-    const btn = document.getElementById("background-decode-save-btn");
+    const btn = document.getElementById("background-decode-save-btn") as HTMLButtonElement | null;
     if (btn) btn.disabled = true;
     apiPutConfig(rigId, payload)
       .then(function (saved) {
@@ -205,30 +254,30 @@
         renderBackgroundDecode();
         clearBgdDirty();
         pollBackgroundDecodeStatus();
-        showToast("Background decode saved.");
+        showToast("Background decode saved.", false);
       })
-      .catch(function (err) {
-        showToast("Save failed: " + err.message, true);
+      .catch(function (err: unknown) {
+        showToast(`Save failed: ${errorMessage(err)}`, true);
       })
       .finally(function () {
         if (btn) btn.disabled = false;
       });
   }
 
-  function resetBackgroundDecode() {
+  async function resetBackgroundDecode() {
     const rigId = currentRigId;
     if (!rigId) return;
-    if (!confirm("Reset background decode configuration? This cannot be undone.")) return;
+    if (!await bgdWindow.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.");
+        showToast("Background decode reset.", false);
       })
-      .catch(function (err) {
-        showToast("Reset failed: " + err.message, true);
+      .catch(function (err: unknown) {
+        showToast(`Reset failed: ${errorMessage(err)}`, true);
       });
   }
 
@@ -245,18 +294,18 @@
       .catch(function () {});
   }
 
-  function renderStatus(status) {
+  function renderStatus(status: BackgroundDecodeStatus): void {
     const card = document.getElementById("background-decode-status-card");
     if (!card) return;
-    const entries = Array.isArray(status && status.entries) ? status.entries : [];
+    const 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));
+      if (typeof status.center_hz === "number" && Number.isFinite(status.center_hz)) summary.push("Center " + formatFreq(status.center_hz));
+      if (typeof status.sample_rate === "number" && Number.isFinite(status.sample_rate) && status.sample_rate > 0) summary.push("Span ±" + formatFreq(status.sample_rate / 2));
     } else {
       summary.push("This rig is not currently selected for audio.");
     }
@@ -265,7 +314,7 @@
     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 (typeof entry.freq_hz === "number" && Number.isFinite(entry.freq_hz)) parts.push(formatFreq(entry.freq_hz));
       if (entry.mode) parts.push(entry.mode);
       if (Array.isArray(entry.decoder_kinds) && entry.decoder_kinds.length) {
         parts.push(entry.decoder_kinds.join("/").toUpperCase());
@@ -285,7 +334,7 @@
     card.innerHTML = html;
   }
 
-  function prettyState(state) {
+  function prettyState(state: string | undefined): string {
     switch (state) {
       case "active": return "\u2713 Active";
       case "out_of_span": return "\u25B3 Out of span";
@@ -301,40 +350,47 @@
     }
   }
 
-  function setCheckbox(id, value) {
-    const el = document.getElementById(id);
-    if (el) el.checked = !!value;
+  function setCheckbox(id: string, value: boolean): void {
+    const el = document.getElementById(id) as HTMLInputElement | null;
+    if (el) el.checked = value;
   }
 
-  function formatFreq(hz) {
+  function formatFreq(hz: number): string {
     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";
+    return `${String(hz)} Hz`;
   }
 
-  function escHtml(value) {
-    return String(value == null ? "" : value)
+  function escHtml(value: unknown): string {
+    const text = typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+      ? String(value)
+      : "";
+    return text
       .replace(/&/g, "&amp;")
       .replace(/</g, "&lt;")
       .replace(/>/g, "&gt;")
       .replace(/"/g, "&quot;");
   }
 
+  function errorMessage(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+  }
+
   function markBgdDirty() {
     if (bgdDirty) return;
     bgdDirty = true;
-    var btn = document.getElementById("background-decode-save-btn");
+    const 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");
+    const btn = document.getElementById("background-decode-save-btn");
     if (btn) btn.classList.remove("sch-dirty");
   }
 
-  function showToast(msg, isError) {
+  function showToast(msg: string, isError: boolean): void {
     const el = document.getElementById("background-decode-toast");
     if (!el) return;
     el.textContent = msg;
@@ -349,9 +405,9 @@
     if (!currentConfig) {
       currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
     }
-    var ids = supportedBookmarks().map(function (bm) { return bm.id; });
+    const ids = supportedBookmarks().map(function (bm) { return bm.id; });
     currentConfig.bookmark_ids = ids;
-    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
+    renderBookmarkChecklist((document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value);
     markBgdDirty();
   }
 
@@ -360,12 +416,12 @@
       currentConfig = { remote: currentRigId, enabled: false, bookmark_ids: [] };
     }
     currentConfig.bookmark_ids = [];
-    renderBookmarkChecklist(document.getElementById("bgd-bookmark-filter")?.value);
+    renderBookmarkChecklist((document.getElementById("bgd-bookmark-filter") as HTMLInputElement | null)?.value);
     markBgdDirty();
   }
 
   function wireBackgroundDecodeEvents() {
-    const filterInput = document.getElementById("bgd-bookmark-filter");
+    const filterInput = document.getElementById("bgd-bookmark-filter") as (HTMLInputElement & WiredElement) | null;
     if (filterInput && !filterInput._wired) {
       filterInput._wired = true;
       filterInput.addEventListener("input", function () {
@@ -373,38 +429,42 @@
       });
     }
 
-    const enabledCb = document.getElementById("background-decode-enabled");
+    const enabledCb = document.getElementById("background-decode-enabled") as (HTMLInputElement & WiredElement) | null;
     if (enabledCb && !enabledCb._wired) {
       enabledCb._wired = true;
       enabledCb.addEventListener("change", function () { markBgdDirty(); });
     }
 
-    const selectAllBtn = document.getElementById("bgd-select-all-btn");
+    const selectAllBtn = document.getElementById("bgd-select-all-btn") as WiredElement | null;
     if (selectAllBtn && !selectAllBtn._wired) {
       selectAllBtn._wired = true;
       selectAllBtn.addEventListener("click", selectAllBookmarks);
     }
 
-    const deselectAllBtn = document.getElementById("bgd-deselect-all-btn");
+    const deselectAllBtn = document.getElementById("bgd-deselect-all-btn") as WiredElement | null;
     if (deselectAllBtn && !deselectAllBtn._wired) {
       deselectAllBtn._wired = true;
       deselectAllBtn.addEventListener("click", deselectAllBookmarks);
     }
 
-    const saveBtn = document.getElementById("background-decode-save-btn");
+    const saveBtn = document.getElementById("background-decode-save-btn") as WiredElement | null;
     if (saveBtn && !saveBtn._wired) {
       saveBtn._wired = true;
       saveBtn.addEventListener("click", saveBackgroundDecode);
     }
 
-    const resetBtn = document.getElementById("background-decode-reset-btn");
+    const resetBtn = document.getElementById("background-decode-reset-btn") as WiredElement | null;
     if (resetBtn && !resetBtn._wired) {
       resetBtn._wired = true;
-      resetBtn.addEventListener("click", resetBackgroundDecode);
+      resetBtn.addEventListener("click", () => { void resetBackgroundDecode(); });
     }
   }
 
-  window.initBackgroundDecode = initBackgroundDecode;
-  window.wireBackgroundDecodeEvents = wireBackgroundDecodeEvents;
-  window.setBackgroundDecodeRig = setBackgroundDecodeRig;
+  bgdWindow.trx ??= {};
+  bgdWindow.trx.modules ??= {};
+  bgdWindow.trx.modules.backgroundDecode = {
+    initialize: initBackgroundDecode,
+    wireEvents: wireBackgroundDecodeEvents,
+    setRig: setBackgroundDecodeRig,
+  };
 })();

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

@@ -2,83 +2,139 @@
 //
 // 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. */
+interface Bookmark {
+  id: string;
+  name: string;
+  freq_hz: number;
+  mode: string;
+  bandwidth_hz?: number | null;
+  locator?: string | null;
+  category?: string | null;
+  comment?: string | null;
+  decoders?: string[];
+  scope?: string;
+}
+
+interface BookmarkService {
+  readonly overlayList: readonly Bookmark[];
+  readonly overlayRevision: number;
+  refreshOverlay(): Promise<void>;
+  invalidateColors(): void;
+  apply(bookmark: Bookmark): void;
+  formatFrequency(frequencyHz: number): string;
+  fetch(categoryFilter: string): Promise<void>;
+  populateScopePicker(): void;
+}
+interface VirtualChannelService {
+  interceptMode(mode: string): Promise<boolean>;
+  interceptBandwidth(bandwidthHz: number): Promise<boolean>;
+  takeSchedulerControl(): Promise<void>;
+}
+
+interface BookmarkBridge {
+  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;
+}
+
+type BookmarkElement = HTMLElement & HTMLInputElement & HTMLSelectElement;
+const bridge = window as unknown as BookmarkBridge;
+function bmEl(id: string): BookmarkElement {
+  const element = document.getElementById(id);
+  if (!element) throw new Error(`Missing bookmark element #${id}`);
+  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);
+}
+
 // --- 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) {
+function bmScopeParam(prefix: boolean, scope?: string | null): string {
   const sep = prefix ? "&" : "?";
   return sep + "scope=" + encodeURIComponent(scope != null ? scope : bmScope);
 }
 
-var bmList = [];
-var bmRevision = 0;
+let bmList: Bookmark[] = [];
 /** 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 bmOverlayList: Bookmark[] = [];
+let bmOverlayRevision = 0;
+let bmFilteredList: Bookmark[] = [];
+let bmEditScope: string | null = null;
 let bmCurrentPage = 1;
 const BM_PAGE_SIZE = 25;
-const bmSelected = new Set();
+const bmSelected = new Set<string>();
 
-function bmFmtFreq(hz) {
+function bmFmtFreq(hz: number): string {
   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";
+  return `${hz}\u202fHz`;
 }
 
-function bmEsc(str) {
+function bmEsc(str: unknown): string {
   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")
-  );
+  return !hostState.authEnabled || hostState.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");
+  const addBtn = bmEl("bm-add-btn");
+  const selectAllBtn = bmEl("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";
+  return hostState.lastActiveRigId || "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();
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    bmOverlayList = await resp.json() as Bookmark[];
   } catch (e) {
     console.error("Failed to fetch overlay bookmarks:", e);
     bmOverlayList = [];
   }
   bmOverlayRevision++;
-  if (typeof window.syncBookmarkMapLocators === "function") {
-    window.syncBookmarkMapLocators(bmOverlayList);
+  if (typeof bridge.syncBookmarkMapLocators === "function") {
+    bridge.syncBookmarkMapLocators(bmOverlayList);
   }
-  if (typeof scheduleSpectrumDraw === "function") scheduleSpectrumDraw();
+  hostCore.scheduleSpectrumDraw();
 }
 
-async function bmFetch(categoryFilter) {
+async function bmFetch(categoryFilter: string): Promise<void> {
   let url = "/bookmarks";
   let hasQuery = false;
   if (categoryFilter && categoryFilter !== "") {
@@ -89,26 +145,25 @@ async function bmFetch(categoryFilter) {
   const overlayPromise = bmFetchOverlay();
   try {
     const resp = await fetch(url);
-    if (!resp.ok) throw new Error("HTTP " + resp.status);
-    bmList = await resp.json();
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    bmList = await resp.json() as Bookmark[];
   } catch (e) {
     console.error("Failed to fetch bookmarks:", e);
     bmList = [];
   }
-  bmRevision++;
   bmSelected.clear();
   bmUpdateSelectionUi();
   bmSyncAccess();
   bmApplyFilters();
-  bmRefreshCategoryFilter(categoryFilter);
+  void 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();
+  const text = (bmEl("bm-text-filter")?.value || "").trim().toLowerCase();
+  const modeFilter = (bmEl("bm-mode-filter")?.value || "").trim().toUpperCase();
   let filtered = modeFilter
-    ? bmList.filter((bm) => String(bm.mode || "").toUpperCase() === modeFilter)
+    ? bmList.filter((bm) => (bm.mode || "").toUpperCase() === modeFilter)
     : bmList;
   filtered = text
     ? filtered.filter((bm) =>
@@ -123,14 +178,14 @@ function bmApplyFilters() {
   bmRender(filtered);
 }
 
-async function bmRefreshCategoryFilter(keepValue) {
-  const sel = document.getElementById("bm-category-filter");
-  const modeSel = document.getElementById("bm-mode-filter");
+async function bmRefreshCategoryFilter(keepValue: string): Promise<void> {
+  const sel = bmEl("bm-category-filter");
+  const modeSel = bmEl("bm-mode-filter");
   if (!sel && !modeSel) return;
   try {
     const resp = await fetch("/bookmarks" + bmScopeParam(false));
     if (!resp.ok) return;
-    const all = await resp.json();
+    const all = await resp.json() as Bookmark[];
     if (sel) {
       const cats = [...new Set(all.map((b) => b.category || "").filter(Boolean))].sort();
       while (sel.options.length > 1) sel.remove(1);
@@ -144,7 +199,7 @@ async function bmRefreshCategoryFilter(keepValue) {
     }
     if (modeSel) {
       const keepMode = modeSel.value;
-      const modes = [...new Set(all.map((b) => String(b.mode || "").trim().toUpperCase()).filter(Boolean))].sort();
+      const modes = [...new Set(all.map((b) => (b.mode || "").trim().toUpperCase()).filter(Boolean))].sort();
       while (modeSel.options.length > 1) modeSel.remove(1);
       modes.forEach((mode) => {
         const opt = document.createElement("option");
@@ -154,17 +209,17 @@ async function bmRefreshCategoryFilter(keepValue) {
       });
       if (keepMode && modes.includes(keepMode)) modeSel.value = keepMode;
     }
-  } catch (_) {}
+  } 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");
+function bmRender(list: Bookmark[]): void {
+  const tbody = bmEl("bm-tbody");
+  const emptyEl = bmEl("bm-empty");
+  const paginatorEl = bmEl("bm-paginator");
+  const pageSummaryEl = bmEl("bm-page-summary");
+  const pageIndicatorEl = bmEl("bm-page-indicator");
+  const prevBtn = bmEl("bm-page-prev");
+  const nextBtn = bmEl("bm-page-next");
   if (!tbody) return;
   tbody.innerHTML = "";
 
@@ -222,7 +277,7 @@ function bmRender(list) {
   if (nextBtn) nextBtn.disabled = page >= totalPages;
 }
 
-function bmChangePage(delta) {
+function bmChangePage(delta: number): void {
   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;
@@ -231,30 +286,30 @@ function bmChangePage(delta) {
 }
 
 // Read decoder checkboxes and return an array of selected decoder names.
-function bmReadDecoders() {
-  return (window.decoderRegistry || [])
+function bmReadDecoders(): string[] {
+  return hostState.decoderRegistry
     .filter(d => d.bookmark_selectable)
-    .filter(d => document.getElementById("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) {
+function bmWriteDecoders(decoders: readonly string[]): void {
   const set = new Set(decoders || []);
-  (window.decoderRegistry || [])
+  hostState.decoderRegistry
     .filter(d => d.bookmark_selectable)
     .forEach(d => {
-      const el = document.getElementById("bm-dec-" + d.id);
+      const el = bmOptionalEl("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");
+  const container = bmEl("bm-decoder-checkboxes");
   if (!container) return;
   container.innerHTML = "";
-  (window.decoderRegistry || [])
+  hostState.decoderRegistry
     .filter(d => d.bookmark_selectable)
     .forEach(d => {
       const label = document.createElement("label");
@@ -264,75 +319,76 @@ function bmBuildDecoderCheckboxes() {
     });
 }
 
-function bmOpenForm(bm) {
-  const wrap = document.getElementById("bm-form-wrap");
+function bmOpenForm(bm: Bookmark | null): void {
+  const wrap = bmEl("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";
+  bmEl("bm-id").value = bm ? bm.id : "";
+  bmEl("bm-name").value = bm ? bm.name : "";
+  bmEl("bm-freq").value = bm ? String(bm.freq_hz) : "";
+  bmEl("bm-mode").value = bm ? bm.mode : "";
+  bmEl("bm-bw").value = bm?.bandwidth_hz ? String(bm.bandwidth_hz) : "";
+  bmEl("bm-locator").value = bm ? (bm.locator || "") : "";
+  bmEl("bm-category-input").value = bm ? (bm.category || "") : "";
+  bmEl("bm-comment").value = bm ? (bm.comment || "") : "";
+  bmWriteDecoders(bm?.decoders ?? []);
+  bmEl("bm-form-title").textContent = bm ? "Edit Bookmark" : "Add Bookmark";
 
   wrap.style.display = "flex";
-  document.getElementById("bm-name").focus();
+  bmEl("bm-name").focus();
 }
 
 function bmCloseForm() {
-  const wrap = document.getElementById("bm-form-wrap");
+  const wrap = bmEl("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);
+  // Read live rig state from the host contract (updated by the SSE stream).
+  const freqHz = hostState.lastFreqHz;
+  if (freqHz != null && Number.isFinite(freqHz)) {
+    bmEl("bm-freq").value = String(Math.round(freqHz));
   }
-  if (typeof lastModeName === "string" && lastModeName) {
-    document.getElementById("bm-mode").value = lastModeName;
+  if (hostState.lastModeName) {
+    bmEl("bm-mode").value = hostState.lastModeName;
   }
-  if (typeof currentBandwidthHz === "number" && currentBandwidthHz > 0) {
-    document.getElementById("bm-bw").value = Math.round(currentBandwidthHz);
+  if (hostState.currentBandwidthHz > 0) {
+    bmEl("bm-bw").value = String(Math.round(hostState.currentBandwidthHz));
   }
   // Prefill decoder checkboxes from current toggle button state.
-  const activeDecoders = (window.decoderRegistry || [])
+  const activeDecoders = hostState.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";
-    })
+    .filter(d => bmOptionalEl(d.id + "-decode-toggle-btn")?.dataset.enabled === "true")
     .map(d => d.id);
   bmWriteDecoders(activeDecoders);
 }
 
-async function bmSave(e) {
+async function bmSave(e: Event): Promise<void> {
   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 id = bmEl("bm-id").value;
+  const name = bmEl("bm-name").value.trim();
+  const freqStr = bmEl("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 mode = bmEl("bm-mode").value.trim();
+  const bwStr = bmEl("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 locator = bmEl("bm-locator").value.trim().toUpperCase();
+  const category = bmEl("bm-category-input").value.trim();
+  const comment = bmEl("bm-comment").value.trim();
   const decoders = bmReadDecoders();
 
+  const formError = bmEl("bm-form-error");
+  if (formError) formError.textContent = "";
   if (!name || !Number.isFinite(freq_hz) || !mode) {
-    alert("Name, Frequency, and Mode are required.");
+    if (formError) formError.textContent = "Enter a name, a valid frequency, and a mode.";
+    const invalid = !name ? bmEl("bm-name")
+      : !Number.isFinite(freq_hz) ? bmEl("bm-freq") : bmEl("bm-mode");
+    invalid?.focus();
     return;
   }
 
@@ -367,90 +423,74 @@ async function bmSave(e) {
       if (resp.status === 409) {
         throw new Error("A bookmark for that frequency already exists.");
       }
-      throw new Error(text || "HTTP " + resp.status);
+      throw new Error(text || `HTTP ${resp.status}`);
     }
     bmCloseForm();
-    await bmFetch(document.getElementById("bm-category-filter").value);
+    await bmFetch(bmEl("bm-category-filter").value);
   } catch (err) {
     console.error("Failed to save bookmark:", err);
-    alert("Failed to save bookmark: " + err.message);
+    if (formError) formError.textContent = "Failed to save bookmark: " + errorMessage(err);
+    bridge.trxUi.notify?.("Bookmark could not be saved", { kind: "error" });
   }
 }
 
-async function bmDelete(id) {
-  if (!confirm("Delete this bookmark?")) return;
+async function bmDelete(id: string): Promise<void> {
+  if (!await bridge.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);
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    await bmFetch(bmEl("bm-category-filter").value);
   } catch (err) {
     console.error("Failed to delete bookmark:", err);
-    alert("Failed to delete bookmark: " + err.message);
+    bridge.trxUi.notify?.("Failed to delete bookmark: " + errorMessage(err), { kind: "error" });
   }
 }
 
-async function bmApply(bm) {
+function bmApply(bm: Bookmark): void {
   try {
     // --- Optimistic UI updates (instant, before any network round-trips) ---
-    if (typeof modeEl !== "undefined" && modeEl) {
-      modeEl.value = String(bm.mode || "").toUpperCase();
+    const modeEl = document.getElementById("mode") as HTMLSelectElement | null;
+    if (modeEl) {
+      modeEl.value = (bm.mode || "").toUpperCase();
     }
     if (bm.bandwidth_hz) {
-      if (typeof currentBandwidthHz !== "undefined") {
-        currentBandwidthHz = bm.bandwidth_hz;
+      hostState.currentBandwidthHz = bm.bandwidth_hz;
+      hostCore.syncBandwidthInput(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;
-      }
+    hostCore.armOptimisticFrequency(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();
+    hostCore.applyLocalTunedFrequency(bm.freq_hz, true);
+    if (hostState.lastSpectrumData) {
+      hostCore.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();
-      }
+      await bridge.trx.modules.vchan?.takeSchedulerControl();
 
-      const onVirtual = typeof vchanInterceptMode === "function"
-        && await vchanInterceptMode(bm.mode);
+      const onVirtual = await bridge.trx.modules.vchan?.interceptMode(bm.mode) ?? false;
       if (!onVirtual) {
-        await postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
+        await hostCore.postPath("/set_mode?mode=" + encodeURIComponent(bm.mode));
       }
 
       if (bm.bandwidth_hz) {
-        const bwHandledByVchan = typeof vchanInterceptBandwidth === "function"
-          && await vchanInterceptBandwidth(bm.bandwidth_hz);
+        const bwHandledByVchan =
+          await bridge.trx.modules.vchan?.interceptBandwidth(bm.bandwidth_hz) ?? false;
         if (!bwHandledByVchan) {
-          await postPath("/set_bandwidth?hz=" + bm.bandwidth_hz);
+          await hostCore.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);
-      }
+      // setRigFrequency redirects to the channel API when a virtual channel is
+      // active.  It repeats the optimistic update applied above, which is a
+      // no-op because the value is unchanged.
+      hostCore.setRigFrequency(bm.freq_hz);
     })();
     // Decoder toggles — fire-and-forget.
     //  - Decoders incompatible with the new mode are always turned off
@@ -460,18 +500,19 @@ async function bmApply(bm) {
     //    alone.
     const hasDecoders = Array.isArray(bm.decoders) && bm.decoders.length > 0;
     const modeUp = (bm.mode || "").toUpperCase();
-    const allToggleDecoders = (window.decoderRegistry || []).filter(d =>
+    const allToggleDecoders = hostState.decoderRegistry.filter(d =>
       d.activation === "toggle"
     );
     const decoderPromise = allToggleDecoders.length ? (async () => {
       let statusUrl = "/status";
-      if (typeof lastActiveRigId !== "undefined" && lastActiveRigId) {
-        statusUrl += "?remote=" + encodeURIComponent(lastActiveRigId);
+      const rigId = hostState.lastActiveRigId;
+      if (rigId) {
+        statusUrl += "?remote=" + encodeURIComponent(rigId);
       }
       const statusResp = await fetch(statusUrl);
       if (!statusResp.ok) return;
-      const st = await statusResp.json();
-      const toggles = [];
+      const st = await statusResp.json() as Record<string, unknown>;
+      const toggles: Promise<unknown>[] = [];
       for (const d of allToggleDecoders) {
         const statusKey = d.id.replace(/-/g, "_") + "_decode_enabled";
         const currentlyOn = !!st[statusKey];
@@ -482,41 +523,52 @@ async function bmApply(bm) {
           // Always disable decoders that don't apply to the new mode.
           wanted = false;
         } else if (hasDecoders) {
-          wanted = bm.decoders.includes(d.id);
+          wanted = bm.decoders?.includes(d.id) ?? false;
         } else {
           // Mode-compatible and no bookmark selection: leave as-is.
           wanted = currentlyOn;
         }
         if (wanted !== currentlyOn) {
-          toggles.push(postPath("/toggle_" + d.id.replace(/-/g, "_") + "_decode"));
+          toggles.push(hostCore.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)
-    );
+    void Promise.all([tunePromise, decoderPromise]).catch((error: unknown) => {
+      console.error("Bookmark apply background error:", error);
+    });
   } catch (err) {
     console.error("Failed to apply bookmark:", err);
   }
 }
 
+bridge.trx.modules.bookmarks = {
+  get overlayList() { return bmOverlayList; },
+  get overlayRevision() { return bmOverlayRevision; },
+  refreshOverlay: bmFetchOverlay,
+  invalidateColors() { bmOverlayRevision += 1; },
+  apply: bmApply,
+  formatFrequency: bmFmtFreq,
+  fetch: bmFetch,
+  populateScopePicker: bmPopulateScopePicker,
+};
+
 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");
+  const btn = bmEl("bm-del-selected-btn");
+  const countEl = bmEl("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 (countEl) countEl.textContent = String(count);
+  const moveWrap = bmEl("bm-move-selected-wrap");
+  const moveCountEl = bmEl("bm-move-selected-count");
   if (moveWrap) moveWrap.style.display = visible ? "" : "none";
-  if (moveCountEl) moveCountEl.textContent = count;
+  if (moveCountEl) moveCountEl.textContent = String(count);
   if (visible) bmPopulateMoveTarget();
-  const selectAllBtn = document.getElementById("bm-select-all-btn");
+  const selectAllBtn = bmEl("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";
@@ -525,10 +577,10 @@ function bmUpdateSelectionUi() {
 
 /** Populate the move-target dropdown with all scopes except the current one. */
 function bmPopulateMoveTarget() {
-  const sel = document.getElementById("bm-move-target");
+  const sel = bmEl("bm-move-target");
   if (!sel) return;
-  const rigIds = (typeof lastRigIds !== "undefined" && Array.isArray(lastRigIds)) ? lastRigIds : [];
-  const displayNames = (typeof lastRigDisplayNames !== "undefined") ? lastRigDisplayNames : {};
+  const rigIds = hostState.lastRigIds;
+  const displayNames = hostState.lastRigDisplayNames;
   const prev = sel.value;
   sel.innerHTML = "";
   if (bmScope !== "general") {
@@ -552,13 +604,18 @@ function bmPopulateMoveTarget() {
 async function bmMoveSelected() {
   const ids = Array.from(bmSelected);
   if (ids.length === 0) return;
-  const target = document.getElementById("bm-move-target")?.value;
+  const target = bmEl("bm-move-target")?.value;
   if (!target) return;
-  const targetLabel = document.getElementById("bm-move-target")?.selectedOptions[0]?.textContent || target;
-  if (!confirm(`Move ${ids.length} bookmark${ids.length > 1 ? "s" : ""} to "${targetLabel}"?`)) return;
+  const targetLabel = bmEl("bm-move-target")?.selectedOptions[0]?.textContent || target;
+  if (!await bridge.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 = {};
+    const byScope: Record<string, string[]> = {};
     for (const id of ids) {
       const bm = bmList.find((b) => b.id === id);
       const scope = bm?.scope || bmScope;
@@ -570,21 +627,21 @@ async function bmMoveSelected() {
         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); })
+      }).then((r) => { if (!r.ok) throw new Error(`HTTP ${r.status}`); })
     ));
     bmSelected.clear();
     bmUpdateSelectionUi();
-    await bmFetch(document.getElementById("bm-category-filter").value);
+    await bmFetch(bmEl("bm-category-filter").value);
   } catch (err) {
     console.error("Failed to move bookmarks:", err);
-    alert("Failed to move bookmarks: " + err.message);
+    bridge.trxUi.notify?.("Failed to move bookmarks: " + errorMessage(err), { kind: "error" });
   }
 }
 
 function bmSyncSelectAllCheckbox() {
-  const selectAll = document.getElementById("bm-select-all");
+  const selectAll = bmEl("bm-select-all");
   if (!selectAll) return;
-  const checkboxes = document.querySelectorAll(".bm-row-sel");
+  const checkboxes = document.querySelectorAll<HTMLInputElement>(".bm-row-sel");
   if (checkboxes.length === 0) {
     selectAll.checked = false;
     selectAll.indeterminate = false;
@@ -598,10 +655,14 @@ function bmSyncSelectAllCheckbox() {
 async function bmDeleteSelected() {
   const ids = Array.from(bmSelected);
   if (ids.length === 0) return;
-  if (!confirm(`Delete ${ids.length} selected bookmark${ids.length > 1 ? "s" : ""}?`)) return;
+  if (!await bridge.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 = {};
+    const byScope: Record<string, string[]> = {};
     for (const id of ids) {
       const bm = bmList.find((b) => b.id === id);
       const scope = bm?.scope || bmScope;
@@ -612,23 +673,23 @@ async function bmDeleteSelected() {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ ids: scopeIds }),
-      }).then((r) => { if (!r.ok) throw new Error("HTTP " + r.status); })
+      }).then((r) => { if (!r.ok) throw new Error(`HTTP ${r.status}`); })
     ));
     bmSelected.clear();
     bmUpdateSelectionUi();
-    await bmFetch(document.getElementById("bm-category-filter").value);
+    await bmFetch(bmEl("bm-category-filter").value);
   } catch (err) {
     console.error("Failed to delete bookmarks:", err);
-    alert("Failed to delete bookmarks: " + err.message);
+    bridge.trxUi.notify?.("Failed to delete bookmarks: " + errorMessage(err), { kind: "error" });
   }
 }
 
 /** Populate the scope picker with "General" + one option per rig. */
 function bmPopulateScopePicker() {
-  const picker = document.getElementById("bm-scope-picker");
+  const picker = bmEl("bm-scope-picker");
   if (!picker) return;
-  const rigIds = (typeof lastRigIds !== "undefined" && Array.isArray(lastRigIds)) ? lastRigIds : [];
-  const displayNames = (typeof lastRigDisplayNames !== "undefined") ? lastRigDisplayNames : {};
+  const rigIds = hostState.lastRigIds;
+  const displayNames = hostState.lastRigDisplayNames;
   // Preserve current selection if still valid.
   const prev = picker.value;
   while (picker.options.length > 1) picker.remove(1);
@@ -655,63 +716,61 @@ 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 window.onDecoderRegistryReady === "function") {
-    window.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
-  }
+  hostCore.onDecoderRegistryReady(bmBuildDecoderCheckboxes);
 
   // Scope picker
   bmPopulateScopePicker();
-  const scopePicker = document.getElementById("bm-scope-picker");
+  const scopePicker = bmEl("bm-scope-picker");
   if (scopePicker) {
     scopePicker.addEventListener("change", (e) => {
-      bmScope = e.target.value;
-      bmFetch(document.getElementById("bm-category-filter")?.value || "");
+      bmScope = (e.currentTarget as HTMLSelectElement).value;
+      void bmFetch(bmEl("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"]');
+  document.querySelector(".tab-bar")?.addEventListener("click", (e) => {
+    const btn = e.target instanceof Element ? e.target.closest('.tab[data-tab="bookmarks"]') : null;
     if (!btn) return;
-    bmFetch(document.getElementById("bm-category-filter").value);
+    void bmFetch(bmEl("bm-category-filter").value);
   });
 
   // Add Bookmark button — open form and prefill from current rig state
-  document.getElementById("bm-add-btn").addEventListener("click", () => {
+  bmEl("bm-add-btn").addEventListener("click", () => {
     bmOpenForm(null);
     bmPrefillFromStatus();
   });
 
   // Category filter dropdown
-  document.getElementById("bm-category-filter").addEventListener("change", (e) => {
-    bmFetch(e.target.value);
+  bmEl("bm-category-filter").addEventListener("change", (e) => {
+    void bmFetch((e.currentTarget as HTMLSelectElement).value);
   });
 
   // Mode filter dropdown (client-side, no re-fetch)
-  document.getElementById("bm-mode-filter").addEventListener("change", () => {
+  bmEl("bm-mode-filter").addEventListener("change", () => {
     bmApplyFilters();
   });
 
   // Text search filter (client-side, no re-fetch)
-  document.getElementById("bm-text-filter").addEventListener("input", () => {
+  bmEl("bm-text-filter").addEventListener("input", () => {
     bmApplyFilters();
   });
 
-  document.getElementById("bm-page-prev").addEventListener("click", () => {
+  bmEl("bm-page-prev").addEventListener("click", () => {
     bmChangePage(-1);
   });
 
-  document.getElementById("bm-page-next").addEventListener("click", () => {
+  bmEl("bm-page-next").addEventListener("click", () => {
     bmChangePage(1);
   });
 
   // Form submit
-  document.getElementById("bm-form").addEventListener("submit", bmSave);
+  bmEl("bm-form").addEventListener("submit", (event) => { void bmSave(event); });
 
   // Form cancel
-  document.getElementById("bm-form-cancel").addEventListener("click", bmCloseForm);
+  bmEl("bm-form-cancel").addEventListener("click", bmCloseForm);
 
-  const formWrap = document.getElementById("bm-form-wrap");
+  const formWrap = bmEl("bm-form-wrap");
   if (formWrap) {
     formWrap.addEventListener("click", (e) => {
       if (e.target === formWrap) bmCloseForm();
@@ -719,24 +778,26 @@ function bmPopulateScopePicker() {
   }
 
   document.addEventListener("keydown", (e) => {
-    if (e.key === "Escape" && document.getElementById("bm-form-wrap")?.style.display === "flex") {
+    if (e.key === "Escape" && bmEl("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) => {
+  bmEl("bm-select-all").addEventListener("change", (e) => {
+    const checked = (e.currentTarget as HTMLInputElement).checked;
+    document.querySelectorAll<HTMLInputElement>(".bm-row-sel").forEach((cb) => {
       cb.checked = checked;
-      if (checked) bmSelected.add(cb.dataset.bmId);
-      else bmSelected.delete(cb.dataset.bmId);
+      const id = cb.dataset.bmId;
+      if (!id) return;
+      if (checked) bmSelected.add(id);
+      else bmSelected.delete(id);
     });
     bmUpdateSelectionUi();
   });
 
   // Select All (across all pages) button
-  document.getElementById("bm-select-all-btn").addEventListener("click", () => {
+  bmEl("bm-select-all-btn").addEventListener("click", () => {
     const allSelected = bmFilteredList.length > 0 && bmFilteredList.every((bm) => bmSelected.has(bm.id));
     if (allSelected) {
       bmSelected.clear();
@@ -744,49 +805,53 @@ function bmPopulateScopePicker() {
       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);
+    document.querySelectorAll<HTMLInputElement>(".bm-row-sel").forEach((cb) => {
+      cb.checked = !!cb.dataset.bmId && bmSelected.has(cb.dataset.bmId);
     });
     bmSyncSelectAllCheckbox();
     bmUpdateSelectionUi();
   });
 
   // Delete Selected button
-  document.getElementById("bm-del-selected-btn").addEventListener("click", () => {
-    bmDeleteSelected();
+  bmEl("bm-del-selected-btn").addEventListener("click", () => {
+    void bmDeleteSelected();
   });
 
   // Move Selected button
-  document.getElementById("bm-move-selected-btn").addEventListener("click", () => {
-    bmMoveSelected();
+  bmEl("bm-move-selected-btn").addEventListener("click", () => {
+    void 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");
+  bmEl("bm-tbody").addEventListener("click", (e) => { void (async () => {
+    if (!(e.target instanceof Element)) return;
+    const checkbox = e.target.closest<HTMLInputElement>(".bm-row-sel");
     if (checkbox) {
-      if (checkbox.checked) bmSelected.add(checkbox.dataset.bmId);
-      else bmSelected.delete(checkbox.dataset.bmId);
+      const id = checkbox.dataset.bmId;
+      if (!id) return;
+      if (checkbox.checked) bmSelected.add(id);
+      else bmSelected.delete(id);
       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");
+    const tuneBtn = e.target.closest<HTMLElement>(".bm-tune-btn");
+    const editBtn = e.target.closest<HTMLElement>(".bm-edit-btn");
+    const delBtn = e.target.closest<HTMLElement>(".bm-del-btn");
 
     if (tuneBtn) {
       const bm = bmList.find((b) => b.id === tuneBtn.dataset.bmId);
-      if (bm) await bmApply(bm);
+      if (bm) 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);
+      const id = delBtn.dataset.bmId;
+      if (id) await bmDelete(id);
     }
-  });
+  })(); });
 
   // Pre-load bookmarks so spectrum markers are visible immediately.
-  bmFetch("");
+  void bmFetch("");
 })();

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

@@ -2,16 +2,56 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore } from "./host.js";
+
+import type { PluginRuntimeWindow } from "./runtime-contract.js";
+
+export {};
+
+type Rgba = [number, number, number, number];
+interface CwRenderer {
+  ready: boolean;
+  ensureSize(width: number, height: number, dpr: number): boolean;
+  clear(color: Rgba): void;
+  fillRect(x: number, y: number, width: number, height: number, color: Rgba): void;
+  drawSegments(points: number[], color: Rgba, width: number): void;
+  drawFilledArea(points: number[], baseline: number, color: Rgba): void;
+  drawPolyline(points: number[], color: Rgba, width: number): void;
+  drawPoints(points: number[], size: number, color: Rgba): void;
+}
+interface CwSpectrum { bins: number[]; sample_rate: number; center_hz: number }
+interface CwEvent { text?: string; wpm?: number; tone_hz?: number; signal_on?: boolean }
+interface CwLine { tsMs: number; ts: string; text: string; wpm: number | null; tone_hz: number | null; lastMs: number }
+interface CwToneRange {
+  tunedHz: number; bandwidthHz: number; toneMinHz: number; toneMaxHz: number;
+  toneSpanHz: number; lowerSideband: boolean; mode: string;
+}
+interface CwBridge {
+  createTrxWebGlRenderer?: (canvas: HTMLCanvasElement, options: WebGLContextAttributes) => CwRenderer;
+  trxParseCssColor?: (color: string) => Rgba;
+  lastFreqHz?: number;
+  currentBandwidthHz?: number;
+  lastSpectrumData?: CwSpectrum;
+  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
+  applyCwAutoUi?: (enabled: boolean) => void;
+  applyCwAutoUiFromServer?: (enabled: boolean) => void;
+  updateCwBar?: () => void;
+  clearCwBar?: () => void;
+  closeCwBar?: () => void;
+  refreshCwTonePicker?: () => void;
+}
+const cwWindow = window as unknown as CwBridge & PluginRuntimeWindow;
+
 // --- 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 cwAutoInput = document.getElementById("cw-auto") as HTMLInputElement | null;
+const cwWpmInput = document.getElementById("cw-wpm") as HTMLInputElement | null;
+const cwToneInput = document.getElementById("cw-tone") as HTMLInputElement | null;
 const cwSignalIndicator = document.getElementById("cw-signal-indicator");
-const cwToneCanvas = document.getElementById("cw-tone-waterfall");
-const cwToneGl = typeof createTrxWebGlRenderer === "function"
-  ? createTrxWebGlRenderer(cwToneCanvas, { alpha: true })
+const cwToneCanvas = document.getElementById("cw-tone-waterfall") as HTMLCanvasElement | null;
+const cwToneGl = cwToneCanvas && cwWindow.createTrxWebGlRenderer
+  ? cwWindow.createTrxWebGlRenderer(cwToneCanvas, { alpha: true })
   : null;
 const cwTonePickerEl = document.querySelector(".cw-tone-picker");
 const cwToneRangeEl = document.getElementById("cw-tone-range");
@@ -24,17 +64,21 @@ 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 cwTonePickerRaf: number | null = null;
+let cwBarHistory: CwLine[] = [];
+let cwBarCurrentLine: CwLine | null = null;
 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;
+let cwAutoLocalOverride: boolean | null = null;
 
-function applyCwAutoUi(enabled) {
+function escapeCwHtml(input: string): string {
+  return hostCore.escapeMapHtml(input);
+}
+
+function applyCwAutoUi(enabled: boolean): void {
   if (cwAutoInput) cwAutoInput.checked = enabled;
   if (cwWpmInput) {
     cwWpmInput.disabled = enabled;
@@ -48,16 +92,16 @@ function applyCwAutoUi(enabled) {
     cwTonePickerEl.classList.toggle("is-auto", enabled);
   }
 }
-window.applyCwAutoUi = applyCwAutoUi;
+cwWindow.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) {
+cwWindow.applyCwAutoUiFromServer = function(enabled: boolean) {
   if (cwAutoLocalOverride !== null) return;
   applyCwAutoUi(enabled);
 };
 
-function cwBarFlushCurrentLine() {
+function cwBarFlushCurrentLine(): void {
   if (cwBarCurrentLine && cwBarCurrentLine.text.trim()) {
     cwBarHistory.unshift(cwBarCurrentLine);
     if (cwBarHistory.length > 50) cwBarHistory.length = 50;
@@ -65,15 +109,15 @@ function cwBarFlushCurrentLine() {
   cwBarCurrentLine = null;
 }
 
-function updateCwBar() {
+function updateCwBar(): void {
   if (!cwBarOverlay) return;
-  const mode = (document.getElementById("mode")?.value || "").toUpperCase();
+  const mode = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase();
   const isCw = mode === "CW" || mode === "CWR";
   const cutoffMs = Date.now() - CW_BAR_WINDOW_MS;
   const recent = cwBarHistory.filter((l) => l.tsMs >= cutoffMs);
   // Prepend the in-progress line so characters appear immediately
   const liveLines = cwBarCurrentLine && cwBarCurrentLine.text ? [cwBarCurrentLine, ...recent] : recent;
-  const newestTsMs = liveLines.reduce((latest, line) => Math.max(latest, Number(line.tsMs) || 0), 0);
+  const newestTsMs = liveLines.reduce((latest, line) => Math.max(latest, line.tsMs || 0), 0);
   if (!isCw || liveLines.length === 0 || newestTsMs <= cwBarDismissedAtMs) {
     cwBarOverlay.style.display = "none";
     cwBarOverlay.innerHTML = "";
@@ -94,22 +138,22 @@ function updateCwBar() {
   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,
+      line.wpm ? `${String(line.wpm)} WPM` : null,
+      line.tone_hz ? `${String(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 class="aprs-bar-frame-main">${ts}${escapeCwHtml(line.text)}` +
+      (meta ? ` <span class="aprs-bar-time">${escapeCwHtml(meta)}</span>` : "") +
       `</div></div>`;
   }
   cwBarOverlay.innerHTML = html;
   cwBarOverlay.style.display = "flex";
 }
-window.updateCwBar = updateCwBar;
-window.clearCwBar = function() {
-  window.resetCwHistoryView();
+cwWindow.updateCwBar = updateCwBar;
+cwWindow.clearCwBar = function() {
+  resetCwHistoryView();
 };
-window.closeCwBar = function() {
+cwWindow.closeCwBar = function() {
   cwBarDismissedAtMs = Date.now();
   if (cwBarOverlay) {
     cwBarOverlay.style.display = "none";
@@ -117,34 +161,31 @@ window.closeCwBar = function() {
   }
 };
 
-function clampCwWpm(wpm) {
+function clampCwWpm(wpm: unknown): number {
   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) {
+function clampCwTone(tone: unknown): number {
   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;
+function currentCwToneRange(): CwToneRange | null {
+  const tunedHz = Number.isFinite(cwWindow.lastFreqHz) ? Number(cwWindow.lastFreqHz) : NaN;
+  const bandwidthHz = Number.isFinite(cwWindow.currentBandwidthHz) ? Number(cwWindow.currentBandwidthHz) : NaN;
   if (!Number.isFinite(tunedHz) || !Number.isFinite(bandwidthHz) || bandwidthHz <= 0) {
     return null;
   }
-  const mode = String(document.getElementById("mode")?.value || "").toUpperCase();
+  const mode = ((document.getElementById("mode") as HTMLSelectElement | null)?.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,
@@ -156,20 +197,20 @@ function currentCwToneRange() {
   };
 }
 
-function cwToneToRfHz(range, toneHz) {
+function cwToneToRfHz(range: CwToneRange | null, toneHz: number): number {
   if (!range) return NaN;
   return range.lowerSideband
     ? range.tunedHz - toneHz
     : range.tunedHz + toneHz;
 }
 
-function toneClampForRange(tone, range) {
+function toneClampForRange(tone: unknown, range: CwToneRange | null): number {
   const clamped = clampCwTone(tone);
   if (!range) return clamped;
   return Math.max(range.toneMinHz, Math.min(range.toneMaxHz, clamped));
 }
 
-function ensureCwToneCanvasResolution() {
+function ensureCwToneCanvasResolution(): boolean {
   if (!cwToneCanvas || !cwToneGl || !cwToneGl.ready) return false;
   const rect = cwToneCanvas.getBoundingClientRect();
   const cssWidth = Math.round(rect.width);
@@ -181,7 +222,7 @@ function ensureCwToneCanvasResolution() {
   return cwToneGl.ensureSize(cssWidth, cssHeight, dpr);
 }
 
-function drawCwTonePicker() {
+function drawCwTonePicker(): void {
   if (!cwToneCanvas || !cwToneGl || !cwToneGl.ready) return;
   ensureCwToneCanvasResolution();
   if (cwToneCanvas.width < 8 || cwToneCanvas.height < 8) return;
@@ -190,12 +231,12 @@ function drawCwTonePicker() {
   cwToneGl.clear([0, 0, 0, 0]);
 
   const range = currentCwToneRange();
-  if (!window.lastSpectrumData || !Array.isArray(window.lastSpectrumData.bins) || !window.lastSpectrumData.bins.length || !range) {
+  if (!cwWindow.lastSpectrumData || !Array.isArray(cwWindow.lastSpectrumData.bins) || !cwWindow.lastSpectrumData.bins.length || !range) {
     if (cwToneRangeEl) {
-      const mode = String(document.getElementById("mode")?.value || "").toUpperCase();
+      const mode = ((document.getElementById("mode") as HTMLSelectElement | null)?.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) {
+      } else if (!cwWindow.lastSpectrumData || !Array.isArray(cwWindow.lastSpectrumData.bins) || !cwWindow.lastSpectrumData.bins.length) {
         cwToneRangeEl.textContent = "Waiting for spectrum";
       }
     }
@@ -205,15 +246,15 @@ function drawCwTonePicker() {
 
   if (cwToneRangeEl) {
     const side = range.lowerSideband ? "Lower side" : "Upper side";
-    cwToneRangeEl.textContent = `Audio ${range.toneMinHz}-${range.toneMaxHz} Hz · ${side}`;
+    cwToneRangeEl.textContent = `Audio ${String(range.toneMinHz)}-${String(range.toneMaxHz)} Hz · ${side}`;
   }
 
-  const bins = window.lastSpectrumData.bins;
-  const sampleRate = Number(window.lastSpectrumData.sample_rate);
-  const centerHz = Number(window.lastSpectrumData.center_hz);
+  const bins = cwWindow.lastSpectrumData.bins;
+  const sampleRate = cwWindow.lastSpectrumData.sample_rate;
+  const centerHz = cwWindow.lastSpectrumData.center_hz;
   const maxIdx = Math.max(1, bins.length - 1);
   const fullLoHz = centerHz - sampleRate / 2;
-  const tones = new Array(width).fill(-140);
+  const tones: number[] = new Array<number>(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;
@@ -223,17 +264,17 @@ function drawCwTonePicker() {
     tones[x] = power;
   }
 
-  const smoothed = new Array(width).fill(-140);
+  const smoothed: number[] = new Array<number>(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];
+      sum += tones[i] ?? -140;
       count += 1;
     }
-    smoothed[x] = count > 0 ? sum / count : tones[x];
+    smoothed[x] = count > 0 ? sum / count : tones[x] ?? -140;
   }
 
   const sorted = smoothed.slice().sort((a, b) => a - b);
@@ -242,23 +283,23 @@ function drawCwTonePicker() {
   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 yForDb = (db: number): number => {
     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
+  const parseColor = typeof cwWindow.trxParseCssColor === "function"
+    ? cwWindow.trxParseCssColor
     : null;
-  const accentRgba = parseColor ? parseColor(accent) : [0, 0.82, 0.5, 1];
-  const axisColor = [230 / 255, 235 / 255, 245 / 255, 0.15];
+  const accentRgba: Rgba = parseColor ? parseColor(accent) : [0, 0.82, 0.5, 1];
+  const axisColor: Rgba = [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 = [];
+  const gridSegments: number[] = [];
   for (let i = 1; i <= hGridCount; i += 1) {
     const y = Math.round((i / (hGridCount + 1)) * (height - 1));
     gridSegments.push(0, y, width, y);
@@ -267,7 +308,7 @@ function drawCwTonePicker() {
 
   const toneStep = range.toneSpanHz <= 500 ? 50 : range.toneSpanHz <= 1000 ? 100 : 200;
   const firstTick = Math.ceil(range.toneMinHz / toneStep) * toneStep;
-  const tickSegments = [];
+  const tickSegments: number[] = [];
   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))));
@@ -275,9 +316,9 @@ function drawCwTonePicker() {
   }
   cwToneGl.drawSegments(tickSegments, axisColor, 1);
 
-  const linePoints = [];
+  const linePoints: number[] = [];
   for (let x = 0; x < width; x += 1) {
-    linePoints.push(x, yForDb(smoothed[x]));
+    linePoints.push(x, yForDb(smoothed[x] ?? -140));
   }
   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));
@@ -285,7 +326,7 @@ function drawCwTonePicker() {
   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))]);
+  const markerY = yForDb(smoothed[Math.max(0, Math.min(width - 1, markerX))] ?? -140);
   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]);
 
@@ -294,14 +335,14 @@ function drawCwTonePicker() {
   }
 }
 
-async function setCwTone(tone, { syncInput = true } = {}) {
+async function setCwTone(tone: unknown, { syncInput = true }: { syncInput?: boolean } = {}): Promise<void> {
   const range = currentCwToneRange();
   const clamped = toneClampForRange(tone, range);
   if (cwToneInput && syncInput) {
-    cwToneInput.value = clamped;
+    cwToneInput.value = String(clamped);
   }
   try {
-    await 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);
   }
@@ -309,40 +350,43 @@ async function setCwTone(tone, { syncInput = true } = {}) {
 }
 
 if (cwAutoInput) {
-  cwAutoInput.addEventListener("change", async () => {
+  cwAutoInput.addEventListener("change", () => {
+    void (async () => {
       const enabled = cwAutoInput.checked;
       cwAutoLocalOverride = enabled;
       applyCwAutoUi(enabled);
       try {
-      await postPath(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
+        await hostCore.postPath(`/set_cw_auto?enabled=${enabled ? "true" : "false"}`);
         drawCwTonePicker();
-    } catch (e) {
-      console.error("CW auto toggle failed", e);
+      } catch (error: unknown) {
+        console.error("CW auto toggle failed", error);
       } finally {
         cwAutoLocalOverride = null;
       }
+    })();
   });
 }
 
 if (cwWpmInput) {
-  cwWpmInput.addEventListener("change", async () => {
-    if (cwAutoInput && cwAutoInput.checked) return;
+  cwWpmInput.addEventListener("change", () => {
+    void (async () => {
+      if (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); }
+      cwWpmInput.value = String(wpm);
+      try { await hostCore.postPath(`/set_cw_wpm?wpm=${encodeURIComponent(wpm)}`); }
+      catch (error: unknown) { console.error("CW WPM set failed", error); }
+    })();
   });
 }
 
 if (cwToneInput) {
-  cwToneInput.addEventListener("change", async () => {
-    if (cwAutoInput?.checked) return;
-    await setCwTone(cwToneInput.value);
+  cwToneInput.addEventListener("change", () => {
+    if (!cwAutoInput?.checked) void setCwTone(cwToneInput.value);
   });
 }
 
 if (cwToneCanvas) {
-  cwToneCanvas.addEventListener("click", async (event) => {
+  cwToneCanvas.addEventListener("click", (event) => {
     if (cwAutoInput?.checked) return;
     const rect = cwToneCanvas.getBoundingClientRect();
     if (rect.width <= 0) return;
@@ -350,31 +394,33 @@ if (cwToneCanvas) {
     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);
+    void setCwTone(tone);
   });
 }
 
-window.resetCwHistoryView = function() {
+function resetCwHistoryView(): void {
   if (cwOutputEl) cwOutputEl.innerHTML = "";
   cwLastAppendTime = 0;
   cwBarHistory = [];
   cwBarCurrentLine = null;
   updateCwBar();
   drawCwTonePicker();
-};
+}
 
-document.getElementById("settings-clear-cw-history")?.addEventListener("click", async () => {
-  if (!confirm("Clear all CW decode history? This cannot be undone.")) return;
+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 postPath("/clear_cw_decode");
-    window.resetCwHistoryView();
-  } catch (e) {
-    console.error("CW history clear failed", e);
+      await hostCore.postPath("/clear_cw_decode");
+      resetCwHistoryView();
+    } catch (error: unknown) {
+      console.error("CW history clear failed", error);
     }
+  })();
 });
 
 // --- Server-side CW decode handler ---
-window.onServerCw = function(evt) {
+function onServerCw(evt: CwEvent): void {
   if (cwStatusEl) cwStatusEl.textContent = "Receiving";
   if (evt.text && cwOutputEl) {
     // Append decoded text to output
@@ -390,7 +436,9 @@ window.onServerCw = function(evt) {
       lastLine.textContent += evt.text;
     }
     while (cwOutputEl.children.length > CW_MAX_LINES) {
-      cwOutputEl.removeChild(cwOutputEl.firstChild);
+      const firstChild = cwOutputEl.firstChild;
+      if (!firstChild) break;
+      cwOutputEl.removeChild(firstChild);
     }
     cwOutputEl.scrollTop = cwOutputEl.scrollHeight;
   }
@@ -417,10 +465,10 @@ window.onServerCw = function(evt) {
   }
   if (!cwAutoInput || cwAutoInput.checked) {
     if (cwWpmInput && Number.isFinite(Number(evt.wpm))) {
-      cwWpmInput.value = clampCwWpm(evt.wpm);
+      cwWpmInput.value = String(clampCwWpm(evt.wpm));
     }
     if (cwToneInput && Number.isFinite(Number(evt.tone_hz))) {
-      cwToneInput.value = toneClampForRange(evt.tone_hz, currentCwToneRange());
+      cwToneInput.value = String(toneClampForRange(evt.tone_hz, currentCwToneRange()));
     }
   }
   if (cwTonePickerRaf != null) return;
@@ -428,17 +476,24 @@ window.onServerCw = function(evt) {
     cwTonePickerRaf = null;
     drawCwTonePicker();
   });
-};
+}
 
-window.restoreCwHistory = function(events) {
+function restoreCwHistory(events: CwEvent[]): void {
   if (!Array.isArray(events) || events.length === 0) return;
   if (cwStatusEl) cwStatusEl.textContent = "Receiving";
   for (const evt of events) {
-    window.onServerCw(evt);
+    onServerCw(evt);
   }
-};
+}
 
-window.refreshCwTonePicker = function refreshCwTonePicker() {
+cwWindow.trxPluginRuntime.registerDecoder({
+  id: "cw",
+  onMessage: onServerCw,
+  restore: restoreCwHistory,
+  reset: resetCwHistoryView,
+});
+
+cwWindow.refreshCwTonePicker = function refreshCwTonePicker() {
   ensureCwToneCanvasResolution();
   drawCwTonePicker();
 };

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

@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { initializeFtxDecoder } from "./ftx-family";
+
+initializeFtxDecoder({ id: "ft2", label: "FT2", periodMs: 3_750 });

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

@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { initializeFtxDecoder } from "./ftx-family";
+
+initializeFtxDecoder({ id: "ft4", label: "FT4", periodMs: 7_500 });

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

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import {
+  initializeFt8FamilyBar,
+  initializeFtxDecoder,
+  installFtxCompatibilityHelpers,
+} from "./ftx-family";
+
+installFtxCompatibilityHelpers();
+initializeFt8FamilyBar();
+initializeFtxDecoder({ id: "ft8", label: "FT8", periodMs: 15_000, periodDigits: 0 });

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

@@ -0,0 +1,328 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// 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";
+
+export interface FtxMessage {
+  message?: string | undefined;
+  ts_ms?: number | undefined;
+  _tsMs?: number | undefined;
+  snr_db?: number | undefined;
+  dt_s?: number | undefined;
+  freq_hz?: number | undefined;
+  receiver?: unknown;
+  [key: string]: unknown;
+}
+
+export interface LocatorDetails { grid: string; station: string | null; source: string | null; target: string | null }
+interface BarFrames { count: number; newestTsMs: number; html: string }
+interface ConfirmApi {
+  confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean>;
+}
+interface FtxBridge {
+  ft8BaseHz?: number;
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  renderFt8Message?: (message: string) => string;
+  ft8EscapeHtml?: (message: string) => string;
+  ft8ExtractLocatorDetails?: (message: string) => LocatorDetails[];
+  ft8ExtractAllGrids?: (message: string) => string[];
+  ft8ExtractLikelyCallsign?: (message: string) => string | null;
+  getDecodeRigMeta?: () => unknown;
+  mapAddLocator?: (
+    raw: string,
+    grids: string[],
+    decoder: FtxDecoderId,
+    station: string | null,
+    message: FtxMessage,
+  ) => void;
+  navigateToMapLocator?: (grid: string, decoder: FtxDecoderId) => void;
+  clearMapMarkersByType?: (decoder: FtxDecoderId) => void;
+  setFt8FamilyBarDecoder?: (decoder: FtxDecoderId) => void;
+  updateFt8Bar?: () => void;
+  registerFt8FamilyBarRenderer?: (decoder: FtxDecoderId, renderer: () => BarFrames) => void;
+  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<void>;
+  trxUi: ConfirmApi;
+  clearFt8Bar?: () => void;
+  closeFt8Bar?: () => void;
+  [key: string]: unknown;
+}
+
+interface FtxConfig {
+  id: FtxDecoderId;
+  label: "FT2" | "FT4" | "FT8";
+  periodMs: number;
+  periodDigits?: number;
+}
+
+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;
+}
+
+function isAlphaNumeric(value: string | undefined): boolean {
+  return value !== undefined && /[A-Za-z0-9]/.test(value);
+}
+
+function isGrid(value: string): boolean {
+  const normalized = value.trim().toUpperCase();
+  return /^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalized)
+    && normalized !== "RR73" && normalized !== "73" && normalized !== "RR";
+}
+
+export function escapeFtxHtml(input: string): string {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+
+export function extractFtxGrids(message: string): string[] {
+  return [...new Set(message.toUpperCase().split(/[^A-Z0-9]+/).filter(isGrid))];
+}
+
+function tokenize(message: string): string[] {
+  return message.toUpperCase().split(/[^A-Z0-9/]+/).filter(Boolean);
+}
+
+function isCallsign(token: string | undefined): token is string {
+  return token !== undefined && token.length >= 3 && token.length <= 12
+    && !["CQ", "DE", "QRZ", "DX"].includes(token) && !isGrid(token)
+    && /^[A-Z0-9/]{1,5}\d[A-Z0-9/]{1,6}$/.test(token);
+}
+
+export function extractFtxLocatorDetails(message: string): LocatorDetails[] {
+  const tokens = tokenize(message);
+  const grids = extractFtxGrids(message);
+  const gridIndex = tokens.findIndex(isGrid);
+  const callsigns = tokens.slice(0, gridIndex < 0 ? tokens.length : gridIndex).filter(isCallsign);
+  const directed = callsigns.length >= 2 && !["CQ", "DE", "QRZ"].includes(tokens[0] ?? "");
+  const source = directed ? callsigns[1] ?? null : callsigns[0] ?? null;
+  const target = directed ? callsigns[0] ?? null : null;
+  return grids.map((grid) => ({ grid, station: source, source, target }));
+}
+
+export function extractFtxCallsign(message: string): string | null {
+  return extractFtxLocatorDetails(message)[0]?.station ?? tokenize(message).find(isCallsign) ?? null;
+}
+
+export function renderFtxMessage(message: string): string {
+  let html = "";
+  let index = 0;
+  while (index < message.length) {
+    if (!isAlphaNumeric(message[index])) {
+      html += escapeFtxHtml(message[index] ?? "");
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < message.length && isAlphaNumeric(message[end])) end += 1;
+    const token = message.slice(index, end);
+    const grid = token.toUpperCase();
+    html += isGrid(grid)
+      ? `<span class="ft8-locator" data-locator-grid="${grid}" role="button" tabindex="0" aria-label="Show locator ${grid} on map">${grid}</span>`
+      : escapeFtxHtml(token);
+    index = end;
+  }
+  return html;
+}
+
+export function installFtxCompatibilityHelpers(): void {
+  bridge.renderFt8Message = renderFtxMessage;
+  bridge.ft8EscapeHtml = escapeFtxHtml;
+  bridge.ft8ExtractLocatorDetails = extractFtxLocatorDetails;
+  bridge.ft8ExtractAllGrids = extractFtxGrids;
+  bridge.ft8ExtractLikelyCallsign = extractFtxCallsign;
+}
+
+export function initializeFt8FamilyBar(): void {
+  const labels: Record<FtxDecoderId, string> = { ft8: "FT8", ft4: "FT4", ft2: "FT2" };
+  const builders: Partial<Record<FtxDecoderId, () => BarFrames>> = {};
+  const dismissed: Record<FtxDecoderId, number> = { ft8: 0, ft4: 0, ft2: 0 };
+  const overlay = document.getElementById("ft8-bar-overlay");
+  let active: FtxDecoderId = "ft8";
+  const update = (): void => {
+    if (!overlay) return;
+    const mode = ((document.getElementById("mode") as HTMLSelectElement | null)?.value ?? "").toUpperCase();
+    const result = builders[active]?.();
+    if ((mode !== "DIG" && mode !== "USB") || !result || result.count === 0 || result.newestTsMs <= dismissed[active]) {
+      overlay.style.display = "none";
+      overlay.innerHTML = "";
+      return;
+    }
+    const label = labels[active];
+    overlay.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}`;
+    overlay.style.display = "flex";
+  };
+  bridge.registerFt8FamilyBarRenderer = (decoder, builder) => { builders[decoder] = builder; };
+  bridge.setFt8FamilyBarDecoder = (decoder) => { active = decoder; update(); };
+  bridge.updateFt8Bar = update;
+  bridge.clearFt8Bar = () => {
+    bridge.trxPluginRuntime.reset(active);
+  };
+  bridge.closeFt8Bar = () => {
+    dismissed[active] = Date.now();
+    update();
+  };
+}
+
+export function initializeFtxDecoder(config: FtxConfig): void {
+  const { id, label, periodMs, periodDigits = 1 } = config;
+  const status = document.getElementById(`${id}-status`);
+  const period = document.getElementById(`${id}-period`);
+  const messagesElement = document.getElementById(`${id}-messages`);
+  const filterInput = document.getElementById(`${id}-filter`) as HTMLInputElement | null;
+  let filterText = "";
+  let history: FtxMessage[] = [];
+
+  const renderMessage = (message: string): string => {
+    return bridge.renderFt8Message?.(message) ?? renderFtxMessage(message);
+  };
+  const retentionMs = (): number => bridge.getDecodeHistoryRetentionMs?.() ?? 86_400_000;
+  const prune = (): void => {
+    const cutoff = Date.now() - retentionMs();
+    history = history.filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= cutoff);
+  };
+  const schedule = (job: () => void): void => {
+    if (bridge.trxScheduleUiFrameJob) bridge.trxScheduleUiFrameJob(`${id}-history`, job);
+    else job();
+  };
+  const displayFrequency = (value: unknown): number | null => {
+    const raw = finiteNumber(value);
+    if (raw === null) return null;
+    const base = finiteNumber(bridge.ft8BaseHz);
+    return base !== null && base > 0 && raw >= 0 && raw < 100_000 ? base + raw : raw;
+  };
+  const renderRow = (message: FtxMessage): HTMLDivElement => {
+    const row = document.createElement("div");
+    row.className = "ft8-row";
+    const raw = message.message ?? "";
+    row.dataset.message = raw.toUpperCase();
+    row.dataset.decoder = id;
+    const storedFrequency = finiteNumber(message.freq_hz);
+    row.dataset.storedFreqHz = storedFrequency === null ? "" : String(storedFrequency);
+    const snr = finiteNumber(message.snr_db);
+    const delta = finiteNumber(message.dt_s);
+    const frequency = displayFrequency(message.freq_hz);
+    const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
+    const time = timestamp === null ? "--:--:--" : new Date(timestamp).toLocaleTimeString([], {
+      hour: "2-digit", minute: "2-digit", second: "2-digit",
+    });
+    row.innerHTML = `<span class="ft8-time">${time}</span><span class="ft8-snr">${snr?.toFixed(1) ?? "--"}</span><span class="ft8-dt">${delta?.toFixed(2) ?? "--"}</span><span class="ft8-freq">${frequency?.toFixed(0) ?? "--"}</span><span class="ft8-msg">${renderMessage(raw)}</span>`;
+    return row;
+  };
+  const render = (): void => {
+    prune();
+    if (!messagesElement) return;
+    const fragment = document.createDocumentFragment();
+    let count = 0;
+    for (const message of history) {
+      if (count >= 200) break;
+      if (filterText && !(message.message ?? "").toUpperCase().includes(filterText)) continue;
+      fragment.appendChild(renderRow(message));
+      count += 1;
+    }
+    messagesElement.replaceChildren(fragment);
+  };
+  const normalize = (message: FtxMessage): FtxMessage => {
+    const raw = message.message ?? "";
+    const locatorDetails = bridge.ft8ExtractLocatorDetails?.(raw) ?? extractFtxLocatorDetails(raw);
+    const grids = locatorDetails.length > 0
+      ? locatorDetails.map(({ grid }) => grid)
+      : bridge.ft8ExtractAllGrids?.(raw) ?? extractFtxGrids(raw);
+    const station = bridge.ft8ExtractLikelyCallsign?.(raw) ?? extractFtxCallsign(raw);
+    const frequency = displayFrequency(message.freq_hz);
+    if (grids.length > 0) {
+      bridge.mapAddLocator?.(raw, grids, id, station, {
+        ...message, freq_hz: frequency ?? message.freq_hz, locator_details: locatorDetails,
+      });
+    }
+    return {
+      receiver: bridge.getDecodeRigMeta?.() ?? null,
+      ts_ms: message.ts_ms,
+      snr_db: message.snr_db,
+      dt_s: message.dt_s,
+      freq_hz: frequency ?? message.freq_hz,
+      message: message.message,
+      _tsMs: finiteNumber(message.ts_ms) ?? Date.now(),
+    };
+  };
+  const receiveBatch = (messages: FtxMessage[]): void => {
+    if (messages.length === 0) return;
+    if (status) status.textContent = "Receiving";
+    history = messages.map(normalize).reverse().concat(history);
+    prune();
+    bridge.setFt8FamilyBarDecoder?.(id);
+    bridge.updateFt8Bar?.();
+    schedule(render);
+  };
+  const reset = (): void => {
+    history = [];
+    bridge.updateFt8Bar?.();
+    render();
+    bridge.clearMapMarkersByType?.(id);
+  };
+  const barFrames = (): BarFrames => {
+    const recent = history
+      .filter((message) => (finiteNumber(message._tsMs ?? message.ts_ms) ?? 0) >= Date.now() - 900_000)
+      .slice(0, 8);
+    let html = "";
+    for (const message of recent) {
+      const timestamp = finiteNumber(message._tsMs ?? message.ts_ms);
+      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);
+      const detail = [snr === null ? "-- dB" : `${snr.toFixed(1)} dB`, delta === null ? null : `dt ${delta.toFixed(2)}`, frequency === null ? null : `${frequency.toFixed(0)} Hz`].filter((part): part is string => part !== null).join(" · ");
+      html += `<div class="aprs-bar-frame"><div class="aprs-bar-frame-main">${time}<span class="aprs-bar-call">${renderMessage(message.message ?? "")}</span>${detail ? ` · ${detail}` : ""}</div></div>`;
+    }
+    return { count: recent.length, newestTsMs: recent.reduce((latest, message) => Math.max(latest, finiteNumber(message._tsMs ?? message.ts_ms) ?? 0), 0), html };
+  };
+
+  bridge.trxPluginRuntime.registerDecoder({
+    id,
+    onMessage: (message: FtxMessage) => { receiveBatch([message]); },
+    onBatch: receiveBatch,
+    restore: receiveBatch,
+    prune: () => { prune(); render(); },
+    reset,
+  });
+  bridge.registerFt8FamilyBarRenderer?.(id, barFrames);
+
+  const updatePeriod = (): void => {
+    if (period) period.textContent = `Next slot ${((periodMs - Date.now() % periodMs) / 1000).toFixed(periodDigits)}s`;
+  };
+  updatePeriod();
+  window.setInterval(updatePeriod, 250);
+  filterInput?.addEventListener("input", () => { filterText = filterInput.value.trim().toUpperCase(); render(); });
+  messagesElement?.addEventListener("click", (event) => {
+    if (!(event.target instanceof Element)) return;
+    const grid = event.target.closest<HTMLElement>(".ft8-locator[data-locator-grid]")?.dataset.locatorGrid;
+    if (grid) { bridge.navigateToMapLocator?.(grid.toUpperCase(), id); event.preventDefault(); }
+  });
+  const toggle = document.getElementById(`${id}-decode-toggle-btn`);
+  toggle?.addEventListener("click", () => { void (async () => {
+    try {
+      await bridge.takeSchedulerControlForDecoderDisable?.(toggle);
+      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 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,10 +2,37 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
+import {
+  aprsAgeText,
+  aprsCategoryLabel,
+  aprsHexBytes,
+  aprsPacketCategory,
+  collapseAprsDuplicates,
+  normalizeAprsPacket,
+  renderAprsInfo,
+  renderLocalAprsSymbol,
+  type AprsPacket,
+  type AprsTypeFilter,
+} from "./aprs-shared";
+import type { PluginRuntimeWindow } from "./runtime-contract";
+
+interface HfAprsBridge {
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  navigateToAprsMap?: (lat: number, lon: number) => void;
+  getDecodeRigMeta?: () => unknown;
+  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<unknown>;
+  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
+}
+const hfAprsWindow = window as unknown as HfAprsBridge;
+const escapeHfAprsHtml = (input: string): string => hostCore.escapeMapHtml(input);
+
 // --- HF APRS Decoder Plugin (server-side decode, 300 baud) ---
 const hfAprsStatus = document.getElementById("hf-aprs-status");
 const hfAprsPacketsEl = document.getElementById("hf-aprs-packets");
-const hfAprsFilterInput = document.getElementById("hf-aprs-filter");
+const hfAprsFilterInput = document.getElementById("hf-aprs-filter") as HTMLInputElement | null;
 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");
@@ -13,92 +40,43 @@ 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 hfAprsPacketHistory: AprsPacket[] = [];
 let hfAprsOnlyPos = false;
 let hfAprsHideCrc = false;
 let hfAprsCollapseDup = false;
-let hfAprsTypeFilter = "all";
+let hfAprsTypeFilter: AprsTypeFilter = "all";
 
-function currentHfAprsHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
+function currentHfAprsHistoryRetentionMs(): number {
+  return typeof hfAprsWindow.getDecodeHistoryRetentionMs === "function"
+    ? hfAprsWindow.getDecodeHistoryRetentionMs()
     : 24 * 60 * 60 * 1000;
 }
 
 function pruneHfAprsPacketHistory() {
   const cutoffMs = Date.now() - currentHfAprsHistoryRetentionMs();
-  hfAprsPacketHistory = hfAprsPacketHistory.filter((pkt) => Number(pkt?._tsMs) >= cutoffMs);
+  hfAprsPacketHistory = hfAprsPacketHistory.filter((pkt) => (pkt._tsMs ?? 0) >= cutoffMs);
 }
 
 function scheduleHfAprsHistoryRender() {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob("hf-aprs-history", () => renderHfAprsHistory());
+  if (typeof hfAprsWindow.trxScheduleUiFrameJob === "function") {
+    hfAprsWindow.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);
+function hfAprsDistanceText(pkt: AprsPacket): string {
+  if (hostState.serverLat == null || hostState.serverLon == null || pkt.lat == null || pkt.lon == null) return "";
+  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`;
 }
 
-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) {
+function hfAprsFilterMatch(pkt: AprsPacket): boolean {
   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 (hfAprsTypeFilter !== "all" && aprsPacketCategory(pkt) !== hfAprsTypeFilter) return false;
   if (!hfAprsFilterText) return true;
   const haystack = [
     pkt.srcCall,
@@ -108,7 +86,7 @@ function hfAprsFilterMatch(pkt) {
     pkt.type,
     pkt.lat != null ? pkt.lat.toFixed(4) : "",
     pkt.lon != null ? pkt.lon.toFixed(4) : "",
-    hfAprsPacketCategory(pkt),
+    aprsPacketCategory(pkt),
   ]
     .filter(Boolean)
     .join(" ")
@@ -116,22 +94,12 @@ function hfAprsFilterMatch(pkt) {
   return haystack.includes(hfAprsFilterText);
 }
 
-function hfAprsVisiblePackets() {
+function hfAprsVisiblePackets(): AprsPacket[] {
   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;
-}
+const collapseHfAprsDuplicates = collapseAprsDuplicates;
 
 function updateHfAprsSummary() {
   const visible = hfAprsVisiblePackets();
@@ -146,7 +114,7 @@ function updateHfAprsSummary() {
     if (!latest) {
       hfAprsLatestSeenEl.textContent = "No packets yet";
     } else {
-      hfAprsLatestSeenEl.textContent = `${latest.srcCall} ${hfAprsAgeText(latest._tsMs)}`;
+      hfAprsLatestSeenEl.textContent = `${latest.srcCall} ${aprsAgeText(latest._tsMs)}`;
     }
   }
 }
@@ -160,69 +128,21 @@ function updateHfAprsChipState() {
   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) {
+function renderHfAprsRow(pkt: AprsPacket, isFresh: boolean): HTMLElement {
   const row = document.createElement("div");
   row.className = "aprs-packet";
   if (!pkt.crcOk) row.classList.add("aprs-packet-crc");
   if (isFresh) row.classList.add("aprs-packet-new");
 
   const ts = pkt._ts || new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  const age = hfAprsAgeText(pkt._tsMs);
-  const category = hfAprsPacketCategory(pkt);
-  const categoryLabel = hfAprsCategoryLabel(category);
+  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 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>';
-  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 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>`
     : "";
@@ -234,19 +154,19 @@ function renderHfAprsRow(pkt, isFresh) {
       `<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>` +
+      `<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">${escapeMapHtml(age)}</span>` +
-      (distance ? `<span class="aprs-meta-text">${escapeMapHtml(distance)}</span>` : "") +
-      `<span class="aprs-meta-text">${escapeMapHtml(pkt.type || "--")}</span>` +
+      `<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="${escapeMapHtml(pkt.type || "")}">${renderHfAprsInfo(pkt)}</span>` +
+      `<span title="${escapeHfAprsHtml(pkt.type || "")}">${renderAprsInfo(pkt)}</span>` +
       (posLink ? `<span>${posLink}</span>` : "") +
     `</div>` +
     `<div class="aprs-row-actions">` +
@@ -257,42 +177,43 @@ function renderHfAprsRow(pkt, isFresh) {
     `<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">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">${escapeMapHtml(pkt.info || "--")}</span>` +
-        `<span class="aprs-detail-label">Info Bytes</span><span class="aprs-detail-value">${escapeMapHtml(hfAprsHexBytes(pkt.info_bytes))}</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) => {
+  row.querySelectorAll<HTMLElement>("[data-aprs-map]").forEach((el) => {
     el.addEventListener("click", (evt) => {
       evt.preventDefault();
-      const raw = String(el.dataset.aprsMap || "");
+      const raw = el.dataset.aprsMap ?? "";
       const [lat, lon] = raw.split(",").map(Number);
-      if (window.navigateToAprsMap && Number.isFinite(lat) && Number.isFinite(lon)) {
-        window.navigateToAprsMap(lat, lon);
+      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]");
+  const copyBtn = row.querySelector<HTMLElement>("[data-aprs-copy]");
   if (copyBtn) {
-    copyBtn.addEventListener("click", async () => {
-      const raw = String(copyBtn.dataset.aprsCopy || "");
+    copyBtn.addEventListener("click", () => { void (async () => {
+      const raw = copyBtn.dataset.aprsCopy ?? "";
       try {
-        if (navigator.clipboard?.writeText) {
-          await navigator.clipboard.writeText(raw);
-          showHint("Coordinates copied", 1200);
+        const clipboard = Reflect.get(navigator, "clipboard") as Clipboard | undefined;
+        if (clipboard) {
+          await clipboard.writeText(raw);
+          hostCore.showHint("Coordinates copied", 1200);
         }
-      } catch (_e) {
-        showHint("Copy failed", 1500);
+      } catch {
+        hostCore.showHint("Copy failed", 1500);
       }
-    });
+    })(); });
   }
 
   return row;
@@ -307,26 +228,26 @@ function renderHfAprsHistory() {
   }
   const visible = hfAprsVisiblePackets();
   const fragment = document.createDocumentFragment();
-  for (let i = 0; i < visible.length; i++) {
-    fragment.appendChild(renderHfAprsRow(visible[i], i === 0));
+  for (const [index, packet] of visible.entries()) {
+    fragment.appendChild(renderHfAprsRow(packet, index === 0));
   }
   hfAprsPacketsEl.replaceChildren(fragment);
   updateHfAprsSummary();
   updateHfAprsChipState();
 }
 
-window.resetHfAprsHistoryView = function() {
+function resetHfAprsHistoryView(): void {
   if (hfAprsPacketsEl) hfAprsPacketsEl.innerHTML = "";
   hfAprsPacketHistory = [];
   renderHfAprsHistory();
-};
+}
 
-window.pruneHfAprsHistoryView = function() {
+function pruneHfAprsHistoryView(): void {
   pruneHfAprsPacketHistory();
   renderHfAprsHistory();
-};
+}
 
-function addHfAprsPacket(pkt) {
+function addHfAprsPacket(pkt: AprsPacket): void {
   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" });
@@ -337,29 +258,14 @@ function addHfAprsPacket(pkt) {
   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,
-  };
+function normalizeServerHfAprsPacket(pkt: AprsPacket): AprsPacket {
+  return normalizeAprsPacket(pkt, hfAprsWindow.getDecodeRigMeta?.() ?? null);
 }
 
-window.onServerHfAprsBatch = function(packets) {
+function onServerHfAprsBatch(packets: AprsPacket[]): void {
   if (!Array.isArray(packets) || packets.length === 0) return;
   if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
-  const normalized = [];
+  const normalized: AprsPacket[] = [];
   for (const pkt of packets) {
     const next = normalizeServerHfAprsPacket(pkt);
     const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
@@ -371,31 +277,27 @@ window.onServerHfAprsBatch = function(packets) {
   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 () => {
+hfAprsDecodeToggleBtn?.addEventListener("click", () => { void (async () => {
   try {
-    await window.takeSchedulerControlForDecoderDisable?.(hfAprsDecodeToggleBtn);
-    await postPath("/toggle_hf_aprs_decode");
+    await hfAprsWindow.takeSchedulerControlForDecoderDisable?.(hfAprsDecodeToggleBtn);
+    await hostCore.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 (!confirm("Clear all HF APRS decode history? This cannot be undone.")) return;
+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 postPath("/clear_hf_aprs_decode");
-    window.resetHfAprsHistoryView();
+    await hostCore.postPath("/clear_hf_aprs_decode");
+    resetHfAprsHistoryView();
   } catch (e) {
     console.error("HF APRS history clear failed", e);
   }
-});
+})(); });
 
 if (hfAprsOnlyPosBtn) {
   hfAprsOnlyPosBtn.addEventListener("click", () => {
@@ -418,7 +320,7 @@ if (hfAprsCollapseDupBtn) {
   });
 }
 
-["all", "position", "message", "weather", "telemetry", "other"].forEach((type) => {
+(["all", "position", "message", "weather", "telemetry", "other"] as const).forEach((type) => {
   const btn = document.getElementById(`hf-aprs-type-${type}`);
   if (!btn) return;
   btn.addEventListener("click", () => {
@@ -435,10 +337,17 @@ if (hfAprsFilterInput) {
 }
 
 // --- Server-side HF APRS decode handler ---
-window.onServerHfAprs = function(pkt) {
+function onServerHfAprs(pkt: AprsPacket): void {
   if (hfAprsStatus) hfAprsStatus.textContent = "Receiving";
   addHfAprsPacket(normalizeServerHfAprsPacket(pkt));
-};
+}
 
 renderHfAprsHistory();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("hf_aprs");
+(window as unknown as PluginRuntimeWindow).trxPluginRuntime.registerDecoder<AprsPacket>({
+  id: "hf_aprs",
+  onMessage: onServerHfAprs,
+  onBatch: onServerHfAprsBatch,
+  restore: onServerHfAprsBatch,
+  reset: resetHfAprsHistoryView,
+  prune: pruneHfAprsHistoryView,
+});

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

@@ -0,0 +1,72 @@
+// 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;
+  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;

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/runtime-contract.ts

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export interface DecoderPlugin<TMessage = unknown> {
+  readonly id: string;
+  onMessage?(message: TMessage): void;
+  onBatch?(messages: TMessage[]): void;
+  restore?(messages: TMessage[]): void;
+  reset?(): void;
+  prune?(): void;
+}
+
+export interface TrxPluginRuntime {
+  registerDecoder<TMessage>(plugin: DecoderPlugin<TMessage>): () => void;
+  dispatch(id: string, message: unknown): boolean;
+  dispatchBatch(id: string, messages: unknown[]): boolean;
+  restore(id: string, messages: unknown[]): boolean;
+  reset(id: string): boolean;
+  resetAll(): void;
+  prune(id: string): boolean;
+  clearQueued(): void;
+  hasDecoder(id: string): boolean;
+}
+
+export interface PluginRuntimeWindow { trxPluginRuntime: TrxPluginRuntime }

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/sat-scheduler.ts

@@ -2,6 +2,22 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import type {
+  SatelliteBookmark,
+  SatelliteScheduleConfig,
+  SatelliteScheduleEntry,
+  SatelliteSchedulerApi,
+  SatelliteSchedulerStatus,
+} from "./satellite-types";
+import type { SchedulerConfig, SchedulerService } from "./scheduler-types.js";
+
+interface SatelliteSchedulerWindow {
+  trx?: { modules?: { scheduler?: SchedulerService } };
+  satScheduler?: SatelliteSchedulerApi;
+  trxUi?: { notify(message: string, options: { kind: "error" }): void };
+}
+const satSchedulerWindow = window as unknown as SatelliteSchedulerWindow;
+
 // 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.
@@ -11,93 +27,91 @@
 
   // ── DOM references (cached once) ──────────────────────────────────
   const dom = {
-    enabled:    document.getElementById("scheduler-sat-enabled"),
-    pretune:    document.getElementById("scheduler-sat-pretune"),
+    enabled:    document.getElementById("scheduler-sat-enabled") as HTMLInputElement | null,
+    pretune:    document.getElementById("scheduler-sat-pretune") as HTMLInputElement | null,
     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"),
+    form:       document.getElementById("sch-sat-form") as HTMLFormElement | null,
     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"),
+    preset:     document.getElementById("scheduler-sat-preset") as HTMLSelectElement | null,
+    name:       document.getElementById("scheduler-sat-name") as HTMLInputElement | null,
+    norad:      document.getElementById("scheduler-sat-norad") as HTMLInputElement | null,
+    bookmark:   document.getElementById("scheduler-sat-bookmark") as HTMLSelectElement | null,
+    minEl:      document.getElementById("scheduler-sat-min-el") as HTMLInputElement | null,
+    priority:   document.getElementById("scheduler-sat-priority") as HTMLInputElement | null,
+    centerHz:   document.getElementById("scheduler-sat-center-hz") as HTMLInputElement | null,
   };
 
   // ── Local state ───────────────────────────────────────────────────
-  let editIdx = null; // null = adding, number = editing
+  let editIdx: number | null = null;
+  let eventsWired = false;
 
   // ── 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 || {};
+  // These accessors use the shared typed scheduler service when available.
+  function getBridge(): SchedulerService | null {
+    return satSchedulerWindow.trx?.modules?.scheduler ?? null;
   }
 
-  function getConfig() {
+  function getConfig(): SchedulerConfig | null {
     const b = getBridge();
-    return typeof b.getConfig === "function" ? b.getConfig() : null;
+    return b?.getConfig() ?? null;
   }
 
-  function getStatus() {
+  function getStatus(): SatelliteSchedulerStatus | null {
     const b = getBridge();
-    return typeof b.getStatus === "function" ? b.getStatus() : null;
+    return b?.getStatus() ?? null;
   }
 
-  function getBookmarks() {
+  function getBookmarks(): SatelliteBookmark[] {
     const b = getBridge();
-    return typeof b.getBookmarks === "function" ? b.getBookmarks() : [];
+    return b?.getBookmarks() ?? [];
   }
 
   function markDirty() {
-    var b = getBridge();
-    if (typeof b.markDirty === "function") b.markDirty();
+    getBridge()?.markDirty();
   }
 
-  function bmName(id) {
+  function bmName(id: string): string {
     const bm = getBookmarks().find(function (b) { return b.id === id; });
-    return bm ? bm.name : String(id || "");
+    return bm ? bm.name : id;
   }
 
-  function escHtml(s) {
-    return String(s)
+  function escHtml(s: string): string {
+    return s
       .replace(/&/g, "&")
       .replace(/</g, "&lt;")
       .replace(/>/g, "&gt;")
       .replace(/"/g, "&quot;");
   }
 
-  function formatFreq(hz) {
+  function formatFreq(hz: number): string {
     if (hz >= 1e6) return (hz / 1e6).toFixed(3) + " MHz";
     if (hz >= 1e3) return (hz / 1e3).toFixed(1) + " kHz";
-    return hz + " Hz";
+    return `${String(hz)} Hz`;
   }
 
   // ── Satellite config helpers ──────────────────────────────────────
-  function getSatelliteEntries() {
-    var config = getConfig();
+  function getSatelliteEntries(): SatelliteScheduleEntry[] {
+    const config = getConfig();
     return (config && config.satellites && Array.isArray(config.satellites.entries))
       ? config.satellites.entries
       : [];
   }
 
-  function ensureSatelliteConfig() {
-    var config = getConfig();
+  function ensureSatelliteConfig(): SatelliteScheduleConfig {
+    const 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;
+  function collectSatelliteConfig(): SatelliteScheduleConfig {
+    const enabled = dom.enabled ? dom.enabled.checked : false;
+    const pretune = dom.pretune ? parseInt(dom.pretune.value, 10) : 60;
     return {
       enabled: enabled,
       pretune_secs: isNaN(pretune) || pretune < 0 ? 60 : pretune,
@@ -107,12 +121,12 @@
 
   // ── Render: section ───────────────────────────────────────────────
   function renderSection() {
-    var config = getConfig();
-    var satCfg = (config && config.satellites) || {};
-    var enabled = !!satCfg.enabled;
+    const config = getConfig();
+    const satCfg = config?.satellites;
+    const enabled = satCfg?.enabled ?? false;
 
     if (dom.enabled) dom.enabled.checked = enabled;
-    if (dom.pretune) dom.pretune.value = satCfg.pretune_secs != null ? satCfg.pretune_secs : 60;
+    if (dom.pretune) dom.pretune.value = String(satCfg?.pretune_secs ?? 60);
     if (dom.body) dom.body.style.display = enabled ? "" : "none";
 
     renderEntries();
@@ -122,35 +136,35 @@
   // ── Render: entries table ─────────────────────────────────────────
   function renderEntries() {
     if (!dom.tbody) return;
-    var entries = getSatelliteEntries();
-    var frag = document.createDocumentFragment();
+    const entries = getSatelliteEntries();
+    const frag = document.createDocumentFragment();
 
     entries.forEach(function (entry, idx) {
-      var tr = document.createElement("tr");
+      const tr = document.createElement("tr");
 
-      var tdSat = document.createElement("td");
+      const tdSat = document.createElement("td");
       tdSat.textContent = entry.satellite || "";
       tr.appendChild(tdSat);
 
-      var tdNorad = document.createElement("td");
-      tdNorad.textContent = entry.norad_id || "";
+      const tdNorad = document.createElement("td");
+      tdNorad.textContent = String(entry.norad_id || "");
       tr.appendChild(tdNorad);
 
-      var tdBm = document.createElement("td");
+      const 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");
+      const tdEl = document.createElement("td");
+      tdEl.textContent = `${String(entry.min_elevation_deg)}\u00B0`;
       tr.appendChild(tdEl);
 
-      var tdPrio = document.createElement("td");
-      tdPrio.textContent = entry.priority || 0;
+      const tdPrio = document.createElement("td");
+      tdPrio.textContent = String(entry.priority || 0);
       tr.appendChild(tdPrio);
 
-      var tdActions = document.createElement("td");
+      const tdActions = document.createElement("td");
 
-      var editBtn = document.createElement("button");
+      const editBtn = document.createElement("button");
       editBtn.className = "sch-write";
       editBtn.type = "button";
       editBtn.textContent = "Edit";
@@ -159,7 +173,7 @@
       });
       tdActions.appendChild(editBtn);
 
-      var removeBtn = document.createElement("button");
+      const removeBtn = document.createElement("button");
       removeBtn.className = "sch-write";
       removeBtn.type = "button";
       removeBtn.textContent = "Remove";
@@ -178,12 +192,12 @@
   // ── Render: pass status ───────────────────────────────────────────
   function renderPassStatus() {
     if (!dom.passStatus) return;
-    var entries = getSatelliteEntries();
+    const entries = getSatelliteEntries();
     if (entries.length === 0) {
       dom.passStatus.innerHTML = "";
       return;
     }
-    var status = getStatus();
+    const status = getStatus();
     if (status && status.active_satellite) {
       dom.passStatus.innerHTML =
         '<span class="sch-sat-active-badge">PASS ACTIVE: ' +
@@ -196,37 +210,38 @@
   }
 
   // ── Render: bookmark dropdown ─────────────────────────────────────
-  function renderBookmarkSelect(selectedId) {
-    if (!dom.bookmark) return;
-    dom.bookmark.innerHTML = '<option value="">— none —</option>';
+  function renderBookmarkSelect(selectedId: string | null): void {
+    const bookmarkSelect = dom.bookmark;
+    if (!bookmarkSelect) return;
+    bookmarkSelect.innerHTML = '<option value="">— none —</option>';
     getBookmarks().forEach(function (bm) {
-      var opt = document.createElement("option");
+      const 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);
+      bookmarkSelect.appendChild(opt);
     });
   }
 
   // ── Entry management ──────────────────────────────────────────────
-  function removeEntry(idx) {
-    var sat = ensureSatelliteConfig();
+  function removeEntry(idx: number): void {
+    const sat = ensureSatelliteConfig();
     sat.entries.splice(idx, 1);
     renderEntries();
     markDirty();
   }
 
   // ── Form: open ────────────────────────────────────────────────────
-  function openForm(entry, idx) {
+  function openForm(entry: SatelliteScheduleEntry | null, idx: number | null): void {
     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 : "";
+    if (dom.norad)    dom.norad.value = entry ? String(entry.norad_id || "") : "";
+    if (dom.minEl)    dom.minEl.value = String(entry?.min_elevation_deg ?? 5);
+    if (dom.priority) dom.priority.value = String(entry?.priority ?? 0);
+    if (dom.centerHz) dom.centerHz.value = entry?.center_hz ? String(entry.center_hz) : "";
 
     renderBookmarkSelect(entry ? entry.bookmark_id : null);
 
@@ -243,24 +258,26 @@
   }
 
   // ── Form: submit ──────────────────────────────────────────────────
-  function onFormSubmit(e) {
+  function onFormSubmit(e: SubmitEvent): void {
     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 : "";
+    const satellite = dom.name ? dom.name.value.trim() : "";
+    const noradId = dom.norad ? parseInt(dom.norad.value, 10) : NaN;
+    const bmId = dom.bookmark ? dom.bookmark.value : "";
 
-    if (!satellite)                    { alert("Please enter a satellite name."); return; }
-    if (isNaN(noradId) || noradId <= 0) { alert("Please enter a valid NORAD catalog number."); return; }
-    if (!bmId)                         { alert("Please select a bookmark."); return; }
+    if (!satellite) { satSchedulerWindow.trxUi?.notify("Enter a satellite name.", { kind: "error" }); dom.name?.focus(); return; }
+    if (isNaN(noradId) || noradId <= 0) { satSchedulerWindow.trxUi?.notify("Enter a valid NORAD catalog number.", { kind: "error" }); dom.norad?.focus(); return; }
+    if (!bmId) { satSchedulerWindow.trxUi?.notify("Select a bookmark.", { kind: "error" }); dom.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;
+    const minEl = dom.minEl ? parseFloat(dom.minEl.value) : 5;
+    const prio = dom.priority ? parseInt(dom.priority.value, 10) : 0;
+    const centerHzRaw = dom.centerHz ? parseInt(dom.centerHz.value, 10) : NaN;
 
-    var sat = ensureSatelliteConfig();
+    const sat = ensureSatelliteConfig();
 
-    var entryData = {
+    const existing = editIdx !== null ? sat.entries[editIdx] : undefined;
+    const entryData: SatelliteScheduleEntry = {
+      id: existing?.id ?? `sat_${Date.now().toString(36)}`,
       satellite: satellite,
       norad_id: noradId,
       bookmark_id: bmId,
@@ -271,11 +288,8 @@
     };
 
     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);
     }
 
@@ -287,16 +301,19 @@
   // ── Preset change handler ─────────────────────────────────────────
   function onPresetChange() {
     if (!dom.preset || !dom.preset.value) return;
-    var parts = dom.preset.value.split("|");
+    const 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 (eventsWired) return;
+    eventsWired = true;
     if (dom.enabled) {
+      const enabledInput = dom.enabled;
       dom.enabled.addEventListener("change", function () {
-        if (dom.body) dom.body.style.display = dom.enabled.checked ? "" : "none";
+        if (dom.body) dom.body.style.display = enabledInput.checked ? "" : "none";
         markDirty();
       });
     }
@@ -312,10 +329,14 @@
   }
 
   // ── Public API ────────────────────────────────────────────────────
-  window.satScheduler = {
+  satSchedulerWindow.satScheduler = {
     wireEvents:              wireEvents,
     renderSection:           renderSection,
     renderPassStatus:        renderPassStatus,
     collectSatelliteConfig:  collectSatelliteConfig,
   };
+  if (getBridge()) {
+    wireEvents();
+    renderSection();
+  }
 })();

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

@@ -2,6 +2,26 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore } from "./host.js";
+
+import type { LrptProgress, SatelliteImage, SatelliteLiveUpdate, SatellitePass, SatellitePassResponse } from "./satellite-types";
+import type { PluginRuntimeWindow } from "./runtime-contract.js";
+
+type SatelliteView = "live" | "history" | "predictions";
+interface SatelliteBridge {
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  clearSatPredictionDom?: () => void;
+  updateSatLiveState?: (update: SatelliteLiveUpdate) => void;
+  addSatMapOverlay?: (image: SatelliteImage) => void;
+  clearSatMapOverlays?: () => void;
+  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<unknown>;
+  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
+  satShowOnMap?: (south: number, west: number, north: number, east: number) => void;
+  enableMapSourceFilter?: (source: string) => void;
+  navigateToAprsMap?: (lat: number, lon: number) => void;
+}
+const satWindow = window as unknown as SatelliteBridge & PluginRuntimeWindow;
+
 // --- SAT Plugin ---
 // Live view: decoder state, latest image card
 // History view: filterable table of all decoded images
@@ -16,16 +36,16 @@ const satDom = {
   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"),
+  filterInput:      document.getElementById("sat-filter") as HTMLInputElement | null,
+  sortSelect:       document.getElementById("sat-sort") as HTMLSelectElement | null,
+  typeFilter:       document.getElementById("sat-type-filter") as HTMLSelectElement | null,
   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"),
+  predFilter:       document.getElementById("sat-pred-filter") as HTMLInputElement | null,
+  predMinEl:        document.getElementById("sat-pred-min-el") as HTMLSelectElement | null,
+  predCategory:     document.getElementById("sat-pred-category") as HTMLSelectElement | null,
   predCurrentList:  document.getElementById("sat-pred-current-list"),
   predUpcomingList: document.getElementById("sat-pred-list"),
   predCurrentSec:   document.getElementById("sat-pred-current-section"),
@@ -34,30 +54,30 @@ const satDom = {
 };
 
 // ── State ───────────────────────────────────────────────────────────
-let satImageHistory = [];
+let satImageHistory: SatelliteImage[] = [];
 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 satActiveView: SatelliteView = "live";
+let satPredData: SatellitePass[] = [];
 let satPredFilterText = "";
 let satPredMinEl = 0;
 let satPredCategory = "all";
 let satPredSatCount = 0;
-let satPredCountdownTimer = null;
+let satPredCountdownTimer: ReturnType<typeof setInterval> | null = null;
 
 // ── UI scheduler helper ─────────────────────────────────────────────
-function scheduleSatUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
+function scheduleSatUi(key: string, job: () => void): void {
+  if (typeof satWindow.trxScheduleUiFrameJob === "function") {
+    satWindow.trxScheduleUiFrameJob(key, job);
     return;
   }
   job();
 }
 
 // ── View switching ──────────────────────────────────────────────────
-function switchSatView(view) {
+function switchSatView(view: SatelliteView): void {
   const leavingPredictions = satActiveView === "predictions" && view !== "predictions";
   satActiveView = view;
   if (satDom.liveView)        satDom.liveView.style.display = view === "live" ? "" : "none";
@@ -71,7 +91,7 @@ function switchSatView(view) {
     renderSatHistoryTable();
   } else if (view === "predictions") {
     satPredShowAll = false;
-    loadSatPredictions();
+    void loadSatPredictions();
   }
 }
 
@@ -80,19 +100,19 @@ function clearPredictionDom() {
   if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
   if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
 }
-window.clearSatPredictionDom = clearPredictionDom;
+satWindow.clearSatPredictionDom = clearPredictionDom;
 
-satDom.viewLiveBtn?.addEventListener("click", () => switchSatView("live"));
-satDom.viewHistoryBtn?.addEventListener("click", () => switchSatView("history"));
-satDom.viewPredBtn?.addEventListener("click", () => switchSatView("predictions"));
+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) {
+let lastSatLrptOn: boolean | null = null;
+satWindow.updateSatLiveState = function (update: SatelliteLiveUpdate) {
   if (!satDom.lrptState) return;
   const lrptOn = !!update.lrpt_decode_enabled;
-  if (lrptOn !== _lastSatLrptOn) {
-    _lastSatLrptOn = lrptOn;
+  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) {
@@ -114,7 +134,7 @@ function renderSatLatestCard() {
   }
 
   const img = satImageHistory[0];
-  const decoder = img._decoder || "unknown";
+  if (!img) return;
   const typeName = "Meteor LRPT";
   const satellite = img.satellite || "";
   const channels = img.channels || img.channel_a || "";
@@ -123,7 +143,7 @@ function renderSatLatestCard() {
   const ts = img._ts || "--";
   const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : "";
 
-  let meta = [typeName];
+  const meta = [typeName];
   if (satellite) meta.push(satellite);
   if (channels) meta.push(channels);
   meta.push(`${lines} ${unit}`);
@@ -143,7 +163,7 @@ function renderSatLatestCard() {
 }
 
 // ── History view: table ─────────────────────────────────────────────
-function getSatFilteredHistory() {
+function getSatFilteredHistory(): SatelliteImage[] {
   let items = satImageHistory;
 
   const typeVal = satDom.typeFilter ? satDom.typeFilter.value : "all";
@@ -168,11 +188,10 @@ function getSatFilteredHistory() {
   return items;
 }
 
-function renderSatHistoryRow(img) {
+function renderSatHistoryRow(img: SatelliteImage): HTMLElement {
   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 || "--";
@@ -204,8 +223,8 @@ 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]));
+  for (const image of items) {
+    fragment.appendChild(renderSatHistoryRow(image));
   }
   satDom.historyList.replaceChildren(fragment);
 
@@ -222,7 +241,7 @@ function renderSatHistoryTable() {
 }
 
 // ── Add image to history ────────────────────────────────────────────
-function addSatImage(img, decoder) {
+function addSatImage(img: SatelliteImage, decoder: "lrpt"): void {
   const tsMs = Number.isFinite(img.ts_ms) ? Number(img.ts_ms) : Date.now();
   img._tsMs = tsMs;
   img._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -237,102 +256,114 @@ function addSatImage(img, decoder) {
     satImageHistory = satImageHistory.slice(0, SAT_MAX_IMAGES);
   }
 
-  scheduleSatUi("sat-latest", () => renderSatLatestCard());
+  scheduleSatUi("sat-latest", () => { renderSatLatestCard(); });
   if (satActiveView === "history") {
-    scheduleSatUi("sat-history", () => renderSatHistoryTable());
+    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";
+function onServerLrptProgress(msg: LrptProgress): void {
+  if (satDom.status && (msg.mcu_count ?? 0) > 0) {
+    satDom.status.textContent = `Receiving \u2014 ${String(msg.mcu_count ?? 0)} MCU rows decoded`;
   }
-};
+}
 
-window.onServerLrptImage = function (msg) {
+function onServerLrptImage(msg: SatelliteImage): void {
   if (satDom.status) satDom.status.textContent = "Image received (Meteor LRPT)";
   addSatImage(msg, "lrpt");
-  if (msg.geo_bounds && msg.path && window.addSatMapOverlay) {
-    window.addSatMapOverlay(msg);
+  if (msg.geo_bounds && msg.path && satWindow.addSatMapOverlay) {
+    satWindow.addSatMapOverlay(msg);
   }
-};
+}
 
-window.resetSatHistoryView = function () {
+function resetSatHistoryView(): void {
   satImageHistory = [];
   if (satDom.historyList) satDom.historyList.innerHTML = "";
   renderSatLatestCard();
   renderSatHistoryTable();
-  if (window.clearSatMapOverlays) window.clearSatMapOverlays();
-};
+  satWindow.clearSatMapOverlays?.();
+}
 
-window.pruneSatHistoryView = function () {
+function pruneSatHistoryView(): void {
   renderSatHistoryTable();
   renderSatLatestCard();
-};
+}
+
+satWindow.trxPluginRuntime.registerDecoder({
+  id: "lrpt_image",
+  onMessage: onServerLrptImage,
+  reset: resetSatHistoryView,
+  prune: pruneSatHistoryView,
+});
+satWindow.trxPluginRuntime.registerDecoder({
+  id: "lrpt_progress",
+  onMessage: onServerLrptProgress,
+});
 
 // ── Toggle buttons ──────────────────────────────────────────────────
 const lrptDecodeToggleBtn = document.getElementById("lrpt-decode-toggle-btn");
-lrptDecodeToggleBtn?.addEventListener("click", async () => {
+lrptDecodeToggleBtn?.addEventListener("click", () => { void (async () => {
   try {
-    await window.takeSchedulerControlForDecoderDisable?.(lrptDecodeToggleBtn);
-    await postPath("/toggle_lrpt_decode");
+    await satWindow.takeSchedulerControlForDecoderDisable?.(lrptDecodeToggleBtn);
+    await hostCore.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();
+const satFilterInput = satDom.filterInput;
+satFilterInput?.addEventListener("input", () => {
+  satFilterText = satFilterInput.value.trim().toUpperCase();
   renderSatHistoryTable();
 });
 
-satDom.sortSelect?.addEventListener("change", () => renderSatHistoryTable());
-satDom.typeFilter?.addEventListener("change", () => renderSatHistoryTable());
+satDom.sortSelect?.addEventListener("change", () => { renderSatHistoryTable(); });
+satDom.typeFilter?.addEventListener("change", () => { renderSatHistoryTable(); });
 
 // ── Settings: clear history ─────────────────────────────────────────
 document
   .getElementById("settings-clear-sat-history")
-  ?.addEventListener("click", async () => {
-    if (!confirm("Clear all satellite decode history? This cannot be undone.")) return;
+  ?.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 postPath("/clear_lrpt_decode");
-      window.resetSatHistoryView();
+      await hostCore.postPath("/clear_lrpt_decode");
+      resetSatHistoryView();
     } catch (e) {
       console.error("Weather satellite history clear failed", e);
     }
-  });
+  })(); });
 
 // ── Predictions: helpers ────────────────────────────────────────────
-function azToCardinal(deg) {
+function azToCardinal(deg: number): string {
   const dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
-  return dirs[Math.round(deg / 45) % 8];
+  return dirs[Math.round(deg / 45) % 8] ?? "N";
 }
 
-function formatPredTime(ms) {
+function formatPredTime(ms: number): string {
   const d = new Date(ms);
   const now = new Date();
   const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-  const day = d.getUTCDay() !== now.getUTCDay() ? dayNames[d.getUTCDay()] + " " : "";
+  const 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) {
+function formatPredDuration(s: number): string {
   if (s >= 60) return `${Math.round(s / 60)} min`;
   return `${s}s`;
 }
 
-function formatCountdown(ms) {
+function formatCountdown(ms: number): string {
   const totalSec = Math.max(0, Math.floor(ms / 1000));
   const m = Math.floor(totalSec / 60);
   const s = totalSec % 60;
   return `${m}:${String(s).padStart(2, "0")}`;
 }
 
-function elevationClass(deg) {
+function elevationClass(deg: number): string {
   if (deg >= 45) return "sat-pred-el-high";
   if (deg >= 10) return "sat-pred-el-mid";
   return "sat-pred-el-low";
@@ -346,8 +377,8 @@ function stopCountdownTimer() {
   }
 }
 
-function startCountdownTimer(container) {
-  const countdownEls = container ? container.querySelectorAll(".sat-pred-col-countdown") : [];
+function startCountdownTimer(container: HTMLElement | null): void {
+  const countdownEls = container?.querySelectorAll<HTMLElement>(".sat-pred-col-countdown") ?? [];
   if (countdownEls.length === 0) return;
 
   satPredCountdownTimer = setInterval(() => {
@@ -358,7 +389,7 @@ function startCountdownTimer(container) {
     const n = Date.now();
     let anyActive = false;
     for (const el of countdownEls) {
-      const los = parseInt(el.dataset.los, 10);
+      const los = Number.parseInt(el.dataset.los ?? "0", 10);
       const rem = los - n;
       if (rem > 0) {
         el.textContent = formatCountdown(rem);
@@ -375,7 +406,7 @@ function startCountdownTimer(container) {
 }
 
 // ── Predictions: row builders ───────────────────────────────────────
-function buildCurrentPassRow(pass, now) {
+function buildCurrentPassRow(pass: SatellitePass, now: number): HTMLElement {
   const row = document.createElement("div");
   row.className = "sat-pred-row-current";
   const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
@@ -391,7 +422,7 @@ function buildCurrentPassRow(pass, now) {
   return row;
 }
 
-function buildUpcomingPassRow(pass) {
+function buildUpcomingPassRow(pass: SatellitePass): HTMLElement {
   const row = document.createElement("div");
   row.className = "sat-pred-row";
   const dir = `${azToCardinal(pass.azimuth_aos_deg)} \u2192 ${azToCardinal(pass.azimuth_los_deg)}`;
@@ -406,7 +437,7 @@ function buildUpcomingPassRow(pass) {
 }
 
 // ── Predictions: filter state ───────────────────────────────────────
-function getFilteredPredictions() {
+function getFilteredPredictions(): SatellitePass[] {
   let items = satPredData;
   if (satPredCategory !== "all") items = items.filter((p) => p.category === satPredCategory);
   if (satPredMinEl > 0) items = items.filter((p) => p.max_elevation_deg >= satPredMinEl);
@@ -418,23 +449,26 @@ function applyPredFilters() {
   renderSatPredictions(getFilteredPredictions());
 }
 
-satDom.predFilter?.addEventListener("input", () => {
-  satPredFilterText = satDom.predFilter.value.trim().toUpperCase();
+const satPredictionFilter = satDom.predFilter;
+satPredictionFilter?.addEventListener("input", () => {
+  satPredFilterText = satPredictionFilter.value.trim().toUpperCase();
   applyPredFilters();
 });
 
-satDom.predMinEl?.addEventListener("change", () => {
-  satPredMinEl = parseInt(satDom.predMinEl.value, 10) || 0;
+const satPredictionMinElevation = satDom.predMinEl;
+satPredictionMinElevation?.addEventListener("change", () => {
+  satPredMinEl = Number.parseInt(satPredictionMinElevation.value, 10) || 0;
   applyPredFilters();
 });
 
-satDom.predCategory?.addEventListener("change", () => {
-  satPredCategory = satDom.predCategory.value;
+const satPredictionCategory = satDom.predCategory;
+satPredictionCategory?.addEventListener("change", () => {
+  satPredCategory = satPredictionCategory.value;
   applyPredFilters();
 });
 
 // ── Predictions: main render ────────────────────────────────────────
-function renderSatPredictions(passes, error) {
+function renderSatPredictions(passes: SatellitePass[], error?: string): void {
   stopCountdownTimer();
 
   if (error) {
@@ -508,14 +542,14 @@ function renderSatPredictions(passes, error) {
 }
 
 // ── Predictions: data loading ───────────────────────────────────────
-async function loadSatPredictions() {
+async function loadSatPredictions(): Promise<void> {
   if (satDom.predStatus)       satDom.predStatus.textContent = "Loading predictions\u2026";
   if (satDom.predCurrentList)  satDom.predCurrentList.innerHTML = "";
   if (satDom.predUpcomingList) satDom.predUpcomingList.innerHTML = "";
   try {
     const resp = await fetch("/sat_passes");
     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    const data = await resp.json();
+    const data = await resp.json() as SatellitePassResponse;
     satPredSatCount = data.satellite_count || 0;
     if (data.error) {
       satPredData = [];
@@ -524,20 +558,20 @@ async function loadSatPredictions() {
       satPredData = data.passes || [];
       renderSatPredictions(getFilteredPredictions());
     }
-  } catch (e) {
-    renderSatPredictions([], `Failed to load predictions: ${e.message}`);
+  } catch (error: unknown) {
+    renderSatPredictions([], `Failed to load predictions: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 
 // ── Navigate to map centered on satellite image bounds ──────────────
-window.satShowOnMap = function (south, west, north, east) {
-  if (typeof window.enableMapSourceFilter === "function") {
-    window.enableMapSourceFilter("sat");
+satWindow.satShowOnMap = function (south: number, west: number, north: number, east: number) {
+  if (typeof satWindow.enableMapSourceFilter === "function") {
+    satWindow.enableMapSourceFilter("sat");
   }
   const lat = (south + north) / 2;
   const lon = (west + east) / 2;
-  if (window.navigateToAprsMap) {
-    window.navigateToAprsMap(lat, lon);
+  if (satWindow.navigateToAprsMap) {
+    satWindow.navigateToAprsMap(lat, lon);
   }
 };
 

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/satellite-types.ts

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+export interface SatelliteImage {
+  ts_ms?: number | null;
+  satellite?: string;
+  channels?: string;
+  channel_a?: string;
+  channel_b?: string;
+  mcu_count?: number;
+  line_count?: number;
+  path?: string;
+  geo_bounds?: [number, number, number, number];
+  _tsMs?: number;
+  _ts?: string;
+  _decoder?: "lrpt";
+}
+
+export interface LrptProgress { mcu_count?: number }
+export interface SatelliteLiveUpdate { lrpt_decode_enabled?: boolean }
+
+export interface SatellitePass {
+  satellite: string;
+  category: string;
+  aos_ms: number;
+  los_ms: number;
+  duration_s: number;
+  azimuth_aos_deg: number;
+  azimuth_los_deg: number;
+  max_elevation_deg: number;
+}
+
+export interface SatellitePassResponse {
+  satellite_count?: number;
+  error?: string | null;
+  passes?: SatellitePass[];
+}
+
+export interface SatelliteScheduleEntry {
+  id: string;
+  satellite: string;
+  norad_id: number;
+  bookmark_id: string;
+  min_elevation_deg: number;
+  priority: number;
+  center_hz: number | null;
+  bookmark_ids: string[];
+}
+
+export interface SatelliteScheduleConfig {
+  enabled: boolean;
+  pretune_secs: number;
+  entries: SatelliteScheduleEntry[];
+}
+
+export interface SatelliteBookmark {
+  id: string;
+  name: string;
+  freq_hz: number;
+  mode: string;
+}
+
+export interface SchedulerConfigWithSatellites {
+  satellites?: SatelliteScheduleConfig;
+  [key: string]: unknown;
+}
+
+export interface SatelliteSchedulerStatus { active_satellite?: string | null }
+
+export interface SatelliteSchedulerBridge {
+  getConfig(): SchedulerConfigWithSatellites | null;
+  getStatus(): SatelliteSchedulerStatus | null;
+  getBookmarks(): SatelliteBookmark[];
+  markDirty(): void;
+}
+
+export interface SatelliteSchedulerApi {
+  wireEvents(): void;
+  renderSection(): void;
+  renderPassStatus(): void;
+  collectSatelliteConfig(): SatelliteScheduleConfig;
+}

src/trx-client/trx-frontend/trx-frontend-http/frontend/src/plugins/scheduler-types.ts

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { SatelliteScheduleConfig, SatelliteSchedulerApi } from "./satellite-types.js";
+
+export type SchedulerMode = "disabled" | "grayline" | "time_span";
+
+export interface SchedulerBookmark {
+  id: string;
+  name: string;
+  freq_hz: number;
+  mode: string;
+}
+
+export interface GraylineConfig {
+  lat: number;
+  lon: number;
+  transition_window_min: number;
+  day_bookmark_id: string | null;
+  night_bookmark_id: string | null;
+  dawn_bookmark_id: string | null;
+  dusk_bookmark_id: string | null;
+}
+
+export interface ScheduleEntry {
+  id?: string;
+  start_min: number;
+  end_min: number;
+  bookmark_id: string;
+  label: string | null;
+  interleave_min: number | null;
+  center_hz: number | null;
+  bookmark_ids: string[];
+  record: boolean;
+  exclusive?: boolean;
+}
+
+export interface SchedulerConfig {
+  remote: string | null;
+  mode: SchedulerMode;
+  grayline: GraylineConfig | null;
+  entries: ScheduleEntry[];
+  interleave_min?: number | null;
+  satellites?: SatelliteScheduleConfig | null;
+}
+
+export interface SchedulerStatus {
+  active: boolean;
+  last_entry_id?: string | null;
+  last_bookmark_id?: string | null;
+  last_bookmark_name?: string | null;
+  last_applied_utc?: number | null;
+  last_center_hz?: number | null;
+  last_bookmark_ids?: string[];
+  active_satellite?: string | null;
+  freq_hz?: number | null;
+  mode?: string | null;
+  active_decoders?: string[];
+}
+
+export interface SchedulerService {
+  initialize(rigId: string | null, role: string | null): void;
+  destroy(): void;
+  setRig(rigId: string | null): void;
+  wireEvents(): void;
+  getConfig(): SchedulerConfig | null;
+  getStatus(): SchedulerStatus | null;
+  getBookmarks(): SchedulerBookmark[];
+  markDirty(): void;
+}
+interface VirtualChannelService {
+  takeSchedulerControl(): Promise<void>;
+  releaseToScheduler(): Promise<void>;
+}
+
+export interface SchedulerWindow {
+  trx: { modules: { scheduler?: SchedulerService; vchan?: VirtualChannelService } };
+  trxUi: {
+    confirm(options: { title: string; message: string; confirmLabel: string; danger?: boolean }): Promise<boolean>;
+    notify?(message: string, options: { kind: "error" }): void;
+  };
+  satScheduler?: SatelliteSchedulerApi;
+}

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

@@ -2,27 +2,74 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore, hostState } from "./host.js";
+
+export {};
+
+interface VirtualChannel {
+  id: string;
+  index: number;
+  freq_hz: number;
+  mode: string;
+  bandwidth_hz?: number;
+  subscribers: number;
+  permanent: boolean;
+}
+interface ChannelsEvent { remote?: string | null; channels?: VirtualChannel[] }
+interface SessionEvent { session_id?: string | null }
+interface SchedulerReleaseState {
+  connected_sessions?: number;
+  released_sessions?: number;
+  all_released?: boolean;
+  current_session_released?: boolean;
+}
+// Callbacks the application publishes as documented transitional window
+// properties; all other application state and services arrive through the
+// typed host contract in ./host.ts.
+interface VirtualChannelBridge {
+  renderRdsOverlays?: () => void;
+  refreshRdsUi?: () => void;
+  trx?: { modules?: { vchan?: VirtualChannelService } };
+}
+
+interface VirtualChannelService {
+  readonly channels: readonly VirtualChannel[];
+  readonly activeId: string | null;
+  activeChannel(): VirtualChannel | null;
+  applyCapabilities(capabilities: { filter_controls?: boolean } | null): void;
+  handleSession(data: string): void;
+  handleChannels(data: string): void;
+  isOnVirtual(): boolean;
+  interceptMode(mode: string): Promise<boolean>;
+  interceptBandwidth(bandwidthHz: number): Promise<boolean>;
+  interceptFrequency(frequencyHz: number): boolean;
+  interceptFreqDisplay(): boolean;
+  takeSchedulerControl(): Promise<void>;
+  releaseToScheduler(): Promise<void>;
+}
+const vchanWindow = window as unknown as VirtualChannelBridge;
+
 // --- 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;
+let vchanSessionId: string | null = null;
+let vchanRigId: string | null = null;
+let vchanChannels: VirtualChannel[] = [];
+let vchanActiveId: string | null = null;
+let schedulerReleaseState: SchedulerReleaseState | null = null;
+let schedulerReleasePollTimer: ReturnType<typeof setInterval> | null = null;
 
-function vchanFmtFreq(hz) {
+function vchanFmtFreq(hz: number): string {
   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";
+  return `${String(hz)}\u202fHz`;
 }
 
-function schedulerReleaseSummaryText(state) {
+function schedulerReleaseSummaryText(state: SchedulerReleaseState | null): string {
   if (!state) return "Scheduler is controlling the rig.";
   const connected = Number(state.connected_sessions) || 0;
   const released = Number(state.released_sessions) || 0;
@@ -45,7 +92,7 @@ function schedulerReleaseSummaryText(state) {
 }
 
 function vchanRenderSchedulerRelease() {
-  const btn = document.getElementById("scheduler-release-btn");
+  const btn = document.getElementById("scheduler-release-btn") as HTMLButtonElement | null;
   const status = document.getElementById("scheduler-release-status");
   if (!btn || !status) return;
   const currentReleased = !!(schedulerReleaseState && schedulerReleaseState.current_session_released);
@@ -55,7 +102,7 @@ function vchanRenderSchedulerRelease() {
   status.textContent = schedulerReleaseSummaryText(schedulerReleaseState);
 }
 
-async function vchanPollSchedulerRelease() {
+async function vchanPollSchedulerRelease(): Promise<void> {
   if (!vchanSessionId) {
     schedulerReleaseState = null;
     vchanRenderSchedulerRelease();
@@ -64,7 +111,7 @@ async function vchanPollSchedulerRelease() {
   try {
     const resp = await fetch(`/scheduler-control?session_id=${encodeURIComponent(vchanSessionId)}`);
     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    schedulerReleaseState = await resp.json();
+    schedulerReleaseState = await resp.json() as SchedulerReleaseState;
     vchanRenderSchedulerRelease();
   } catch (e) {
     console.error("scheduler release status failed", e);
@@ -75,12 +122,12 @@ function vchanStartSchedulerReleasePolling() {
   if (schedulerReleasePollTimer) {
     clearInterval(schedulerReleasePollTimer);
   }
-  schedulerReleasePollTimer = setInterval(vchanPollSchedulerRelease, 10000);
+  schedulerReleasePollTimer = setInterval(() => { void vchanPollSchedulerRelease(); }, 10000);
 }
 
 async function vchanToggleSchedulerRelease() {
   if (!vchanSessionId) return;
-  const rigId = vchanRigId || (typeof lastActiveRigId !== "undefined" ? lastActiveRigId : null);
+  const rigId = vchanRigId || hostState.lastActiveRigId || null;
   try {
     const resp = await fetch("/scheduler-control", {
       method: "PUT",
@@ -88,7 +135,7 @@ async function vchanToggleSchedulerRelease() {
       body: JSON.stringify({ session_id: vchanSessionId, released: true, remote: rigId }),
     });
     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    schedulerReleaseState = await resp.json();
+    schedulerReleaseState = await resp.json() as SchedulerReleaseState;
     vchanRenderSchedulerRelease();
   } catch (e) {
     console.error("scheduler release toggle failed", e);
@@ -105,46 +152,46 @@ async function vchanTakeSchedulerControl() {
       body: JSON.stringify({ session_id: vchanSessionId, released: false }),
     });
     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    schedulerReleaseState = await resp.json();
+    schedulerReleaseState = await resp.json() as SchedulerReleaseState;
     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) {
+function vchanHandleSession(data: string): void {
   try {
-    const d = JSON.parse(data);
+    const d = JSON.parse(data) as SessionEvent;
     vchanSessionId = d.session_id || null;
-    vchanPollSchedulerRelease();
+    void vchanPollSchedulerRelease();
   } catch (e) {
     console.warn("vchan: bad session event", e);
   }
 }
 
 // Called by app.js when the SSE `channels` event arrives.
-function vchanHandleChannels(data) {
+function vchanHandleChannels(data: string): void {
   try {
-    const d = JSON.parse(data);
+    const d = JSON.parse(data) as ChannelsEvent;
     vchanRigId = d.remote || null;
     vchanChannels = d.channels || [];
     const ids = new Set(vchanChannels.map(c => c.id));
-    if (!vchanActiveId && vchanChannels.length > 0 && vchanSessionId) {
+    const primaryChannel = vchanChannels[0];
+    if (!vchanActiveId && primaryChannel && 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);
+      void vchanAutoJoinPrimary(primaryChannel.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;
+      vchanActiveId = vchanChannels[0]?.id ?? null;
       vchanReconnectAudio();
     }
     vchanRender();
     vchanRenderSchedulerRelease();
-    if (typeof renderRdsOverlays === "function") renderRdsOverlays();
+    vchanWindow.renderRdsOverlays?.();
   } catch (e) {
     console.warn("vchan: bad channels event", e);
   }
@@ -173,13 +220,13 @@ function vchanRender() {
       del.title = "Delete channel";
       del.addEventListener("click", e => {
         e.stopPropagation();
-        vchanDelete(ch.id);
+        void vchanDelete(ch.id);
       });
       btn.appendChild(del);
     }
 
     btn.addEventListener("click", () => {
-      if (ch.id !== vchanActiveId) vchanSubscribe(ch.id);
+      if (ch.id !== vchanActiveId) void vchanSubscribe(ch.id);
     });
 
     picker.appendChild(btn);
@@ -191,13 +238,11 @@ function vchanRender() {
   addBtn.className = "vchan-add";
   addBtn.textContent = "+";
   addBtn.title = "Allocate new virtual channel at current frequency";
-  addBtn.addEventListener("click", vchanAllocate);
+  addBtn.addEventListener("click", () => { void vchanAllocate(); });
   picker.appendChild(addBtn);
 
   vchanSyncAccentUI();
-  if (typeof updateDocumentTitle === "function" && typeof activeChannelRds === "function") {
-    updateDocumentTitle(activeChannelRds());
-  }
+  hostCore.updateDocumentTitle(hostCore.activeChannelRds());
   vchanRenderSchedulerRelease();
 }
 
@@ -205,10 +250,10 @@ 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
+  const freqHz = (typeof hostState.lastFreqHz === "number" && hostState.lastFreqHz > 0)
+    ? hostState.lastFreqHz
     : 0;
-  const modeEl = document.getElementById("mode");
+  const modeEl = document.getElementById("mode") as HTMLSelectElement | null;
   const mode = modeEl ? (modeEl.value || "USB") : "USB";
 
   try {
@@ -222,7 +267,7 @@ async function vchanAllocate() {
       console.warn("vchan: allocate failed —", msg);
       return;
     }
-    const ch = await resp.json();
+    const ch = await resp.json() as VirtualChannel;
     vchanActiveId = ch.id;
     // The SSE `channels` event will trigger vchanRender(); optimistically
     // mark active so the picker feels responsive even before the event arrives.
@@ -233,7 +278,7 @@ async function vchanAllocate() {
   }
 }
 
-async function vchanDelete(channelId) {
+async function vchanDelete(channelId: string): Promise<void> {
   if (!vchanRigId) return;
   try {
     const resp = await fetch(
@@ -252,7 +297,7 @@ async function vchanDelete(channelId) {
 // 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) {
+async function vchanAutoJoinPrimary(channelId: string): Promise<void> {
   if (!vchanSessionId || !vchanRigId) return;
   try {
     const resp = await fetch(
@@ -274,7 +319,7 @@ async function vchanAutoJoinPrimary(channelId) {
   }
 }
 
-async function vchanSubscribe(channelId) {
+async function vchanSubscribe(channelId: string): Promise<void> {
   if (!vchanSessionId || !vchanRigId) return;
   try {
     await vchanTakeSchedulerControl();
@@ -304,26 +349,24 @@ async function vchanSubscribe(channelId) {
 // - 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() {
+function vchanReconnectAudio(): void {
   // 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();
+  hostState.audioChannelOverride = ch?.id ?? null;
+  if (!hostState.rxActive) return;
+  hostCore.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();
+    hostCore.startRxAudio();
   }, 300);
 }
 
 // Called by app.js from applyCapabilities().
 // Shows the channel picker only for SDR rigs.
-function vchanApplyCapabilities(caps) {
+function vchanApplyCapabilities(caps: { filter_controls?: boolean } | null): void {
   const picker = document.getElementById("vchan-picker");
   if (!picker) return;
   picker.style.display = (caps && caps.filter_controls) ? "" : "none";
@@ -335,12 +378,12 @@ function vchanApplyCapabilities(caps) {
 // ---------------------------------------------------------------------------
 
 // Returns true when the active channel is a non-primary (virtual) channel.
-function vchanIsOnVirtual() {
+function vchanIsOnVirtual(): boolean {
   if (!vchanActiveId || vchanChannels.length === 0) return false;
-  return vchanActiveId !== vchanChannels[0].id;
+  return vchanActiveId !== vchanChannels[0]?.id;
 }
 
-function vchanActiveChannel() {
+function vchanActiveChannel(): VirtualChannel | null {
   return vchanChannels.find(c => c.id === vchanActiveId) || null;
 }
 
@@ -348,19 +391,15 @@ function vchanActiveChannel() {
 function vchanUpdateFreqDisplay() {
   const ch = vchanActiveChannel();
   if (!ch) return;
-  const el = document.getElementById("freq");
+  const el = document.getElementById("freq") as HTMLInputElement | null;
   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+$/, "");
-  }
+  el.value = hostCore.formatFreqForStep(ch.freq_hz, hostState.jogUnit);
 }
 
 // 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");
+  const modeEl = document.getElementById("mode") as HTMLSelectElement | null;
   if (!modeEl) return;
   if (vchanIsOnVirtual()) {
     const ch = vchanActiveChannel();
@@ -368,23 +407,21 @@ function vchanSyncModeDisplay() {
   }
   // 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();
+  if (typeof hostState.lastModeName === "string") {
+    if (modeUpper === "WFM" && hostState.lastModeName !== "WFM") {
+      hostCore.setJogDivisor(10);
+      hostCore.resetRdsDisplay();
+    } else if (modeUpper !== "WFM" && hostState.lastModeName === "WFM") {
+      hostCore.resetRdsDisplay();
     }
-    lastModeName = modeUpper;
+    hostState.lastModeName = modeUpper;
   }
-  if (typeof updateWfmControls === "function") updateWfmControls();
-  if (typeof updateSdrSquelchControlVisibility === "function") {
-    updateSdrSquelchControlVisibility();
-  }
-  if (typeof refreshRdsUi === "function") {
-    refreshRdsUi();
-  } else if (typeof positionRdsPsOverlay === "function") {
-    positionRdsPsOverlay();
+  hostCore.updateWfmControls();
+  hostCore.updateSdrSquelchControlVisibility();
+  if (vchanWindow.refreshRdsUi) {
+    vchanWindow.refreshRdsUi();
+  } else {
+    hostCore.positionRdsPsOverlay();
   }
 }
 
@@ -393,21 +430,16 @@ function vchanSyncBwDisplay() {
   if (!vchanIsOnVirtual()) return;
   const ch = vchanActiveChannel();
   if (!ch) return;
-  const bwEl = document.getElementById("spectrum-bw-input");
+  const bwEl = document.getElementById("spectrum-bw-input") as HTMLInputElement | null;
   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) {
+    bwHz = hostCore.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;
-    }
+    hostState.currentBandwidthHz = bwHz;
   }
 }
 
@@ -422,47 +454,39 @@ function vchanSyncAccentUI() {
     vchanUpdateFreqDisplay();
     vchanSyncModeDisplay();
     vchanSyncBwDisplay();
-  } else if (typeof _origRefreshFreqDisplay === "function") {
-    _origRefreshFreqDisplay();
-  }
-  if (typeof updateDocumentTitle === "function" && typeof activeChannelRds === "function") {
-    updateDocumentTitle(activeChannelRds());
+  } else {
+    hostCore.refreshFreqDisplay();
   }
+  hostCore.updateDocumentTitle(hostCore.activeChannelRds());
 }
 
-// Saved reference to the original refreshFreqDisplay from app.js.
-let _origRefreshFreqDisplay = null;
-
-function vchanSetChannelFreq(freqHz) {
+function vchanSetChannelFreq(freqHz: number): void {
   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 (hostState.lastSpectrumData && hostState.lastSpectrumData.sample_rate > 0) {
+    const halfSpan = hostState.lastSpectrumData.sample_rate / 2;
+    const center = hostState.lastSpectrumData.center_hz;
     if (Math.abs(freqHz - center) > halfSpan) {
-      if (typeof showHint === "function") {
-        showHint(
+      hostCore.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(
+  void vchanTakeSchedulerControl();
+  void 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));
+  ).catch((error: unknown) => { console.error("vchan: set freq error", error); });
 }
 
-async function vchanSetChannelBandwidth(bwHz) {
+async function vchanSetChannelBandwidth(bwHz: number): Promise<void> {
   if (!vchanRigId || !vchanActiveId) return;
   try {
     await vchanTakeSchedulerControl();
@@ -480,7 +504,7 @@ async function vchanSetChannelBandwidth(bwHz) {
   }
 }
 
-async function vchanSetChannelMode(mode) {
+async function vchanSetChannelMode(mode: string): Promise<void> {
   if (!vchanRigId || !vchanActiveId) return;
   try {
     await vchanTakeSchedulerControl();
@@ -501,65 +525,66 @@ async function vchanSetChannelMode(mode) {
 // 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) {
+async function vchanInterceptMode(mode: string): Promise<boolean> {
   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) {
+async function vchanInterceptBandwidth(bwHz: number): Promise<boolean> {
   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));
-      }
+// Called by setRigFrequency before it posts /set_freq.  When a non-primary
+// channel is active the change belongs to the channel API instead of the rig,
+// so this applies the optimistic local update and reports the tune as handled.
+function vchanInterceptFrequency(freqHz: number): boolean {
+  if (!vchanIsOnVirtual()) return false;
+  const targetHz = Math.round(freqHz);
+  hostCore.armOptimisticFrequency(targetHz);
+  hostCore.applyLocalTunedFrequency(targetHz);
   vchanSetChannelFreq(freqHz);
-      return;
-    }
-    // Scheduler control is fire-and-forget — don't block the freq change.
-    vchanTakeSchedulerControl();
-    if (typeof _orig === "function") _orig(freqHz);
-  };
-})();
+  return true;
+}
+
+// Called by the application's refreshFreqDisplay.  While a virtual channel is
+// active the field belongs to that channel, so report the render as handled.
+function vchanInterceptFreqDisplay(): boolean {
+  if (!vchanIsOnVirtual()) return false;
+  vchanUpdateFreqDisplay();
+  return true;
+}
+
+vchanWindow.trx ??= {};
+vchanWindow.trx.modules ??= {};
+vchanWindow.trx.modules.vchan = {
+  get channels() { return vchanChannels; },
+  get activeId() { return vchanActiveId; },
+  activeChannel: vchanActiveChannel,
+  applyCapabilities: vchanApplyCapabilities,
+  handleSession: vchanHandleSession,
+  handleChannels: vchanHandleChannels,
+  isOnVirtual: vchanIsOnVirtual,
+  interceptMode: vchanInterceptMode,
+  interceptBandwidth: vchanInterceptBandwidth,
+  interceptFrequency: vchanInterceptFrequency,
+  interceptFreqDisplay: vchanInterceptFreqDisplay,
+  takeSchedulerControl: vchanTakeSchedulerControl,
+  releaseToScheduler: vchanToggleSchedulerRelease,
+};
 
 (function initSchedulerReleaseControl() {
   const btn = document.getElementById("scheduler-release-btn");
   if (btn) {
     btn.addEventListener("click", () => {
-      vchanToggleSchedulerRelease();
+      void 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/frontend/src/plugins/vdes.ts

@@ -2,54 +2,101 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore } from "./host.js";
+
+export {};
+
+import type { PluginRuntimeWindow } from "./runtime-contract";
+
+interface VdesMessage {
+  rig_id?: string | null;
+  message_type?: number;
+  bit_len?: number;
+  raw_bytes?: number[];
+  lat?: number | null;
+  lon?: number | null;
+  vessel_name?: string | null;
+  callsign?: string | null;
+  destination?: string | null;
+  message_label?: string | null;
+  session_id?: number | null;
+  source_id?: number | null;
+  destination_id?: number | null;
+  data_count?: number | null;
+  asm_identifier?: number | null;
+  ack_nack_mask?: number | null;
+  channel_quality?: number | null;
+  payload_preview?: string | null;
+  link_id?: number | null;
+  sync_score?: number | null;
+  sync_errors?: number | null;
+  phase_rotation?: number | null;
+  fec_state?: string | null;
+  ts_ms?: number | null;
+  _tsMs?: number;
+  _ts?: string;
+}
+
+interface VdesBridge {
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
+  vdesMapAddPoint?: (message: VdesMessage) => void;
+  updateVdesBar?: () => void;
+  clearVdesBar?: () => void;
+}
+
+const vdesWindow = window as unknown as VdesBridge;
+const escapeVdesHtml = (input: string): string => hostCore.escapeMapHtml(input);
+
 // --- 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 vdesFilterInput = document.getElementById("vdes-filter") as HTMLInputElement | null;
 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 = [];
+let vdesMessageHistory: VdesMessage[] = [];
 
-function currentVdesHistoryRetentionMs() {
-  return typeof window.getDecodeHistoryRetentionMs === "function"
-    ? window.getDecodeHistoryRetentionMs()
+function currentVdesHistoryRetentionMs(): number {
+  return typeof vdesWindow.getDecodeHistoryRetentionMs === "function"
+    ? vdesWindow.getDecodeHistoryRetentionMs()
     : 24 * 60 * 60 * 1000;
 }
 
 function pruneVdesMessageHistory() {
   const cutoffMs = Date.now() - currentVdesHistoryRetentionMs();
-  vdesMessageHistory = vdesMessageHistory.filter((msg) => Number(msg?._tsMs) >= cutoffMs);
+  vdesMessageHistory = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs);
 }
 
-function scheduleVdesUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === "function") {
-    window.trxScheduleUiFrameJob(key, job);
+function scheduleVdesUi(key: string, job: () => void): void {
+  if (typeof vdesWindow.trxScheduleUiFrameJob === "function") {
+    vdesWindow.trxScheduleUiFrameJob(key, job);
     return;
   }
   job();
 }
 
 function scheduleVdesHistoryRender() {
-  scheduleVdesUi("vdes-history", () => renderVdesHistory());
+  scheduleVdesUi("vdes-history", () => { renderVdesHistory(); });
 }
 
 function scheduleVdesBarUpdate() {
-  scheduleVdesUi("vdes-bar", () => updateVdesBar());
+  scheduleVdesUi("vdes-bar", () => { updateVdesBar(); });
 }
 
 function currentVdesCenterText() {
-  const raw = (document.getElementById("freq")?.value || "").replace(/[^\d]/g, "");
+  const raw = ((document.getElementById("freq") as HTMLInputElement | null)?.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";
+function vdesAgeText(tsMs: number | undefined): string {
+  if (typeof tsMs !== "number" || !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";
@@ -60,11 +107,11 @@ function vdesAgeText(tsMs) {
   return `${hours}h ago`;
 }
 
-function vdesHexPreview(rawBytes) {
+function vdesHexPreview(rawBytes: number[] | undefined): string {
   if (!Array.isArray(rawBytes) || rawBytes.length === 0) return "--";
   return rawBytes
     .slice(0, 20)
-    .map((value) => Number(value).toString(16).padStart(2, "0"))
+    .map((value) => value.toString(16).padStart(2, "0"))
     .join(" ")
     .toUpperCase();
 }
@@ -84,7 +131,7 @@ function updateVdesSummary() {
   }
 }
 
-function applyVdesFilterToRow(row) {
+function applyVdesFilterToRow(row: HTMLElement): void {
   if (!vdesFilterText) {
     row.style.display = "";
     return;
@@ -93,12 +140,7 @@ function applyVdesFilterToRow(row) {
   row.style.display = text.includes(vdesFilterText) ? "" : "none";
 }
 
-function applyVdesFilterToAll() {
-  if (!vdesMessagesEl) return;
-  vdesMessagesEl.querySelectorAll(".vdes-message").forEach((row) => applyVdesFilterToRow(row));
-}
-
-function renderVdesRow(msg) {
+function renderVdesRow(msg: VdesMessage): HTMLElement {
   const row = document.createElement("div");
   row.className = "vdes-message";
   const ts = msg._ts || new Date().toLocaleTimeString([], {
@@ -150,32 +192,32 @@ function renderVdesRow(msg) {
   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>` +
+      `<span class="vdes-call">${escapeVdesHtml(title)}</span>` +
+      `<span class="vdes-badge">${escapeVdesHtml(label)}</span>` +
+      (labelText ? `<span class="vdes-badge">${escapeVdesHtml(labelText)}</span>` : "") +
+      (linkText ? `<span class="vdes-badge">${escapeVdesHtml(linkText)}</span>` : "") +
+      (srcText ? `<span class="vdes-badge">${escapeVdesHtml(srcText)}</span>` : "") +
+      (dstText ? `<span class="vdes-badge">${escapeVdesHtml(dstText)}</span>` : "") +
+      (syncText ? `<span class="vdes-badge">${escapeVdesHtml(syncText)}</span>` : "") +
+      (phaseText ? `<span class="vdes-badge">${escapeVdesHtml(phaseText)}</span>` : "") +
+      `<span class="vdes-badge">T${escapeVdesHtml(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>` +
+      `<span>${escapeVdesHtml(currentVdesCenterText())}</span>` +
+      `<span>${escapeVdesHtml(`${msg.bit_len || 0} bits`)}</span>` +
+      (sessionText ? `<span>${escapeVdesHtml(sessionText)}</span>` : "") +
+      (asmText ? `<span>${escapeVdesHtml(asmText)}</span>` : "") +
+      (countText ? `<span>${escapeVdesHtml(countText)}</span>` : "") +
+      (ackText ? `<span>${escapeVdesHtml(ackText)}</span>` : "") +
+      (cqiText ? `<span>${escapeVdesHtml(cqiText)}</span>` : "") +
+      (info ? `<span>${escapeVdesHtml(info)}</span>` : "") +
+      (fecText ? `<span>${escapeVdesHtml(fecText)}</span>` : "") +
+      `<span>${escapeVdesHtml(vdesAgeText(msg._tsMs))}</span>` +
     `</div>` +
     `<div class="vdes-row-detail">` +
-      (previewText ? `<span>${escapeMapHtml(previewText)}</span>` : "") +
+      (previewText ? `<span>${escapeVdesHtml(previewText)}</span>` : "") +
       (previewText ? `<span>·</span>` : "") +
-      `<span class="vdes-raw">${escapeMapHtml(rawHex)}</span>` +
+      `<span class="vdes-raw">${escapeVdesHtml(rawHex)}</span>` +
     `</div>`;
   applyVdesFilterToRow(row);
   return row;
@@ -184,9 +226,9 @@ function renderVdesRow(msg) {
 function updateVdesBar() {
   if (!vdesBarOverlay) return;
   updateVdesSummary();
-  const isVdes = (document.getElementById("mode")?.value || "").toUpperCase() === "VDES";
+  const isVdes = ((document.getElementById("mode") as HTMLSelectElement | null)?.value || "").toUpperCase() === "VDES";
   const cutoffMs = Date.now() - VDES_BAR_WINDOW_MS;
-  const messages = vdesMessageHistory.filter((msg) => msg._tsMs >= cutoffMs).slice(0, 6);
+  const messages = vdesMessageHistory.filter((msg) => (msg._tsMs ?? 0) >= cutoffMs).slice(0, 6);
   if (!isVdes || messages.length === 0) {
     vdesBarOverlay.style.display = "none";
     vdesBarOverlay.innerHTML = "";
@@ -196,19 +238,19 @@ function updateVdesBar() {
   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 label = escapeVdesHtml(msg.callsign || "VDES");
+    const title = escapeVdesHtml(msg.vessel_name || "Burst");
     const detail = [
       `${msg.bit_len || 0} bits`,
-      msg.message_label ? escapeMapHtml(msg.message_label) : null,
+      msg.message_label ? escapeVdesHtml(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)),
+      msg.destination ? escapeVdesHtml(msg.destination) : null,
+      escapeVdesHtml(vdesAgeText(msg._tsMs)),
     ]
       .filter(Boolean)
       .join(" · ");
@@ -217,17 +259,17 @@ function updateVdesBar() {
   vdesBarOverlay.innerHTML = html;
   vdesBarOverlay.style.display = "flex";
 }
-window.updateVdesBar = updateVdesBar;
-window.clearVdesBar = function() {
-  window.resetVdesHistoryView();
+vdesWindow.updateVdesBar = updateVdesBar;
+vdesWindow.clearVdesBar = function() {
+  resetVdesHistoryView();
 };
 
-window.resetVdesHistoryView = function() {
+function resetVdesHistoryView(): void {
   if (vdesMessagesEl) vdesMessagesEl.innerHTML = "";
   vdesMessageHistory = [];
   updateVdesBar();
   renderVdesHistory();
-};
+}
 
 function renderVdesHistory() {
   pruneVdesMessageHistory();
@@ -236,14 +278,14 @@ function renderVdesHistory() {
     return;
   }
   const fragment = document.createDocumentFragment();
-  for (let i = 0; i < vdesMessageHistory.length; i += 1) {
-    fragment.appendChild(renderVdesRow(vdesMessageHistory[i]));
+  for (const message of vdesMessageHistory) {
+    fragment.appendChild(renderVdesRow(message));
   }
   vdesMessagesEl.replaceChildren(fragment);
   updateVdesSummary();
 }
 
-function addVdesMessage(msg) {
+function addVdesMessage(msg: VdesMessage): void {
   const tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
   msg._tsMs = tsMs;
   msg._ts = new Date(tsMs).toLocaleTimeString([], {
@@ -258,39 +300,17 @@ function addVdesMessage(msg) {
   scheduleVdesHistoryRender();
 }
 
-function normalizeServerVdesMessage(msg) {
+function normalizeServerVdesMessage(msg: VdesMessage): VdesMessage {
   return {
+    ...msg,
     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) {
+function onServerVdesBatch(messages: VdesMessage[]): void {
   if (!Array.isArray(messages) || messages.length === 0) return;
   if (vdesStatus) vdesStatus.textContent = "Receiving";
-  const normalized = [];
+  const normalized: VdesMessage[] = [];
   for (const msg of messages) {
     const next = normalizeServerVdesMessage(msg);
     const tsMs = Number.isFinite(next.ts_ms) ? Number(next.ts_ms) : Date.now();
@@ -300,8 +320,8 @@ window.onServerVdesBatch = function(messages) {
       minute: "2-digit",
       second: "2-digit",
     });
-    if (next.lat != null && next.lon != null && window.vdesMapAddPoint) {
-      window.vdesMapAddPoint(next);
+    if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
+      vdesWindow.vdesMapAddPoint(next);
     }
     normalized.push(next);
   }
@@ -310,21 +330,17 @@ window.onServerVdesBatch = function(messages) {
   pruneVdesMessageHistory();
   scheduleVdesBarUpdate();
   scheduleVdesHistoryRender();
-};
+}
 
-window.restoreVdesHistory = function(messages) {
-  window.onServerVdesBatch(messages);
-};
-
-document.getElementById("settings-clear-vdes-history")?.addEventListener("click", async () => {
-  if (!confirm("Clear all VDES decode history? This cannot be undone.")) return;
+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 postPath("/clear_vdes_decode");
-    window.resetVdesHistoryView();
+    await hostCore.postPath("/clear_vdes_decode");
+    resetVdesHistoryView();
   } catch (e) {
     console.error("VDES history clear failed", e);
   }
-});
+})(); });
 
 if (vdesFilterInput) {
   vdesFilterInput.addEventListener("input", () => {
@@ -333,20 +349,27 @@ if (vdesFilterInput) {
   });
 }
 
-window.onServerVdes = function(msg) {
+function onServerVdes(msg: VdesMessage): void {
   if (vdesStatus) vdesStatus.textContent = "Receiving";
   const next = normalizeServerVdesMessage(msg);
   addVdesMessage(next);
-  if (next.lat != null && next.lon != null && window.vdesMapAddPoint) {
-    window.vdesMapAddPoint(next);
+  if (next.lat != null && next.lon != null && vdesWindow.vdesMapAddPoint) {
+    vdesWindow.vdesMapAddPoint(next);
   }
-};
+}
 
-window.pruneVdesHistoryView = function() {
+function pruneVdesHistoryView(): void {
   pruneVdesMessageHistory();
   updateVdesBar();
   renderVdesHistory();
-};
+}
 
 updateVdesSummary();
-if (window._trxDrainPendingDecode) window._trxDrainPendingDecode("vdes");
+(window as unknown as PluginRuntimeWindow).trxPluginRuntime.registerDecoder<VdesMessage>({
+  id: "vdes",
+  onMessage: onServerVdes,
+  onBatch: onServerVdesBatch,
+  restore: onServerVdesBatch,
+  reset: resetVdesHistoryView,
+  prune: pruneVdesHistoryView,
+});

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

@@ -2,6 +2,41 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+import { hostCore } from "./host.js";
+
+import type { PluginRuntimeWindow } from "./runtime-contract.js";
+
+export {};
+
+interface WefaxImage {
+  ts_ms?: number;
+  ioc?: number;
+  lpm?: number;
+  line_count?: number;
+  path?: string;
+  _tsMs?: number;
+  _ts?: string;
+  _dataUrl?: string;
+}
+
+interface WefaxProgress {
+  state?: string;
+  line_data?: string;
+  line_count?: number;
+  pixels_per_line?: number;
+  ioc?: number;
+  lpm?: number;
+}
+
+interface WefaxBridge {
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<unknown>;
+  syncWefaxToggle?: (enabled: boolean) => void;
+}
+
+const wefaxWindow = window as unknown as WefaxBridge & PluginRuntimeWindow;
+
 // ---------------------------------------------------------------------------
 // wefax.js — WEFAX decoder plugin for trx-frontend-http
 // Live view: decoder state, live canvas, latest image card
@@ -9,18 +44,18 @@
 // ---------------------------------------------------------------------------
 
 // ── DOM references (cached once) ───────────────────────────────────
-var wefaxDom = {
+const 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'),
+  liveCanvas:     document.getElementById('wefax-live-canvas') as HTMLCanvasElement | null,
   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'),
+  filterInput:    document.getElementById('wefax-filter') as HTMLInputElement | null,
+  sortSelect:     document.getElementById('wefax-sort') as HTMLSelectElement | null,
   toggleBtn:      document.getElementById('wefax-decode-toggle-btn'),
   clearBtn:       document.getElementById('wefax-clear-btn'),
   viewLiveBtn:    document.getElementById('wefax-view-live'),
@@ -28,25 +63,25 @@ var wefaxDom = {
 };
 
 // ── State ───────────────────────────────────────────────────────────
-var wefaxImageHistory = [];
-var WEFAX_MAX_IMAGES  = 100;
-var wefaxLiveCtx      = null;
-var wefaxLiveLineCount = 0;
-var wefaxLivePixelsPerLine = 1809;
-var wefaxActiveView   = 'live';
-var wefaxFilterText   = '';
+let wefaxImageHistory: WefaxImage[] = [];
+const WEFAX_MAX_IMAGES = 100;
+let wefaxLiveCtx: CanvasRenderingContext2D | null = null;
+let wefaxLiveLineCount = 0;
+let wefaxLivePixelsPerLine = 1809;
+let wefaxActiveView: 'live' | 'history' = 'live';
+let wefaxFilterText = '';
 
 // ── Helpers ─────────────────────────────────────────────────────────
-function currentWefaxHistoryRetentionMs() {
-  return window.getDecodeHistoryRetentionMs ? window.getDecodeHistoryRetentionMs() : 24 * 60 * 60 * 1000;
+function currentWefaxHistoryRetentionMs(): number {
+  return wefaxWindow.getDecodeHistoryRetentionMs?.() ?? 24 * 60 * 60 * 1000;
 }
 
 function pruneWefaxHistory() {
-  var cutoff = Date.now() - currentWefaxHistoryRetentionMs();
+  const cutoff = Date.now() - currentWefaxHistoryRetentionMs();
   wefaxImageHistory = wefaxImageHistory.filter(function (m) { return (m._tsMs || 0) > cutoff; });
 }
 
-function escapeHtml(s) {
+function escapeHtml(s: unknown): string {
   return String(s)
     .replace(/&/g, '&amp;')
     .replace(/</g, '&lt;')
@@ -54,16 +89,16 @@ function escapeHtml(s) {
     .replace(/"/g, '&quot;');
 }
 
-function scheduleWefaxUi(key, job) {
-  if (typeof window.trxScheduleUiFrameJob === 'function') {
-    window.trxScheduleUiFrameJob(key, job);
+function scheduleWefaxUi(key: string, job: () => void): void {
+  if (typeof wefaxWindow.trxScheduleUiFrameJob === 'function') {
+    wefaxWindow.trxScheduleUiFrameJob(key, job);
     return;
   }
   job();
 }
 
 // ── View switching ──────────────────────────────────────────────────
-function switchWefaxView(view) {
+function switchWefaxView(view: 'live' | 'history'): void {
   wefaxActiveView = view;
   if (wefaxDom.liveView)    wefaxDom.liveView.style.display = view === 'live' ? '' : 'none';
   if (wefaxDom.historyView) wefaxDom.historyView.style.display = view === 'history' ? '' : 'none';
@@ -81,33 +116,39 @@ if (wefaxDom.viewLiveBtn)    wefaxDom.viewLiveBtn.addEventListener('click', func
 if (wefaxDom.viewHistoryBtn) wefaxDom.viewHistoryBtn.addEventListener('click', function () { switchWefaxView('history'); });
 
 // ── Live canvas rendering ───────────────────────────────────────────
-function resetLiveCanvas(pixelsPerLine) {
+function resetLiveCanvas(pixelsPerLine: number): void {
+  const canvas = wefaxDom.liveCanvas;
+  if (!canvas) return;
   wefaxLivePixelsPerLine = pixelsPerLine;
   wefaxLiveLineCount = 0;
-  wefaxDom.liveCanvas.width = pixelsPerLine;
-  wefaxDom.liveCanvas.height = 800;
-  wefaxLiveCtx = wefaxDom.liveCanvas.getContext('2d');
+  canvas.width = pixelsPerLine;
+  canvas.height = 800;
+  wefaxLiveCtx = canvas.getContext('2d');
+  if (!wefaxLiveCtx) return;
   wefaxLiveCtx.fillStyle = '#000';
-  wefaxLiveCtx.fillRect(0, 0, wefaxDom.liveCanvas.width, wefaxDom.liveCanvas.height);
+  wefaxLiveCtx.fillRect(0, 0, canvas.width, canvas.height);
   if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = '';
 }
 
-function paintLine(lineBytes) {
-  if (!wefaxLiveCtx) return;
-  var y = wefaxLiveLineCount;
+function paintLine(lineBytes: Uint8Array): void {
+  const canvas = wefaxDom.liveCanvas;
+  if (!wefaxLiveCtx || !canvas) return;
+  const y = wefaxLiveLineCount;
 
-  if (y >= wefaxDom.liveCanvas.height) {
-    var old = wefaxLiveCtx.getImageData(0, 0, wefaxDom.liveCanvas.width, wefaxDom.liveCanvas.height);
-    wefaxDom.liveCanvas.height *= 2;
+  if (y >= canvas.height) {
+    const old = wefaxLiveCtx.getImageData(0, 0, canvas.width, canvas.height);
+    canvas.height *= 2;
+    wefaxLiveCtx = canvas.getContext('2d');
+    if (!wefaxLiveCtx) return;
     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;
+  const w = wefaxLivePixelsPerLine;
+  const imgData = wefaxLiveCtx.createImageData(w, 1);
+  const d = imgData.data;
+  for (let x = 0; x < w; x++) {
+    const v = lineBytes[x] ?? 0;
+    const i = x * 4;
     d[i] = v; d[i + 1] = v; d[i + 2] = v; d[i + 3] = 255;
   }
   wefaxLiveCtx.putImageData(imgData, 0, y);
@@ -123,23 +164,24 @@ function renderWefaxLatestCard() {
     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,
+  const img = wefaxImageHistory[0];
+  if (!img) return;
+  const ts = img._ts || '--';
+  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString() : '';
+  const meta = [
+    `${String(img.ioc ?? '--')} IOC`,
+    `${String(img.lpm ?? '--')} LPM`,
+    `${String(img.line_count ?? 0)} lines`,
+    `${date} ${ts}`,
   ].join(' \u00b7 ');
 
-  var imgSrc = img._dataUrl
+  const imgSrc = img._dataUrl
     ? img._dataUrl
     : img.path
       ? '/images/' + escapeHtml(img.path.split('/').pop())
       : null;
 
-  var html = '<div class="sat-latest-card">';
+  let 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) {
@@ -151,11 +193,11 @@ function renderWefaxLatestCard() {
 
 // ── History view: table ─────────────────────────────────────────────
 function getWefaxFilteredHistory() {
-  var items = wefaxImageHistory;
+  let items = wefaxImageHistory;
 
   if (wefaxFilterText) {
     items = items.filter(function (i) {
-      var haystack = [
+      const haystack = [
         String(i.ioc || ''),
         String(i.lpm || ''),
         String(i.line_count || ''),
@@ -164,28 +206,28 @@ function getWefaxFilteredHistory() {
     });
   }
 
-  var sortVal = wefaxDom.sortSelect ? wefaxDom.sortSelect.value : 'newest';
+  const sortVal = wefaxDom.sortSelect ? wefaxDom.sortSelect.value : 'newest';
   if (sortVal === 'oldest') items = items.slice().reverse();
 
   return items;
 }
 
-function renderWefaxHistoryRow(img) {
-  var row = document.createElement('div');
+function renderWefaxHistoryRow(img: WefaxImage): HTMLElement {
+  const 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;
+  const ts = img._ts || '--';
+  const date = img._tsMs ? new Date(img._tsMs).toLocaleDateString([], { month: 'short', day: 'numeric' }) : '';
+  const ioc = img.ioc || '--';
+  const lpm = img.lpm || '--';
+  const lines = img.line_count || 0;
 
-  var imgSrc = img._dataUrl
+  const imgSrc = img._dataUrl
     ? img._dataUrl
     : img.path
       ? '/images/' + escapeHtml(img.path.split('/').pop())
       : null;
-  var link = imgSrc
+  const link = imgSrc
     ? '<a href="' + imgSrc + '" target="_blank" style="color:var(--accent);">View</a>'
     : '--';
 
@@ -193,7 +235,7 @@ function renderWefaxHistoryRow(img) {
     '<span>' + escapeHtml(date + ' ' + ts) + '</span>',
     '<span>' + escapeHtml(String(ioc)) + '</span>',
     '<span>' + escapeHtml(String(lpm)) + '</span>',
-    '<span>' + lines + '</span>',
+    `<span>${String(lines)}</span>`,
     '<span>' + link + '</span>',
   ].join('');
 
@@ -203,28 +245,28 @@ function renderWefaxHistoryRow(img) {
 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]));
+  const items = getWefaxFilteredHistory();
+  const fragment = document.createDocumentFragment();
+  for (const item of items) {
+    fragment.appendChild(renderWefaxHistoryRow(item));
   }
   wefaxDom.historyList.replaceChildren(fragment);
 
   if (wefaxDom.historyCount) {
-    var total = wefaxImageHistory.length;
-    var shown = items.length;
+    const total = wefaxImageHistory.length;
+    const shown = items.length;
     wefaxDom.historyCount.textContent =
       total === 0
         ? 'No images yet'
         : shown === total
-          ? total + ' image' + (total === 1 ? '' : 's')
-          : shown + ' of ' + total + ' images';
+          ? `${String(total)} image${total === 1 ? '' : 's'}`
+          : `${String(shown)} of ${String(total)} images`;
   }
 }
 
 // ── Add image to history ────────────────────────────────────────────
-function addWefaxImage(msg) {
-  var tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
+function addWefaxImage(msg: WefaxImage): void {
+  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',
@@ -233,11 +275,14 @@ function addWefaxImage(msg) {
   });
 
   // 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;
+  const canvas = wefaxDom.liveCanvas;
+  if (wefaxLiveCtx && canvas && wefaxLiveLineCount > 0) {
+    const trimmed = wefaxLiveCtx.getImageData(0, 0, canvas.width, wefaxLiveLineCount);
+    canvas.height = wefaxLiveLineCount;
+    wefaxLiveCtx = canvas.getContext('2d');
+    if (!wefaxLiveCtx) return;
     wefaxLiveCtx.putImageData(trimmed, 0, 0);
-    try { msg._dataUrl = wefaxDom.liveCanvas.toDataURL('image/png'); } catch (e) {}
+    try { msg._dataUrl = canvas.toDataURL('image/png'); } catch {}
   }
 
   wefaxImageHistory.unshift(msg);
@@ -252,7 +297,7 @@ function addWefaxImage(msg) {
 }
 
 // ── SSE event handlers (public API) ─────────────────────────────────
-window.onServerWefaxProgress = function (msg) {
+function onServerWefaxProgress(msg: WefaxProgress): void {
   // State-only update (no image data): show decoder state in status.
   if (msg.state && !msg.line_data) {
     if (wefaxDom.status) {
@@ -263,43 +308,43 @@ window.onServerWefaxProgress = function (msg) {
     return;
   }
 
-  if (msg.line_count <= 1 || !wefaxLiveCtx) {
+  if ((msg.line_count ?? 0) <= 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);
+    const binary = atob(msg.line_data);
+    const bytes = new Uint8Array(binary.length);
+    for (let 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';
+      `Line ${String(msg.line_count ?? 0)} \u00b7 ${String(msg.ioc ?? '--')} IOC \u00b7 ${String(msg.lpm ?? '--')} LPM`;
   }
   if (wefaxDom.status) {
-    wefaxDom.status.textContent = 'Receiving \u2014 line ' + msg.line_count;
+    wefaxDom.status.textContent = `Receiving \u2014 line ${String(msg.line_count ?? 0)}`;
     wefaxDom.status.style.color = 'var(--text-accent)';
   }
-};
+}
 
-window.onServerWefax = function (msg) {
+function onServerWefax(msg: WefaxImage): void {
   addWefaxImage(msg);
 
   if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = 'none';
   if (wefaxDom.status) {
-    wefaxDom.status.textContent = 'Complete \u2014 ' + msg.line_count + ' lines';
+    wefaxDom.status.textContent = `Complete \u2014 ${String(msg.line_count ?? 0)} 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([], {
+function restoreWefaxHistory(messages: WefaxImage[]): void {
+  if (!messages.length) return;
+  for (const message of messages) {
+    const tsMs = Number.isFinite(message.ts_ms) ? Number(message.ts_ms) : Date.now();
+    message._tsMs = tsMs;
+    message._ts = new Date(tsMs).toLocaleTimeString([], {
       hour: '2-digit',
       minute: '2-digit',
       second: '2-digit',
@@ -311,15 +356,15 @@ window.restoreWefaxHistory = function (messages) {
   if (wefaxActiveView === 'history') {
     scheduleWefaxUi('wefax-history', renderWefaxHistoryTable);
   }
-};
+}
 
-window.pruneWefaxHistoryView = function () {
+function pruneWefaxHistoryView(): void {
   pruneWefaxHistory();
   renderWefaxHistoryTable();
   renderWefaxLatestCard();
-};
+}
 
-window.resetWefaxHistoryView = function () {
+function resetWefaxHistoryView(): void {
   wefaxImageHistory = [];
   if (wefaxDom.historyList) wefaxDom.historyList.innerHTML = '';
   if (wefaxDom.liveContainer) wefaxDom.liveContainer.style.display = 'none';
@@ -331,12 +376,13 @@ window.resetWefaxHistoryView = function () {
     wefaxDom.status.textContent = 'Idle';
     wefaxDom.status.style.color = '';
   }
-};
+}
 
 // ── Filter / sort handlers ──────────────────────────────────────────
 if (wefaxDom.filterInput) {
+  const filterInput = wefaxDom.filterInput;
   wefaxDom.filterInput.addEventListener('input', function () {
-    wefaxFilterText = wefaxDom.filterInput.value.trim().toUpperCase();
+    wefaxFilterText = filterInput.value.trim().toUpperCase();
     scheduleWefaxUi('wefax-history', renderWefaxHistoryTable);
   });
 }
@@ -350,7 +396,7 @@ if (wefaxDom.sortSelect) {
 // 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) {
+wefaxWindow.syncWefaxToggle = function (enabled: boolean) {
   if (!wefaxDom.toggleBtn) return;
   wefaxDom.toggleBtn.dataset.enabled = enabled ? 'true' : 'false';
   wefaxDom.toggleBtn.textContent = enabled ? 'Disable WEFAX' : 'Enable WEFAX';
@@ -360,27 +406,40 @@ window.syncWefaxToggle = function (enabled) {
 
 // ── Button handlers ─────────────────────────────────────────────────
 if (wefaxDom.toggleBtn) {
-  wefaxDom.toggleBtn.addEventListener('click', async function () {
+  const toggleButton = wefaxDom.toggleBtn;
+  wefaxDom.toggleBtn.addEventListener('click', () => { void (async () => {
     try {
-      if (window.takeSchedulerControlForDecoderDisable) {
-        await window.takeSchedulerControlForDecoderDisable(wefaxDom.toggleBtn);
+      if (wefaxWindow.takeSchedulerControlForDecoderDisable) {
+        await wefaxWindow.takeSchedulerControlForDecoderDisable(toggleButton);
       }
-      await postPath('/toggle_wefax_decode');
+      await hostCore.postPath('/toggle_wefax_decode');
     } catch (e) {
       console.error('WEFAX toggle failed', e);
     }
-  });
+  })(); });
 }
 if (wefaxDom.clearBtn) {
-  wefaxDom.clearBtn.addEventListener('click', async function () {
+  wefaxDom.clearBtn.addEventListener('click', () => { void (async () => {
     try {
-      await postPath('/clear_wefax_decode');
-      window.resetWefaxHistoryView();
+      await hostCore.postPath('/clear_wefax_decode');
+      resetWefaxHistoryView();
     } catch (e) {
       console.error('WEFAX clear failed', e);
     }
-  });
+  })(); });
 }
 
 // ── Initial render ──────────────────────────────────────────────────
 renderWefaxLatestCard();
+
+wefaxWindow.trxPluginRuntime.registerDecoder({
+  id: "wefax",
+  onMessage: onServerWefax,
+  restore: restoreWefaxHistory,
+  prune: pruneWefaxHistoryView,
+  reset: resetWefaxHistoryView,
+});
+wefaxWindow.trxPluginRuntime.registerDecoder({
+  id: "wefax_progress",
+  onMessage: onServerWefaxProgress,
+});

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

@@ -0,0 +1,333 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { hostCore } from "./host.js";
+
+import type { PluginRuntimeWindow } from "./runtime-contract.js";
+
+export {};
+
+interface WsprMessage {
+  message?: string | undefined;
+  ts_ms?: number | undefined;
+  _tsMs?: number | undefined;
+  snr_db?: number | undefined;
+  dt_s?: number | undefined;
+  freq_hz?: number | undefined;
+  receiver?: unknown;
+  [key: string]: unknown;
+}
+interface WsprBridge {
+  getDecodeHistoryRetentionMs?: () => number;
+  trxScheduleUiFrameJob?: (key: string, job: () => void) => void;
+  ft8BaseHz?: number;
+  getDecodeRigMeta?: () => unknown;
+  mapAddLocator?: (raw: string, grids: string[], type: "wspr", station: string | null, message: WsprMessage) => void;
+  navigateToMapLocator?: (grid: string, type: "wspr") => void;
+  clearMapMarkersByType?: (type: "wspr") => void;
+  takeSchedulerControlForDecoderDisable?: (button: HTMLElement) => Promise<void>;
+  trxUi: { confirm(options: { title: string; message: string; confirmLabel: string }): Promise<boolean> };
+  [key: string]: unknown;
+}
+const wsprWindow = window as unknown as WsprBridge & PluginRuntimeWindow;
+
+// --- 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") as HTMLInputElement | null;
+const WSPR_PERIOD_SECONDS = 120;
+let wsprFilterText = "";
+let wsprMessageHistory: WsprMessage[] = [];
+
+function finiteNumber(value: unknown): number | null {
+  const number = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function currentWsprHistoryRetentionMs(): number {
+  return typeof wsprWindow.getDecodeHistoryRetentionMs === "function"
+    ? wsprWindow.getDecodeHistoryRetentionMs()
+    : 24 * 60 * 60 * 1000;
+}
+
+function pruneWsprMessageHistory(): void {
+  const cutoffMs = Date.now() - currentWsprHistoryRetentionMs();
+  wsprMessageHistory = wsprMessageHistory.filter((msg) => Number(msg._tsMs ?? msg.ts_ms) >= cutoffMs);
+}
+
+function scheduleWsprHistoryRender(): void {
+  if (typeof wsprWindow.trxScheduleUiFrameJob === "function") {
+    wsprWindow.trxScheduleUiFrameJob("wspr-history", () => { renderWsprHistory(); });
+    return;
+  }
+  renderWsprHistory();
+}
+
+function fmtWsprTime(tsMs: number | undefined): string {
+  if (!tsMs) return "--:--:--";
+  return new Date(tsMs).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
+function updateWsprPeriodTimer(): void {
+  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: WsprMessage): HTMLDivElement {
+  const row = document.createElement("div");
+  row.className = "ft8-row";
+  row.dataset.decoder = "wspr";
+  const snr = finiteNumber(msg.snr_db);
+  const delta = finiteNumber(msg.dt_s);
+  const baseHz = finiteNumber(wsprWindow.ft8BaseHz);
+  const offsetHz = finiteNumber(msg.freq_hz);
+  const rfHz = offsetHz !== null && baseHz !== null ? baseHz + offsetHz : null;
+  const freq = rfHz?.toFixed(0) ?? "--";
+  const message = msg.message ?? "";
+  row.dataset.message = message.toUpperCase();
+  row.innerHTML = `<span class="ft8-time">${fmtWsprTime(msg.ts_ms)}</span><span class="ft8-snr">${snr?.toFixed(1) ?? "--"}</span><span class="ft8-dt">${delta?.toFixed(2) ?? "--"}</span><span class="ft8-freq">${freq}</span><span class="ft8-msg">${renderWsprMessage(message)}</span>`;
+  applyWsprFilterToRow(row);
+  return row;
+}
+
+function renderWsprHistory(): void {
+  pruneWsprMessageHistory();
+  if (!wsprMessagesEl) return;
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < wsprMessageHistory.length; i += 1) {
+    const message = wsprMessageHistory[i];
+    if (message) fragment.appendChild(renderWsprRow(message));
+  }
+  wsprMessagesEl.replaceChildren(fragment);
+}
+
+function addWsprMessage(msg: WsprMessage): void {
+  msg._tsMs = Number.isFinite(msg.ts_ms) ? Number(msg.ts_ms) : Date.now();
+  wsprMessageHistory.unshift(msg);
+  pruneWsprMessageHistory();
+  scheduleWsprHistoryRender();
+}
+
+function normalizeServerWsprMessage(msg: WsprMessage): { raw: string; grids: string[]; station: string | null; rfHz: number | null; history: WsprMessage } {
+  const raw = msg.message ?? "";
+  const grids = extractAllGrids(raw);
+  const station = extractLikelyCallsign(raw);
+  const baseHz = finiteNumber(wsprWindow.ft8BaseHz);
+  const offsetHz = finiteNumber(msg.freq_hz);
+  const rfHz = offsetHz !== null && baseHz !== null ? baseHz + offsetHz : offsetHz;
+  return {
+    raw,
+    grids,
+    station,
+    rfHz,
+    history: {
+      receiver: wsprWindow.getDecodeRigMeta ? wsprWindow.getDecodeRigMeta() : null,
+      ts_ms: msg.ts_ms,
+      snr_db: msg.snr_db,
+      dt_s: msg.dt_s,
+      freq_hz: msg.freq_hz,
+      message: raw,
+    },
+  };
+}
+
+function onServerWsprBatch(messages: WsprMessage[]): void {
+  if (!Array.isArray(messages) || messages.length === 0) return;
+  if (wsprStatus) wsprStatus.textContent = "Receiving";
+  const normalized: WsprMessage[] = [];
+  for (const msg of messages) {
+    const next = normalizeServerWsprMessage(msg);
+    if (next.grids.length > 0 && wsprWindow.mapAddLocator) {
+      wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
+        ...msg,
+        ...(next.rfHz === null ? {} : { freq_hz: next.rfHz }),
+      });
+    }
+    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();
+}
+
+function pruneWsprHistoryView(): void {
+  pruneWsprMessageHistory();
+  renderWsprHistory();
+}
+
+function escapeWsprHtml(input: string): string {
+  return input
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll("\"", "&quot;");
+}
+
+function renderWsprMessage(message: string): string {
+  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: string): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  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: string): string | null {
+  const parts = 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: string): boolean {
+  const normalized = token.trim().toUpperCase();
+  return normalized === "RR73" || normalized === "73" || normalized === "RR";
+}
+
+function isMaidenheadGridToken(token: string): boolean {
+  const normalized = token.trim().toUpperCase();
+  return /^[A-R]{2}\d{2}(?:[A-X]{2})?$/.test(normalized) && !isFtxFarewellToken(normalized);
+}
+
+function isAlphaNum(ch: string | undefined): boolean {
+  return ch !== undefined && /[A-Za-z0-9]/.test(ch);
+}
+
+function activateWsprHistoryLocator(target: EventTarget | null): boolean {
+  if (!(target instanceof Element)) return false;
+  const locatorEl = target.closest<HTMLElement>(".ft8-locator[data-locator-grid]");
+  if (!locatorEl) return false;
+  const grid = (locatorEl.dataset.locatorGrid || "").toUpperCase();
+  if (!grid) return false;
+  if (typeof wsprWindow.navigateToMapLocator === "function") {
+    wsprWindow.navigateToMapLocator(grid, "wspr");
+  }
+  return true;
+}
+
+function applyWsprFilterToRow(row: HTMLElement): void {
+  if (!wsprFilterText) {
+    row.style.display = "";
+    return;
+  }
+  const message = row.dataset.message || "";
+  row.style.display = message.includes(wsprFilterText) ? "" : "none";
+}
+
+function resetWsprHistoryView(): void {
+  if (wsprMessagesEl) wsprMessagesEl.innerHTML = "";
+  wsprMessageHistory = [];
+  renderWsprHistory();
+  if (wsprWindow.clearMapMarkersByType) wsprWindow.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", () => {
+  void (async () => {
+    try {
+      await wsprWindow.takeSchedulerControlForDecoderDisable?.(wsprDecodeToggleBtn);
+      await hostCore.postPath("/toggle_wspr_decode");
+    } catch (error: unknown) {
+      console.error("WSPR toggle failed", error);
+    }
+  })();
+});
+
+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 hostCore.postPath("/clear_wspr_decode");
+      resetWsprHistoryView();
+    } catch (error: unknown) {
+      console.error("WSPR history clear failed", error);
+    }
+  })();
+});
+
+function onServerWspr(msg: WsprMessage): void {
+  if (wsprStatus) wsprStatus.textContent = "Receiving";
+  const next = normalizeServerWsprMessage(msg);
+  if (next.grids.length > 0 && wsprWindow.mapAddLocator) {
+    wsprWindow.mapAddLocator(next.raw, next.grids, "wspr", next.station, {
+      ...msg,
+      ...(next.rfHz === null ? {} : { freq_hz: next.rfHz }),
+    });
+  }
+  addWsprMessage(next.history);
+}
+
+wsprWindow.trxPluginRuntime.registerDecoder({
+  id: "wspr",
+  onMessage: onServerWspr,
+  onBatch: onServerWsprBatch,
+  restore: onServerWsprBatch,
+  prune: pruneWsprHistoryView,
+  reset: resetWsprHistoryView,
+});

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

@@ -0,0 +1,286 @@
+// 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.
+type Rgba255 = [number, number, number, number];
+interface SnapshotRenderer { gl?: { flush?: () => void; finish?: () => void } }
+interface ScreenshotModule {
+  captureSpectrumScreenshot(): Promise<boolean>;
+  buildSpectrumSnapshotCanvas(): HTMLCanvasElement | null;
+  saveCanvasAsPng(canvas: HTMLCanvasElement | null, fileName: string): Promise<boolean>;
+}
+interface TrxScreenshotBridge {
+  cssColorToRgba(color: string): Rgba255;
+  overviewGl?: SnapshotRenderer;
+  spectrumGl?: SnapshotRenderer;
+  signalOverlayGl?: SnapshotRenderer;
+  overviewCanvas?: HTMLCanvasElement;
+  spectrumCanvas?: HTMLCanvasElement;
+  showHint(message: string, durationMs: number): void;
+  modules: { screenshot?: ScreenshotModule };
+}
+export {};
+const screenshotWindow = window as typeof window & { trx: TrxScreenshotBridge };
+
+(function () {
+  "use strict";
+  const T = screenshotWindow.trx;
+
+  function isVisibleForSnapshot(el: Element | null): el is HTMLElement {
+    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: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, r: number) {
+    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: CanvasRenderingContext2D, el: HTMLElement | null, rootRect: DOMRect, 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(${String(Math.round(bg[0]))}, ${String(Math.round(bg[1]))}, ${String(Math.round(bg[2]))}, ${String(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(${String(Math.round(border[0]))}, ${String(Math.round(border[1]))}, ${String(Math.round(border[2]))}, ${String(borderAlpha)})`;
+      ctx.stroke();
+    }
+    return { x, y, w, h, style };
+  }
+
+  function drawWrappedText(ctx: CanvasRenderingContext2D, text: string, x: number, y: number, maxWidth: number, lineHeight: number, maxLines: number) {
+    const words = (text || "").split(/\s+/).filter(Boolean);
+    if (!words.length) return;
+    let line = "";
+    let lineIdx = 0;
+    for (let i = 0; i < words.length; i += 1) {
+      const word = words[i] ?? "";
+      const candidate = line ? `${line} ${word}` : word;
+      if (ctx.measureText(candidate).width <= maxWidth || !line) {
+        line = candidate;
+        continue;
+      }
+      ctx.fillText(line, x, y + lineIdx * lineHeight);
+      lineIdx += 1;
+      if (lineIdx >= maxLines) return;
+      line = word;
+    }
+    if (line && lineIdx < maxLines) {
+      ctx.fillText(line, x, y + lineIdx * lineHeight);
+    }
+  }
+
+  function drawElementTextBlock(ctx: CanvasRenderingContext2D, el: HTMLElement, rootRect: DOMRect, fallbackText: string | null = 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: CanvasRenderingContext2D, axisEl: HTMLElement | null, rootRect: DOMRect) {
+    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(): HTMLCanvasElement | null {
+    const rootEl = document.querySelector<HTMLElement>(".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") as HTMLCanvasElement | null;
+    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: string, fileName: string) {
+    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: HTMLCanvasElement | null, fileName: string): Promise<boolean> {
+    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
+  screenshotWindow.trx.modules.screenshot = {
+    captureSpectrumScreenshot,
+    buildSpectrumSnapshotCanvas,
+    saveCanvasAsPng,
+  };
+})();

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

@@ -0,0 +1,420 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+"use strict";
+
+type NoticeKind = "info" | "error" | "success" | "warning";
+interface NoticeOptions {
+  kind?: NoticeKind;
+  duration?: number;
+  action?: { label?: string; run: () => void } | null;
+}
+interface ConfirmOptions {
+  title?: string;
+  message?: string;
+  confirmLabel?: string;
+  danger?: boolean;
+}
+interface ButtonStateOptions {
+  active?: boolean;
+  activeLabel?: string;
+  inactiveLabel?: string;
+  busy?: boolean;
+  disabled?: boolean;
+}
+type TabKind = "primary" | "secondary";
+type LayoutCapability = "broadcast" | "digital";
+type LayoutName = "compact" | "broadcast" | "digital" | "full";
+interface OperatorLayout {
+  label: string;
+  unavailable?: string;
+  advanced: boolean;
+  audio: boolean;
+  scheduler: boolean;
+  preferredTab: string;
+  capability?: LayoutCapability;
+}
+interface LayoutOptions { persist?: boolean; navigate?: boolean }
+interface TrxUi {
+  notify(message: string, options?: NoticeOptions): HTMLDivElement;
+  confirm(options?: ConfirmOptions): Promise<boolean>;
+  setButtonState(button: HTMLButtonElement | null, options?: ButtonStateOptions): void;
+  prepareTabList(bar: HTMLElement | null, kind?: TabKind): void;
+  syncSelectedTab(bar: HTMLElement | null, selected: Element): void;
+  setLayoutCapabilities(capabilities?: Partial<Record<LayoutCapability, boolean>>): void;
+  setActiveRig(rigId: string | null): void;
+  applyLayout(name: string, options?: LayoutOptions): void;
+  closeMobileOverlays?: (restoreFocus?: boolean) => void;
+  init(): void;
+}
+
+const browserWindow = window as typeof window & {
+  trxUi?: TrxUi;
+  navigateToTab?: (tab: string) => void;
+};
+const preparedTabLists = new WeakSet<HTMLElement>();
+
+function elementById<T extends HTMLElement>(id: string): T {
+  const element = document.getElementById(id);
+  if (!element) throw new Error(`Missing required UI element #${id}`);
+  return element as T;
+}
+
+// Shared UI primitives. Keeping these outside app.js prevents navigation,
+// feedback, dialogs, and layout preferences from growing separate state models.
+(function initUiCore() {
+  const api = (browserWindow.trxUi ?? {}) as 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: string, options: NoticeOptions = {}) {
+    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);
+    }
+    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: ConfirmOptions = {}) {
+    ensureLiveRegions();
+    const dialog = elementById<HTMLDialogElement>("ui-confirm-dialog");
+    elementById("ui-confirm-title").textContent = options.title || "Confirm action";
+    elementById("ui-confirm-message").textContent = options.message || "Continue?";
+    const confirmButton = dialog.querySelector<HTMLButtonElement>('[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: HTMLButtonElement | null, options: ButtonStateOptions = {}) {
+    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: HTMLElement | null, kind: TabKind = "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<HTMLElement>(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: HTMLElement | null, selected: Element) {
+    if (!bar) return;
+    bar.querySelectorAll<HTMLElement>('[role="tab"]').forEach((tab) => {
+      const active = tab === selected;
+      tab.setAttribute("aria-selected", String(active));
+      tab.tabIndex = active ? 0 : -1;
+    });
+  };
+
+  const layouts: Record<LayoutName, OperatorLayout> = {
+    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: Record<LayoutCapability, boolean> = { broadcast: false, digital: false };
+  let activeRigId: string | null = null;
+
+  function layoutStorageKey() {
+    return activeRigId ? `trxOperatorLayout:${activeRigId}` : "trxOperatorLayout";
+  }
+
+  function savedLayoutName() {
+    return localStorage.getItem(layoutStorageKey()) || localStorage.getItem("trxOperatorLayout") || "compact";
+  }
+
+  function layoutAvailable(layout: OperatorLayout): boolean {
+    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") as HTMLSelectElement | null;
+    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: Partial<Record<LayoutCapability, boolean>> = {}) {
+    (Object.keys(layoutCapabilities) as LayoutCapability[]).forEach((name) => {
+      if (name in capabilities) layoutCapabilities[name] = Boolean(capabilities[name]);
+    });
+    refreshLayoutOptions();
+    const select = document.getElementById("operator-layout-select") as HTMLSelectElement | null;
+    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: string | null) {
+    activeRigId = typeof rigId === "string" && rigId ? rigId : null;
+    const saved = savedLayoutName();
+    const select = document.getElementById("operator-layout-select") as HTMLSelectElement | null;
+    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: string, options: LayoutOptions = {}) {
+    const requestedName = name in layouts ? name as LayoutName : "compact";
+    const requestedLayout = layouts[requestedName];
+    const permittedName: LayoutName = 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") as HTMLDetailsElement | null;
+    if (details) details.open = layout.advanced;
+    const audioDetails = document.getElementById("audio-controls") as HTMLDetailsElement | null;
+    if (audioDetails) audioDetails.open = layout.audio;
+    const schedulerDetails = document.getElementById("scheduler-controls") as HTMLDetailsElement | null;
+    if (schedulerDetails) schedulerDetails.open = layout.scheduler;
+    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<HTMLSelectElement>("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<HTMLElement>(".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<HTMLElement>('[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: Array<[string, string[]]> = [
+      ["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<HTMLButtonElement>(`[data-subtab="${id}"]`);
+        if (button) group.appendChild(new Option(button.textContent.trim(), id));
+      });
+      select.appendChild(group);
+    });
+    select.addEventListener("change", () => bar.querySelector<HTMLElement>(`[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<HTMLElement>(".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<HTMLElement>(".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/frontend/src/webgl-renderer.ts

@@ -2,17 +2,39 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-(function initTrxWebGl(global) {
+type Rgba = [number, number, number, number];
+type ColorInput = string | number[] | { r: number; g: number; b: number; a?: number };
+interface TextureEntry { texture: WebGLTexture | null; width: number; height: number }
+interface ColorLocations {
+  pos: number;
+  color: number;
+  resolution: WebGLUniformLocation | null;
+}
+interface TextureLocations {
+  pos: number;
+  uv: number;
+  resolution: WebGLUniformLocation | null;
+  alpha: WebGLUniformLocation | null;
+  tex: WebGLUniformLocation | null;
+}
+interface TrxWebGlGlobals {
+  trxParseCssColor?: (value: string) => Rgba;
+  trxHslToRgba?: (h: number, s: number, l: number, a?: number) => Rgba;
+  createTrxWebGlRenderer?: (canvas: HTMLCanvasElement, options?: WebGLContextAttributes) => object;
+  trxClearCssColorCache?: () => void;
+}
+
+(function initTrxWebGl(global: TrxWebGlGlobals) {
   "use strict";
 
-  const cssColorCache = new Map();
-  let cssColorProbe = null;
+  const cssColorCache = new Map<string, Rgba>();
+  let cssColorProbe: HTMLSpanElement | null = null;
 
   function clearCssColorCache() {
     cssColorCache.clear();
   }
 
-  function ensureCssColorProbe() {
+  function ensureCssColorProbe(): HTMLSpanElement {
     if (cssColorProbe) return cssColorProbe;
     const el = document.createElement("span");
     el.style.position = "absolute";
@@ -25,10 +47,10 @@
     return cssColorProbe;
   }
 
-  function parseRgbString(value) {
-    const m = /^rgba?\(([^)]+)\)$/.exec(String(value || "").trim());
+  function parseRgbString(value: string): Rgba | null {
+    const m = /^rgba?\(([^)]+)\)$/.exec(value.trim());
     if (!m) return null;
-    const parts = m[1].split(",").map((p) => p.trim());
+    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]);
@@ -43,8 +65,8 @@
     ];
   }
 
-  function parseHexColor(value) {
-    const raw = String(value || "").trim();
+  function parseHexColor(value: string): Rgba | null {
+    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) {
@@ -58,9 +80,10 @@
     return [r, g, b, a];
   }
 
-  function parseCssColor(value) {
-    const key = String(value ?? "");
-    if (cssColorCache.has(key)) return cssColorCache.get(key).slice();
+  function parseCssColor(value: string): Rgba {
+    const key = value;
+    const cached = cssColorCache.get(key);
+    if (cached) return [...cached];
 
     let parsed = parseHexColor(key) || parseRgbString(key);
     if (!parsed) {
@@ -70,18 +93,18 @@
       const computed = getComputedStyle(probe).color;
       parsed = parseRgbString(computed) || [0, 0, 0, 1];
     }
-    cssColorCache.set(key, parsed.slice());
-    return parsed.slice();
+    cssColorCache.set(key, [...parsed]);
+    return [...parsed];
   }
 
-  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));
+  function hslToRgba(h: number, s: number, l: number, a = 1): Rgba {
+    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) => {
+    const hueToRgb = (t: number): number => {
       let tt = t;
       if (tt < 0) tt += 1;
       if (tt > 1) tt -= 1;
@@ -94,31 +117,29 @@
     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)))];
+    return [r, g, b, Math.max(0, Math.min(1, a))];
   }
 
-  function normalizeColor(input, alphaMul = 1) {
-    let rgba;
+  function normalizeColor(input: ColorInput, alphaMul = 1): Rgba {
+    let rgba: Rgba;
     if (Array.isArray(input)) {
-      const arr = input.map((v) => Number(v));
+      const arr = input;
       if (arr.length >= 4) {
-        rgba = [arr[0], arr[1], arr[2], arr[3]];
+        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 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];
+      rgba = [
+        input.r || 0,
+        input.g || 0,
+        input.b || 0,
+        input.a ?? 1,
+      ];
     }
-    const out = [
+    const out: Rgba = [
       Math.max(0, Math.min(1, rgba[0])),
       Math.max(0, Math.min(1, rgba[1])),
       Math.max(0, Math.min(1, rgba[2])),
@@ -127,8 +148,9 @@
     return out;
   }
 
-  function compileShader(gl, type, source) {
+  function compileShader(gl: WebGLRenderingContext, type: number, source: string): WebGLShader {
     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)) {
@@ -139,7 +161,7 @@
     return shader;
   }
 
-  function createProgram(gl, vertexSrc, fragmentSrc) {
+  function createProgram(gl: WebGLRenderingContext, vertexSrc: string, fragmentSrc: string): WebGLProgram {
     const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);
     const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
     const program = gl.createProgram();
@@ -156,11 +178,11 @@
     return program;
   }
 
-  function pushColoredVertex(target, x, y, rgba) {
+  function pushColoredVertex(target: number[], x: number, y: number, rgba: Rgba) {
     target.push(x, y, rgba[0], rgba[1], rgba[2], rgba[3]);
   }
 
-  function segmentToQuadVertices(out, x0, y0, x1, y1, halfW, rgba) {
+  function segmentToQuadVertices(out: number[], x0: number, y0: number, x1: number, y1: number, halfW: number, rgba: Rgba) {
     const dx = x1 - x0;
     const dy = y1 - y0;
     const len = Math.hypot(dx, dy);
@@ -183,23 +205,33 @@
   }
 
   class TrxWebGlRenderer {
-    constructor(canvas, options = {}) {
+    readonly canvas: HTMLCanvasElement;
+    readonly options: WebGLContextAttributes;
+    readonly gl: WebGLRenderingContext | null;
+    readonly ready: boolean;
+    readonly textures = new Map<string, TextureEntry>();
+    private _colorScratch = new Float32Array(4096 * 6);
+    private _colorGpuSize = 0;
+    private readonly _texScratch = new Float32Array(6 * 4);
+    private colorProgram!: WebGLProgram;
+    private colorBuffer!: WebGLBuffer | null;
+    private colorLoc!: ColorLocations;
+    private textureProgram!: WebGLProgram;
+    private textureBuffer!: WebGLBuffer | null;
+    private textureLoc!: TextureLocations;
+
+    constructor(canvas: HTMLCanvasElement, options: WebGLContextAttributes = {}) {
       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.gl = (canvas.getContext("webgl", this.options) ||
+        canvas.getContext("experimental-webgl", this.options)) as WebGLRenderingContext | 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;
+      if (!gl) return;
       gl.disable(gl.DEPTH_TEST);
       gl.disable(gl.CULL_FACE);
       gl.enable(gl.BLEND);
@@ -268,8 +300,8 @@
       };
     }
 
-    ensureSize(cssWidth, cssHeight, dpr = (window.devicePixelRatio || 1)) {
-      if (!this.ready) return false;
+    ensureSize(cssWidth: number, cssHeight: number, dpr = (window.devicePixelRatio || 1)): boolean {
+      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;
@@ -281,24 +313,26 @@
       return changed;
     }
 
-    clear(color) {
-      if (!this.ready) return;
+    clear(color: ColorInput) {
+      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) {
+    drawTriangles(vertices: number[]) {
+      if (!this.gl) return;
       this._drawColorGeometry(vertices, this.gl.TRIANGLES);
     }
 
-    drawTriangleStrip(vertices) {
+    drawTriangleStrip(vertices: number[]) {
+      if (!this.gl) return;
       this._drawColorGeometry(vertices, this.gl.TRIANGLE_STRIP);
     }
 
-    _drawColorGeometry(vertices, mode) {
-      if (!this.ready || !vertices || vertices.length === 0) return;
+    private _drawColorGeometry(vertices: number[], mode: number) {
+      if (!this.gl || vertices.length === 0) return;
       const gl = this.gl;
       const count = vertices.length;
 
@@ -333,88 +367,88 @@
       gl.drawArrays(mode, 0, count / 6);
     }
 
-    fillRect(x, y, w, h, color) {
+    fillRect(x: number, y: number, w: number, h: number, color: ColorInput) {
       if (w <= 0 || h <= 0) return;
       const rgba = normalizeColor(color);
-      const v = [];
+      const v: number[] = [];
       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);
+      this.drawTriangles(v);
     }
 
-    fillGradientRect(x, y, w, h, colorTL, colorTR, colorBR, colorBL) {
+    fillGradientRect(x: number, y: number, w: number, h: number, colorTL: ColorInput, colorTR: ColorInput, colorBR: ColorInput, colorBL: ColorInput) {
       if (w <= 0 || h <= 0) return;
       const tl = normalizeColor(colorTL);
       const tr = normalizeColor(colorTR);
       const br = normalizeColor(colorBR);
       const bl = normalizeColor(colorBL);
-      const v = [];
+      const v: number[] = [];
       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);
+      this.drawTriangles(v);
     }
 
-    drawPolyline(points, color, width = 1) {
+    drawPolyline(points: number[], color: ColorInput, 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 = [];
+      const halfW = Math.max(0.5, width || 1) / 2;
+      const verts: number[] = [];
       for (let i = 0; i < points.length - 2; i += 2) {
         segmentToQuadVertices(
           verts,
-          points[i], points[i + 1],
-          points[i + 2], points[i + 3],
+          points[i] ?? 0, points[i + 1] ?? 0,
+          points[i + 2] ?? 0, points[i + 3] ?? 0,
           halfW,
           rgba,
         );
       }
-      this._drawColorGeometry(verts, this.gl.TRIANGLES);
+      this.drawTriangles(verts);
     }
 
-    drawSegments(segments, color, width = 1) {
+    drawSegments(segments: number[], color: ColorInput, 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 = [];
+      const halfW = Math.max(0.5, width || 1) / 2;
+      const verts: number[] = [];
       for (let i = 0; i < segments.length - 3; i += 4) {
         segmentToQuadVertices(
           verts,
-          segments[i], segments[i + 1],
-          segments[i + 2], segments[i + 3],
+          segments[i] ?? 0, segments[i + 1] ?? 0,
+          segments[i + 2] ?? 0, segments[i + 3] ?? 0,
           halfW,
           rgba,
         );
       }
-      this._drawColorGeometry(verts, this.gl.TRIANGLES);
+      this.drawTriangles(verts);
     }
 
-    drawFilledArea(points, baselineY, color) {
+    drawFilledArea(points: number[], baselineY: number, color: ColorInput) {
       if (!Array.isArray(points) || points.length < 4) return;
       const rgba = normalizeColor(color);
-      const verts = [];
+      const verts: number[] = [];
       for (let i = 0; i < points.length; i += 2) {
-        pushColoredVertex(verts, points[i], baselineY, rgba);
-        pushColoredVertex(verts, points[i], points[i + 1], rgba);
+        pushColoredVertex(verts, points[i] ?? 0, baselineY, rgba);
+        pushColoredVertex(verts, points[i] ?? 0, points[i + 1] ?? 0, rgba);
       }
-      this._drawColorGeometry(verts, this.gl.TRIANGLE_STRIP);
+      this.drawTriangleStrip(verts);
     }
 
-    drawPoints(points, size, color) {
+    drawPoints(points: number[], size: number, color: ColorInput) {
       if (!Array.isArray(points) || points.length < 2) return;
-      const radius = Math.max(1, Number(size) || 1);
+      const radius = Math.max(1, size || 1);
       const rgba = normalizeColor(color);
-      const verts = [];
+      const verts: number[] = [];
       for (let i = 0; i < points.length; i += 2) {
-        const x = points[i] - radius;
-        const y = points[i + 1] - radius;
+        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);
@@ -424,15 +458,15 @@
         pushColoredVertex(verts, x + w, y + h, rgba);
         pushColoredVertex(verts, x, y + h, rgba);
       }
-      this._drawColorGeometry(verts, this.gl.TRIANGLES);
+      this.drawTriangles(verts);
     }
 
-    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);
+    drawDashedVerticalLine(x: number, y0: number, y1: number, dashLen: number, gapLen: number, color: ColorInput, 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 = [];
+      const segments: number[] = [];
       for (let y = top; y < bottom; y += dash + gap) {
         const segEnd = Math.min(bottom, y + dash);
         segments.push(x, y, x, segEnd);
@@ -440,8 +474,8 @@
       this.drawSegments(segments, color, width);
     }
 
-    uploadRgbaTexture(name, width, height, data, filter = "linear") {
-      if (!this.ready || !name || !data) return null;
+    uploadRgbaTexture(name: string, width: number, height: number, data: ArrayBufferView, filter: "linear" | "nearest" = "linear"): WebGLTexture | null {
+      if (!this.gl || !name) return null;
       const gl = this.gl;
       let entry = this.textures.get(name);
       if (!entry) {
@@ -486,8 +520,8 @@
       return entry.texture;
     }
 
-    drawTexture(name, x, y, w, h, alpha = 1, flipY = true) {
-      if (!this.ready || !name || w <= 0 || h <= 0) return;
+    drawTexture(name: string, x: number, y: number, w: number, h: number, 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;
@@ -516,7 +550,7 @@
       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.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);
@@ -524,7 +558,7 @@
     }
   }
 
-  function createRenderer(canvas, options) {
+  function createRenderer(canvas: HTMLCanvasElement, options: WebGLContextAttributes = {}) {
     return new TrxWebGlRenderer(canvas, options);
   }
 
@@ -532,4 +566,4 @@
   global.trxHslToRgba = hslToRgba;
   global.createTrxWebGlRenderer = createRenderer;
   global.trxClearCssColorCache = clearCssColorCache;
-})(window);
+})(window as TrxWebGlGlobals);

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

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { bundleEntry } from "./bundle-entry.mjs";
+import { createHost } from "./host-fixture.mjs";
+
+test("AIS entry forwards positioned vessels with normalized metadata", async () => {
+  const forwarded = [];
+  const window = {
+    ...createHost(),
+    trxUi: { confirm: async () => true },
+    aisMapAddVessel: (message) => { forwarded.push(message); },
+  };
+  const context = vm.createContext({
+    window,
+    document: { getElementById: () => null },
+    Date,
+    Number,
+    String,
+    Array,
+    Map,
+    console,
+  });
+  const runtime = await bundleEntry(new URL("../src/plugin-runtime.ts", import.meta.url));
+  const source = await bundleEntry(new URL("../src/plugins/ais.ts", import.meta.url));
+  new vm.Script(runtime).runInContext(context);
+  new vm.Script(source).runInContext(context);
+
+  window.trxPluginRuntime.dispatch("ais", { mmsi: 261000001, lat: 54.5, lon: 18.5, channel: "A", ts_ms: Date.now() });
+  assert.equal(window.onServerAis, undefined);
+  assert.equal(forwarded.length, 1);
+  assert.equal(forwarded[0].mmsi, 261000001);
+  assert.equal(forwarded[0].rig_id, null);
+  assert.equal(typeof forwarded[0]._tsMs, "number");
+});

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

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { bundleEntry } from "./bundle-entry.mjs";
+import { createHost } from "./host-fixture.mjs";
+
+test("APRS entry normalizes positioned packets without remote symbol assets", async () => {
+  const forwarded = [];
+  const window = {
+    ...createHost(),
+    trxUi: { confirm: async () => true },
+    aprsMapAddStation: (...args) => { forwarded.push(args); },
+  };
+  const context = vm.createContext({
+    window,
+    document: { getElementById: () => null, querySelectorAll: () => [] },
+    navigator: {},
+    Date,
+    Number,
+    String,
+    Array,
+    Set,
+    Reflect,
+    console,
+  });
+  const runtime = await bundleEntry(new URL("../src/plugin-runtime.ts", import.meta.url));
+  const source = await bundleEntry(new URL("../src/plugins/aprs.ts", import.meta.url));
+  assert.equal(source.includes("raw.githubusercontent.com"), false);
+  new vm.Script(runtime).runInContext(context);
+  new vm.Script(source).runInContext(context);
+
+  window.trxPluginRuntime.dispatch("aprs", { src_call: "SP0ABC", dest_call: "APRS", crc_ok: true, lat: 54.5, lon: 18.5, symbol_table: "/", symbol_code: ">" });
+  assert.equal(window.onServerAprs, undefined);
+  assert.equal(forwarded.length, 1);
+  assert.equal(forwarded[0][0], "SP0ABC");
+  assert.equal(forwarded[0][1], 54.5);
+  assert.equal(forwarded[0][6].rig_id, null);
+});
+
+// Distance is computed from the receiver position and the great-circle helper,
+// both of which the entry reads through the host contract.  These used to be
+// bare window properties that the module graph stopped publishing, so the
+// distance column rendered empty for every positioned packet.
+test("APRS distance text uses the receiver position from the host contract", async () => {
+  const distanceArgs = [];
+  const host = createHost({
+    state: { serverLat: 54.0, serverLon: 18.0 },
+    core: {
+      haversineKm: (lat1, lon1, lat2, lon2) => {
+        distanceArgs.push([lat1, lon1, lat2, lon2]);
+        return 61.7;
+      },
+    },
+  });
+  const window = { ...host, trxUi: { confirm: async () => true }, aprsMapAddStation: () => {} };
+  const node = () => ({
+    innerHTML: "", textContent: "", className: "", style: {}, dataset: {},
+    appendChild(child) { return child; }, addEventListener() {}, replaceChildren() {},
+    querySelector: () => null, querySelectorAll: () => [], setAttribute() {},
+    classList: { add() {}, toggle() {} },
+  });
+  const context = vm.createContext({
+    window,
+    document: {
+      getElementById: (id) => (id === "aprs-packets" ? node() : null),
+      querySelectorAll: () => [],
+      createElement: node,
+      createDocumentFragment: node,
+    },
+    navigator: {},
+    Date, Number, String, Array, Set, Reflect, console,
+  });
+  const runtime = await bundleEntry(new URL("../src/plugin-runtime.ts", import.meta.url));
+  const source = await bundleEntry(new URL("../src/plugins/aprs.ts", import.meta.url));
+  new vm.Script(runtime).runInContext(context);
+  new vm.Script(source).runInContext(context);
+
+  window.trxPluginRuntime.dispatch("aprs", {
+    src_call: "SP0ABC", dest_call: "APRS", crc_ok: true, lat: 54.5, lon: 18.5,
+    symbol_table: "/", symbol_code: ">",
+  });
+
+  assert.deepEqual(distanceArgs, [[54.0, 18.0, 54.5, 18.5]]);
+});

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/auto-bandwidth.test.mjs

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { build } from "esbuild";
+
+async function loadEstimator() {
+  const result = await build({
+    entryPoints: [new URL("../src/features/radio/auto-bandwidth.ts", import.meta.url).pathname],
+    bundle: true,
+    format: "cjs",
+    platform: "browser",
+    target: "es2022",
+    write: false,
+  });
+  const module = { exports: {} };
+  vm.runInNewContext(result.outputFiles[0].text, {
+    module,
+    exports: module.exports,
+    Array,
+    ArrayBuffer,
+    Number,
+    Math,
+  });
+  return module.exports.estimateOccupiedBandwidth;
+}
+
+function wfmFrame(signalHalfWidthHz, signalDb = -70) {
+  const sampleRate = 400_000;
+  const bins = Array.from({ length: 1025 }, (_, index) => {
+    const offsetHz = (index / 1024 - 0.5) * sampleRate;
+    return Math.abs(offsetHz) <= signalHalfWidthHz ? signalDb : -100;
+  });
+  return { bins, center_hz: 100_000_000, sample_rate: sampleRate };
+}
+
+test("weak WFM falls back to the 60 kHz intelligibility floor", async () => {
+  const estimate = await loadEstimator();
+  const weak = wfmFrame(90_000, -97);
+  assert.equal(estimate(weak, 100_000_000, "WFM", [180_000, 60_000, 300_000, 5_000]), 60_000);
+});
+
+test("WFM ACI and CCI cap an otherwise wide occupied estimate", async () => {
+  const estimate = await loadEstimator();
+  const frame = wfmFrame(95_000);
+  const limits = [180_000, 60_000, 300_000, 5_000];
+  const clear = estimate(frame, 100_000_000, "WFM", limits);
+  const adjacent = estimate(frame, 100_000_000, "WFM", limits, { aci: 100 });
+  const cochannel = estimate(frame, 100_000_000, "WFM", limits, { cci: 100 });
+  assert.ok(clear > adjacent);
+  assert.equal(adjacent, 60_000);
+  assert.ok(cochannel >= 135_000 && cochannel < clear);
+});

src/trx-client/trx-frontend/trx-frontend-http/frontend/tests/background-decode.test.mjs

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { createHost } from "./host-fixture.mjs";
+import { bundleEntry } from "./bundle-entry.mjs";
+
+test("background decode loads configuration for the explicitly selected rig", async () => {
+  const requested = [];
+  const window = {
+    ...createHost(),
+    decoderRegistry: [],
+    trxUi: { confirm: async () => true },
+  };
+  const context = vm.createContext({
+    window,
+    document: { getElementById: () => null },
+    fetch: async (url) => {
+      requested.push(url);
+      return {
+        ok: true,
+        json: async () => url === "/bookmarks"
+          ? []
+          : url.endsWith("/status")
+            ? { entries: [] }
+            : { remote: "rig/a", enabled: false, bookmark_ids: [] },
+      };
+    },
+    setInterval: () => 1,
+    clearInterval() {},
+    setTimeout,
+    URL,
+    Set,
+    Error,
+    console,
+  });
+  const source = await bundleEntry(new URL("../src/plugins/background-decode.ts", import.meta.url));
+  new vm.Script(source).runInContext(context);
+
+  window.trx.modules.backgroundDecode.initialize("rig/a", "control");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  assert.ok(requested.includes("/background-decode/rig%2Fa"));
+  assert.ok(requested.includes("/bookmarks"));
+  assert.ok(requested.includes("/background-decode/rig%2Fa/status"));
+  assert.equal(window.initBackgroundDecode, undefined);
+});

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

@@ -0,0 +1,176 @@
+// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { bundleEntry } from "./bundle-entry.mjs";
+
+class ElementFixture {
+  constructor() {
+    this.value = "";
+    this.textContent = "";
+    this.innerHTML = "";
+    this.style = {};
+    this.dataset = {};
+    this.options = [];
+    this.selectedOptions = [];
+    this.children = [];
+  }
+  addEventListener() {}
+  appendChild(child) { this.children.push(child); return child; }
+  add(child) { this.options.push(child); }
+  remove(index) { this.options.splice(index, 1); }
+  focus() {}
+  querySelector() { return null; }
+}
+
+// Mirrors the `window.trx` host contract published by app.ts.  The plugin is a
+// separate bundle, so every application service it uses arrives this way.
+function hostFixture(overrides = {}) {
+  const calls = { postPath: [], setRigFrequency: [], armOptimisticFrequency: [], applyLocalTunedFrequency: [], syncBandwidthInput: [], scheduleSpectrumDraw: 0 };
+  const state = {
+    authEnabled: false,
+    authRole: "control",
+    lastActiveRigId: null,
+    lastRigIds: [],
+    lastRigDisplayNames: {},
+    lastFreqHz: 14_074_000,
+    lastModeName: "USB",
+    lastSpectrumData: null,
+    currentBandwidthHz: 2400,
+    decoderRegistry: [],
+    ...overrides,
+  };
+  const core = {
+    postPath: async (path) => { calls.postPath.push(path); },
+    setRigFrequency: (hz) => { calls.setRigFrequency.push(hz); },
+    applyLocalTunedFrequency: (hz, force) => { calls.applyLocalTunedFrequency.push([hz, force]); },
+    armOptimisticFrequency: (hz) => { calls.armOptimisticFrequency.push(hz); },
+    syncBandwidthInput: (hz) => { calls.syncBandwidthInput.push(hz); },
+    scheduleSpectrumDraw: () => { calls.scheduleSpectrumDraw += 1; },
+    onDecoderRegistryReady: () => {},
+  };
+  return { window: { trx: { state, core, modules: {} }, trxUi: { confirm: async () => true } }, calls };
+}
+
+function documentFixture(element) {
+  return {
+    getElementById: element,
+    querySelector: () => new ElementFixture(),
+    querySelectorAll: () => [],
+    createElement: () => new ElementFixture(),
+    createTextNode: (text) => ({ textContent: text }),
+    addEventListener() {},
+  };
+}
+
+const source = await bundleEntry(new URL("../src/plugins/bookmarks.ts", import.meta.url));
+
+test("bookmarks register an explicit typed service for application consumers", async () => {
+  const elements = new Map();
+  const element = (id) => {
+    if (!elements.has(id)) elements.set(id, new ElementFixture());
+    return elements.get(id);
+  };
+  element("bm-scope-picker").value = "general";
+  element("bm-category-filter").options.push({ value: "" });
+  element("bm-mode-filter").options.push({ value: "" });
+  const bookmarks = [{ id: "one", name: "Local", freq_hz: 145_500_000, mode: "FM", scope: "general" }];
+  const { window } = hostFixture();
+  const context = vm.createContext({
+    window,
+    document: documentFixture(element),
+    fetch: async () => ({ ok: true, json: async () => bookmarks }),
+    CSS: { escape: (value) => value },
+    Element: ElementFixture,
+    console,
+  });
+  new vm.Script(source).runInContext(context);
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(window.trx.modules.bookmarks.overlayList.length, 1);
+  assert.equal(window.trx.modules.bookmarks.overlayList[0].id, "one");
+  assert.equal(typeof window.trx.modules.bookmarks.apply, "function");
+  assert.equal(typeof window.trx.modules.bookmarks.formatFrequency, "function");
+  assert.equal(typeof window.trx.modules.bookmarks.populateScopePicker, "function");
+  assert.equal(globalThis.bmOverlayList, undefined);
+});
+
+test("applying a bookmark drives tuning through the host services", async () => {
+  const elements = new Map();
+  const element = (id) => {
+    if (!elements.has(id)) elements.set(id, new ElementFixture());
+    return elements.get(id);
+  };
+  const { window, calls } = hostFixture({
+    lastActiveRigId: "sdr",
+    decoderRegistry: [
+      { id: "ft8", label: "FT8", activation: "toggle", active_modes: ["USB"], bookmark_selectable: true },
+      { id: "cw", label: "CW", activation: "toggle", active_modes: ["CW"], bookmark_selectable: true },
+    ],
+  });
+  const context = vm.createContext({
+    window,
+    document: documentFixture(element),
+    fetch: async (url) => ({
+      ok: true,
+      json: async () => (url.startsWith("/status") ? { ft8_decode_enabled: false, cw_decode_enabled: true } : []),
+    }),
+    CSS: { escape: (value) => value },
+    Element: ElementFixture,
+    console,
+  });
+  new vm.Script(source).runInContext(context);
+  await new Promise((resolve) => setImmediate(resolve));
+  calls.postPath.length = 0;
+
+  window.trx.modules.bookmarks.apply({
+    id: "ft8-20m", name: "FT8 20m", freq_hz: 14_074_000, mode: "USB", bandwidth_hz: 3000, decoders: ["ft8"],
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  await new Promise((resolve) => setImmediate(resolve));
+
+  // Optimistic UI: the guard is armed before the display update so a stale SSE
+  // frame cannot snap the marker back while the tune is in flight.
+  assert.deepEqual(calls.armOptimisticFrequency, [14_074_000]);
+  assert.deepEqual(calls.applyLocalTunedFrequency, [[14_074_000, true]]);
+  assert.deepEqual(calls.syncBandwidthInput, [3000]);
+  assert.equal(window.trx.state.currentBandwidthHz, 3000);
+  assert.equal(element("mode").value, "USB");
+
+  // Rig commands: mode and bandwidth over postPath, frequency via the core
+  // tuning service so virtual-channel redirection still applies.
+  assert.deepEqual(calls.setRigFrequency, [14_074_000]);
+  assert.ok(calls.postPath.includes("/set_mode?mode=USB"));
+  assert.ok(calls.postPath.includes("/set_bandwidth?hz=3000"));
+  // ft8 is selected and off; cw is on but incompatible with USB.
+  assert.ok(calls.postPath.includes("/toggle_ft8_decode"));
+  assert.ok(calls.postPath.includes("/toggle_cw_decode"));
+});
+
+test("bookmark controls follow the host authentication state", async () => {
+  const elements = new Map();
+  const element = (id) => {
+    if (!elements.has(id)) elements.set(id, new ElementFixture());
+    return elements.get(id);
+  };
+  const { window } = hostFixture({ authEnabled: true, authRole: "rx" });
+  const context = vm.createContext({
+    window,
+    document: documentFixture(element),
+    fetch: async () => ({ ok: true, json: async () => [] }),
+    CSS: { escape: (value) => value },
+    Element: ElementFixture,
+    console,
+  });
+  new vm.Script(source).runInContext(context);
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(element("bm-add-btn").style.display, "none");
+
+  window.trx.state.authRole = "control";
+  await window.trx.modules.bookmarks.fetch("");
+  assert.equal(element("bm-add-btn").style.display, "");
+});