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

package/dist-engine-src/src/transaction/staging.rs

@@ -1,9 +1,9 @@
-use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::collections::{BTreeMap, HashMap};
 use std::sync::{Arc, Mutex};
 
 use crate::catalog::SchemaPlanId;
 use crate::domain::{Domain, DomainRowIdentity};
-use crate::entity_identity::EntityIdentity;
+use crate::entity_pk::EntityPk;
 use crate::functions::{FunctionProvider, FunctionProviderHandle};
 #[cfg(test)]
 use crate::live_state::LiveStateRowRequest;
@@ -11,11 +11,12 @@ use crate::live_state::{LiveStateScanRequest, MaterializedLiveStateRow};
 #[cfg(test)]
 use crate::transaction::types::{stage_json_from_value, TransactionJson};
 use crate::transaction::types::{
-    LogicalPrimaryKey, PreparedTransactionWrite, TransactionFileData, TransactionWriteMode,
-    TransactionWriteOperation, TransactionWriteOrigin, TransactionWriteOutcome,
+    LogicalPrimaryKey, PreparedTransactionWrite, StagedCommitChangeRef, TransactionFileData,
+    TransactionWriteMode, TransactionWriteOperation, TransactionWriteOrigin,
+    TransactionWriteOutcome,
 };
-use crate::transaction::types::{PreparedAdoptedStateRow, PreparedStateRow, StagedCommitMembers};
-use crate::GLOBAL_VERSION_ID;
+use crate::transaction::types::{PreparedStateRow, StagedCommitChangeRefs};
+use crate::GLOBAL_BRANCH_ID;
 use crate::{LixError, NullableKeyFilter};
 
 /// Transaction-local write buffer after transaction-boundary preparation.
@@ -27,28 +28,25 @@ use crate::{LixError, NullableKeyFilter};
 pub(crate) struct TransactionWriteBuffer {
     functions: FunctionProviderHandle,
     rows: Mutex<Vec<Option<PreparedStateRow>>>,
-    adopted_rows: Mutex<Vec<Option<PreparedAdoptedStateRow>>>,
     by_identity: Mutex<HashMap<PreparedStateRowIdentity, RowSlot>>,
     insert_identities: Mutex<BTreeMap<PreparedStateRowIdentity, Option<TransactionWriteOrigin>>>,
-    commit_members_by_version: Mutex<BTreeMap<String, StagedCommitMembers>>,
-    extra_commit_parents_by_version: Mutex<BTreeMap<String, Vec<String>>>,
+    commit_change_refs_by_branch: Mutex<BTreeMap<String, StagedCommitChangeRefs>>,
+    extra_commit_parents_by_branch: Mutex<BTreeMap<String, Vec<String>>>,
     file_data_writes: Mutex<Vec<TransactionFileData>>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum RowSlot {
     State(usize),
-    Adopted(usize),
 }
 
 /// Drained prepared transaction writes ready for commit.
 pub(crate) struct PreparedWriteSet {
     pub(crate) state_rows: Vec<PreparedStateRow>,
-    pub(crate) adopted_rows: Vec<PreparedAdoptedStateRow>,
     pub(crate) insert_identities:
         BTreeMap<PreparedStateRowIdentity, Option<TransactionWriteOrigin>>,
-    pub(crate) commit_members_by_version: BTreeMap<String, StagedCommitMembers>,
-    pub(crate) extra_commit_parents_by_version: BTreeMap<String, Vec<String>>,
+    pub(crate) commit_change_refs_by_branch: BTreeMap<String, StagedCommitChangeRefs>,
+    pub(crate) extra_commit_parents_by_branch: BTreeMap<String, Vec<String>>,
     pub(crate) file_data_writes: Vec<TransactionFileData>,
 }
 
@@ -75,35 +73,30 @@ pub(crate) struct PreparedWriteValidationIndex<'a> {
 #[derive(Clone, Copy)]
 pub(crate) enum PreparedValidationRow<'a> {
     State(&'a PreparedStateRow),
-    Adopted(&'a PreparedAdoptedStateRow),
 }
 
 impl<'a> PreparedValidationRow<'a> {
-    pub(crate) fn entity_id(&self) -> &EntityIdentity {
+    pub(crate) fn entity_pk(&self) -> &EntityPk {
         match self {
-            Self::State(row) => &row.entity_id,
-            Self::Adopted(row) => &row.entity_id,
+            Self::State(row) => &row.entity_pk,
         }
     }
 
     pub(crate) fn schema_plan_id(&self) -> SchemaPlanId {
         match self {
             Self::State(row) => row.schema_plan_id,
-            Self::Adopted(row) => row.schema_plan_id,
         }
     }
 
     pub(crate) fn schema_key(&self) -> &str {
         match self {
             Self::State(row) => &row.schema_key,
-            Self::Adopted(row) => &row.schema_key,
         }
     }
 
     pub(crate) fn file_id(&self) -> &Option<String> {
         match self {
             Self::State(row) => &row.file_id,
-            Self::Adopted(row) => &row.file_id,
         }
     }
 
@@ -114,10 +107,6 @@ impl<'a> PreparedValidationRow<'a> {
                 .snapshot
                 .as_ref()
                 .map(|snapshot| snapshot.normalized.as_ref()),
-            Self::Adopted(row) => row
-                .snapshot
-                .as_ref()
-                .map(|snapshot| snapshot.normalized.as_ref()),
         }
     }
 
@@ -127,10 +116,6 @@ impl<'a> PreparedValidationRow<'a> {
                 .snapshot
                 .as_ref()
                 .map(|snapshot| snapshot.value.as_ref()),
-            Self::Adopted(row) => row
-                .snapshot
-                .as_ref()
-                .map(|snapshot| snapshot.value.as_ref()),
         }
     }
 
@@ -140,30 +125,30 @@ impl<'a> PreparedValidationRow<'a> {
                 .metadata
                 .as_ref()
                 .map(|metadata| metadata.value.as_ref()),
-            Self::Adopted(row) => row
-                .metadata
-                .as_ref()
-                .map(|metadata| metadata.value.as_ref()),
+        }
+    }
+
+    pub(crate) fn is_tombstone(&self) -> bool {
+        match self {
+            Self::State(row) => row.snapshot.is_none(),
         }
     }
 
     pub(crate) fn untracked(&self) -> bool {
         match self {
             Self::State(row) => row.untracked,
-            Self::Adopted(_) => false,
         }
     }
 
-    pub(crate) fn version_id(&self) -> &str {
+    pub(crate) fn branch_id(&self) -> &str {
         match self {
-            Self::State(row) => &row.version_id,
-            Self::Adopted(row) => &row.version_id,
+            Self::State(row) => &row.branch_id,
         }
     }
 
     pub(crate) fn domain(&self) -> Domain {
         Domain::exact_file(
-            self.version_id().to_string(),
+            self.branch_id().to_string(),
             self.untracked(),
             self.file_id().clone(),
         )
@@ -173,7 +158,7 @@ impl<'a> PreparedValidationRow<'a> {
         DomainRowIdentity::in_domain(
             self.domain(),
             self.schema_key().to_string(),
-            self.entity_id().clone(),
+            self.entity_pk().clone(),
         )
     }
 }
@@ -193,7 +178,7 @@ impl<'a> PreparedWriteValidationIndex<'a> {
             .flat_map(|(target_scope, rows)| {
                 rows.iter().copied().filter(move |row| {
                     schema_scope.validation_scope_contains_constraint_domain(target_scope)
-                        || (row.snapshot_json().is_none()
+                        || (row.is_tombstone()
                             && target_scope.tombstone_domain_affects_validation_scope(schema_scope))
                 })
             })
@@ -235,10 +220,7 @@ impl<'a> PreparedWriteValidationSet<'a> {
 impl PreparedWriteSet {
     #[cfg(test)]
     pub(crate) fn validation_rows(&self) -> impl Iterator<Item = PreparedValidationRow<'_>> + '_ {
-        self.state_rows
-            .iter()
-            .map(PreparedValidationRow::State)
-            .chain(self.adopted_rows.iter().map(PreparedValidationRow::Adopted))
+        self.state_rows.iter().map(PreparedValidationRow::State)
     }
 
     pub(crate) fn validation_index(&self) -> PreparedWriteValidationIndex<'_> {
@@ -250,14 +232,6 @@ impl PreparedWriteSet {
                 .or_default()
                 .push(row);
         }
-        for row in &self.adopted_rows {
-            let row = PreparedValidationRow::Adopted(row);
-            rows_by_schema_scope
-                .entry(row.domain().schema_catalog_domain())
-                .or_default()
-                .push(row);
-        }
-
         let mut insert_identities_by_schema_scope = BTreeMap::<
             Domain,
             Vec<(&PreparedStateRowIdentity, Option<&TransactionWriteOrigin>)>,
@@ -296,11 +270,10 @@ impl TransactionWriteBuffer {
         Self {
             functions,
             rows: Mutex::new(Vec::new()),
-            adopted_rows: Mutex::new(Vec::new()),
             by_identity: Mutex::new(HashMap::new()),
             insert_identities: Mutex::new(BTreeMap::new()),
-            commit_members_by_version: Mutex::new(BTreeMap::new()),
-            extra_commit_parents_by_version: Mutex::new(BTreeMap::new()),
+            commit_change_refs_by_branch: Mutex::new(BTreeMap::new()),
+            extra_commit_parents_by_branch: Mutex::new(BTreeMap::new()),
             file_data_writes: Mutex::new(Vec::new()),
         }
     }
@@ -313,12 +286,6 @@ impl TransactionWriteBuffer {
                 "failed to acquire transaction staged writes lock",
             )
         })?;
-        let mut adopted_rows_guard = self.adopted_rows.lock().map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged adopted writes lock",
-            )
-        })?;
         let mut by_identity_guard = self.by_identity.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
@@ -337,112 +304,87 @@ impl TransactionWriteBuffer {
                 "failed to acquire transaction staged insert identity lock",
             )
         })?;
-        let mut commit_members_guard = self.commit_members_by_version.lock().map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged commit membership lock",
-            )
-        })?;
-        let mut extra_parents_guard =
-            self.extra_commit_parents_by_version.lock().map_err(|_| {
+        let mut commit_change_refs_guard =
+            self.commit_change_refs_by_branch.lock().map_err(|_| {
                 LixError::new(
                     "LIX_ERROR_UNKNOWN",
-                    "failed to acquire transaction staged extra commit parents lock",
+                    "failed to acquire transaction staged commit change refs lock",
                 )
             })?;
+        let mut extra_parents_guard = self.extra_commit_parents_by_branch.lock().map_err(|_| {
+            LixError::new(
+                "LIX_ERROR_UNKNOWN",
+                "failed to acquire transaction staged extra commit parents lock",
+            )
+        })?;
         let result = Ok(PreparedWriteSet {
             state_rows: std::mem::take(&mut *rows_guard)
                 .into_iter()
                 .flatten()
                 .collect(),
-            adopted_rows: std::mem::take(&mut *adopted_rows_guard)
-                .into_iter()
-                .flatten()
-                .collect(),
             insert_identities: std::mem::take(&mut *insert_identities_guard),
-            commit_members_by_version: std::mem::take(&mut *commit_members_guard),
-            extra_commit_parents_by_version: std::mem::take(&mut *extra_parents_guard),
+            commit_change_refs_by_branch: std::mem::take(&mut *commit_change_refs_guard),
+            extra_commit_parents_by_branch: std::mem::take(&mut *extra_parents_guard),
             file_data_writes: std::mem::take(&mut *file_data_guard),
         });
         by_identity_guard.clear();
         result
     }
 
-    /// Records an additional parent for the commit generated for `version_id`.
+    /// Records an additional parent for the commit generated for `branch_id`.
     ///
-    /// Normal writes parent the new commit to the version's previous head.
-    /// Merges add the source version head as an extra parent so the commit graph
+    /// Normal writes parent the new commit to the branch's previous head.
+    /// Merges add the source branch head as an extra parent so the commit graph
     /// preserves branch ancestry while tracked-state roots still apply source
     /// rows onto the target root.
     pub(crate) fn add_commit_parent(
         &self,
-        version_id: String,
+        branch_id: String,
         parent_commit_id: String,
     ) -> Result<(), LixError> {
-        let mut guard = self.extra_commit_parents_by_version.lock().map_err(|_| {
+        let mut guard = self.extra_commit_parents_by_branch.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
                 "failed to acquire transaction staged extra commit parents lock",
             )
         })?;
-        let parents = guard.entry(version_id).or_default();
+        let parents = guard.entry(branch_id).or_default();
         if !parents.contains(&parent_commit_id) {
             parents.push(parent_commit_id);
         }
         Ok(())
     }
 
-    pub(crate) fn staged_commit_id(&self, version_id: &str) -> Result<Option<String>, LixError> {
-        let guard = self.commit_members_by_version.lock().map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged commit membership lock",
-            )
-        })?;
-        Ok(guard
-            .get(version_id)
-            .map(|members| members.commit_id.clone()))
-    }
-
-    /// Stages a commit for `version_id` even if no tracked state rows changed.
-    ///
-    /// Merge uses this to record graph ancestry for convergent merges where the
-    /// target already has the same final state as the source, but the source
-    /// head is not reachable from the target head.
-    pub(crate) fn stage_empty_commit(&self, version_id: String) -> Result<String, LixError> {
+    pub(crate) fn stage_selected_commit_change_refs(
+        &self,
+        branch_id: String,
+        selected_change_refs: impl IntoIterator<Item = StagedCommitChangeRef>,
+    ) -> Result<String, LixError> {
         let mut functions = self.functions.clone();
-        let mut guard = self.commit_members_by_version.lock().map_err(|_| {
+        let mut guard = self.commit_change_refs_by_branch.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged commit membership lock",
+                "failed to acquire transaction staged commit change refs lock",
             )
         })?;
-        let members = guard.entry(version_id).or_insert_with(|| {
-            StagedCommitMembers::new(
+        let change_refs = guard.entry(branch_id).or_insert_with(|| {
+            StagedCommitChangeRefs::new(
                 functions.uuid_v7(),
                 functions.uuid_v7(),
                 functions.timestamp(),
             )
         });
-        members.allow_empty();
-        Ok(members.commit_id.clone())
+        change_refs.allow_empty();
+        for change_ref in selected_change_refs {
+            change_refs.add_selected_change_ref(change_ref);
+        }
+        Ok(change_refs.commit_id.clone())
     }
 
     /// Builds the transaction-local read overlay from currently staged writes.
     pub(crate) fn staging_overlay(self: &Arc<Self>) -> Result<PreparedStateRowOverlay, LixError> {
-        let by_identity_guard = self.by_identity.lock().map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged identity index lock",
-            )
-        })?;
-        let slots = by_identity_guard
-            .iter()
-            .map(|(identity, slot)| (identity.clone(), *slot))
-            .collect();
         Ok(PreparedStateRowOverlay {
             staged_writes: Arc::clone(self),
-            slots,
         })
     }
 
@@ -458,16 +400,9 @@ impl TransactionWriteBuffer {
         let (mode, count) = match &write {
             PreparedTransactionWrite::Rows { mode, rows } => (Some(*mode), rows.len() as u64),
             PreparedTransactionWrite::RowsWithFileData { mode, count, .. } => (Some(*mode), *count),
-            PreparedTransactionWrite::AdoptedChanges { rows } => (None, rows.len() as u64),
         };
         let mut functions = self.functions.clone();
-        let (rows, adopted_rows, file_data_writes) = self.state_rows_from_stage_write(write)?;
-        for row in &rows {
-            validate_commit_membership_support(row)?;
-        }
-        for row in &adopted_rows {
-            validate_adopted_commit_membership_support(row)?;
-        }
+        let (rows, file_data_writes) = self.state_rows_from_stage_write(write);
         reject_duplicate_present_rows_in_batch(&rows)?;
         let mut guard = self.rows.lock().map_err(|_| {
             LixError::new(
@@ -475,24 +410,19 @@ impl TransactionWriteBuffer {
                 "failed to acquire transaction staged writes lock",
             )
         })?;
-        let mut adopted_guard = self.adopted_rows.lock().map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged adopted writes lock",
-            )
-        })?;
         let mut by_identity_guard = self.by_identity.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
                 "failed to acquire transaction staged identity index lock",
             )
         })?;
-        let mut commit_members_guard = self.commit_members_by_version.lock().map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged commit membership lock",
-            )
-        })?;
+        let mut commit_change_refs_guard =
+            self.commit_change_refs_by_branch.lock().map_err(|_| {
+                LixError::new(
+                    "LIX_ERROR_UNKNOWN",
+                    "failed to acquire transaction staged commit change refs lock",
+                )
+            })?;
         let mut insert_identities_guard = self.insert_identities.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
@@ -500,22 +430,25 @@ impl TransactionWriteBuffer {
             )
         })?;
         for mut row in rows {
+            if row.global && row.branch_id != GLOBAL_BRANCH_ID {
+                return Err(LixError::new(
+                    LixError::CODE_INVALID_PARAM,
+                    "global staged rows must use the global branch id",
+                ));
+            }
             let identity = PreparedStateRowIdentity::from(&row);
             if mode == Some(TransactionWriteMode::Insert)
                 && by_identity_guard.contains_key(&identity)
             {
                 return Err(duplicate_insert_identity_error(&row));
             }
-            if matches!(by_identity_guard.get(&identity), Some(RowSlot::Adopted(_))) {
-                return Err(conflicting_adopted_identity_error(&row));
-            }
             let existing_slot = by_identity_guard.remove(&identity);
             if let Some(RowSlot::State(index)) = existing_slot {
                 if let Some(previous) = guard.get_mut(index).and_then(Option::take) {
-                    remove_row_from_commit_members(&mut commit_members_guard, &previous);
+                    remove_row_from_commit_change_refs(&mut commit_change_refs_guard, &previous);
                 }
             }
-            add_row_to_commit_members(&mut commit_members_guard, &mut row, &mut functions);
+            add_row_to_commit_change_refs(&mut commit_change_refs_guard, &mut row, &mut functions);
             let identity = PreparedStateRowIdentity::from(&row);
             if mode == Some(TransactionWriteMode::Insert) {
                 insert_identities_guard.insert(identity.clone(), row.origin.clone());
@@ -533,17 +466,6 @@ impl TransactionWriteBuffer {
             };
             by_identity_guard.insert(identity, slot);
         }
-        for mut row in adopted_rows {
-            let identity = PreparedStateRowIdentity::from(&row);
-            if by_identity_guard.contains_key(&identity) {
-                return Err(conflicting_adopted_projection_error(&row));
-            }
-            add_adopted_row_to_commit_members(&mut commit_members_guard, &mut row, &mut functions);
-            let identity = PreparedStateRowIdentity::from(&row);
-            let index = adopted_guard.len();
-            adopted_guard.push(Some(row));
-            by_identity_guard.insert(identity, RowSlot::Adopted(index));
-        }
         if !file_data_writes.is_empty() {
             self.file_data_writes
                 .lock()
@@ -561,16 +483,8 @@ impl TransactionWriteBuffer {
     fn state_rows_from_stage_write(
         &self,
         write: PreparedTransactionWrite,
-    ) -> Result<
-        (
-            Vec<PreparedStateRow>,
-            Vec<PreparedAdoptedStateRow>,
-            Vec<TransactionFileData>,
-        ),
-        LixError,
-    > {
+    ) -> (Vec<PreparedStateRow>, Vec<TransactionFileData>) {
         let mut state_rows = Vec::new();
-        let mut adopted_rows = Vec::new();
         let mut file_data_writes = Vec::new();
         match write {
             PreparedTransactionWrite::Rows { rows, .. } => {
@@ -582,23 +496,19 @@ impl TransactionWriteBuffer {
                 state_rows.extend(rows);
                 file_data_writes.extend(file_data);
             }
-            PreparedTransactionWrite::AdoptedChanges { rows } => {
-                adopted_rows.extend(rows);
-            }
         }
-        Ok((state_rows, adopted_rows, file_data_writes))
+        (state_rows, file_data_writes)
     }
 }
 
 /// Read overlay derived from staged transaction writes.
+#[derive(Clone)]
 pub(crate) struct PreparedStateRowOverlay {
     staged_writes: Arc<TransactionWriteBuffer>,
-    slots: BTreeMap<PreparedStateRowIdentity, RowSlot>,
 }
 
 pub(crate) struct StagedScanParts {
     pub(crate) rows: Vec<MaterializedLiveStateRow>,
-    pub(crate) hidden_identities: BTreeSet<PreparedStateRowIdentity>,
 }
 
 impl PreparedStateRowOverlay {
@@ -608,7 +518,17 @@ impl PreparedStateRowOverlay {
         &self,
         request: &LiveStateScanRequest,
     ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
-        Ok(self.scan_parts(request)?.rows)
+        Ok(crate::live_state::resolve_visible_rows(
+            self.scan_parts(request)?.rows,
+            Vec::new(),
+            &crate::live_state::VisibilityRequest {
+                branch_scope: crate::live_state::VisibilityBranchScope::BranchIds {
+                    branch_ids: request.filter.branch_ids.clone(),
+                },
+                include_tombstones: request.filter.include_tombstones,
+                limit: None,
+            },
+        ))
     }
 
     /// Returns staged rows and base-row identities hidden by staged rows in one pass.
@@ -619,22 +539,28 @@ impl PreparedStateRowOverlay {
         &self,
         request: &LiveStateScanRequest,
     ) -> Result<StagedScanParts, LixError> {
+        if matches!(
+            request.filter.rows,
+            crate::live_state::LiveStateRowFilter::None
+        ) {
+            return Ok(StagedScanParts { rows: Vec::new() });
+        }
+
         let rows_guard = self.staged_writes.rows.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
                 "failed to acquire transaction staged writes lock",
             )
         })?;
-        let adopted_guard = self.staged_writes.adopted_rows.lock().map_err(|_| {
+        let by_identity_guard = self.staged_writes.by_identity.lock().map_err(|_| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
-                "failed to acquire transaction staged adopted writes lock",
+                "failed to acquire transaction staged identity index lock",
             )
         })?;
 
         let mut rows = Vec::new();
-        let mut hidden_identities = BTreeSet::new();
-        for (identity, slot) in &self.slots {
+        for slot in by_identity_guard.values() {
             match *slot {
                 RowSlot::State(index) => {
                     let Some(row) = rows_guard.get(index).and_then(Option::as_ref) else {
@@ -643,29 +569,11 @@ impl PreparedStateRowOverlay {
                     if !staged_row_identity_matches_scan(row, request) {
                         continue;
                     }
-                    hidden_identities.insert(identity.clone());
-                    if row.snapshot.is_some() || request.filter.include_tombstones {
-                        rows.push(MaterializedLiveStateRow::from(row));
-                    }
-                }
-                RowSlot::Adopted(index) => {
-                    let Some(row) = adopted_guard.get(index).and_then(Option::as_ref) else {
-                        continue;
-                    };
-                    if !adopted_row_identity_matches_scan(row, request) {
-                        continue;
-                    }
-                    hidden_identities.insert(identity.clone());
-                    if row.snapshot.is_some() || request.filter.include_tombstones {
-                        rows.push(MaterializedLiveStateRow::from(row));
-                    }
+                    rows.push(MaterializedLiveStateRow::from(row));
                 }
             }
         }
-        Ok(StagedScanParts {
-            rows,
-            hidden_identities,
-        })
+        Ok(StagedScanParts { rows })
     }
 
     /// Returns a staged exact-row answer, if this transaction has one.
@@ -688,44 +596,26 @@ impl PreparedStateRowOverlay {
                 StagedExactRow::Row(MaterializedLiveStateRow::from(&row))
             });
         }
-        self.load_adopted_slot(&identity).map(|row| {
-            if row.snapshot.is_none() {
-                StagedExactRow::Tombstone
-            } else {
-                StagedExactRow::Row(MaterializedLiveStateRow::from(&row))
-            }
-        })
+        None
     }
 
     #[cfg(test)]
     fn load_state_slot(&self, identity: &PreparedStateRowIdentity) -> Option<PreparedStateRow> {
-        let Some(RowSlot::State(index)) = self.slots.get(identity).copied() else {
+        let rows_guard = self.staged_writes.rows.lock().ok()?;
+        let by_identity_guard = self.staged_writes.by_identity.lock().ok()?;
+        let Some(RowSlot::State(index)) = by_identity_guard.get(identity).copied() else {
             return None;
         };
-        self.staged_writes
-            .rows
-            .lock()
-            .ok()?
-            .get(index)?
-            .as_ref()
-            .cloned()
+        rows_guard.get(index)?.as_ref().cloned()
     }
+}
 
-    #[cfg(test)]
-    fn load_adopted_slot(
+impl crate::live_state::StagedLiveStateRows for PreparedStateRowOverlay {
+    fn staged_rows(
         &self,
-        identity: &PreparedStateRowIdentity,
-    ) -> Option<PreparedAdoptedStateRow> {
-        let Some(RowSlot::Adopted(index)) = self.slots.get(identity).copied() else {
-            return None;
-        };
-        self.staged_writes
-            .adopted_rows
-            .lock()
-            .ok()?
-            .get(index)?
-            .as_ref()
-            .cloned()
+        request: &LiveStateScanRequest,
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
+        Ok(self.scan_parts(request)?.rows)
     }
 }
 
@@ -739,9 +629,9 @@ pub(crate) enum StagedExactRow {
 pub(crate) struct PreparedStateRowIdentity {
     untracked: bool,
     schema_key: String,
-    entity_id: crate::entity_identity::EntityIdentity,
+    entity_pk: crate::entity_pk::EntityPk,
     file_id: Option<String>,
-    version_id: String,
+    branch_id: String,
 }
 
 impl PreparedStateRowIdentity {
@@ -749,9 +639,9 @@ impl PreparedStateRowIdentity {
         Self {
             untracked: row.untracked,
             schema_key: row.schema_key.clone(),
-            entity_id: row.entity_id.clone(),
+            entity_pk: row.entity_pk.clone(),
             file_id: row.file_id.clone(),
-            version_id: row.version_id.clone(),
+            branch_id: row.branch_id.clone(),
         }
     }
 
@@ -766,9 +656,9 @@ impl PreparedStateRowIdentity {
         Some(Self {
             untracked,
             schema_key: request.schema_key.clone(),
-            entity_id: request.entity_id.clone(),
+            entity_pk: request.entity_pk.clone(),
             file_id,
-            version_id: request.version_id.clone(),
+            branch_id: request.branch_id.clone(),
         })
     }
 
@@ -776,16 +666,12 @@ impl PreparedStateRowIdentity {
         &self.schema_key
     }
 
-    pub(crate) fn entity_id(&self) -> &crate::entity_identity::EntityIdentity {
-        &self.entity_id
+    pub(crate) fn entity_pk(&self) -> &crate::entity_pk::EntityPk {
+        &self.entity_pk
     }
 
     pub(crate) fn domain(&self) -> Domain {
-        Domain::exact_file(
-            self.version_id.clone(),
-            self.untracked,
-            self.file_id.clone(),
-        )
+        Domain::exact_file(self.branch_id.clone(), self.untracked, self.file_id.clone())
     }
 }
 
@@ -795,52 +681,18 @@ impl From<&PreparedStateRow> for PreparedStateRowIdentity {
     }
 }
 
-impl From<&PreparedAdoptedStateRow> for PreparedStateRowIdentity {
-    fn from(row: &PreparedAdoptedStateRow) -> Self {
-        Self {
-            untracked: false,
-            schema_key: row.schema_key.clone(),
-            entity_id: row.entity_id.clone(),
-            file_id: row.file_id.clone(),
-            version_id: row.version_id.clone(),
-        }
-    }
-}
-
 impl From<&MaterializedLiveStateRow> for PreparedStateRowIdentity {
     fn from(row: &MaterializedLiveStateRow) -> Self {
         Self {
             untracked: row.untracked,
             schema_key: row.schema_key.clone(),
-            entity_id: row.entity_id.clone(),
+            entity_pk: row.entity_pk.clone(),
             file_id: row.file_id.clone(),
-            version_id: row.version_id.clone(),
+            branch_id: row.branch_id.clone(),
         }
     }
 }
 
-fn validate_commit_membership_support(row: &PreparedStateRow) -> Result<(), LixError> {
-    if row.global && row.version_id != GLOBAL_VERSION_ID {
-        return Err(LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            "engine global staged rows must use the global version id",
-        ));
-    }
-    Ok(())
-}
-
-fn validate_adopted_commit_membership_support(
-    row: &PreparedAdoptedStateRow,
-) -> Result<(), LixError> {
-    if row.global && row.version_id != GLOBAL_VERSION_ID {
-        return Err(LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            "engine global adopted rows must use the global version id",
-        ));
-    }
-    Ok(())
-}
-
 fn reject_duplicate_present_rows_in_batch(rows: &[PreparedStateRow]) -> Result<(), LixError> {
     let mut pending_present_rows = BTreeMap::<PreparedStateRowIdentity, &PreparedStateRow>::new();
     for row in rows {
@@ -863,13 +715,13 @@ fn duplicate_staged_present_row_error(
     let message = logical_primary_key_violation_message(row.origin.as_ref())
         .unwrap_or_else(|| {
             format!(
-                "primary-key constraint violation on schema '{}': duplicate staged rows for entity_id '{}' in version '{}'",
+                "primary-key constraint violation on schema '{}': duplicate staged rows for entity_pk '{}' in branch '{}'",
                 row.schema_key,
                 previous
-                    .entity_id
+                    .entity_pk
                     .as_json_array_text()
-                    .unwrap_or_else(|_| "<invalid entity_id>".to_string()),
-                row.version_id
+                    .unwrap_or_else(|_| "<invalid entity_pk>".to_string()),
+                row.branch_id
             )
         });
     LixError::new(LixError::CODE_UNIQUE, message)
@@ -877,22 +729,22 @@ fn duplicate_staged_present_row_error(
 
 pub(crate) fn duplicate_insert_identity_message(
     schema_key: &str,
-    entity_id: &crate::entity_identity::EntityIdentity,
-    version_id: Option<&str>,
+    entity_pk: &crate::entity_pk::EntityPk,
+    branch_id: Option<&str>,
     origin: Option<&TransactionWriteOrigin>,
 ) -> String {
     if let Some(message) = logical_primary_key_violation_message(origin) {
         return message;
     }
-    let entity_id = entity_id
+    let entity_pk = entity_pk
         .as_json_array_text()
-        .unwrap_or_else(|_| "<invalid entity_id>".to_string());
-    match version_id {
-        Some(version_id) => format!(
-            "primary-key constraint violation on schema '{schema_key}': INSERT would duplicate entity_id '{entity_id}' in version '{version_id}'"
+        .unwrap_or_else(|_| "<invalid entity_pk>".to_string());
+    match branch_id {
+        Some(branch_id) => format!(
+            "primary-key constraint violation on schema '{schema_key}': INSERT would duplicate entity_pk '{entity_pk}' in branch '{branch_id}'"
         ),
         None => format!(
-            "primary-key constraint violation on schema '{schema_key}': INSERT would duplicate entity_id '{entity_id}'"
+            "primary-key constraint violation on schema '{schema_key}': INSERT would duplicate entity_pk '{entity_pk}'"
         ),
     }
 }
@@ -900,8 +752,8 @@ pub(crate) fn duplicate_insert_identity_message(
 fn duplicate_insert_identity_error(row: &PreparedStateRow) -> LixError {
     let message = duplicate_insert_identity_message(
         &row.schema_key,
-        &row.entity_id,
-        Some(&row.version_id),
+        &row.entity_pk,
+        Some(&row.branch_id),
         row.origin.as_ref(),
     );
     LixError::new(LixError::CODE_UNIQUE, message)
@@ -939,36 +791,8 @@ fn format_logical_primary_key(primary_key: &LogicalPrimaryKey) -> String {
         .join(", ")
 }
 
-fn conflicting_adopted_identity_error(row: &PreparedStateRow) -> LixError {
-    LixError::new(
-        LixError::CODE_UNIQUE,
-        format!(
-            "transaction cannot stage a new row and an adopted projection for schema '{}' entity_id '{}' in version '{}'",
-            row.schema_key,
-            row.entity_id
-                .as_json_array_text()
-                .unwrap_or_else(|_| "<invalid entity_id>".to_string()),
-            row.version_id
-        ),
-    )
-}
-
-fn conflicting_adopted_projection_error(row: &PreparedAdoptedStateRow) -> LixError {
-    LixError::new(
-        LixError::CODE_UNIQUE,
-        format!(
-            "transaction cannot stage duplicate adopted projections for schema '{}' entity_id '{}' in version '{}'",
-            row.schema_key,
-            row.entity_id
-                .as_json_array_text()
-                .unwrap_or_else(|_| "<invalid entity_id>".to_string()),
-            row.version_id
-        ),
-    )
-}
-
-fn add_row_to_commit_members(
-    members_by_version: &mut BTreeMap<String, StagedCommitMembers>,
+fn add_row_to_commit_change_refs(
+    change_refs_by_branch: &mut BTreeMap<String, StagedCommitChangeRefs>,
     row: &mut PreparedStateRow,
     functions: &mut dyn FunctionProvider,
 ) {
@@ -978,81 +802,39 @@ fn add_row_to_commit_members(
     let change_id = row
         .change_id
         .clone()
-        .expect("tracked staged rows must carry change_id for commit membership");
-    let members = members_by_version
-        .entry(row.version_id.clone())
-        .or_insert_with(|| {
-            StagedCommitMembers::new(
-                functions.uuid_v7(),
-                functions.uuid_v7(),
-                functions.timestamp(),
-            )
-        });
-    row.commit_id = Some(members.commit_id.clone());
-    members.add_change_id(change_id);
-}
-
-fn add_adopted_row_to_commit_members(
-    members_by_version: &mut BTreeMap<String, StagedCommitMembers>,
-    row: &mut PreparedAdoptedStateRow,
-    functions: &mut dyn FunctionProvider,
-) {
-    let members = members_by_version
-        .entry(row.version_id.clone())
+        .expect("tracked staged rows must carry change_id for commit change refs");
+    let change_refs = change_refs_by_branch
+        .entry(row.branch_id.clone())
         .or_insert_with(|| {
-            StagedCommitMembers::new(
+            StagedCommitChangeRefs::new(
                 functions.uuid_v7(),
                 functions.uuid_v7(),
                 functions.timestamp(),
             )
         });
-    row.commit_id = members.commit_id.clone();
-    members.add_change_id(row.change_id.clone());
+    row.commit_id = Some(change_refs.commit_id.clone());
+    change_refs.add_change_id(change_id);
 }
 
-fn remove_row_from_commit_members(
-    members_by_version: &mut BTreeMap<String, StagedCommitMembers>,
+fn remove_row_from_commit_change_refs(
+    change_refs_by_branch: &mut BTreeMap<String, StagedCommitChangeRefs>,
     row: &PreparedStateRow,
 ) {
     if row.untracked {
         return;
     }
-    let Some(members) = members_by_version.get_mut(&row.version_id) else {
+    let Some(change_refs) = change_refs_by_branch.get_mut(&row.branch_id) else {
         return;
     };
     let Some(change_id) = row.change_id.as_deref() else {
         return;
     };
-    members.remove_change_id(change_id);
-    if members.is_empty() {
-        members_by_version.remove(&row.version_id);
+    change_refs.remove_change_id(change_id);
+    if change_refs.is_empty() {
+        change_refs_by_branch.remove(&row.branch_id);
     }
 }
 
-fn adopted_row_identity_matches_scan(
-    row: &PreparedAdoptedStateRow,
-    request: &LiveStateScanRequest,
-) -> bool {
-    if !request.filter.schema_keys.is_empty()
-        && !request.filter.schema_keys.contains(&row.schema_key)
-    {
-        return false;
-    }
-    if !request.filter.entity_ids.is_empty() && !request.filter.entity_ids.contains(&row.entity_id)
-    {
-        return false;
-    }
-    if !request.filter.version_ids.is_empty()
-        && !request.filter.version_ids.contains(&row.version_id)
-    {
-        return false;
-    }
-    if request.filter.untracked == Some(true) {
-        return false;
-    }
-    nullable_key_matches_filters(&row.file_id, &request.filter.file_ids)
-}
-
 fn staged_row_identity_matches_scan(
     row: &PreparedStateRow,
     request: &LiveStateScanRequest,
@@ -1062,13 +844,11 @@ fn staged_row_identity_matches_scan(
     {
         return false;
     }
-    if !request.filter.entity_ids.is_empty() && !request.filter.entity_ids.contains(&row.entity_id)
+    if !request.filter.entity_pks.is_empty() && !request.filter.entity_pks.contains(&row.entity_pk)
     {
         return false;
     }
-    if !request.filter.version_ids.is_empty()
-        && !request.filter.version_ids.contains(&row.version_id)
-    {
+    if !staged_branch_matches_scan(&row.branch_id, request) {
         return false;
     }
     if request
@@ -1091,6 +871,21 @@ fn nullable_key_matches_filters(
             .any(|filter| nullable_key_matches_filter(value, filter))
 }
 
+fn staged_branch_matches_scan(branch_id: &str, request: &LiveStateScanRequest) -> bool {
+    request.filter.branch_ids.is_empty()
+        || request
+            .filter
+            .branch_ids
+            .iter()
+            .any(|requested| requested == branch_id)
+        || (branch_id == GLOBAL_BRANCH_ID
+            && request
+                .filter
+                .branch_ids
+                .iter()
+                .any(|requested| requested != GLOBAL_BRANCH_ID))
+}
+
 fn nullable_key_matches_filter(value: &Option<String>, filter: &NullableKeyFilter<String>) -> bool {
     match filter {
         NullableKeyFilter::Any => true,
@@ -1128,8 +923,8 @@ mod tests {
         let row = overlay
             .load_exact(&LiveStateRowRequest {
                 schema_key: "lix_key_value".to_string(),
-                version_id: "global".to_string(),
-                entity_id: crate::entity_identity::EntityIdentity::single("sql2-duplicate-key"),
+                branch_id: "global".to_string(),
+                entity_pk: crate::entity_pk::EntityPk::single("sql2-duplicate-key"),
                 file_id: NullableKeyFilter::Null,
             })
             .expect("staged row should be visible");
@@ -1268,7 +1063,7 @@ mod tests {
 
         assert_eq!(drained.state_rows.len(), 2);
         assert!(drained.state_rows.iter().any(|row| {
-            row.entity_id == crate::entity_identity::EntityIdentity::single("sql2-key-a")
+            row.entity_pk == crate::entity_pk::EntityPk::single("sql2-key-a")
                 && row
                     .snapshot
                     .as_ref()
@@ -1276,7 +1071,7 @@ mod tests {
                     == Some("{\"key\":\"sql2-key-a\",\"value\":\"second\"}")
         }));
         assert!(drained.state_rows.iter().any(|row| {
-            row.entity_id == crate::entity_identity::EntityIdentity::single("sql2-key-b")
+            row.entity_pk == crate::entity_pk::EntityPk::single("sql2-key-b")
                 && row
                     .snapshot
                     .as_ref()
@@ -1295,7 +1090,7 @@ mod tests {
                 rows: vec![state_row("file-readme", "descriptor")],
                 file_data: vec![TransactionFileData {
                     file_id: "file-readme".to_string(),
-                    version_id: "global".to_string(),
+                    branch_id: "global".to_string(),
                     untracked: true,
                     data: b"hello".to_vec(),
                 }],
@@ -1323,12 +1118,12 @@ mod tests {
             .expect("tracked global row should stage");
 
         let drained = staged_writes.drain().expect("drain should succeed");
-        let members = drained
-            .commit_members_by_version
+        let change_refs = drained
+            .commit_change_refs_by_branch
             .get("global")
-            .expect("global commit members should exist");
+            .expect("global commit change_refs should exist");
         assert_eq!(
-            members.change_ids.iter().cloned().collect::<Vec<_>>(),
+            change_refs.change_ids.iter().cloned().collect::<Vec<_>>(),
             vec!["test-change-id".to_string()]
         );
     }
@@ -1345,7 +1140,7 @@ mod tests {
             .expect("untracked row should stage");
 
         let drained = staged_writes.drain().expect("drain should succeed");
-        assert!(drained.commit_members_by_version.is_empty());
+        assert!(drained.commit_change_refs_by_branch.is_empty());
     }
 
     #[tokio::test]
@@ -1370,12 +1165,12 @@ mod tests {
             .expect("tracked overwrite should stage");
 
         let drained = staged_writes.drain().expect("drain should succeed");
-        let members = drained
-            .commit_members_by_version
+        let change_refs = drained
+            .commit_change_refs_by_branch
             .get("global")
-            .expect("global commit members should exist");
+            .expect("global commit change_refs should exist");
         assert_eq!(
-            members.change_ids.iter().cloned().collect::<Vec<_>>(),
+            change_refs.change_ids.iter().cloned().collect::<Vec<_>>(),
             vec!["change-second".to_string()]
         );
     }
@@ -1407,12 +1202,12 @@ mod tests {
             .state_rows
             .iter()
             .any(|row| { row.change_id.as_deref() == Some("change-untracked") && row.untracked }));
-        let members = drained
-            .commit_members_by_version
+        let change_refs = drained
+            .commit_change_refs_by_branch
             .get("global")
             .expect("tracked commit member should remain in tracked domain");
         assert_eq!(
-            members.change_ids.iter().cloned().collect::<Vec<_>>(),
+            change_refs.change_ids.iter().cloned().collect::<Vec<_>>(),
             vec!["change-tracked".to_string()]
         );
     }
@@ -1455,41 +1250,41 @@ mod tests {
         let drained = staged_writes.drain().expect("drain should succeed");
         assert_eq!(drained.state_rows.len(), 2);
         assert!(drained.state_rows.iter().any(|row| {
-            row.entity_id == crate::entity_identity::EntityIdentity::single("shared-domain-key")
+            row.entity_pk == crate::entity_pk::EntityPk::single("shared-domain-key")
                 && !row.untracked
         }));
         assert!(drained.state_rows.iter().any(|row| {
-            row.entity_id == crate::entity_identity::EntityIdentity::single("shared-domain-key")
+            row.entity_pk == crate::entity_pk::EntityPk::single("shared-domain-key")
                 && row.untracked
         }));
     }
 
     #[tokio::test]
-    async fn staged_writes_track_active_version_members_separately() {
+    async fn staged_writes_track_active_branch_members_separately() {
         let staged_writes = test_staged_writes();
 
         staged_writes
             .stage_write(PreparedTransactionWrite::Rows {
                 mode: TransactionWriteMode::Replace,
-                rows: vec![state_row("active-version-key", "value")
+                rows: vec![state_row("active-branch-key", "value")
                     .with_tracked()
-                    .with_version("version-a")],
+                    .with_branch("branch-a")],
             })
-            .expect("active-version tracked staging should accumulate members");
+            .expect("active-branch tracked staging should accumulate change_refs");
 
         let drained = staged_writes.drain().expect("drain should succeed");
-        let members = drained
-            .commit_members_by_version
-            .get("version-a")
-            .expect("active-version commit members should exist");
+        let change_refs = drained
+            .commit_change_refs_by_branch
+            .get("branch-a")
+            .expect("active-branch commit change_refs should exist");
         assert_eq!(
-            members.change_ids.iter().cloned().collect::<Vec<_>>(),
+            change_refs.change_ids.iter().cloned().collect::<Vec<_>>(),
             vec!["test-change-id".to_string()]
         );
     }
 
     #[tokio::test]
-    async fn staged_writes_reject_global_rows_with_non_global_version_id() {
+    async fn staged_writes_reject_global_rows_with_non_global_branch_id() {
         let staged_writes = test_staged_writes();
 
         let error = staged_writes
@@ -1497,15 +1292,15 @@ mod tests {
                 mode: TransactionWriteMode::Replace,
                 rows: vec![{
                     let mut row = state_row("invalid-global-key", "value");
-                    row.version_id = "version-a".to_string();
+                    row.branch_id = "branch-a".to_string();
                     row
                 }],
             })
-            .expect_err("global row with non-global version should fail");
+            .expect_err("global row with non-global branch should fail");
 
         assert!(error
             .message
-            .contains("global staged rows must use the global version id"));
+            .contains("global staged rows must use the global branch id"));
     }
 
     #[tokio::test]
@@ -1523,7 +1318,7 @@ mod tests {
                 mode: TransactionWriteMode::Replace,
                 rows: vec![
                     state_row("shared-entity", "base"),
-                    state_row("shared-entity", "other-version").with_version("version-b"),
+                    state_row("shared-entity", "other-branch").with_branch("branch-b"),
                     state_row("shared-entity", "other-schema").with_schema("other_schema"),
                     state_row("shared-entity", "other-file").with_file_id("file-a"),
                     state_row("shared-entity", "tracked").with_tracked(),
@@ -1537,9 +1332,7 @@ mod tests {
         let rows = overlay
             .scan(&LiveStateScanRequest {
                 filter: LiveStateFilter {
-                    entity_ids: vec![crate::entity_identity::EntityIdentity::single(
-                        "shared-entity",
-                    )],
+                    entity_pks: vec![crate::entity_pk::EntityPk::single("shared-entity")],
                     include_tombstones: true,
                     ..LiveStateFilter::default()
                 },
@@ -1547,20 +1340,21 @@ mod tests {
             })
             .expect("overlay scan should succeed");
 
-        assert_eq!(rows.len(), 5);
+        assert_eq!(rows.len(), 4);
         assert_eq!(
             rows.iter()
-                .filter(|row| row.entity_id
-                    == crate::entity_identity::EntityIdentity::single("shared-entity")
-                    && row.version_id == "global"
-                    && row.schema_key == "lix_key_value"
-                    && row.file_id.is_none())
+                .filter(
+                    |row| row.entity_pk == crate::entity_pk::EntityPk::single("shared-entity")
+                        && row.branch_id == "global"
+                        && row.schema_key == "lix_key_value"
+                        && row.file_id.is_none()
+                )
                 .count(),
-            2
+            1
         );
         assert!(rows.iter().any(|row| {
             row.snapshot_content.as_deref()
-                == Some("{\"key\":\"shared-entity\",\"value\":\"tracked\"}")
+                == Some("{\"key\":\"shared-entity\",\"value\":\"base\"}")
         }));
     }
 
@@ -1576,13 +1370,13 @@ mod tests {
             .expect("staging rows should succeed");
 
         let drained = staged_writes.drain().expect("drain should succeed");
-        let members = drained
-            .commit_members_by_version
+        let change_refs = drained
+            .commit_change_refs_by_branch
             .get("global")
-            .expect("global commit members should exist");
-        assert_eq!(members.commit_id, "test-uuid-1");
-        assert_eq!(members.commit_change_id, "test-uuid-2");
-        assert_eq!(members.created_at, "test-timestamp-1");
+            .expect("global commit change_refs should exist");
+        assert_eq!(change_refs.commit_id, "test-uuid-1");
+        assert_eq!(change_refs.commit_change_id, "test-uuid-2");
+        assert_eq!(change_refs.created_at, "test-timestamp-1");
     }
 
     #[tokio::test]
@@ -1604,9 +1398,9 @@ mod tests {
         );
         assert_eq!(
             drained
-                .commit_members_by_version
+                .commit_change_refs_by_branch
                 .get("global")
-                .expect("global commit members should exist")
+                .expect("global commit change_refs should exist")
                 .commit_id,
             "test-uuid-1"
         );
@@ -1645,7 +1439,7 @@ mod tests {
         PreparedStateRow {
             schema_plan_id: SchemaPlanId::for_test(0),
             facts: crate::transaction::types::PreparedRowFacts::default(),
-            entity_id: crate::entity_identity::EntityIdentity::single(key),
+            entity_pk: crate::entity_pk::EntityPk::single(key),
             schema_key: "lix_key_value".to_string(),
             file_id: None,
             snapshot: Some(snapshot),
@@ -1657,7 +1451,7 @@ mod tests {
             change_id: None,
             commit_id: None,
             untracked: true,
-            version_id: "global".to_string(),
+            branch_id: "global".to_string(),
         }
     }
 
@@ -1670,8 +1464,8 @@ mod tests {
     fn exact_request_for_key(key: &str) -> LiveStateRowRequest {
         LiveStateRowRequest {
             schema_key: "lix_key_value".to_string(),
-            version_id: "global".to_string(),
-            entity_id: crate::entity_identity::EntityIdentity::single(key),
+            branch_id: "global".to_string(),
+            entity_pk: crate::entity_pk::EntityPk::single(key),
             file_id: NullableKeyFilter::Null,
         }
     }
@@ -1680,8 +1474,8 @@ mod tests {
         LiveStateScanRequest {
             filter: LiveStateFilter {
                 schema_keys: vec!["lix_key_value".to_string()],
-                entity_ids: vec![crate::entity_identity::EntityIdentity::single(key)],
-                version_ids: vec!["global".to_string()],
+                entity_pks: vec![crate::entity_pk::EntityPk::single(key)],
+                branch_ids: vec!["global".to_string()],
                 file_ids: vec![NullableKeyFilter::Null],
                 include_tombstones,
                 ..LiveStateFilter::default()
@@ -1694,7 +1488,7 @@ mod tests {
         fn with_schema(self, schema_key: &str) -> Self;
         fn with_file_id(self, file_id: &str) -> Self;
         fn with_tracked(self) -> Self;
-        fn with_version(self, version_id: &str) -> Self;
+        fn with_branch(self, branch_id: &str) -> Self;
         fn with_change_id(self, change_id: &str) -> Self;
     }
 
@@ -1717,9 +1511,9 @@ mod tests {
             self
         }
 
-        fn with_version(mut self, version_id: &str) -> Self {
-            self.version_id = version_id.to_string();
-            self.global = version_id == GLOBAL_VERSION_ID;
+        fn with_branch(mut self, branch_id: &str) -> Self {
+            self.branch_id = branch_id.to_string();
+            self.global = branch_id == GLOBAL_BRANCH_ID;
             self
         }