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

package/dist-engine-src/src/live_state/context.rs

@@ -1,25 +1,29 @@
 use async_trait::async_trait;
 use tokio::sync::Mutex;
 
-use crate::commit_graph::{CommitGraphCommit, CommitGraphContext};
+use crate::commit_graph::CommitGraphContext;
+use crate::entity_identity::EntityIdentity;
 use crate::live_state::visibility;
 use crate::live_state::{
-    LiveStateFilter, LiveStateReader, LiveStateRow, LiveStateRowRequest, LiveStateScanRequest,
+    LiveStateReader, LiveStateRowRequest, LiveStateScanRequest, MaterializedLiveStateRow,
 };
-use crate::storage::{StorageReader, StorageWriteSet};
+use crate::storage::StorageReader;
 use crate::tracked_state::{
-    TrackedStateContext, TrackedStateFilter, TrackedStateProjection, TrackedStateRow,
+    MaterializedTrackedStateRow, TrackedStateContext, TrackedStateFilter, TrackedStateProjection,
     TrackedStateRowRequest, TrackedStateScanRequest,
 };
 use crate::untracked_state::{
-    canonicalize_materialized_row, MaterializedUntrackedStateRow, UntrackedStateContext,
-    UntrackedStateIdentity, UntrackedStateRowRequest, UntrackedStateScanRequest,
+    UntrackedStateContext, UntrackedStateRowRequest, UntrackedStateScanRequest,
 };
 use crate::version::VERSION_REF_SCHEMA_KEY;
 use crate::LixError;
+use crate::NullableKeyFilter;
 use crate::GLOBAL_VERSION_ID;
 
-/// Serving facade for visible live-state readers and writers.
+const COMMIT_SCHEMA_KEY: &str = "lix_commit";
+const COMMIT_EDGE_SCHEMA_KEY: &str = "lix_commit_edge";
+
+/// Serving facade for visible live-state reads.
 ///
 /// Live state composes the rebuildable tracked projection with the durable
 /// untracked local overlay. Lower stores own persistence; this facade owns the
@@ -55,22 +59,6 @@ impl LiveStateContext {
             commit_graph: self.commit_graph.clone(),
         }
     }
-
-    /// Creates a visible live-state writer over a caller-provided KV reader.
-    ///
-    /// The writer owns the tracked/untracked routing rule: tracked rows update
-    /// the tracked projection and clear matching untracked overlay rows, while
-    /// untracked rows update only the local untracked overlay.
-    pub(crate) fn writer<S>(&self, store: S) -> LiveStateWriter<S>
-    where
-        S: StorageReader,
-    {
-        LiveStateWriter {
-            store,
-            tracked_state: self.tracked_state.clone(),
-            untracked_state: self.untracked_state,
-        }
-    }
 }
 
 /// Visible live-state reader backed by a caller-provided KV store.
@@ -88,30 +76,35 @@ where
     pub(crate) async fn scan_rows(
         &self,
         request: &LiveStateScanRequest,
-    ) -> Result<Vec<LiveStateRow>, LixError> {
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
         let mut store = self.store.lock().await;
         let scope = scan_scope(&mut *store, &self.untracked_state, request).await?;
+        let derived_rows =
+            scan_commit_derived_rows(&mut *store, &self.commit_graph, request, &scope).await?;
         let mut tracked_rows = Vec::new();
-        for version_id in &scope.storage_version_ids {
-            let Some(commit_id) =
-                load_version_ref_commit_id(&mut *store, &self.untracked_state, version_id).await?
-            else {
-                continue;
-            };
-            let tracked_request = tracked_scan_request_from_live(request);
-            let source = tracked_source_from_version_id(version_id);
-            let store: &mut dyn StorageReader = &mut *store;
-            tracked_rows.extend(
-                self.tracked_state
-                    .reader(store)
-                    .scan_rows_at_commit(&commit_id, &tracked_request)
-                    .await?
-                    .into_iter()
-                    .map(|row| project_tracked_row(row, version_id, source)),
-            );
+        if request.filter.untracked != Some(true) && !is_commit_derived_only_request(request) {
+            for version_id in &scope.storage_version_ids {
+                let Some(commit_id) =
+                    load_version_ref_commit_id(&mut *store, &self.untracked_state, version_id)
+                        .await?
+                else {
+                    continue;
+                };
+                let tracked_request = tracked_scan_request_from_live(request);
+                let source = tracked_source_from_version_id(version_id);
+                let store: &mut dyn StorageReader = &mut *store;
+                tracked_rows.extend(
+                    self.tracked_state
+                        .reader(store)
+                        .scan_rows_at_commit(&commit_id, &tracked_request)
+                        .await?
+                        .into_iter()
+                        .map(|row| project_tracked_row(row, version_id, source)),
+                );
+            }
         }
 
-        let untracked_rows = {
+        let untracked_rows = if request.filter.untracked != Some(false) {
             let store: &mut dyn StorageReader = &mut *store;
             self.untracked_state
                 .reader(store)
@@ -120,28 +113,25 @@ where
                     &scope.storage_version_ids,
                 ))
                 .await?
-        }
-        .into_iter()
-        .map(LiveStateRow::from)
-        .collect::<Vec<_>>();
-
-        let mut commit_rows = if scope.includes_commit_graph_projection {
-            let store: &mut dyn StorageReader = &mut *store;
-            self.commit_graph
-                .reader(store)
-                .all_commits()
-                .await?
                 .into_iter()
-                .map(live_state_row_from_commit)
+                .map(MaterializedLiveStateRow::from)
                 .collect::<Vec<_>>()
         } else {
             Vec::new()
         };
-        commit_rows.retain(|row| live_state_row_matches_filter(row, &request.filter));
 
-        let mut rows =
-            crate::live_state::overlay::overlay_untracked_rows(tracked_rows, untracked_rows);
-        rows.extend(commit_rows);
+        let mut rows = if request.filter.untracked.is_some() {
+            tracked_rows
+                .into_iter()
+                .chain(untracked_rows)
+                .chain(derived_rows)
+                .collect()
+        } else {
+            crate::live_state::overlay::overlay_untracked_rows(tracked_rows, untracked_rows)
+                .into_iter()
+                .chain(derived_rows)
+                .collect()
+        };
         rows = visibility::resolve_scan_rows(
             rows,
             &scope.projection_version_ids,
@@ -156,14 +146,40 @@ where
     pub(crate) async fn load_row(
         &self,
         request: &LiveStateRowRequest,
-    ) -> Result<Option<LiveStateRow>, LixError> {
+    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
         let mut store = self.store.lock().await;
         if !version_ref_exists(&mut *store, &self.untracked_state, &request.version_id).await? {
             return Ok(None);
         }
-        if request.schema_key == COMMIT_SCHEMA_KEY {
-            let store: &mut dyn StorageReader = &mut *store;
-            return self.load_commit_row(store, request).await;
+        if is_commit_derived_schema(&request.schema_key)
+            && request.file_id == NullableKeyFilter::Null
+        {
+            let scope = LiveStateScanScope {
+                storage_version_ids: vec![request.version_id.clone()],
+                projection_version_ids: vec![request.version_id.clone()],
+            };
+            let rows = scan_commit_derived_rows(
+                &mut *store,
+                &self.commit_graph,
+                &LiveStateScanRequest {
+                    filter: crate::live_state::LiveStateFilter {
+                        schema_keys: vec![request.schema_key.clone()],
+                        entity_ids: vec![request.entity_id.clone()],
+                        version_ids: vec![request.version_id.clone()],
+                        file_ids: vec![NullableKeyFilter::Null],
+                        untracked: Some(false),
+                        include_tombstones: false,
+                        ..Default::default()
+                    },
+                    limit: Some(1),
+                    ..Default::default()
+                },
+                &scope,
+            )
+            .await?;
+            if let Some(row) = rows.into_iter().next() {
+                return Ok(Some(row));
+            }
         }
         for candidate in load_row_candidates(request) {
             match candidate.source {
@@ -179,7 +195,7 @@ where
                         .await?
                     {
                         return Ok(Some(visibility::project_loaded_row(
-                            LiveStateRow::from(row),
+                            MaterializedLiveStateRow::from(row),
                             &request.version_id,
                             &candidate.version_id,
                         )));
@@ -196,12 +212,13 @@ where
                         continue;
                     };
                     let store: &mut dyn StorageReader = &mut *store;
-                    if let Some(row) = self
+                    let tracked_request = tracked_row_request_from_live(request);
+                    let mut rows = self
                         .tracked_state
                         .reader(store)
-                        .load_row_at_commit(&commit_id, &tracked_row_request_from_live(request))
-                        .await?
-                    {
+                        .load_rows_at_commit(&commit_id, &[tracked_request])
+                        .await?;
+                    if let Some(row) = rows.pop().flatten() {
                         return Ok(Some(project_tracked_row(
                             row,
                             &request.version_id,
@@ -213,30 +230,6 @@ where
         }
         Ok(None)
     }
-
-    async fn load_commit_row(
-        &self,
-        store: &mut dyn StorageReader,
-        request: &LiveStateRowRequest,
-    ) -> Result<Option<LiveStateRow>, LixError> {
-        if !nullable_filter_matches(&request.file_id, &None) {
-            return Ok(None);
-        }
-        let Some(commit) = self
-            .commit_graph
-            .reader(store)
-            .load_commit(&request.entity_id.as_string()?)
-            .await?
-        else {
-            return Ok(None);
-        };
-        let row = live_state_row_from_commit(commit);
-        Ok(Some(visibility::project_loaded_row(
-            row,
-            &request.version_id,
-            GLOBAL_VERSION_ID,
-        )))
-    }
 }
 
 #[async_trait]
@@ -247,105 +240,162 @@ where
     async fn scan_rows(
         &self,
         request: &LiveStateScanRequest,
-    ) -> Result<Vec<LiveStateRow>, LixError> {
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
         LiveStateStoreReader::scan_rows(self, request).await
     }
 
     async fn load_row(
         &self,
         request: &LiveStateRowRequest,
-    ) -> Result<Option<LiveStateRow>, LixError> {
+    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
         LiveStateStoreReader::load_row(self, request).await
     }
 }
 
-/// Writer for visible live-state rows over a caller-provided KV reader.
-pub(crate) struct LiveStateWriter<S> {
-    store: S,
-    tracked_state: TrackedStateContext,
-    untracked_state: UntrackedStateContext,
+async fn scan_commit_derived_rows(
+    store: &mut dyn StorageReader,
+    commit_graph: &CommitGraphContext,
+    request: &LiveStateScanRequest,
+    scope: &LiveStateScanScope,
+) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
+    if request.filter.untracked == Some(true) || !request_may_include_commit_derived(request) {
+        return Ok(Vec::new());
+    }
+    if !file_filter_allows_null(&request.filter.file_ids) {
+        return Ok(Vec::new());
+    }
+
+    let version_ids = if scope.projection_version_ids.is_empty() {
+        vec![GLOBAL_VERSION_ID.to_string()]
+    } else {
+        scope.projection_version_ids.clone()
+    };
+    let mut graph = commit_graph.reader(store);
+    let commits = graph.all_commits().await?;
+    let include_commit = schema_filter_allows(&request.filter.schema_keys, COMMIT_SCHEMA_KEY);
+    let include_commit_edge =
+        schema_filter_allows(&request.filter.schema_keys, COMMIT_EDGE_SCHEMA_KEY);
+
+    let mut rows = Vec::new();
+    for version_id in &version_ids {
+        if include_commit {
+            for commit in &commits {
+                rows.push(commit_row(commit, version_id)?);
+            }
+        }
+        if include_commit_edge {
+            for edge in graph.commit_edges(&commits) {
+                rows.push(commit_edge_row(&edge, version_id)?);
+            }
+        }
+    }
+
+    rows.retain(|row| {
+        (request.filter.entity_ids.is_empty() || request.filter.entity_ids.contains(&row.entity_id))
+            && (request.filter.version_ids.is_empty()
+                || request.filter.version_ids.contains(&row.version_id))
+    });
+    Ok(rows)
 }
 
-impl<S> LiveStateWriter<S>
-where
-    S: StorageReader,
-{
-    pub(crate) async fn stage_rows(
-        &mut self,
-        writes: &mut StorageWriteSet,
-        json_writer: &mut crate::json_store::JsonStoreWriter,
-        rows: &[LiveStateRow],
-    ) -> Result<(), LixError> {
-        let (tracked_rows, untracked_rows): (Vec<_>, Vec<_>) =
-            rows.iter().partition(|row| !row.untracked);
+fn request_may_include_commit_derived(request: &LiveStateScanRequest) -> bool {
+    request.filter.schema_keys.is_empty()
+        || request
+            .filter
+            .schema_keys
+            .iter()
+            .any(|schema_key| is_commit_derived_schema(schema_key))
+}
 
-        if !untracked_rows.is_empty() {
-            let untracked_rows = untracked_rows
-                .into_iter()
-                .map(MaterializedUntrackedStateRow::from)
-                .collect::<Vec<_>>();
-            let canonical_rows = untracked_rows
-                .iter()
-                .map(|row| canonicalize_materialized_row(writes, json_writer, row))
-                .collect::<Result<Vec<_>, _>>()?;
-            self.untracked_state
-                .writer(writes)
-                .stage_rows(&canonical_rows)?;
-        }
+fn is_commit_derived_only_request(request: &LiveStateScanRequest) -> bool {
+    !request.filter.schema_keys.is_empty()
+        && request
+            .filter
+            .schema_keys
+            .iter()
+            .all(|schema_key| is_commit_derived_schema(schema_key))
+}
 
-        if tracked_rows.is_empty() {
-            return Ok(());
-        }
+fn is_commit_derived_schema(schema_key: &str) -> bool {
+    matches!(schema_key, COMMIT_SCHEMA_KEY | COMMIT_EDGE_SCHEMA_KEY)
+}
+
+fn schema_filter_allows(schema_keys: &[String], schema_key: &str) -> bool {
+    schema_keys.is_empty() || schema_keys.iter().any(|candidate| candidate == schema_key)
+}
 
-        let identities = tracked_rows
+fn file_filter_allows_null(file_ids: &[NullableKeyFilter<String>]) -> bool {
+    file_ids.is_empty()
+        || file_ids
             .iter()
-            .map(|row| {
-                Ok(UntrackedStateIdentity {
-                    version_id: row.version_id.clone(),
-                    schema_key: row.schema_key.clone(),
-                    entity_id: row.entity_id.clone(),
-                    file_id: row.file_id.clone(),
-                })
-            })
-            .collect::<Result<Vec<_>, LixError>>()?;
-        self.untracked_state
-            .writer(writes)
-            .stage_delete_rows(&identities);
-
-        for (commit_id, rows) in grouped_live_rows_by_commit(&tracked_rows)? {
-            let parent_commit_id = parent_commit_id_for_commit_rows(commit_id, &rows)?;
-            validate_root_local_write_batch(commit_id, &rows)?;
-            // Commit graph facts live in the changelog/commit_graph projection.
-            // They are present in the write batch so the tracked root can inherit
-            // parent metadata, but they are not stored as version entities.
-            let root_rows = rows
-                .iter()
-                .filter(|row| row.schema_key != COMMIT_SCHEMA_KEY)
-                .map(|row| TrackedStateRow::try_from(*row))
-                .collect::<Result<Vec<_>, _>>()?;
-            self.tracked_state
-                .writer()
-                .stage_root(
-                    &mut self.store,
-                    writes,
-                    json_writer,
-                    commit_id,
-                    parent_commit_id.as_deref(),
-                    &root_rows,
-                )
-                .await?;
-        }
+            .any(|file_id| matches!(file_id, NullableKeyFilter::Any | NullableKeyFilter::Null))
+}
 
-        Ok(())
-    }
+fn commit_row(
+    commit: &crate::commit_graph::CommitGraphCommit,
+    version_id: &str,
+) -> Result<MaterializedLiveStateRow, LixError> {
+    let snapshot_content = serde_json::to_string(&serde_json::json!({
+        "id": commit.commit_id,
+    }))
+    .map_err(|error| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            format!("failed to encode derived lix_commit snapshot: {error}"),
+        )
+    })?;
+    Ok(MaterializedLiveStateRow {
+        entity_id: EntityIdentity::single(commit.commit_id.clone()),
+        schema_key: COMMIT_SCHEMA_KEY.to_string(),
+        file_id: None,
+        snapshot_content: Some(snapshot_content),
+        metadata: None,
+        deleted: false,
+        created_at: commit.change.created_at.clone(),
+        updated_at: commit.change.created_at.clone(),
+        global: true,
+        change_id: Some(commit.change.id.clone()),
+        commit_id: Some(commit.commit_id.clone()),
+        untracked: false,
+        version_id: version_id.to_string(),
+    })
 }
 
-fn tracked_scan_request_from_live(request: &LiveStateScanRequest) -> TrackedStateScanRequest {
-    let mut columns = request.projection.columns.clone();
-    if !columns.is_empty() && !columns.iter().any(|column| column == "snapshot_content") {
-        columns.push("snapshot_content".to_string());
-    }
+fn commit_edge_row(
+    edge: &crate::commit_graph::CommitGraphEdge,
+    version_id: &str,
+) -> Result<MaterializedLiveStateRow, LixError> {
+    let snapshot_content = serde_json::to_string(&serde_json::json!({
+        "parent_id": edge.parent_commit_id,
+        "child_id": edge.child_commit_id,
+        "parent_order": edge.parent_order,
+    }))
+    .map_err(|error| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            format!("failed to encode derived lix_commit_edge snapshot: {error}"),
+        )
+    })?;
+    Ok(MaterializedLiveStateRow {
+        entity_id: EntityIdentity {
+            parts: vec![edge.parent_commit_id.clone(), edge.child_commit_id.clone()],
+        },
+        schema_key: COMMIT_EDGE_SCHEMA_KEY.to_string(),
+        file_id: None,
+        snapshot_content: Some(snapshot_content),
+        metadata: None,
+        deleted: false,
+        created_at: "1970-01-01T00:00:00.000Z".to_string(),
+        updated_at: "1970-01-01T00:00:00.000Z".to_string(),
+        global: true,
+        change_id: None,
+        commit_id: Some(edge.child_commit_id.clone()),
+        untracked: false,
+        version_id: version_id.to_string(),
+    })
+}
 
+fn tracked_scan_request_from_live(request: &LiveStateScanRequest) -> TrackedStateScanRequest {
     TrackedStateScanRequest {
         filter: TrackedStateFilter {
             schema_keys: request.filter.schema_keys.clone(),
@@ -355,7 +405,9 @@ fn tracked_scan_request_from_live(request: &LiveStateScanRequest) -> TrackedStat
             // global fallback rows before the serving facade filters them.
             include_tombstones: true,
         },
-        projection: TrackedStateProjection { columns },
+        projection: TrackedStateProjection {
+            columns: request.projection.columns.clone(),
+        },
         limit: None,
     }
 }
@@ -368,7 +420,9 @@ fn untracked_scan_request_from_live(
     filter.version_ids = version_ids.to_vec();
     UntrackedStateScanRequest {
         filter,
-        projection: Default::default(),
+        projection: crate::untracked_state::UntrackedStateProjection {
+            columns: request.projection.columns.clone(),
+        },
         limit: None,
     }
 }
@@ -377,7 +431,6 @@ fn untracked_scan_request_from_live(
 struct LiveStateScanScope {
     storage_version_ids: Vec<String>,
     projection_version_ids: Vec<String>,
-    includes_commit_graph_projection: bool,
 }
 
 async fn scan_scope(
@@ -389,7 +442,6 @@ async fn scan_scope(
         return Ok(LiveStateScanScope {
             storage_version_ids: all_version_ref_ids(store, untracked_state).await?,
             projection_version_ids: Vec::new(),
-            includes_commit_graph_projection: true,
         });
     }
 
@@ -403,7 +455,6 @@ async fn scan_scope(
     let storage_version_ids = visibility::expanded_version_ids(&projection_version_ids);
     Ok(LiveStateScanScope {
         storage_version_ids,
-        includes_commit_graph_projection: !projection_version_ids.is_empty(),
         projection_version_ids,
     })
 }
@@ -424,7 +475,7 @@ async fn all_version_ref_ids(
         })
         .await?;
     rows.into_iter()
-        .map(|row| row.entity_id.as_string())
+        .map(|row| row.entity_id.as_single_string_owned())
         .collect()
 }
 
@@ -473,27 +524,6 @@ async fn version_ref_exists(
     )
 }
 
-const COMMIT_SCHEMA_KEY: &str = "lix_commit";
-
-fn live_state_row_from_commit(commit: CommitGraphCommit) -> LiveStateRow {
-    let change = commit.change;
-    LiveStateRow {
-        entity_id: change.entity_id,
-        schema_key: change.schema_key,
-        file_id: change.file_id,
-        snapshot_content: change.snapshot_content,
-        metadata: change.metadata,
-        schema_version: change.schema_version,
-        created_at: change.created_at.clone(),
-        updated_at: change.created_at,
-        global: true,
-        change_id: Some(change.id),
-        commit_id: Some(commit.commit_id),
-        untracked: false,
-        version_id: GLOBAL_VERSION_ID.to_string(),
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum TrackedRowSource {
     Global,
@@ -509,17 +539,17 @@ fn tracked_source_from_version_id(version_id: &str) -> TrackedRowSource {
 }
 
 fn project_tracked_row(
-    row: TrackedStateRow,
+    row: MaterializedTrackedStateRow,
     view_version_id: &str,
     source: TrackedRowSource,
-) -> LiveStateRow {
-    LiveStateRow {
+) -> MaterializedLiveStateRow {
+    MaterializedLiveStateRow {
         entity_id: row.entity_id,
         schema_key: row.schema_key,
         file_id: row.file_id,
         snapshot_content: row.snapshot_content,
         metadata: row.metadata,
-        schema_version: row.schema_version,
+        deleted: row.deleted,
         created_at: row.created_at,
         updated_at: row.updated_at,
         global: source == TrackedRowSource::Global,
@@ -530,164 +560,6 @@ fn project_tracked_row(
     }
 }
 
-fn live_state_row_matches_filter(row: &LiveStateRow, filter: &LiveStateFilter) -> bool {
-    if !filter.schema_keys.is_empty() && !filter.schema_keys.contains(&row.schema_key) {
-        return false;
-    }
-    if !filter.entity_ids.is_empty() && !filter.entity_ids.contains(&row.entity_id) {
-        return false;
-    }
-    if !filter.file_ids.is_empty()
-        && !filter
-            .file_ids
-            .iter()
-            .any(|filter| nullable_filter_matches(filter, &row.file_id))
-    {
-        return false;
-    }
-    true
-}
-
-fn nullable_filter_matches(
-    filter: &crate::NullableKeyFilter<String>,
-    value: &Option<String>,
-) -> bool {
-    match filter {
-        crate::NullableKeyFilter::Any => true,
-        crate::NullableKeyFilter::Null => value.is_none(),
-        crate::NullableKeyFilter::Value(expected) => value.as_ref() == Some(expected),
-    }
-}
-
-fn grouped_live_rows_by_commit<'a>(
-    rows: &[&'a LiveStateRow],
-) -> Result<Vec<(&'a str, Vec<&'a LiveStateRow>)>, LixError> {
-    let mut grouped = Vec::<(&str, Vec<&LiveStateRow>)>::new();
-    for row in rows {
-        let commit_id = row.commit_id.as_deref().ok_or_else(|| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "tracked live-state row is missing commit_id before tracked root write",
-            )
-        })?;
-        if let Some((_, bucket)) = grouped
-            .iter_mut()
-            .find(|(existing_commit_id, _)| *existing_commit_id == commit_id)
-        {
-            bucket.push(*row);
-        } else {
-            grouped.push((commit_id, vec![*row]));
-        }
-    }
-    Ok(grouped)
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct RootWriteScope {
-    version_id: String,
-    global: bool,
-}
-
-fn validate_root_local_write_batch(
-    commit_id: &str,
-    rows: &[&LiveStateRow],
-) -> Result<(), LixError> {
-    let mut root_scope = None::<RootWriteScope>;
-    for row in rows
-        .iter()
-        .copied()
-        .filter(|row| row.schema_key != COMMIT_SCHEMA_KEY)
-    {
-        let scope = RootWriteScope {
-            version_id: row.version_id.clone(),
-            global: row.global,
-        };
-        if row.global != (row.version_id == GLOBAL_VERSION_ID) {
-            return Err(LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                format!(
-                    "tracked root write for commit '{commit_id}' has invalid storage scope: version_id='{}', global={}",
-                    row.version_id, row.global
-                ),
-            ));
-        }
-        if let Some(existing) = &root_scope {
-            if existing != &scope {
-                return Err(LixError::new(
-                    "LIX_ERROR_UNKNOWN",
-                    format!(
-                        "tracked root write for commit '{commit_id}' mixes multiple storage scopes"
-                    ),
-                ));
-            }
-        } else {
-            root_scope = Some(scope);
-        }
-    }
-    Ok(())
-}
-
-fn parent_commit_id_for_commit_rows(
-    commit_id: &str,
-    rows: &[&LiveStateRow],
-) -> Result<Option<String>, LixError> {
-    let Some(row) = rows.iter().find(|row| {
-        row.schema_key == COMMIT_SCHEMA_KEY
-            && row
-                .entity_id
-                .as_string()
-                .is_ok_and(|entity_id| entity_id == commit_id)
-    }) else {
-        return Ok(None);
-    };
-    parent_commit_id_from_commit_row(row)
-}
-
-fn parent_commit_id_from_commit_row(row: &&LiveStateRow) -> Result<Option<String>, LixError> {
-    let snapshot = serde_json::from_str::<serde_json::Value>(
-        row.snapshot_content.as_deref().ok_or_else(|| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "tracked root commit row is missing snapshot_content",
-            )
-        })?,
-    )
-    .map_err(|error| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!("tracked root commit snapshot parse failed: {error}"),
-        )
-    })?;
-    let Some(parent_commit_ids_value) = snapshot.get("parent_commit_ids") else {
-        return Err(LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            "tracked root commit row is missing parent_commit_ids",
-        ));
-    };
-    let Some(parent_commit_ids_array) = parent_commit_ids_value.as_array() else {
-        return Err(LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            "tracked root commit parent_commit_ids must be an array",
-        ));
-    };
-    let parent_commit_ids = parent_commit_ids_array
-        .iter()
-        .map(|value| {
-            value.as_str().map(str::to_string).ok_or_else(|| {
-                LixError::new(
-                    "LIX_ERROR_UNKNOWN",
-                    "tracked root commit parent_commit_ids must contain strings",
-                )
-            })
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-
-    // Tracked roots inherit from the first parent. Merge commits record
-    // additional parents for graph ancestry, but the merge operation has
-    // already materialized the source-side rows as target-version writes.
-    Ok(parent_commit_ids.into_iter().next())
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum LiveStateLookupSource {
     Untracked,
@@ -754,21 +626,25 @@ mod tests {
 
     use super::*;
     use crate::backend::{testing::UnitTestBackend, Backend};
-    use crate::changelog::{canonicalize_materialized_change, MaterializedCanonicalChange};
+    use crate::commit_store::{CommitDraftRef, CommitStoreContext};
     use crate::entity_identity::EntityIdentity;
-    use crate::json_store::JsonStoreContext;
+    use crate::json_store::{
+        JsonStoreContext, JsonWritePlacementRef, NormalizedJson, NormalizedJsonRef,
+    };
     use crate::live_state::LiveStateFilter;
-    use crate::storage::{StorageContext, StorageWriteTransaction};
-    use crate::tracked_state::TrackedStateScanRequest;
+    use crate::storage::{StorageContext, StorageWriteSet, StorageWriteTransaction};
+    use crate::tracked_state::{TrackedStateDeltaRef, TrackedStateScanRequest};
     use crate::untracked_state::{MaterializedUntrackedStateRow, UntrackedStateContext};
     use crate::NullableKeyFilter;
     use serde_json::json;
 
+    const COMMIT_SCHEMA_KEY: &str = "lix_commit";
+
     fn live_state_context() -> LiveStateContext {
         LiveStateContext::new(
             crate::tracked_state::TrackedStateContext::new(),
             crate::untracked_state::UntrackedStateContext::new(),
-            crate::commit_graph::CommitGraphContext::new(crate::changelog::ChangelogContext::new()),
+            crate::commit_graph::CommitGraphContext::new(),
         )
     }
 
@@ -777,16 +653,14 @@ mod tests {
         rows: &[MaterializedUntrackedStateRow],
     ) {
         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<_>, _>>()
-                .expect("untracked rows should canonicalize")
-        };
+        let canonical_rows = rows
+            .iter()
+            .map(|row| crate::test_support::untracked_state_row_from_materialized(&mut writes, row))
+            .collect::<Result<Vec<_>, _>>()
+            .expect("untracked rows should canonicalize");
         UntrackedStateContext::new()
             .writer(&mut writes)
-            .stage_rows(&canonical_rows)
+            .stage_rows(canonical_rows.iter().map(|row| row.as_ref()))
             .expect("untracked rows should write");
         writes
             .apply(store)
@@ -794,6 +668,174 @@ mod tests {
             .expect("untracked rows should apply");
     }
 
+    async fn write_empty_commits_to_store(
+        store: &mut (impl StorageWriteTransaction + ?Sized),
+        commit_ids: &[&str],
+    ) {
+        let mut writes = StorageWriteSet::new();
+        for commit_id in commit_ids {
+            let commit_change_id = format!("{commit_id}:commit");
+            CommitStoreContext::new()
+                .writer(&mut *store, &mut writes)
+                .stage_commit_draft(
+                    CommitDraftRef {
+                        id: commit_id,
+                        change_id: &commit_change_id,
+                        parent_ids: &[],
+                        author_account_ids: &[],
+                        created_at: "1970-01-01T00:00:00.000Z",
+                    },
+                    Vec::new(),
+                    Vec::new(),
+                )
+                .await
+                .expect("empty commit should stage");
+        }
+        writes
+            .apply(store)
+            .await
+            .expect("empty commits should apply");
+    }
+
+    async fn stage_materialized_live_rows(
+        store: &mut (impl StorageReader + ?Sized),
+        writes: &mut StorageWriteSet,
+        _json_writer: &mut crate::json_store::JsonStoreWriter,
+        rows: &[MaterializedLiveStateRow],
+    ) -> Result<(), LixError> {
+        let mut untracked_rows = Vec::new();
+        let mut tracked_rows_by_commit = std::collections::BTreeMap::<
+            String,
+            Vec<(crate::commit_store::Change, String, String)>,
+        >::new();
+        let mut parent_by_commit = std::collections::BTreeMap::<String, Option<String>>::new();
+
+        for row in rows {
+            if row.untracked {
+                let materialized = crate::untracked_state::MaterializedUntrackedStateRow::from(row);
+                let canonical = crate::test_support::untracked_state_row_from_materialized(
+                    writes,
+                    &materialized,
+                )?;
+                untracked_rows.push(canonical);
+                continue;
+            }
+            let materialized = MaterializedTrackedStateRow::try_from(row)?;
+            let commit_id = row.commit_id.clone().ok_or_else(|| {
+                LixError::new("LIX_ERROR_UNKNOWN", "test tracked row missing commit_id")
+            })?;
+            if row.schema_key == COMMIT_SCHEMA_KEY {
+                parent_by_commit.insert(
+                    commit_id.clone(),
+                    parent_commit_id_from_test_commit_row(row)?,
+                );
+            }
+            if row.schema_key != COMMIT_SCHEMA_KEY {
+                let change = crate::test_support::tracked_change_from_materialized(&materialized)?;
+                stage_tracked_materialized_json(writes, &commit_id, &materialized)?;
+                tracked_rows_by_commit.entry(commit_id).or_default().push((
+                    change,
+                    materialized.created_at,
+                    materialized.updated_at,
+                ));
+            }
+        }
+
+        UntrackedStateContext::new()
+            .writer(writes)
+            .stage_rows(untracked_rows.iter().map(|row| row.as_ref()))?;
+        for (commit_id, rows) in tracked_rows_by_commit {
+            let parent_commit_id = parent_by_commit.remove(&commit_id).flatten();
+            let parent_ids = parent_commit_id
+                .as_ref()
+                .map(|parent| vec![parent.clone()])
+                .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(|(change, _, _)| change.created_at.as_str())
+                    .unwrap_or("1970-01-01T00:00:00.000Z"),
+            };
+            let staged = CommitStoreContext::new()
+                .writer(&mut *store, writes)
+                .stage_tracked_commit_draft(
+                    commit,
+                    rows.iter().map(|(change, _, _)| change.as_ref()).collect(),
+                    Vec::new(),
+                )
+                .await?;
+            let deltas = rows
+                .iter()
+                .zip(&staged.authored_locators)
+                .map(
+                    |((change, created_at, updated_at), locator)| TrackedStateDeltaRef {
+                        change: change.as_ref(),
+                        locator: locator.as_ref(),
+                        created_at,
+                        updated_at,
+                    },
+                )
+                .collect::<Vec<_>>();
+            TrackedStateContext::new()
+                .writer(&mut *store, writes)
+                .stage_delta(&commit_id, parent_commit_id.as_deref(), &deltas)
+                .await?;
+        }
+        Ok(())
+    }
+
+    fn stage_tracked_materialized_json(
+        writes: &mut StorageWriteSet,
+        commit_id: &str,
+        row: &MaterializedTrackedStateRow,
+    ) -> Result<(), LixError> {
+        let mut payloads = Vec::new();
+        if let Some(snapshot) = row.snapshot_content.as_deref() {
+            payloads.push(NormalizedJson::from_arc_unchecked(Arc::from(snapshot)));
+        }
+        if let Some(metadata) = row.metadata.as_ref() {
+            payloads.push(NormalizedJson::from_arc_unchecked(Arc::from(
+                crate::serialize_row_metadata(metadata),
+            )));
+        }
+        JsonStoreContext::new().writer().stage_batch(
+            writes,
+            JsonWritePlacementRef::CommitPack {
+                commit_id,
+                pack_id: 0,
+            },
+            payloads
+                .iter()
+                .map(|payload| NormalizedJsonRef::from(payload)),
+        )?;
+        Ok(())
+    }
+
+    fn parent_commit_id_from_test_commit_row(
+        row: &MaterializedLiveStateRow,
+    ) -> Result<Option<String>, LixError> {
+        let Some(metadata) = row.metadata.as_deref() else {
+            return Ok(None);
+        };
+        let metadata = serde_json::from_str::<serde_json::Value>(metadata).map_err(|error| {
+            LixError::new(
+                "LIX_ERROR_UNKNOWN",
+                format!("test commit row has invalid metadata: {error}"),
+            )
+        })?;
+        Ok(metadata
+            .get("test_parents")
+            .and_then(serde_json::Value::as_array)
+            .and_then(|parents| parents.first())
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_string))
+    }
+
     #[tokio::test]
     async fn live_state_overlays_untracked_rows() {
         let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
@@ -808,19 +850,18 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(
-                        &mut writes,
-                        &mut json_writer,
-                        &[tracked_row_with_commit(
-                            "tracked-value",
-                            Some("change-tracked"),
-                            "commit-tracked",
-                        )],
-                    )
-                    .await
-                    .expect("tracked row should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &[tracked_row_with_commit(
+                        "tracked-value",
+                        Some("change-tracked"),
+                        "commit-tracked",
+                    )],
+                )
+                .await
+                .expect("tracked row should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -880,19 +921,18 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(
-                        &mut writes,
-                        &mut json_writer,
-                        &[tracked_row_with_commit(
-                            "tracked-value",
-                            Some("change-tracked"),
-                            "commit-tracked",
-                        )],
-                    )
-                    .await
-                    .expect("tracked row should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &[tracked_row_with_commit(
+                        "tracked-value",
+                        Some("change-tracked"),
+                        "commit-tracked",
+                    )],
+                )
+                .await
+                .expect("tracked row should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -932,19 +972,18 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(
-                        &mut writes,
-                        &mut json_writer,
-                        &[tracked_row_with_commit(
-                            "tracked-value",
-                            Some("change-tracked"),
-                            "commit-tracked",
-                        )],
-                    )
-                    .await
-                    .expect("tracked row should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &[tracked_row_with_commit(
+                        "tracked-value",
+                        Some("change-tracked"),
+                        "commit-tracked",
+                    )],
+                )
+                .await
+                .expect("tracked row should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -961,14 +1000,15 @@ mod tests {
         .await;
         {
             let mut writes = StorageWriteSet::new();
+            let identity = crate::untracked_state::UntrackedStateIdentity {
+                version_id: "global".to_string(),
+                schema_key: "lix_key_value".to_string(),
+                entity_id: EntityIdentity::single("selected-tab"),
+                file_id: None,
+            };
             UntrackedStateContext::new()
                 .writer(&mut writes)
-                .stage_delete_rows(&[crate::untracked_state::UntrackedStateIdentity {
-                    version_id: "global".to_string(),
-                    schema_key: "lix_key_value".to_string(),
-                    entity_id: EntityIdentity::single("selected-tab"),
-                    file_id: None,
-                }]);
+                .stage_delete_rows(std::iter::once(identity.as_ref()));
             writes
                 .apply(&mut transaction.as_mut())
                 .await
@@ -1007,11 +1047,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked row should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked row should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1026,6 +1069,7 @@ mod tests {
             ],
         )
         .await;
+        write_empty_commits_to_store(transaction.as_mut(), &["commit-version-a"]).await;
         transaction.commit().await.expect("commit should persist");
 
         let loaded = load_selected_tab_at(&live_state, storage.clone(), "version-a")
@@ -1050,7 +1094,7 @@ mod tests {
         let live_state = LiveStateContext::new(
             tracked_state.clone(),
             UntrackedStateContext::new(),
-            crate::commit_graph::CommitGraphContext::new(crate::changelog::ChangelogContext::new()),
+            crate::commit_graph::CommitGraphContext::new(),
         );
 
         let mut transaction = storage
@@ -1066,11 +1110,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("global tracked row should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("global tracked row should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1085,6 +1132,7 @@ mod tests {
             ],
         )
         .await;
+        write_empty_commits_to_store(transaction.as_mut(), &["commit-main"]).await;
         transaction.commit().await.expect("commit should persist");
 
         let loaded = load_selected_tab_at(&live_state, storage.clone(), "main")
@@ -1130,11 +1178,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1187,11 +1238,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1244,11 +1298,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1303,11 +1360,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1355,11 +1415,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1374,6 +1437,7 @@ mod tests {
             ],
         )
         .await;
+        write_empty_commits_to_store(transaction.as_mut(), &["commit-version-a"]).await;
         transaction.commit().await.expect("commit should persist");
 
         let rows = scan_selected_tab_at(&live_state, storage.clone(), "version-a", false)
@@ -1408,11 +1472,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked row should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked row should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1459,11 +1526,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1515,11 +1585,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1550,158 +1623,6 @@ mod tests {
         assert_eq!(tombstones[0].snapshot_content, None);
     }
 
-    #[tokio::test]
-    async fn scan_rows_projects_commit_graph_facts_as_global_rows() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        append_commit_change(storage.clone(), "commit-a").await;
-        write_version_refs(storage.clone(), &[version_ref_row("version-a", "commit-a")]).await;
-
-        let rows = live_state
-            .reader(storage.clone())
-            .scan_rows(&LiveStateScanRequest {
-                filter: LiveStateFilter {
-                    schema_keys: vec![COMMIT_SCHEMA_KEY.to_string()],
-                    version_ids: vec!["version-a".to_string()],
-                    ..LiveStateFilter::default()
-                },
-                ..LiveStateScanRequest::default()
-            })
-            .await
-            .expect("commit rows should scan");
-
-        assert_eq!(rows.len(), 1);
-        assert_eq!(rows[0].entity_id.as_string().as_deref(), Ok("commit-a"));
-        assert_eq!(rows[0].schema_key, COMMIT_SCHEMA_KEY);
-        assert_eq!(rows[0].version_id, "version-a");
-        assert!(rows[0].global);
-        assert!(!rows[0].untracked);
-        assert_eq!(rows[0].change_id.as_deref(), Some("change-commit-a"));
-        assert_eq!(rows[0].commit_id.as_deref(), Some("commit-a"));
-    }
-
-    #[tokio::test]
-    async fn load_row_reads_commit_graph_fact() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        append_commit_change(storage.clone(), "commit-a").await;
-        write_version_refs(storage.clone(), &[version_ref_row("version-a", "commit-a")]).await;
-
-        let row = live_state
-            .reader(storage.clone())
-            .load_row(&LiveStateRowRequest {
-                schema_key: COMMIT_SCHEMA_KEY.to_string(),
-                version_id: "version-a".to_string(),
-                entity_id: crate::entity_identity::EntityIdentity::single("commit-a"),
-                file_id: NullableKeyFilter::Null,
-            })
-            .await
-            .expect("commit row should load")
-            .expect("commit row should exist");
-
-        assert_eq!(row.entity_id.as_string().as_deref(), Ok("commit-a"));
-        assert_eq!(row.version_id, "version-a");
-        assert!(row.global);
-        assert_eq!(row.change_id.as_deref(), Some("change-commit-a"));
-        assert_eq!(row.commit_id.as_deref(), Some("commit-a"));
-    }
-
-    #[tokio::test]
-    async fn load_commit_row_does_not_project_into_missing_version() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        append_commit_change(storage.clone(), "commit-a").await;
-
-        let row = live_state
-            .reader(storage.clone())
-            .load_row(&LiveStateRowRequest {
-                schema_key: COMMIT_SCHEMA_KEY.to_string(),
-                version_id: "missing-version".to_string(),
-                entity_id: crate::entity_identity::EntityIdentity::single("commit-a"),
-                file_id: NullableKeyFilter::Null,
-            })
-            .await
-            .expect("commit row load should succeed");
-
-        assert_eq!(
-            row, None,
-            "commit rows must not be projected into a missing version scope"
-        );
-    }
-
-    #[tokio::test]
-    async fn writer_rejects_tracked_root_batches_that_mix_global_and_version_rows() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-
-        let error = {
-            let rows = [
-                tracked_row_at_with_commit(
-                    "global",
-                    "global-row",
-                    Some("change-global"),
-                    "commit-shared",
-                ),
-                tracked_row_at_with_commit(
-                    "version-a",
-                    "version-row",
-                    Some("change-version"),
-                    "commit-shared",
-                ),
-            ];
-            let mut writes = StorageWriteSet::new();
-            let mut json_writer = JsonStoreContext::new().writer();
-            let mut writer = live_state.writer(transaction.as_mut());
-            writer
-                .stage_rows(&mut writes, &mut json_writer, &rows)
-                .await
-        }
-        .expect_err("one tracked root must not mix global and version rows");
-
-        assert!(
-            error.message.contains("mixes multiple storage scopes"),
-            "unexpected error: {error:?}"
-        );
-    }
-
-    #[tokio::test]
-    async fn writer_rejects_tracked_rows_with_invalid_storage_scope() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        let mut invalid_row =
-            tracked_row_at_with_commit("version-a", "bad-row", Some("change-bad"), "commit-bad");
-        invalid_row.global = true;
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-
-        let error = {
-            let rows = [invalid_row];
-            let mut writes = StorageWriteSet::new();
-            let mut json_writer = JsonStoreContext::new().writer();
-            let mut writer = live_state.writer(transaction.as_mut());
-            writer
-                .stage_rows(&mut writes, &mut json_writer, &rows)
-                .await
-        }
-        .expect_err("global rows must be stored in the global root only");
-
-        assert!(
-            error.message.contains("invalid storage scope"),
-            "unexpected error: {error:?}"
-        );
-    }
-
     #[tokio::test]
     async fn writer_allows_commit_fact_to_share_the_touched_version_commit_id() {
         let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
@@ -1725,11 +1646,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("commit facts are changelog projections, not root-local rows");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("commit facts are changelog projections, not root-local rows");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1757,25 +1681,31 @@ mod tests {
     async fn writer_uses_first_parent_as_merge_root_base() {
         let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
         let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
         let mut seed_transaction = storage
             .begin_write_transaction()
             .await
             .expect("seed transaction should open");
         let mut writes = StorageWriteSet::new();
         {
-            let mut json_writer = JsonStoreContext::new().writer();
-            TrackedStateContext::new()
-                .writer()
-                .stage_root(
-                    &mut seed_transaction.as_mut(),
-                    &mut writes,
-                    &mut json_writer,
-                    "parent-left",
-                    None,
-                    &[],
+            CommitStoreContext::new()
+                .writer(&mut seed_transaction.as_mut(), &mut writes)
+                .stage_commit_draft(
+                    CommitDraftRef {
+                        id: "parent-left",
+                        change_id: "parent-left:commit",
+                        parent_ids: &[],
+                        author_account_ids: &[],
+                        created_at: "1970-01-01T00:00:00.000Z",
+                    },
+                    Vec::new(),
+                    Vec::new(),
                 )
                 .await
+                .expect("first parent commit should stage");
+            TrackedStateContext::new()
+                .writer(&mut seed_transaction.as_mut(), &mut writes)
+                .stage_delta("parent-left", None, &[])
+                .await
                 .expect("first parent root should exist");
         }
         writes
@@ -1808,11 +1738,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("merge commit should use first parent as tracked-root base");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("merge commit should use first parent as tracked-root base");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1821,101 +1754,11 @@ mod tests {
         }
     }
 
-    #[tokio::test]
-    async fn writer_rejects_commit_root_with_missing_parent_commit_ids() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-
-        let error = {
-            let rows = [
-                tracked_row_at_with_commit(
-                    "version-a",
-                    "version-row",
-                    Some("change-version"),
-                    "commit-malformed",
-                ),
-                commit_live_state_row_with_snapshot(
-                    "commit-malformed",
-                    json!({
-                        "id": "commit-malformed",
-                        "change_set_id": "change-set-commit-malformed",
-                        "change_ids": ["change-version"],
-                    }),
-                ),
-            ];
-            let mut writes = StorageWriteSet::new();
-            let mut json_writer = JsonStoreContext::new().writer();
-            let mut writer = live_state.writer(transaction.as_mut());
-            writer
-                .stage_rows(&mut writes, &mut json_writer, &rows)
-                .await
-        }
-        .expect_err("commit roots must declare parent_commit_ids");
-
-        assert!(
-            error.message.contains("missing parent_commit_ids"),
-            "unexpected error: {error:?}"
-        );
-    }
-
-    #[tokio::test]
-    async fn writer_rejects_commit_root_with_non_array_parent_commit_ids() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(Arc::clone(&backend));
-        let live_state = live_state_context();
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-
-        let error = {
-            let rows = [
-                tracked_row_at_with_commit(
-                    "version-a",
-                    "version-row",
-                    Some("change-version"),
-                    "commit-malformed",
-                ),
-                commit_live_state_row_with_snapshot(
-                    "commit-malformed",
-                    json!({
-                        "id": "commit-malformed",
-                        "change_set_id": "change-set-commit-malformed",
-                        "change_ids": ["change-version"],
-                        "parent_commit_ids": "parent-1",
-                    }),
-                ),
-            ];
-            let mut writes = StorageWriteSet::new();
-            let mut json_writer = JsonStoreContext::new().writer();
-            let mut writer = live_state.writer(transaction.as_mut());
-            writer
-                .stage_rows(&mut writes, &mut json_writer, &rows)
-                .await
-        }
-        .expect_err("commit root parent_commit_ids must be an array");
-
-        assert!(
-            error.message.contains("parent_commit_ids must be an array"),
-            "unexpected error: {error:?}"
-        );
-    }
-
     #[tokio::test]
     async fn non_global_root_does_not_store_global_rows() {
         let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
         let storage = StorageContext::new(Arc::clone(&backend));
         let tracked_state = TrackedStateContext::new();
-        let live_state = LiveStateContext::new(
-            tracked_state.clone(),
-            UntrackedStateContext::new(),
-            crate::commit_graph::CommitGraphContext::new(crate::changelog::ChangelogContext::new()),
-        );
         let mut transaction = storage
             .begin_write_transaction()
             .await
@@ -1934,11 +1777,14 @@ mod tests {
             let mut writes = StorageWriteSet::new();
             let mut json_writer = JsonStoreContext::new().writer();
             {
-                let mut writer = live_state.writer(transaction.as_mut());
-                writer
-                    .stage_rows(&mut writes, &mut json_writer, &rows)
-                    .await
-                    .expect("tracked rows should stage");
+                stage_materialized_live_rows(
+                    transaction.as_mut(),
+                    &mut writes,
+                    &mut json_writer,
+                    &rows,
+                )
+                .await
+                .expect("tracked rows should stage");
             }
             writes
                 .apply(&mut transaction.as_mut())
@@ -1967,7 +1813,7 @@ mod tests {
     async fn load_selected_tab(
         live_state: &LiveStateContext,
         storage: StorageContext,
-    ) -> Result<Option<LiveStateRow>, LixError> {
+    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
         live_state
             .reader(storage)
             .load_row(&LiveStateRowRequest {
@@ -1983,7 +1829,7 @@ mod tests {
         live_state: &LiveStateContext,
         storage: StorageContext,
         version_id: &str,
-    ) -> Result<Option<LiveStateRow>, LixError> {
+    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
         live_state
             .reader(storage)
             .load_row(&LiveStateRowRequest {
@@ -2000,7 +1846,7 @@ mod tests {
         storage: StorageContext,
         version_id: &str,
         include_tombstones: bool,
-    ) -> Result<Vec<LiveStateRow>, LixError> {
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
         live_state
             .reader(storage)
             .scan_rows(&LiveStateScanRequest {
@@ -2023,7 +1869,7 @@ mod tests {
         tracked_state: &TrackedStateContext,
         storage: StorageContext,
         commit_id: &str,
-    ) -> Vec<TrackedStateRow> {
+    ) -> Vec<MaterializedTrackedStateRow> {
         tracked_state
             .reader(storage)
             .scan_rows_at_commit(
@@ -2044,7 +1890,7 @@ mod tests {
         value: &str,
         change_id: Option<&str>,
         commit_id: &str,
-    ) -> LiveStateRow {
+    ) -> MaterializedLiveStateRow {
         tracked_row_at_with_commit("global", value, change_id, commit_id)
     }
 
@@ -2053,14 +1899,14 @@ mod tests {
         value: &str,
         change_id: Option<&str>,
         commit_id: &str,
-    ) -> LiveStateRow {
-        LiveStateRow {
+    ) -> MaterializedLiveStateRow {
+        MaterializedLiveStateRow {
             entity_id: identity("selected-tab"),
             schema_key: "lix_key_value".to_string(),
             file_id: None,
             snapshot_content: Some(format!("{{\"value\":\"{value}\"}}")),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: "2026-01-01T00:00:00Z".to_string(),
             updated_at: "2026-01-01T00:00:00Z".to_string(),
             global: version_id == "global",
@@ -2075,9 +1921,10 @@ mod tests {
         version_id: &str,
         change_id: Option<&str>,
         commit_id: &str,
-    ) -> LiveStateRow {
-        LiveStateRow {
+    ) -> MaterializedLiveStateRow {
+        MaterializedLiveStateRow {
             snapshot_content: None,
+            deleted: true,
             ..tracked_row_at_with_commit(version_id, "ignored", change_id, commit_id)
         }
     }
@@ -2093,7 +1940,7 @@ mod tests {
             file_id: None,
             snapshot_content: Some(format!("{{\"value\":\"{value}\"}}")),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: "2026-01-01T00:00:00Z".to_string(),
             updated_at: "2026-01-01T00:00:00Z".to_string(),
             global: version_id == "global",
@@ -2114,7 +1961,7 @@ mod tests {
                 .expect("version ref should serialize"),
             ),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: "2026-01-01T00:00:00Z".to_string(),
             updated_at: "2026-01-01T00:00:00Z".to_string(),
             global: true,
@@ -2122,57 +1969,32 @@ mod tests {
         }
     }
 
-    async fn write_version_refs(storage: StorageContext, refs: &[MaterializedUntrackedStateRow]) {
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("version-ref transaction should open");
-        let mut writes = StorageWriteSet::new();
-        let canonical_refs = {
-            let mut json_writer = JsonStoreContext::new().writer();
-            refs.iter()
-                .map(|row| canonicalize_materialized_row(&mut writes, &mut json_writer, row))
-                .collect::<Result<Vec<_>, _>>()
-                .expect("version refs should canonicalize")
-        };
-        UntrackedStateContext::new()
-            .writer(&mut writes)
-            .stage_rows(&canonical_refs)
-            .expect("version refs should write");
-        writes
-            .apply(&mut transaction.as_mut())
-            .await
-            .expect("version refs should apply");
-        transaction
-            .commit()
-            .await
-            .expect("version-ref transaction should commit");
-    }
-
-    fn commit_live_state_row(commit_id: &str) -> LiveStateRow {
+    fn commit_live_state_row(commit_id: &str) -> MaterializedLiveStateRow {
         commit_live_state_row_with_parents(commit_id, &[])
     }
 
     fn commit_live_state_row_with_parents(
         commit_id: &str,
-        parent_commit_ids: &[&str],
-    ) -> LiveStateRow {
-        commit_live_state_row_with_snapshot(
+        parent_ids: &[&str],
+    ) -> MaterializedLiveStateRow {
+        let mut row = commit_live_state_row_with_snapshot(
             commit_id,
             json!({
                 "id": commit_id,
-                "change_set_id": format!("change-set-{commit_id}"),
-                "change_ids": ["change-version"],
-                "parent_commit_ids": parent_commit_ids,
             }),
-        )
+        );
+        row.metadata = Some(
+            serde_json::to_string(&json!({ "test_parents": parent_ids }))
+                .expect("test metadata should serialize"),
+        );
+        row
     }
 
     fn commit_live_state_row_with_snapshot(
         commit_id: &str,
         snapshot: serde_json::Value,
-    ) -> LiveStateRow {
-        LiveStateRow {
+    ) -> MaterializedLiveStateRow {
+        MaterializedLiveStateRow {
             entity_id: identity(commit_id),
             schema_key: COMMIT_SCHEMA_KEY.to_string(),
             file_id: None,
@@ -2180,7 +2002,7 @@ mod tests {
                 serde_json::to_string(&snapshot).expect("commit snapshot should serialize"),
             ),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: "2026-01-01T00:00:00Z".to_string(),
             updated_at: "2026-01-01T00:00:00Z".to_string(),
             global: true,
@@ -2191,50 +2013,6 @@ mod tests {
         }
     }
 
-    async fn append_commit_change(storage: StorageContext, commit_id: &str) {
-        let changelog = crate::changelog::ChangelogContext::new();
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let change = MaterializedCanonicalChange {
-            id: format!("change-{commit_id}"),
-            entity_id: crate::entity_identity::EntityIdentity::single(commit_id),
-            schema_key: COMMIT_SCHEMA_KEY.to_string(),
-            schema_version: "1".to_string(),
-            file_id: None,
-            snapshot_content: Some(
-                serde_json::to_string(&json!({
-                    "id": commit_id,
-                    "change_set_id": format!("change-set-{commit_id}"),
-                    "change_ids": [],
-                    "parent_commit_ids": [],
-                }))
-                .expect("commit snapshot should serialize"),
-            ),
-            metadata: None,
-            created_at: "2026-01-01T00:00:00Z".to_string(),
-        };
-        let mut writes = StorageWriteSet::new();
-        let canonical_change = {
-            let mut json_writer = JsonStoreContext::new().writer();
-            canonicalize_materialized_change(&mut writes, &mut json_writer, &change)
-                .expect("commit change should canonicalize")
-        };
-        changelog
-            .writer(&mut writes)
-            .stage_changes(&[canonical_change])
-            .expect("commit change should append");
-        writes
-            .apply(&mut transaction.as_mut())
-            .await
-            .expect("commit change should apply");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
-    }
-
     fn identity(entity_id: &str) -> EntityIdentity {
         EntityIdentity::single(entity_id)
     }