Optimize Store persistence by eliminating deep clone of internal lock, and optimize relation merging by using retain deduplication.

server/src/handlers.rs

@@ -1053,11 +1053,10 @@ impl MemoryHandler {
                             adrs.push(a);
                         });
                         
-                        if let Some(adr) = new_adr {
+                        if let Some(adr) = new_adr
-                            if let Ok(idx) = self.state.search_index.read() {
+                            && let Ok(idx) = self.state.search_index.read() {
                                 drop(idx.index_adr(&adr));
                             }
-                        }
                         
                         Ok(format!("Decision logged as {}", adr_id).to_string())
                     }
@@ -1081,8 +1080,7 @@ impl MemoryHandler {
                             if let Some(src) = master.entities.remove(&req.source_entity) {
                                 if let Some(tgt) = master.entities.get_mut(&req.target_entity) {
                                     tgt.observations.extend(src.observations);
-                                    tgt.observations =
+                                    MemoryState::deduplicate(&mut tgt.observations);
-                                        MemoryState::unique_items(tgt.observations.clone());
                                 } else {
                                     let mut new_tgt = src.clone();
                                     new_tgt.name = req.target_entity.clone();
@@ -1097,7 +1095,7 @@ impl MemoryHandler {
                                     r.to = req.target_entity.clone();
                                 }
                             }
-                            master.relations = MemoryState::unique_items(master.relations.clone());
+                            MemoryState::deduplicate(&mut master.relations);
                         });
                         Ok("Entities merged".to_string())
                     }

server/src/state.rs

@@ -31,12 +31,9 @@ pub struct MemoryState {
 }
 
 impl MemoryState {
-    pub fn unique_items<T: Eq + std::hash::Hash + Clone>(input: Vec<T>) -> Vec<T> {
+    pub fn deduplicate<T: Eq + std::hash::Hash + Clone>(input: &mut Vec<T>) {
         let mut keys = std::collections::HashSet::new();
-        input
+        input.retain(|entry| keys.insert(entry.clone()));
-            .into_iter()
-            .filter(|entry| keys.insert(entry.clone()))
-            .collect()
     }
 
     pub fn broadcast_activity(&self, message: &str) {

server/src/store.rs

@@ -30,29 +30,27 @@ impl<T: DeserializeOwned + Default + Serialize + Clone + Send + 'static> Store<T
         T::default()
     }
 
-    fn save_to_db(key: &str, db: &Database, data: &T) {
-        let write_txn = db.begin_write().unwrap();
-        {
-            let mut table = write_txn.open_table(STORE_TABLE).unwrap();
-            let json_data = serde_json::to_vec(data).unwrap();
-            table.insert(key, json_data.as_slice()).unwrap();
-        }
-        write_txn.commit().unwrap();
-    }
-
     pub fn read(&self) -> T {
         let lock = self.cache.read().unwrap();
         lock.clone()
     }
 
     pub fn modify<F: FnOnce(&mut T)>(&self, f: F) {
-        let mut lock = self.cache.write().unwrap();
+        let (key, db, json_data) = {
-        f(&mut lock);
+            let mut lock = self.cache.write().unwrap();
-        let key = self.key.clone();
+            f(&mut lock);
-        let db = self.db.clone();
+            // Serialize while holding lock to avoid expensive deep clone of T
-        let data = lock.clone();
+            let json = serde_json::to_vec(&*lock).unwrap();
+            (self.key.clone(), self.db.clone(), json)
+        };
+        
         tokio::task::spawn_blocking(move || {
-            Self::save_to_db(&key, &db, &data);
+            let write_txn = db.begin_write().unwrap();
+            {
+                let mut table = write_txn.open_table(STORE_TABLE).unwrap();
+                table.insert(key.as_str(), json_data.as_slice()).unwrap();
+            }
+            write_txn.commit().unwrap();
         });
     }
 }