Viewer: real instant encoding swap + strict ISO-8859-1 decoder

- Added with_encoding(FileEncoding) -> Option<Box<dyn FileViewerBackend>> on
  the backend trait. ByteSeek and LineIndex implement it as 'clone struct,
  swap encoding field, skip reindex'. set_encoding's instant-swap path now
  invokes with_encoding and returns immediately when same_byte_layout holds
  (UTF-8 <-> Windows-1252 family); the prior implementation always queued a
  background rebuild, defeating the 'instant' label.
- Replaced FileEncoding::Iso8859_1's encoding_rs alias to WINDOWS_1252 with
  a manual 1:1 byte-to-codepoint decoder. encoding_rs reassigns 0x80-0x9F to
  Windows-1252 glyphs (0x80 -> Euro); strict ISO-8859-1 leaves them as the
  C1 control codes U+0080-U+009F. Users selecting 'Western (ISO-8859-1)' get
  the strict mapping now. as_static() for Iso8859_1 is unreachable!() because
  decode_line handles it before that branch.
- Added a test-only AtomicUsize counter on LineIndexBackend::open_with_encoding
  so tests can assert the instant-swap path skips the rebuild.

Author: vdavid

apps/desktop/src-tauri/src/file_viewer/byte_seek.rs

@@ -270,6 +270,18 @@ impl FileViewerBackend for ByteSeekBackend {
         Ok(Box::new(self.extend_to(new_size, cancel)))
     }
 
+    fn with_encoding(&self, new_encoding: FileEncoding) -> Option<Box<dyn FileViewerBackend>> {
+        if !super::encoding::same_byte_layout(self.encoding, new_encoding) {
+            return None;
+        }
+        Some(Box::new(Self {
+            path: self.path.clone(),
+            total_bytes: self.total_bytes,
+            file_name: self.file_name.clone(),
+            encoding: new_encoding,
+        }))
+    }
+
     fn get_lines(&self, target: &SeekTarget, count: usize) -> Result<LineChunk, ViewerError> {
         let raw_offset = self.resolve_byte_offset(target);
 

apps/desktop/src-tauri/src/file_viewer/encoding.rs

@@ -107,11 +107,19 @@ impl FileEncoding {
     }
 
     /// Maps to the `encoding_rs` static encoding used by `decode_line`.
+    ///
+    /// **Iso8859_1 is NOT mapped via `encoding_rs::WINDOWS_1252`** because the
+    /// two disagree on the `0x80-0x9F` range: Windows-1252 reassigns those
+    /// bytes to characters like `€` (`0x80`), while strict ISO-8859-1 leaves
+    /// them as the C1 control codes `U+0080-U+009F`. The viewer handles ISO
+    /// directly via a manual 1:1 byte → codepoint table in [`decode_line`];
+    /// this method is unused for the `Iso8859_1` variant (and asserts the
+    /// invariant via `unreachable!`).
     pub fn as_static(self) -> &'static encoding_rs::Encoding {
         match self {
             Self::Utf8 | Self::Utf8WithBom | Self::UsAscii => encoding_rs::UTF_8,
             Self::Windows1252 => encoding_rs::WINDOWS_1252,
-            Self::Iso8859_1 => encoding_rs::WINDOWS_1252, // ISO-8859-1 is a strict subset; encoding_rs aliases.
+            Self::Iso8859_1 => unreachable!("ISO-8859-1 decoding is handled manually in decode_line"),
             Self::MacRoman => encoding_rs::MACINTOSH,
             Self::Utf16Le => encoding_rs::UTF_16LE,
             Self::Utf16Be => encoding_rs::UTF_16BE,
@@ -368,6 +376,18 @@ pub fn decode_line(bytes: &[u8], encoding: FileEncoding) -> String {
     ) {
         return String::from_utf8_lossy(bytes).into_owned();
     }
+    if matches!(encoding, FileEncoding::Iso8859_1) {
+        // Strict ISO-8859-1: byte N decodes to U+00XX with no remapping. The
+        // 0x80-0x9F range stays as C1 control codes, unlike Windows-1252
+        // which reassigns them to characters like `€` (0x80). Implemented
+        // manually because `encoding_rs` doesn't ship a strict ISO-8859-1
+        // decoder — it aliases the label to Windows-1252.
+        let mut out = String::with_capacity(bytes.len());
+        for &b in bytes {
+            out.push(b as char);
+        }
+        return out;
+    }
     let (cow, _had_errors) = encoding.as_static().decode_without_bom_handling(bytes);
     cow.into_owned()
 }

apps/desktop/src-tauri/src/file_viewer/line_index.rs

@@ -21,6 +21,17 @@ use super::{
     BackendCapabilities, FileViewerBackend, INDEX_CHECKPOINT_INTERVAL, LineChunk, SearchMatch, SeekTarget, ViewerError,
 };
 
+/// Test-only counter incremented every time `LineIndexBackend::open_with_encoding`
+/// runs. Lets tests assert the instant-swap path actually skips the rebuild.
+#[cfg(test)]
+static OPEN_CALL_COUNT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+
+#[cfg(test)]
+#[allow(dead_code, reason = "consumed by session_test instant-swap test")]
+pub fn test_only_open_call_count() -> usize {
+    OPEN_CALL_COUNT.load(Ordering::Relaxed)
+}
+
 /// A checkpoint in the line index: (line_number, byte_offset).
 #[derive(Debug, Clone)]
 struct Checkpoint {
@@ -49,6 +60,8 @@ impl LineIndexBackend {
     }
 
     pub fn open_with_encoding(path: &Path, encoding: FileEncoding, cancel: &AtomicBool) -> Result<Self, ViewerError> {
+        #[cfg(test)]
+        OPEN_CALL_COUNT.fetch_add(1, Ordering::Relaxed);
         let metadata = std::fs::metadata(path).map_err(|e| match e.kind() {
             std::io::ErrorKind::NotFound => ViewerError::NotFound {
                 path: path.display().to_string(),
@@ -388,6 +401,24 @@ impl FileViewerBackend for LineIndexBackend {
         Ok(Box::new(extended))
     }
 
+    fn with_encoding(&self, new_encoding: FileEncoding) -> Option<Box<dyn FileViewerBackend>> {
+        // Only valid when the new encoding shares byte layout with the current
+        // one (same BOM + both ASCII-newline-compatible). The session enforces
+        // this via `same_byte_layout` before calling, but check again here so
+        // a future caller can't accidentally bypass the rebuild.
+        if !super::encoding::same_byte_layout(self.encoding, new_encoding) {
+            return None;
+        }
+        Some(Box::new(Self {
+            path: self.path.clone(),
+            total_bytes: self.total_bytes,
+            file_name: self.file_name.clone(),
+            checkpoints: self.checkpoints.clone(),
+            total_lines: self.total_lines,
+            encoding: new_encoding,
+        }))
+    }
+
     fn get_lines(&self, target: &SeekTarget, count: usize) -> Result<LineChunk, ViewerError> {
         let target_line = self.resolve_target(target);
         let checkpoint = self.find_checkpoint(target_line);

apps/desktop/src-tauri/src/file_viewer/mod.rs

@@ -6,13 +6,13 @@
 //! - `ByteSeekBackend`: byte-offset seeking, no pre-scan needed (instant open)
 
 mod byte_seek;
-mod encoding;
+pub mod encoding;
 mod full_load;
 mod line_index;
 mod range_read;
 mod search_matcher;
-mod session;
-mod watcher;
+pub mod session;
+pub mod watcher;
 
 #[cfg(test)]
 mod byte_seek_test;
@@ -173,6 +173,16 @@ pub trait FileViewerBackend: Send + Sync {
         })
     }
 
+    /// Returns a fresh boxed backend whose internal state is identical to
+    /// `self` but with the encoding field swapped to `new_encoding`. Used by
+    /// the `set_encoding` instant-swap path when `same_byte_layout` holds: the
+    /// existing newline index is still valid under the new encoding, so only
+    /// the decoder needs to change. Default is `None`, meaning the session
+    /// must take the slow rebuild path.
+    fn with_encoding(&self, _new_encoding: FileEncoding) -> Option<Box<dyn FileViewerBackend>> {
+        None
+    }
+
     /// Search the file with the given `Matcher`, populating matches into the provided vec.
     /// Checks the cancel flag at chunk, line, and match granularity and stops early if set.
     /// Updates `progress` with the number of bytes scanned so far.