@feltdb/core 0.8.4 → 0.8.5

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

@@ -9,9 +9,8 @@
 #[cfg(test)]
 mod feltdb_state_boundary_tests {
     use feltdb::{
-        FeltDBStateSystem, StateTopology, Relationship,
-        SemanticDiff, ConflictClassification, 
-        ConflictClass,
+        ConflictClass, ConflictClassification, FeltDBStateSystem, Relationship, SemanticDiff,
+        StateTopology,
     };
     use serde_json::json;
 
@@ -22,21 +21,32 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_state_id_deterministic() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state1 = store.create(r#"{"x":1}"#.to_string(), "auth1".to_string()).unwrap();
-        let state2 = store.create(r#"{"x":1}"#.to_string(), "auth2".to_string()).unwrap();
-        
-        // Same content → same StateId regardless of authority
-        assert_eq!(state1.id, state2.id);
+
+        let state1 = store
+            .create("docs:1", r#"{"x":1}"#.to_string(), "auth1".to_string())
+            .unwrap();
+        let state2 = store
+            .create("docs:2", r#"{"x":1}"#.to_string(), "auth2".to_string())
+            .unwrap();
+
+        // Same content on two resources is the same *state* and two distinct
+        // *revisions*. Content identity is deterministic; revision identity
+        // names the occurrence, and an occurrence belongs to a resource.
+        assert_eq!(state1.content_id, state2.content_id);
+        assert_ne!(state1.id, state2.id);
     }
 
     #[test]
     fn boundary_state_id_representation_sensitive() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let string_state = store.create(r#"{"v":"1"}"#.to_string(), "auth".to_string()).unwrap();
-        let number_state = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        
+
+        let string_state = store
+            .create("docs:3", r#"{"v":"1"}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let number_state = store
+            .create("docs:4", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+
         // "1" ≠ 1 in JSON representation
         assert_ne!(string_state.id, number_state.id);
     }
@@ -44,13 +54,25 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_revision_immutability() {
         let store = FeltDBStateSystem::create_test_store();
-        let rev1 = store.create(r#"{"data":"initial"}"#.to_string(), "auth".to_string()).unwrap();
-        
+        let rev1 = store
+            .create(
+                "docs:5",
+                r#"{"data":"initial"}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
         let rev1_id = rev1.id.clone();
-        
+
         // Create another state
-        let _rev2 = store.commit(r#"{"data":"modified"}"#.to_string(), &rev1, "auth".to_string()).unwrap();
-        
+        let _rev2 = store
+            .commit(
+                r#"{"data":"modified"}"#.to_string(),
+                &rev1,
+                "auth".to_string(),
+            )
+            .unwrap();
+
         // First revision is unchanged
         let retrieved = store.get(&rev1_id).unwrap();
         assert_eq!(retrieved.id, rev1_id);
@@ -64,10 +86,16 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_state_persistence() {
         let store = FeltDBStateSystem::create_test_store();
-        let state = store.create(r#"{"persistent":"data"}"#.to_string(), "auth".to_string()).unwrap();
-        
+        let state = store
+            .create(
+                "docs:6",
+                r#"{"persistent":"data"}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
         let state_id = state.id.clone();
-        
+
         // Verify it persists in store
         assert!(store.exists(&state_id));
         assert_eq!(store.get(&state_id).unwrap().id, state_id);
@@ -76,13 +104,17 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_current_pointer_persistence() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        assert_eq!(store.current().unwrap().id, state1.id);
-        
-        let state2 = store.commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string()).unwrap();
-        assert_eq!(store.current().unwrap().id, state2.id);
-        
+
+        let state1 = store
+            .create("docs:7", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        assert_eq!(store.get(&state1.id).unwrap().id, state1.id);
+
+        let state2 = store
+            .commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string())
+            .unwrap();
+        assert_eq!(store.get(&state2.id).unwrap().id, state2.id);
+
         // Verify both exist
         assert!(store.exists(&state1.id));
         assert!(store.exists(&state2.id));
@@ -95,11 +127,15 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_expected_parent_validation() {
         let store = FeltDBStateSystem::create_test_store();
-        let parent = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        
+        let parent = store
+            .create("docs:8", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+
         // Create child with explicit parent
-        let child = store.commit(r#"{"v":2}"#.to_string(), &parent, "auth".to_string()).unwrap();
-        
+        let child = store
+            .commit(r#"{"v":2}"#.to_string(), &parent, "auth".to_string())
+            .unwrap();
+
         // Child must have parent
         assert_eq!(child.parent_id, Some(parent.id.clone()));
     }
@@ -107,21 +143,27 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_stale_transition_rejection() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state1 = store.create(r#"{"seq":1}"#.to_string(), "auth".to_string()).unwrap();
-        let state2 = store.commit(r#"{"seq":2}"#.to_string(), &state1, "auth".to_string()).unwrap();
-        
+
+        let state1 = store
+            .create("docs:9", r#"{"seq":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let state2 = store
+            .commit(r#"{"seq":2}"#.to_string(), &state1, "auth".to_string())
+            .unwrap();
+
         // Create a branch from state1 (before state2)
-        let branch = store.commit(r#"{"seq":1.5}"#.to_string(), &state1, "auth".to_string()).unwrap();
-        
+        let branch = store
+            .commit(r#"{"seq":1.5}"#.to_string(), &state1, "auth".to_string())
+            .unwrap();
+
         // Verify topology catches this divergence
         let mut topology = StateTopology::new();
         topology.add_revision(state1.clone());
         topology.add_revision(state2.clone());
         topology.add_revision(branch.clone());
-        
+
         match topology.relationship(&state2.id, &branch.id) {
-            Relationship::Diverged => {}, // Expected
+            Relationship::Diverged => {} // Expected
             _ => panic!("Expected Diverged relationship"),
         }
     }
@@ -129,16 +171,20 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_revision_persistence_before_pointer_advancement() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+
+        let state1 = store
+            .create("docs:10", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
         let state1_id = state1.id.clone();
-        
+
         // Create and advance current
-        let state2 = store.commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string()).unwrap();
-        
+        let state2 = store
+            .commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string())
+            .unwrap();
+
         // Current points to state2
-        assert_eq!(store.current().unwrap().id, state2.id);
-        
+        assert_eq!(store.get(&state2.id).unwrap().id, state2.id);
+
         // But state1 still exists
         assert!(store.exists(&state1_id));
         assert_eq!(store.get(&state1_id).unwrap().id, state1_id);
@@ -151,68 +197,122 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_explicit_parent_required() {
         let store = FeltDBStateSystem::create_test_store();
-        let parent = store.create(r#"{"parent":true}"#.to_string(), "auth".to_string()).unwrap();
-        
+        let parent = store
+            .create(
+                "docs:11",
+                r#"{"parent":true}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
         // Initial state has no parent
         assert_eq!(parent.parent_id, None);
-        
+
         // Child must have parent
-        let child = store.commit(r#"{"parent":true,"child":true}"#.to_string(), &parent, "auth".to_string()).unwrap();
+        let child = store
+            .commit(
+                r#"{"parent":true,"child":true}"#.to_string(),
+                &parent,
+                "auth".to_string(),
+            )
+            .unwrap();
         assert_eq!(child.parent_id, Some(parent.id.clone()));
     }
 
     #[test]
-    fn boundary_immutable_branches() {
+    fn boundary_revisions_are_immutable_and_addressed_by_identity() {
         let store = FeltDBStateSystem::create_test_store();
-        let state = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        
-        store.create_branch("my-branch".to_string(), state.id.clone()).unwrap();
-        
-        // Branch reference is created
-        assert!(store.branch_head("my-branch").is_some());
-        
-        // Original state still exists unchanged
-        assert_eq!(store.get(&state.id).unwrap().id, state.id);
+        let state = store
+            .create("docs:12", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+
+        // Committing a descendant does not disturb its parent. There is no
+        // named branch to create: the identity is what a name would point at.
+        let child = store
+            .commit(r#"{"v":2}"#.to_string(), &state, "auth".to_string())
+            .unwrap();
+
+        let original = store.get(&state.id).unwrap();
+        assert_eq!(original.id, state.id);
+        assert_eq!(original.content, r#"{"v":1}"#);
+        assert_eq!(store.parent(&child.id).unwrap().id, state.id);
     }
 
     #[test]
     fn boundary_branch_does_not_advance_current() {
         let store = FeltDBStateSystem::create_test_store();
-        let state1 = store.create(r#"{"current":"first"}"#.to_string(), "auth".to_string()).unwrap();
-        
-        let state2 = store.commit(r#"{"current":"second"}"#.to_string(), &state1, "auth".to_string()).unwrap();
-        assert_eq!(store.current().unwrap().id, state2.id);
-        
-        // Create branch from state1
-        store.create_branch("experimental".to_string(), state1.id.clone()).unwrap();
-        
-        // Current is still state2
-        assert_eq!(store.current().unwrap().id, state2.id);
+        let state1 = store
+            .create(
+                "docs:13",
+                r#"{"current":"first"}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
+        let state2 = store
+            .commit(
+                r#"{"current":"second"}"#.to_string(),
+                &state1,
+                "auth".to_string(),
+            )
+            .unwrap();
+        assert_eq!(store.get(&state2.id).unwrap().id, state2.id);
+
+        // Both revisions remain independently addressable. Neither is
+        // privileged, because the store keeps no pointer that could privilege
+        // one of them.
+        assert_eq!(store.get(&state1.id).unwrap().id, state1.id);
+        assert_eq!(store.get(&state2.id).unwrap().id, state2.id);
     }
 
     #[test]
     fn boundary_no_automatic_merge() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let initial = store.create(r#"{"shared":100}"#.to_string(), "auth".to_string()).unwrap();
-        
-        let branch_a = store.commit(r#"{"shared":150}"#.to_string(), &initial, "auth".to_string()).unwrap();
-        let branch_b = store.commit(r#"{"shared":120}"#.to_string(), &initial, "auth".to_string()).unwrap();
-        
+
+        let initial = store
+            .create(
+                "docs:14",
+                r#"{"shared":100}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
+        let branch_a = store
+            .commit(
+                r#"{"shared":150}"#.to_string(),
+                &initial,
+                "auth".to_string(),
+            )
+            .unwrap();
+        let branch_b = store
+            .commit(
+                r#"{"shared":120}"#.to_string(),
+                &initial,
+                "auth".to_string(),
+            )
+            .unwrap();
+
         // Two divergent branches exist
         let mut topology = StateTopology::new();
         topology.add_revision(initial.clone());
         topology.add_revision(branch_a.clone());
         topology.add_revision(branch_b.clone());
-        
+
         assert!(matches!(
             topology.relationship(&branch_a.id, &branch_b.id),
             Relationship::Diverged
         ));
-        
-        // No merge happened automatically
-        assert!(store.branch_head("a").is_none());
-        assert!(store.branch_head("b").is_none());
+
+        // No merge happened automatically: both divergent revisions are still
+        // exactly what their authors wrote, and no third revision appeared.
+        assert_eq!(
+            store.get(&branch_a.id).unwrap().content,
+            r#"{"shared":150}"#
+        );
+        assert_eq!(
+            store.get(&branch_b.id).unwrap().content,
+            r#"{"shared":120}"#
+        );
     }
 
     // ========================================================================
@@ -222,16 +322,22 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_ancestors_linear() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let s1 = store.create(r#"{"seq":1}"#.to_string(), "auth".to_string()).unwrap();
-        let s2 = store.commit(r#"{"seq":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
-        let s3 = store.commit(r#"{"seq":3}"#.to_string(), &s2, "auth".to_string()).unwrap();
-        
+
+        let s1 = store
+            .create("docs:15", r#"{"seq":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let s2 = store
+            .commit(r#"{"seq":2}"#.to_string(), &s1, "auth".to_string())
+            .unwrap();
+        let s3 = store
+            .commit(r#"{"seq":3}"#.to_string(), &s2, "auth".to_string())
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(s1.clone());
         topology.add_revision(s2.clone());
         topology.add_revision(s3.clone());
-        
+
         let ancestors = topology.ancestors(&s3.id);
         assert!(ancestors.contains(&s2.id));
         assert!(ancestors.contains(&s1.id));
@@ -241,16 +347,22 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_is_ancestor() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let parent = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        let child = store.commit(r#"{"v":2}"#.to_string(), &parent, "auth".to_string()).unwrap();
-        let grandchild = store.commit(r#"{"v":3}"#.to_string(), &child, "auth".to_string()).unwrap();
-        
+
+        let parent = store
+            .create("docs:16", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let child = store
+            .commit(r#"{"v":2}"#.to_string(), &parent, "auth".to_string())
+            .unwrap();
+        let grandchild = store
+            .commit(r#"{"v":3}"#.to_string(), &child, "auth".to_string())
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(parent.clone());
         topology.add_revision(child.clone());
         topology.add_revision(grandchild.clone());
-        
+
         assert!(topology.is_ancestor(&parent.id, &grandchild.id));
         assert!(topology.is_ancestor(&child.id, &grandchild.id));
         assert!(!topology.is_ancestor(&grandchild.id, &parent.id));
@@ -259,16 +371,26 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_common_ancestor() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let root = store.create(r#"{"root":true}"#.to_string(), "auth".to_string()).unwrap();
-        let left = store.commit(r#"{"left":true}"#.to_string(), &root, "auth".to_string()).unwrap();
-        let right = store.commit(r#"{"right":true}"#.to_string(), &root, "auth".to_string()).unwrap();
-        
+
+        let root = store
+            .create(
+                "docs:17",
+                r#"{"root":true}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+        let left = store
+            .commit(r#"{"left":true}"#.to_string(), &root, "auth".to_string())
+            .unwrap();
+        let right = store
+            .commit(r#"{"right":true}"#.to_string(), &root, "auth".to_string())
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(root.clone());
         topology.add_revision(left.clone());
         topology.add_revision(right.clone());
-        
+
         let common = topology.common_ancestor(&left.id, &right.id);
         assert_eq!(common, Some(root.id.clone()));
     }
@@ -276,40 +398,70 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_relationship_types() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let s1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        let s2 = store.commit(r#"{"v":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
-        let s3 = store.commit(r#"{"v":3}"#.to_string(), &s1, "auth".to_string()).unwrap();
-        
+
+        let s1 = store
+            .create("docs:18", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let s2 = store
+            .commit(r#"{"v":2}"#.to_string(), &s1, "auth".to_string())
+            .unwrap();
+        let s3 = store
+            .commit(r#"{"v":3}"#.to_string(), &s1, "auth".to_string())
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(s1.clone());
         topology.add_revision(s2.clone());
         topology.add_revision(s3.clone());
-        
+
         // Identity
-        assert!(matches!(topology.relationship(&s1.id, &s1.id), Relationship::Identity));
-        
+        assert!(matches!(
+            topology.relationship(&s1.id, &s1.id),
+            Relationship::Identity
+        ));
+
         // Ancestor
-        assert!(matches!(topology.relationship(&s1.id, &s2.id), Relationship::Ancestor));
-        
+        assert!(matches!(
+            topology.relationship(&s1.id, &s2.id),
+            Relationship::Ancestor
+        ));
+
         // Descendant
-        assert!(matches!(topology.relationship(&s2.id, &s1.id), Relationship::Descendant));
-        
+        assert!(matches!(
+            topology.relationship(&s2.id, &s1.id),
+            Relationship::Descendant
+        ));
+
         // Diverged
-        assert!(matches!(topology.relationship(&s2.id, &s3.id), Relationship::Diverged));
+        assert!(matches!(
+            topology.relationship(&s2.id, &s3.id),
+            Relationship::Diverged
+        ));
     }
 
     #[test]
     fn boundary_unrelated_histories() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let hist1_root = store.create(r#"{"history":1}"#.to_string(), "auth".to_string()).unwrap();
-        let hist2_root = store.create(r#"{"history":2}"#.to_string(), "auth".to_string()).unwrap();
-        
+
+        let hist1_root = store
+            .create(
+                "docs:19",
+                r#"{"history":1}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+        let hist2_root = store
+            .create(
+                "docs:20",
+                r#"{"history":2}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(hist1_root.clone());
         topology.add_revision(hist2_root.clone());
-        
+
         assert!(matches!(
             topology.relationship(&hist1_root.id, &hist2_root.id),
             Relationship::Unrelated
@@ -324,9 +476,9 @@ mod feltdb_state_boundary_tests {
     fn boundary_diff_deterministic_paths() {
         let base: serde_json::Value = json!({"a": 1, "b": 2});
         let modified: serde_json::Value = json!({"a": 2, "b": 2});
-        
+
         let diff = SemanticDiff::compute(&base, &modified);
-        
+
         // Should have exactly one change
         assert_eq!(diff.changes.len(), 1);
         assert!(!diff.changes[0].path.is_empty());
@@ -347,9 +499,9 @@ mod feltdb_state_boundary_tests {
                 {"name": "charlie"}
             ]
         });
-        
+
         let diff = SemanticDiff::compute(&base, &modified);
-        
+
         // Should detect array element addition
         assert!(!diff.changes.is_empty());
     }
@@ -358,9 +510,9 @@ mod feltdb_state_boundary_tests {
     fn boundary_diff_added_removed_changed() {
         let base: serde_json::Value = json!({"x": 1, "y": 2});
         let modified: serde_json::Value = json!({"x": 10, "z": 3});
-        
+
         let diff = SemanticDiff::compute(&base, &modified);
-        
+
         // Should have changes for: x changed, y removed, z added
         assert!(diff.changes.len() >= 2);
     }
@@ -369,9 +521,9 @@ mod feltdb_state_boundary_tests {
     fn boundary_diff_type_sensitive() {
         let base: serde_json::Value = json!({"v": "1"});
         let modified: serde_json::Value = json!({"v": 1});
-        
+
         let diff = SemanticDiff::compute(&base, &modified);
-        
+
         // Should detect type change
         assert!(!diff.changes.is_empty());
     }
@@ -380,9 +532,9 @@ mod feltdb_state_boundary_tests {
     fn boundary_diff_read_only() {
         let base: serde_json::Value = json!({"original": true});
         let modified: serde_json::Value = json!({"modified": true});
-        
+
         let _diff = SemanticDiff::compute(&base, &modified);
-        
+
         // Diff should not modify inputs
         assert_eq!(base.get("original"), Some(&json!(true)));
         assert_eq!(modified.get("modified"), Some(&json!(true)));
@@ -395,13 +547,23 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_conflict_independent() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let base = store.create(r#"{"a":1,"b":1}"#.to_string(), "auth".to_string()).unwrap();
-        let left = store.commit(r#"{"a":2,"b":1}"#.to_string(), &base, "auth".to_string()).unwrap();
-        let right = store.commit(r#"{"a":1,"b":2}"#.to_string(), &base, "auth".to_string()).unwrap();
-        
+
+        let base = store
+            .create(
+                "docs:21",
+                r#"{"a":1,"b":1}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+        let left = store
+            .commit(r#"{"a":2,"b":1}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+        let right = store
+            .commit(r#"{"a":1,"b":2}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+
         let classification = ConflictClassification::classify(&base, &left, &right);
-        
+
         // Modifications to different fields are independent
         assert_eq!(classification.overall, ConflictClass::Independent);
     }
@@ -409,13 +571,19 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_conflict_convergent() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let base = store.create(r#"{"value":1}"#.to_string(), "auth".to_string()).unwrap();
-        let left = store.commit(r#"{"value":2}"#.to_string(), &base, "auth".to_string()).unwrap();
-        let right = store.commit(r#"{"value":2}"#.to_string(), &base, "auth".to_string()).unwrap();
-        
+
+        let base = store
+            .create("docs:22", r#"{"value":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let left = store
+            .commit(r#"{"value":2}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+        let right = store
+            .commit(r#"{"value":2}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+
         let classification = ConflictClassification::classify(&base, &left, &right);
-        
+
         // Both made same change → convergent
         assert_eq!(classification.overall, ConflictClass::Convergent);
     }
@@ -423,13 +591,23 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_conflict_actual_conflict() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let base = store.create(r#"{"balance":100}"#.to_string(), "auth".to_string()).unwrap();
-        let left = store.commit(r#"{"balance":150}"#.to_string(), &base, "auth".to_string()).unwrap();
-        let right = store.commit(r#"{"balance":120}"#.to_string(), &base, "auth".to_string()).unwrap();
-        
+
+        let base = store
+            .create(
+                "docs:23",
+                r#"{"balance":100}"#.to_string(),
+                "auth".to_string(),
+            )
+            .unwrap();
+        let left = store
+            .commit(r#"{"balance":150}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+        let right = store
+            .commit(r#"{"balance":120}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+
         let classification = ConflictClassification::classify(&base, &left, &right);
-        
+
         // Different modifications to same field → conflict
         assert_eq!(classification.overall, ConflictClass::Conflict);
     }
@@ -437,13 +615,19 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_conflict_authority_neutral() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let base = store.create(r#"{"v":1}"#.to_string(), "alice".to_string()).unwrap();
-        let left = store.commit(r#"{"v":2}"#.to_string(), &base, "alice".to_string()).unwrap();
-        let right = store.commit(r#"{"v":2}"#.to_string(), &base, "bob".to_string()).unwrap();
-        
+
+        let base = store
+            .create("docs:24", r#"{"v":1}"#.to_string(), "alice".to_string())
+            .unwrap();
+        let left = store
+            .commit(r#"{"v":2}"#.to_string(), &base, "alice".to_string())
+            .unwrap();
+        let right = store
+            .commit(r#"{"v":2}"#.to_string(), &base, "bob".to_string())
+            .unwrap();
+
         let classification = ConflictClassification::classify(&base, &left, &right);
-        
+
         // Classification doesn't prefer one authority over another
         // It should classify based on content, not authority
         assert_eq!(classification.overall, ConflictClass::Convergent);
@@ -456,11 +640,17 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_authority_recorded() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state = store.create(r#"{"data":"value"}"#.to_string(), "my-authority".to_string()).unwrap();
-        
+
+        let state = store
+            .create(
+                "docs:25",
+                r#"{"data":"value"}"#.to_string(),
+                "my-authority".to_string(),
+            )
+            .unwrap();
+
         assert_eq!(state.authority, "my-authority");
-        
+
         let retrieved = store.get(&state.id).unwrap();
         assert_eq!(retrieved.authority, "my-authority");
     }
@@ -468,12 +658,18 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_authority_does_not_affect_id() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state1 = store.create(r#"{"x":1}"#.to_string(), "auth1".to_string()).unwrap();
-        let state2 = store.create(r#"{"x":1}"#.to_string(), "auth2".to_string()).unwrap();
-        
-        // Same content, different authorities → same ID
-        assert_eq!(state1.id, state2.id);
+
+        let state1 = store
+            .create("docs:26", r#"{"x":1}"#.to_string(), "auth1".to_string())
+            .unwrap();
+        let state2 = store
+            .create("docs:27", r#"{"x":1}"#.to_string(), "auth2".to_string())
+            .unwrap();
+
+        // Authority takes no part in either identity. The content identity is
+        // equal; the revision identities differ only because the resources do.
+        assert_eq!(state1.content_id, state2.content_id);
+        assert_ne!(state1.id, state2.id);
     }
 
     // ========================================================================
@@ -483,19 +679,23 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_topology_is_read_only() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let s1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        let s2 = store.commit(r#"{"v":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
-        
+
+        let s1 = store
+            .create("docs:28", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let s2 = store
+            .commit(r#"{"v":2}"#.to_string(), &s1, "auth".to_string())
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(s1.clone());
         topology.add_revision(s2.clone());
-        
+
         // Topology operations shouldn't mutate states
         let _rel = topology.relationship(&s1.id, &s2.id);
         let _anc = topology.is_ancestor(&s1.id, &s2.id);
         let _ancestors = topology.ancestors(&s2.id);
-        
+
         // States unchanged
         assert_eq!(store.get(&s1.id).unwrap().id, s1.id);
         assert_eq!(store.get(&s2.id).unwrap().id, s2.id);
@@ -505,9 +705,9 @@ mod feltdb_state_boundary_tests {
     fn boundary_diff_is_read_only() {
         let base: serde_json::Value = json!({"immutable": "base"});
         let modified: serde_json::Value = json!({"immutable": "base", "changed": true});
-        
+
         let _diff = SemanticDiff::compute(&base, &modified);
-        
+
         // Input values unchanged
         assert_eq!(base.get("immutable"), Some(&json!("base")));
         assert_eq!(modified.get("immutable"), Some(&json!("base")));
@@ -516,13 +716,19 @@ mod feltdb_state_boundary_tests {
     #[test]
     fn boundary_classification_is_read_only() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let base = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
-        let left = store.commit(r#"{"v":2}"#.to_string(), &base, "auth".to_string()).unwrap();
-        let right = store.commit(r#"{"v":3}"#.to_string(), &base, "auth".to_string()).unwrap();
-        
+
+        let base = store
+            .create("docs:29", r#"{"v":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let left = store
+            .commit(r#"{"v":2}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+        let right = store
+            .commit(r#"{"v":3}"#.to_string(), &base, "auth".to_string())
+            .unwrap();
+
         let _classification = ConflictClassification::classify(&base, &left, &right);
-        
+
         // States unchanged
         assert_eq!(store.get(&base.id).unwrap().id, base.id);
         assert_eq!(store.get(&left.id).unwrap().id, left.id);
@@ -537,26 +743,33 @@ mod feltdb_state_boundary_tests {
     fn boundary_no_git_dependency() {
         // This test should pass without any .git directory or Git runtime
         let store = FeltDBStateSystem::create_test_store();
-        
-        let state = store.create(
-            r#"{"git-independent": true}"#.to_string(),
-            "auth".to_string()
-        ).expect("State operations should work without Git");
-        
+
+        let state = store
+            .create(
+                "docs:30",
+                r#"{"git-independent": true}"#.to_string(),
+                "auth".to_string(),
+            )
+            .expect("State operations should work without Git");
+
         assert!(store.exists(&state.id));
     }
 
     #[test]
     fn boundary_topology_no_git() {
         let store = FeltDBStateSystem::create_test_store();
-        
-        let s1 = store.create(r#"{"seq":1}"#.to_string(), "auth".to_string()).unwrap();
-        let s2 = store.commit(r#"{"seq":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
-        
+
+        let s1 = store
+            .create("docs:31", r#"{"seq":1}"#.to_string(), "auth".to_string())
+            .unwrap();
+        let s2 = store
+            .commit(r#"{"seq":2}"#.to_string(), &s1, "auth".to_string())
+            .unwrap();
+
         let mut topology = StateTopology::new();
         topology.add_revision(s1.clone());
         topology.add_revision(s2.clone());
-        
+
         // All topology operations should work without Git
         let _ancestors = topology.ancestors(&s2.id);
         let _is_anc = topology.is_ancestor(&s1.id, &s2.id);
@@ -574,58 +787,61 @@ mod feltdb_state_boundary_tests {
 
         // 1. Initialize
         let store = FeltDBStateSystem::create_test_store();
-        
+
         // 2. Create initial application state
-        let initial = store.create(
-            r#"{"users":{"alice":{"balance":100}}}"#.to_string(),
-            "app-authority".to_string(),
-        ).expect("Create initial state");
-        
+        let initial = store
+            .create(
+                "docs:32",
+                r#"{"users":{"alice":{"balance":100}}}"#.to_string(),
+                "app-authority".to_string(),
+            )
+            .expect("Create initial state");
+
         // 3. Make first update
-        let update1 = store.commit(
-            r#"{"users":{"alice":{"balance":150}}}"#.to_string(),
-            &initial,
-            "alice".to_string(),
-        ).expect("First update");
-        
+        let update1 = store
+            .commit(
+                r#"{"users":{"alice":{"balance":150}}}"#.to_string(),
+                &initial,
+                "alice".to_string(),
+            )
+            .expect("First update");
+
         // 4. Branch: parallel update from initial
-        let update2 = store.commit(
-            r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#.to_string(),
-            &initial,
-            "bob".to_string(),
-        ).expect("Parallel update");
-        
-        store.create_branch("alice-branch".to_string(), update1.id.clone()).expect("Create branch");
-        
+        let update2 = store
+            .commit(
+                r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#.to_string(),
+                &initial,
+                "bob".to_string(),
+            )
+            .expect("Parallel update");
+
         // 5. Analyze topology
         let mut topology = StateTopology::new();
         topology.add_revision(initial.clone());
         topology.add_revision(update1.clone());
         topology.add_revision(update2.clone());
-        
+
         assert!(matches!(
             topology.relationship(&update1.id, &update2.id),
             Relationship::Diverged
         ));
-        
+
         // 6. Compute diffs
-        let initial_json: serde_json::Value = serde_json::from_str(
-            r#"{"users":{"alice":{"balance":100}}}"#
-        ).unwrap();
-        let update1_json: serde_json::Value = serde_json::from_str(
-            r#"{"users":{"alice":{"balance":150}}}"#
-        ).unwrap();
-        
+        let initial_json: serde_json::Value =
+            serde_json::from_str(r#"{"users":{"alice":{"balance":100}}}"#).unwrap();
+        let update1_json: serde_json::Value =
+            serde_json::from_str(r#"{"users":{"alice":{"balance":150}}}"#).unwrap();
+
         let diff = SemanticDiff::compute(&initial_json, &update1_json);
         assert!(!diff.changes.is_empty());
-        
+
         // 7. Classify conflict
         let classification = ConflictClassification::classify(&initial, &update1, &update2);
         assert_eq!(classification.overall, ConflictClass::Independent);
-        
+
         // 8. Verify current pointer
-        assert_eq!(store.current().unwrap().id, update2.id);
-        
+        assert_eq!(store.get(&update2.id).unwrap().id, update2.id);
+
         // 9. Verify all states exist
         assert!(store.exists(&initial.id));
         assert!(store.exists(&update1.id));