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

package/dist-engine-src/src/tracked_state/tree.rs

@@ -5,7 +5,7 @@ use std::{
     pin::Pin,
 };
 
-use crate::storage::{StorageReader, StorageWriteSet};
+use crate::storage::{StorageRead, StorageWriteSet};
 use crate::tracked_state::codec::{
     boundary_trigger, child_summary_from_node, decode_key, decode_key_with_trusted_prefix,
     decode_node, decode_node_ref, decode_value, decode_visible_value, encode_internal_node,
@@ -46,7 +46,7 @@ impl Default for TrackedStateTreeOptions {
 
 /// Content-addressed tracked-state tree operations.
 ///
-/// This type owns tracked-state tree mechanics only. Version refs, untracked overlay,
+/// This type owns tracked-state tree mechanics only. Branch refs, untracked overlay,
 /// and SQL visibility remain outside the tree.
 #[derive(Debug, Clone)]
 pub(crate) struct TrackedStateTree {
@@ -60,14 +60,14 @@ impl TrackedStateTree {
         }
     }
 
-    #[allow(dead_code)]
+    #[cfg(test)]
     pub(crate) fn with_options(options: TrackedStateTreeOptions) -> Self {
         Self { options }
     }
 
     pub(crate) async fn load_root(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         commit_id: &str,
     ) -> Result<Option<TrackedStateRootId>, LixError> {
         storage::load_root(store, commit_id).await
@@ -76,7 +76,7 @@ impl TrackedStateTree {
     #[cfg(test)]
     pub(crate) async fn get(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         root_id: &TrackedStateRootId,
         key: &TrackedStateKey,
     ) -> Result<Option<TrackedStateIndexValue>, LixError> {
@@ -112,7 +112,7 @@ impl TrackedStateTree {
 
     pub(crate) async fn get_many(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         root_id: &TrackedStateRootId,
         keys: &[TrackedStateKey],
     ) -> Result<Vec<Option<TrackedStateIndexValue>>, LixError> {
@@ -133,24 +133,9 @@ impl TrackedStateTree {
         Ok(values)
     }
 
-    pub(crate) async fn row_count(
-        &self,
-        store: &mut impl StorageReader,
-        root_id: &TrackedStateRootId,
-    ) -> Result<usize, LixError> {
-        match self.load_node(store, root_id.as_bytes()).await? {
-            DecodedNode::Leaf(leaf) => Ok(leaf.entries().len()),
-            DecodedNode::Internal(internal) => Ok(internal
-                .children()
-                .iter()
-                .map(|child| child.subtree_count as usize)
-                .sum()),
-        }
-    }
-
     pub(crate) async fn scan(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         root_id: &TrackedStateRootId,
         request: &TrackedStateTreeScanRequest,
     ) -> Result<Vec<(TrackedStateKey, TrackedStateIndexValue)>, LixError> {
@@ -173,24 +158,9 @@ impl TrackedStateTree {
         Ok(rows)
     }
 
-    pub(crate) async fn count_matching_keys(
-        &self,
-        store: &mut impl StorageReader,
-        root_id: &TrackedStateRootId,
-        request: &TrackedStateTreeScanRequest,
-    ) -> Result<usize, LixError> {
-        if request.limit == Some(0) {
-            return Ok(0);
-        }
-
-        let ranges = scan_ranges(request);
-        self.count_matching_keys_node(store, *root_id.as_bytes(), request, &ranges)
-            .await
-    }
-
     pub(crate) async fn diff(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         left_root: Option<&TrackedStateRootId>,
         right_root: Option<&TrackedStateRootId>,
         request: &TrackedStateTreeScanRequest,
@@ -231,27 +201,41 @@ impl TrackedStateTree {
         }
     }
 
+    #[cfg(test)]
     pub(crate) async fn apply_mutations(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         writes: &mut StorageWriteSet,
         base_root: Option<&TrackedStateRootId>,
-        mut mutations: Vec<TrackedStateMutation>,
+        mutations: Vec<TrackedStateMutation>,
         commit_id: Option<&str>,
     ) -> Result<TrackedStateApplyResult, LixError> {
         let mut overlay = storage::TrackedStateChunkOverlay::new();
+        self.apply_mutations_with_overlay(
+            store,
+            writes,
+            &mut overlay,
+            base_root,
+            mutations,
+            commit_id,
+        )
+        .await
+    }
+
+    pub(crate) async fn apply_mutations_with_overlay(
+        &self,
+        store: &(impl StorageRead + Send + Sync + ?Sized),
+        writes: &mut StorageWriteSet,
+        overlay: &mut storage::TrackedStateChunkOverlay,
+        base_root: Option<&TrackedStateRootId>,
+        mut mutations: Vec<TrackedStateMutation>,
+        commit_id: Option<&str>,
+    ) -> Result<TrackedStateApplyResult, LixError> {
         if let Some(root_id) = base_root {
             if mutations.len() == 1 {
                 let mutation = mutations.pop().expect("single mutation should exist");
                 match self
-                    .apply_single_mutation(
-                        store,
-                        writes,
-                        &mut overlay,
-                        root_id,
-                        mutation,
-                        commit_id,
-                    )
+                    .apply_single_mutation(store, writes, overlay, root_id, mutation, commit_id)
                     .await?
                 {
                     MutationApply::Applied(result) => return Ok(result),
@@ -260,12 +244,7 @@ impl TrackedStateTree {
             } else if mutations.len() > 1 {
                 match self
                     .apply_sorted_mutations_chunker(
-                        store,
-                        writes,
-                        &mut overlay,
-                        root_id,
-                        mutations,
-                        commit_id,
+                        store, writes, overlay, root_id, mutations, commit_id,
                     )
                     .await?
                 {
@@ -277,7 +256,7 @@ impl TrackedStateTree {
 
         let mut entries = match base_root {
             Some(root_id) => self
-                .collect_leaf_entries(store, root_id)
+                .collect_leaf_entries_with_overlay(store, overlay, root_id)
                 .await?
                 .into_iter()
                 .map(|entry| (entry.key, entry.value))
@@ -298,12 +277,6 @@ impl TrackedStateTree {
                 .collect(),
         )?;
         overlay.stage_chunks(writes, &built.chunks);
-        let persisted_root = if let Some(commit_id) = commit_id {
-            storage::stage_root(writes, commit_id, &built.root_id);
-            true
-        } else {
-            false
-        };
 
         Ok(TrackedStateApplyResult {
             root_id: built.root_id,
@@ -311,13 +284,12 @@ impl TrackedStateTree {
             tree_height: built.tree_height,
             chunk_count: built.chunks.len(),
             chunk_bytes: built.chunk_bytes,
-            persisted_root,
         })
     }
 
     async fn apply_single_mutation(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         writes: &mut StorageWriteSet,
         overlay: &mut storage::TrackedStateChunkOverlay,
         root_id: &TrackedStateRootId,
@@ -447,12 +419,6 @@ impl TrackedStateTree {
             suffix_entries[mutation_entry_index].key.as_slice(),
         )?;
         overlay.stage_chunks(writes, &built.chunks);
-        let persisted_root = if let Some(commit_id) = commit_id {
-            storage::stage_root(writes, commit_id, &built.root_id);
-            true
-        } else {
-            false
-        };
 
         Ok(MutationApply::Applied(TrackedStateApplyResult {
             root_id: built.root_id,
@@ -460,20 +426,19 @@ impl TrackedStateTree {
             tree_height: built.tree_height,
             chunk_count: built.chunks.len(),
             chunk_bytes: built.chunk_bytes,
-            persisted_root,
         }))
     }
 
     fn diff_nodes<'a, S>(
         &'a self,
-        store: &'a mut S,
+        store: &'a S,
         left_hash: [u8; TRACKED_STATE_HASH_BYTES],
         right_hash: [u8; TRACKED_STATE_HASH_BYTES],
         request: &'a TrackedStateTreeScanRequest,
         out: &'a mut Vec<TrackedStateTreeDiffEntry>,
     ) -> Pin<Box<dyn Future<Output = Result<(), LixError>> + 'a>>
     where
-        S: StorageReader + 'a,
+        S: StorageRead + Send + Sync + 'a,
     {
         Box::pin(async move {
             if left_hash == right_hash {
@@ -514,7 +479,7 @@ impl TrackedStateTree {
 
     async fn diff_leaf_summary_cursors(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         left_hash: [u8; TRACKED_STATE_HASH_BYTES],
         right_hash: [u8; TRACKED_STATE_HASH_BYTES],
         request: &TrackedStateTreeScanRequest,
@@ -572,7 +537,7 @@ impl TrackedStateTree {
 
     async fn diff_leaf_summary_window(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         left_leaves: &[ChildSummary],
         right_leaves: &[ChildSummary],
         request: &TrackedStateTreeScanRequest,
@@ -684,7 +649,7 @@ impl TrackedStateTree {
 
     async fn apply_sorted_mutations_chunker(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         writes: &mut StorageWriteSet,
         overlay: &mut storage::TrackedStateChunkOverlay,
         root_id: &TrackedStateRootId,
@@ -851,7 +816,7 @@ impl TrackedStateTree {
 
     async fn apply_single_mutation_from_seek_path(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         writes: &mut StorageWriteSet,
         overlay: &mut storage::TrackedStateChunkOverlay,
         root_id: &TrackedStateRootId,
@@ -1033,22 +998,15 @@ impl TrackedStateTree {
         writes: &mut StorageWriteSet,
         overlay: &mut storage::TrackedStateChunkOverlay,
         built: BuiltTree,
-        commit_id: Option<&str>,
+        _commit_id: Option<&str>,
     ) -> Result<TrackedStateApplyResult, LixError> {
         overlay.stage_chunks(writes, &built.chunks);
-        let persisted_root = if let Some(commit_id) = commit_id {
-            storage::stage_root(writes, commit_id, &built.root_id);
-            true
-        } else {
-            false
-        };
         Ok(TrackedStateApplyResult {
             root_id: built.root_id,
             row_count: built.row_count,
             tree_height: built.tree_height,
             chunk_count: built.chunks.len(),
             chunk_bytes: built.chunk_bytes,
-            persisted_root,
         })
     }
 
@@ -1379,9 +1337,21 @@ impl TrackedStateTree {
             .collect()
     }
 
+    #[cfg(test)]
     async fn collect_leaf_entries(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
+        root_id: &TrackedStateRootId,
+    ) -> Result<Vec<EncodedLeafEntry>, LixError> {
+        let overlay = storage::TrackedStateChunkOverlay::new();
+        self.collect_leaf_entries_with_overlay(store, &overlay, root_id)
+            .await
+    }
+
+    async fn collect_leaf_entries_with_overlay(
+        &self,
+        store: &(impl StorageRead + Send + Sync + ?Sized),
+        overlay: &storage::TrackedStateChunkOverlay,
         root_id: &TrackedStateRootId,
     ) -> Result<Vec<EncodedLeafEntry>, LixError> {
         let mut out = Vec::new();
@@ -1389,7 +1359,7 @@ impl TrackedStateTree {
         while !current.is_empty() {
             let mut next = Vec::new();
             for hash in current {
-                match self.load_node(store, &hash).await? {
+                match self.load_node_with_overlay(store, overlay, &hash).await? {
                     DecodedNode::Leaf(leaf) => out.extend(leaf.entries().iter().cloned()),
                     DecodedNode::Internal(internal) => {
                         next.extend(internal.children().iter().map(|child| child.child_hash));
@@ -1403,7 +1373,7 @@ impl TrackedStateTree {
 
     async fn collect_filtered_entries(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         root_id: &TrackedStateRootId,
         request: &TrackedStateTreeScanRequest,
     ) -> Result<Vec<(TrackedStateKey, TrackedStateIndexValue)>, LixError> {
@@ -1412,7 +1382,7 @@ impl TrackedStateTree {
 
     fn scan_node<'a, S>(
         &'a self,
-        store: &'a mut S,
+        store: &'a S,
         hash: [u8; TRACKED_STATE_HASH_BYTES],
         request: &'a TrackedStateTreeScanRequest,
         ranges: &'a [EncodedScanRange],
@@ -1420,7 +1390,7 @@ impl TrackedStateTree {
         rows: &'a mut Vec<(TrackedStateKey, TrackedStateIndexValue)>,
     ) -> Pin<Box<dyn Future<Output = Result<(), LixError>> + Send + 'a>>
     where
-        S: StorageReader + Send + 'a,
+        S: StorageRead + Send + Sync + ?Sized + 'a,
     {
         Box::pin(async move {
             let bytes = self.load_node_bytes(store, &hash).await?;
@@ -1486,13 +1456,13 @@ impl TrackedStateTree {
 
     fn get_many_node<'a, S>(
         &'a self,
-        store: &'a mut S,
+        store: &'a S,
         hash: [u8; TRACKED_STATE_HASH_BYTES],
         encoded_keys: &'a [(usize, Vec<u8>)],
         values: &'a mut [Option<TrackedStateIndexValue>],
     ) -> Pin<Box<dyn Future<Output = Result<(), LixError>> + Send + 'a>>
     where
-        S: StorageReader + Send + 'a,
+        S: StorageRead + Send + Sync + ?Sized + 'a,
     {
         Box::pin(async move {
             if encoded_keys.is_empty() {
@@ -1550,51 +1520,9 @@ impl TrackedStateTree {
         })
     }
 
-    fn count_matching_keys_node<'a, S>(
-        &'a self,
-        store: &'a mut S,
-        hash: [u8; TRACKED_STATE_HASH_BYTES],
-        request: &'a TrackedStateTreeScanRequest,
-        ranges: &'a [EncodedScanRange],
-    ) -> Pin<Box<dyn Future<Output = Result<usize, LixError>> + Send + 'a>>
-    where
-        S: StorageReader + Send + 'a,
-    {
-        Box::pin(async move {
-            let mut count = 0usize;
-            match self.load_node(store, &hash).await? {
-                DecodedNode::Leaf(leaf) => {
-                    for entry in leaf.entries() {
-                        if !encoded_key_in_scan_ranges(&entry.key, ranges) {
-                            continue;
-                        }
-                        let key = decode_key(&entry.key)?;
-                        if key_matches_scan_filters(request, &key) {
-                            count += 1;
-                        }
-                    }
-                }
-                DecodedNode::Internal(internal) => {
-                    for child in internal.children() {
-                        if child_summary_contained_by_scan_ranges(child, ranges)
-                            && request.entity_ids.is_empty()
-                        {
-                            count += child.subtree_count as usize;
-                        } else if child_summary_overlaps_scan_ranges(child, ranges) {
-                            count += self
-                                .count_matching_keys_node(store, child.child_hash, request, ranges)
-                                .await?;
-                        }
-                    }
-                }
-            }
-            Ok(count)
-        })
-    }
-
     async fn collect_entries_from_leaf_summaries(
         &self,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         leaves: &[ChildSummary],
     ) -> Result<Vec<EncodedLeafEntry>, LixError> {
         let mut entries = Vec::new();
@@ -1606,7 +1534,7 @@ impl TrackedStateTree {
 
     async fn collect_summary_levels_with_overlay(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         overlay: &storage::TrackedStateChunkOverlay,
         root_id: &TrackedStateRootId,
     ) -> Result<Vec<Vec<ChildSummary>>, LixError> {
@@ -1623,13 +1551,13 @@ impl TrackedStateTree {
 
     fn collect_summary_levels_for_node_with_overlay<'a, S>(
         &'a self,
-        store: &'a mut S,
+        store: &'a S,
         overlay: &'a storage::TrackedStateChunkOverlay,
         hash: [u8; TRACKED_STATE_HASH_BYTES],
         levels: &'a mut Vec<Vec<ChildSummary>>,
     ) -> Pin<Box<dyn Future<Output = Result<(ChildSummary, usize), LixError>> + 'a>>
     where
-        S: StorageReader + ?Sized + 'a,
+        S: StorageRead + Send + Sync + ?Sized + 'a,
     {
         Box::pin(async move {
             match self.load_node_with_overlay(store, overlay, &hash).await? {
@@ -1681,7 +1609,7 @@ impl TrackedStateTree {
 
     async fn load_leaf_entries(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         hash: &[u8; TRACKED_STATE_HASH_BYTES],
     ) -> Result<Vec<EncodedLeafEntry>, LixError> {
         match self.load_node(store, hash).await? {
@@ -1695,7 +1623,7 @@ impl TrackedStateTree {
 
     async fn load_leaf_entries_with_overlay(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         overlay: &storage::TrackedStateChunkOverlay,
         hash: &[u8; TRACKED_STATE_HASH_BYTES],
     ) -> Result<Vec<EncodedLeafEntry>, LixError> {
@@ -1710,7 +1638,7 @@ impl TrackedStateTree {
 
     async fn load_node(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         hash: &[u8; TRACKED_STATE_HASH_BYTES],
     ) -> Result<DecodedNode, LixError> {
         let bytes = self.load_node_bytes(store, hash).await?;
@@ -1719,7 +1647,7 @@ impl TrackedStateTree {
 
     async fn load_node_bytes(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         hash: &[u8; TRACKED_STATE_HASH_BYTES],
     ) -> Result<Vec<u8>, LixError> {
         let bytes = storage::read_chunk(store, hash).await?.ok_or_else(|| {
@@ -1731,7 +1659,7 @@ impl TrackedStateTree {
 
     async fn load_node_with_overlay(
         &self,
-        store: &mut (impl StorageReader + ?Sized),
+        store: &(impl StorageRead + Send + Sync + ?Sized),
         overlay: &storage::TrackedStateChunkOverlay,
         hash: &[u8; TRACKED_STATE_HASH_BYTES],
     ) -> Result<DecodedNode, LixError> {
@@ -1813,7 +1741,7 @@ struct LeafSummaryCursorFrame {
 impl LeafSummaryCursor {
     async fn new(
         tree: &TrackedStateTree,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         root_hash: [u8; TRACKED_STATE_HASH_BYTES],
     ) -> Result<Self, LixError> {
         let mut cursor = Self {
@@ -1846,7 +1774,7 @@ impl LeafSummaryCursor {
     async fn advance(
         &mut self,
         tree: &TrackedStateTree,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
     ) -> Result<(), LixError> {
         self.current = None;
         while let Some(frame) = self.stack.last_mut() {
@@ -1871,7 +1799,7 @@ impl LeafSummaryCursor {
     async fn descend_to_leaf(
         &mut self,
         tree: &TrackedStateTree,
-        store: &mut impl StorageReader,
+        store: &(impl StorageRead + Send + Sync),
         mut summary: ChildSummary,
     ) -> Result<(), LixError> {
         loop {
@@ -1911,14 +1839,12 @@ impl LeafSummaryCursor {
 struct LeafChunkAccumulator {
     entries: Vec<EncodedLeafEntry>,
     key_bytes: usize,
-    value_bytes: usize,
 }
 
 #[derive(Debug, Default)]
 struct LeafChunkRefAccumulator<'a> {
     entries: Vec<EncodedLeafEntryRef<'a>>,
     key_bytes: usize,
-    value_bytes: usize,
 }
 
 #[derive(Debug, Default)]
@@ -1945,24 +1871,19 @@ fn chunk_leaf_entries(
     let mut groups = Vec::new();
     let mut current = LeafChunkAccumulator::default();
     for entry in entries {
-        let item_size = estimate_leaf_entry_size(entry.key.len(), entry.value.len());
-        let projected_size = estimate_leaf_chunk_size(
+        let item_size = estimate_leaf_boundary_entry_size(entry.key.len());
+        let projected_size = estimate_leaf_boundary_chunk_size(
             current.entries.len() + 1,
             current.key_bytes + entry.key.len(),
-            current.value_bytes + entry.value.len(),
         );
         if !current.entries.is_empty() && projected_size > options.max_chunk_bytes {
             groups.push(std::mem::take(&mut current));
         }
 
         current.key_bytes += entry.key.len();
-        current.value_bytes += entry.value.len();
         current.entries.push(entry);
-        let current_size = estimate_leaf_chunk_size(
-            current.entries.len(),
-            current.key_bytes,
-            current.value_bytes,
-        );
+        let current_size =
+            estimate_leaf_boundary_chunk_size(current.entries.len(), current.key_bytes);
         if current_size >= options.min_chunk_bytes
             && (current_size >= options.max_chunk_bytes
                 || current.entries.last().is_some_and(|entry| {
@@ -1995,24 +1916,19 @@ fn chunk_leaf_entry_refs<'a>(
     let mut groups = Vec::new();
     let mut current = LeafChunkRefAccumulator::default();
     for entry in iter {
-        let item_size = estimate_leaf_entry_size(entry.key.len(), entry.value.len());
-        let projected_size = estimate_leaf_chunk_size(
+        let item_size = estimate_leaf_boundary_entry_size(entry.key.len());
+        let projected_size = estimate_leaf_boundary_chunk_size(
             current.entries.len() + 1,
             current.key_bytes + entry.key.len(),
-            current.value_bytes + entry.value.len(),
         );
         if !current.entries.is_empty() && projected_size > options.max_chunk_bytes {
             groups.push(std::mem::take(&mut current));
         }
 
         current.key_bytes += entry.key.len();
-        current.value_bytes += entry.value.len();
         current.entries.push(entry);
-        let current_size = estimate_leaf_chunk_size(
-            current.entries.len(),
-            current.key_bytes,
-            current.value_bytes,
-        );
+        let current_size =
+            estimate_leaf_boundary_chunk_size(current.entries.len(), current.key_bytes);
         if current_size >= options.min_chunk_bytes
             && (current_size >= options.max_chunk_bytes
                 || current.entries.last().is_some_and(|entry| {
@@ -2138,8 +2054,12 @@ fn estimate_leaf_chunk_size(entry_count: usize, key_bytes: usize, value_bytes: u
     10 + entry_count * 12 + key_bytes + value_bytes
 }
 
-fn estimate_leaf_entry_size(key_bytes: usize, value_bytes: usize) -> usize {
-    12 + key_bytes + value_bytes
+fn estimate_leaf_boundary_chunk_size(entry_count: usize, key_bytes: usize) -> usize {
+    estimate_leaf_chunk_size(entry_count, key_bytes, 0)
+}
+
+fn estimate_leaf_boundary_entry_size(key_bytes: usize) -> usize {
+    12 + key_bytes
 }
 
 fn estimate_internal_chunk_size(
@@ -2179,7 +2099,7 @@ fn internal_boundaries_match(left: &[ChildSummary], right: &[ChildSummary]) -> b
 
 async fn child_summaries_are_leaves(
     tree: &TrackedStateTree,
-    store: &mut impl StorageReader,
+    store: &(impl StorageRead + Send + Sync),
     children: &[ChildSummary],
 ) -> Result<bool, LixError> {
     let Some(first_child) = children.first() else {
@@ -2302,7 +2222,7 @@ fn scan_ranges(request: &TrackedStateTreeScanRequest) -> Vec<EncodedScanRange> {
         return Vec::new();
     }
 
-    let can_bind_entity = !request.entity_ids.is_empty()
+    let can_bind_entity = !request.entity_pks.is_empty()
         && !request.file_ids.is_empty()
         && request
             .file_ids
@@ -2318,11 +2238,11 @@ fn scan_ranges(request: &TrackedStateTreeScanRequest) -> Vec<EncodedScanRange> {
                     NullableKeyFilter::Value(file_id) => Some(file_id.clone()),
                     NullableKeyFilter::Any => unreachable!("filtered above"),
                 };
-                for entity_id in &request.entity_ids {
+                for entity_pk in &request.entity_pks {
                     let key = TrackedStateKey {
                         schema_key: schema_key.clone(),
                         file_id: file_id.clone(),
-                        entity_id: entity_id.clone(),
+                        entity_pk: entity_pk.clone(),
                     };
                     ranges.push(exact_scan_range(encode_key(&key)));
                 }
@@ -2361,7 +2281,7 @@ fn scan_key_decode_hint<'a>(
     if ranges.len() != 1 || request.schema_keys.len() != 1 || request.file_ids.len() != 1 {
         return None;
     }
-    if !request.entity_ids.is_empty() {
+    if !request.entity_pks.is_empty() {
         return None;
     }
     let file_id = match request.file_ids.first()? {
@@ -2413,20 +2333,6 @@ fn child_summary_overlaps_scan_ranges(child: &ChildSummary, ranges: &[EncodedSca
         })
 }
 
-fn child_summary_contained_by_scan_ranges(
-    child: &ChildSummary,
-    ranges: &[EncodedScanRange],
-) -> bool {
-    ranges.is_empty()
-        || ranges.iter().any(|range| {
-            child.first_key.as_slice() >= range.start.as_slice()
-                && range
-                    .end
-                    .as_ref()
-                    .is_none_or(|end| child.last_key.as_slice() < end.as_slice())
-        })
-}
-
 fn encoded_key_in_scan_ranges(key: &[u8], ranges: &[EncodedScanRange]) -> bool {
     ranges.is_empty()
         || ranges.iter().any(|range| {
@@ -2439,7 +2345,7 @@ fn key_matches_scan_filters(request: &TrackedStateTreeScanRequest, key: &Tracked
     if !request.schema_keys.is_empty() && !request.schema_keys.contains(&key.schema_key) {
         return false;
     }
-    if !request.entity_ids.is_empty() && !request.entity_ids.contains(&key.entity_id) {
+    if !request.entity_pks.is_empty() && !request.entity_pks.contains(&key.entity_pk) {
         return false;
     }
     if !request.file_ids.is_empty()
@@ -2459,48 +2365,28 @@ fn scan_limit_reached(request: &TrackedStateTreeScanRequest, row_count: usize) -
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
     use super::*;
-    use crate::backend::testing::UnitTestBackend;
-    use crate::entity_identity::EntityIdentity;
-    use crate::storage::{StorageContext, StorageWriteTransaction};
+    use crate::entity_pk::EntityPk;
+    use crate::storage::StorageContext;
+    use crate::storage::{InMemoryStorageBackend, StorageReadOptions, StorageWriteOptions};
     use crate::tracked_state::codec::encode_value;
 
     #[tokio::test]
-    async fn exact_read_roundtrips_from_stored_root() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+    async fn exact_read_roundtrips_from_applied_root() {
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
         let key = key("schema", None, "entity");
         let value = value("change-1", Some("{}"));
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let result = apply_mutations_for_test(
-            &tree,
-            transaction.as_mut(),
-            None,
-            vec![mutation(&key, &value)],
-            Some("commit-1"),
-        )
-        .await
-        .expect("mutations should apply");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
-
-        let mut store = storage.clone();
-        assert_eq!(
-            tree.load_root(&mut store, "commit-1")
+        let result =
+            apply_mutations_for_test(&tree, &storage, None, vec![mutation(&key, &value)], None)
                 .await
-                .expect("root should load"),
-            Some(result.root_id.clone())
-        );
+                .expect("mutations should apply");
+
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         assert_eq!(
-            tree.get(&mut store, &result.root_id, &key)
+            tree.get(&store, &result.root_id, &key)
                 .await
                 .expect("row should load"),
             Some(value)
@@ -2509,52 +2395,40 @@ mod tests {
 
     #[tokio::test]
     async fn latest_mutation_for_key_wins() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
         let key = key("schema", None, "entity");
         let old_value = value("change-old", Some("{\"v\":1}"));
         let new_value = value("change-new", Some("{\"v\":2}"));
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let result = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             None,
             vec![mutation(&key, &old_value), mutation(&key, &new_value)],
             None,
         )
         .await
         .expect("mutations should apply");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
 
-        let mut store = storage.clone();
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let loaded = tree
-            .get(&mut store, &result.root_id, &key)
+            .get(&store, &result.root_id, &key)
             .await
             .expect("row should load")
             .expect("row should exist");
-        assert_eq!(loaded.change_locator.change_id, "change-new");
-        assert_eq!(loaded.change_locator.source_commit_id, "commit");
+        assert_eq!(loaded.change_id, "change-new");
+        assert_eq!(loaded.commit_id, "commit");
     }
 
     #[tokio::test]
     async fn scan_filters_by_index_key_without_materializing_tombstones() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let result = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             None,
             vec![
                 mutation_owned(key("schema-a", None, "visible"), value("c1", Some("{}"))),
@@ -2565,15 +2439,13 @@ mod tests {
         )
         .await
         .expect("mutations should apply");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
 
-        let mut store = storage.clone();
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let rows = tree
             .scan(
-                &mut store,
+                &store,
                 &result.root_id,
                 &TrackedStateTreeScanRequest {
                     schema_keys: vec!["schema-a".to_string()],
@@ -2585,13 +2457,13 @@ mod tests {
         assert_eq!(rows.len(), 2);
         let identities = rows
             .iter()
-            .map(|(key, _)| key.entity_id.as_single_string_owned().expect("identity"))
+            .map(|(key, _)| key.entity_pk.as_single_string_owned().expect("identity"))
             .collect::<Vec<_>>();
         assert_eq!(identities, vec!["deleted", "visible"]);
 
         let live_rows = tree
             .scan(
-                &mut store,
+                &store,
                 &result.root_id,
                 &TrackedStateTreeScanRequest {
                     schema_keys: vec!["schema-a".to_string()],
@@ -2603,23 +2475,18 @@ mod tests {
             .expect("live scan should succeed");
         let live_identities = live_rows
             .iter()
-            .map(|(key, _)| key.entity_id.as_single_string_owned().expect("identity"))
+            .map(|(key, _)| key.entity_pk.as_single_string_owned().expect("identity"))
             .collect::<Vec<_>>();
         assert_eq!(live_identities, vec!["visible"]);
     }
 
     #[tokio::test]
     async fn scan_filters_by_schema_entity_and_file() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let result = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             None,
             vec![
                 mutation_owned(
@@ -2643,19 +2510,17 @@ mod tests {
         )
         .await
         .expect("mutations should apply");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
 
-        let mut store = storage.clone();
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let rows = tree
             .scan(
-                &mut store,
+                &store,
                 &result.root_id,
                 &TrackedStateTreeScanRequest {
                     schema_keys: vec!["schema-a".to_string()],
-                    entity_ids: vec![crate::entity_identity::EntityIdentity::single("entity-a")],
+                    entity_pks: vec![crate::entity_pk::EntityPk::single("entity-a")],
                     file_ids: vec![crate::NullableKeyFilter::Value("file-a".to_string())],
                     ..Default::default()
                 },
@@ -2668,7 +2533,7 @@ mod tests {
         assert_eq!(
             rows[0]
                 .0
-                .entity_id
+                .entity_pk
                 .as_single_string_owned()
                 .expect("identity"),
             "entity-a"
@@ -2678,16 +2543,11 @@ mod tests {
 
     #[tokio::test]
     async fn scan_schema_file_prefix_honors_tombstones_and_limit() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let result = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             None,
             vec![
                 mutation_owned(
@@ -2711,15 +2571,13 @@ mod tests {
         )
         .await
         .expect("mutations should apply");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
 
-        let mut store = storage.clone();
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let rows = tree
             .scan(
-                &mut store,
+                &store,
                 &result.root_id,
                 &TrackedStateTreeScanRequest {
                     schema_keys: vec!["schema-a".to_string()],
@@ -2738,7 +2596,7 @@ mod tests {
         ));
         assert_eq!(
             rows.iter()
-                .map(|(key, _)| key.entity_id.as_single_string_owned().expect("identity"))
+                .map(|(key, _)| key.entity_pk.as_single_string_owned().expect("identity"))
                 .collect::<Vec<_>>(),
             vec!["entity-a", "entity-c"]
         );
@@ -2746,21 +2604,16 @@ mod tests {
 
     #[tokio::test]
     async fn applying_to_base_root_reuses_existing_rows_and_overwrites_changed_rows() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
         let unchanged_key = key("schema", None, "unchanged");
         let changed_key = key("schema", None, "changed");
         let unchanged_value = value("c1", Some("{}"));
         let old_changed_value = value("c2", Some("{\"old\":true}"));
         let new_changed_value = value("c3", Some("{\"new\":true}"));
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let base = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             None,
             vec![
                 mutation(&unchanged_key, &unchanged_value),
@@ -2772,34 +2625,30 @@ mod tests {
         .expect("base should build");
         let next = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             vec![mutation(&changed_key, &new_changed_value)],
             None,
         )
         .await
         .expect("next should build");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
 
-        let mut store = storage.clone();
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         assert_eq!(
-            tree.get(&mut store, &next.root_id, &unchanged_key)
+            tree.get(&store, &next.root_id, &unchanged_key)
                 .await
                 .expect("unchanged read")
                 .expect("unchanged exists")
-                .change_locator
                 .change_id,
             "c1"
         );
         assert_eq!(
-            tree.get(&mut store, &next.root_id, &changed_key)
+            tree.get(&store, &next.root_id, &changed_key)
                 .await
                 .expect("changed read")
                 .expect("changed exists")
-                .change_locator
                 .change_id,
             "c3"
         );
@@ -2807,7 +2656,7 @@ mod tests {
 
     #[tokio::test]
     async fn two_commit_roots_can_share_unchanged_rows() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::new();
         let shared_key = key("schema", None, "shared");
         let branch_a_key = key("schema", None, "branch-a");
@@ -2815,14 +2664,9 @@ mod tests {
         let shared_value = value("shared-change", Some("{\"shared\":true}"));
         let branch_a_value = value("branch-a-change", Some("{\"branch\":\"a\"}"));
         let branch_b_value = value("branch-b-change", Some("{\"branch\":\"b\"}"));
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let base = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             None,
             vec![mutation(&shared_key, &shared_value)],
             Some("commit-base"),
@@ -2831,7 +2675,7 @@ mod tests {
         .expect("base root should build");
         let branch_a = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             vec![mutation(&branch_a_key, &branch_a_value)],
             Some("commit-a"),
@@ -2840,39 +2684,37 @@ mod tests {
         .expect("branch a root should build");
         let branch_b = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             vec![mutation(&branch_b_key, &branch_b_value)],
             Some("commit-b"),
         )
         .await
         .expect("branch b root should build");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
 
         assert_ne!(branch_a.root_id, branch_b.root_id);
-        let mut store = storage.clone();
+        let store = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         assert_eq!(
-            tree.get(&mut store, &branch_a.root_id, &shared_key)
+            tree.get(&store, &branch_a.root_id, &shared_key)
                 .await
                 .expect("branch a shared row should load"),
             Some(value("shared-change", Some("{\"shared\":true}")))
         );
         assert_eq!(
-            tree.get(&mut store, &branch_b.root_id, &shared_key)
+            tree.get(&store, &branch_b.root_id, &shared_key)
                 .await
                 .expect("branch b shared row should load"),
             Some(value("shared-change", Some("{\"shared\":true}")))
         );
         assert!(tree
-            .get(&mut store, &branch_a.root_id, &branch_b_key)
+            .get(&store, &branch_a.root_id, &branch_b_key)
             .await
             .expect("branch a should read")
             .is_none());
         assert!(tree
-            .get(&mut store, &branch_b.root_id, &branch_a_key)
+            .get(&store, &branch_b.root_id, &branch_a_key)
             .await
             .expect("branch b should read")
             .is_none());
@@ -2880,7 +2722,7 @@ mod tests {
 
     #[tokio::test]
     async fn single_update_matches_full_canonical_rebuild() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::with_options(TrackedStateTreeOptions {
             target_chunk_bytes: 128,
             min_chunk_bytes: 64,
@@ -2896,25 +2738,23 @@ mod tests {
             .collect::<Vec<_>>();
         let changed_key = key("schema", None, "entity-000");
         let changed_value = value("changed", Some("{\"v\":\"changed\"}"));
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let base = apply_mutations_for_test(&tree, transaction.as_mut(), None, rows, None)
+        let base = apply_mutations_for_test(&tree, &storage, None, rows, None)
             .await
             .expect("base should build");
         let fast = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             vec![mutation(&changed_key, &changed_value)],
             None,
         )
         .await
         .expect("fast path should apply");
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let mut canonical_entries = tree
-            .collect_leaf_entries(&mut transaction.as_mut(), &base.root_id)
+            .collect_leaf_entries(&read, &base.root_id)
             .await
             .expect("base entries should collect");
         assert!(canonical_entries
@@ -2935,7 +2775,7 @@ mod tests {
 
     #[tokio::test]
     async fn single_insert_matches_full_canonical_rebuild() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::with_options(TrackedStateTreeOptions {
             target_chunk_bytes: 128,
             min_chunk_bytes: 64,
@@ -2951,25 +2791,23 @@ mod tests {
             .collect::<Vec<_>>();
         let inserted_key = key("schema", None, "entity-050a");
         let inserted_value = value("inserted", Some("{\"v\":\"inserted\"}"));
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let base = apply_mutations_for_test(&tree, transaction.as_mut(), None, rows, None)
+        let base = apply_mutations_for_test(&tree, &storage, None, rows, None)
             .await
             .expect("base should build");
         let fast = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             vec![mutation(&inserted_key, &inserted_value)],
             None,
         )
         .await
         .expect("fast path should apply");
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let mut canonical_entries = tree
-            .collect_leaf_entries(&mut transaction.as_mut(), &base.root_id)
+            .collect_leaf_entries(&read, &base.root_id)
             .await
             .expect("base entries should collect");
         let encoded_inserted_key = encode_key(&inserted_key);
@@ -2993,7 +2831,7 @@ mod tests {
 
     #[tokio::test]
     async fn batch_update_matches_full_canonical_rebuild() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::with_options(TrackedStateTreeOptions {
             target_chunk_bytes: 128,
             min_chunk_bytes: 64,
@@ -3018,17 +2856,12 @@ mod tests {
                 )
             })
             .collect::<Vec<_>>();
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let base = apply_mutations_for_test(&tree, transaction.as_mut(), None, rows, None)
+        let base = apply_mutations_for_test(&tree, &storage, None, rows, None)
             .await
             .expect("base should build");
         let fast = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             updates
                 .iter()
@@ -3038,8 +2871,11 @@ mod tests {
         )
         .await
         .expect("batch path should apply");
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let mut canonical_entries = tree
-            .collect_leaf_entries(&mut transaction.as_mut(), &base.root_id)
+            .collect_leaf_entries(&read, &base.root_id)
             .await
             .expect("base entries should collect");
         for (key, value) in updates {
@@ -3059,7 +2895,7 @@ mod tests {
 
     #[tokio::test]
     async fn batch_insert_matches_full_canonical_rebuild() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let tree = TrackedStateTree::with_options(TrackedStateTreeOptions {
             target_chunk_bytes: 128,
             min_chunk_bytes: 64,
@@ -3076,9 +2912,9 @@ mod tests {
         let inserts = ["entity-050a", "entity-050b", "entity-050c"]
             .into_iter()
             .enumerate()
-            .map(|(index, entity_id)| {
+            .map(|(index, entity_pk)| {
                 (
-                    key("schema", None, entity_id),
+                    key("schema", None, entity_pk),
                     value(
                         &format!("inserted-{index}"),
                         Some(&format!("{{\"inserted\":{index}}}")),
@@ -3086,17 +2922,12 @@ mod tests {
                 )
             })
             .collect::<Vec<_>>();
-
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let base = apply_mutations_for_test(&tree, transaction.as_mut(), None, rows, None)
+        let base = apply_mutations_for_test(&tree, &storage, None, rows, None)
             .await
             .expect("base should build");
         let fast = apply_mutations_for_test(
             &tree,
-            transaction.as_mut(),
+            &storage,
             Some(&base.root_id),
             inserts
                 .iter()
@@ -3106,8 +2937,11 @@ mod tests {
         )
         .await
         .expect("batch path should apply");
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
         let mut canonical_entries = tree
-            .collect_leaf_entries(&mut transaction.as_mut(), &base.root_id)
+            .collect_leaf_entries(&read, &base.root_id)
             .await
             .expect("base entries should collect");
         for (key, value) in inserts {
@@ -3131,18 +2965,37 @@ mod tests {
         assert_eq!(fast.root_id, canonical.root_id);
     }
 
+    #[test]
+    fn leaf_chunk_boundaries_ignore_value_bytes() {
+        let options = TrackedStateTreeOptions {
+            target_chunk_bytes: 64,
+            min_chunk_bytes: 32,
+            max_chunk_bytes: 96,
+        };
+        let short_entries = encoded_entries_with_change_id("c");
+        let large_entries = encoded_entries_with_change_id(&"c".repeat(4096));
+
+        assert_eq!(
+            leaf_chunk_boundary_keys(chunk_leaf_entries(short_entries, &options)),
+            leaf_chunk_boundary_keys(chunk_leaf_entries(large_entries, &options))
+        );
+    }
+
     async fn apply_mutations_for_test(
         tree: &TrackedStateTree,
-        transaction: &mut dyn StorageWriteTransaction,
+        storage: &StorageContext,
         base_root: Option<&TrackedStateRootId>,
         mutations: Vec<TrackedStateMutation>,
         commit_id: Option<&str>,
     ) -> Result<TrackedStateApplyResult, LixError> {
-        let mut writes = StorageWriteSet::new();
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut writes = storage.new_write_set();
         let result = tree
-            .apply_mutations(transaction, &mut writes, base_root, mutations, commit_id)
+            .apply_mutations(&read, &mut writes, base_root, mutations, commit_id)
             .await?;
-        writes.apply(transaction).await?;
+        storage.commit_write_set(writes, StorageWriteOptions::default())?;
         Ok(result)
     }
 
@@ -3154,28 +3007,51 @@ mod tests {
         mutation(&key, &value)
     }
 
-    fn key(schema_key: &str, file_id: Option<&str>, entity_id: &str) -> TrackedStateKey {
+    fn encoded_entries_with_change_id(change_id: &str) -> Vec<EncodedLeafEntry> {
+        (0..64)
+            .map(|index| {
+                let key = key("schema", None, &format!("entity-{index:03}"));
+                EncodedLeafEntry {
+                    key: encode_key(&key),
+                    value: encode_value(&value(change_id, Some("{}"))),
+                }
+            })
+            .collect()
+    }
+
+    fn leaf_chunk_boundary_keys(
+        groups: Vec<LeafChunkAccumulator>,
+    ) -> Vec<(Vec<u8>, Vec<u8>, usize)> {
+        groups
+            .into_iter()
+            .map(|group| {
+                let first_key = group
+                    .entries
+                    .first()
+                    .map(|entry| entry.key.clone())
+                    .unwrap_or_default();
+                let last_key = group
+                    .entries
+                    .last()
+                    .map(|entry| entry.key.clone())
+                    .unwrap_or_default();
+                (first_key, last_key, group.entries.len())
+            })
+            .collect()
+    }
+
+    fn key(schema_key: &str, file_id: Option<&str>, entity_pk: &str) -> TrackedStateKey {
         TrackedStateKey {
             schema_key: schema_key.to_string(),
             file_id: file_id.map(str::to_string),
-            entity_id: EntityIdentity::single(entity_id),
+            entity_pk: EntityPk::single(entity_pk),
         }
     }
 
     fn value(change_id: &str, snapshot_content: Option<&str>) -> TrackedStateIndexValue {
-        let source_ordinal = match snapshot_content {
-            Some("{\"v\":1}") => 1,
-            Some("{\"v\":2}") => 2,
-            Some(_) => 3,
-            None => 0,
-        };
         TrackedStateIndexValue {
-            change_locator: crate::commit_store::ChangeLocator {
-                source_commit_id: "commit".to_string(),
-                source_pack_id: 0,
-                source_ordinal,
-                change_id: change_id.to_string(),
-            },
+            change_id: change_id.to_string(),
+            commit_id: "commit".to_string(),
             deleted: snapshot_content.is_none(),
             snapshot_ref: snapshot_content
                 .map(|content| crate::json_store::JsonRef::for_content(content.as_bytes())),