@lix-js/sdk 0.6.0-preview.2 → 0.6.0-preview.3

package/dist-engine-src/src/storage_bench.rs

@@ -1,29 +1,53 @@
 use crate::binary_cas::{BinaryCasContext, BlobHash, BlobWrite};
-use crate::changelog::{
-    canonicalize_materialized_change, CanonicalChange, ChangelogContext, ChangelogScanRequest,
-    MaterializedCanonicalChange,
+use crate::catalog::CatalogContext;
+use crate::commit_graph::CommitGraphChangeHistoryRequest;
+use crate::commit_store::{
+    Change, ChangeScanRequest, CommitDraftRef, CommitStoreContext, MaterializedChange,
 };
 use crate::entity_identity::EntityIdentity;
-use crate::entity_identity::EntityIdentityPart;
 use crate::json_store::context::JsonStoreContext;
-use crate::json_store::types::{JsonProjectionPath, JsonRef};
+use crate::json_store::types::{
+    JsonLoadRequestRef, JsonProjectionLoadRequestRef, JsonProjectionPath, JsonReadScopeRef,
+    JsonRef, JsonWritePlacementRef, NormalizedJsonRef,
+};
+use crate::live_state::LiveStateContext;
+use crate::session::SessionMode;
 use crate::storage::{
     KvGetGroup, KvGetRequest, KvScanRange, KvScanRequest, KvWriteBatch, StorageContext,
     StorageWriteSet,
 };
 use crate::tracked_state::{
-    TrackedStateContext, TrackedStateDiffRequest, TrackedStateFilter, TrackedStateProjection,
-    TrackedStateRow, TrackedStateRowRequest, TrackedStateScanRequest,
+    MaterializedTrackedStateRow, TrackedStateContext, TrackedStateDeltaRef,
+    TrackedStateDiffRequest, TrackedStateFilter, TrackedStateProjection, TrackedStateRowRequest,
+    TrackedStateScanRequest,
+};
+use crate::transaction::open_transaction;
+use crate::transaction::types::{
+    TransactionJson, TransactionWrite, TransactionWriteMode, TransactionWriteRow,
 };
 use crate::untracked_state::{
-    canonicalize_materialized_row, MaterializedUntrackedStateRow, UntrackedStateContext,
-    UntrackedStateFilter, UntrackedStateProjection, UntrackedStateRowRequest,
-    UntrackedStateScanRequest,
+    MaterializedUntrackedStateRow, UntrackedStateContext, UntrackedStateFilter,
+    UntrackedStateProjection, UntrackedStateRowRequest, UntrackedStateScanRequest,
 };
+use crate::version::VersionContext;
 use crate::{Backend, LixError, NullableKeyFilter};
+use std::collections::{BTreeMap, HashSet};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::OnceLock;
 use std::time::{Duration, Instant};
 
+fn prepare_json_ref(document: &[u8]) -> Result<JsonRef, LixError> {
+    let text = std::str::from_utf8(document).map_err(|error| {
+        LixError::new(
+            LixError::CODE_UNKNOWN,
+            format!("benchmark JSON document is invalid UTF-8: {error}"),
+        )
+    })?;
+    Ok(JsonRef::for_content(text.as_bytes()))
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct StorageBenchConfig {
     pub rows: usize,
@@ -115,13 +139,647 @@ pub struct StorageBenchReport {
     pub elapsed: Duration,
 }
 
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct TransactionBenchCounters {
+    pub rows_staged: usize,
+    pub untracked_rows: usize,
+    pub validation_version_count: usize,
+    pub schema_catalog_loads: usize,
+    pub json_store_stage_bytes_calls: usize,
+    pub unique_json_refs: usize,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct TransactionAccountingReport {
+    pub counters: TransactionBenchCounters,
+    pub storage_write_batches: usize,
+    pub kv_puts_by_namespace: BTreeMap<String, usize>,
+    pub bytes_by_namespace: BTreeMap<String, usize>,
+}
+
 pub struct StorageApiFixture {
     storage: StorageContext,
     rows: usize,
 }
 
+pub struct TransactionBenchFixture {
+    storage: StorageContext,
+    live_state: Arc<LiveStateContext>,
+    tracked_state: Arc<TrackedStateContext>,
+    binary_cas: Arc<BinaryCasContext>,
+    commit_store: Arc<CommitStoreContext>,
+    version_ctx: Arc<VersionContext>,
+    catalog_context: Arc<CatalogContext>,
+    rows: Vec<TransactionWriteRow>,
+}
+
+pub struct TransactionCommitOnlyFixture {
+    runtime_functions: crate::functions::FunctionContext,
+    transaction: crate::transaction::Transaction,
+    rows: usize,
+}
+
+static TRANSACTION_ROWS_STAGED: AtomicUsize = AtomicUsize::new(0);
+static TRANSACTION_UNTRACKED_ROWS: AtomicUsize = AtomicUsize::new(0);
+static TRANSACTION_VALIDATION_VERSION_COUNT: AtomicUsize = AtomicUsize::new(0);
+static TRANSACTION_SCHEMA_CATALOG_LOADS: AtomicUsize = AtomicUsize::new(0);
+static JSON_STORE_STAGE_BYTES_CALLS: AtomicUsize = AtomicUsize::new(0);
+static JSON_STORE_UNIQUE_REFS: OnceLock<Mutex<HashSet<[u8; 32]>>> = OnceLock::new();
+
 const STORAGE_API_NAMESPACE: &str = "bench.storage_api";
 const STORAGE_API_ALT_NAMESPACE: &str = "bench.storage_api.alt";
+const TRANSACTION_BENCH_SCHEMA_KEY: &str = "bench_transaction_entity";
+
+pub fn reset_transaction_bench_counters() {
+    TRANSACTION_ROWS_STAGED.store(0, Ordering::Relaxed);
+    TRANSACTION_UNTRACKED_ROWS.store(0, Ordering::Relaxed);
+    TRANSACTION_VALIDATION_VERSION_COUNT.store(0, Ordering::Relaxed);
+    TRANSACTION_SCHEMA_CATALOG_LOADS.store(0, Ordering::Relaxed);
+    JSON_STORE_STAGE_BYTES_CALLS.store(0, Ordering::Relaxed);
+    json_store_unique_refs()
+        .lock()
+        .expect("json store unique ref counter mutex should lock")
+        .clear();
+}
+
+pub fn transaction_bench_counters() -> TransactionBenchCounters {
+    TransactionBenchCounters {
+        rows_staged: TRANSACTION_ROWS_STAGED.load(Ordering::Relaxed),
+        untracked_rows: TRANSACTION_UNTRACKED_ROWS.load(Ordering::Relaxed),
+        validation_version_count: TRANSACTION_VALIDATION_VERSION_COUNT.load(Ordering::Relaxed),
+        schema_catalog_loads: TRANSACTION_SCHEMA_CATALOG_LOADS.load(Ordering::Relaxed),
+        json_store_stage_bytes_calls: JSON_STORE_STAGE_BYTES_CALLS.load(Ordering::Relaxed),
+        unique_json_refs: json_store_unique_refs()
+            .lock()
+            .expect("json store unique ref counter mutex should lock")
+            .len(),
+    }
+}
+
+pub(crate) fn record_transaction_rows_staged(rows: usize) {
+    TRANSACTION_ROWS_STAGED.fetch_add(rows, Ordering::Relaxed);
+}
+
+pub(crate) fn record_transaction_untracked_rows(rows: usize) {
+    TRANSACTION_UNTRACKED_ROWS.fetch_add(rows, Ordering::Relaxed);
+}
+
+pub(crate) fn record_transaction_validation_version() {
+    TRANSACTION_VALIDATION_VERSION_COUNT.fetch_add(1, Ordering::Relaxed);
+}
+
+pub(crate) fn record_transaction_schema_catalog_load() {
+    TRANSACTION_SCHEMA_CATALOG_LOADS.fetch_add(1, Ordering::Relaxed);
+}
+
+pub(crate) fn record_json_store_stage_bytes(hash: [u8; 32]) {
+    JSON_STORE_STAGE_BYTES_CALLS.fetch_add(1, Ordering::Relaxed);
+    json_store_unique_refs()
+        .lock()
+        .expect("json store unique ref counter mutex should lock")
+        .insert(hash);
+}
+
+fn json_store_unique_refs() -> &'static Mutex<HashSet<[u8; 32]>> {
+    JSON_STORE_UNIQUE_REFS.get_or_init(|| Mutex::new(HashSet::new()))
+}
+
+pub async fn prepare_transaction_commit_empty(
+    backend: Arc<dyn Backend + Send + Sync>,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_fixture(backend, Vec::new()).await
+}
+
+pub async fn prepare_transaction_commit_schema_only(
+    backend: Arc<dyn Backend + Send + Sync>,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_fixture(backend, vec![transaction_registered_schema_row()]).await
+}
+
+pub async fn prepare_transaction_commit_entities_no_payload(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_fixture(
+        backend,
+        transaction_entity_rows(TransactionEntityRows {
+            rows,
+            payload_bytes: 0,
+            payload_pattern: TransactionPayloadPattern::Unique,
+            metadata_pattern: TransactionPayloadPattern::None,
+            untracked: false,
+            key_prefix: "entity-no-payload",
+        }),
+    )
+    .await
+}
+
+pub async fn prepare_transaction_commit_entities_payload_1k_unique(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_payload_fixture(
+        backend,
+        rows,
+        1024,
+        TransactionPayloadPattern::Unique,
+        false,
+        "entity-payload-1k-unique",
+    )
+    .await
+}
+
+pub async fn prepare_transaction_commit_entities_payload_1k_same(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_payload_fixture(
+        backend,
+        rows,
+        1024,
+        TransactionPayloadPattern::Same,
+        false,
+        "entity-payload-1k-same",
+    )
+    .await
+}
+
+pub async fn prepare_transaction_commit_entities_payload_1k_half_duplicate(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_payload_fixture(
+        backend,
+        rows,
+        1024,
+        TransactionPayloadPattern::HalfDuplicate,
+        false,
+        "entity-payload-1k-half-duplicate",
+    )
+    .await
+}
+
+pub async fn prepare_transaction_commit_entities_metadata_1k_same(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_fixture(
+        backend,
+        transaction_entity_rows(TransactionEntityRows {
+            rows,
+            payload_bytes: 0,
+            payload_pattern: TransactionPayloadPattern::Unique,
+            metadata_pattern: TransactionPayloadPattern::Same,
+            untracked: false,
+            key_prefix: "entity-metadata-1k-same",
+        }),
+    )
+    .await
+}
+
+pub async fn prepare_transaction_commit_entities_payload_16k_unique(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_payload_fixture(
+        backend,
+        rows,
+        16 * 1024,
+        TransactionPayloadPattern::Unique,
+        false,
+        "entity-payload-16k-unique",
+    )
+    .await
+}
+
+pub async fn prepare_transaction_commit_untracked_payload_1k_same(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_payload_fixture(
+        backend,
+        rows,
+        1024,
+        TransactionPayloadPattern::Same,
+        true,
+        "untracked-payload-1k-same",
+    )
+    .await
+}
+
+pub async fn prepare_transaction_update_existing_payload_1k(
+    backend: Arc<dyn Backend + Send + Sync>,
+    root_rows: usize,
+    update_rows: usize,
+) -> Result<TransactionBenchFixture, LixError> {
+    let fixture = prepare_transaction_payload_fixture(
+        backend,
+        root_rows,
+        1024,
+        TransactionPayloadPattern::Unique,
+        false,
+        "update-existing-root",
+    )
+    .await?;
+    transaction_commit_prepared(&fixture).await?;
+    let rows = transaction_entity_rows(TransactionEntityRows {
+        rows: update_rows,
+        payload_bytes: 1024,
+        payload_pattern: TransactionPayloadPattern::Unique,
+        metadata_pattern: TransactionPayloadPattern::None,
+        untracked: false,
+        key_prefix: "update-existing-root",
+    });
+    Ok(TransactionBenchFixture { rows, ..fixture })
+}
+
+pub async fn transaction_commit_prepared(
+    fixture: &TransactionBenchFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let opened = open_transaction(
+        &SessionMode::Pinned {
+            version_id: crate::GLOBAL_VERSION_ID.to_string(),
+        },
+        fixture.storage.clone(),
+        Arc::clone(&fixture.live_state),
+        Arc::clone(&fixture.tracked_state),
+        Arc::clone(&fixture.binary_cas),
+        Arc::clone(&fixture.commit_store),
+        Arc::clone(&fixture.version_ctx),
+        Arc::clone(&fixture.catalog_context),
+    )
+    .await?;
+    let mut transaction = opened.transaction;
+    let runtime_functions = opened.runtime_functions;
+    let started_at = Instant::now();
+    if !fixture.rows.is_empty() {
+        transaction
+            .stage_write(TransactionWrite::Rows {
+                mode: TransactionWriteMode::Replace,
+                rows: fixture.rows.clone(),
+            })
+            .await?;
+    }
+    transaction.commit(&runtime_functions).await?;
+    Ok(StorageBenchReport {
+        measured_rows: fixture.rows.len(),
+        verified_rows: fixture.rows.len(),
+        elapsed: started_at.elapsed(),
+    })
+}
+
+pub async fn transaction_open_empty_prepared(
+    fixture: &TransactionBenchFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let started_at = Instant::now();
+    let opened = open_transaction(
+        &SessionMode::Pinned {
+            version_id: crate::GLOBAL_VERSION_ID.to_string(),
+        },
+        fixture.storage.clone(),
+        Arc::clone(&fixture.live_state),
+        Arc::clone(&fixture.tracked_state),
+        Arc::clone(&fixture.binary_cas),
+        Arc::clone(&fixture.commit_store),
+        Arc::clone(&fixture.version_ctx),
+        Arc::clone(&fixture.catalog_context),
+    )
+    .await?;
+    let elapsed = started_at.elapsed();
+    opened.transaction.rollback().await?;
+    Ok(StorageBenchReport {
+        measured_rows: 0,
+        verified_rows: 0,
+        elapsed,
+    })
+}
+
+pub async fn transaction_stage_only_prepared(
+    fixture: &TransactionBenchFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let opened = open_transaction(
+        &SessionMode::Pinned {
+            version_id: crate::GLOBAL_VERSION_ID.to_string(),
+        },
+        fixture.storage.clone(),
+        Arc::clone(&fixture.live_state),
+        Arc::clone(&fixture.tracked_state),
+        Arc::clone(&fixture.binary_cas),
+        Arc::clone(&fixture.commit_store),
+        Arc::clone(&fixture.version_ctx),
+        Arc::clone(&fixture.catalog_context),
+    )
+    .await?;
+    let mut transaction = opened.transaction;
+    let started_at = Instant::now();
+    if !fixture.rows.is_empty() {
+        transaction
+            .stage_write(TransactionWrite::Rows {
+                mode: TransactionWriteMode::Replace,
+                rows: fixture.rows.clone(),
+            })
+            .await?;
+    }
+    let elapsed = started_at.elapsed();
+    transaction.rollback().await?;
+    Ok(StorageBenchReport {
+        measured_rows: fixture.rows.len(),
+        verified_rows: fixture.rows.len(),
+        elapsed,
+    })
+}
+
+pub async fn prepare_transaction_commit_only(
+    fixture: TransactionBenchFixture,
+) -> Result<TransactionCommitOnlyFixture, LixError> {
+    let opened = open_transaction(
+        &SessionMode::Pinned {
+            version_id: crate::GLOBAL_VERSION_ID.to_string(),
+        },
+        fixture.storage.clone(),
+        Arc::clone(&fixture.live_state),
+        Arc::clone(&fixture.tracked_state),
+        Arc::clone(&fixture.binary_cas),
+        Arc::clone(&fixture.commit_store),
+        Arc::clone(&fixture.version_ctx),
+        Arc::clone(&fixture.catalog_context),
+    )
+    .await?;
+    let mut transaction = opened.transaction;
+    let runtime_functions = opened.runtime_functions;
+    let rows = fixture.rows.len();
+    if !fixture.rows.is_empty() {
+        transaction
+            .stage_write(TransactionWrite::Rows {
+                mode: TransactionWriteMode::Replace,
+                rows: fixture.rows,
+            })
+            .await?;
+    }
+    Ok(TransactionCommitOnlyFixture {
+        runtime_functions,
+        transaction,
+        rows,
+    })
+}
+
+pub async fn transaction_commit_only_prepared(
+    fixture: TransactionCommitOnlyFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let rows = fixture.rows;
+    let started_at = Instant::now();
+    fixture
+        .transaction
+        .commit(&fixture.runtime_functions)
+        .await?;
+    Ok(StorageBenchReport {
+        measured_rows: rows,
+        verified_rows: rows,
+        elapsed: started_at.elapsed(),
+    })
+}
+
+async fn prepare_transaction_payload_fixture(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: usize,
+    payload_bytes: usize,
+    payload_pattern: TransactionPayloadPattern,
+    untracked: bool,
+    key_prefix: &'static str,
+) -> Result<TransactionBenchFixture, LixError> {
+    prepare_transaction_fixture(
+        backend,
+        transaction_entity_rows(TransactionEntityRows {
+            rows,
+            payload_bytes,
+            payload_pattern,
+            metadata_pattern: TransactionPayloadPattern::None,
+            untracked,
+            key_prefix,
+        }),
+    )
+    .await
+}
+
+async fn prepare_transaction_fixture(
+    backend: Arc<dyn Backend + Send + Sync>,
+    rows: Vec<TransactionWriteRow>,
+) -> Result<TransactionBenchFixture, LixError> {
+    let storage = StorageContext::new(backend);
+    let tracked_state = Arc::new(TrackedStateContext::new());
+    let untracked_state = Arc::new(UntrackedStateContext::new());
+    let commit_store = Arc::new(CommitStoreContext::new());
+    let live_state = Arc::new(LiveStateContext::new(
+        tracked_state.as_ref().clone(),
+        untracked_state.as_ref().clone(),
+        crate::commit_graph::CommitGraphContext::new(),
+    ));
+    let binary_cas = Arc::new(BinaryCasContext::new());
+    let version_ctx = Arc::new(VersionContext::new(untracked_state));
+    let catalog_context = Arc::new(CatalogContext::new());
+    seed_transaction_visible_schema_rows(storage.clone()).await?;
+    Ok(TransactionBenchFixture {
+        storage,
+        live_state,
+        tracked_state,
+        binary_cas,
+        commit_store,
+        version_ctx,
+        catalog_context,
+        rows,
+    })
+}
+
+async fn seed_transaction_visible_schema_rows(storage: StorageContext) -> Result<(), LixError> {
+    let mut writes = StorageWriteSet::new();
+    let rows = crate::schema::seed_schema_definitions()
+        .into_iter()
+        .cloned()
+        .chain(std::iter::once(transaction_entity_schema_definition()))
+        .map(|schema| {
+            let key = crate::schema::schema_key_from_definition(&schema)
+                .expect("seed schema key should derive");
+            let snapshot_content = serde_json::json!({ "value": schema }).to_string();
+            Ok(crate::untracked_state::UntrackedStateRow {
+                entity_id: crate::schema::registered_schema_entity_id(&key.schema_key)
+                    .expect("registered schema identity should derive"),
+                schema_key: "lix_registered_schema".to_string(),
+                file_id: None,
+                version_id: crate::GLOBAL_VERSION_ID.to_string(),
+                snapshot_content: Some(snapshot_content),
+                metadata: None,
+                created_at: "1970-01-01T00:00:00.000Z".to_string(),
+                updated_at: "1970-01-01T00:00:00.000Z".to_string(),
+                global: true,
+            })
+        })
+        .collect::<Result<Vec<_>, LixError>>()?;
+    let mut transaction = storage.begin_write_transaction().await?;
+    UntrackedStateContext::new()
+        .writer(&mut writes)
+        .stage_rows(rows.iter().map(|row| row.as_ref()))?;
+    writes.apply(&mut transaction.as_mut()).await?;
+    transaction.commit().await
+}
+
+fn transaction_entity_schema_definition() -> serde_json::Value {
+    serde_json::json!({
+        "x-lix-key": TRANSACTION_BENCH_SCHEMA_KEY,
+        "type": "object",
+        "properties": {
+            "value": {
+                "anyOf": [
+                    { "type": "string" },
+                    { "type": "object" },
+                    { "type": "array" },
+                    { "type": "number" },
+                    { "type": "boolean" },
+                    { "type": "null" }
+                ]
+            }
+        },
+        "required": ["value"],
+        "additionalProperties": false
+    })
+}
+
+#[derive(Debug, Clone, Copy)]
+enum TransactionPayloadPattern {
+    None,
+    Unique,
+    Same,
+    HalfDuplicate,
+}
+
+struct TransactionEntityRows {
+    rows: usize,
+    payload_bytes: usize,
+    payload_pattern: TransactionPayloadPattern,
+    metadata_pattern: TransactionPayloadPattern,
+    untracked: bool,
+    key_prefix: &'static str,
+}
+
+fn transaction_entity_rows(config: TransactionEntityRows) -> Vec<TransactionWriteRow> {
+    (0..config.rows)
+        .map(|index| {
+            let key = format!("{}-{index:06}", config.key_prefix);
+            let value_index = payload_pattern_index(config.payload_pattern, index);
+            let metadata_index = payload_pattern_index(config.metadata_pattern, index);
+            TransactionWriteRow {
+                entity_id: Some(EntityIdentity::single(key.clone())),
+                schema_key: TRANSACTION_BENCH_SCHEMA_KEY.to_string(),
+                file_id: None,
+                snapshot: Some(transaction_snapshot_json(
+                    &key,
+                    value_index,
+                    config.payload_bytes,
+                )),
+                metadata: transaction_metadata(config.metadata_pattern, metadata_index),
+                origin: None,
+                created_at: None,
+                updated_at: None,
+                global: true,
+                change_id: None,
+                commit_id: None,
+                untracked: config.untracked,
+                version_id: crate::GLOBAL_VERSION_ID.to_string(),
+            }
+        })
+        .collect()
+}
+
+fn transaction_registered_schema_row() -> TransactionWriteRow {
+    let schema = serde_json::json!({
+        "x-lix-key": "bench_transaction_schema",
+        "x-lix-primary-key": ["/id"],
+        "type": "object",
+        "properties": {
+            "id": { "type": "string" },
+            "value": { "type": "string" }
+        },
+        "required": ["id", "value"],
+        "additionalProperties": false
+    });
+    let key =
+        crate::schema::schema_key_from_definition(&schema).expect("seed schema key should derive");
+    TransactionWriteRow {
+        entity_id: Some(
+            crate::schema::registered_schema_entity_id(&key.schema_key)
+                .expect("registered schema identity should derive"),
+        ),
+        schema_key: "lix_registered_schema".to_string(),
+        file_id: None,
+        snapshot: Some(TransactionJson::from_value_unchecked(
+            serde_json::json!({ "value": schema }),
+        )),
+        metadata: None,
+        origin: None,
+        created_at: None,
+        updated_at: None,
+        global: true,
+        change_id: None,
+        commit_id: None,
+        untracked: false,
+        version_id: crate::GLOBAL_VERSION_ID.to_string(),
+    }
+}
+
+fn transaction_snapshot_json(
+    _key: &str,
+    payload_index: usize,
+    target_bytes: usize,
+) -> TransactionJson {
+    let base_value = format!("/entities/{payload_index}/value");
+    let value = if target_bytes == 0 {
+        base_value
+    } else {
+        let current = serde_json::json!({
+            "value": base_value,
+        })
+        .to_string()
+        .len();
+        let padding = target_bytes.saturating_sub(current);
+        format!("{base_value}:{}", "x".repeat(padding))
+    };
+    let mut object = serde_json::Map::new();
+    object.insert("value".to_string(), serde_json::Value::String(value));
+    TransactionJson::from_value_unchecked(serde_json::Value::Object(object))
+}
+
+fn transaction_metadata(
+    pattern: TransactionPayloadPattern,
+    metadata_index: usize,
+) -> Option<TransactionJson> {
+    match pattern {
+        TransactionPayloadPattern::None => None,
+        TransactionPayloadPattern::Unique
+        | TransactionPayloadPattern::Same
+        | TransactionPayloadPattern::HalfDuplicate => {
+            let mut object = serde_json::Map::new();
+            object.insert(
+                "source".to_string(),
+                serde_json::Value::String("transaction-bench".to_string()),
+            );
+            object.insert(
+                "metadata_index".to_string(),
+                serde_json::Value::String(metadata_index.to_string()),
+            );
+            pad_json_object(&mut object, 1024);
+            Some(TransactionJson::from_value_unchecked(
+                serde_json::Value::Object(object),
+            ))
+        }
+    }
+}
+
+fn payload_pattern_index(pattern: TransactionPayloadPattern, index: usize) -> usize {
+    match pattern {
+        TransactionPayloadPattern::None | TransactionPayloadPattern::Unique => index,
+        TransactionPayloadPattern::Same => 0,
+        TransactionPayloadPattern::HalfDuplicate => index % 2,
+    }
+}
 
 pub async fn storage_api_write_kv_batch_puts(
     backend: Arc<dyn Backend + Send + Sync>,
@@ -689,7 +1347,7 @@ fn storage_api_updated_value(index: usize) -> Vec<u8> {
 
 pub struct TrackedStateWriteRootFixture {
     context: TrackedStateContext,
-    rows: Vec<TrackedStateRow>,
+    rows: Vec<MaterializedTrackedStateRow>,
 }
 
 pub struct TrackedStateReadFixture {
@@ -702,7 +1360,7 @@ pub struct TrackedStateReadFixture {
 
 pub struct TrackedStateUpdateFixture {
     context: TrackedStateContext,
-    rows: Vec<TrackedStateRow>,
+    rows: Vec<MaterializedTrackedStateRow>,
 }
 
 pub struct TrackedStateDiffFixture {
@@ -712,6 +1370,32 @@ pub struct TrackedStateDiffFixture {
     expected_entries: usize,
 }
 
+pub struct TrackedStateMaterializeFixture {
+    context: TrackedStateContext,
+    commit_id: String,
+    expected_rows: usize,
+}
+
+#[derive(Clone)]
+pub struct JsonPointerStorageRow {
+    pub path: String,
+    pub value_json: String,
+    pub updated_value_json: String,
+}
+
+pub struct JsonPointerTrackedStateReadFixture {
+    context: TrackedStateContext,
+    rows: Vec<JsonPointerStorageRow>,
+    commit_id: String,
+}
+
+pub struct JsonPointerTrackedStateDiffFixture {
+    context: TrackedStateContext,
+    left_commit_id: String,
+    right_commit_id: String,
+    expected_entries: usize,
+}
+
 pub struct UntrackedStateWriteFixture {
     context: UntrackedStateContext,
     rows: Vec<MaterializedUntrackedStateRow>,
@@ -725,20 +1409,25 @@ pub struct UntrackedStateReadFixture {
 }
 
 pub struct ChangelogAppendFixture {
-    context: ChangelogContext,
-    changes: Vec<MaterializedCanonicalChange>,
+    context: CommitStoreContext,
+    changes: Vec<MaterializedChange>,
 }
 
 pub struct ChangelogReadFixture {
-    context: ChangelogContext,
+    context: CommitStoreContext,
     rows: usize,
 }
 
 pub struct ChangelogCodecFixture {
-    changes: Vec<CanonicalChange>,
+    changes: Vec<Change>,
     encoded_changes: Vec<Vec<u8>>,
 }
 
+pub struct CommitGraphReadFixture {
+    head_commit_id: String,
+    rows: usize,
+}
+
 pub struct BinaryCasWriteFixture {
     context: BinaryCasContext,
     file_ids: Vec<String>,
@@ -839,97 +1528,161 @@ pub async fn prepare_tracked_state_read_file_selective(
     })
 }
 
-pub async fn tracked_state_read_point_hit_prepared(
-    backend: &Arc<dyn Backend + Send + Sync>,
-    fixture: &TrackedStateReadFixture,
-) -> Result<StorageBenchReport, LixError> {
-    let mut verified_rows = 0;
-    let mut reader = fixture
-        .context
-        .reader(StorageContext::new(Arc::clone(backend)));
-    for index in 0..fixture.rows {
-        if reader
-            .load_row_at_commit(
-                &fixture.commit_id,
-                &TrackedStateRowRequest {
-                    schema_key: tracked_schema_key(index, StorageBenchSelectivity::Percent100),
-                    entity_id: EntityIdentity::single(entity_id(
-                        "tracked",
-                        index,
-                        fixture.key_pattern,
-                    )),
-                    file_id: NullableKeyFilter::Value("bench.json".to_string()),
-                },
-            )
-            .await?
-            .is_some()
-        {
-            verified_rows += 1;
-        }
-    }
-    Ok(report(fixture.rows, verified_rows, Duration::ZERO))
-}
-
-pub async fn tracked_state_read_point_hit_constant_prepared(
+pub async fn prepare_tracked_state_read_after_update_rows(
     backend: &Arc<dyn Backend + Send + Sync>,
-    fixture: &TrackedStateReadFixture,
-    measured_reads: usize,
+    config: StorageBenchConfig,
+    updated_rows: usize,
+) -> Result<TrackedStateReadFixture, LixError> {
+    let fixture = prepare_tracked_state_update_rows(backend, config, updated_rows).await?;
+    tracked_state_update_existing_prepared(backend, &fixture).await?;
+    Ok(TrackedStateReadFixture {
+        context: fixture.context,
+        rows: config.rows,
+        commit_id: "bench-tracked-child".to_string(),
+        key_pattern: config.key_pattern,
+        selectivity: config.selectivity,
+    })
+}
+
+pub async fn prepare_tracked_state_read_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<TrackedStateReadFixture, LixError> {
+    let (context, final_commit_id) =
+        write_tracked_delta_chain(backend, config, delta_commits, updated_rows_per_commit).await?;
+    Ok(TrackedStateReadFixture {
+        context,
+        rows: config.rows,
+        commit_id: final_commit_id,
+        key_pattern: config.key_pattern,
+        selectivity: config.selectivity,
+    })
+}
+
+pub async fn prepare_tracked_state_read_materialized_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<TrackedStateReadFixture, LixError> {
+    let (context, final_commit_id) =
+        write_tracked_delta_chain(backend, config, delta_commits, updated_rows_per_commit).await?;
+    materialize_tracked_root(backend, &context, &final_commit_id).await?;
+    Ok(TrackedStateReadFixture {
+        context,
+        rows: config.rows,
+        commit_id: final_commit_id,
+        key_pattern: config.key_pattern,
+        selectivity: config.selectivity,
+    })
+}
+
+pub async fn prepare_tracked_state_materialize_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<TrackedStateMaterializeFixture, LixError> {
+    let (context, final_commit_id) =
+        write_tracked_delta_chain(backend, config, delta_commits, updated_rows_per_commit).await?;
+    Ok(TrackedStateMaterializeFixture {
+        context,
+        commit_id: final_commit_id,
+        expected_rows: config.rows,
+    })
+}
+
+fn tracked_point_hit_requests(
+    rows: usize,
+    key_pattern: StorageBenchKeyPattern,
+) -> Vec<TrackedStateRowRequest> {
+    (0..rows)
+        .map(|index| TrackedStateRowRequest {
+            schema_key: tracked_schema_key(index, StorageBenchSelectivity::Percent100),
+            entity_id: EntityIdentity::single(entity_id("tracked", index, key_pattern)),
+            file_id: NullableKeyFilter::Value("bench.json".to_string()),
+        })
+        .collect()
+}
+
+fn tracked_point_miss_requests(
+    rows: usize,
+    selectivity: StorageBenchSelectivity,
+) -> Vec<TrackedStateRowRequest> {
+    (0..rows)
+        .map(|index| TrackedStateRowRequest {
+            schema_key: tracked_schema_key(index, selectivity),
+            entity_id: EntityIdentity::single(format!("missing-{index}")),
+            file_id: NullableKeyFilter::Value("bench.json".to_string()),
+        })
+        .collect()
+}
+
+fn tracked_point_miss_requests_for_schema(
+    rows: usize,
+    schema_key: &str,
+) -> Vec<TrackedStateRowRequest> {
+    (0..rows)
+        .map(|index| TrackedStateRowRequest {
+            schema_key: schema_key.to_string(),
+            entity_id: EntityIdentity::single(format!("missing-{index}")),
+            file_id: NullableKeyFilter::Value("bench.json".to_string()),
+        })
+        .collect()
+}
+
+pub async fn tracked_state_read_point_hit_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &TrackedStateReadFixture,
 ) -> Result<StorageBenchReport, LixError> {
-    let mut verified_rows = 0;
     let mut reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    for index in 0..measured_reads.min(fixture.rows) {
-        if reader
-            .load_row_at_commit(
-                &fixture.commit_id,
-                &TrackedStateRowRequest {
-                    schema_key: tracked_schema_key(index, StorageBenchSelectivity::Percent100),
-                    entity_id: EntityIdentity::single(entity_id(
-                        "tracked",
-                        index,
-                        fixture.key_pattern,
-                    )),
-                    file_id: NullableKeyFilter::Value("bench.json".to_string()),
-                },
-            )
-            .await?
-            .is_some()
-        {
-            verified_rows += 1;
-        }
-    }
-    Ok(report(
-        measured_reads.min(fixture.rows),
-        verified_rows,
-        Duration::ZERO,
-    ))
+    let requests = tracked_point_hit_requests(fixture.rows, fixture.key_pattern);
+    let verified_rows = reader
+        .load_rows_at_commit(&fixture.commit_id, &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
+    Ok(report(fixture.rows, verified_rows, Duration::ZERO))
+}
+
+pub async fn tracked_state_read_point_hit_constant_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &TrackedStateReadFixture,
+    measured_reads: usize,
+) -> Result<StorageBenchReport, LixError> {
+    let measured_rows = measured_reads.min(fixture.rows);
+    let mut reader = fixture
+        .context
+        .reader(StorageContext::new(Arc::clone(backend)));
+    let requests = tracked_point_hit_requests(measured_rows, fixture.key_pattern);
+    let verified_rows = reader
+        .load_rows_at_commit(&fixture.commit_id, &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
+    Ok(report(measured_rows, verified_rows, Duration::ZERO))
 }
 
 pub async fn tracked_state_read_point_miss_prepared(
     backend: &Arc<dyn Backend + Send + Sync>,
     fixture: &TrackedStateReadFixture,
 ) -> Result<StorageBenchReport, LixError> {
-    let mut misses = 0;
     let mut reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    for index in 0..fixture.rows {
-        if reader
-            .load_row_at_commit(
-                &fixture.commit_id,
-                &TrackedStateRowRequest {
-                    schema_key: "bench_tracked_entity".to_string(),
-                    entity_id: EntityIdentity::single(format!("missing-{index}")),
-                    file_id: NullableKeyFilter::Value("bench.json".to_string()),
-                },
-            )
-            .await?
-            .is_none()
-        {
-            misses += 1;
-        }
-    }
+    let requests = tracked_point_miss_requests_for_schema(fixture.rows, TRACKED_MATCH_SCHEMA_KEY);
+    let misses = reader
+        .load_rows_at_commit(&fixture.commit_id, &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_none)
+        .count();
     Ok(report(fixture.rows, misses, Duration::ZERO))
 }
 
@@ -1261,6 +2014,22 @@ pub async fn prepare_tracked_state_diff_update_rows(
     })
 }
 
+pub async fn prepare_tracked_state_diff_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<TrackedStateDiffFixture, LixError> {
+    let (context, final_commit_id) =
+        write_tracked_delta_chain(backend, config, delta_commits, updated_rows_per_commit).await?;
+    Ok(TrackedStateDiffFixture {
+        context,
+        left_commit_id: "bench-tracked-base".to_string(),
+        right_commit_id: final_commit_id,
+        expected_entries: updated_rows_per_commit.min(config.rows),
+    })
+}
+
 pub async fn prepare_tracked_state_diff_tombstone_rows(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
@@ -1276,24 +2045,315 @@ pub async fn prepare_tracked_state_diff_tombstone_rows(
     })
 }
 
-pub async fn prepare_tracked_state_diff_equal(
+pub async fn prepare_tracked_state_diff_equal(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+) -> Result<TrackedStateDiffFixture, LixError> {
+    let context = TrackedStateContext::new();
+    let rows = tracked_rows(config, "bench-tracked-parent");
+    write_tracked_root(backend, &context, "bench-tracked-parent", None, &rows).await?;
+    Ok(TrackedStateDiffFixture {
+        context,
+        left_commit_id: "bench-tracked-parent".to_string(),
+        right_commit_id: "bench-tracked-parent".to_string(),
+        expected_entries: 0,
+    })
+}
+
+pub async fn tracked_state_diff_commits_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &TrackedStateDiffFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let mut reader = fixture
+        .context
+        .reader(StorageContext::new(Arc::clone(backend)));
+    let diff = reader
+        .diff_commits(
+            &fixture.left_commit_id,
+            &fixture.right_commit_id,
+            &TrackedStateDiffRequest::default(),
+        )
+        .await?;
+    Ok(report(
+        fixture.expected_entries,
+        diff.entries.len(),
+        Duration::ZERO,
+    ))
+}
+
+pub async fn tracked_state_materialize_root_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &TrackedStateMaterializeFixture,
+) -> Result<StorageBenchReport, LixError> {
+    materialize_tracked_root(backend, &fixture.context, &fixture.commit_id).await?;
+    Ok(report(
+        fixture.expected_rows,
+        fixture.expected_rows,
+        Duration::ZERO,
+    ))
+}
+
+pub async fn prepare_json_pointer_tracked_state_write_root(
+    rows: &[JsonPointerStorageRow],
+) -> Result<TrackedStateWriteRootFixture, LixError> {
+    Ok(TrackedStateWriteRootFixture {
+        context: TrackedStateContext::new(),
+        rows: json_pointer_tracked_rows(rows, "json-pointer-base", false),
+    })
+}
+
+pub async fn prepare_json_pointer_tracked_state_read(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    rows: &[JsonPointerStorageRow],
+) -> Result<JsonPointerTrackedStateReadFixture, LixError> {
+    let context = TrackedStateContext::new();
+    let materialized_rows = json_pointer_tracked_rows(rows, "json-pointer-base", false);
+    write_tracked_root(
+        backend,
+        &context,
+        "json-pointer-base",
+        None,
+        &materialized_rows,
+    )
+    .await?;
+    Ok(JsonPointerTrackedStateReadFixture {
+        context,
+        rows: rows.to_vec(),
+        commit_id: "json-pointer-base".to_string(),
+    })
+}
+
+pub async fn prepare_json_pointer_tracked_state_diff_update_rows(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    rows: &[JsonPointerStorageRow],
+    updated_rows: usize,
+) -> Result<JsonPointerTrackedStateDiffFixture, LixError> {
+    let context = TrackedStateContext::new();
+    let base_rows = json_pointer_tracked_rows(rows, "json-pointer-base", false);
+    write_tracked_root(backend, &context, "json-pointer-base", None, &base_rows).await?;
+    let child_rows = json_pointer_tracked_rows(
+        &rows[..updated_rows.min(rows.len())],
+        "json-pointer-child",
+        true,
+    );
+    write_tracked_root(
+        backend,
+        &context,
+        "json-pointer-child",
+        Some("json-pointer-base"),
+        &child_rows,
+    )
+    .await?;
+    Ok(JsonPointerTrackedStateDiffFixture {
+        context,
+        left_commit_id: "json-pointer-base".to_string(),
+        right_commit_id: "json-pointer-child".to_string(),
+        expected_entries: child_rows.len(),
+    })
+}
+
+pub async fn json_pointer_tracked_state_get_many_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let mut reader = fixture
+        .context
+        .reader(StorageContext::new(Arc::clone(backend)));
+    let requests = fixture
+        .rows
+        .iter()
+        .map(|row| TrackedStateRowRequest {
+            schema_key: "json_pointer".to_string(),
+            entity_id: EntityIdentity::single(row.path.as_str()),
+            file_id: NullableKeyFilter::Null,
+        })
+        .collect::<Vec<_>>();
+    let verified_rows = reader
+        .load_rows_at_commit(&fixture.commit_id, &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
+    Ok(report(fixture.rows.len(), verified_rows, Duration::ZERO))
+}
+
+pub async fn json_pointer_tracked_state_get_many_missing_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let mut reader = fixture
+        .context
+        .reader(StorageContext::new(Arc::clone(backend)));
+    let requests = fixture
+        .rows
+        .iter()
+        .map(|row| TrackedStateRowRequest {
+            schema_key: "json_pointer".to_string(),
+            entity_id: EntityIdentity::single(format!("missing{}", row.path)),
+            file_id: NullableKeyFilter::Null,
+        })
+        .collect::<Vec<_>>();
+    let verified_rows = reader
+        .load_rows_at_commit(&fixture.commit_id, &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_none)
+        .count();
+    Ok(report(fixture.rows.len(), verified_rows, Duration::ZERO))
+}
+
+pub async fn json_pointer_tracked_state_scan_keys_only_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    json_pointer_scan_with_projection(
+        backend,
+        fixture,
+        TrackedStateProjection {
+            columns: vec!["entity_id".to_string()],
+        },
+    )
+    .await
+}
+
+pub async fn json_pointer_tracked_state_scan_headers_only_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    json_pointer_scan_with_projection(
+        backend,
+        fixture,
+        TrackedStateProjection {
+            columns: tracked_state_header_columns(),
+        },
+    )
+    .await
+}
+
+pub async fn json_pointer_tracked_state_scan_full_rows_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    json_pointer_scan_with_projection(backend, fixture, TrackedStateProjection::default()).await
+}
+
+pub async fn json_pointer_tracked_state_prefix_scan_schema_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    json_pointer_scan_with_projection(backend, fixture, TrackedStateProjection::default()).await
+}
+
+pub async fn json_pointer_tracked_state_prefix_scan_schema_file_null_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    json_pointer_scan_with_projection(backend, fixture, TrackedStateProjection::default()).await
+}
+
+async fn json_pointer_scan_with_projection(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &JsonPointerTrackedStateReadFixture,
+    projection: TrackedStateProjection,
+) -> Result<StorageBenchReport, LixError> {
+    let mut reader = fixture
+        .context
+        .reader(StorageContext::new(Arc::clone(backend)));
+    let verified_rows = reader
+        .scan_rows_at_commit(
+            &fixture.commit_id,
+            &TrackedStateScanRequest {
+                filter: TrackedStateFilter {
+                    schema_keys: vec!["json_pointer".to_string()],
+                    file_ids: vec![NullableKeyFilter::Null],
+                    ..Default::default()
+                },
+                projection,
+                ..Default::default()
+            },
+        )
+        .await?
+        .len();
+    Ok(report(fixture.rows.len(), verified_rows, Duration::ZERO))
+}
+
+pub async fn prepare_json_pointer_tracked_state_update_rows(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    rows: &[JsonPointerStorageRow],
+    updated_rows: usize,
+) -> Result<TrackedStateUpdateFixture, LixError> {
+    let context = TrackedStateContext::new();
+    let base_rows = json_pointer_tracked_rows(rows, "json-pointer-base", false);
+    write_tracked_root(backend, &context, "json-pointer-base", None, &base_rows).await?;
+    let child_rows = json_pointer_tracked_rows(
+        &rows[..updated_rows.min(rows.len())],
+        "json-pointer-child",
+        true,
+    );
+    Ok(TrackedStateUpdateFixture {
+        context,
+        rows: child_rows,
+    })
+}
+
+pub async fn prepare_json_pointer_tracked_state_tombstone_rows(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    rows: &[JsonPointerStorageRow],
+    tombstone_rows: usize,
+) -> Result<TrackedStateUpdateFixture, LixError> {
+    let context = TrackedStateContext::new();
+    let base_rows = json_pointer_tracked_rows(rows, "json-pointer-base", false);
+    write_tracked_root(backend, &context, "json-pointer-base", None, &base_rows).await?;
+    let mut child_rows = json_pointer_tracked_rows(
+        &rows[..tombstone_rows.min(rows.len())],
+        "json-pointer-child",
+        true,
+    );
+    for row in &mut child_rows {
+        row.snapshot_content = None;
+    }
+    Ok(TrackedStateUpdateFixture {
+        context,
+        rows: child_rows,
+    })
+}
+
+pub async fn prepare_json_pointer_tracked_state_diff_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    rows: &[JsonPointerStorageRow],
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<JsonPointerTrackedStateDiffFixture, LixError> {
+    let (context, final_commit_id) =
+        write_json_pointer_delta_chain(backend, rows, delta_commits, updated_rows_per_commit)
+            .await?;
+    Ok(JsonPointerTrackedStateDiffFixture {
+        context,
+        left_commit_id: "json-pointer-base".to_string(),
+        right_commit_id: final_commit_id,
+        expected_entries: updated_rows_per_commit.min(rows.len()),
+    })
+}
+
+pub async fn prepare_json_pointer_tracked_state_materialize_delta_chain(
     backend: &Arc<dyn Backend + Send + Sync>,
-    config: StorageBenchConfig,
-) -> Result<TrackedStateDiffFixture, LixError> {
-    let context = TrackedStateContext::new();
-    let rows = tracked_rows(config, "bench-tracked-parent");
-    write_tracked_root(backend, &context, "bench-tracked-parent", None, &rows).await?;
-    Ok(TrackedStateDiffFixture {
+    rows: &[JsonPointerStorageRow],
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<TrackedStateMaterializeFixture, LixError> {
+    let (context, final_commit_id) =
+        write_json_pointer_delta_chain(backend, rows, delta_commits, updated_rows_per_commit)
+            .await?;
+    Ok(TrackedStateMaterializeFixture {
         context,
-        left_commit_id: "bench-tracked-parent".to_string(),
-        right_commit_id: "bench-tracked-parent".to_string(),
-        expected_entries: 0,
+        commit_id: final_commit_id,
+        expected_rows: rows.len(),
     })
 }
 
-pub async fn tracked_state_diff_commits_prepared(
+pub async fn json_pointer_tracked_state_changed_keys_prepared(
     backend: &Arc<dyn Backend + Send + Sync>,
-    fixture: &TrackedStateDiffFixture,
+    fixture: &JsonPointerTrackedStateDiffFixture,
 ) -> Result<StorageBenchReport, LixError> {
     let mut reader = fixture
         .context
@@ -1617,7 +2677,7 @@ pub async fn prepare_changelog_append_changes(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_materialized_changes(config),
     })
 }
@@ -1626,7 +2686,7 @@ pub async fn prepare_changelog_append_tombstones(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_tombstone_changes(config),
     })
 }
@@ -1635,7 +2695,7 @@ pub async fn prepare_changelog_append_metadata(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_metadata_changes(config),
     })
 }
@@ -1644,7 +2704,7 @@ pub async fn prepare_changelog_append_shared_payload(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_shared_payload_changes(config),
     })
 }
@@ -1653,7 +2713,7 @@ pub async fn prepare_changelog_append_shared_metadata(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_shared_metadata_changes(config),
     })
 }
@@ -1662,7 +2722,7 @@ pub async fn prepare_changelog_append_shared_payload_and_metadata(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_shared_payload_and_metadata_changes(config),
     })
 }
@@ -1671,7 +2731,7 @@ pub async fn prepare_changelog_append_composite_entity_ids(
     config: StorageBenchConfig,
 ) -> Result<ChangelogAppendFixture, LixError> {
     Ok(ChangelogAppendFixture {
-        context: ChangelogContext::new(),
+        context: CommitStoreContext::new(),
         changes: changelog_composite_entity_id_changes(config),
     })
 }
@@ -1682,7 +2742,7 @@ pub async fn prepare_changelog_codec(
     let changes = changelog_changes(config);
     let encoded_changes = changes
         .iter()
-        .map(crate::changelog::codec::encode_change)
+        .map(|change| crate::commit_store::codec::encode_change_ref(change.as_ref()))
         .collect::<Result<Vec<_>, _>>()?;
     Ok(ChangelogCodecFixture {
         changes,
@@ -1699,7 +2759,7 @@ pub async fn changelog_append_changes_prepared(
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
     let verified_rows = reader
-        .scan_changes(&ChangelogScanRequest::default())
+        .scan_changes(&ChangeScanRequest::default())
         .await?
         .len();
     Ok(report(fixture.changes.len(), verified_rows, Duration::ZERO))
@@ -1709,7 +2769,7 @@ pub async fn prepare_changelog_read(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<ChangelogReadFixture, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_materialized_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     Ok(ChangelogReadFixture {
@@ -1722,7 +2782,7 @@ pub async fn prepare_changelog_read_with_selectivity(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<ChangelogReadFixture, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_selective_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     Ok(ChangelogReadFixture {
@@ -1735,7 +2795,7 @@ pub async fn prepare_changelog_read_entity_history(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<ChangelogReadFixture, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_entity_history_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     Ok(ChangelogReadFixture {
@@ -1750,7 +2810,7 @@ pub async fn changelog_encode_only_prepared(
     let mut verified_rows = 0;
     let mut encoded_bytes = 0;
     for change in &fixture.changes {
-        encoded_bytes += crate::changelog::codec::encode_change(change)?.len();
+        encoded_bytes += crate::commit_store::codec::encode_change_ref(change.as_ref())?.len();
         verified_rows += 1;
     }
     Ok(report(
@@ -1766,7 +2826,7 @@ pub async fn changelog_decode_only_prepared(
     let mut verified_rows = 0;
     let mut decoded_bytes = 0;
     for bytes in &fixture.encoded_changes {
-        let change = crate::changelog::codec::decode_change(bytes)?;
+        let change = crate::commit_store::codec::decode_change(bytes)?;
         decoded_bytes += change.schema_key.len();
         verified_rows += 1;
     }
@@ -1777,43 +2837,41 @@ pub async fn changelog_decode_only_prepared(
     ))
 }
 
-pub async fn changelog_load_change_hit_prepared(
+pub async fn changelog_load_changes_hit_prepared(
     backend: &Arc<dyn Backend + Send + Sync>,
     fixture: &ChangelogReadFixture,
 ) -> Result<StorageBenchReport, LixError> {
     let reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    let mut verified_rows = 0;
-    for index in 0..fixture.rows {
-        if reader
-            .load_change(&format!("bench-change-{index}"))
-            .await?
-            .is_some()
-        {
-            verified_rows += 1;
-        }
-    }
+    let change_ids = (0..fixture.rows)
+        .map(|index| format!("bench-change-{index}"))
+        .collect::<Vec<_>>();
+    let verified_rows = reader
+        .load_changes(&change_ids)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
     Ok(report(fixture.rows, verified_rows, Duration::ZERO))
 }
 
-pub async fn changelog_load_change_miss_prepared(
+pub async fn changelog_load_changes_miss_prepared(
     backend: &Arc<dyn Backend + Send + Sync>,
     fixture: &ChangelogReadFixture,
 ) -> Result<StorageBenchReport, LixError> {
     let reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    let mut misses = 0;
-    for index in 0..fixture.rows {
-        if reader
-            .load_change(&format!("missing-change-{index}"))
-            .await?
-            .is_none()
-        {
-            misses += 1;
-        }
-    }
+    let change_ids = (0..fixture.rows)
+        .map(|index| format!("missing-change-{index}"))
+        .collect::<Vec<_>>();
+    let misses = reader
+        .load_changes(&change_ids)
+        .await?
+        .into_iter()
+        .filter(Option::is_none)
+        .count();
     Ok(report(fixture.rows, misses, Duration::ZERO))
 }
 
@@ -1825,7 +2883,7 @@ pub async fn changelog_scan_all_prepared(
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
     let verified_rows = reader
-        .scan_changes(&ChangelogScanRequest::default())
+        .scan_changes(&ChangeScanRequest::default())
         .await?
         .len();
     Ok(report(fixture.rows, verified_rows, Duration::ZERO))
@@ -1847,7 +2905,7 @@ pub async fn changelog_scan_limit_100_prepared(
         .reader(StorageContext::new(Arc::clone(backend)));
     let expected = fixture.rows.min(100);
     let verified_rows = reader
-        .scan_changes(&ChangelogScanRequest {
+        .scan_changes(&ChangeScanRequest {
             limit: Some(expected),
         })
         .await?
@@ -1855,6 +2913,25 @@ pub async fn changelog_scan_limit_100_prepared(
     Ok(report(expected, verified_rows, Duration::ZERO))
 }
 
+pub async fn changelog_scan_change_set_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &ChangelogReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let reader = fixture
+        .context
+        .reader(StorageContext::new(Arc::clone(backend)));
+    let change_ids = (0..fixture.rows)
+        .map(|index| format!("bench-change-{index}"))
+        .collect::<Vec<_>>();
+    let verified_rows = reader
+        .load_changes(&change_ids)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
+    Ok(report(fixture.rows, verified_rows, Duration::ZERO))
+}
+
 pub async fn changelog_scan_schema_prepared(
     backend: &Arc<dyn Backend + Send + Sync>,
     fixture: &ChangelogReadFixture,
@@ -1863,12 +2940,10 @@ pub async fn changelog_scan_schema_prepared(
     let reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    let changes = reader
-        .scan_changes(&ChangelogScanRequest::default())
-        .await?;
+    let changes = reader.scan_changes(&ChangeScanRequest::default()).await?;
     let verified_rows = changes
         .iter()
-        .filter(|change| change.schema_key == CHANGELOG_MATCH_SCHEMA_KEY)
+        .filter(|change| change.record.schema_key == CHANGELOG_MATCH_SCHEMA_KEY)
         .count();
     Ok(report(
         selectivity.expected_rows(fixture.rows),
@@ -1884,13 +2959,11 @@ pub async fn changelog_scan_entity_history_prepared(
     let reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    let changes = reader
-        .scan_changes(&ChangelogScanRequest::default())
-        .await?;
+    let changes = reader.scan_changes(&ChangeScanRequest::default()).await?;
     let target = EntityIdentity::single(CHANGELOG_HISTORY_ENTITY_ID);
     let verified_rows = changes
         .iter()
-        .filter(|change| change.entity_id == target)
+        .filter(|change| change.record.entity_id == target)
         .count();
     Ok(report(
         fixture.rows.div_ceil(10),
@@ -1899,6 +2972,41 @@ pub async fn changelog_scan_entity_history_prepared(
     ))
 }
 
+pub async fn prepare_commit_graph_read(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+) -> Result<CommitGraphReadFixture, LixError> {
+    let changelog = CommitStoreContext::new();
+    let mut changes = changelog_materialized_changes(config);
+    let head_commit_id = "bench-commit-head".to_string();
+    changes.push(commit_graph_materialized_commit_change(
+        &head_commit_id,
+        config.rows,
+    ));
+    append_changelog_changes(backend, &changelog, &changes).await?;
+
+    Ok(CommitGraphReadFixture {
+        head_commit_id,
+        rows: config.rows,
+    })
+}
+
+pub async fn commit_graph_change_history_from_commit_prepared(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    fixture: &CommitGraphReadFixture,
+) -> Result<StorageBenchReport, LixError> {
+    let graph = crate::commit_graph::CommitGraphContext::new();
+    let mut reader = graph.reader(StorageContext::new(Arc::clone(backend)));
+    let verified_rows = reader
+        .change_history_from_commit(
+            &fixture.head_commit_id,
+            &CommitGraphChangeHistoryRequest::default(),
+        )
+        .await?
+        .len();
+    Ok(report(fixture.rows, verified_rows, Duration::ZERO))
+}
+
 pub async fn prepare_binary_cas_write_blobs(
     config: StorageBenchConfig,
 ) -> Result<BinaryCasWriteFixture, LixError> {
@@ -2029,9 +3137,24 @@ pub async fn json_store_write_prepared(
     {
         let mut writes = StorageWriteSet::new();
         let mut writer = fixture.context.writer();
-        for document in &fixture.documents {
-            writer.stage_bytes(&mut writes, document)?;
-        }
+        writer.stage_batch(
+            &mut writes,
+            JsonWritePlacementRef::OutOfBand,
+            fixture
+                .documents
+                .iter()
+                .map(|document| {
+                    std::str::from_utf8(document)
+                        .map(NormalizedJsonRef::new)
+                        .map_err(|error| {
+                            LixError::new(
+                                LixError::CODE_UNKNOWN,
+                                format!("benchmark JSON document is invalid UTF-8: {error}"),
+                            )
+                        })
+                })
+                .collect::<Result<Vec<_>, _>>()?,
+        )?;
         writes.apply(&mut transaction.as_mut()).await?;
     }
     transaction.commit().await?;
@@ -2070,9 +3193,26 @@ pub async fn prepare_json_store_projection_read(
     {
         let mut writes = StorageWriteSet::new();
         let mut writer = context.writer();
-        for document in documents {
-            refs.push(writer.stage_bytes(&mut writes, &document)?);
+        for document in &documents {
+            refs.push(prepare_json_ref(document)?);
         }
+        writer.stage_batch(
+            &mut writes,
+            JsonWritePlacementRef::OutOfBand,
+            documents
+                .iter()
+                .map(|document| {
+                    std::str::from_utf8(document)
+                        .map(NormalizedJsonRef::new)
+                        .map_err(|error| {
+                            LixError::new(
+                                LixError::CODE_UNKNOWN,
+                                format!("benchmark JSON document is invalid UTF-8: {error}"),
+                            )
+                        })
+                })
+                .collect::<Result<Vec<_>, _>>()?,
+        )?;
         writes.apply(&mut transaction.as_mut()).await?;
     }
     transaction.commit().await?;
@@ -2091,8 +3231,14 @@ pub async fn json_store_read_bytes_prepared(
     let mut reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    for json_ref in &fixture.refs {
-        if reader.load_bytes(json_ref).await?.is_some() {
+    let batch = reader
+        .load_bytes_many(JsonLoadRequestRef {
+            refs: &fixture.refs,
+            scope: JsonReadScopeRef::OutOfBand,
+        })
+        .await?;
+    for value in batch.values() {
+        if value.is_some() {
             verified_rows += 1;
         }
     }
@@ -2107,8 +3253,14 @@ pub async fn json_store_read_value_prepared(
     let mut reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    for json_ref in &fixture.refs {
-        if reader.load_json_value(json_ref).await?.is_some() {
+    let batch = reader
+        .load_values_many(JsonLoadRequestRef {
+            refs: &fixture.refs,
+            scope: JsonReadScopeRef::OutOfBand,
+        })
+        .await?;
+    for value in batch.values() {
+        if value.is_some() {
             verified_rows += 1;
         }
     }
@@ -2123,12 +3275,15 @@ pub async fn json_store_read_projection_prepared(
     let mut reader = fixture
         .context
         .reader(StorageContext::new(Arc::clone(backend)));
-    for json_ref in &fixture.refs {
-        if reader
-            .load_json_projection(json_ref, &fixture.paths)
-            .await?
-            .is_some()
-        {
+    let batch = reader
+        .load_projections_many(JsonProjectionLoadRequestRef {
+            refs: &fixture.refs,
+            scope: JsonReadScopeRef::OutOfBand,
+            paths: &fixture.paths,
+        })
+        .await?;
+    for value in batch.values() {
+        if value.is_some() {
             verified_rows += 1;
         }
     }
@@ -2162,9 +3317,26 @@ async fn prepare_json_store_base_update(
     {
         let mut writes = StorageWriteSet::new();
         let mut writer = context.writer();
-        for document in documents {
-            refs.push(writer.stage_bytes(&mut writes, &document)?);
+        for document in &documents {
+            refs.push(prepare_json_ref(document)?);
         }
+        writer.stage_batch(
+            &mut writes,
+            JsonWritePlacementRef::OutOfBand,
+            documents
+                .iter()
+                .map(|document| {
+                    std::str::from_utf8(document)
+                        .map(NormalizedJsonRef::new)
+                        .map_err(|error| {
+                            LixError::new(
+                                LixError::CODE_UNKNOWN,
+                                format!("benchmark JSON document is invalid UTF-8: {error}"),
+                            )
+                        })
+                })
+                .collect::<Result<Vec<_>, _>>()?,
+        )?;
         writes.apply(&mut transaction.as_mut()).await?;
     }
     transaction.commit().await?;
@@ -2205,10 +3377,29 @@ async fn json_store_write_against_base_prepared(
     {
         let mut writes = StorageWriteSet::new();
         let mut writer = fixture.context.writer();
+        let mut updated_documents = Vec::with_capacity(fixture.refs.len());
         for (index, _json_ref) in fixture.refs.iter().enumerate() {
             let updated = updated_json_document(shape, index);
-            writer.stage_bytes(&mut writes, &updated)?;
+            prepare_json_ref(&updated)?;
+            updated_documents.push(updated);
         }
+        writer.stage_batch(
+            &mut writes,
+            JsonWritePlacementRef::OutOfBand,
+            updated_documents
+                .iter()
+                .map(|document| {
+                    std::str::from_utf8(document)
+                        .map(NormalizedJsonRef::new)
+                        .map_err(|error| {
+                            LixError::new(
+                                LixError::CODE_UNKNOWN,
+                                format!("benchmark JSON document is invalid UTF-8: {error}"),
+                            )
+                        })
+                })
+                .collect::<Result<Vec<_>, _>>()?,
+        )?;
         writes.apply(&mut transaction.as_mut()).await?;
     }
     transaction.commit().await?;
@@ -2243,28 +3434,14 @@ pub async fn tracked_state_read_point_hit(
     write_tracked_root(backend, &context, "bench-tracked-commit", None, &rows).await?;
 
     let started = Instant::now();
-    let mut verified_rows = 0;
     let mut reader = context.reader(StorageContext::new(Arc::clone(backend)));
-    for index in 0..config.rows {
-        if reader
-            .load_row_at_commit(
-                "bench-tracked-commit",
-                &TrackedStateRowRequest {
-                    schema_key: tracked_schema_key(index, StorageBenchSelectivity::Percent100),
-                    entity_id: EntityIdentity::single(entity_id(
-                        "tracked",
-                        index,
-                        config.key_pattern,
-                    )),
-                    file_id: NullableKeyFilter::Value("bench.json".to_string()),
-                },
-            )
-            .await?
-            .is_some()
-        {
-            verified_rows += 1;
-        }
-    }
+    let requests = tracked_point_hit_requests(config.rows, config.key_pattern);
+    let verified_rows = reader
+        .load_rows_at_commit("bench-tracked-commit", &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
     Ok(report(config.rows, verified_rows, started.elapsed()))
 }
 
@@ -2277,24 +3454,14 @@ pub async fn tracked_state_read_point_miss(
     write_tracked_root(backend, &context, "bench-tracked-commit", None, &rows).await?;
 
     let started = Instant::now();
-    let mut misses = 0;
     let mut reader = context.reader(StorageContext::new(Arc::clone(backend)));
-    for index in 0..config.rows {
-        if reader
-            .load_row_at_commit(
-                "bench-tracked-commit",
-                &TrackedStateRowRequest {
-                    schema_key: tracked_schema_key(index, StorageBenchSelectivity::Percent100),
-                    entity_id: EntityIdentity::single(format!("missing-{index}")),
-                    file_id: NullableKeyFilter::Value("bench.json".to_string()),
-                },
-            )
-            .await?
-            .is_none()
-        {
-            misses += 1;
-        }
-    }
+    let requests = tracked_point_miss_requests(config.rows, StorageBenchSelectivity::Percent100);
+    let misses = reader
+        .load_rows_at_commit("bench-tracked-commit", &requests)
+        .await?
+        .into_iter()
+        .filter(Option::is_none)
+        .count();
     Ok(report(config.rows, misses, started.elapsed()))
 }
 
@@ -2559,61 +3726,59 @@ pub async fn changelog_append_changes(
     config: StorageBenchConfig,
 ) -> Result<StorageBenchReport, LixError> {
     let changes = changelog_materialized_changes(config);
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let started = Instant::now();
     append_changelog_changes(backend, &context, &changes).await?;
     let elapsed = started.elapsed();
     let reader = context.reader(StorageContext::new(Arc::clone(backend)));
     let verified_rows = reader
-        .scan_changes(&ChangelogScanRequest::default())
+        .scan_changes(&ChangeScanRequest::default())
         .await?
         .len();
     Ok(report(changes.len(), verified_rows, elapsed))
 }
 
-pub async fn changelog_load_change_hit(
+pub async fn changelog_load_changes_hit(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<StorageBenchReport, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_materialized_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     let reader = context.reader(StorageContext::new(Arc::clone(backend)));
 
     let started = Instant::now();
-    let mut verified_rows = 0;
-    for index in 0..config.rows {
-        if reader
-            .load_change(&format!("bench-change-{index}"))
-            .await?
-            .is_some()
-        {
-            verified_rows += 1;
-        }
-    }
+    let change_ids = (0..config.rows)
+        .map(|index| format!("bench-change-{index}"))
+        .collect::<Vec<_>>();
+    let verified_rows = reader
+        .load_changes(&change_ids)
+        .await?
+        .into_iter()
+        .filter(Option::is_some)
+        .count();
     Ok(report(config.rows, verified_rows, started.elapsed()))
 }
 
-pub async fn changelog_load_change_miss(
+pub async fn changelog_load_changes_miss(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<StorageBenchReport, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_materialized_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     let reader = context.reader(StorageContext::new(Arc::clone(backend)));
 
     let started = Instant::now();
-    let mut misses = 0;
-    for index in 0..config.rows {
-        if reader
-            .load_change(&format!("missing-change-{index}"))
-            .await?
-            .is_none()
-        {
-            misses += 1;
-        }
-    }
+    let change_ids = (0..config.rows)
+        .map(|index| format!("missing-change-{index}"))
+        .collect::<Vec<_>>();
+    let misses = reader
+        .load_changes(&change_ids)
+        .await?
+        .into_iter()
+        .filter(Option::is_none)
+        .count();
     Ok(report(config.rows, misses, started.elapsed()))
 }
 
@@ -2621,14 +3786,14 @@ pub async fn changelog_scan_all(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<StorageBenchReport, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_materialized_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     let reader = context.reader(StorageContext::new(Arc::clone(backend)));
 
     let started = Instant::now();
     let verified_rows = reader
-        .scan_changes(&ChangelogScanRequest::default())
+        .scan_changes(&ChangeScanRequest::default())
         .await?
         .len();
     Ok(report(config.rows, verified_rows, started.elapsed()))
@@ -2638,7 +3803,7 @@ pub async fn changelog_scan_limit_100(
     backend: &Arc<dyn Backend + Send + Sync>,
     config: StorageBenchConfig,
 ) -> Result<StorageBenchReport, LixError> {
-    let context = ChangelogContext::new();
+    let context = CommitStoreContext::new();
     let changes = changelog_materialized_changes(config);
     append_changelog_changes(backend, &context, &changes).await?;
     let reader = context.reader(StorageContext::new(Arc::clone(backend)));
@@ -2646,7 +3811,7 @@ pub async fn changelog_scan_limit_100(
 
     let started = Instant::now();
     let verified_rows = reader
-        .scan_changes(&ChangelogScanRequest {
+        .scan_changes(&ChangeScanRequest {
             limit: Some(expected),
         })
         .await?
@@ -2747,36 +3912,181 @@ async fn write_tracked_root(
     context: &TrackedStateContext,
     commit_id: &str,
     parent_commit_id: Option<&str>,
-    rows: &[TrackedStateRow],
+    rows: &[MaterializedTrackedStateRow],
 ) -> Result<(), LixError> {
     let storage = StorageContext::new(Arc::clone(backend));
     let mut transaction = storage.begin_write_transaction().await?;
-    {
-        let mut writes = StorageWriteSet::new();
-        {
-            let mut json_writer = JsonStoreContext::new().writer();
-            context
-                .writer()
-                .stage_root(
-                    &mut transaction.as_mut(),
-                    &mut writes,
-                    &mut json_writer,
-                    commit_id,
-                    parent_commit_id,
-                    rows,
-                )
-                .await?;
+    let mut writes = StorageWriteSet::new();
+    let changes = rows
+        .iter()
+        .map(tracked_bench_change_from_materialized)
+        .collect::<Result<Vec<_>, _>>()?;
+    let payloads = tracked_bench_json_payloads(rows, &changes);
+    let json_report = JsonStoreContext::new().writer().stage_batch_report(
+        &mut writes,
+        JsonWritePlacementRef::CommitPack {
+            commit_id,
+            pack_id: 0,
+        },
+        payloads.iter().map(|(payload, json_ref)| match json_ref {
+            Some(json_ref) => NormalizedJsonRef::trusted_prehashed(payload.as_str(), *json_ref),
+            None => NormalizedJsonRef::new(payload.as_str()),
+        }),
+    )?;
+
+    let parent_ids = parent_commit_id
+        .map(|parent| vec![parent.to_string()])
+        .unwrap_or_default();
+    let commit_change_id = format!("{commit_id}:commit");
+    let commit = CommitDraftRef {
+        id: commit_id,
+        change_id: &commit_change_id,
+        parent_ids: &parent_ids,
+        author_account_ids: &[],
+        created_at: rows
+            .first()
+            .map(|row| row.updated_at.as_str())
+            .unwrap_or("1970-01-01T00:00:00.000Z"),
+    };
+    let commit_store = CommitStoreContext::new();
+    let authored_changes = changes.iter().map(Change::as_ref).collect::<Vec<_>>();
+    let staged = commit_store
+        .writer(&mut transaction.as_mut(), &mut writes)
+        .stage_tracked_commit_draft(commit, authored_changes.clone(), Vec::new())
+        .await?;
+    let mut deltas = Vec::with_capacity(changes.len());
+    deltas.extend(
+        authored_changes
+            .iter()
+            .zip(&staged.authored_locators)
+            .zip(rows)
+            .map(|((change, locator), row)| TrackedStateDeltaRef {
+                change: *change,
+                locator: locator.as_ref(),
+                created_at: row.created_at.as_str(),
+                updated_at: row.updated_at.as_str(),
+            }),
+    );
+    context
+        .writer(&mut transaction.as_mut(), &mut writes)
+        .stage_delta_with_json_pack_indexes(
+            commit_id,
+            parent_commit_id,
+            &deltas,
+            crate::tracked_state::DeltaJsonPackIndexesRef {
+                commit_id,
+                pack_id: 0,
+                indexes: &json_report.pack_indexes,
+            },
+        )
+        .await?;
+    writes.apply(&mut transaction.as_mut()).await?;
+    transaction.commit().await
+}
+
+async fn materialize_tracked_root(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    context: &TrackedStateContext,
+    commit_id: &str,
+) -> Result<(), LixError> {
+    let storage = StorageContext::new(Arc::clone(backend));
+    let mut transaction = storage.begin_write_transaction().await?;
+    let mut writes = StorageWriteSet::new();
+    let commit_store = CommitStoreContext::new();
+    context
+        .materializer(&mut transaction.as_mut(), &mut writes, &commit_store)
+        .materialize_root_at(commit_id)
+        .await?;
+    writes.apply(&mut transaction.as_mut()).await?;
+    transaction.commit().await
+}
+
+async fn write_tracked_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    config: StorageBenchConfig,
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<(TrackedStateContext, String), LixError> {
+    let context = TrackedStateContext::new();
+    let base_commit_id = "bench-tracked-base";
+    let rows = tracked_rows(config, base_commit_id);
+    write_tracked_root(backend, &context, base_commit_id, None, &rows).await?;
+
+    let mut parent_commit_id = base_commit_id.to_string();
+    for delta_index in 0..delta_commits {
+        let commit_id = format!("bench-tracked-delta-{delta_index}");
+        let mut updated_rows = tracked_rows(
+            config.with_rows(updated_rows_per_commit.min(config.rows)),
+            &commit_id,
+        );
+        for (row_index, row) in updated_rows.iter_mut().enumerate() {
+            row.snapshot_content = Some(delta_chain_snapshot_content(
+                delta_index,
+                row_index,
+                config.state_payload_bytes,
+            ));
+            row.updated_at = timestamp(config.rows + delta_index * config.rows + row_index);
         }
-        writes.apply(&mut transaction.as_mut()).await?;
+        write_tracked_root(
+            backend,
+            &context,
+            &commit_id,
+            Some(parent_commit_id.as_str()),
+            &updated_rows,
+        )
+        .await?;
+        parent_commit_id = commit_id;
     }
-    transaction.commit().await
+
+    Ok((context, parent_commit_id))
+}
+
+fn tracked_bench_change_from_materialized(
+    row: &MaterializedTrackedStateRow,
+) -> Result<Change, LixError> {
+    Ok(Change {
+        id: row.change_id.clone(),
+        entity_id: row.entity_id.clone(),
+        schema_key: row.schema_key.clone(),
+        file_id: row.file_id.clone(),
+        snapshot_ref: row
+            .snapshot_content
+            .as_deref()
+            .map(|value| prepare_json_ref(value.as_bytes()))
+            .transpose()?,
+        metadata_ref: row
+            .metadata
+            .as_ref()
+            .map(|value| {
+                let serialized = crate::serialize_row_metadata(value);
+                prepare_json_ref(serialized.as_bytes())
+            })
+            .transpose()?,
+        created_at: row.created_at.clone(),
+    })
+}
+
+fn tracked_bench_json_payloads(
+    rows: &[MaterializedTrackedStateRow],
+    changes: &[Change],
+) -> Vec<(String, Option<JsonRef>)> {
+    let mut payloads = Vec::new();
+    for (row, change) in rows.iter().zip(changes) {
+        if let Some(snapshot) = row.snapshot_content.as_deref() {
+            payloads.push((snapshot.to_string(), change.snapshot_ref));
+        }
+        if let Some(metadata) = row.metadata.as_ref() {
+            payloads.push((crate::serialize_row_metadata(metadata), change.metadata_ref));
+        }
+    }
+    payloads
 }
 
 async fn scan_tracked(
     backend: &Arc<dyn Backend + Send + Sync>,
     context: &TrackedStateContext,
     commit_id: &str,
-) -> Result<Vec<TrackedStateRow>, LixError> {
+) -> Result<Vec<MaterializedTrackedStateRow>, LixError> {
     let mut reader = context.reader(StorageContext::new(Arc::clone(backend)));
     reader
         .scan_rows_at_commit(commit_id, &TrackedStateScanRequest::default())
@@ -2792,14 +4102,12 @@ async fn write_untracked_rows(
     let mut transaction = storage.begin_write_transaction().await?;
     {
         let mut writes = StorageWriteSet::new();
-        let canonical_rows = {
-            let mut json_writer = JsonStoreContext::new().writer();
-            rows.iter()
-                .map(|row| canonicalize_materialized_row(&mut writes, &mut json_writer, row))
-                .collect::<Result<Vec<_>, _>>()?
-        };
+        let canonical_rows = rows
+            .iter()
+            .map(|row| crate::test_support::untracked_state_row_from_materialized(&mut writes, row))
+            .collect::<Result<Vec<_>, _>>()?;
         let mut writer = context.writer(&mut writes);
-        writer.stage_rows(&canonical_rows)?;
+        writer.stage_rows(canonical_rows.iter().map(|row| row.as_ref()))?;
         writes.apply(&mut transaction.as_mut()).await?;
     }
     transaction.commit().await
@@ -2816,24 +4124,47 @@ async fn scan_untracked(
 
 async fn append_changelog_changes(
     backend: &Arc<dyn Backend + Send + Sync>,
-    context: &ChangelogContext,
-    changes: &[MaterializedCanonicalChange],
+    context: &CommitStoreContext,
+    changes: &[MaterializedChange],
 ) -> Result<(), LixError> {
     let storage = StorageContext::new(Arc::clone(backend));
     let mut transaction = storage.begin_write_transaction().await?;
     {
         let mut writes = StorageWriteSet::new();
-        let canonical_changes = {
-            let mut json_writer = JsonStoreContext::new().writer();
-            changes
+        let canonical_changes = changes
+            .iter()
+            .map(canonical_changelog_bench_change)
+            .collect::<Result<Vec<_>, _>>()?;
+        let payloads = changelog_bench_json_payloads(changes);
+        JsonStoreContext::new().writer().stage_batch(
+            &mut writes,
+            JsonWritePlacementRef::OutOfBand,
+            payloads
                 .iter()
-                .map(|change| {
-                    canonicalize_materialized_change(&mut writes, &mut json_writer, change)
-                })
-                .collect::<Result<Vec<_>, _>>()?
-        };
-        let mut writer = context.writer(&mut writes);
-        writer.stage_changes(&canonical_changes)?;
+                .map(|payload| NormalizedJsonRef::new(payload.as_str())),
+        )?;
+        let parent_ids = Vec::new();
+        let author_account_ids = vec!["bench-author".to_string()];
+        {
+            let mut transaction_ref = transaction.as_mut();
+            let mut writer = context.writer(&mut transaction_ref, &mut writes);
+            writer
+                .stage_commit_draft(
+                    CommitDraftRef {
+                        id: "bench-changelog-commit-0",
+                        change_id: "bench-changelog-header-change-0",
+                        parent_ids: &parent_ids,
+                        author_account_ids: &author_account_ids,
+                        created_at: "2024-01-01T00:00:00.000Z",
+                    },
+                    canonical_changes
+                        .iter()
+                        .map(|change| change.as_ref())
+                        .collect(),
+                    Vec::new(),
+                )
+                .await?;
+        }
         writes.apply(&mut transaction.as_mut()).await?;
     }
     transaction.commit().await
@@ -2879,29 +4210,101 @@ const CHANGELOG_MATCH_SCHEMA_KEY: &str = "bench_changelog_entity";
 const CHANGELOG_OTHER_SCHEMA_KEY: &str = "bench_changelog_other_entity";
 const CHANGELOG_HISTORY_ENTITY_ID: &str = "change-entity-history-target";
 
-fn tracked_rows(config: StorageBenchConfig, commit_id: &str) -> Vec<TrackedStateRow> {
+fn tracked_rows(config: StorageBenchConfig, commit_id: &str) -> Vec<MaterializedTrackedStateRow> {
     (0..config.rows)
-        .map(|index| TrackedStateRow {
+        .map(|index| MaterializedTrackedStateRow {
             entity_id: EntityIdentity::single(entity_id("tracked", index, config.key_pattern)),
             schema_key: tracked_schema_key(index, config.selectivity),
             file_id: Some("bench.json".to_string()),
             snapshot_content: Some(snapshot_content(index, config.state_payload_bytes)),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: timestamp(index),
             updated_at: timestamp(index),
-            change_id: format!("tracked-change-{index}"),
+            change_id: tracked_change_id(commit_id, index),
             commit_id: commit_id.to_string(),
         })
         .collect()
 }
 
+fn json_pointer_tracked_rows(
+    rows: &[JsonPointerStorageRow],
+    commit_id: &str,
+    updated: bool,
+) -> Vec<MaterializedTrackedStateRow> {
+    rows.iter()
+        .enumerate()
+        .map(|(index, row)| {
+            let value_json = if updated {
+                row.updated_value_json.as_str()
+            } else {
+                row.value_json.as_str()
+            };
+            let value = serde_json::from_str::<serde_json::Value>(value_json)
+                .unwrap_or_else(|_| serde_json::Value::String(value_json.to_string()));
+            let snapshot = serde_json::json!({
+                "path": row.path,
+                "value": value,
+            })
+            .to_string();
+            MaterializedTrackedStateRow {
+                entity_id: EntityIdentity::single(row.path.as_str()),
+                schema_key: "json_pointer".to_string(),
+                file_id: None,
+                snapshot_content: Some(snapshot),
+                metadata: None,
+                deleted: false,
+                created_at: timestamp(index),
+                updated_at: timestamp(index),
+                change_id: tracked_change_id(commit_id, index),
+                commit_id: commit_id.to_string(),
+            }
+        })
+        .collect()
+}
+
+async fn write_json_pointer_delta_chain(
+    backend: &Arc<dyn Backend + Send + Sync>,
+    rows: &[JsonPointerStorageRow],
+    delta_commits: usize,
+    updated_rows_per_commit: usize,
+) -> Result<(TrackedStateContext, String), LixError> {
+    let context = TrackedStateContext::new();
+    let base_commit_id = "json-pointer-base";
+    let base_rows = json_pointer_tracked_rows(rows, base_commit_id, false);
+    write_tracked_root(backend, &context, base_commit_id, None, &base_rows).await?;
+
+    let mut parent_commit_id = base_commit_id.to_string();
+    for delta_index in 0..delta_commits {
+        let commit_id = format!("json-pointer-delta-{delta_index}");
+        let mut child_rows = json_pointer_tracked_rows(
+            &rows[..updated_rows_per_commit.min(rows.len())],
+            &commit_id,
+            true,
+        );
+        for row in &mut child_rows {
+            row.updated_at = timestamp(rows.len() + delta_index);
+        }
+        write_tracked_root(
+            backend,
+            &context,
+            &commit_id,
+            Some(parent_commit_id.as_str()),
+            &child_rows,
+        )
+        .await?;
+        parent_commit_id = commit_id;
+    }
+
+    Ok((context, parent_commit_id))
+}
+
 fn tracked_rows_file_selective(
     config: StorageBenchConfig,
     commit_id: &str,
-) -> Vec<TrackedStateRow> {
+) -> Vec<MaterializedTrackedStateRow> {
     (0..config.rows)
-        .map(|index| TrackedStateRow {
+        .map(|index| MaterializedTrackedStateRow {
             entity_id: EntityIdentity::single(entity_id("tracked", index, config.key_pattern)),
             schema_key: TRACKED_MATCH_SCHEMA_KEY.to_string(),
             file_id: Some(
@@ -2914,15 +4317,19 @@ fn tracked_rows_file_selective(
             ),
             snapshot_content: Some(snapshot_content(index, config.state_payload_bytes)),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: timestamp(index),
             updated_at: timestamp(index),
-            change_id: format!("tracked-change-{index}"),
+            change_id: tracked_change_id(commit_id, index),
             commit_id: commit_id.to_string(),
         })
         .collect()
 }
 
+fn tracked_change_id(commit_id: &str, index: usize) -> String {
+    format!("{commit_id}:tracked-change-{index}")
+}
+
 fn untracked_rows(config: StorageBenchConfig) -> Vec<MaterializedUntrackedStateRow> {
     (0..config.rows)
         .map(|index| MaterializedUntrackedStateRow {
@@ -2931,7 +4338,7 @@ fn untracked_rows(config: StorageBenchConfig) -> Vec<MaterializedUntrackedStateR
             file_id: Some("bench.json".to_string()),
             snapshot_content: Some(snapshot_content(index, config.state_payload_bytes)),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: timestamp(index),
             updated_at: timestamp(index),
             global: false,
@@ -2940,16 +4347,16 @@ fn untracked_rows(config: StorageBenchConfig) -> Vec<MaterializedUntrackedStateR
         .collect()
 }
 
-fn changelog_changes(config: StorageBenchConfig) -> Vec<CanonicalChange> {
+fn changelog_changes(config: StorageBenchConfig) -> Vec<Change> {
     changelog_materialized_changes(config)
         .into_iter()
-        .map(canonical_changelog_bench_change)
+        .map(changelog_bench_change_ref_only)
         .collect()
 }
 
-fn changelog_materialized_changes(config: StorageBenchConfig) -> Vec<MaterializedCanonicalChange> {
+fn changelog_materialized_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     (0..config.rows)
-        .map(|index| MaterializedCanonicalChange {
+        .map(|index| MaterializedChange {
             id: format!("bench-change-{index}"),
             entity_id: EntityIdentity::single(entity_id(
                 "change-entity",
@@ -2957,7 +4364,6 @@ fn changelog_materialized_changes(config: StorageBenchConfig) -> Vec<Materialize
                 config.key_pattern,
             )),
             schema_key: "bench_changelog_entity".to_string(),
-            schema_version: "1".to_string(),
             file_id: Some("bench.json".to_string()),
             snapshot_content: Some(snapshot_content(index, config.state_payload_bytes)),
             metadata: None,
@@ -2966,21 +4372,72 @@ fn changelog_materialized_changes(config: StorageBenchConfig) -> Vec<Materialize
         .collect()
 }
 
-fn canonical_changelog_bench_change(change: MaterializedCanonicalChange) -> CanonicalChange {
+fn commit_graph_materialized_commit_change(commit_id: &str, rows: usize) -> MaterializedChange {
+    let snapshot_content = serde_json::json!({
+        "id": commit_id,
+    })
+    .to_string();
+
+    MaterializedChange {
+        id: format!("bench-commit-change-{commit_id}"),
+        entity_id: EntityIdentity::single(commit_id.to_string()),
+        schema_key: "lix_commit".to_string(),
+        file_id: None,
+        snapshot_content: Some(snapshot_content),
+        metadata: None,
+        created_at: timestamp(rows),
+    }
+}
+
+fn canonical_changelog_bench_change(change: &MaterializedChange) -> Result<Change, LixError> {
+    let snapshot_ref = change
+        .snapshot_content
+        .as_ref()
+        .map(|value| prepare_json_ref(value.as_bytes()))
+        .transpose()?;
+    let metadata_ref = change
+        .metadata
+        .as_ref()
+        .map(|value| prepare_json_ref(value.as_bytes()))
+        .transpose()?;
+    Ok(Change {
+        id: change.id.clone(),
+        entity_id: change.entity_id.clone(),
+        schema_key: change.schema_key.clone(),
+        file_id: change.file_id.clone(),
+        snapshot_ref,
+        metadata_ref,
+        created_at: change.created_at.clone(),
+    })
+}
+
+fn changelog_bench_json_payloads(changes: &[MaterializedChange]) -> Vec<String> {
+    changes
+        .iter()
+        .flat_map(|change| {
+            change
+                .snapshot_content
+                .iter()
+                .chain(change.metadata.iter())
+                .cloned()
+                .collect::<Vec<_>>()
+        })
+        .collect()
+}
+
+fn changelog_bench_change_ref_only(change: MaterializedChange) -> Change {
     let snapshot_ref = change
         .snapshot_content
         .as_ref()
         .map(|value| JsonRef::from_hash(blake3::hash(value.as_bytes())));
-    let metadata_ref = change.metadata.as_ref().map(|value| {
-        let bytes =
-            serde_json::to_vec(value).expect("bench metadata should serialize to JSON bytes");
-        JsonRef::from_hash(blake3::hash(&bytes))
-    });
-    CanonicalChange {
+    let metadata_ref = change
+        .metadata
+        .as_ref()
+        .map(|value| JsonRef::from_hash(blake3::hash(value.as_bytes())));
+    Change {
         id: change.id,
         entity_id: change.entity_id,
         schema_key: change.schema_key,
-        schema_version: change.schema_version,
         file_id: change.file_id,
         snapshot_ref,
         metadata_ref,
@@ -2988,7 +4445,7 @@ fn canonical_changelog_bench_change(change: MaterializedCanonicalChange) -> Cano
     }
 }
 
-fn changelog_tombstone_changes(config: StorageBenchConfig) -> Vec<MaterializedCanonicalChange> {
+fn changelog_tombstone_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     changelog_materialized_changes(config)
         .into_iter()
         .map(|mut change| {
@@ -2999,7 +4456,7 @@ fn changelog_tombstone_changes(config: StorageBenchConfig) -> Vec<MaterializedCa
         .collect()
 }
 
-fn changelog_metadata_changes(config: StorageBenchConfig) -> Vec<MaterializedCanonicalChange> {
+fn changelog_metadata_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     changelog_materialized_changes(config)
         .into_iter()
         .enumerate()
@@ -3010,9 +4467,7 @@ fn changelog_metadata_changes(config: StorageBenchConfig) -> Vec<MaterializedCan
         .collect()
 }
 
-fn changelog_shared_payload_changes(
-    config: StorageBenchConfig,
-) -> Vec<MaterializedCanonicalChange> {
+fn changelog_shared_payload_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     let shared_snapshot_content = snapshot_content(0, config.state_payload_bytes);
     changelog_materialized_changes(config)
         .into_iter()
@@ -3023,9 +4478,7 @@ fn changelog_shared_payload_changes(
         .collect()
 }
 
-fn changelog_shared_metadata_changes(
-    config: StorageBenchConfig,
-) -> Vec<MaterializedCanonicalChange> {
+fn changelog_shared_metadata_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     let shared_metadata = snapshot_metadata(0, config.state_payload_bytes);
     changelog_materialized_changes(config)
         .into_iter()
@@ -3039,7 +4492,7 @@ fn changelog_shared_metadata_changes(
 
 fn changelog_shared_payload_and_metadata_changes(
     config: StorageBenchConfig,
-) -> Vec<MaterializedCanonicalChange> {
+) -> Vec<MaterializedChange> {
     let shared_snapshot_content = snapshot_content(0, config.state_payload_bytes);
     let shared_metadata = snapshot_metadata(1, config.state_payload_bytes);
     changelog_materialized_changes(config)
@@ -3052,22 +4505,16 @@ fn changelog_shared_payload_and_metadata_changes(
         .collect()
 }
 
-fn changelog_composite_entity_id_changes(
-    config: StorageBenchConfig,
-) -> Vec<MaterializedCanonicalChange> {
+fn changelog_composite_entity_id_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     changelog_materialized_changes(config)
         .into_iter()
         .enumerate()
         .map(|(index, mut change)| {
             change.entity_id = EntityIdentity {
                 parts: vec![
-                    EntityIdentityPart::String(entity_id(
-                        "change-composite",
-                        index,
-                        config.key_pattern,
-                    )),
-                    EntityIdentityPart::Number(index.to_string()),
-                    EntityIdentityPart::Bool(index % 2 == 0),
+                    entity_id("change-composite", index, config.key_pattern),
+                    index.to_string(),
+                    (index % 2 == 0).to_string(),
                 ],
             };
             change
@@ -3075,7 +4522,7 @@ fn changelog_composite_entity_id_changes(
         .collect()
 }
 
-fn changelog_selective_changes(config: StorageBenchConfig) -> Vec<MaterializedCanonicalChange> {
+fn changelog_selective_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     changelog_materialized_changes(config)
         .into_iter()
         .enumerate()
@@ -3086,9 +4533,7 @@ fn changelog_selective_changes(config: StorageBenchConfig) -> Vec<MaterializedCa
         .collect()
 }
 
-fn changelog_entity_history_changes(
-    config: StorageBenchConfig,
-) -> Vec<MaterializedCanonicalChange> {
+fn changelog_entity_history_changes(config: StorageBenchConfig) -> Vec<MaterializedChange> {
     changelog_materialized_changes(config)
         .into_iter()
         .enumerate()
@@ -3187,16 +4632,14 @@ fn snapshot_content(index: usize, target_bytes: usize) -> String {
     value.to_string()
 }
 
-fn snapshot_metadata(index: usize, target_bytes: usize) -> serde_json::Value {
-    serde_json::from_str(&snapshot_content(index, target_bytes))
-        .expect("bench snapshot content should be valid JSON metadata")
+fn snapshot_metadata(index: usize, target_bytes: usize) -> String {
+    snapshot_content(index, target_bytes)
 }
 
 fn tracked_state_header_columns() -> Vec<String> {
     [
         "entity_id",
         "schema_key",
-        "schema_version",
         "file_id",
         "metadata",
         "created_at",
@@ -3213,7 +4656,6 @@ fn untracked_state_header_columns() -> Vec<String> {
     [
         "entity_id",
         "schema_key",
-        "schema_version",
         "file_id",
         "metadata",
         "created_at",
@@ -3247,6 +4689,21 @@ fn partial_updated_snapshot_content(index: usize, target_bytes: usize) -> String
     value.to_string()
 }
 
+fn delta_chain_snapshot_content(
+    delta_index: usize,
+    row_index: usize,
+    target_bytes: usize,
+) -> String {
+    let mut value = serde_json::json!({
+        "id": format!("entity-{row_index}"),
+        "value": format!("delta-{delta_index}-{row_index}"),
+        "index": row_index,
+        "delta": delta_index
+    });
+    pad_snapshot_content(&mut value, target_bytes);
+    value.to_string()
+}
+
 fn pad_snapshot_content(value: &mut serde_json::Value, target_bytes: usize) {
     let current = value.to_string().len();
     if target_bytes <= current {