v2.3.0: Flashspan- Backend Robustness & Frontend Cleanup

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "flashspan",
 	"private": true,
-	"version": "2.1.0",
+	"version": "2.3.0",
 	"type": "module",
 	"scripts": {
 		"dev": "vite",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "Flashspan"
-version = "2.2.1"
+version = "2.3.0"
 description = "Mental Maths training simulator"
 authors = ["you"]
 license = ""

src-tauri/src/audio.rs

@@ -1,7 +1,7 @@
 use log::{error, info, warn};
-use std::sync::OnceLock;
 use rodio::{Decoder, DeviceSinkBuilder, Player};
 use std::io::Cursor;
+use std::sync::OnceLock;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{Sender, channel};
 

src-tauri/src/core/engine.rs

@@ -1,7 +1,7 @@
 use crate::core::generate::random_number_with_constraints;
 use crate::core::types::{SessionConfig, SessionConfigEffective, SessionPlan, SessionStep};
-use rand::rngs::StdRng;
 use rand::SeedableRng;
+use rand::rngs::StdRng;
 
 /// Build a deterministic session plan from configuration and an optional seed.
 ///

src-tauri/src/core/generate.rs

@@ -6,6 +6,7 @@ pub(crate) fn random_fixed_digits_no_leading_zero(rng: &mut impl Rng, digits: u3
         return rng.random_range(1u32..=9u32).to_string();
     }
 
+    debug_assert!(digits <= 18, "digits {} exceeds u64 range", digits);
     let min = 10u64.pow(digits - 1);
     let max_exclusive = 10u64.pow(digits);
     rng.random_range(min..max_exclusive).to_string()

src-tauri/src/main.rs

@@ -12,7 +12,8 @@ mod native_app {
         types::{AutoRepeatPlan, SessionConfigEffective, SessionConfigInput},
         validate::normalize_session_config,
     };
-    use crate::session::SessionManager;
+    use crate::session::{recover_lock, SessionManager};
+    use log::warn;
     use serde::Deserialize;
     use std::sync::{Arc, Mutex};
     use std::thread;
@@ -108,7 +109,7 @@ mod native_app {
 
     #[tauri::command]
     fn get_app_settings(settings: tauri::State<'_, SettingsState>) -> AppSettings {
-        settings.0.lock().expect("settings lock poisoned").clone()
+        recover_lock(&settings.0, "settings").clone()
     }
 
     #[tauri::command]
@@ -128,7 +129,7 @@ mod native_app {
         color_scheme: ColorScheme,
     ) -> Result<AppSettings, String> {
         let updated = {
-            let mut guard = settings.0.lock().expect("settings lock poisoned");
+            let mut guard = recover_lock(&settings.0, "settings");
             guard.color_scheme = color_scheme;
             guard.clone()
         };
@@ -143,7 +144,7 @@ mod native_app {
         theme_mode: ThemeMode,
     ) -> Result<AppSettings, String> {
         let updated = {
-            let mut guard = settings.0.lock().expect("settings lock poisoned");
+            let mut guard = recover_lock(&settings.0, "settings");
             guard.theme_mode = theme_mode;
             guard.clone()
         };
@@ -233,54 +234,65 @@ mod native_app {
         let manager_arc = Arc::clone(&manager);
         let app_for_thread = app.clone();
         let remaining_repeats = remaining;
-        thread::spawn(move || {
-            let end_at = Instant::now() + std::time::Duration::from_millis(delay_ms);
-            let mut last_sent: Option<u64> = None;
+        if let Err(e) = std::thread::Builder::new()
+            .name("auto-repeat".into())
+            .spawn(move || {
+                let end_at = Instant::now() + std::time::Duration::from_millis(delay_ms);
+                let mut last_sent: Option<u64> = None;
+
+                loop {
+                    if manager_arc.auto_repeat_generation() != generation {
+                        return;
+                    }
+
+                    let now = Instant::now();
+                    if now >= end_at {
+                        break;
+                    }
+
+                    let remaining_duration = end_at.saturating_duration_since(now);
+                    let seconds_left = (remaining_duration.as_millis() as u64).div_ceil(1000);
+
+                    if last_sent != Some(seconds_left) {
+                        last_sent = Some(seconds_left);
+                        let _ = app_for_thread.emit(
+                            "auto_repeat_tick",
+                            AutoRepeatTickPayload {
+                                session_id,
+                                seconds_left,
+                                remaining: remaining_repeats,
+                            },
+                        );
+                    }
+
+                    let step = remaining_duration.min(std::time::Duration::from_millis(120));
+                    thread::sleep(step);
+                }
 
-            loop {
                 if manager_arc.auto_repeat_generation() != generation {
                     return;
                 }
 
-                let now = Instant::now();
-                if now >= end_at {
-                    break;
-                }
+                let _ = app_for_thread.emit(
+                    "auto_repeat_tick",
+                    AutoRepeatTickPayload {
+                        session_id,
+                        seconds_left: 0,
+                        remaining: remaining_repeats,
+                    },
+                );
 
-                let remaining_duration = end_at.saturating_duration_since(now);
-                let seconds_left = (remaining_duration.as_millis() as u64).div_ceil(1000);
-
-                if last_sent != Some(seconds_left) {
-                    last_sent = Some(seconds_left);
-                    let _ = app_for_thread.emit(
-                        "auto_repeat_tick",
-                        AutoRepeatTickPayload {
-                            session_id,
-                            seconds_left,
-                            remaining: remaining_repeats,
-                        },
-                    );
+                // TOCTOU guard: re-check generation right before start()
+                if manager_arc.auto_repeat_generation() != generation {
+                    return;
                 }
-
-                let step = remaining_duration.min(std::time::Duration::from_millis(120));
-                thread::sleep(step);
-            }
-
-            if manager_arc.auto_repeat_generation() != generation {
-                return;
-            }
-
-            let _ = app_for_thread.emit(
-                "auto_repeat_tick",
-                AutoRepeatTickPayload {
-                    session_id,
-                    seconds_left: 0,
-                    remaining: remaining_repeats,
-                },
-            );
-
-            let _ = manager_arc.start(app_for_thread, config);
-        });
+                if let Err(e) = manager_arc.start(app_for_thread, config) {
+                    warn!("auto-repeat start failed: {}", e);
+                }
+            })
+        {
+            warn!("auto-repeat thread spawn failed: {}", e);
+        }
 
         Ok(Some(payload))
     }