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

package/dist-engine-src/src/sql2/filesystem_planner.rs

@@ -9,9 +9,10 @@ use crate::common::{
     directory_ancestor_paths, directory_name_from_path, normalize_directory_path,
     parent_directory_path, stable_content_fingerprint_hex, ParsedFilePath,
 };
-use crate::entity_identity::EntityIdentity;
+use crate::entity_pk::EntityPk;
 use crate::live_state::MaterializedLiveStateRow;
 use crate::LixError;
+use crate::GLOBAL_BRANCH_ID;
 
 use super::filesystem_visibility::VisibleFilesystem;
 use crate::transaction::types::{TransactionFileData, TransactionJson, TransactionWriteRow};
@@ -44,7 +45,7 @@ pub(crate) struct FilesystemDeletePlan {
 /// Common state-row lane fields shared by filesystem descriptor/blob rows.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct FilesystemRowContext {
-    pub(crate) version_id: String,
+    pub(crate) branch_id: String,
     pub(crate) global: bool,
     pub(crate) untracked: bool,
     pub(crate) file_id: Option<String>,
@@ -52,9 +53,9 @@ pub(crate) struct FilesystemRowContext {
 }
 
 impl FilesystemRowContext {
-    pub(crate) fn active_version(version_id: impl Into<String>) -> Self {
+    pub(crate) fn active_branch(branch_id: impl Into<String>) -> Self {
         Self {
-            version_id: version_id.into(),
+            branch_id: branch_id.into(),
             global: false,
             untracked: false,
             file_id: None,
@@ -478,8 +479,8 @@ pub(crate) fn blob_ref_row(input: BlobRefRowInput) -> Result<TransactionWriteRow
         LixError::new(
             "LIX_ERROR_UNKNOWN",
             format!(
-                "binary blob size exceeds supported range for file '{}' version '{}'",
-                input.file_id, input.context.version_id
+                "binary blob size exceeds supported range for file '{}' branch '{}'",
+                input.file_id, input.context.branch_id
             ),
         )
     })?;
@@ -546,7 +547,7 @@ pub(crate) fn plan_file_path_write(
         })?);
         file_data.push(TransactionFileData {
             file_id,
-            version_id: input.context.version_id,
+            branch_id: input.context.branch_id,
             untracked: input.context.untracked,
             data,
         });
@@ -675,8 +676,13 @@ pub(crate) fn directory_path_resolvers_from_state_rows(
         let Some(snapshot_content) = row.snapshot_content.as_deref() else {
             continue;
         };
+        let storage_branch_id = if row.global {
+            GLOBAL_BRANCH_ID
+        } else {
+            row.branch_id.as_str()
+        };
         let resolver_key = filesystem_storage_scope_key(
-            &row.version_id,
+            storage_branch_id,
             row.global,
             row.untracked,
             row.file_id.as_deref(),
@@ -718,7 +724,7 @@ pub(crate) fn directory_path_resolvers_from_state_rows(
     }
 
     let mut resolvers = BTreeMap::new();
-    for (version_id, records) in directory_rows {
+    for (branch_id, records) in directory_rows {
         let mut paths = BTreeMap::<String, String>::new();
         for directory_id in records.keys() {
             resolve_directory_seed_path(directory_id, &records, &mut paths, &mut BTreeSet::new())?;
@@ -727,15 +733,15 @@ pub(crate) fn directory_path_resolvers_from_state_rows(
             .into_iter()
             .map(|(directory_id, path)| (path, directory_id))
             .collect::<Vec<_>>();
-        let files = file_rows.remove(&version_id).unwrap_or_default();
+        let files = file_rows.remove(&branch_id).unwrap_or_default();
         resolvers.insert(
-            version_id,
+            branch_id,
             DirectoryPathResolver::from_existing_filesystem(seeds, files)?,
         );
     }
-    for (version_id, files) in file_rows {
+    for (branch_id, files) in file_rows {
         resolvers.insert(
-            version_id,
+            branch_id,
             DirectoryPathResolver::from_existing_filesystem(std::iter::empty(), files)?,
         );
     }
@@ -743,13 +749,13 @@ pub(crate) fn directory_path_resolvers_from_state_rows(
 }
 
 pub(crate) fn filesystem_storage_scope_key(
-    version_id: &str,
+    branch_id: &str,
     global: bool,
     untracked: bool,
     file_id: Option<&str>,
 ) -> String {
     format!(
-        "version={version_id}\0global={global}\0untracked={untracked}\0file_id={}",
+        "branch={branch_id}\0global={global}\0untracked={untracked}\0file_id={}",
         file_id.unwrap_or("<null>")
     )
 }
@@ -804,23 +810,23 @@ fn directory_parent_cycle_error(directory_id: &str) -> LixError {
 }
 
 fn state_row(
-    entity_id: String,
+    entity_pk: String,
     schema_key: &str,
     snapshot: Option<JsonValue>,
     context: FilesystemRowContext,
 ) -> TransactionWriteRow {
-    partial_state_row(Some(entity_id), schema_key, snapshot, context)
+    partial_state_row(Some(entity_pk), schema_key, snapshot, context)
 }
 
 fn partial_state_row(
-    entity_id: Option<String>,
+    entity_pk: Option<String>,
     schema_key: &str,
     snapshot: Option<JsonValue>,
     context: FilesystemRowContext,
 ) -> TransactionWriteRow {
     let snapshot = snapshot.map(TransactionJson::from_value_unchecked);
     TransactionWriteRow {
-        entity_id: entity_id.map(EntityIdentity::single),
+        entity_pk: entity_pk.map(EntityPk::single),
         schema_key: schema_key.to_string(),
         file_id: context.file_id,
         snapshot,
@@ -832,16 +838,16 @@ fn partial_state_row(
         change_id: None,
         commit_id: None,
         untracked: context.untracked,
-        version_id: context.version_id,
+        branch_id: context.branch_id,
     }
 }
 
 fn tombstone_row(
-    entity_id: String,
+    entity_pk: String,
     schema_key: &str,
     context: FilesystemRowContext,
 ) -> TransactionWriteRow {
-    state_row(entity_id, schema_key, None, context)
+    state_row(entity_pk, schema_key, None, context)
 }
 
 fn collect_recursive_directory_delete(
@@ -900,7 +906,7 @@ mod tests {
     use crate::sql2::filesystem_visibility::{
         VisibleBlobRef, VisibleDirectory, VisibleFile, VisibleFilesystem,
     };
-    use crate::{entity_identity::EntityIdentity, live_state::MaterializedLiveStateRow};
+    use crate::{entity_pk::EntityPk, live_state::MaterializedLiveStateRow};
 
     fn test_id_generator(ids: &'static [&'static str]) -> impl FnMut() -> String {
         let mut ids = ids.iter();
@@ -914,15 +920,15 @@ mod tests {
             parent_id: None,
             name: "docs".to_string(),
             hidden: false,
-            context: FilesystemRowContext::active_version("version-a"),
+            context: FilesystemRowContext::active_branch("branch-a"),
         });
 
         assert_eq!(
-            row.entity_id.as_ref(),
-            Some(&crate::entity_identity::EntityIdentity::single("dir-docs"))
+            row.entity_pk.as_ref(),
+            Some(&crate::entity_pk::EntityPk::single("dir-docs"))
         );
         assert_eq!(row.schema_key, "lix_directory_descriptor");
-        assert_eq!(row.version_id, "version-a");
+        assert_eq!(row.branch_id, "branch-a");
         let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "dir-docs");
         assert_eq!(snapshot["parent_id"], JsonValue::Null);
@@ -937,14 +943,12 @@ mod tests {
             directory_id: Some("dir-docs".to_string()),
             name: "readme.md".to_string(),
             hidden: false,
-            context: FilesystemRowContext::active_version("version-a"),
+            context: FilesystemRowContext::active_branch("branch-a"),
         });
 
         assert_eq!(
-            row.entity_id.as_ref(),
-            Some(&crate::entity_identity::EntityIdentity::single(
-                "file-readme"
-            ))
+            row.entity_pk.as_ref(),
+            Some(&crate::entity_pk::EntityPk::single("file-readme"))
         );
         assert_eq!(row.schema_key, "lix_file_descriptor");
         let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
@@ -957,15 +961,13 @@ mod tests {
         let row = blob_ref_row(BlobRefRowInput {
             file_id: "file-readme".to_string(),
             data: b"Hello".to_vec(),
-            context: FilesystemRowContext::active_version("version-a"),
+            context: FilesystemRowContext::active_branch("branch-a"),
         })
         .expect("blob ref row should build");
 
         assert_eq!(
-            row.entity_id.as_ref(),
-            Some(&crate::entity_identity::EntityIdentity::single(
-                "file-readme"
-            ))
+            row.entity_pk.as_ref(),
+            Some(&crate::entity_pk::EntityPk::single("file-readme"))
         );
         assert_eq!(row.file_id.as_deref(), Some("file-readme"));
         assert_eq!(row.schema_key, "lix_binary_blob_ref");
@@ -986,7 +988,7 @@ mod tests {
         let rows = resolver
             .ensure_directory_path(
                 "/docs/nested/",
-                FilesystemRowContext::active_version("version-a"),
+                FilesystemRowContext::active_branch("branch-a"),
                 false,
                 &mut test_id_generator(&["dir-generated-nested"]),
             )
@@ -1013,7 +1015,7 @@ mod tests {
         let docs_rows = resolver
             .ensure_directory_path(
                 "/docs/",
-                FilesystemRowContext::active_version("version-a"),
+                FilesystemRowContext::active_branch("branch-a"),
                 false,
                 &mut test_id_generator(&["dir-generated-docs"]),
             )
@@ -1023,7 +1025,7 @@ mod tests {
         let nested_rows = resolver
             .ensure_directory_path(
                 "/docs/nested/",
-                FilesystemRowContext::active_version("version-a"),
+                FilesystemRowContext::active_branch("branch-a"),
                 false,
                 &mut test_id_generator(&["dir-generated-nested"]),
             )
@@ -1045,7 +1047,7 @@ mod tests {
             .ensure_directory_path_with_leaf_id(
                 "/docs/nested/",
                 Some("dir-nested".to_string()),
-                FilesystemRowContext::active_version("version-a"),
+                FilesystemRowContext::active_branch("branch-a"),
                 false,
                 &mut test_id_generator(&["dir-generated-docs"]),
             )
@@ -1075,7 +1077,7 @@ mod tests {
         let rows = resolver
             .ensure_directory_path(
                 "/docs/nested/",
-                FilesystemRowContext::active_version("version-a"),
+                FilesystemRowContext::active_branch("branch-a"),
                 false,
                 &mut test_id_generator(&["dir-generated-docs", "dir-generated-nested"]),
             )
@@ -1085,7 +1087,7 @@ mod tests {
         let rows = resolver
             .ensure_directory_path(
                 "/docs/nested/",
-                FilesystemRowContext::active_version("version-a"),
+                FilesystemRowContext::active_branch("branch-a"),
                 false,
                 &mut test_id_generator(&["should-not-be-used"]),
             )
@@ -1105,7 +1107,7 @@ mod tests {
                 path: "/docs/guides/readme.md".to_string(),
                 data: Some(b"hello".to_vec()),
                 hidden: Some(false),
-                context: FilesystemRowContext::active_version("version-a"),
+                context: FilesystemRowContext::active_branch("branch-a"),
             },
             &mut test_id_generator(&["dir-generated-docs", "dir-generated-guides"]),
         )
@@ -1114,7 +1116,7 @@ mod tests {
         assert_eq!(plan.count, 1);
         assert_eq!(plan.file_data.len(), 1);
         assert_eq!(plan.file_data[0].file_id, "file-readme");
-        assert_eq!(plan.file_data[0].version_id, "version-a");
+        assert_eq!(plan.file_data[0].branch_id, "branch-a");
         assert_eq!(plan.file_data[0].data, b"hello");
         assert_eq!(plan.rows.len(), 4);
         assert_eq!(
@@ -1155,7 +1157,7 @@ mod tests {
                 path: "/docs/guides/readme.md".to_string(),
                 data: Some(b"hello".to_vec()),
                 hidden: Some(false),
-                context: FilesystemRowContext::active_version("version-a"),
+                context: FilesystemRowContext::active_branch("branch-a"),
             },
             &mut test_id_generator(&["should-not-be-used"]),
         )
@@ -1190,7 +1192,7 @@ mod tests {
             "/docs/renamed.md".to_string(),
             false,
             Some(b"hello".to_vec()),
-            FilesystemRowContext::active_version("version-a"),
+            FilesystemRowContext::active_branch("branch-a"),
             &mut test_id_generator(&["should-not-be-used"]),
         )
         .expect("file path update should plan");
@@ -1221,7 +1223,7 @@ mod tests {
             "/docs/guides/readme.md".to_string(),
             true,
             Some(b"hello".to_vec()),
-            FilesystemRowContext::active_version("version-a"),
+            FilesystemRowContext::active_branch("branch-a"),
             &mut test_id_generator(&["dir-generated-docs", "dir-generated-guides"]),
         )
         .expect("file path update should plan");
@@ -1257,12 +1259,12 @@ mod tests {
         let resolvers = super::directory_path_resolvers_from_state_rows(vec![
             live_directory_row(
                 "dir-docs",
-                "version-a",
+                "branch-a",
                 "{\"id\":\"dir-docs\",\"parent_id\":null,\"name\":\"docs\"}",
             ),
             live_directory_row(
                 "dir-guides",
-                "version-a",
+                "branch-a",
                 "{\"id\":\"dir-guides\",\"parent_id\":\"dir-docs\",\"name\":\"guides\"}",
             ),
         ])
@@ -1270,10 +1272,7 @@ mod tests {
 
         let resolver = resolvers
             .get(&super::filesystem_storage_scope_key(
-                "version-a",
-                false,
-                false,
-                None,
+                "branch-a", false, false, None,
             ))
             .expect("storage-scope resolver should exist");
         assert_eq!(resolver.directory_id("/docs/").unwrap(), Some("dir-docs"));
@@ -1288,7 +1287,7 @@ mod tests {
         let plan = super::plan_file_delete(FileDeleteInput {
             file_id: "file-readme".to_string(),
             has_blob_ref: true,
-            context: FilesystemRowContext::active_version("version-a"),
+            context: FilesystemRowContext::active_branch("branch-a"),
         });
 
         assert_eq!(plan.count, 1);
@@ -1299,10 +1298,8 @@ mod tests {
             .find(|row| row.schema_key == "lix_file_descriptor")
             .expect("file descriptor tombstone should be planned");
         assert_eq!(
-            descriptor.entity_id.as_ref(),
-            Some(&crate::entity_identity::EntityIdentity::single(
-                "file-readme"
-            ))
+            descriptor.entity_pk.as_ref(),
+            Some(&crate::entity_pk::EntityPk::single("file-readme"))
         );
         assert_eq!(descriptor.file_id, None);
         assert_eq!(descriptor.snapshot, None);
@@ -1313,10 +1310,8 @@ mod tests {
             .find(|row| row.schema_key == "lix_binary_blob_ref")
             .expect("blob ref tombstone should be planned");
         assert_eq!(
-            blob_ref.entity_id.as_ref(),
-            Some(&crate::entity_identity::EntityIdentity::single(
-                "file-readme"
-            ))
+            blob_ref.entity_pk.as_ref(),
+            Some(&crate::entity_pk::EntityPk::single("file-readme"))
         );
         assert_eq!(blob_ref.file_id.as_deref(), Some("file-readme"));
         assert_eq!(blob_ref.snapshot, None);
@@ -1327,7 +1322,7 @@ mod tests {
         let plan = super::plan_file_delete(FileDeleteInput {
             file_id: "file-readme".to_string(),
             has_blob_ref: false,
-            context: FilesystemRowContext::active_version("version-a"),
+            context: FilesystemRowContext::active_branch("branch-a"),
         });
 
         assert_eq!(plan.count, 1);
@@ -1340,14 +1335,14 @@ mod tests {
     fn directory_delete_plans_descriptor_tombstone() {
         let plan = super::plan_directory_delete(DirectoryDeleteInput {
             directory_id: "dir-docs".to_string(),
-            context: FilesystemRowContext::active_version("version-a"),
+            context: FilesystemRowContext::active_branch("branch-a"),
         });
 
         assert_eq!(plan.count, 1);
         assert_eq!(plan.rows.len(), 1);
         assert_eq!(
-            plan.rows[0].entity_id.as_ref(),
-            Some(&crate::entity_identity::EntityIdentity::single("dir-docs"))
+            plan.rows[0].entity_pk.as_ref(),
+            Some(&crate::entity_pk::EntityPk::single("dir-docs"))
         );
         assert_eq!(plan.rows[0].schema_key, "lix_directory_descriptor");
         assert_eq!(plan.rows[0].file_id, None);
@@ -1356,7 +1351,7 @@ mod tests {
 
     #[test]
     fn recursive_directory_delete_plans_files_blobs_and_deepest_directories_first() {
-        let context = FilesystemRowContext::active_version("version-a");
+        let context = FilesystemRowContext::active_branch("branch-a");
         let mut directories_by_id = BTreeMap::new();
         directories_by_id.insert(
             "dir-docs".to_string(),
@@ -1408,11 +1403,11 @@ mod tests {
                 .map(|row| {
                     (
                         row.schema_key.as_str(),
-                        row.entity_id
+                        row.entity_pk
                             .as_ref()
-                            .expect("planned recursive delete row should carry entity_id")
+                            .expect("planned recursive delete row should carry entity_pk")
                             .as_single_string_owned()
-                            .expect("planned recursive delete row should project entity_id"),
+                            .expect("planned recursive delete row should project entity_pk"),
                     )
                 })
                 .collect::<Vec<_>>(),
@@ -1467,20 +1462,20 @@ mod tests {
     }
 
     fn live_directory_row(
-        entity_id: &str,
-        version_id: &str,
+        entity_pk: &str,
+        branch_id: &str,
         snapshot_content: &str,
     ) -> MaterializedLiveStateRow {
         MaterializedLiveStateRow {
-            entity_id: EntityIdentity::single(entity_id),
+            entity_pk: EntityPk::single(entity_pk),
             schema_key: "lix_directory_descriptor".to_string(),
             file_id: None,
             snapshot_content: Some(snapshot_content.to_string()),
             metadata: None,
             deleted: false,
-            version_id: version_id.to_string(),
-            change_id: Some(format!("change-{entity_id}")),
-            commit_id: Some(format!("commit-{entity_id}")),
+            branch_id: branch_id.to_string(),
+            change_id: Some(format!("change-{entity_pk}")),
+            commit_id: Some(format!("commit-{entity_pk}")),
             global: false,
             untracked: false,
             created_at: "2026-04-23T00:00:00Z".to_string(),

package/dist-engine-src/src/sql2/filesystem_visibility.rs

@@ -28,11 +28,11 @@ pub(crate) struct VisibleFilesystem {
 }
 
 impl VisibleFilesystem {
-    /// Loads filesystem rows for a single version from execution-visible live
+    /// Loads filesystem rows for a single branch from execution-visible live
     /// state and builds lookup indexes used by filesystem write planning.
     pub(crate) async fn load(
         live_state: Arc<dyn LiveStateReader>,
-        version_id: &str,
+        branch_id: &str,
     ) -> Result<Self, LixError> {
         let rows = live_state
             .scan_rows(&LiveStateScanRequest {
@@ -42,7 +42,7 @@ impl VisibleFilesystem {
                         FILE_DESCRIPTOR_SCHEMA_KEY.to_string(),
                         BLOB_REF_SCHEMA_KEY.to_string(),
                     ],
-                    version_ids: vec![version_id.to_string()],
+                    branch_ids: vec![branch_id.to_string()],
                     ..LiveStateFilter::default()
                 },
                 ..LiveStateScanRequest::default()
@@ -185,7 +185,7 @@ fn filesystem_row_context(
     row: &MaterializedLiveStateRow,
 ) -> Result<FilesystemRowContext, LixError> {
     Ok(FilesystemRowContext {
-        version_id: row.version_id.clone(),
+        branch_id: row.branch_id.clone(),
         global: row.global,
         untracked: row.untracked,
         file_id: row.file_id.clone(),
@@ -232,7 +232,7 @@ mod tests {
                     r#"{"id":"dir-guides","parent_id":"dir-docs","name":"guides","hidden":false}"#,
                 ),
             ]),
-            "version-a",
+            "branch-a",
         )
         .await
         .expect("visible filesystem should load");
@@ -261,7 +261,7 @@ mod tests {
                 "file-readme",
                 r#"{"id":"file-readme","directory_id":"dir-guides","name":"readme.md","hidden":false}"#,
             )]),
-            "version-a",
+            "branch-a",
         )
         .await
         .expect("visible filesystem should load");
@@ -283,7 +283,7 @@ mod tests {
                 "file-readme",
                 r#"{"id":"file-readme","blob_hash":"abc123","size_bytes":5}"#,
             )]),
-            "version-a",
+            "branch-a",
         )
         .await
         .expect("visible filesystem should load");
@@ -316,8 +316,8 @@ mod tests {
                 .filter(|row| {
                     (request.filter.schema_keys.is_empty()
                         || request.filter.schema_keys.contains(&row.schema_key))
-                        && (request.filter.version_ids.is_empty()
-                            || request.filter.version_ids.contains(&row.version_id))
+                        && (request.filter.branch_ids.is_empty()
+                            || request.filter.branch_ids.contains(&row.branch_id))
                 })
                 .cloned()
                 .collect())
@@ -331,49 +331,49 @@ mod tests {
         }
     }
 
-    fn directory_row(entity_id: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
+    fn directory_row(entity_pk: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
         live_row(
-            entity_id,
+            entity_pk,
             DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
             None,
             snapshot_content,
         )
     }
 
-    fn file_row(entity_id: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
+    fn file_row(entity_pk: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
         live_row(
-            entity_id,
+            entity_pk,
             FILE_DESCRIPTOR_SCHEMA_KEY,
             None,
             snapshot_content,
         )
     }
 
-    fn blob_ref_row(entity_id: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
+    fn blob_ref_row(entity_pk: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
         live_row(
-            entity_id,
+            entity_pk,
             BLOB_REF_SCHEMA_KEY,
-            Some(entity_id.to_string()),
+            Some(entity_pk.to_string()),
             snapshot_content,
         )
     }
 
     fn live_row(
-        entity_id: &str,
+        entity_pk: &str,
         schema_key: &str,
         file_id: Option<String>,
         snapshot_content: &str,
     ) -> MaterializedLiveStateRow {
         MaterializedLiveStateRow {
-            entity_id: crate::entity_identity::EntityIdentity::single(entity_id),
+            entity_pk: crate::entity_pk::EntityPk::single(entity_pk),
             schema_key: schema_key.to_string(),
             file_id,
             snapshot_content: Some(snapshot_content.to_string()),
             metadata: None,
             deleted: false,
-            version_id: "version-a".to_string(),
-            change_id: Some(format!("change-{entity_id}")),
-            commit_id: Some(format!("commit-{entity_id}")),
+            branch_id: "branch-a".to_string(),
+            change_id: Some(format!("change-{entity_pk}")),
+            commit_id: Some(format!("commit-{entity_pk}")),
             global: false,
             untracked: false,
             created_at: "2026-04-23T00:00:00Z".to_string(),

package/dist-engine-src/src/sql2/history_projection.rs

@@ -1,12 +1,12 @@
 use serde_json::Value as JsonValue;
 
-use crate::entity_identity::EntityIdentity;
+use crate::entity_pk::EntityPk;
 use crate::LixError;
 
 /// Shared projection contract for typed history views.
 ///
 /// On tombstone rows (`snapshot_content IS NULL`), identity columns survive by
-/// projecting from canonical entity identity. Non-identity columns must remain
+/// projecting from canonical entity primary key. Non-identity columns must remain
 /// NULL because there is no snapshot to project payload from.
 pub(crate) enum HistoryIdentityProjection<'a> {
     PrimaryKeyPaths(&'a [Vec<String>]),
@@ -15,26 +15,26 @@ pub(crate) enum HistoryIdentityProjection<'a> {
 
 pub(crate) fn tombstone_identity_column_value(
     column_name: &str,
-    entity_id: &str,
+    entity_pk: &str,
     projection: HistoryIdentityProjection<'_>,
 ) -> Result<Option<JsonValue>, LixError> {
     match projection {
         HistoryIdentityProjection::SingleColumn { column } => {
             if column_name == column {
-                Ok(Some(JsonValue::String(entity_id.to_string())))
+                Ok(Some(JsonValue::String(entity_pk.to_string())))
             } else {
                 Ok(None)
             }
         }
         HistoryIdentityProjection::PrimaryKeyPaths(primary_key_paths) => {
-            primary_key_tombstone_value(column_name, entity_id, primary_key_paths)
+            primary_key_tombstone_value(column_name, entity_pk, primary_key_paths)
         }
     }
 }
 
 fn primary_key_tombstone_value(
     column_name: &str,
-    entity_id: &str,
+    entity_pk: &str,
     primary_key_paths: &[Vec<String>],
 ) -> Result<Option<JsonValue>, LixError> {
     let Some(part_index) = primary_key_paths
@@ -44,9 +44,9 @@ fn primary_key_tombstone_value(
         return Ok(None);
     };
 
-    let identity = EntityIdentity::from_json_array_text(entity_id).map_err(|error| {
+    let identity = EntityPk::from_json_array_text(entity_pk).map_err(|error| {
         LixError::unknown(format!(
-            "failed to decode history tombstone entity identity: {error}"
+            "failed to decode history tombstone entity primary key: {error}"
         ))
     })?;
     Ok(identity