[refactor](trx-server): extract history policy

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

@@ -274,8 +274,7 @@ mod tests {
 
         // Pseudo-random noise vs gradient — correlation should be low.
         let noise: Vec<u8> = (0..256)
-            .map(|i| (i as u32).wrapping_mul(1_103_515_245).wrapping_add(12_345))
+            .map(|i| ((i * 1103515245 + 12345) as u32 >> 8 & 0xff) as u8)
-            .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/assets/web/app.js

@@ -840,8 +840,6 @@ let jogMult = loadSetting("jogMult", 1);      // divisor: 1, 10, 100
 let jogStep = Math.max(Math.round(jogUnit / jogMult), 1);
 let minFreqStepHz = 1;
 let lastModeName = "";
-let lastWfmCci = 0;
-let lastWfmAci = 0;
 const VFO_COLORS = ["var(--accent-green)", "var(--accent-yellow)"];
 function vfoColor(idx) {
   if (idx < VFO_COLORS.length) return VFO_COLORS[idx];
@@ -3295,14 +3293,8 @@ function render(update) {
       wfmStFlagEl.classList.toggle("wfm-st-flag-stereo", detected);
       wfmStFlagEl.classList.toggle("wfm-st-flag-mono", !detected);
     }
-    if (typeof update.filter.wfm_cci === "number") {
+    if (typeof update.filter.wfm_cci === "number") updateIntfBar(wfmCciFillEl, wfmCciValEl, update.filter.wfm_cci);
-      lastWfmCci = Math.max(0, Math.min(100, update.filter.wfm_cci));
+    if (typeof update.filter.wfm_aci === "number") updateIntfBar(wfmAciFillEl, wfmAciValEl, update.filter.wfm_aci);
-      updateIntfBar(wfmCciFillEl, wfmCciValEl, lastWfmCci);
-    }
-    if (typeof update.filter.wfm_aci === "number") {
-      lastWfmAci = Math.max(0, Math.min(100, update.filter.wfm_aci));
-      updateIntfBar(wfmAciFillEl, wfmAciValEl, lastWfmAci);
-    }
     if (samStereoWidthEl && typeof update.filter.sam_stereo_width === "number") {
       samStereoWidthEl.value = String(Math.round(update.filter.sam_stereo_width * 100));
     }
@@ -4276,7 +4268,7 @@ const MODE_BW_DEFAULTS = {
   FM:     [12_500, 2_500, 25_000, 500],
   AIS:    [25_000, 12_500, 50_000, 500],
   VDES:   [100_000, 25_000, 200_000, 1_000],
-  WFM:    [180_000, 60_000,300_000,5_000],
+  WFM:    [180_000, 50_000,300_000,5_000],
   DIG:    [3_000,  300,   6_000,  100],
   PKT:    [25_000, 300,  50_000,  500],
 };
@@ -4356,110 +4348,64 @@ async function applyBandwidthFromInput() {
   } catch (_) {}
 }
 
-function estimateOccupiedBandwidth(data, centerHz, interference = {}) {
+function estimateBandwidthAroundPeak(data, centerHz) {
   if (!data || !isBinsArray(data.bins) || data.bins.length < 3 || !Number.isFinite(centerHz)) {
     return null;
   }
 
   const bins = data.bins;
   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 mode = (modeEl ? modeEl.value : "USB").toUpperCase();
+  const searchRadius = Math.max(6, Math.min(120, Math.round(maxIdx * 0.03)));
-  const [defaultBw, minBw, maxBw, stepBw] = mwDefaultsForMode(mode);
+  const searchLo = Math.max(1, centerIdx - searchRadius);
-  const oneSided = mode === "USB" || mode === "DIG" || mode === "CW"
+  const searchHi = Math.min(maxIdx - 1, centerIdx + searchRadius);
-    ? 1
-    : mode === "LSB" || mode === "CWR" ? -1 : 0;
-  const isWfm = mode === "WFM";
 
-  // Reduce single-bin peaks and holes before finding occupied-channel edges.
+  let peakIdx = centerIdx;
-  // WFM needs a wider smoothing window because its energy is noise-like and
+  for (let i = searchLo; i <= searchHi; i++) {
-  // spread across the entire channel rather than concentrated at a carrier.
+    if (bins[i] > bins[peakIdx]) peakIdx = i;
-  const smoothRadius = isWfm ? 3 : 1;
-  const smoothed = bins.map((_, i) => {
-    let sum = 0;
-    let count = 0;
-    for (let j = Math.max(0, i - smoothRadius); j <= Math.min(maxIdx, i + smoothRadius); j++) {
-      sum += bins[j];
-      count += 1;
   }
-    return sum / count;
+
-  });
   const sorted = [...bins].sort((a, b) => a - b);
   const noise = sorted[Math.floor(sorted.length * 0.2)];
-  const maxSpanBins = Math.max(2, Math.ceil(maxBw / hzPerBin));
+  const peak = bins[peakIdx];
-  const searchHalfBins = oneSided === 0 ? Math.ceil(maxSpanBins / 2) : maxSpanBins;
+  const threshold = Math.max(noise + 4, peak - Math.max(8, (peak - noise) * 0.35));
-  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 i = searchLo; i <= searchHi; i++) peak = Math.max(peak, smoothed[i]);
-  const snr = peak - noise;
-  if (!Number.isFinite(snr) || snr < (isWfm ? 5 : 4)) return isWfm ? minBw : defaultBw;
 
-  // A threshold relative to the noise floor finds occupied bandwidth much
+  let left = peakIdx;
-  // more reliably than one relative to the peak.  The latter fails for WFM,
+  let right = peakIdx;
-  // whose multiplex spectrum has peaks, notches, and no narrow centre carrier.
+  let belowCount = 0;
-  const threshold = noise + Math.max(3, Math.min(isWfm ? 6 : 10, snr * (isWfm ? 0.18 : 0.28)));
+  for (let i = peakIdx; i > 1; i--) {
-  const allowedGap = Math.max(isWfm ? 4 : 2, Math.ceil((isWfm ? 12_000 : stepBw) / hzPerBin));
+    if (bins[i] < threshold) belowCount += 1;
-
+    else belowCount = 0;
-  function occupiedExtent(direction, limitBins) {
+    if (belowCount >= 2) break;
-    let lastOccupied = centerIdx;
+    left = i;
-    let gap = 0;
-    for (let n = 0; n <= limitBins; n++) {
-      const i = centerIdx + direction * n;
-      if (i <= 0 || i >= maxIdx) break;
-      if (smoothed[i] >= threshold) {
-        lastOccupied = i;
-        gap = 0;
-      } else if (++gap > allowedGap) {
-        break;
-      }
-    }
-    return Math.abs(lastOccupied - centerIdx) * hzPerBin;
   }
 
-  let rawBw;
+  belowCount = 0;
-  if (oneSided !== 0) {
+  for (let i = peakIdx; i < maxIdx - 1; i++) {
-    rawBw = occupiedExtent(oneSided, maxSpanBins);
+    if (bins[i] < threshold) belowCount += 1;
-  } else {
+    else belowCount = 0;
-    const leftHz = occupiedExtent(-1, searchHalfBins);
+    if (belowCount >= 2) break;
-    const rightHz = occupiedExtent(1, searchHalfBins);
+    right = i;
-    // A symmetric RF filter must contain the larger of the two sidebands.
-    rawBw = 2 * Math.max(leftHz, rightHz);
   }
 
-  // Add a transition-band margin.  Weak WFM deliberately falls back to the
+  const shoulderPad = Math.max(1, Math.round((right - left) * 0.08));
-  // 60 kHz mode floor above: a narrower filter trades stereo/RDS content for
+  left = Math.max(0, left - shoulderPad);
-  // a useful improvement in intelligibility when the signal is very poor.
+  right = Math.min(maxIdx, right + shoulderPad);
-  rawBw *= isWfm ? 1.08 : 1.12;
+
-  if (isWfm) {
+  const hzPerBin = data.sample_rate / maxIdx;
-    const aci = Math.max(0, Math.min(100, Number(interference.aci) || 0)) / 100;
+  const rawBw = Math.max(hzPerBin, (right - left) * hzPerBin);
-    const cci = Math.max(0, Math.min(100, Number(interference.cci) || 0)) / 100;
+  const [, minBw, maxBw, stepBw] = mwDefaultsForMode(modeEl ? modeEl.value : "USB");
-    // Adjacent-channel energy is outside the wanted modulation, so ACI can
-    // safely drive the cap all the way from the 300 kHz ceiling to 60 kHz.
-    const aciCap = maxBw - (maxBw - minBw) * aci;
-    // CCI overlaps the wanted station and cannot be removed by an RF filter.
-    // Only distrust the widest edge estimates, retaining at least 65% of the
-    // useful range between the weak-signal floor and nominal WFM bandwidth.
-    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);
 }
 
 async function applyAutoBandwidth() {
   if (!lastSpectrumData || lastFreqHz == null) return;
-  // WFM interference telemetry belongs to the primary DSP channel. Do not
+  const estimated = estimateBandwidthAroundPeak(lastSpectrumData, lastFreqHz);
-  // apply it to a virtual channel, where it would describe the wrong signal.
-  const onVirtual = typeof vchanIsOnVirtual === "function" && vchanIsOnVirtual();
-  const interference = onVirtual ? {} : { cci: lastWfmCci, aci: lastWfmAci };
-  const estimated = estimateOccupiedBandwidth(lastSpectrumData, lastFreqHz, interference);
   if (!Number.isFinite(estimated) || estimated <= 0) {
     syncBandwidthInput(currentBandwidthHz);
     return;

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

@@ -1641,41 +1641,16 @@ SPDX-License-Identifier: GPL-2.0-or-later
     'settings': ['/vchan.js', '/scheduler.js']
   };
   var loaded = new Set();
-  var loading = new Map();
-
-  function loadScript(src) {
-    if (loaded.has(src)) return Promise.resolve();
-    if (loading.has(src)) return loading.get(src);
-
-    var request = new Promise(function(resolve, reject) {
-      var s = document.createElement('script');
-      s.src = src;
-      s.onload = function() {
-        loaded.add(src);
-        loading.delete(src);
-        resolve();
-      };
-      s.onerror = function() {
-        loading.delete(src);
-        reject(new Error('Failed to load plugin script: ' + src));
-      };
-      document.body.appendChild(s);
-    });
-    loading.set(src, request);
-    return request;
-  }
-
   function loadPlugins(tab) {
     var scripts = pluginScripts[tab];
-    if (!scripts) return Promise.resolve();
+    if (!scripts) return;
-    return scripts.reduce(function(sequence, src) {
+    scripts.forEach(function(src) {
-      return sequence.then(function() { return loadScript(src); });
+      if (loaded.has(src)) return;
-    }, Promise.resolve());
+      loaded.add(src);
-  }
+      var s = document.createElement('script');
-
+      s.src = src;
-  function requestPlugins(tab) {
+      s.defer = true;
-    return loadPlugins(tab).catch(function(err) {
+      document.body.appendChild(s);
-      console.error(err);
     });
   }
   // Eager plugin loading is triggered by app.js (after window.trx is set up)
@@ -1683,14 +1658,12 @@ SPDX-License-Identifier: GPL-2.0-or-later
   // loading them before app.js would cause map-core.js to crash when
   // window.trx is not yet defined.
   window.loadEagerPlugins = function() {
-    return Promise.all(
+    ['digital-modes', 'map-data', 'bookmarks', 'settings'].forEach(loadPlugins);
-      ['digital-modes', 'map-data', 'bookmarks', 'settings'].map(requestPlugins)
-    );
   };
   // Load others on tab switch
   document.addEventListener('click', function(e) {
     var tab = e.target.closest('[data-tab]');
-    if (tab) requestPlugins(tab.dataset.tab);
+    if (tab) loadPlugins(tab.dataset.tab);
   });
   window.loadPluginsForTab = loadPlugins;
 })();

src/trx-server/src/audio.rs

@@ -6,14 +6,13 @@
 
 #[cfg(feature = "ft2")]
 use std::collections::HashMap;
-use std::collections::HashSet;
+use std::collections::{HashSet, VecDeque};
-#[cfg(test)]
-use std::collections::VecDeque;
 use std::net::SocketAddr;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
+use base64::Engine as _;
 use bytes::Bytes;
 use flate2::write::GzEncoder;
 use flate2::Compression;
@@ -35,9 +34,10 @@ use trx_core::audio::{
     AUDIO_MSG_VCHAN_MODE, AUDIO_MSG_VCHAN_REMOVE, AUDIO_MSG_VCHAN_SUB, AUDIO_MSG_VCHAN_UNSUB,
     AUDIO_MSG_VDES_DECODE, AUDIO_MSG_WEFAX_DECODE, AUDIO_MSG_WEFAX_PROGRESS, AUDIO_MSG_WSPR_DECODE,
 };
-#[cfg(test)]
+use trx_core::decode::{
-use trx_core::decode::{AisMessage, AprsPacket, CwEvent};
+    AisMessage, AprsPacket, CwEvent, DecodedMessage, Ft8Message, LrptImage, LrptProgress,
-use trx_core::decode::{DecodedMessage, Ft8Message, LrptImage, LrptProgress, WsprMessage};
+    VdesMessage, WefaxMessage, WsprMessage,
+};
 use trx_core::rig::state::{RigMode, RigState};
 use trx_core::vchan::SharedVChanManager;
 use trx_cw::CwDecoder;
@@ -47,9 +47,9 @@ use trx_wspr::WsprDecoder;
 use uuid::Uuid;
 
 use crate::config::AudioConfig;
-use crate::history_policy::{current_timestamp_ms, lock_or_recover};
+use crate::history_policy::{
-#[cfg(test)]
+    enforce_capacity, lock_or_recover, prune_by_age, HISTORY_RETENTION, MAX_HISTORY_ENTRIES,
-use crate::history_policy::{enforce_capacity, prune_by_age, MAX_HISTORY_ENTRIES};
+};
 use trx_decode_log::DecoderLoggers;
 
 /// Silence timeout before auto-finalising an LRPT pass (30 s without new MCUs).
@@ -65,6 +65,13 @@ const DECODE_AUDIO_GATE_RMS: f32 = 2.5e-4;
 const AUDIO_STREAM_ERROR_LOG_INTERVAL: Duration = Duration::from_secs(60);
 const AUDIO_STREAM_RECOVERY_DELAY: Duration = Duration::from_secs(1);
 
+fn current_timestamp_ms() -> i64 {
+    match std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH) {
+        Ok(dur) => dur.as_millis() as i64,
+        Err(_) => 0,
+    }
+}
+
 #[cfg(feature = "ft2")]
 fn retain_ft2_window(buf: &mut Vec<f32>) {
     if buf.len() > FT2_ASYNC_BUFFER_SAMPLES {
@@ -343,7 +350,457 @@ fn classify_stream_error(err: &str) -> &'static str {
     }
 }
 
-pub use crate::decoder_history::DecoderHistories;
+/// Per-rig decoder history store.
+///
+/// Replaces the previous process-wide `OnceLock` statics so that each rig
+/// instance can maintain its own independent history.  Pass an
+/// `Arc<DecoderHistories>` into every decoder task and into the audio listener.
+pub struct DecoderHistories {
+    pub ais: Mutex<VecDeque<(Instant, AisMessage)>>,
+    pub vdes: Mutex<VecDeque<(Instant, VdesMessage)>>,
+    pub aprs: Mutex<VecDeque<(Instant, AprsPacket)>>,
+    pub hf_aprs: Mutex<VecDeque<(Instant, AprsPacket)>>,
+    pub cw: Mutex<VecDeque<(Instant, CwEvent)>>,
+    pub ft8: Mutex<VecDeque<(Instant, Ft8Message)>>,
+    pub ft4: Mutex<VecDeque<(Instant, Ft8Message)>>,
+    pub ft2: Mutex<VecDeque<(Instant, Ft8Message)>>,
+    pub wspr: Mutex<VecDeque<(Instant, WsprMessage)>>,
+    pub lrpt: Mutex<VecDeque<(Instant, LrptImage)>>,
+    pub wefax: Mutex<VecDeque<(Instant, WefaxMessage)>>,
+    /// Approximate total entry count across all decoders, maintained
+    /// atomically so `estimated_total_count()` avoids 9 lock acquisitions.
+    total_count: AtomicUsize,
+}
+
+impl DecoderHistories {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            ais: Mutex::new(VecDeque::new()),
+            vdes: Mutex::new(VecDeque::new()),
+            aprs: Mutex::new(VecDeque::new()),
+            hf_aprs: Mutex::new(VecDeque::new()),
+            cw: Mutex::new(VecDeque::new()),
+            ft8: Mutex::new(VecDeque::new()),
+            ft4: Mutex::new(VecDeque::new()),
+            ft2: Mutex::new(VecDeque::new()),
+            wspr: Mutex::new(VecDeque::new()),
+            lrpt: Mutex::new(VecDeque::new()),
+            wefax: Mutex::new(VecDeque::new()),
+            total_count: AtomicUsize::new(0),
+        })
+    }
+
+    /// Adjust the atomic total count after a record/prune/clear operation.
+    ///
+    /// Uses a CAS loop for decrements to prevent underflow wrapping the
+    /// counter to `usize::MAX` (which would cause a capacity-overflow panic
+    /// when pre-allocating the history replay blob).
+    fn adjust_total_count(&self, old_len: usize, new_len: usize) {
+        if new_len > old_len {
+            self.total_count
+                .fetch_add(new_len - old_len, Ordering::Relaxed);
+        } else if old_len > new_len {
+            let delta = old_len - new_len;
+            let mut current = self.total_count.load(Ordering::Relaxed);
+            loop {
+                let next = current.saturating_sub(delta);
+                match self.total_count.compare_exchange_weak(
+                    current,
+                    next,
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                ) {
+                    Ok(_) => break,
+                    Err(actual) => current = actual,
+                }
+            }
+        }
+    }
+
+    // --- AIS ---
+
+    fn prune_ais(history: &mut VecDeque<(Instant, AisMessage)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_ais_message(&self, mut msg: AisMessage) {
+        if msg.ts_ms.is_none() {
+            msg.ts_ms = Some(current_timestamp_ms());
+        }
+        let mut h = lock_or_recover(&self.ais, "ais_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_ais(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_ais_history(&self) -> Vec<AisMessage> {
+        let mut h = lock_or_recover(&self.ais, "ais_history");
+        let before = h.len();
+        Self::prune_ais(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter().map(|(_, msg)| msg.clone()).collect()
+    }
+
+    // --- VDES ---
+
+    fn prune_vdes(history: &mut VecDeque<(Instant, VdesMessage)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_vdes_message(&self, mut msg: VdesMessage) {
+        if msg.ts_ms.is_none() {
+            msg.ts_ms = Some(current_timestamp_ms());
+        }
+        let mut h = lock_or_recover(&self.vdes, "vdes_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_vdes(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_vdes_history(&self) -> Vec<VdesMessage> {
+        let mut h = lock_or_recover(&self.vdes, "vdes_history");
+        let before = h.len();
+        Self::prune_vdes(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter().map(|(_, msg)| msg.clone()).collect()
+    }
+
+    // --- APRS ---
+
+    fn prune_aprs(history: &mut VecDeque<(Instant, AprsPacket)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_aprs_packet(&self, mut pkt: AprsPacket) {
+        if !pkt.crc_ok {
+            return;
+        }
+        if pkt.ts_ms.is_none() {
+            pkt.ts_ms = Some(current_timestamp_ms());
+        }
+        let mut h = lock_or_recover(&self.aprs, "aprs_history");
+        let before = h.len();
+        h.push_back((Instant::now(), pkt));
+        Self::prune_aprs(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_aprs_history(&self) -> Vec<AprsPacket> {
+        let mut h = lock_or_recover(&self.aprs, "aprs_history");
+        let before = h.len();
+        Self::prune_aprs(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, pkt): &(Instant, AprsPacket)| pkt.clone())
+            .collect()
+    }
+
+    pub fn clear_aprs_history(&self) {
+        let mut h = lock_or_recover(&self.aprs, "aprs_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- HF APRS ---
+
+    fn prune_hf_aprs(history: &mut VecDeque<(Instant, AprsPacket)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_hf_aprs_packet(&self, mut pkt: AprsPacket) {
+        if !pkt.crc_ok {
+            return;
+        }
+        if pkt.ts_ms.is_none() {
+            pkt.ts_ms = Some(current_timestamp_ms());
+        }
+        let mut h = lock_or_recover(&self.hf_aprs, "hf_aprs_history");
+        let before = h.len();
+        h.push_back((Instant::now(), pkt));
+        Self::prune_hf_aprs(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_hf_aprs_history(&self) -> Vec<AprsPacket> {
+        let mut h = lock_or_recover(&self.hf_aprs, "hf_aprs_history");
+        let before = h.len();
+        Self::prune_hf_aprs(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, pkt): &(Instant, AprsPacket)| pkt.clone())
+            .collect()
+    }
+
+    pub fn clear_hf_aprs_history(&self) {
+        let mut h = lock_or_recover(&self.hf_aprs, "hf_aprs_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- CW ---
+
+    fn prune_cw(history: &mut VecDeque<(Instant, CwEvent)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_cw_event(&self, evt: CwEvent) {
+        let mut h = lock_or_recover(&self.cw, "cw_history");
+        let before = h.len();
+        h.push_back((Instant::now(), evt));
+        Self::prune_cw(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_cw_history(&self) -> Vec<CwEvent> {
+        let mut h = lock_or_recover(&self.cw, "cw_history");
+        let before = h.len();
+        Self::prune_cw(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, evt): &(Instant, CwEvent)| evt.clone())
+            .collect()
+    }
+
+    pub fn clear_cw_history(&self) {
+        let mut h = lock_or_recover(&self.cw, "cw_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- FT8 ---
+
+    fn prune_ft8(history: &mut VecDeque<(Instant, Ft8Message)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_ft8_message(&self, msg: Ft8Message) {
+        let mut h = lock_or_recover(&self.ft8, "ft8_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_ft8(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_ft8_history(&self) -> Vec<Ft8Message> {
+        let mut h = lock_or_recover(&self.ft8, "ft8_history");
+        let before = h.len();
+        Self::prune_ft8(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, msg): &(Instant, Ft8Message)| msg.clone())
+            .collect()
+    }
+
+    pub fn clear_ft8_history(&self) {
+        let mut h = lock_or_recover(&self.ft8, "ft8_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- FT4 ---
+
+    fn prune_ft4(history: &mut VecDeque<(Instant, Ft8Message)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_ft4_message(&self, msg: Ft8Message) {
+        let mut h = lock_or_recover(&self.ft4, "ft4_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_ft4(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_ft4_history(&self) -> Vec<Ft8Message> {
+        let mut h = lock_or_recover(&self.ft4, "ft4_history");
+        let before = h.len();
+        Self::prune_ft4(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, msg): &(Instant, Ft8Message)| msg.clone())
+            .collect()
+    }
+
+    pub fn clear_ft4_history(&self) {
+        let mut h = lock_or_recover(&self.ft4, "ft4_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- FT2 ---
+
+    #[cfg_attr(not(feature = "ft2"), allow(dead_code))]
+    fn prune_ft2(history: &mut VecDeque<(Instant, Ft8Message)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    #[cfg_attr(not(feature = "ft2"), allow(dead_code))]
+    pub fn record_ft2_message(&self, msg: Ft8Message) {
+        let mut h = lock_or_recover(&self.ft2, "ft2_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_ft2(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    #[cfg_attr(not(feature = "ft2"), allow(dead_code))]
+    pub fn snapshot_ft2_history(&self) -> Vec<Ft8Message> {
+        let mut h = lock_or_recover(&self.ft2, "ft2_history");
+        let before = h.len();
+        Self::prune_ft2(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, msg): &(Instant, Ft8Message)| msg.clone())
+            .collect()
+    }
+
+    pub fn clear_ft2_history(&self) {
+        let mut h = lock_or_recover(&self.ft2, "ft2_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- WSPR ---
+
+    fn prune_wspr(history: &mut VecDeque<(Instant, WsprMessage)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_wspr_message(&self, msg: WsprMessage) {
+        let mut h = lock_or_recover(&self.wspr, "wspr_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_wspr(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_wspr_history(&self) -> Vec<WsprMessage> {
+        let mut h = lock_or_recover(&self.wspr, "wspr_history");
+        let before = h.len();
+        Self::prune_wspr(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, msg): &(Instant, WsprMessage)| msg.clone())
+            .collect()
+    }
+
+    pub fn clear_wspr_history(&self) {
+        let mut h = lock_or_recover(&self.wspr, "wspr_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- LRPT ---
+
+    fn prune_lrpt(history: &mut VecDeque<(Instant, LrptImage)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_lrpt_image(&self, mut img: LrptImage) {
+        if img.ts_ms.is_none() {
+            img.ts_ms = Some(current_timestamp_ms());
+        }
+        let mut h = lock_or_recover(&self.lrpt, "lrpt_history");
+        let before = h.len();
+        h.push_back((Instant::now(), img));
+        Self::prune_lrpt(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_lrpt_history(&self) -> Vec<LrptImage> {
+        let mut h = lock_or_recover(&self.lrpt, "lrpt_history");
+        let before = h.len();
+        Self::prune_lrpt(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, img): &(Instant, LrptImage)| img.clone())
+            .collect()
+    }
+
+    pub fn clear_lrpt_history(&self) {
+        let mut h = lock_or_recover(&self.lrpt, "lrpt_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    // --- WEFAX ---
+
+    fn prune_wefax(history: &mut VecDeque<(Instant, WefaxMessage)>) {
+        prune_by_age(history, HISTORY_RETENTION, Instant::now());
+    }
+
+    pub fn record_wefax_message(&self, mut msg: WefaxMessage) {
+        if msg.ts_ms.is_none() {
+            msg.ts_ms = Some(current_timestamp_ms());
+        }
+        // Strip bulk PNG data before storing in memory/persistence.
+        msg.png_data = None;
+        let mut h = lock_or_recover(&self.wefax, "wefax_history");
+        let before = h.len();
+        h.push_back((Instant::now(), msg));
+        Self::prune_wefax(&mut h);
+        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
+        self.adjust_total_count(before, h.len());
+    }
+
+    pub fn snapshot_wefax_history(&self) -> Vec<WefaxMessage> {
+        let mut h = lock_or_recover(&self.wefax, "wefax_history");
+        let before = h.len();
+        Self::prune_wefax(&mut h);
+        self.adjust_total_count(before, h.len());
+        h.iter()
+            .map(|(_, msg)| {
+                let mut m = msg.clone();
+                // Re-read PNG from disk so remote clients can save a local copy.
+                if m.png_data.is_none() {
+                    if let Some(ref path) = m.path {
+                        if let Ok(bytes) = std::fs::read(path) {
+                            m.png_data =
+                                Some(base64::engine::general_purpose::STANDARD.encode(&bytes));
+                        }
+                    }
+                }
+                m
+            })
+            .collect()
+    }
+
+    pub fn clear_wefax_history(&self) {
+        let mut h = lock_or_recover(&self.wefax, "wefax_history");
+        let before = h.len();
+        h.clear();
+        self.adjust_total_count(before, 0);
+    }
+
+    /// Returns a quick (non-pruning) estimate of the total number of history
+    /// entries across all decoders, used for pre-allocating the replay blob.
+    ///
+    /// Uses an `AtomicUsize` counter maintained by record/prune/clear methods,
+    /// avoiding 9 separate mutex acquisitions.
+    pub fn estimated_total_count(&self) -> usize {
+        self.total_count.load(Ordering::Relaxed)
+    }
+}
 
 /// Spawn the audio capture thread.
 ///

src/trx-server/src/decoder_history.rs

@@ -1,489 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stan Grams <sjg@haxx.space>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-//! Per-rig storage and lifecycle operations for decoded-message histories.
-
-use std::collections::VecDeque;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
-
-use base64::Engine as _;
-use trx_core::decode::{
-    AisMessage, AprsPacket, CwEvent, Ft8Message, LrptImage, VdesMessage, WefaxMessage, WsprMessage,
-};
-
-use crate::history_policy::{
-    current_timestamp_ms, enforce_capacity, lock_or_recover, prune_by_age, HISTORY_RETENTION,
-    MAX_HISTORY_ENTRIES,
-};
-
-/// Per-rig decoder history store.
-///
-/// Replaces the previous process-wide `OnceLock` statics so that each rig
-/// instance can maintain its own independent history.  Pass an
-/// `Arc<DecoderHistories>` into every decoder task and into the audio listener.
-pub struct DecoderHistories {
-    pub ais: Mutex<VecDeque<(Instant, AisMessage)>>,
-    pub vdes: Mutex<VecDeque<(Instant, VdesMessage)>>,
-    pub aprs: Mutex<VecDeque<(Instant, AprsPacket)>>,
-    pub hf_aprs: Mutex<VecDeque<(Instant, AprsPacket)>>,
-    pub cw: Mutex<VecDeque<(Instant, CwEvent)>>,
-    pub ft8: Mutex<VecDeque<(Instant, Ft8Message)>>,
-    pub ft4: Mutex<VecDeque<(Instant, Ft8Message)>>,
-    pub ft2: Mutex<VecDeque<(Instant, Ft8Message)>>,
-    pub wspr: Mutex<VecDeque<(Instant, WsprMessage)>>,
-    pub lrpt: Mutex<VecDeque<(Instant, LrptImage)>>,
-    pub wefax: Mutex<VecDeque<(Instant, WefaxMessage)>>,
-    /// Approximate total entry count across all decoders, maintained
-    /// atomically so `estimated_total_count()` avoids 11 lock acquisitions.
-    total_count: AtomicUsize,
-}
-
-impl DecoderHistories {
-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            ais: Mutex::new(VecDeque::new()),
-            vdes: Mutex::new(VecDeque::new()),
-            aprs: Mutex::new(VecDeque::new()),
-            hf_aprs: Mutex::new(VecDeque::new()),
-            cw: Mutex::new(VecDeque::new()),
-            ft8: Mutex::new(VecDeque::new()),
-            ft4: Mutex::new(VecDeque::new()),
-            ft2: Mutex::new(VecDeque::new()),
-            wspr: Mutex::new(VecDeque::new()),
-            lrpt: Mutex::new(VecDeque::new()),
-            wefax: Mutex::new(VecDeque::new()),
-            total_count: AtomicUsize::new(0),
-        })
-    }
-
-    /// Adjust the atomic total count after a record/prune/clear operation.
-    ///
-    /// Uses a CAS loop for decrements to prevent underflow wrapping the
-    /// counter to `usize::MAX` (which would cause a capacity-overflow panic
-    /// when pre-allocating the history replay blob).
-    pub(crate) fn adjust_total_count(&self, old_len: usize, new_len: usize) {
-        if new_len > old_len {
-            self.total_count
-                .fetch_add(new_len - old_len, Ordering::Relaxed);
-        } else if old_len > new_len {
-            let delta = old_len - new_len;
-            let mut current = self.total_count.load(Ordering::Relaxed);
-            loop {
-                let next = current.saturating_sub(delta);
-                match self.total_count.compare_exchange_weak(
-                    current,
-                    next,
-                    Ordering::Relaxed,
-                    Ordering::Relaxed,
-                ) {
-                    Ok(_) => break,
-                    Err(actual) => current = actual,
-                }
-            }
-        }
-    }
-
-    // --- AIS ---
-
-    fn prune_ais(history: &mut VecDeque<(Instant, AisMessage)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_ais_message(&self, mut msg: AisMessage) {
-        if msg.ts_ms.is_none() {
-            msg.ts_ms = Some(current_timestamp_ms());
-        }
-        let mut h = lock_or_recover(&self.ais, "ais_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_ais(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_ais_history(&self) -> Vec<AisMessage> {
-        let mut h = lock_or_recover(&self.ais, "ais_history");
-        let before = h.len();
-        Self::prune_ais(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter().map(|(_, msg)| msg.clone()).collect()
-    }
-
-    // --- VDES ---
-
-    fn prune_vdes(history: &mut VecDeque<(Instant, VdesMessage)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_vdes_message(&self, mut msg: VdesMessage) {
-        if msg.ts_ms.is_none() {
-            msg.ts_ms = Some(current_timestamp_ms());
-        }
-        let mut h = lock_or_recover(&self.vdes, "vdes_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_vdes(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_vdes_history(&self) -> Vec<VdesMessage> {
-        let mut h = lock_or_recover(&self.vdes, "vdes_history");
-        let before = h.len();
-        Self::prune_vdes(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter().map(|(_, msg)| msg.clone()).collect()
-    }
-
-    // --- APRS ---
-
-    fn prune_aprs(history: &mut VecDeque<(Instant, AprsPacket)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_aprs_packet(&self, mut pkt: AprsPacket) {
-        if !pkt.crc_ok {
-            return;
-        }
-        if pkt.ts_ms.is_none() {
-            pkt.ts_ms = Some(current_timestamp_ms());
-        }
-        let mut h = lock_or_recover(&self.aprs, "aprs_history");
-        let before = h.len();
-        h.push_back((Instant::now(), pkt));
-        Self::prune_aprs(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_aprs_history(&self) -> Vec<AprsPacket> {
-        let mut h = lock_or_recover(&self.aprs, "aprs_history");
-        let before = h.len();
-        Self::prune_aprs(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, pkt): &(Instant, AprsPacket)| pkt.clone())
-            .collect()
-    }
-
-    pub fn clear_aprs_history(&self) {
-        let mut h = lock_or_recover(&self.aprs, "aprs_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- HF APRS ---
-
-    fn prune_hf_aprs(history: &mut VecDeque<(Instant, AprsPacket)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_hf_aprs_packet(&self, mut pkt: AprsPacket) {
-        if !pkt.crc_ok {
-            return;
-        }
-        if pkt.ts_ms.is_none() {
-            pkt.ts_ms = Some(current_timestamp_ms());
-        }
-        let mut h = lock_or_recover(&self.hf_aprs, "hf_aprs_history");
-        let before = h.len();
-        h.push_back((Instant::now(), pkt));
-        Self::prune_hf_aprs(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_hf_aprs_history(&self) -> Vec<AprsPacket> {
-        let mut h = lock_or_recover(&self.hf_aprs, "hf_aprs_history");
-        let before = h.len();
-        Self::prune_hf_aprs(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, pkt): &(Instant, AprsPacket)| pkt.clone())
-            .collect()
-    }
-
-    pub fn clear_hf_aprs_history(&self) {
-        let mut h = lock_or_recover(&self.hf_aprs, "hf_aprs_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- CW ---
-
-    fn prune_cw(history: &mut VecDeque<(Instant, CwEvent)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_cw_event(&self, evt: CwEvent) {
-        let mut h = lock_or_recover(&self.cw, "cw_history");
-        let before = h.len();
-        h.push_back((Instant::now(), evt));
-        Self::prune_cw(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_cw_history(&self) -> Vec<CwEvent> {
-        let mut h = lock_or_recover(&self.cw, "cw_history");
-        let before = h.len();
-        Self::prune_cw(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, evt): &(Instant, CwEvent)| evt.clone())
-            .collect()
-    }
-
-    pub fn clear_cw_history(&self) {
-        let mut h = lock_or_recover(&self.cw, "cw_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- FT8 ---
-
-    fn prune_ft8(history: &mut VecDeque<(Instant, Ft8Message)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_ft8_message(&self, msg: Ft8Message) {
-        let mut h = lock_or_recover(&self.ft8, "ft8_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_ft8(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_ft8_history(&self) -> Vec<Ft8Message> {
-        let mut h = lock_or_recover(&self.ft8, "ft8_history");
-        let before = h.len();
-        Self::prune_ft8(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, msg): &(Instant, Ft8Message)| msg.clone())
-            .collect()
-    }
-
-    pub fn clear_ft8_history(&self) {
-        let mut h = lock_or_recover(&self.ft8, "ft8_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- FT4 ---
-
-    fn prune_ft4(history: &mut VecDeque<(Instant, Ft8Message)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_ft4_message(&self, msg: Ft8Message) {
-        let mut h = lock_or_recover(&self.ft4, "ft4_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_ft4(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_ft4_history(&self) -> Vec<Ft8Message> {
-        let mut h = lock_or_recover(&self.ft4, "ft4_history");
-        let before = h.len();
-        Self::prune_ft4(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, msg): &(Instant, Ft8Message)| msg.clone())
-            .collect()
-    }
-
-    pub fn clear_ft4_history(&self) {
-        let mut h = lock_or_recover(&self.ft4, "ft4_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- FT2 ---
-
-    #[cfg_attr(not(feature = "ft2"), allow(dead_code))]
-    fn prune_ft2(history: &mut VecDeque<(Instant, Ft8Message)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    #[cfg_attr(not(feature = "ft2"), allow(dead_code))]
-    pub fn record_ft2_message(&self, msg: Ft8Message) {
-        let mut h = lock_or_recover(&self.ft2, "ft2_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_ft2(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    #[cfg_attr(not(feature = "ft2"), allow(dead_code))]
-    pub fn snapshot_ft2_history(&self) -> Vec<Ft8Message> {
-        let mut h = lock_or_recover(&self.ft2, "ft2_history");
-        let before = h.len();
-        Self::prune_ft2(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, msg): &(Instant, Ft8Message)| msg.clone())
-            .collect()
-    }
-
-    pub fn clear_ft2_history(&self) {
-        let mut h = lock_or_recover(&self.ft2, "ft2_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- WSPR ---
-
-    fn prune_wspr(history: &mut VecDeque<(Instant, WsprMessage)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_wspr_message(&self, msg: WsprMessage) {
-        let mut h = lock_or_recover(&self.wspr, "wspr_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_wspr(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_wspr_history(&self) -> Vec<WsprMessage> {
-        let mut h = lock_or_recover(&self.wspr, "wspr_history");
-        let before = h.len();
-        Self::prune_wspr(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, msg): &(Instant, WsprMessage)| msg.clone())
-            .collect()
-    }
-
-    pub fn clear_wspr_history(&self) {
-        let mut h = lock_or_recover(&self.wspr, "wspr_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- LRPT ---
-
-    fn prune_lrpt(history: &mut VecDeque<(Instant, LrptImage)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_lrpt_image(&self, mut img: LrptImage) {
-        if img.ts_ms.is_none() {
-            img.ts_ms = Some(current_timestamp_ms());
-        }
-        let mut h = lock_or_recover(&self.lrpt, "lrpt_history");
-        let before = h.len();
-        h.push_back((Instant::now(), img));
-        Self::prune_lrpt(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_lrpt_history(&self) -> Vec<LrptImage> {
-        let mut h = lock_or_recover(&self.lrpt, "lrpt_history");
-        let before = h.len();
-        Self::prune_lrpt(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, img): &(Instant, LrptImage)| img.clone())
-            .collect()
-    }
-
-    pub fn clear_lrpt_history(&self) {
-        let mut h = lock_or_recover(&self.lrpt, "lrpt_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    // --- WEFAX ---
-
-    fn prune_wefax(history: &mut VecDeque<(Instant, WefaxMessage)>) {
-        prune_by_age(history, HISTORY_RETENTION, Instant::now());
-    }
-
-    pub fn record_wefax_message(&self, mut msg: WefaxMessage) {
-        if msg.ts_ms.is_none() {
-            msg.ts_ms = Some(current_timestamp_ms());
-        }
-        // Strip bulk PNG data before storing in memory/persistence.
-        msg.png_data = None;
-        let mut h = lock_or_recover(&self.wefax, "wefax_history");
-        let before = h.len();
-        h.push_back((Instant::now(), msg));
-        Self::prune_wefax(&mut h);
-        enforce_capacity(&mut h, MAX_HISTORY_ENTRIES);
-        self.adjust_total_count(before, h.len());
-    }
-
-    pub fn snapshot_wefax_history(&self) -> Vec<WefaxMessage> {
-        let mut h = lock_or_recover(&self.wefax, "wefax_history");
-        let before = h.len();
-        Self::prune_wefax(&mut h);
-        self.adjust_total_count(before, h.len());
-        h.iter()
-            .map(|(_, msg)| {
-                let mut m = msg.clone();
-                // Re-read PNG from disk so remote clients can save a local copy.
-                if m.png_data.is_none() {
-                    if let Some(ref path) = m.path {
-                        if let Ok(bytes) = std::fs::read(path) {
-                            m.png_data =
-                                Some(base64::engine::general_purpose::STANDARD.encode(&bytes));
-                        }
-                    }
-                }
-                m
-            })
-            .collect()
-    }
-
-    pub fn clear_wefax_history(&self) {
-        let mut h = lock_or_recover(&self.wefax, "wefax_history");
-        let before = h.len();
-        h.clear();
-        self.adjust_total_count(before, 0);
-    }
-
-    /// Returns a quick (non-pruning) estimate of the total number of history
-    /// entries across all decoders, used for pre-allocating the replay blob.
-    ///
-    /// Uses an `AtomicUsize` counter maintained by record/prune/clear methods,
-    /// avoiding 11 separate mutex acquisitions.
-    pub fn estimated_total_count(&self) -> usize {
-        self.total_count.load(Ordering::Relaxed)
-    }
-
-    /// Rebuild the aggregate count after bulk restoration bypasses the normal
-    /// record methods.
-    pub(crate) fn recalculate_total_count(&self) {
-        let total = lock_or_recover(&self.ais, "ais_history").len()
-            + lock_or_recover(&self.vdes, "vdes_history").len()
-            + lock_or_recover(&self.aprs, "aprs_history").len()
-            + lock_or_recover(&self.hf_aprs, "hf_aprs_history").len()
-            + lock_or_recover(&self.cw, "cw_history").len()
-            + lock_or_recover(&self.ft8, "ft8_history").len()
-            + lock_or_recover(&self.ft4, "ft4_history").len()
-            + lock_or_recover(&self.ft2, "ft2_history").len()
-            + lock_or_recover(&self.wspr, "wspr_history").len()
-            + lock_or_recover(&self.lrpt, "lrpt_history").len()
-            + lock_or_recover(&self.wefax, "wefax_history").len();
-        self.total_count.store(total, Ordering::Relaxed);
-    }
-}

src/trx-server/src/history_policy.rs

@@ -14,13 +14,6 @@ pub(crate) const HISTORY_RETENTION: Duration = Duration::from_secs(24 * 60 * 60)
 /// busy channels independently of time-based pruning.
 pub(crate) const MAX_HISTORY_ENTRIES: usize = 10_000;
 
-pub(crate) fn current_timestamp_ms() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map(|duration| duration.as_millis() as i64)
-        .unwrap_or(0)
-}
-
 pub(crate) fn lock_or_recover<'a, T>(mutex: &'a Mutex<T>, label: &str) -> MutexGuard<'a, T> {
     mutex.lock().unwrap_or_else(|error| {
         tracing::warn!(

src/trx-server/src/history_store.rs

@@ -19,7 +19,7 @@ use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 use trx_core::decode::{
-    AisMessage, AprsPacket, CwEvent, Ft8Message, LrptImage, VdesMessage, WefaxMessage, WsprMessage,
+    AisMessage, AprsPacket, CwEvent, Ft8Message, VdesMessage, WefaxMessage, WsprMessage,
 };
 
 use crate::audio::DecoderHistories;
@@ -118,11 +118,6 @@ pub fn load_all(db: &PickleDb, rig_id: &str, histories: &Arc<DecoderHistories>)
             h.push_back(e);
         }
     }
-    if let Ok(mut h) = histories.hf_aprs.lock() {
-        for e in load_key::<AprsPacket>(db, &k("hf_aprs")) {
-            h.push_back(e);
-        }
-    }
     if let Ok(mut h) = histories.cw.lock() {
         for e in load_key::<CwEvent>(db, &k("cw")) {
             h.push_back(e);
@@ -133,32 +128,16 @@ pub fn load_all(db: &PickleDb, rig_id: &str, histories: &Arc<DecoderHistories>)
             h.push_back(e);
         }
     }
-    if let Ok(mut h) = histories.ft4.lock() {
-        for e in load_key::<Ft8Message>(db, &k("ft4")) {
-            h.push_back(e);
-        }
-    }
-    if let Ok(mut h) = histories.ft2.lock() {
-        for e in load_key::<Ft8Message>(db, &k("ft2")) {
-            h.push_back(e);
-        }
-    }
     if let Ok(mut h) = histories.wspr.lock() {
         for e in load_key::<WsprMessage>(db, &k("wspr")) {
             h.push_back(e);
         }
     }
-    if let Ok(mut h) = histories.lrpt.lock() {
-        for e in load_key::<LrptImage>(db, &k("lrpt")) {
-            h.push_back(e);
-        }
-    }
     if let Ok(mut h) = histories.wefax.lock() {
         for e in load_key::<WefaxMessage>(db, &k("wefax")) {
             h.push_back(e);
         }
     }
-    histories.recalculate_total_count();
 }
 
 /// Flush `histories` to the database under `rig_id`-prefixed keys and sync.
@@ -183,11 +162,6 @@ pub fn flush_all(db: &mut PickleDb, rig_id: &str, histories: &Arc<DecoderHistori
         drop(h);
         save_key(db, &k("aprs"), &snapshot);
     }
-    if let Ok(h) = histories.hf_aprs.lock() {
-        let snapshot = h.clone();
-        drop(h);
-        save_key(db, &k("hf_aprs"), &snapshot);
-    }
     if let Ok(h) = histories.cw.lock() {
         let snapshot = h.clone();
         drop(h);
@@ -198,26 +172,11 @@ pub fn flush_all(db: &mut PickleDb, rig_id: &str, histories: &Arc<DecoderHistori
         drop(h);
         save_key(db, &k("ft8"), &snapshot);
     }
-    if let Ok(h) = histories.ft4.lock() {
-        let snapshot = h.clone();
-        drop(h);
-        save_key(db, &k("ft4"), &snapshot);
-    }
-    if let Ok(h) = histories.ft2.lock() {
-        let snapshot = h.clone();
-        drop(h);
-        save_key(db, &k("ft2"), &snapshot);
-    }
     if let Ok(h) = histories.wspr.lock() {
         let snapshot = h.clone();
         drop(h);
         save_key(db, &k("wspr"), &snapshot);
     }
-    if let Ok(h) = histories.lrpt.lock() {
-        let snapshot = h.clone();
-        drop(h);
-        save_key(db, &k("lrpt"), &snapshot);
-    }
     if let Ok(h) = histories.wefax.lock() {
         let snapshot = h.clone();
         drop(h);
@@ -226,38 +185,20 @@ pub fn flush_all(db: &mut PickleDb, rig_id: &str, histories: &Arc<DecoderHistori
     let _ = db.dump();
 }
 
-fn flush_all_rigs(db: &Mutex<PickleDb>, rig_histories: &[(String, Arc<DecoderHistories>)]) {
-    let Ok(mut guard) = db.lock() else {
-        tracing::warn!("history database mutex poisoned; skipping periodic flush");
-        return;
-    };
-    for (rig_id, histories) in rig_histories {
-        flush_all(&mut guard, rig_id, histories);
-    }
-}
-
 /// Spawn a Tokio task that flushes all rigs' histories to disk every 60 seconds.
-///
-/// Snapshot cloning, JSON serialization, and disk I/O run on Tokio's blocking
-/// pool so a large history database cannot stall an async runtime worker.
 pub fn spawn_flush_task(
     db: Arc<Mutex<PickleDb>>,
     rig_histories: Vec<(String, Arc<DecoderHistories>)>,
 ) {
     tokio::spawn(async move {
-        let rig_histories = Arc::new(rig_histories);
         let mut interval = tokio::time::interval(Duration::from_secs(60));
         interval.tick().await; // consume the immediate first tick
         loop {
             interval.tick().await;
-            let db = Arc::clone(&db);
+            if let Ok(mut guard) = db.lock() {
-            let rig_histories = Arc::clone(&rig_histories);
+                for (rig_id, histories) in &rig_histories {
-            if let Err(err) = tokio::task::spawn_blocking(move || {
+                    flush_all(&mut guard, rig_id, histories);
-                flush_all_rigs(&db, rig_histories.as_slice());
+                }
-            })
-            .await
-            {
-                tracing::warn!(error = %err, "history flush worker failed");
             }
         }
     });
@@ -361,79 +302,4 @@ mod tests {
         let _ = std::fs::remove_file(&db_file);
         let _ = std::fs::remove_dir(&dir);
     }
-
-    #[test]
-    fn flush_and_load_all_restores_previously_omitted_histories() {
-        let db_file = std::env::temp_dir().join(format!(
-            "trx_history_all_{}_{}.db",
-            std::process::id(),
-            now_unix_ms()
-        ));
-        let mut db = PickleDb::new(
-            &db_file,
-            PickleDbDumpPolicy::DumpUponRequest,
-            SerializationMethod::Json,
-        );
-        let source = DecoderHistories::new();
-        let now = Instant::now();
-
-        source.hf_aprs.lock().unwrap().push_back((
-            now,
-            AprsPacket {
-                rig_id: Some("rig-a".into()),
-                ts_ms: Some(now_unix_ms()),
-                src_call: "TEST".into(),
-                dest_call: "APRS".into(),
-                path: String::new(),
-                info: "history".into(),
-                info_bytes: Vec::new(),
-                packet_type: "position".into(),
-                crc_ok: true,
-                lat: None,
-                lon: None,
-                symbol_table: None,
-                symbol_code: None,
-            },
-        ));
-        for (queue, mode) in [(&source.ft4, "FT4"), (&source.ft2, "FT2")] {
-            queue.lock().unwrap().push_back((
-                now,
-                Ft8Message {
-                    rig_id: Some("rig-a".into()),
-                    ts_ms: now_unix_ms(),
-                    snr_db: -10.0,
-                    dt_s: 0.1,
-                    freq_hz: 1_000.0,
-                    message: mode.into(),
-                },
-            ));
-        }
-        source.lrpt.lock().unwrap().push_back((
-            now,
-            LrptImage {
-                rig_id: Some("rig-a".into()),
-                pass_start_ms: now_unix_ms(),
-                pass_end_ms: now_unix_ms(),
-                mcu_count: 1,
-                path: "/tmp/lrpt.png".into(),
-                ts_ms: Some(now_unix_ms()),
-                satellite: None,
-                channels: None,
-                geo_bounds: None,
-                ground_track: None,
-            },
-        ));
-
-        flush_all(&mut db, "rig-a", &source);
-        let restored = DecoderHistories::new();
-        load_all(&db, "rig-a", &restored);
-
-        assert_eq!(restored.hf_aprs.lock().unwrap().len(), 1);
-        assert_eq!(restored.ft4.lock().unwrap().len(), 1);
-        assert_eq!(restored.ft2.lock().unwrap().len(), 1);
-        assert_eq!(restored.lrpt.lock().unwrap().len(), 1);
-        assert_eq!(restored.estimated_total_count(), 4);
-
-        let _ = std::fs::remove_file(db_file);
-    }
 }

src/trx-server/src/main.rs

@@ -4,7 +4,6 @@
 
 mod audio;
 mod config;
-mod decoder_history;
 mod error;
 mod history_policy;
 mod history_store;

src/trx-server/trx-backend/trx-backend-soapysdr/src/dsp/filter.rs

@@ -251,9 +251,9 @@ fn mul_freq_domain(buf: &mut [FftComplex<f32>], h_freq: &[FftComplex<f32>], scal
         unsafe {
             mul_freq_domain_neon(buf, h_freq, scale);
         }
+        return;
     }
 
-    #[cfg(not(target_arch = "aarch64"))]
     mul_freq_domain_scalar(buf, h_freq, scale);
 }