@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,850 +0,0 @@
-//! Comprehensive FeltDB State Boundary Tests
-//!
-//! These tests verify that all proven contracts from feltgit PRs #6-#14
-//! are re-proven at the FeltDB public API boundary using FeltDBStateSystem.
-//!
-//! This is evidence that the graduated state model is canonical and
-//! ready for real applications.
-
-#[cfg(test)]
-mod feltdb_state_boundary_tests {
-    use feltdb::{
-        ConflictClass, ConflictClassification, FeltDBStateSystem, Relationship, SemanticDiff,
-        StateTopology,
-    };
-    use serde_json::json;
-
-    // ========================================================================
-    // STATE IDENTITY & IMMUTABILITY TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_state_id_deterministic() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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("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);
-    }
-
-    #[test]
-    fn boundary_revision_immutability() {
-        let store = FeltDBStateSystem::create_test_store();
-        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();
-
-        // First revision is unchanged
-        let retrieved = store.get(&rev1_id).unwrap();
-        assert_eq!(retrieved.id, rev1_id);
-        assert_eq!(retrieved.content, r#"{"data":"initial"}"#);
-    }
-
-    // ========================================================================
-    // PERSISTENCE & RESTART RECOVERY TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_state_persistence() {
-        let store = FeltDBStateSystem::create_test_store();
-        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);
-    }
-
-    #[test]
-    fn boundary_current_pointer_persistence() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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));
-    }
-
-    // ========================================================================
-    // STATE TRANSITIONS & ATOMICITY TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_expected_parent_validation() {
-        let store = FeltDBStateSystem::create_test_store();
-        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();
-
-        // Child must have parent
-        assert_eq!(child.parent_id, Some(parent.id.clone()));
-    }
-
-    #[test]
-    fn boundary_stale_transition_rejection() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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();
-
-        // 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
-            _ => panic!("Expected Diverged relationship"),
-        }
-    }
-
-    #[test]
-    fn boundary_revision_persistence_before_pointer_advancement() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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();
-
-        // Current points to state2
-        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);
-    }
-
-    // ========================================================================
-    // BRANCHING & DIVERGENCE TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_explicit_parent_required() {
-        let store = FeltDBStateSystem::create_test_store();
-        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();
-        assert_eq!(child.parent_id, Some(parent.id.clone()));
-    }
-
-    #[test]
-    fn boundary_revisions_are_immutable_and_addressed_by_identity() {
-        let store = FeltDBStateSystem::create_test_store();
-        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(
-                "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(
-                "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: 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}"#
-        );
-    }
-
-    // ========================================================================
-    // TOPOLOGY & ANCESTRY TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_ancestors_linear() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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));
-        assert!(!ancestors.contains(&s3.id));
-    }
-
-    #[test]
-    fn boundary_is_ancestor() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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));
-    }
-
-    #[test]
-    fn boundary_common_ancestor() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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()));
-    }
-
-    #[test]
-    fn boundary_relationship_types() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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
-        ));
-
-        // Ancestor
-        assert!(matches!(
-            topology.relationship(&s1.id, &s2.id),
-            Relationship::Ancestor
-        ));
-
-        // Descendant
-        assert!(matches!(
-            topology.relationship(&s2.id, &s1.id),
-            Relationship::Descendant
-        ));
-
-        // 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(
-                "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
-        ));
-    }
-
-    // ========================================================================
-    // SEMANTIC DIFF TESTS
-    // ========================================================================
-
-    #[test]
-    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());
-    }
-
-    #[test]
-    fn boundary_diff_key_vs_index() {
-        let base: serde_json::Value = json!({
-            "users": [
-                {"name": "alice"},
-                {"name": "bob"}
-            ]
-        });
-        let modified: serde_json::Value = json!({
-            "users": [
-                {"name": "alice"},
-                {"name": "bob"},
-                {"name": "charlie"}
-            ]
-        });
-
-        let diff = SemanticDiff::compute(&base, &modified);
-
-        // Should detect array element addition
-        assert!(!diff.changes.is_empty());
-    }
-
-    #[test]
-    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);
-    }
-
-    #[test]
-    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());
-    }
-
-    #[test]
-    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)));
-    }
-
-    // ========================================================================
-    // CONFLICT CLASSIFICATION TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_conflict_independent() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-    }
-
-    #[test]
-    fn boundary_conflict_convergent() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-    }
-
-    #[test]
-    fn boundary_conflict_actual_conflict() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-    }
-
-    #[test]
-    fn boundary_conflict_authority_neutral() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-    }
-
-    // ========================================================================
-    // AUTHORITY & IMMUTABILITY TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_authority_recorded() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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");
-    }
-
-    #[test]
-    fn boundary_authority_does_not_affect_id() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-    }
-
-    // ========================================================================
-    // READ-ONLY BOUNDARY TESTS
-    // ========================================================================
-
-    #[test]
-    fn boundary_topology_is_read_only() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-    }
-
-    #[test]
-    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")));
-    }
-
-    #[test]
-    fn boundary_classification_is_read_only() {
-        let store = FeltDBStateSystem::create_test_store();
-
-        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);
-        assert_eq!(store.get(&right.id).unwrap().id, right.id);
-    }
-
-    // ========================================================================
-    // GIT INDEPENDENCE TESTS
-    // ========================================================================
-
-    #[test]
-    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(
-                "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("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);
-        let _common = topology.common_ancestor(&s1.id, &s2.id);
-        let _rel = topology.relationship(&s1.id, &s2.id);
-    }
-
-    // ========================================================================
-    // INTEGRATION WORKFLOW TEST
-    // ========================================================================
-
-    #[test]
-    fn boundary_complete_application_workflow() {
-        // Simulate a complete application workflow using canonical FeltDB state
-
-        // 1. Initialize
-        let store = FeltDBStateSystem::create_test_store();
-
-        // 2. Create initial application 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");
-
-        // 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");
-
-        // 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 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.get(&update2.id).unwrap().id, update2.id);
-
-        // 9. Verify all states exist
-        assert!(store.exists(&initial.id));
-        assert!(store.exists(&update1.id));
-        assert!(store.exists(&update2.id));
-    }
-}