feat: Update SAL Vault examples and documentation

- Renamed examples directory to `_archive` to reflect legacy status.
- Updated README.md to reflect current status of vault module,
  including migration from Sameh's implementation to Lee's.
- Temporarily disabled Rhai scripting integration for the vault.
- Added notes regarding current and future development steps.

vault/_archive/tests/rhai_integration_tests.rs

@@ -0,0 +1,243 @@
+use rhai::{Engine, EvalAltResult};
+use sal_vault::rhai::*;
+use std::sync::Mutex;
+
+// NOTE: These tests use global state (SESSION and KEYSPACE_REGISTRY) and are automatically
+// serialized using a global mutex to prevent test interference during parallel execution.
+
+// Global test mutex to ensure tests run sequentially
+static TEST_MUTEX: Mutex<()> = Mutex::new(());
+
+#[cfg(test)]
+mod rhai_integration_tests {
+    use super::*;
+
+    fn create_test_engine() -> Engine {
+        let mut engine = Engine::new();
+        register_crypto_module(&mut engine).expect("Failed to register crypto module");
+        engine
+    }
+
+    #[test]
+    fn test_rhai_module_registration() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        // Test that the functions are registered by checking if they exist
+        let script = r#"
+            // Test that all crypto functions are available
+            let functions_exist = true;
+            
+            // We can't actually call these without proper setup, but we can verify they're registered
+            // by checking that the engine doesn't throw "function not found" errors
+            functions_exist
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_symmetric_encryption_functions() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        let script = r#"
+            // Test symmetric encryption functions
+            let key = generate_key();
+            let message = "Hello, World!";
+            
+            let encrypted = encrypt(key, message);
+            let decrypted = decrypt(key, encrypted);
+            
+            decrypted == message
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_keyspace_functions() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        let script = r#"
+            // Test keyspace functions
+            clear_session();
+            
+            let created = create_key_space("test_space", "password123");
+            if !created {
+                throw "Failed to create key space";
+            }
+            
+            let selected = select_keyspace("test_space");
+            if !selected {
+                throw "Failed to select keyspace";
+            }
+            
+            true
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_keypair_functions() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        let script = r#"
+            // Test keypair functions
+            clear_session();
+            
+            // Create and select keyspace
+            create_key_space("test_space", "password123");
+            select_keyspace("test_space");
+            
+            // Create keypair
+            let created = create_keypair("test_keypair");
+            if !created {
+                throw "Failed to create keypair";
+            }
+            
+            // Select keypair
+            let selected = select_keypair("test_keypair");
+            if !selected {
+                throw "Failed to select keypair";
+            }
+            
+            // Get public key
+            let pub_key = keypair_pub_key();
+            if pub_key == "" {
+                throw "Failed to get public key";
+            }
+            
+            true
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_signing_functions() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        let script = r#"
+            // Test signing and verification functions
+            clear_session();
+            
+            // Setup keyspace and keypair
+            create_key_space("test_space", "password123");
+            select_keyspace("test_space");
+            create_keypair("test_keypair");
+            select_keypair("test_keypair");
+            
+            // Test signing and verification
+            let message = "test message";
+            let signature = sign(message);
+            
+            if signature == "" {
+                throw "Failed to sign message";
+            }
+            
+            let is_valid = verify(message, signature);
+            if !is_valid {
+                throw "Signature verification failed";
+            }
+            
+            // Test with wrong message
+            let wrong_is_valid = verify("wrong message", signature);
+            if wrong_is_valid {
+                throw "Signature should not be valid for wrong message";
+            }
+            
+            true
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_session_management() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        let script = r#"
+            // Test session management
+            clear_session();
+            
+            // Create multiple keyspaces
+            create_key_space("space1", "password1");
+            create_key_space("space2", "password2");
+            
+            // Test listing keyspaces
+            let spaces = list_keyspaces();
+            let space_count = count_keyspaces();
+            if space_count < 2 {
+                throw "Should have at least 2 keyspaces";
+            }
+            
+            // Test selecting different keyspaces
+            select_keyspace("space1");
+            create_keypair("keypair1");
+            
+            select_keyspace("space2");
+            create_keypair("keypair2");
+            
+            // Test listing keypairs in current space
+            let keypairs = list_keypairs();
+            let keypair_count = count_keypairs();
+            if keypair_count != 1 {
+                throw "Should have exactly 1 keypair in space2";
+            }
+            
+            true
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        if let Err(ref e) = result {
+            println!("Script error: {}", e);
+        }
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_error_handling() {
+        let _guard = TEST_MUTEX.lock().unwrap();
+        let engine = create_test_engine();
+
+        let script = r#"
+            // Test error handling
+            clear_session();
+            
+            // Try to select non-existent keyspace
+            let selected = select_keyspace("non_existent");
+            if selected {
+                throw "Should not be able to select non-existent keyspace";
+            }
+            
+            // Try to create keypair without keyspace
+            let created = create_keypair("test_keypair");
+            if created {
+                throw "Should not be able to create keypair without keyspace";
+            }
+            
+            true
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+}