@feltdb/core 0.8.4 → 0.8.5

package/dist/create/server-source/crates/feltdb/tests/state_model_integration.rs

@@ -14,8 +14,8 @@
 #[cfg(test)]
 mod integration_smoke_test {
     use feltdb::{
-        StateRevision, StateStore, StateTopology, Relationship, SemanticDiff,
-        ConflictClassification, ConflictClass, ReconciliationPlan,
+        ConflictClass, ConflictClassification, ReconciliationPlan, Relationship, SemanticDiff,
+        StateRevision, StateStore, StateTopology,
     };
     use serde_json::json;
 
@@ -25,13 +25,14 @@ mod integration_smoke_test {
         let store = StateStore::new_volatile();
         let initial_state = store
             .create(
+                "docs:1",
                 r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#.to_string(),
                 "initial-authority".to_string(),
             )
             .expect("Failed to create initial state");
 
         assert!(store.exists(&initial_state.id));
-        assert_eq!(store.current().unwrap().id, initial_state.id);
+        assert_eq!(store.get(&initial_state.id).unwrap().id, initial_state.id);
 
         println!("✓ Step 1: Created initial state ({})", initial_state.id);
 
@@ -44,13 +45,10 @@ mod integration_smoke_test {
             )
             .expect("Failed to create alice branch");
 
-        store
-            .create_branch("alice-branch".to_string(), alice_branch.id.clone())
-            .expect("Failed to create alice-branch");
-
         println!(
             "✓ Step 2: Created alice branch ({}), parent: {}",
-            alice_branch.id, alice_branch.parent().unwrap()
+            alice_branch.id,
+            alice_branch.parent().unwrap()
         );
 
         // Step 3: Create second branch from initial state (Bob's branch - modifies bob balance)
@@ -62,13 +60,10 @@ mod integration_smoke_test {
             )
             .expect("Failed to create bob branch");
 
-        store
-            .create_branch("bob-branch".to_string(), bob_branch.id.clone())
-            .expect("Failed to create bob-branch");
-
         println!(
             "✓ Step 3: Created bob branch ({}), parent: {}",
-            bob_branch.id, bob_branch.parent().unwrap()
+            bob_branch.id,
+            bob_branch.parent().unwrap()
         );
 
         // Step 4: Inspect topology
@@ -96,18 +91,15 @@ mod integration_smoke_test {
         );
 
         // Step 5: Compute semantic diffs
-        let initial_json = serde_json::from_str(
-            r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#,
-        )
-        .unwrap();
-        let alice_json = serde_json::from_str(
-            r#"{"users":{"alice":{"balance":150},"bob":{"balance":50}}}"#,
-        )
-        .unwrap();
-        let bob_json = serde_json::from_str(
-            r#"{"users":{"alice":{"balance":100},"bob":{"balance":150}}}"#,
-        )
-        .unwrap();
+        let initial_json =
+            serde_json::from_str(r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#)
+                .unwrap();
+        let alice_json =
+            serde_json::from_str(r#"{"users":{"alice":{"balance":150},"bob":{"balance":50}}}"#)
+                .unwrap();
+        let bob_json =
+            serde_json::from_str(r#"{"users":{"alice":{"balance":100},"bob":{"balance":150}}}"#)
+                .unwrap();
 
         let alice_diff = SemanticDiff::compute(&initial_json, &alice_json);
         let bob_diff = SemanticDiff::compute(&initial_json, &bob_json);
@@ -120,18 +112,15 @@ mod integration_smoke_test {
         println!("  - Bob's change: {:?}", bob_diff.changes[0]);
 
         // Step 6: Classify conflicts
-        let conflict_class = ConflictClassification::classify(
-            &initial_state,
-            &alice_branch,
-            &bob_branch,
-        );
+        let conflict_class =
+            ConflictClassification::classify(&initial_state, &alice_branch, &bob_branch);
 
         // These changes are independent (different paths)
         assert_eq!(conflict_class.overall, ConflictClass::Independent);
-        assert!(
-            conflict_class.path_conflicts.iter()
-                .all(|c| c.classification == ConflictClass::Independent)
-        );
+        assert!(conflict_class
+            .path_conflicts
+            .iter()
+            .all(|c| c.classification == ConflictClass::Independent));
 
         println!("✓ Step 6: Classified conflicts as INDEPENDENT");
 
@@ -172,7 +161,10 @@ mod integration_smoke_test {
             )
             .expect("Failed to commit reconciled state");
 
-        println!("✓ Step 8: Materialized reconciled state ({})", final_state.id);
+        println!(
+            "✓ Step 8: Materialized reconciled state ({})",
+            final_state.id
+        );
 
         // Step 9: Verify state properties
         let retrieved = store
@@ -207,6 +199,7 @@ mod integration_smoke_test {
         let store = StateStore::new_volatile();
         let initial = store
             .create(
+                "docs:1",
                 r#"{"status":"initial"}"#.to_string(),
                 "auth".to_string(),
             )
@@ -232,6 +225,7 @@ mod integration_smoke_test {
         let store = StateStore::new_volatile();
         let initial = store
             .create(
+                "docs:1",
                 r#"{"value":"initial"}"#.to_string(),
                 "auth".to_string(),
             )
@@ -262,12 +256,12 @@ mod integration_smoke_test {
         // Test that unrelated branches are detected as such
         let store1 = StateStore::new_volatile();
         let state1 = store1
-            .create(r#"{"id":1}"#.to_string(), "auth1".to_string())
+            .create("docs:1", r#"{"id":1}"#.to_string(), "auth1".to_string())
             .unwrap();
 
         let store2 = StateStore::new_volatile();
         let state2 = store2
-            .create(r#"{"id":2}"#.to_string(), "auth2".to_string())
+            .create("docs:1", r#"{"id":2}"#.to_string(), "auth2".to_string())
             .unwrap();
 
         let mut topology = StateTopology::new();
@@ -294,36 +288,34 @@ mod integration_smoke_test {
         let diff2 = SemanticDiff::compute(&old, &new_string);
 
         assert_eq!(diff1.changes.len(), 0, "No change for same representation");
-        assert_eq!(diff2.changes.len(), 1, "Change detected for different representation");
+        assert_eq!(
+            diff2.changes.len(),
+            1,
+            "Change detected for different representation"
+        );
 
         println!("✓ Representation sensitivity verified in diffs");
     }
 
     #[test]
-    fn test_branching_does_not_advance_current() {
-        // Verify that creating a branch doesn't automatically advance current pointer
+    fn test_committing_a_child_does_not_disturb_its_parent() {
+        // The store keeps no pointer that a commit could advance, so a parent
+        // is exactly as retrievable after its child exists as before.
         let store = StateStore::new_volatile();
         let state1 = store
-            .create(r#"{"v":1}"#.to_string(), "auth".to_string())
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
             .unwrap();
+        assert_eq!(store.get(&state1.id).unwrap().content, r#"{"v":1}"#);
 
-        let current_after_create = store.current().unwrap();
-        assert_eq!(current_after_create.id, state1.id);
-
-        // Branch from state1
         let state2 = store
             .commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string())
             .unwrap();
 
-        store
-            .create_branch("test-branch".to_string(), state2.id.clone())
-            .unwrap();
-
-        // Current should still be state2 (because we committed it)
-        let current_after_branch = store.current().unwrap();
-        assert_eq!(current_after_branch.id, state2.id);
+        assert_eq!(store.get(&state1.id).unwrap().content, r#"{"v":1}"#);
+        assert_eq!(store.get(&state2.id).unwrap().content, r#"{"v":2}"#);
+        assert_eq!(store.parent(&state2.id).unwrap().id, state1.id);
 
-        println!("✓ Branch creation verified (doesn't implicitly advance current)");
+        println!("✓ A commit adds a revision and displaces nothing");
     }
 
     #[test]
@@ -331,11 +323,15 @@ mod integration_smoke_test {
         // Verify that reconciliation requires explicit plan
         let store = StateStore::new_volatile();
         let initial = store
-            .create(r#"{"a":1,"b":2}"#.to_string(), "auth".to_string())
+            .create("docs:1", r#"{"a":1,"b":2}"#.to_string(), "auth".to_string())
             .unwrap();
 
         let left = store
-            .commit(r#"{"a":10,"b":2}"#.to_string(), &initial, "auth".to_string())
+            .commit(
+                r#"{"a":10,"b":2}"#.to_string(),
+                &initial,
+                "auth".to_string(),
+            )
             .unwrap();
 
         let right = StateRevision::child(
@@ -348,12 +344,8 @@ mod integration_smoke_test {
         let classification = ConflictClassification::classify(&initial, &left, &right);
 
         // Caller must supply explicit plan
-        let plan = ReconciliationPlan::new(
-            left.id.clone(),
-            right.id.clone(),
-            initial.id.clone(),
-            true,
-        );
+        let plan =
+            ReconciliationPlan::new(left.id.clone(), right.id.clone(), initial.id.clone(), true);
 
         assert!(plan.validate());
         assert!(

package/dist/create/server-source/crates/feltdb/tests/state_persistence_integration.rs

@@ -22,8 +22,12 @@ mod state_persistence_tests {
         // Create initial state with FeltDB persistence
         let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1.create(r#"{"v":1}"#.to_string(), "auth".to_string()).expect("create");
-        let rev2 = store1.commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string()).expect("commit");
+        let rev1 = store1
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .expect("create");
+        let rev2 = store1
+            .commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string())
+            .expect("commit");
 
         let id1 = rev1.id.clone();
         let id2 = rev2.id.clone();
@@ -32,7 +36,10 @@ mod state_persistence_tests {
         // Verify both revisions exist
         assert!(store1.exists(&id1), "rev1 should exist");
         assert!(store1.exists(&id2), "rev2 should exist");
-        assert_eq!(store1.current().map(|r| r.id.as_hex().to_string()), Some(id2_hex.clone()));
+        assert_eq!(
+            store1.get(&id2).map(|r| r.id.as_hex().to_string()),
+            Some(id2_hex.clone())
+        );
 
         // Drop store and database (simulate restart)
         drop(store1);
@@ -44,7 +51,11 @@ mod state_persistence_tests {
         // Verify all revisions still exist
         assert!(store2.exists(&id1), "rev1 should survive restart");
         assert!(store2.exists(&id2), "rev2 should survive restart");
-        assert_eq!(store2.current().map(|r| r.id.as_hex().to_string()), Some(id2_hex), "current should be restored");
+        assert_eq!(
+            store2.get(&id2).map(|r| r.id.as_hex().to_string()),
+            Some(id2_hex),
+            "the revision is retrievable by identity after restart"
+        );
 
         // Verify content is correct
         let recovered_rev2 = store2.get(&id2).expect("get rev2");
@@ -59,7 +70,13 @@ mod state_persistence_tests {
 
         let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1.create(r#"{"fixed":"content"}"#.to_string(), "auth".to_string()).expect("create");
+        let rev1 = store1
+            .create(
+                "docs:1",
+                r#"{"fixed":"content"}"#.to_string(),
+                "auth".to_string(),
+            )
+            .expect("create");
         let id1 = rev1.id.clone();
         drop(store1);
 
@@ -67,9 +84,13 @@ mod state_persistence_tests {
         let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
         let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
         let recovered = store2.get(&id1).expect("get");
-        
+
         // Content hash must be the same for identical content
-        assert_eq!(recovered.id.as_hex(), id1.as_hex(), "StateId should be deterministic");
+        assert_eq!(
+            recovered.id.as_hex(),
+            id1.as_hex(),
+            "StateId should be deterministic"
+        );
     }
 
     #[test]
@@ -80,22 +101,28 @@ mod state_persistence_tests {
         // Create store and initial state
         let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1.create(r#"{"v":1}"#.to_string(), "auth".to_string()).expect("create");
-        
+        let rev1 = store1
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .expect("create");
+
         let id1 = rev1.id.clone();
         let id1_hex = id1.as_hex().to_string();
-        
-        // Create a branch
-        store1.create_branch("main".to_string(), id1.clone()).expect("branch");
-        
-        // Verify branch exists
-        assert_eq!(store1.branch_head("main").map(|id| id.as_hex().to_string()), Some(id1_hex.clone()));
+
+        // There are no named branches. A revision is addressed by its own
+        // content-derived identity, which is what a name would have pointed at.
+        assert_eq!(
+            store1.get(&id1).map(|id| id.id.as_hex().to_string()),
+            Some(id1_hex.clone())
+        );
         drop(store1);
 
-        // Recover and check branch
         let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
-        assert_eq!(store2.branch_head("main").map(|id| id.as_hex().to_string()), Some(id1_hex), "branch should survive restart");
+        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("reopen");
+        assert_eq!(
+            store2.get(&id1).map(|id| id.id.as_hex().to_string()),
+            Some(id1_hex),
+            "the revision survives restart under its own identity"
+        );
     }
 
     #[test]
@@ -105,14 +132,22 @@ mod state_persistence_tests {
 
         // Create volatile store
         let store1 = StateStore::new_volatile();
-        let rev1 = store1.create(r#"{"v":1}"#.to_string(), "auth".to_string()).expect("create");
+        let rev1 = store1
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .expect("create");
         drop(store1);
 
         // Try to recover from disk (should be empty)
         let db2 = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("create store");
-        assert!(!store2.exists(&rev1.id), "volatile store should not persist");
-        assert!(store2.current().is_none(), "should have no current state");
+        assert!(
+            !store2.exists(&rev1.id),
+            "volatile store should not persist"
+        );
+        assert!(
+            store2.get(&rev1.id).is_none(),
+            "nothing from the volatile store reached disk"
+        );
     }
 
     #[test]
@@ -123,10 +158,16 @@ mod state_persistence_tests {
         // Create chain of revisions
         let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1.create(r#"{"v":1}"#.to_string(), "auth".to_string()).expect("create");
-        let rev2 = store1.commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string()).expect("commit");
-        let rev3 = store1.commit(r#"{"v":3}"#.to_string(), &rev2, "auth".to_string()).expect("commit");
-        
+        let rev1 = store1
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .expect("create");
+        let rev2 = store1
+            .commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string())
+            .expect("commit");
+        let rev3 = store1
+            .commit(r#"{"v":3}"#.to_string(), &rev2, "auth".to_string())
+            .expect("commit");
+
         let id1 = rev1.id.clone();
         let id2 = rev2.id.clone();
         let id3 = rev3.id.clone();
@@ -135,15 +176,26 @@ mod state_persistence_tests {
         // Recover and verify parent pointers
         let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
         let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
-        
+
         let recovered_rev3 = store2.get(&id3).expect("get rev3");
-        assert_eq!(recovered_rev3.parent_id.as_ref().map(|id| id.as_hex()), Some(id2.as_hex()), "rev3 parent should be rev2");
-        
+        assert_eq!(
+            recovered_rev3.parent_id.as_ref().map(|id| id.as_hex()),
+            Some(id2.as_hex()),
+            "rev3 parent should be rev2"
+        );
+
         let recovered_rev2 = store2.get(&id2).expect("get rev2");
-        assert_eq!(recovered_rev2.parent_id.as_ref().map(|id| id.as_hex()), Some(id1.as_hex()), "rev2 parent should be rev1");
-        
+        assert_eq!(
+            recovered_rev2.parent_id.as_ref().map(|id| id.as_hex()),
+            Some(id1.as_hex()),
+            "rev2 parent should be rev1"
+        );
+
         let recovered_rev1 = store2.get(&id1).expect("get rev1");
-        assert!(recovered_rev1.parent_id.is_none(), "rev1 should have no parent");
+        assert!(
+            recovered_rev1.parent_id.is_none(),
+            "rev1 should have no parent"
+        );
     }
 
     #[test]
@@ -153,20 +205,30 @@ mod state_persistence_tests {
 
         let db = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-        
+
         // Commit sequence
-        let rev1 = store.create(r#"{"step":1}"#.to_string(), "app".to_string()).expect("1");
-        let rev2 = store.commit(r#"{"step":2}"#.to_string(), &rev1, "app".to_string()).expect("2");
-        let rev3 = store.commit(r#"{"step":3}"#.to_string(), &rev2, "app".to_string()).expect("3");
-        let rev4 = store.commit(r#"{"step":4}"#.to_string(), &rev3, "app".to_string()).expect("4");
-        let rev5 = store.commit(r#"{"step":5}"#.to_string(), &rev4, "app".to_string()).expect("5");
-        
+        let rev1 = store
+            .create("docs:1", r#"{"step":1}"#.to_string(), "app".to_string())
+            .expect("1");
+        let rev2 = store
+            .commit(r#"{"step":2}"#.to_string(), &rev1, "app".to_string())
+            .expect("2");
+        let rev3 = store
+            .commit(r#"{"step":3}"#.to_string(), &rev2, "app".to_string())
+            .expect("3");
+        let rev4 = store
+            .commit(r#"{"step":4}"#.to_string(), &rev3, "app".to_string())
+            .expect("4");
+        let rev5 = store
+            .commit(r#"{"step":5}"#.to_string(), &rev4, "app".to_string())
+            .expect("5");
+
         let id1 = rev1.id.clone();
         let id2 = rev2.id.clone();
         let id3 = rev3.id.clone();
         let id4 = rev4.id.clone();
         let id5 = rev5.id.clone();
-        
+
         // All should exist
         assert!(store.exists(&id1));
         assert!(store.exists(&id2));
@@ -174,7 +236,10 @@ mod state_persistence_tests {
         assert!(store.exists(&id4));
         assert!(store.exists(&id5));
         let id5_hex = id5.as_hex().to_string();
-        assert_eq!(store.current().map(|r| r.id.as_hex().to_string()), Some(id5_hex));
+        assert_eq!(
+            store.get(&id5).map(|r| r.id.as_hex().to_string()),
+            Some(id5_hex)
+        );
     }
 
     #[test]
@@ -185,10 +250,13 @@ mod state_persistence_tests {
         // Create and persist
         let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1.create(
-            r#"{"complex":{"nested":{"data":[1,2,3],"unicode":"αβγ"}}}"#.to_string(),
-            "auth".to_string()
-        ).expect("create");
+        let rev1 = store1
+            .create(
+                "docs:1",
+                r#"{"complex":{"nested":{"data":[1,2,3],"unicode":"αβγ"}}}"#.to_string(),
+                "auth".to_string(),
+            )
+            .expect("create");
         let id1 = rev1.id.clone();
         drop(store1);
 
@@ -196,7 +264,10 @@ mod state_persistence_tests {
         let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
         let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
         let recovered = store2.get(&id1).expect("get");
-        assert_eq!(recovered.content, r#"{"complex":{"nested":{"data":[1,2,3],"unicode":"αβγ"}}}"#);
+        assert_eq!(
+            recovered.content,
+            r#"{"complex":{"nested":{"data":[1,2,3],"unicode":"αβγ"}}}"#
+        );
     }
 
     #[test]
@@ -206,7 +277,9 @@ mod state_persistence_tests {
 
         let db = feltdb::FeltDb::open(&temp_path).expect("open db");
         let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-        let rev1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).expect("create");
+        let rev1 = store
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .expect("create");
         let id1 = rev1.id.clone();
 
         // Clone the store for concurrent access
@@ -216,11 +289,19 @@ mod state_persistence_tests {
         let id1_hex = id1.as_hex().to_string();
 
         // Both can read
-        assert_eq!(store_clone1.current().map(|r| r.id.as_hex().to_string()), Some(id1_hex.clone()));
-        assert_eq!(store_clone2.current().map(|r| r.id.as_hex().to_string()), Some(id1_hex));
+        assert_eq!(
+            store_clone1.get(&id1).map(|r| r.id.as_hex().to_string()),
+            Some(id1_hex.clone())
+        );
+        assert_eq!(
+            store_clone2.get(&id1).map(|r| r.id.as_hex().to_string()),
+            Some(id1_hex)
+        );
 
         // Commit from one
-        let rev2 = store_clone1.commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string()).expect("commit");
+        let rev2 = store_clone1
+            .commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string())
+            .expect("commit");
         let id2 = rev2.id.clone();
 
         // Both should see the new revision
@@ -233,38 +314,52 @@ mod state_persistence_tests {
         let temp_dir = TempDir::new().unwrap();
         let temp_path = temp_dir.path().join("test.log");
 
+        // The caller carries the ids it cares about across restarts.
+        let rev2_id;
+        let rev3_id;
+
         // Cycle 1: create initial state
         {
             let db = feltdb::FeltDb::open(&temp_path).expect("open db");
             let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-            let rev1 = store.create(r#"{"cycle":1}"#.to_string(), "auth".to_string()).expect("create1");
-            let _rev2 = store.commit(r#"{"cycle":1.5}"#.to_string(), &rev1, "auth".to_string()).expect("commit1");
+            let rev1 = store
+                .create("docs:1", r#"{"cycle":1}"#.to_string(), "auth".to_string())
+                .expect("create1");
+            rev2_id = store
+                .commit(r#"{"cycle":1.5}"#.to_string(), &rev1, "auth".to_string())
+                .expect("commit1")
+                .id;
         }
 
-        // Cycle 2: recover and add more
+        // Cycle 2: reopen and add more, starting from the id we carried
         {
             let db = feltdb::FeltDb::open(&temp_path).expect("open db");
             let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-            let rev2 = store.current().expect("current");
-            let _rev3 = store.commit(r#"{"cycle":2}"#.to_string(), &rev2, "auth".to_string()).expect("commit2");
+            let rev2 = store.get(&rev2_id).expect("rev2 survives");
+            rev3_id = store
+                .commit(r#"{"cycle":2}"#.to_string(), &rev2, "auth".to_string())
+                .expect("commit2")
+                .id;
         }
 
         // Cycle 3: verify all history
         {
             let db = feltdb::FeltDb::open(&temp_path).expect("open db");
             let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-            assert!(store.current().is_some(), "should have current state after 3 cycles");
-            
+
             // Walk the chain backwards - count how many nodes we can reach
-            let mut rev = store.current().expect("current");
-            let mut count = 1;  // Start with 1 for the current node
+            let mut rev = store.get(&rev3_id).expect("rev3 survives every cycle");
+            let mut count = 1; // Start with 1 for the current node
             while let Some(parent_id) = &rev.parent_id {
                 rev = store.get(parent_id).expect("get parent");
                 count += 1;
             }
-            
-            assert!(count >= 3, "should have chain of at least 3 revisions, got {}", count);
+
+            assert!(
+                count >= 3,
+                "should have chain of at least 3 revisions, got {}",
+                count
+            );
         }
     }
 }
-