[GH-25] Fix persistent split/merged flags causing data corruption (#41)

* Fix persistent split/merged flags causing data corruption

The bool-typed fields `merged` and `split` in the ProllyNode struct were being
persisted through serialization and never reset to false, causing severe data
corruption during tree operations.

This commit fixes the issue by:
1. Making split/merged flags transient using #[serde(skip)]
2. Ensuring flags are always reset to false when nodes are retrieved from storage
3. Adding comprehensive tests to verify the fix and prevent regressions

The fix prevents catastrophic data corruption where:
- Split nodes would have their edges incorrectly hoisted to parent on every operation
- Merged nodes would have their siblings incorrectly dropped from parent

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

* Apply cargo fmt formatting

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

---------

Co-authored-by: Claude <[email protected]>

Author: zhangfengcdt

src/node.rs

@@ -143,7 +143,9 @@ pub struct ProllyNode<const N: usize> {
     pub min_chunk_size: usize,
     pub max_chunk_size: usize,
     pub pattern: u64,
+    #[serde(skip)]
     pub split: bool,
+    #[serde(skip)]
     pub merged: bool,
     pub encode_types: Vec<EncodingType>,
     pub encode_values: Vec<Vec<u8>>,
@@ -1540,4 +1542,57 @@ mod tests {
             assert!(node.find(&[i], &storage).is_some());
         }
     }
+
+    #[test]
+    fn test_flags_reset_after_operations() {
+        // Test that split/merged flags are reset after insert/delete operations
+        let mut storage = InMemoryNodeStorage::<32>::default();
+        let mut node: ProllyNode<32> = ProllyNode::builder()
+            .pattern(0b1)
+            .min_chunk_size(2)
+            .max_chunk_size(4)
+            .build();
+
+        // Insert enough items to trigger splits
+        for i in 0..6 {
+            node.insert(vec![i], vec![i], &mut storage, Vec::new());
+            storage.insert_node(node.get_hash(), node.clone());
+            // Flags should be reset after each operation
+            assert!(
+                !node.split,
+                "Split flag should be reset after insert operation {}",
+                i
+            );
+            assert!(
+                !node.merged,
+                "Merged flag should be reset after insert operation {}",
+                i
+            );
+        }
+
+        // Test deletion as well
+        assert!(node.delete(&[0], &mut storage, Vec::new()));
+        assert!(
+            !node.split,
+            "Split flag should be reset after delete operation"
+        );
+        assert!(
+            !node.merged,
+            "Merged flag should be reset after delete operation"
+        );
+    }
+
+    #[test]
+    fn test_flags_not_serialized() {
+        // Test that split/merged flags are not serialized
+        let mut node = ProllyNode::<32>::default();
+        node.split = true;
+        node.merged = true;
+        let bytes = bincode::serialize(&node).unwrap();
+        let de: ProllyNode<32> = bincode::deserialize(&bytes).unwrap();
+        assert!(
+            !de.split && !de.merged,
+            "Split/merged flags should not be serialized"
+        );
+    }
 }

src/storage.rs

@@ -89,7 +89,11 @@ impl<const N: usize> InMemoryNodeStorage<N> {
 
 impl<const N: usize> NodeStorage<N> for InMemoryNodeStorage<N> {
     fn get_node_by_hash(&self, hash: &ValueDigest<N>) -> Option<ProllyNode<N>> {
-        self.map.get(hash).cloned()
+        self.map.get(hash).cloned().map(|mut node| {
+            node.split = false;
+            node.merged = false;
+            node
+        })
     }
 
     fn insert_node(&mut self, hash: ValueDigest<N>, node: ProllyNode<N>) -> Option<()> {
@@ -156,7 +160,10 @@ impl<const N: usize> NodeStorage<N> for FileNodeStorage<N> {
             let mut file = File::open(path).unwrap();
             let mut data = Vec::new();
             file.read_to_end(&mut data).unwrap();
-            Some(bincode::deserialize(&data).unwrap())
+            let mut node: ProllyNode<N> = bincode::deserialize(&data).unwrap();
+            node.split = false;
+            node.merged = false;
+            Some(node)
         } else {
             None
         }