fix(mlg): correct timestamp unit and viewport-aware chart detail

Two MLG-related fixes bundled together:

1. Parser: MLG raw u16 timestamps are 10 µs/tick per the EFI Analytics
   MLG Binary Log Format spec, not 1 ms/tick. The previous formula
   compounded a 10× error in both the raw remainder and the wrap count
   for a net 100× over-estimate of wall-clock time (a ~30 min log
   showed as ~48 hours). Fixed via named constants
   MLG_TICK_SECONDS = 1e-5 and MLG_WRAP_TICKS = 65536, plus a
   regression test covering rusefi/speeduino sample logs.

2. UI: chart downsampling now slices raw data to the visible viewport
   before LTTB so detail scales with zoom. Previously LTTB compressed
   the full log to MAX_CHART_POINTS regardless of zoom, leaving fine
   detail invisible. Viewport bounds are remembered per plot area
   between frames; Y normalization uses the channel's global min/max
   so heights stay stable across pans.

Author: irudoy

src/app.rs

@@ -55,6 +55,11 @@ pub struct UltraLogApp {
     pub(crate) downsample_cache: HashMap<CacheKey, Vec<[f64; 2]>>,
     /// Cache for channel min/max values (avoids O(n) scans)
     pub(crate) minmax_cache: HashMap<CacheKey, (f64, f64)>,
+    /// Last X-axis bounds shown by each plot area. Used to slice raw data to
+    /// the visible viewport before LTTB-downsampling, so chart detail scales
+    /// with zoom level instead of being fixed at MAX_CHART_POINTS over the
+    /// full log range. Keyed by plot_area_id (0 in single-plot mode).
+    pub(crate) chart_last_x_bounds: HashMap<usize, (f64, f64)>,
     /// Current cursor position in seconds (timeline feature)
     pub(crate) cursor_time: Option<f64>,
     /// Total time range across all loaded files (min, max)
@@ -175,6 +180,7 @@ impl Default for UltraLogApp {
             loading_state: LoadingState::Idle,
             downsample_cache: HashMap::new(),
             minmax_cache: HashMap::new(),
+            chart_last_x_bounds: HashMap::new(),
             cursor_time: None,
             time_range: None,
             cursor_record: None,
@@ -919,6 +925,10 @@ impl UltraLogApp {
             }
             self.minmax_cache = new_minmax_cache;
 
+            // Reset viewport-bounds memory so the next frame after a file is
+            // removed picks fresh bounds from whatever data remains.
+            self.chart_last_x_bounds.clear();
+
             // Clear computed channels for this file and update indices
             self.file_computed_channels.remove(&index);
             let mut new_computed_channels = HashMap::new();

src/parsers/speeduino.rs

@@ -285,11 +285,16 @@ impl Speeduino {
         let mut times: Vec<f64> = Vec::with_capacity(estimated_records);
         let mut data_records: Vec<Vec<Value>> = Vec::with_capacity(estimated_records);
 
-        // Track timestamp wraparound (u16 wraps at 65535ms = 65.535 seconds)
+        // Track u16 timestamp wraparound. Per the EFI Analytics MLG Binary
+        // Log Format spec, each tick is 10 µs, so the u16 wraps every
+        // 65536 × 10 µs = 0.65536 s of wall-clock time.
+        const MLG_TICK_SECONDS: f64 = 1e-5;
+        const MLG_WRAP_TICKS: f64 = 65_536.0;
         let mut prev_raw_timestamp: u16 = 0;
         let mut wrap_count: u64 = 0;
-        // If timestamp drops by more than 30 seconds, it definitely wrapped
-        // (actual wraparounds show ~58.7s drop when going from ~65s to ~6s)
+        // A drop > 30000 raw ticks (= 0.3 s) is far above the per-record
+        // increment at any realistic ECU sample rate (20–1000 Hz), so it
+        // reliably distinguishes a real u16 wraparound from sample jitter.
         const WRAP_THRESHOLD: u16 = 30000;
 
         while offset + 4 <= data.len() {
@@ -316,7 +321,8 @@ impl Speeduino {
             prev_raw_timestamp = raw_timestamp;
 
             // Calculate actual timestamp with wraparound compensation
-            let timestamp = (raw_timestamp as f64 / 1000.0) + (wrap_count as f64 * 65.536);
+            let timestamp =
+                (raw_timestamp as f64 + wrap_count as f64 * MLG_WRAP_TICKS) * MLG_TICK_SECONDS;
 
             if block_type == 0 {
                 // Data record - calculate required bytes for all channels
@@ -819,4 +825,50 @@ mod tests {
         eprintln!("Parsed {} channels from rusEFI log", log.channels.len());
         eprintln!("Parsed {} data records", log.data.len());
     }
+
+    #[test]
+    fn test_mlg_timestamp_scale() {
+        // Regression guard for the 10 µs/bit timestamp unit. A previous
+        // version of the parser treated the u16 tick as milliseconds, which
+        // multiplied wall-clock time by ~100×. The bounds below are wide
+        // enough to allow any realistic ECU sample rate (1 ms .. 1 s per
+        // record) and tight enough to fail loudly on a ×10 or ×100 drift.
+        for file_path in [
+            "exampleLogs/rusefi/rusefilog.mlg",
+            "exampleLogs/rusefi/Log1.mlg",
+            "exampleLogs/speeduino/speeduino.mlg",
+        ] {
+            let data = match std::fs::read(file_path) {
+                Ok(d) => d,
+                Err(_) => {
+                    eprintln!("Skipping {}: file not found", file_path);
+                    continue;
+                }
+            };
+
+            let log = Speeduino::parse_binary(&data)
+                .unwrap_or_else(|e| panic!("parse {}: {}", file_path, e));
+            assert!(
+                log.times.len() > 1,
+                "{}: expected multiple records",
+                file_path
+            );
+
+            let total = *log.times.last().unwrap() - log.times[0];
+            let avg_dt = total / (log.times.len() - 1) as f64;
+            assert!(
+                (1e-3..=1.0).contains(&avg_dt),
+                "{}: average sample interval {:.6}s outside 1ms..1s — units regression?",
+                file_path,
+                avg_dt
+            );
+            eprintln!(
+                "{}: {} records, total {:.3}s, avg dt {:.4}s",
+                file_path,
+                log.times.len(),
+                total,
+                avg_dt
+            );
+        }
+    }
 }

src/ui/chart.rs

@@ -7,8 +7,8 @@ use rust_i18n::t;
 use crate::app::UltraLogApp;
 use crate::normalize::normalize_channel_name_with_custom;
 use crate::state::{
-    CacheKey, PlotArea, SelectedChannel, CHART_COLORS, COLORBLIND_COLORS, MAX_CHART_POINTS,
-    MIN_PLOT_HEIGHT, PLOT_RESIZE_HANDLE_HEIGHT,
+    PlotArea, SelectedChannel, CHART_COLORS, COLORBLIND_COLORS, MAX_CHART_POINTS, MIN_PLOT_HEIGHT,
+    PLOT_RESIZE_HANDLE_HEIGHT,
 };
 
 /// Sensitivity multiplier for scroll-to-zoom (higher = faster zoom per scroll tick).
@@ -76,32 +76,16 @@ impl UltraLogApp {
             return;
         }
 
-        // Pre-compute and cache downsampled + normalized data for all selected channels
-        for selected in &selected_channels {
-            if selected.file_index >= self.files.len() {
-                continue;
-            }
-
-            let cache_key = CacheKey {
-                file_index: selected.file_index,
-                channel_index: selected.channel_index,
-                plot_area_id: 0, // Single-plot mode uses plot_area_id 0
-            };
-
-            if !self.downsample_cache.contains_key(&cache_key) {
-                let file = &self.files[selected.file_index];
-                let times = file.log.get_times_as_f64();
-                // Use app method to get channel data (handles both regular and computed channels)
-                let data = self.get_channel_data(selected.file_index, selected.channel_index);
-
-                if times.len() == data.len() && !times.is_empty() {
-                    let downsampled = Self::downsample_lttb(times, &data, MAX_CHART_POINTS);
-                    // Normalize Y values to 0-1 range so all channels overlay
-                    let normalized = Self::normalize_points(&downsampled);
-                    self.downsample_cache.insert(cache_key, normalized);
-                }
-            }
-        }
+        // Compute downsampled + normalized data sliced to the current viewport.
+        // Detail scales with zoom level: a 1% viewport gets MAX_CHART_POINTS
+        // over that 1%, not over the whole log.
+        let viewport = self.chart_last_x_bounds.get(&0).copied();
+        let chart_points: Vec<Option<Vec<[f64; 2]>>> = selected_channels
+            .iter()
+            .map(|selected| {
+                self.compute_viewport_points(selected.file_index, selected.channel_index, viewport)
+            })
+            .collect();
 
         // Pre-compute legend names with current values at cursor position
         let use_normalization = self.field_normalization;
@@ -139,7 +123,7 @@ impl UltraLogApp {
             .collect();
 
         // Prepare data for the plot closure (can't borrow self mutably inside)
-        let cache = &self.downsample_cache;
+        let chart_points = &chart_points;
         let files = &self.files;
         // selected_channels already defined at top of function from get_selected_channels()
         let cursor_time = self.get_cursor_time();
@@ -275,13 +259,7 @@ impl UltraLogApp {
                     continue;
                 }
 
-                let cache_key = CacheKey {
-                    file_index: selected.file_index,
-                    channel_index: selected.channel_index,
-                    plot_area_id: 0, // Single-plot mode uses plot_area_id 0
-                };
-
-                if let Some(points) = cache.get(&cache_key) {
+                if let Some(points) = chart_points.get(i).and_then(|p| p.as_ref()) {
                     let plot_points: PlotPoints = points.iter().copied().collect();
                     let palette = if color_blind_mode {
                         COLORBLIND_COLORS
@@ -314,6 +292,12 @@ impl UltraLogApp {
             plot_ui.pointer_coordinate()
         });
 
+        // Remember the X-axis bounds we just rendered so the next frame can
+        // slice raw data to this viewport before LTTB-downsampling.
+        let final_bounds = response.transform.bounds();
+        self.chart_last_x_bounds
+            .insert(0, (final_bounds.min()[0], final_bounds.max()[0]));
+
         // Detect user interaction with chart (drag, zoom, scroll)
         // This marks the chart as "interacted" so we stop using the initial zoomed view
         if response.response.dragged()
@@ -506,30 +490,14 @@ impl UltraLogApp {
         plot_area_id: usize,
         height: f32,
     ) {
-        // Pre-compute and cache data for these channels
-        for selected in channels {
-            if selected.file_index >= self.files.len() {
-                continue;
-            }
-
-            let cache_key = CacheKey {
-                file_index: selected.file_index,
-                channel_index: selected.channel_index,
-                plot_area_id,
-            };
-
-            if !self.downsample_cache.contains_key(&cache_key) {
-                let file = &self.files[selected.file_index];
-                let times = file.log.get_times_as_f64();
-                let data = self.get_channel_data(selected.file_index, selected.channel_index);
-
-                if times.len() == data.len() && !times.is_empty() {
-                    let downsampled = Self::downsample_lttb(times, &data, MAX_CHART_POINTS);
-                    let normalized = Self::normalize_points(&downsampled);
-                    self.downsample_cache.insert(cache_key, normalized);
-                }
-            }
-        }
+        // Compute viewport-aware downsampled + normalized points for this plot area.
+        let viewport = self.chart_last_x_bounds.get(&plot_area_id).copied();
+        let chart_points: Vec<Option<Vec<[f64; 2]>>> = channels
+            .iter()
+            .map(|selected| {
+                self.compute_viewport_points(selected.file_index, selected.channel_index, viewport)
+            })
+            .collect();
 
         // Build legend names with values
         let use_normalization = self.field_normalization;
@@ -567,7 +535,7 @@ impl UltraLogApp {
             .collect();
 
         // Prepare data for plot
-        let cache = &self.downsample_cache;
+        let chart_points = &chart_points;
         let files = &self.files;
         let cursor_time = self.get_cursor_time();
         let cursor_tracking = self.cursor_tracking;
@@ -652,13 +620,7 @@ impl UltraLogApp {
                     continue;
                 }
 
-                let cache_key = CacheKey {
-                    file_index: selected.file_index,
-                    channel_index: selected.channel_index,
-                    plot_area_id,
-                };
-
-                if let Some(points) = cache.get(&cache_key) {
+                if let Some(points) = chart_points.get(i).and_then(|p| p.as_ref()) {
                     let plot_points: PlotPoints = points.iter().copied().collect();
                     let palette = if color_blind_mode {
                         COLORBLIND_COLORS
@@ -688,6 +650,12 @@ impl UltraLogApp {
             plot_ui.pointer_coordinate()
         });
 
+        // Save the bounds we just rendered so the next frame's downsample
+        // matches the visible viewport.
+        let final_bounds = response.transform.bounds();
+        self.chart_last_x_bounds
+            .insert(plot_area_id, (final_bounds.min()[0], final_bounds.max()[0]));
+
         // Detect interaction
         if response.response.dragged()
             || response.response.drag_started()
@@ -872,6 +840,61 @@ impl UltraLogApp {
         }
     }
 
+    /// Compute the points to plot for one channel, sliced to the currently
+    /// visible viewport before LTTB-downsampling. Y is normalized to [0, 1]
+    /// against the channel's full-range min/max so heights stay stable when
+    /// the user pans or zooms. `viewport` is the previous frame's X bounds;
+    /// when `None` (e.g., first frame after load) the full data range is used.
+    fn compute_viewport_points(
+        &mut self,
+        file_index: usize,
+        channel_index: usize,
+        viewport: Option<(f64, f64)>,
+    ) -> Option<Vec<[f64; 2]>> {
+        let file = self.files.get(file_index)?;
+        let times = file.log.get_times_as_f64();
+        let data = self.get_channel_data(file_index, channel_index);
+        if times.is_empty() || times.len() != data.len() {
+            return None;
+        }
+
+        let (lo, hi) = match viewport {
+            Some((vmin, vmax)) if vmax > vmin => {
+                let pad = (vmax - vmin) * 0.1;
+                let lo_t = vmin - pad;
+                let hi_t = vmax + pad;
+                let lo_i = times.partition_point(|&t| t < lo_t).saturating_sub(1);
+                let hi_i = times
+                    .partition_point(|&t| t <= hi_t)
+                    .saturating_add(1)
+                    .min(times.len());
+                (lo_i, hi_i.max(lo_i + 1))
+            }
+            _ => (0, times.len()),
+        };
+
+        let times_slice = &times[lo..hi];
+        let data_slice = &data[lo..hi];
+        let downsampled = Self::downsample_lttb(times_slice, data_slice, MAX_CHART_POINTS);
+
+        let (min_y, max_y) = self
+            .get_channel_min_max(file_index, channel_index)
+            .unwrap_or((0.0, 1.0));
+        let range = (max_y - min_y).abs();
+        // Constant channels (range ≈ 0) get parked at the middle of the
+        // overlay strip so they remain visible instead of pinning to the
+        // bottom edge — matches the prior `normalize_points` behavior.
+        if range < f64::EPSILON {
+            return Some(downsampled.into_iter().map(|p| [p[0], 0.5]).collect());
+        }
+        Some(
+            downsampled
+                .into_iter()
+                .map(|p| [p[0], (p[1] - min_y) / range])
+                .collect(),
+        )
+    }
+
     /// Normalize values to 0-1 range for overlay display
     pub fn normalize_points(points: &[[f64; 2]]) -> Vec<[f64; 2]> {
         if points.is_empty() {

tests/parsers/speeduino_tests.rs

@@ -290,6 +290,55 @@ fn test_speeduino_timestamp_monotonicity() {
     assert_monotonic_times(&log);
 }
 
+/// Regression guard for the MLG raw u16 timestamp unit (10 µs/tick per the
+/// EFI Analytics MLG spec). A previous version of the parser used 1 ms/tick,
+/// which compounded with the wraparound logic to inflate wall-clock time
+/// ~100×. We bound the total parsed duration to a value that all bundled
+/// sample logs comfortably satisfy and that any 10× or 100× drift would
+/// blow past.
+fn assert_mlg_total_duration_under(file_path: &str, max_seconds: f64) {
+    if !example_file_exists(file_path) {
+        eprintln!("Skipping {}: file not found", file_path);
+        return;
+    }
+
+    let data = read_example_binary(file_path);
+    let log = Speeduino::parse_binary(&data)
+        .unwrap_or_else(|e| panic!("Failed to parse {}: {}", file_path, e));
+
+    assert!(
+        log.times.len() > 1,
+        "{}: expected multiple records",
+        file_path
+    );
+
+    let total = *log.times.last().unwrap() - log.times[0];
+    assert!(
+        total > 0.0 && total < max_seconds,
+        "{}: total duration {:.3}s outside (0, {})s — timestamp unit regression?",
+        file_path,
+        total,
+        max_seconds
+    );
+}
+
+#[test]
+fn test_speeduino_mlg_duration_bounded() {
+    // ~30 minutes is well above any of the bundled speeduino samples but
+    // far below the ~50 hour figure the old 1ms-tick interpretation produced.
+    assert_mlg_total_duration_under(SPEEDUINO_MLG, 30.0 * 60.0);
+}
+
+#[test]
+fn test_rusefi_mlg_duration_bounded() {
+    assert_mlg_total_duration_under(RUSEFI_MLG, 30.0 * 60.0);
+}
+
+#[test]
+fn test_rusefi_log1_duration_bounded() {
+    assert_mlg_total_duration_under(RUSEFI_LOG1, 30.0 * 60.0);
+}
+
 #[test]
 fn test_speeduino_timestamp_range() {
     if !example_file_exists(SPEEDUINO_MLG) {