@feltdb/core 0.7.1 → 0.7.3

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

@@ -0,0 +1,366 @@
+//! Integration Smoke Test: End-to-End State Model Functionality
+//!
+//! This test demonstrates complete state model usage without Git dependencies:
+//! 1. Create initial state
+//! 2. Branch state
+//! 3. Make changes on each branch
+//! 4. Inspect topology
+//! 5. Compute semantic diffs
+//! 6. Classify conflicts
+//! 7. Supply reconciliation result
+//! 8. Materialize reconciled state
+//! 9. Verify restart recovery
+
+#[cfg(test)]
+mod integration_smoke_test {
+    use feltdb::{
+        StateRevision, StateStore, StateTopology, Relationship, SemanticDiff,
+        ConflictClassification, ConflictClass, ReconciliationPlan,
+    };
+    use serde_json::json;
+
+    #[test]
+    fn end_to_end_state_model_smoke_test() {
+        // Step 1: Create initial application state
+        let store = StateStore::new_volatile();
+        let initial_state = store
+            .create(
+                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);
+
+        println!("✓ Step 1: Created initial state ({})", initial_state.id);
+
+        // Step 2: Create first branch (Alice's branch - modifies alice balance)
+        let alice_branch = store
+            .commit(
+                r#"{"users":{"alice":{"balance":150},"bob":{"balance":50}}}"#.to_string(),
+                &initial_state,
+                "alice-authority".to_string(),
+            )
+            .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()
+        );
+
+        // Step 3: Create second branch from initial state (Bob's branch - modifies bob balance)
+        let bob_branch = store
+            .commit(
+                r#"{"users":{"alice":{"balance":100},"bob":{"balance":150}}}"#.to_string(),
+                &initial_state,
+                "bob-authority".to_string(),
+            )
+            .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()
+        );
+
+        // Step 4: Inspect topology
+        let mut topology = StateTopology::new();
+        topology.add_revision(initial_state.clone());
+        topology.add_revision(alice_branch.clone());
+        topology.add_revision(bob_branch.clone());
+
+        // Verify ancestry relationships
+        assert!(topology.is_ancestor(&initial_state.id, &alice_branch.id));
+        assert!(topology.is_ancestor(&initial_state.id, &bob_branch.id));
+        assert!(!topology.is_ancestor(&alice_branch.id, &bob_branch.id));
+        assert!(!topology.is_ancestor(&bob_branch.id, &alice_branch.id));
+
+        let common = topology.common_ancestor(&alice_branch.id, &bob_branch.id);
+        assert_eq!(common, Some(initial_state.id.clone()));
+
+        let relationship = topology.relationship(&alice_branch.id, &bob_branch.id);
+        assert_eq!(relationship, Relationship::Diverged);
+
+        println!("✓ Step 4: Verified topology");
+        println!(
+            "  - Alice and Bob branches diverged from {}",
+            initial_state.id
+        );
+
+        // 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 alice_diff = SemanticDiff::compute(&initial_json, &alice_json);
+        let bob_diff = SemanticDiff::compute(&initial_json, &bob_json);
+
+        assert_eq!(alice_diff.changes.len(), 1);
+        assert_eq!(bob_diff.changes.len(), 1);
+
+        println!("✓ Step 5: Computed semantic diffs");
+        println!("  - Alice's change: {:?}", alice_diff.changes[0]);
+        println!("  - Bob's change: {:?}", bob_diff.changes[0]);
+
+        // Step 6: Classify conflicts
+        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)
+        );
+
+        println!("✓ Step 6: Classified conflicts as INDEPENDENT");
+
+        // Step 7: Create reconciliation plan with explicit parent choice
+        let plan = ReconciliationPlan::new(
+            alice_branch.id.clone(),
+            bob_branch.id.clone(),
+            initial_state.id.clone(),
+            true, // Choose alice's state as parent
+        );
+
+        assert!(plan.validate());
+
+        println!("✓ Step 7: Created reconciliation plan (parent_choice=alice)");
+
+        // Step 8: Materialize reconciled state
+        // For this test, merge by combining both changes
+        let merged_json = json!({
+            "users": {
+                "alice": {"balance": 150},
+                "bob": {"balance": 150}
+            }
+        });
+        let merged_content = merged_json.to_string();
+
+        let reconciled = StateRevision::child(
+            merged_content,
+            &alice_branch,
+            "reconciliation-authority".to_string(),
+        );
+
+        // Store the reconciled state
+        let final_state = store
+            .commit(
+                reconciled.content.clone(),
+                &alice_branch,
+                "reconciliation-authority".to_string(),
+            )
+            .expect("Failed to commit reconciled state");
+
+        println!("✓ Step 8: Materialized reconciled state ({})", final_state.id);
+
+        // Step 9: Verify state properties
+        let retrieved = store
+            .get(&final_state.id)
+            .expect("Failed to retrieve final state");
+
+        assert_eq!(retrieved.id, final_state.id);
+        assert_eq!(retrieved.authority, "reconciliation-authority");
+        assert!(retrieved.verify_integrity());
+
+        // Verify we can recover parent
+        let parent = store
+            .get(retrieved.parent().unwrap())
+            .expect("Failed to get parent");
+        assert_eq!(parent.id, alice_branch.id);
+
+        println!("✓ Step 9: Verified state persistence and recovery");
+
+        // Summary
+        println!("\n✅ END-TO-END STATE MODEL TEST PASSED");
+        println!("   - Created and branched states");
+        println!("   - Verified causal topology");
+        println!("   - Computed semantic diffs");
+        println!("   - Classified conflicts");
+        println!("   - Applied explicit reconciliation");
+        println!("   - Verified persistence and recovery");
+    }
+
+    #[test]
+    fn test_convergent_conflict_detection() {
+        // Test where both branches make the same change (convergent)
+        let store = StateStore::new_volatile();
+        let initial = store
+            .create(
+                r#"{"status":"initial"}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
+        let both_updated = r#"{"status":"updated"}"#.to_string();
+
+        let left = store
+            .commit(both_updated.clone(), &initial, "auth".to_string())
+            .unwrap();
+
+        let right = StateRevision::child(both_updated, &initial, "auth".to_string());
+
+        let classification = ConflictClassification::classify(&initial, &left, &right);
+        assert_eq!(classification.overall, ConflictClass::Convergent);
+
+        println!("✓ Convergent conflict correctly detected");
+    }
+
+    #[test]
+    fn test_actual_conflict_detection() {
+        // Test where both branches make conflicting changes (conflict)
+        let store = StateStore::new_volatile();
+        let initial = store
+            .create(
+                r#"{"value":"initial"}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
+        let left = store
+            .commit(
+                r#"{"value":"left-version"}"#.to_string(),
+                &initial,
+                "auth".to_string(),
+            )
+            .unwrap();
+
+        let right = StateRevision::child(
+            r#"{"value":"right-version"}"#.to_string(),
+            &initial,
+            "auth".to_string(),
+        );
+
+        let classification = ConflictClassification::classify(&initial, &left, &right);
+        assert_eq!(classification.overall, ConflictClass::Conflict);
+
+        println!("✓ Actual conflict correctly detected");
+    }
+
+    #[test]
+    fn test_unrelated_histories() {
+        // 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())
+            .unwrap();
+
+        let store2 = StateStore::new_volatile();
+        let state2 = store2
+            .create(r#"{"id":2}"#.to_string(), "auth2".to_string())
+            .unwrap();
+
+        let mut topology = StateTopology::new();
+        topology.add_revision(state1.clone());
+        topology.add_revision(state2.clone());
+
+        assert_eq!(
+            topology.relationship(&state1.id, &state2.id),
+            Relationship::Unrelated
+        );
+        assert!(topology.common_ancestor(&state1.id, &state2.id).is_none());
+
+        println!("✓ Unrelated histories correctly identified");
+    }
+
+    #[test]
+    fn test_representation_sensitivity_in_diff() {
+        // Verify that representation-sensitive changes are tracked
+        let old = json!({"count": 1});
+        let new_int = json!({"count": 1}); // Same numeric value
+        let new_string = json!({"count": "1"}); // Different representation
+
+        let diff1 = SemanticDiff::compute(&old, &new_int);
+        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");
+
+        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
+        let store = StateStore::new_volatile();
+        let state1 = store
+            .create(r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+
+        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);
+
+        println!("✓ Branch creation verified (doesn't implicitly advance current)");
+    }
+
+    #[test]
+    fn test_no_automatic_merge() {
+        // 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())
+            .unwrap();
+
+        let left = store
+            .commit(r#"{"a":10,"b":2}"#.to_string(), &initial, "auth".to_string())
+            .unwrap();
+
+        let right = StateRevision::child(
+            r#"{"a":1,"b":20}"#.to_string(),
+            &initial,
+            "auth".to_string(),
+        );
+
+        // Classify but don't automatically merge
+        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,
+        );
+
+        assert!(plan.validate());
+        assert!(
+            plan.path_overrides.is_empty(),
+            "Plan starts empty; caller must supply overrides"
+        );
+
+        println!("✓ No automatic merge; explicit plan required");
+    }
+}

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

@@ -0,0 +1,270 @@
+//! Comprehensive tests for FeltDB State Model persistence
+//!
+//! This test suite verifies that:
+//! 1. State revisions persist to disk through FeltDB
+//! 2. Current pointer persists correctly
+//! 3. Branches persist and recover
+//! 4. Restart recovery works (close database, reopen and recover state)
+//! 5. Deterministic StateIds survive restart
+//! 6. Volatile stores remain unchanged
+
+#[cfg(test)]
+mod state_persistence_tests {
+    use feltdb::state_model::StateStore;
+    use std::sync::Arc;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_persistent_store_saves_revisions_to_disk() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        // 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 id1 = rev1.id.clone();
+        let id2 = rev2.id.clone();
+        let id2_hex = id2.as_hex().to_string();
+
+        // 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()));
+
+        // Drop store and database (simulate restart)
+        drop(store1);
+
+        // New process: recover from disk
+        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
+        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery setup");
+
+        // 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");
+
+        // Verify content is correct
+        let recovered_rev2 = store2.get(&id2).expect("get rev2");
+        assert_eq!(recovered_rev2.content, r#"{"v":2}"#);
+        assert_eq!(recovered_rev2.authority, "auth");
+    }
+
+    #[test]
+    fn test_persistent_store_preserves_state_id_determinism() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        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 id1 = rev1.id.clone();
+        drop(store1);
+
+        // Recover and recreate the same content
+        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");
+    }
+
+    #[test]
+    fn test_persistent_store_handles_branch_persistence() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        // 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 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()));
+        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");
+    }
+
+    #[test]
+    fn test_volatile_store_does_not_persist() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        // Create volatile store
+        let store1 = StateStore::new_volatile();
+        let rev1 = store1.create(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");
+    }
+
+    #[test]
+    fn test_persistent_store_tracks_ancestry_across_restart() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        // 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 id1 = rev1.id.clone();
+        let id2 = rev2.id.clone();
+        let id3 = rev3.id.clone();
+        drop(store1);
+
+        // 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");
+        
+        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");
+        
+        let recovered_rev1 = store2.get(&id1).expect("get rev1");
+        assert!(recovered_rev1.parent_id.is_none(), "rev1 should have no parent");
+    }
+
+    #[test]
+    fn test_persistent_store_multiple_commits_in_sequence() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        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 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));
+        assert!(store.exists(&id3));
+        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));
+    }
+
+    #[test]
+    fn test_persistence_with_corrupted_content() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        // 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 id1 = rev1.id.clone();
+        drop(store1);
+
+        // Recover
+        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":"αβγ"}}}"#);
+    }
+
+    #[test]
+    fn test_concurrent_access_to_persistent_store() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        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 id1 = rev1.id.clone();
+
+        // Clone the store for concurrent access
+        let store_clone1 = store.clone();
+        let store_clone2 = store.clone();
+
+        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));
+
+        // Commit from one
+        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
+        assert!(store.exists(&id2));
+        assert!(store_clone2.exists(&id2));
+    }
+
+    #[test]
+    fn test_persistent_store_recovery_after_multiple_crashes() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = temp_dir.path().join("test.log");
+
+        // 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");
+        }
+
+        // Cycle 2: recover and add more
+        {
+            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");
+        }
+
+        // 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
+            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);
+        }
+    }
+}
+

package/dist/create/server-source/crates/feltdb-server/src/app_state.rs

@@ -1,8 +1,20 @@
 use std::path::PathBuf;
 use std::{
+    collections::HashMap,
     sync::{atomic::AtomicU64, Arc},
     time::Instant,
 };
+use serde_json::Value;
+
+#[derive(Clone)]
+pub struct BoundedQueryCursor {
+    pub query_hash: String,
+    pub principal_key_id: String,
+    pub namespace: String,
+    pub records: Arc<Vec<Value>>,
+    pub position: usize,
+    pub created_at: u64,
+}
 
 use feltdb::{
     FeltDb,
@@ -74,4 +86,5 @@ pub struct AppState {
     pub workloads: Arc<std::sync::Mutex<WorkloadStore>>,
     pub mesh: Arc<std::sync::Mutex<WorkerMeshStore>>,
     pub readiness_probe: Arc<PathBuf>,
+    pub bounded_query_cursors: Arc<std::sync::Mutex<HashMap<String, BoundedQueryCursor>>>,
 }