@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,123 +0,0 @@
-//! Evidence for generalized version-control semantics over data representations.
-//!
-//! This test suite adds no new capability. It checks that the same revision
-//! machinery behaves the same for source-shaped, artifact-shaped, and
-//! application-shaped state.
-
-use feltdb::{
-    reconcile, ConflictClass, ConflictClassification, ReconciliationPlan, Relationship, SemanticDiff,
-    StateStore, StateTopology,
-};
-use serde_json::{json, Value};
-
-struct Scenario {
-    resource: &'static str,
-    base: Value,
-    left: Value,
-    right: Value,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-struct Outcome {
-    relationship: Relationship,
-    has_lca: bool,
-    left_changes: usize,
-    right_changes: usize,
-    overall: ConflictClass,
-    path_conflicts: usize,
-}
-
-fn run_scenario(scenario: Scenario) -> Outcome {
-    let store = StateStore::new_volatile();
-    let base = store
-        .create(scenario.resource, scenario.base.to_string(), "audit".to_string())
-        .expect("base");
-    let left = store
-        .commit(scenario.left.to_string(), &base, "audit".to_string())
-        .expect("left");
-    let right = store
-        .commit(scenario.right.to_string(), &base, "audit".to_string())
-        .expect("right");
-
-    let mut topology = StateTopology::new();
-    for revision in [&base, &left, &right] {
-        topology.add_revision(revision.clone());
-    }
-
-    let left_diff = SemanticDiff::compute(&scenario.base, &scenario.left);
-    let right_diff = SemanticDiff::compute(&scenario.base, &scenario.right);
-    let classification = ConflictClassification::classify(&base, &left, &right);
-
-    let plan = ReconciliationPlan::new(left.id.clone(), right.id.clone(), base.id.clone(), true);
-    let merged = reconcile(&base, &left, &right, &plan, "reconciler".to_string()).expect("merge");
-    assert_eq!(
-        merged.materialized_state.parent_id.as_ref(),
-        Some(&left.id),
-        "the selected parent is honored independent of representation"
-    );
-
-    Outcome {
-        relationship: topology.relationship(&left.id, &right.id),
-        has_lca: topology.common_ancestor(&left.id, &right.id).is_some(),
-        left_changes: left_diff.changes.len(),
-        right_changes: right_diff.changes.len(),
-        overall: classification.overall,
-        path_conflicts: classification.path_conflicts.len(),
-    }
-}
-
-#[test]
-fn source_artifact_and_application_states_share_the_same_version_control_behavior() {
-    let source = run_scenario(Scenario {
-        resource: "source:src/main.rs",
-        base: json!({"body":"fn main() {}","digest":"h1"}),
-        left: json!({"body":"fn main() { println!(\"ok\"); }","digest":"h1"}),
-        right: json!({"body":"fn main() {}","digest":"h2"}),
-    });
-
-    let artifact = run_scenario(Scenario {
-        resource: "artifact:dist/app.wasm",
-        base: json!({"payload":"AA==","digest":"h1"}),
-        left: json!({"payload":"AQ==","digest":"h1"}),
-        right: json!({"payload":"AA==","digest":"h2"}),
-    });
-
-    let application = run_scenario(Scenario {
-        resource: "application:tasks/1",
-        base: json!({"state":"open","digest":"h1"}),
-        left: json!({"state":"closed","digest":"h1"}),
-        right: json!({"state":"open","digest":"h2"}),
-    });
-
-    let expected = Outcome {
-        relationship: Relationship::Diverged,
-        has_lca: true,
-        left_changes: 1,
-        right_changes: 1,
-        overall: ConflictClass::Independent,
-        path_conflicts: 2,
-    };
-
-    assert_eq!(source, expected);
-    assert_eq!(artifact, expected);
-    assert_eq!(application, expected);
-}
-
-#[test]
-fn mutating_resource_identity_changes_ids_not_version_control_semantics() {
-    let source_namespace = run_scenario(Scenario {
-        resource: "source:module/alpha",
-        base: json!({"value":1,"tag":"stable"}),
-        left: json!({"value":2,"tag":"stable"}),
-        right: json!({"value":1,"tag":"candidate"}),
-    });
-
-    let artifact_namespace = run_scenario(Scenario {
-        resource: "artifact:module/alpha",
-        base: json!({"value":1,"tag":"stable"}),
-        left: json!({"value":2,"tag":"stable"}),
-        right: json!({"value":1,"tag":"candidate"}),
-    });
-
-    assert_eq!(source_namespace, artifact_namespace);
-}

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

@@ -1,299 +0,0 @@
-use feltdb::{
-    MaterializationError, MaterializationProjection, PathComponent, RefError, StateId, StateStore,
-};
-use feltdb::state_model::GarbageCollectionReport;
-use serde_json::json;
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use tempfile::TempDir;
-
-fn durable_store(name: &str) -> (TempDir, StateStore) {
-    let directory = TempDir::new().unwrap();
-    let db = Arc::new(feltdb::FeltDb::open(directory.path().join(name)).unwrap());
-    let store = StateStore::with_feltdb(db).unwrap();
-    (directory, store)
-}
-
-fn projection(paths: Vec<Vec<PathComponent>>) -> MaterializationProjection {
-    MaterializationProjection::select(paths)
-}
-
-#[test]
-fn refs_cas_enforcement_rejects_stale_moves() {
-    let store = StateStore::new_volatile();
-    let a = store
-        .create("docs:1", json!({"n": 1}).to_string(), "auth".into())
-        .unwrap();
-    let b = store
-        .commit(json!({"n": 2}).to_string(), &a, "auth".into())
-        .unwrap();
-    store
-        .create_ref("refs", "main", a.id.clone(), "auth".into(), BTreeMap::new())
-        .unwrap();
-
-    store
-        .compare_and_swap_ref("refs", "main", 1, b.id.clone(), "auth".into(), None)
-        .unwrap();
-    let stale = store.compare_and_swap_ref("refs", "main", 1, a.id.clone(), "auth".into(), None);
-    assert!(matches!(
-        stale,
-        Err(RefError::VersionConflict {
-            expected: 1,
-            current: 2
-        })
-    ));
-}
-
-#[test]
-fn refs_persist_target_and_versions_across_restart() {
-    let (directory, store) = durable_store("refs.log");
-    let a = store
-        .create("docs:1", json!({"n": 1}).to_string(), "auth".into())
-        .unwrap();
-    let b = store
-        .commit(json!({"n": 2}).to_string(), &a, "auth".into())
-        .unwrap();
-
-    store
-        .create_ref("refs", "main", a.id.clone(), "auth".into(), BTreeMap::new())
-        .unwrap();
-    let moved = store.move_ref("refs", "main", b.id.clone(), "auth2".into()).unwrap();
-    assert_eq!(moved.target, b.id);
-    assert_eq!(moved.version, 2);
-
-    let reopened = StateStore::with_feltdb(Arc::new(
-        feltdb::FeltDb::open(directory.path().join("refs.log")).unwrap(),
-    ))
-    .unwrap();
-    let persisted = reopened.get_ref("refs", "main").unwrap();
-    assert_eq!(persisted.target, moved.target);
-    assert_eq!(persisted.version, moved.version);
-}
-
-#[test]
-fn refs_namespace_isolation_deletion_and_enumeration() {
-    let store = StateStore::new_volatile();
-    let revision = store
-        .create("docs:1", json!({"n": 1}).to_string(), "auth".into())
-        .unwrap();
-
-    store
-        .create_ref("refs", "main", revision.id.clone(), "auth".into(), BTreeMap::new())
-        .unwrap();
-    store
-        .create_ref("tags", "main", revision.id.clone(), "auth".into(), BTreeMap::new())
-        .unwrap();
-
-    let refs_all = store.list_refs(None);
-    assert_eq!(refs_all.len(), 2);
-    assert_eq!(store.list_refs(Some("refs")).len(), 1);
-    assert_eq!(store.list_refs(Some("tags")).len(), 1);
-
-    store.delete_ref("tags", "main", Some(1)).unwrap();
-    assert!(store.get_ref("tags", "main").is_none());
-    assert!(store.get_ref("refs", "main").is_some());
-}
-
-#[test]
-fn materialization_projection_filters_revision_selection_and_nested_paths() {
-    let store = StateStore::new_volatile();
-    let base = store
-        .create(
-            "source:file",
-            json!({"tree":{"src":{"lib.rs":"v1","main.rs":"m1"}},"meta":{"lang":"rust"}})
-                .to_string(),
-            "auth".into(),
-        )
-        .unwrap();
-    let head = store
-        .commit(
-            json!({"tree":{"src":{"lib.rs":"v2","main.rs":"m1"}},"meta":{"lang":"rust"}})
-                .to_string(),
-            &base,
-            "auth".into(),
-        )
-        .unwrap();
-
-    let view = store
-        .materialize(
-            &head.id,
-            &projection(vec![
-                vec![PathComponent::Key("tree".into()), PathComponent::Key("src".into()), PathComponent::Key("lib.rs".into())],
-            ]),
-        )
-        .unwrap();
-    assert_eq!(view, json!({"tree":{"src":{"lib.rs":"v2"}}}));
-
-    let base_view = store
-        .materialize(
-            &base.id,
-            &projection(vec![
-                vec![PathComponent::Key("tree".into()), PathComponent::Key("src".into()), PathComponent::Key("lib.rs".into())],
-            ]),
-        )
-        .unwrap();
-    assert_eq!(base_view, json!({"tree":{"src":{"lib.rs":"v1"}}}));
-}
-
-#[test]
-fn materialization_missing_paths_and_deterministic_output_are_enforced() {
-    let store = StateStore::new_volatile();
-    let revision = store
-        .create(
-            "artifact:item",
-            json!({"manifest":{"digest":"abc","size":7},"chunks":[{"id":1},{"id":2}]}).to_string(),
-            "auth".into(),
-        )
-        .unwrap();
-
-    let missing = store.materialize(
-        &revision.id,
-        &projection(vec![vec![
-            PathComponent::Key("manifest".into()),
-            PathComponent::Key("missing".into()),
-        ]]),
-    );
-    assert!(matches!(missing, Err(MaterializationError::MissingPath(_))));
-
-    let first = store
-        .materialize(
-            &revision.id,
-            &projection(vec![
-                vec![PathComponent::Key("manifest".into()), PathComponent::Key("size".into())],
-                vec![PathComponent::Key("chunks".into()), PathComponent::Index(1)],
-            ]),
-        )
-        .unwrap();
-    let second = store
-        .materialize(
-            &revision.id,
-            &projection(vec![
-                vec![PathComponent::Key("chunks".into()), PathComponent::Index(1)],
-                vec![PathComponent::Key("manifest".into()), PathComponent::Key("size".into())],
-            ]),
-        )
-        .unwrap();
-    assert_eq!(first, second);
-}
-
-fn setup_gc_graph(store: &StateStore) -> (StateId, StateId, StateId, StateId) {
-    let a = store
-        .create("graph:r", json!({"node":"A"}).to_string(), "auth".into())
-        .unwrap();
-    let b = store
-        .commit(json!({"node":"B"}).to_string(), &a, "auth".into())
-        .unwrap();
-    let c = store
-        .commit(json!({"node":"C"}).to_string(), &b, "auth".into())
-        .unwrap();
-    let d = store
-        .commit(json!({"node":"D"}).to_string(), &b, "auth".into())
-        .unwrap();
-    (a.id, b.id, c.id, d.id)
-}
-
-fn collect(store: &StateStore) -> GarbageCollectionReport {
-    store.collect_unreachable().unwrap()
-}
-
-#[test]
-fn gc_root_discovery_and_unreachable_collection() {
-    let store = StateStore::new_volatile();
-    let (_a, _b, _c, _d) = setup_gc_graph(&store);
-    let report = collect(&store);
-    // Roots are refs, each resource's latest revisions, and anything younger
-    // than the grace period (adrs/state-ref-authority-and-safe-reclamation.md,
-    // option A). Before that decision this test asserted that a store with no
-    // refs collected all four revisions, which is the history loss the
-    // decision removes. Collection of a stale fork is covered, with an explicit
-    // clock, by `state_model::tests::gc_keeps_latest_revisions_refs_and_all_their_ancestors`.
-    assert_eq!(report.roots.len(), 0, "no refs");
-    assert_eq!(report.reachable_revisions.len(), 4);
-    assert_eq!(report.reachable_objects.len(), 4);
-    assert!(report.collected_revisions.is_empty());
-    assert!(report.collected_objects.is_empty());
-}
-
-#[test]
-fn gc_parent_and_content_traversal_preserves_shared_history() {
-    let store = StateStore::new_volatile();
-    let (a, b, c, d) = setup_gc_graph(&store);
-    store
-        .create_ref("refs", "c", c.clone(), "auth".into(), BTreeMap::new())
-        .unwrap();
-    store
-        .create_ref("refs", "d", d.clone(), "auth".into(), BTreeMap::new())
-        .unwrap();
-
-    let keep_all = collect(&store);
-    assert!(keep_all.collected_revisions.is_empty());
-
-    // Shared history is reached through both refs.
-    for ancestor in [&a, &b] {
-        assert!(keep_all.reachable_revisions.contains(ancestor));
-    }
-
-    // Deleting d's ref no longer makes d collectable: d ties c at the highest
-    // sequence, so it is one of the resource's latest revisions, and it is
-    // younger than the grace period. (Before option A this asserted that d was
-    // collected.) Its ancestors are still reached, and nothing is lost.
-    store.delete_ref("refs", "d", Some(1)).unwrap();
-    let after_delete = collect(&store);
-    assert!(after_delete.collected_revisions.is_empty());
-    assert!(after_delete.collected_objects.is_empty());
-    for kept in [&a, &b, &c, &d] {
-        assert!(store.exists(kept));
-        assert!(after_delete.reachable_revisions.contains(kept));
-    }
-}
-
-#[test]
-fn substrate_is_domain_neutral_for_refs_materialization_and_gc() {
-    let store = StateStore::new_volatile();
-
-    let scenarios = vec![
-        (
-            "source:module",
-            json!({"tree":{"src":{"lib.rs":"v1","main.rs":"v1"}}}),
-            vec![PathComponent::Key("tree".into()), PathComponent::Key("src".into()), PathComponent::Key("lib.rs".into())],
-        ),
-        (
-            "artifact:bundle",
-            json!({"manifest":{"digest":"h1"},"payload":{"chunks":["a","b"]}}),
-            vec![PathComponent::Key("manifest".into()), PathComponent::Key("digest".into())],
-        ),
-        (
-            "application:state",
-            json!({"entities":{"tasks":{"1":{"status":"open"}}},"meta":{"v":1}}),
-            vec![PathComponent::Key("entities".into()), PathComponent::Key("tasks".into()), PathComponent::Key("1".into()), PathComponent::Key("status".into())],
-        ),
-    ];
-
-    for (resource, content, path) in scenarios {
-        let rev = store
-            .create(resource, content.to_string(), "auth".into())
-            .unwrap();
-        store
-            .create_ref("heads", resource, rev.id.clone(), "auth".into(), BTreeMap::new())
-            .unwrap();
-        let view = store
-            .materialize(&rev.id, &projection(vec![path]))
-            .unwrap();
-        assert!(view.is_object());
-    }
-
-    let keep = collect(&store);
-    assert_eq!(keep.collected_revisions.len(), 0);
-
-    for reference in store.list_refs(Some("heads")) {
-        store
-            .delete_ref("heads", &reference.name, Some(reference.version))
-            .unwrap();
-    }
-    // Without their refs each resource's only revision is still its latest, so
-    // nothing is collected. (Before option A this asserted all three were.)
-    let collected = collect(&store);
-    assert!(collected.collected_revisions.is_empty());
-    assert!(collected.collected_objects.is_empty());
-    assert_eq!(collected.reachable_revisions.len(), 3);
-}

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

@@ -1,69 +0,0 @@
-use std::process::Command;
-
-use feltdb::{AtomicMutation, FeltDb};
-use serde_json::json;
-use tempfile::TempDir;
-
-const CHILD_ENV: &str = "FELTDB_OWNERSHIP_CHILD";
-const PATH_ENV: &str = "FELTDB_OWNERSHIP_PATH";
-const EXPECT_LOCKED_ENV: &str = "FELTDB_EXPECT_LOCKED";
-
-#[test]
-fn ownership_child() {
-    if std::env::var_os(CHILD_ENV).is_none() {
-        return;
-    }
-    let path = std::env::var(PATH_ENV).unwrap();
-    let expect_locked = std::env::var_os(EXPECT_LOCKED_ENV).is_some();
-    match FeltDb::open(path) {
-        Ok(database) => {
-            assert!(!expect_locked, "a second owner opened the database");
-            let mutation = AtomicMutation {
-                capability: "probe".into(),
-                key: "probe:child".into(),
-                value: Some(json!({ "owner": "child" })),
-            };
-            database
-                .apply_atomic_transaction("child", None, &[], &[mutation], None)
-                .unwrap();
-        }
-        Err(error) => {
-            assert!(expect_locked, "an unowned database failed to open: {error}");
-            assert!(error.to_string().contains("already owned"));
-        }
-    }
-}
-
-fn child(path: &std::path::Path, expect_locked: bool) -> std::process::ExitStatus {
-    let mut command = Command::new(std::env::current_exe().unwrap());
-    command
-        .arg("--exact")
-        .arg("ownership_child")
-        .arg("--nocapture")
-        .env(CHILD_ENV, "1")
-        .env(PATH_ENV, path);
-    if expect_locked {
-        command.env(EXPECT_LOCKED_ENV, "1");
-    }
-    command.status().unwrap()
-}
-
-#[test]
-fn another_process_cannot_read_write_or_transact_while_owned() {
-    let directory = TempDir::new().unwrap();
-    let path = directory.path().join("shared.db");
-    let _owner = FeltDb::open(&path).unwrap();
-    assert!(child(&path, true).success());
-}
-
-#[test]
-fn ownership_is_released_when_the_process_exits() {
-    let directory = TempDir::new().unwrap();
-    let path = directory.path().join("shared.db");
-    assert!(child(&path, false).success());
-    let database = FeltDb::open(path).unwrap();
-    assert_eq!(
-        database.get::<serde_json::Value>("probe:child").unwrap(),
-        Some(json!({ "owner": "child" }))
-    );
-}

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

@@ -1,191 +0,0 @@
-//! The managed incident, composed.
-//!
-//! The four remediations each have their own contract: `compaction_stall_contract`
-//! covers the deferred rewrite, `bounded_read_contract` covers scoped reads, and
-//! the server crate's `admission_tests` cover the refusal. Every one of them
-//! exercises its fix in isolation, on an idle database.
-//!
-//! The incident was not any one of them in isolation. It was their composition:
-//! a populated collection, a timer firing compaction into the single lock that
-//! serializes every read and write, and scoped requests arriving throughout.
-//! A database that satisfies each contract separately can still fail the shape
-//! that actually happened, so the shape gets its own test.
-//!
-//! # What this file does not establish
-//!
-//! **It does not measure latency, and it does not prove the incident cannot
-//! recur.** No assertion here bounds how long a read waits, and every read
-//! still queues behind the same mutex. That is claim `M6`, and it is recorded
-//! in the certification matrix as `Unproven` precisely because a test like this
-//! one is not evidence for it. A timing assertion added here would either be
-//! flaky or be tuned until it passed, and both are worse than an honest gap.
-//!
-//! What it does establish is that under the composed load, the timer does not
-//! rewrite, scoped reads stay bounded, and no read observes a torn or missing
-//! database.
-
-use feltdb::{CompactionOutcome, CompactionPolicy, FeltDb};
-use serde_json::json;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::Arc;
-use tempfile::TempDir;
-
-const ROWS: usize = 800;
-
-/// A database shaped like the affected instance: one large collection, every
-/// operation acknowledged so a compaction always has work to do.
-fn incident_shaped() -> (TempDir, Arc<FeltDb>) {
-    let directory = TempDir::new().unwrap();
-    let db = Arc::new(FeltDb::open(directory.path().join("incident.log")).unwrap());
-    db.set_compaction_policy(CompactionPolicy::default());
-
-    for index in 0..ROWS {
-        db.insert(
-            &format!("docs:{index:05}"),
-            json!({ "n": index, "body": "x".repeat(200) }),
-        )
-        .unwrap();
-    }
-    let versions = db.operation_versions().unwrap();
-    db.acknowledge_peer_versions("peer-1".to_string(), versions)
-        .unwrap();
-
-    (directory, db)
-}
-
-/// **Scoped reads stay correct and bounded while the compaction timer runs.**
-///
-/// The compacting thread calls the same entry point the server's timer calls,
-/// continuously, for the whole run. The reading thread does what the handlers
-/// now do: a keyed lookup and a limited search, never a materializing scan.
-///
-/// Three properties are asserted, and each one is a way the incident could
-/// return:
-///
-/// 1. every read returns the right answer — a compaction running concurrently
-///    never exposes a partially pruned database;
-/// 2. every bounded search visits exactly its limit — the amplifier is still
-///    absent under load, not just on an idle database;
-/// 3. the timer performs no durable rewrite — the expensive half stays deferred
-///    when the policy says it should, and does not creep back in because
-///    something else about the workload changed.
-#[test]
-fn scoped_reads_stay_correct_and_bounded_while_compaction_runs() {
-    let (_directory, db) = incident_shaped();
-
-    let stop = Arc::new(AtomicBool::new(false));
-    let rewrites = Arc::new(AtomicUsize::new(0));
-    let ticks = Arc::new(AtomicUsize::new(0));
-
-    let compactor = {
-        let db = db.clone();
-        let stop = stop.clone();
-        let rewrites = rewrites.clone();
-        let ticks = ticks.clone();
-        std::thread::spawn(move || {
-            while !stop.load(Ordering::Relaxed) {
-                let outcome = db
-                    .maybe_compact_operation_log(&["peer-1".to_string()])
-                    .expect("a timer-driven compaction does not fail");
-                ticks.fetch_add(1, Ordering::Relaxed);
-                if matches!(outcome, CompactionOutcome::Rewritten { .. }) {
-                    rewrites.fetch_add(1, Ordering::Relaxed);
-                }
-            }
-        })
-    };
-
-    for round in 0..200 {
-        let key = format!("docs:{:05}", round % ROWS);
-        let row = db
-            .get_collection_record("docs", &key)
-            .unwrap()
-            .unwrap_or_else(|| panic!("{key} is readable while compaction runs"));
-        assert_eq!(row.value["n"], json!(round % ROWS));
-
-        let visited = AtomicUsize::new(0);
-        let matched = db
-            .query_collection("docs", Some(10), |row| {
-                visited.fetch_add(1, Ordering::Relaxed);
-                row.value["body"].is_string()
-            })
-            .unwrap();
-        assert_eq!(matched.len(), 10, "the limit is honoured under load");
-        assert_eq!(
-            visited.load(Ordering::Relaxed),
-            10,
-            "and the search did not walk the collection"
-        );
-    }
-
-    stop.store(true, Ordering::Relaxed);
-    compactor.join().unwrap();
-
-    assert!(
-        ticks.load(Ordering::Relaxed) > 0,
-        "the compaction thread actually ran"
-    );
-    assert_eq!(
-        rewrites.load(Ordering::Relaxed),
-        0,
-        "the timer rewrote the durable log during the run; the deferred-rewrite \
-         fix does not hold under the composed workload"
-    );
-}
-
-/// **The composed run leaves the database intact.**
-///
-/// The incident's worst plausible outcome was not slowness, it was a database
-/// damaged by a rewrite interleaved with traffic. After the concurrent run the
-/// full collection is still present, still correct, and still there after a
-/// reopen — including once a rewrite is forced to happen.
-#[test]
-fn a_concurrent_compaction_leaves_the_database_intact() {
-    let directory = TempDir::new().unwrap();
-    let path = directory.path().join("intact.log");
-    let db = Arc::new(FeltDb::open(&path).unwrap());
-    db.set_compaction_policy(CompactionPolicy::default());
-
-    for index in 0..ROWS {
-        db.insert(&format!("docs:{index:05}"), json!({ "n": index }))
-            .unwrap();
-    }
-    let versions = db.operation_versions().unwrap();
-    db.acknowledge_peer_versions("peer-1".to_string(), versions)
-        .unwrap();
-
-    let stop = Arc::new(AtomicBool::new(false));
-    let compactor = {
-        let db = db.clone();
-        let stop = stop.clone();
-        std::thread::spawn(move || {
-            while !stop.load(Ordering::Relaxed) {
-                db.maybe_compact_operation_log(&["peer-1".to_string()])
-                    .unwrap();
-            }
-        })
-    };
-
-    for index in ROWS..ROWS + 200 {
-        db.insert(&format!("docs:{index:05}"), json!({ "n": index }))
-            .unwrap();
-    }
-
-    stop.store(true, Ordering::Relaxed);
-    compactor.join().unwrap();
-
-    // An explicit compaction still rewrites — the deferral is a policy, not a
-    // disablement — and the rewrite happens over a database that concurrent
-    // traffic has just been mutating.
-    db.compact_operation_log(&["peer-1".to_string()]).unwrap();
-    drop(db);
-
-    let reopened = FeltDb::open(&path).unwrap();
-    for index in 0..ROWS + 200 {
-        let value: serde_json::Value = reopened
-            .get(&format!("docs:{index:05}"))
-            .unwrap()
-            .unwrap_or_else(|| panic!("docs:{index:05} survived the composed run"));
-        assert_eq!(value["n"], json!(index));
-    }
-}