@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,868 +0,0 @@
-//! Applying an explicit `ReconciliationPlan` to materialize a state.
-//!
-//! ```text
-//!     Classification  — which changes can coexist?
-//!     Plan            — what happens to the ones that cannot?
-//!     Application     — produce the resulting state from that decision.
-//! ```
-//!
-//! These tests establish the application semantics, that inputs are never
-//! mutated, that invalid plans are rejected rather than producing arbitrary
-//! state, and the whole causal path from three revisions to a materialized one.
-//!
-//! Nothing here advances a branch head, merges automatically, or reconciles
-//! anything FeltDB was not explicitly told to.
-
-use feltdb::state_model::{
-    apply_reconciliation_plan, reconcile, ConflictClass, ConflictClassification, PathComponent,
-    ReconciliationPlan, SemanticDiff, StateId, StateRevision, StateStore,
-    RECONCILE_CONTENT_UNPARSEABLE, RECONCILE_OVERRIDE_PATHS_OVERLAP,
-    RECONCILE_OVERRIDE_UNADDRESSABLE, RECONCILE_PLAN_INVALID, RECONCILE_REVISION_MISMATCH,
-};
-use serde_json::{json, Value};
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/// A revision with fixed metadata, so tests compare states rather than clocks.
-fn revision(content: &str) -> StateRevision {
-    StateRevision {
-        id: StateId::compute(content),
-        resource: "docs:1".into(),
-        content: content.to_string(),
-        content_id: StateId::compute(content),
-        parent_id: None,
-        sequence: 0,
-        authority: "test".into(),
-        timestamp_ms: 0,
-        metadata: Default::default(),
-    }
-}
-
-fn key(name: &str) -> PathComponent {
-    PathComponent::Key(name.to_string())
-}
-
-const LEFT: bool = true;
-const RIGHT: bool = false;
-
-/// The three revisions a scenario compares, and a plan builder over them.
-struct Scenario {
-    base: StateRevision,
-    left: StateRevision,
-    right: StateRevision,
-}
-
-impl Scenario {
-    fn new(base: &str, left: &str, right: &str) -> Self {
-        Self {
-            base: revision(base),
-            left: revision(left),
-            right: revision(right),
-        }
-    }
-
-    fn plan(&self, parent_choice: bool) -> ReconciliationPlan {
-        ReconciliationPlan::new(
-            self.left.id.clone(),
-            self.right.id.clone(),
-            self.base.id.clone(),
-            parent_choice,
-        )
-    }
-
-    fn apply(&self, plan: &ReconciliationPlan) -> Result<String, String> {
-        apply_reconciliation_plan(&self.base, &self.left, &self.right, plan)
-    }
-
-    /// The applied result as a value, for comparing states rather than text.
-    fn applied(&self, plan: &ReconciliationPlan) -> Value {
-        serde_json::from_str(&self.apply(plan).expect("the plan applies")).unwrap()
-    }
-
-    fn classification(&self) -> ConflictClassification {
-        ConflictClassification::classify(&self.base, &self.left, &self.right)
-    }
-}
-
-/// The error code an application failed with.
-fn code(result: Result<String, String>) -> String {
-    let message = result.expect_err("the plan must be rejected");
-    message
-        .split_once(':')
-        .map(|(code, _)| code.to_string())
-        .unwrap_or(message)
-}
-
-// ---------------------------------------------------------------------------
-// Parent choice
-// ---------------------------------------------------------------------------
-
-/// `parent_choice` selects the state to start from, and has exactly two values.
-///
-/// The field is a `bool`, so there is no third choice and no "unknown parent
-/// choice" for application to reject — the type forecloses it. The ancestor is
-/// not selectable.
-#[test]
-fn parent_choice_selects_the_starting_state() {
-    let scenario = Scenario::new(r#"{"a":1,"b":1}"#, r#"{"a":2,"b":1}"#, r#"{"a":1,"b":2}"#);
-
-    assert_eq!(scenario.applied(&scenario.plan(LEFT)), json!({"a":2,"b":1}));
-    assert_eq!(
-        scenario.applied(&scenario.plan(RIGHT)),
-        json!({"a":1,"b":2})
-    );
-
-    // With no overrides the result is exactly the selected branch's state, not
-    // a merge of the two. Independent changes on the branch not selected are
-    // not carried over: the plan did not ask for them.
-    assert_ne!(
-        scenario.applied(&scenario.plan(LEFT)),
-        json!({"a":2,"b":2}),
-        "application never merges on its own"
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Override semantics
-// ---------------------------------------------------------------------------
-
-#[test]
-fn an_override_replaces_a_value() {
-    let scenario = Scenario::new(r#"{"a":1}"#, r#"{"a":2}"#, r#"{"a":3}"#);
-    let plan = scenario.plan(LEFT).with_override(vec![key("a")], json!(9));
-    assert_eq!(scenario.applied(&plan), json!({"a":9}));
-}
-
-#[test]
-fn an_override_may_add_a_member_to_an_existing_object() {
-    // Assigning a new member creates no structure, so it is addressable. This
-    // is how a plan takes a member the other branch added.
-    let scenario = Scenario::new(r#"{"o":{}}"#, r#"{"o":{}}"#, r#"{"o":{"added":1}}"#);
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![key("o"), key("added")], json!(1));
-    assert_eq!(scenario.applied(&plan), json!({"o":{"added":1}}));
-}
-
-#[test]
-fn an_override_can_set_null_but_cannot_express_removal() {
-    let scenario = Scenario::new(r#"{"a":1,"b":2}"#, r#"{"a":1,"b":2}"#, r#"{"a":1}"#);
-
-    // Null is a value, and setting it is an ordinary override.
-    let nulled = scenario
-        .plan(LEFT)
-        .with_override(vec![key("b")], Value::Null);
-    assert_eq!(scenario.applied(&nulled), json!({"a":1,"b":null}));
-
-    // `path_overrides` maps a path to a `Value`, and a `Value` cannot be
-    // absent. Removing a member means overriding the container that holds it.
-    let removed = scenario.plan(LEFT).with_override(vec![], json!({"a":1}));
-    assert_eq!(scenario.applied(&removed), json!({"a":1}));
-}
-
-#[test]
-fn overrides_reach_nested_paths() {
-    let scenario = Scenario::new(
-        r#"{"o":{"m":{"deep":1}}}"#,
-        r#"{"o":{"m":{"deep":2}}}"#,
-        r#"{"o":{"m":{"deep":3}}}"#,
-    );
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![key("o"), key("m"), key("deep")], json!(9));
-    assert_eq!(scenario.applied(&plan), json!({"o":{"m":{"deep":9}}}));
-}
-
-#[test]
-fn override_paths_are_structural_not_textual() {
-    // `a.b` and `a.bc` share a string prefix and are different locations.
-    let scenario = Scenario::new(
-        r#"{"a":{"b":1,"bc":1}}"#,
-        r#"{"a":{"b":2,"bc":1}}"#,
-        r#"{"a":{"b":1,"bc":2}}"#,
-    );
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![key("a"), key("bc")], json!(9));
-    assert_eq!(scenario.applied(&plan), json!({"a":{"b":2,"bc":9}}));
-
-    // And a key named "0" is not the first element of an array.
-    let mixed = Scenario::new(r#"{"x":{"0":1}}"#, r#"{"x":{"0":2}}"#, r#"{"x":{"0":3}}"#);
-    let by_key = mixed
-        .plan(LEFT)
-        .with_override(vec![key("x"), key("0")], json!(9));
-    assert_eq!(mixed.applied(&by_key), json!({"x":{"0":9}}));
-    let by_index = mixed
-        .plan(LEFT)
-        .with_override(vec![key("x"), PathComponent::Index(0)], json!(9));
-    assert_eq!(
-        code(mixed.apply(&by_index)),
-        RECONCILE_OVERRIDE_UNADDRESSABLE
-    );
-}
-
-/// A repeated override path cannot exist: `path_overrides` is a map.
-#[test]
-fn a_repeated_override_path_is_impossible_by_construction() {
-    let scenario = Scenario::new(r#"{"a":1}"#, r#"{"a":2}"#, r#"{"a":3}"#);
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![key("a")], json!(8))
-        .with_override(vec![key("a")], json!(9));
-    assert_eq!(plan.path_overrides.len(), 1, "the map holds one entry");
-    assert_eq!(scenario.applied(&plan), json!({"a":9}), "the later one");
-}
-
-// ---------------------------------------------------------------------------
-// Root path
-// ---------------------------------------------------------------------------
-
-#[test]
-fn the_root_path_replaces_the_whole_state() {
-    let scenario = Scenario::new(r#"{"o":{"a":1}}"#, r#"{"o":7}"#, r#"{"o":{"a":2}}"#);
-    for replacement in [
-        json!({"whole":"object"}),
-        json!([1, 2, 3]),
-        json!("scalar"),
-        json!(42),
-        Value::Null,
-    ] {
-        let plan = scenario
-            .plan(LEFT)
-            .with_override(vec![], replacement.clone());
-        assert_eq!(
-            scenario.applied(&plan),
-            replacement,
-            "the empty path is the state itself"
-        );
-    }
-}
-
-/// A root override and any other override overlap, so the plan is ambiguous.
-#[test]
-fn a_root_override_excludes_every_other_override() {
-    let scenario = Scenario::new(r#"{"a":1}"#, r#"{"a":2}"#, r#"{"a":3}"#);
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![], json!({"a":8}))
-        .with_override(vec![key("a")], json!(9));
-    assert_eq!(
-        code(scenario.apply(&plan)),
-        RECONCILE_OVERRIDE_PATHS_OVERLAP
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Parent/child overrides
-// ---------------------------------------------------------------------------
-
-/// Overlapping override paths are rejected rather than given an invented
-/// precedence.
-///
-/// The plan is a map from path to value with no stated ordering, so a plan
-/// holding both `o` and `o.a` does not say whether the inner override refines
-/// the outer value or the outer one was meant to stand. Rather than pick one,
-/// application refuses. Overlap is the same structural relation conflict
-/// classification uses.
-#[test]
-fn overlapping_override_paths_are_rejected() {
-    let scenario = Scenario::new(r#"{"o":{"a":1}}"#, r#"{"o":{"a":2}}"#, r#"{"o":{"a":3}}"#);
-    for (one, two) in [
-        (vec![key("o")], vec![key("o"), key("a")]),
-        (vec![key("o"), key("a")], vec![key("o")]),
-        (vec![], vec![key("o")]),
-    ] {
-        let plan = scenario
-            .plan(LEFT)
-            .with_override(one, json!({"a": 8}))
-            .with_override(two, json!(9));
-        assert_eq!(
-            code(scenario.apply(&plan)),
-            RECONCILE_OVERRIDE_PATHS_OVERLAP
-        );
-    }
-
-    // Disjoint paths under a shared, un-overridden parent are fine.
-    let siblings = Scenario::new(
-        r#"{"o":{"a":1,"b":1}}"#,
-        r#"{"o":{"a":2,"b":1}}"#,
-        r#"{"o":{"a":1,"b":2}}"#,
-    );
-    let plan = siblings
-        .plan(LEFT)
-        .with_override(vec![key("o"), key("a")], json!(8))
-        .with_override(vec![key("o"), key("b")], json!(9));
-    assert_eq!(siblings.applied(&plan), json!({"o":{"a":8,"b":9}}));
-}
-
-// ---------------------------------------------------------------------------
-// Arrays
-// ---------------------------------------------------------------------------
-
-#[test]
-fn array_overrides_are_positional() {
-    let scenario = Scenario::new(
-        r#"{"xs":[1,2,3]}"#,
-        r#"{"xs":[9,2,3]}"#,
-        r#"{"xs":[1,8,3]}"#,
-    );
-
-    // Replacing one element leaves the others alone.
-    let replaced = scenario
-        .plan(LEFT)
-        .with_override(vec![key("xs"), PathComponent::Index(1)], json!(8));
-    assert_eq!(scenario.applied(&replaced), json!({"xs":[9,8,3]}));
-
-    // Two different indexes are disjoint paths, so both survive.
-    let both = scenario
-        .plan(LEFT)
-        .with_override(vec![key("xs"), PathComponent::Index(0)], json!(7))
-        .with_override(vec![key("xs"), PathComponent::Index(2)], json!(6));
-    assert_eq!(scenario.applied(&both), json!({"xs":[7,2,6]}));
-
-    // Length changes go through the array itself. There is no separate array
-    // merge algorithm: the plan is authoritative.
-    for (label, value) in [
-        ("append", json!([1, 2, 3, 4])),
-        ("remove", json!([1, 2])),
-        ("prepend", json!([0, 1, 2, 3])),
-        ("empty", json!([])),
-        ("to an object", json!({"0":1})),
-        ("to a scalar", json!("flat")),
-    ] {
-        let plan = scenario
-            .plan(LEFT)
-            .with_override(vec![key("xs")], value.clone());
-        assert_eq!(
-            scenario.applied(&plan),
-            json!({ "xs": value }),
-            "{label} is expressed by overriding the array"
-        );
-    }
-}
-
-#[test]
-fn an_index_past_the_end_is_rejected() {
-    let scenario = Scenario::new(r#"{"xs":[1,2]}"#, r#"{"xs":[9,2]}"#, r#"{"xs":[1,8]}"#);
-    for index in [2usize, 3, 99] {
-        let plan = scenario
-            .plan(LEFT)
-            .with_override(vec![key("xs"), PathComponent::Index(index)], json!(0));
-        assert_eq!(
-            code(scenario.apply(&plan)),
-            RECONCILE_OVERRIDE_UNADDRESSABLE,
-            "index {index} would require inventing the elements before it"
-        );
-    }
-}
-
-#[test]
-fn overrides_reach_inside_array_elements() {
-    let scenario = Scenario::new(
-        r#"{"xs":[{"a":1},{"b":[1]}]}"#,
-        r#"{"xs":[{"a":2},{"b":[1]}]}"#,
-        r#"{"xs":[{"a":1},{"b":[2]}]}"#,
-    );
-    let plan = scenario.plan(LEFT).with_override(
-        vec![
-            key("xs"),
-            PathComponent::Index(1),
-            key("b"),
-            PathComponent::Index(0),
-        ],
-        json!(9),
-    );
-    assert_eq!(scenario.applied(&plan), json!({"xs":[{"a":2},{"b":[9]}]}));
-}
-
-// ---------------------------------------------------------------------------
-// Canonical output
-// ---------------------------------------------------------------------------
-
-/// The result is canonical, whatever the selected parent's content looked like.
-///
-/// Content identity is the hash of the content string, so two revisions holding
-/// the same state with differently ordered members are different revisions.
-/// Applying an equivalent plan to either produces the *same* canonical content,
-/// and therefore the same identity.
-#[test]
-fn the_result_is_canonical_regardless_of_the_parents_representation() {
-    let sorted = Scenario::new(r#"{"a":1,"b":1}"#, r#"{"a":2,"b":1}"#, r#"{"a":1,"b":2}"#);
-    let unsorted = Scenario::new(r#"{"b":1,"a":1}"#, r#"{"b":1,"a":2}"#, r#"{"a":1,"b":2}"#);
-
-    assert_ne!(
-        sorted.left.id, unsorted.left.id,
-        "differently ordered content is a different revision"
-    );
-
-    let one = sorted.apply(&sorted.plan(LEFT)).unwrap();
-    let two = unsorted.apply(&unsorted.plan(LEFT)).unwrap();
-    assert_eq!(one, two, "both applications produce canonical content");
-    assert_eq!(one, r#"{"a":2,"b":1}"#);
-    assert_eq!(
-        StateId::compute(&one),
-        StateId::compute(&two),
-        "so they have the same content identity"
-    );
-}
-
-/// Repeated application produces the same bytes, and the result is a fixed
-/// point of the diff.
-#[test]
-fn application_is_repeatable_and_the_result_is_a_fixed_point() {
-    let scenario = Scenario::new(
-        r#"{"o":{"a":1},"xs":[1,2]}"#,
-        r#"{"o":{"a":2},"xs":[9,2]}"#,
-        r#"{"o":{"a":3},"xs":[1,8]}"#,
-    );
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![key("o"), key("a")], json!(5))
-        .with_override(vec![key("xs"), PathComponent::Index(1)], json!(8));
-
-    let first = scenario.apply(&plan).expect("applies");
-    for _ in 0..8 {
-        assert_eq!(scenario.apply(&plan).expect("applies"), first);
-    }
-
-    let result: Value = serde_json::from_str(&first).unwrap();
-    assert!(
-        SemanticDiff::compute(&result, &result).changes.is_empty(),
-        "the result does not differ from itself"
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Immutability
-// ---------------------------------------------------------------------------
-
-/// Applying a plan mutates nothing it was given.
-#[test]
-fn application_mutates_none_of_its_inputs() {
-    let scenario = Scenario::new(r#"{"o":{"a":1}}"#, r#"{"o":{"a":2}}"#, r#"{"o":{"a":3}}"#);
-    let plan = scenario
-        .plan(LEFT)
-        .with_override(vec![key("o"), key("a")], json!(9));
-
-    let before = (
-        serde_json::to_string(&scenario.base).unwrap(),
-        serde_json::to_string(&scenario.left).unwrap(),
-        serde_json::to_string(&scenario.right).unwrap(),
-        format!("{plan:?}"),
-    );
-
-    let result = reconcile(
-        &scenario.base,
-        &scenario.left,
-        &scenario.right,
-        &plan,
-        "reconciler".into(),
-    )
-    .expect("applies");
-
-    assert_eq!(serde_json::to_string(&scenario.base).unwrap(), before.0);
-    assert_eq!(serde_json::to_string(&scenario.left).unwrap(), before.1);
-    assert_eq!(serde_json::to_string(&scenario.right).unwrap(), before.2);
-    assert_eq!(format!("{plan:?}"), before.3);
-    assert_eq!(
-        result.materialized_state.content, r#"{"o":{"a":9}}"#,
-        "the result is newly materialized"
-    );
-    // And the result is a different revision from all three inputs.
-    for existing in [&scenario.base, &scenario.left, &scenario.right] {
-        assert_ne!(result.materialized_state.id, existing.id);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Materialization
-// ---------------------------------------------------------------------------
-
-/// The materialized revision uses the existing identity and provenance model.
-#[test]
-fn the_materialized_revision_uses_the_existing_model() {
-    let scenario = Scenario::new(r#"{"a":1}"#, r#"{"a":2}"#, r#"{"a":3}"#);
-
-    for (choice, expected_parent) in [(LEFT, &scenario.left), (RIGHT, &scenario.right)] {
-        let plan = scenario.plan(choice);
-        let result = reconcile(
-            &scenario.base,
-            &scenario.left,
-            &scenario.right,
-            &plan,
-            "reconciler".into(),
-        )
-        .expect("applies");
-        let revision = &result.materialized_state;
-
-        assert!(
-            revision.verify_integrity(),
-            "both identities match what they are computed from"
-        );
-        assert_eq!(
-            revision.content_id,
-            StateId::compute(&revision.content),
-            "no new content-identity algorithm"
-        );
-        assert_ne!(
-            revision.id, revision.content_id,
-            "the revision identity names the occurrence, not the state"
-        );
-        assert_eq!(
-            revision.parent_id.as_ref(),
-            Some(&expected_parent.id),
-            "the selected branch is the parent"
-        );
-        assert_eq!(revision.authority, "reconciler");
-        // The plan travels with the result, so the decision stays attached to
-        // the state it produced.
-        assert_eq!(result.plan.parent_choice, choice);
-    }
-}
-
-/// A materialized revision can be committed through the existing store, and
-/// nothing about branches moves.
-#[test]
-fn a_materialized_revision_commits_through_the_existing_store() {
-    let store = StateStore::new_volatile();
-    let base = store
-        .create("docs:1", r#"{"a":1,"b":1}"#.to_string(), "auth".into())
-        .expect("create");
-    let left = store
-        .commit(r#"{"a":2,"b":1}"#.to_string(), &base, "auth".into())
-        .expect("left");
-    let right = store
-        .commit(r#"{"a":1,"b":2}"#.to_string(), &base, "auth".into())
-        .expect("right");
-
-    let plan = ReconciliationPlan::new(left.id.clone(), right.id.clone(), base.id.clone(), LEFT)
-        .with_override(vec![key("b")], json!(2));
-
-    let result = reconcile(&base, &left, &right, &plan, "reconciler".into()).expect("applies");
-    let committed = store
-        .commit(
-            result.materialized_state.content.clone(),
-            &left,
-            "reconciler".into(),
-        )
-        .expect("commit");
-
-    assert_eq!(committed.content, r#"{"a":2,"b":2}"#);
-    assert_eq!(committed.id, result.materialized_state.id);
-
-    // Applying a plan disturbed nothing it started from: both source revisions
-    // are exactly as retrievable as before. There is no branch head to move,
-    // because the store keeps none.
-    assert_eq!(store.get(&left.id).unwrap().content, left.content);
-    assert_eq!(store.get(&right.id).unwrap().content, right.content);
-}
-
-// ---------------------------------------------------------------------------
-// Rejection
-// ---------------------------------------------------------------------------
-
-#[test]
-fn an_invalid_plan_is_rejected_rather_than_producing_state() {
-    let scenario = Scenario::new(r#"{"a":1}"#, r#"{"a":2}"#, r#"{"a":3}"#);
-
-    // A plan whose ids are empty does not reference three revisions.
-    let mut empty = scenario.plan(LEFT);
-    empty.base_id = StateId::from_hex(String::new());
-    assert_eq!(code(scenario.apply(&empty)), RECONCILE_PLAN_INVALID);
-
-    // A plan that names revisions other than the ones supplied.
-    let other = revision(r#"{"a":99}"#);
-    for (base, left, right) in [
-        (&other, &scenario.left, &scenario.right),
-        (&scenario.base, &other, &scenario.right),
-        (&scenario.base, &scenario.left, &other),
-    ] {
-        assert_eq!(
-            code(apply_reconciliation_plan(
-                base,
-                left,
-                right,
-                &scenario.plan(LEFT)
-            )),
-            RECONCILE_REVISION_MISMATCH
-        );
-    }
-
-    // Content that is not JSON. Classification reads such content as JSON null
-    // because it only describes; materializing a state from it would be
-    // producing arbitrary state, so this refuses.
-    let broken = Scenario::new("{}", "not json", "{}");
-    assert_eq!(
-        code(broken.apply(&broken.plan(LEFT))),
-        RECONCILE_CONTENT_UNPARSEABLE
-    );
-    // The branch that is not selected is not parsed, so it cannot fail the plan.
-    assert_eq!(broken.applied(&broken.plan(RIGHT)), json!({}));
-
-    // Override paths that name nothing assignable.
-    let scenario = Scenario::new(r#"{"o":{"a":1}}"#, r#"{"o":7}"#, r#"{"o":{"a":2}}"#);
-    for path in [
-        vec![key("o"), key("a")],          // `o` is a scalar in the left branch
-        vec![key("missing"), key("deep")], // the prefix does not resolve
-        vec![key("o"), PathComponent::Index(0)], // a scalar is not an array
-    ] {
-        let plan = scenario.plan(LEFT).with_override(path, json!(1));
-        assert_eq!(
-            code(scenario.apply(&plan)),
-            RECONCILE_OVERRIDE_UNADDRESSABLE
-        );
-    }
-}
-
-/// Application does not require every conflict to have an override, and says so.
-///
-/// `unresolved_conflicts` reports which conflicting paths a plan does not
-/// address, so a caller that wants each one decided individually can require it
-/// to be empty. Application itself does not: leaving a conflict unaddressed
-/// resolves it to the selected parent's value, and selecting that parent is
-/// itself an explicit decision.
-#[test]
-fn unresolved_conflicts_are_reported_but_not_required() {
-    let scenario = Scenario::new(r#"{"a":1,"b":1}"#, r#"{"a":2,"b":2}"#, r#"{"a":3,"b":3}"#);
-    let classification = scenario.classification();
-    assert_eq!(classification.overall, ConflictClass::Conflict);
-
-    let bare = scenario.plan(LEFT);
-    let unresolved = bare.unresolved_conflicts(&classification);
-    assert_eq!(unresolved.len(), 2, "neither conflict is addressed");
-
-    // Applying anyway is allowed: the conflicts resolve to the chosen branch.
-    assert_eq!(scenario.applied(&bare), json!({"a":2,"b":2}));
-
-    let partly = scenario.plan(LEFT).with_override(vec![key("a")], json!(9));
-    assert_eq!(partly.unresolved_conflicts(&classification).len(), 1);
-
-    let fully = scenario
-        .plan(LEFT)
-        .with_override(vec![key("a")], json!(9))
-        .with_override(vec![key("b")], json!(8));
-    assert!(fully.unresolved_conflicts(&classification).is_empty());
-    assert_eq!(scenario.applied(&fully), json!({"a":9,"b":8}));
-}
-
-// ---------------------------------------------------------------------------
-// The overlap regression from the corrected classifier
-// ---------------------------------------------------------------------------
-
-/// The ancestor/descendant case the corrected classifier now flags.
-///
-/// ```text
-/// base:  {"o":{"a":1}}
-/// left:  {"o":7}
-/// right: {"o":{"a":2}}
-/// ```
-///
-/// The two changes cannot both be applied. The classifier says so, and
-/// application does not quietly merge them into something that keeps both: the
-/// result is exactly the branch the plan chose, or exactly the override it
-/// supplied.
-#[test]
-fn an_overlapping_conflict_is_resolved_only_as_the_plan_says() {
-    let scenario = Scenario::new(r#"{"o":{"a":1}}"#, r#"{"o":7}"#, r#"{"o":{"a":2}}"#);
-
-    let classification = scenario.classification();
-    assert_eq!(
-        classification.overall,
-        ConflictClass::Conflict,
-        "the corrected classifier identifies the overlap"
-    );
-
-    // Choosing left takes the scalar, whole.
-    assert_eq!(scenario.applied(&scenario.plan(LEFT)), json!({"o":7}));
-    // Choosing right takes the object, whole.
-    assert_eq!(
-        scenario.applied(&scenario.plan(RIGHT)),
-        json!({"o":{"a":2}})
-    );
-    // An explicit override takes exactly what it says.
-    let explicit = scenario
-        .plan(LEFT)
-        .with_override(vec![key("o")], json!({"a":3}));
-    assert_eq!(scenario.applied(&explicit), json!({"o":{"a":3}}));
-
-    // Nothing produces a state carrying both the scalar and the member: these
-    // structures cannot be combined, and application does not try.
-    for plan in [scenario.plan(LEFT), scenario.plan(RIGHT), explicit] {
-        let result = scenario.applied(&plan);
-        let o = &result["o"];
-        assert!(
-            o.is_number() ^ o.is_object(),
-            "the result is one shape or the other, never an invented combination"
-        );
-    }
-}
-
-// ---------------------------------------------------------------------------
-// End to end
-// ---------------------------------------------------------------------------
-
-/// The whole causal path, with independent changes and one real conflict.
-///
-/// ```text
-/// base → left, right → SemanticDiff → ConflictClassification
-///      → explicit ReconciliationPlan → apply → result revision
-/// ```
-#[test]
-fn the_state_model_reconciles_an_explicit_decision_end_to_end() {
-    let store = StateStore::new_volatile();
-
-    // Two branches: each edits a different member independently, and both edit
-    // `shared` differently, which is the conflict.
-    let base = store
-        .create(
-            "docs:1",
-            r#"{"only_left":1,"only_right":1,"shared":1,"untouched":"keep"}"#.to_string(),
-            "auth".into(),
-        )
-        .expect("create");
-    let left = store
-        .commit(
-            r#"{"only_left":2,"only_right":1,"shared":10,"untouched":"keep"}"#.to_string(),
-            &base,
-            "alice".into(),
-        )
-        .expect("left");
-    let right = store
-        .commit(
-            r#"{"only_left":1,"only_right":2,"shared":20,"untouched":"keep"}"#.to_string(),
-            &base,
-            "bob".into(),
-        )
-        .expect("right");
-
-    // The diffs are what classification is defined over.
-    let base_value: Value = serde_json::from_str(&base.content).unwrap();
-    let left_value: Value = serde_json::from_str(&left.content).unwrap();
-    let right_value: Value = serde_json::from_str(&right.content).unwrap();
-    assert_eq!(
-        SemanticDiff::compute(&base_value, &left_value)
-            .changes
-            .len(),
-        2
-    );
-    assert_eq!(
-        SemanticDiff::compute(&base_value, &right_value)
-            .changes
-            .len(),
-        2
-    );
-
-    // Classification separates what can coexist from what cannot.
-    let classification = ConflictClassification::classify(&base, &left, &right);
-    assert_eq!(classification.overall, ConflictClass::Conflict);
-    let conflicting: Vec<_> = classification
-        .path_conflicts
-        .iter()
-        .filter(|entry| entry.classification == ConflictClass::Conflict)
-        .collect();
-    assert_eq!(conflicting.len(), 1, "exactly one path conflicts");
-    assert_eq!(conflicting[0].path, vec![key("shared")]);
-    assert_eq!(conflicting[0].base_value, Some(json!(1)));
-    assert_eq!(conflicting[0].left_value, Some(json!(10)));
-    assert_eq!(conflicting[0].right_value, Some(json!(20)));
-
-    // The caller decides: take the left branch, keep the right branch's
-    // independent change, and resolve the conflict to a third value neither
-    // branch proposed.
-    let plan = ReconciliationPlan::new(left.id.clone(), right.id.clone(), base.id.clone(), LEFT)
-        .with_override(vec![key("only_right")], json!(2))
-        .with_override(vec![key("shared")], json!(99));
-    assert!(
-        plan.unresolved_conflicts(&classification).is_empty(),
-        "every conflict is explicitly addressed"
-    );
-
-    let before = (
-        base.content.clone(),
-        left.content.clone(),
-        right.content.clone(),
-    );
-    let result = reconcile(&base, &left, &right, &plan, "reconciler".into()).expect("applies");
-    let reconciled: Value = serde_json::from_str(&result.materialized_state.content).unwrap();
-
-    // 1. the independent change on the selected branch survives
-    assert_eq!(reconciled["only_left"], json!(2));
-    // 2. the independent change on the other branch survives, because the plan
-    //    asked for it
-    assert_eq!(reconciled["only_right"], json!(2));
-    // 3. the chosen resolution survives, and neither branch's value does
-    assert_eq!(reconciled["shared"], json!(99));
-    assert_ne!(reconciled["shared"], json!(10));
-    assert_ne!(reconciled["shared"], json!(20));
-    // 4. unrelated state is preserved
-    assert_eq!(reconciled["untouched"], json!("keep"));
-    // 5. the result is canonical
-    assert_eq!(
-        result.materialized_state.content,
-        serde_json::to_string(&reconciled).unwrap()
-    );
-    assert!(result.materialized_state.verify_integrity());
-    // 6. the inputs are unchanged
-    assert_eq!(
-        (
-            base.content.clone(),
-            left.content.clone(),
-            right.content.clone()
-        ),
-        before
-    );
-
-    // The result is a revision like any other, committable through the store.
-    let committed = store
-        .commit(
-            result.materialized_state.content.clone(),
-            &left,
-            "reconciler".into(),
-        )
-        .expect("commit");
-    assert_eq!(committed.id, result.materialized_state.id);
-    assert_eq!(committed.parent_id.as_ref(), Some(&left.id));
-
-    // And the reconciled state has no remaining difference from itself.
-    let final_value: Value = serde_json::from_str(&committed.content).unwrap();
-    assert!(SemanticDiff::compute(&final_value, &reconciled)
-        .changes
-        .is_empty());
-}
-
-// ---------------------------------------------------------------------------
-// A recorded limitation of the plan type
-// ---------------------------------------------------------------------------
-
-/// A plan carrying overrides cannot be serialized to JSON.
-///
-/// `path_overrides` is keyed by `Vec<PathComponent>`, and JSON object keys must
-/// be strings, so `serde_json` refuses the map the moment it holds an entry.
-/// The type derives `Serialize`, which makes this look supported; it is not.
-///
-/// This is recorded, not fixed. A plan is presently constructed and applied
-/// in-process, which this PR is what establishes; nothing transmits one. Giving
-/// the path a string encoding would be inventing a second path syntax — exactly
-/// the flattened rendering the conflict work went out of its way to avoid —
-/// and it is not needed by any caller that exists. The test exists so that the
-/// day a caller does need to transmit a plan, the limitation is already stated
-/// rather than discovered.
-#[test]
-fn a_plan_with_overrides_is_not_json_serializable() {
-    let scenario = Scenario::new(r#"{"a":1}"#, r#"{"a":2}"#, r#"{"a":3}"#);
-
-    // Without overrides the plan serializes.
-    let plain = scenario.plan(LEFT);
-    assert!(serde_json::to_string(&plain).is_ok());
-
-    // With one, it does not, and application is unaffected either way.
-    let with_override = plain.clone().with_override(vec![key("a")], json!(9));
-    let error = serde_json::to_string(&with_override).expect_err("non-string key");
-    assert!(
-        error.to_string().contains("key must be a string"),
-        "unexpected error: {error}"
-    );
-    assert_eq!(scenario.apply(&with_override).unwrap(), r#"{"a":9}"#);
-}