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

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

@@ -10,18 +10,15 @@ use crate::common::{
     parent_directory_path, stable_content_fingerprint_hex, ParsedFilePath,
 };
 use crate::entity_identity::EntityIdentity;
-use crate::live_state::LiveStateRow;
-use crate::{LixError, RowMetadata};
+use crate::live_state::MaterializedLiveStateRow;
+use crate::LixError;
 
 use super::filesystem_visibility::VisibleFilesystem;
-use crate::transaction::types::{StageFileData, StageRow};
+use crate::transaction::types::{TransactionFileData, TransactionJson, TransactionWriteRow};
 
 pub(crate) const FILE_DESCRIPTOR_SCHEMA_KEY: &str = "lix_file_descriptor";
-pub(crate) const FILE_DESCRIPTOR_SCHEMA_VERSION: &str = "1";
 pub(crate) const DIRECTORY_DESCRIPTOR_SCHEMA_KEY: &str = "lix_directory_descriptor";
-pub(crate) const DIRECTORY_DESCRIPTOR_SCHEMA_VERSION: &str = "1";
 pub(crate) const BLOB_REF_SCHEMA_KEY: &str = "lix_binary_blob_ref";
-pub(crate) const BLOB_REF_SCHEMA_VERSION: &str = "1";
 
 /// Planned filesystem write output after SQL surface columns have been lowered
 /// into state rows and optional file payload writes.
@@ -31,8 +28,8 @@ pub(crate) const BLOB_REF_SCHEMA_VERSION: &str = "1";
 /// filesystem write surface.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub(crate) struct FilesystemWritePlan {
-    pub(crate) rows: Vec<StageRow>,
-    pub(crate) file_data: Vec<StageFileData>,
+    pub(crate) rows: Vec<TransactionWriteRow>,
+    pub(crate) file_data: Vec<TransactionFileData>,
     pub(crate) count: u64,
 }
 
@@ -40,7 +37,7 @@ pub(crate) struct FilesystemWritePlan {
 /// and the surface delete has been lowered into tombstone state rows.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub(crate) struct FilesystemDeletePlan {
-    pub(crate) rows: Vec<StageRow>,
+    pub(crate) rows: Vec<TransactionWriteRow>,
     pub(crate) count: u64,
 }
 
@@ -51,7 +48,7 @@ pub(crate) struct FilesystemRowContext {
     pub(crate) global: bool,
     pub(crate) untracked: bool,
     pub(crate) file_id: Option<String>,
-    pub(crate) metadata: Option<RowMetadata>,
+    pub(crate) metadata: Option<TransactionJson>,
 }
 
 impl FilesystemRowContext {
@@ -224,7 +221,7 @@ impl DirectoryPathResolver {
         context: FilesystemRowContext,
         hidden: bool,
         generate_directory_id: &mut dyn FnMut() -> String,
-    ) -> Result<Vec<StageRow>, LixError> {
+    ) -> Result<Vec<TransactionWriteRow>, LixError> {
         self.ensure_directory_path_with_leaf_id(
             directory_path,
             None,
@@ -241,7 +238,7 @@ impl DirectoryPathResolver {
         context: FilesystemRowContext,
         hidden: bool,
         generate_directory_id: &mut dyn FnMut() -> String,
-    ) -> Result<Vec<StageRow>, LixError> {
+    ) -> Result<Vec<TransactionWriteRow>, LixError> {
         self.plan_directory_path(
             directory_path,
             leaf_id,
@@ -259,7 +256,7 @@ impl DirectoryPathResolver {
         context: FilesystemRowContext,
         hidden: bool,
         generate_directory_id: &mut dyn FnMut() -> String,
-    ) -> Result<Vec<StageRow>, LixError> {
+    ) -> Result<Vec<TransactionWriteRow>, LixError> {
         self.plan_directory_path(
             directory_path,
             leaf_id,
@@ -278,7 +275,7 @@ impl DirectoryPathResolver {
         hidden: bool,
         generate_directory_id: &mut dyn FnMut() -> String,
         reject_existing_leaf: bool,
-    ) -> Result<Vec<StageRow>, LixError> {
+    ) -> Result<Vec<TransactionWriteRow>, LixError> {
         let directory_path = normalize_directory_path(directory_path)?;
         if directory_path == "/" {
             if reject_existing_leaf {
@@ -402,7 +399,7 @@ fn filesystem_namespace_conflict_error(
     )
 }
 
-pub(crate) fn directory_descriptor_row(input: DirectoryDescriptorRowInput) -> StageRow {
+pub(crate) fn directory_descriptor_row(input: DirectoryDescriptorRowInput) -> TransactionWriteRow {
     directory_descriptor_write_row(DirectoryDescriptorWriteIntent {
         id: Some(input.id),
         parent_id: input.parent_id,
@@ -412,7 +409,7 @@ pub(crate) fn directory_descriptor_row(input: DirectoryDescriptorRowInput) -> St
     })
 }
 
-pub(crate) fn file_descriptor_row(input: FileDescriptorRowInput) -> StageRow {
+pub(crate) fn file_descriptor_row(input: FileDescriptorRowInput) -> TransactionWriteRow {
     file_descriptor_write_row(FileDescriptorWriteIntent {
         id: Some(input.id),
         directory_id: input.directory_id,
@@ -422,7 +419,9 @@ pub(crate) fn file_descriptor_row(input: FileDescriptorRowInput) -> StageRow {
     })
 }
 
-pub(crate) fn directory_descriptor_write_row(input: DirectoryDescriptorWriteIntent) -> StageRow {
+pub(crate) fn directory_descriptor_write_row(
+    input: DirectoryDescriptorWriteIntent,
+) -> TransactionWriteRow {
     let mut snapshot = JsonMap::new();
     if let Some(id) = input.id.as_ref() {
         snapshot.insert("id".to_string(), JsonValue::String(id.clone()));
@@ -443,13 +442,12 @@ pub(crate) fn directory_descriptor_write_row(input: DirectoryDescriptorWriteInte
     partial_state_row(
         input.id,
         DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
-        DIRECTORY_DESCRIPTOR_SCHEMA_VERSION.to_string(),
-        Some(JsonValue::Object(snapshot).to_string()),
+        Some(JsonValue::Object(snapshot)),
         input.context,
     )
 }
 
-pub(crate) fn file_descriptor_write_row(input: FileDescriptorWriteIntent) -> StageRow {
+pub(crate) fn file_descriptor_write_row(input: FileDescriptorWriteIntent) -> TransactionWriteRow {
     let mut snapshot = JsonMap::new();
     if let Some(id) = input.id.as_ref() {
         snapshot.insert("id".to_string(), JsonValue::String(id.clone()));
@@ -470,13 +468,12 @@ pub(crate) fn file_descriptor_write_row(input: FileDescriptorWriteIntent) -> Sta
     partial_state_row(
         input.id,
         FILE_DESCRIPTOR_SCHEMA_KEY,
-        FILE_DESCRIPTOR_SCHEMA_VERSION.to_string(),
-        Some(JsonValue::Object(snapshot).to_string()),
+        Some(JsonValue::Object(snapshot)),
         input.context,
     )
 }
 
-pub(crate) fn blob_ref_row(input: BlobRefRowInput) -> Result<StageRow, LixError> {
+pub(crate) fn blob_ref_row(input: BlobRefRowInput) -> Result<TransactionWriteRow, LixError> {
     let size_bytes = u64::try_from(input.data.len()).map_err(|_| {
         LixError::new(
             "LIX_ERROR_UNKNOWN",
@@ -486,18 +483,16 @@ pub(crate) fn blob_ref_row(input: BlobRefRowInput) -> Result<StageRow, LixError>
             ),
         )
     })?;
-    let snapshot_content = json!({
+    let snapshot = json!({
         "id": input.file_id.clone(),
         "blob_hash": stable_content_fingerprint_hex(&input.data),
         "size_bytes": size_bytes,
-    })
-    .to_string();
+    });
 
     Ok(state_row(
         input.file_id.clone(),
         BLOB_REF_SCHEMA_KEY,
-        BLOB_REF_SCHEMA_VERSION.to_string(),
-        Some(snapshot_content),
+        Some(snapshot),
         FilesystemRowContext {
             file_id: Some(input.file_id),
             ..input.context
@@ -549,7 +544,7 @@ pub(crate) fn plan_file_path_write(
                 ..input.context.clone()
             },
         })?);
-        file_data.push(StageFileData {
+        file_data.push(TransactionFileData {
             file_id,
             version_id: input.context.version_id,
             untracked: input.context.untracked,
@@ -617,7 +612,6 @@ pub(crate) fn plan_file_delete(input: FileDeleteInput) -> FilesystemDeletePlan {
     let mut rows = vec![tombstone_row(
         input.file_id.clone(),
         FILE_DESCRIPTOR_SCHEMA_KEY,
-        FILE_DESCRIPTOR_SCHEMA_VERSION.to_string(),
         FilesystemRowContext {
             file_id: None,
             ..input.context.clone()
@@ -628,7 +622,6 @@ pub(crate) fn plan_file_delete(input: FileDeleteInput) -> FilesystemDeletePlan {
         rows.push(tombstone_row(
             input.file_id.clone(),
             BLOB_REF_SCHEMA_KEY,
-            BLOB_REF_SCHEMA_VERSION.to_string(),
             FilesystemRowContext {
                 file_id: Some(input.file_id),
                 metadata: None,
@@ -645,7 +638,6 @@ pub(crate) fn plan_directory_delete(input: DirectoryDeleteInput) -> FilesystemDe
         rows: vec![tombstone_row(
             input.directory_id,
             DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
-            DIRECTORY_DESCRIPTOR_SCHEMA_VERSION.to_string(),
             FilesystemRowContext {
                 file_id: None,
                 ..input.context
@@ -675,7 +667,7 @@ pub(crate) fn plan_recursive_directory_delete(
 }
 
 pub(crate) fn directory_path_resolvers_from_state_rows(
-    rows: Vec<LiveStateRow>,
+    rows: Vec<MaterializedLiveStateRow>,
 ) -> Result<BTreeMap<String, DirectoryPathResolver>, LixError> {
     let mut directory_rows = BTreeMap::<String, BTreeMap<String, DirectoryDescriptorSeed>>::new();
     let mut file_rows = BTreeMap::<String, Vec<(Option<String>, String, String)>>::new();
@@ -814,37 +806,26 @@ fn directory_parent_cycle_error(directory_id: &str) -> LixError {
 fn state_row(
     entity_id: String,
     schema_key: &str,
-    schema_version: String,
-    snapshot_content: Option<String>,
+    snapshot: Option<JsonValue>,
     context: FilesystemRowContext,
-) -> StageRow {
-    partial_state_row(
-        Some(entity_id),
-        schema_key,
-        schema_version,
-        snapshot_content,
-        context,
-    )
+) -> TransactionWriteRow {
+    partial_state_row(Some(entity_id), schema_key, snapshot, context)
 }
 
 fn partial_state_row(
     entity_id: Option<String>,
     schema_key: &str,
-    schema_version: String,
-    snapshot_content: Option<String>,
+    snapshot: Option<JsonValue>,
     context: FilesystemRowContext,
-) -> StageRow {
-    StageRow {
-        entity_id: entity_id.map(|entity_id| {
-            EntityIdentity::from_string(&entity_id)
-                .expect("filesystem entity id should decode as entity identity")
-        }),
+) -> TransactionWriteRow {
+    let snapshot = snapshot.map(TransactionJson::from_value_unchecked);
+    TransactionWriteRow {
+        entity_id: entity_id.map(EntityIdentity::single),
         schema_key: schema_key.to_string(),
         file_id: context.file_id,
-        snapshot_content,
+        snapshot,
         metadata: context.metadata,
         origin: None,
-        schema_version,
         created_at: None,
         updated_at: None,
         global: context.global,
@@ -858,17 +839,16 @@ fn partial_state_row(
 fn tombstone_row(
     entity_id: String,
     schema_key: &str,
-    schema_version: String,
     context: FilesystemRowContext,
-) -> StageRow {
-    state_row(entity_id, schema_key, schema_version, None, context)
+) -> TransactionWriteRow {
+    state_row(entity_id, schema_key, None, context)
 }
 
 fn collect_recursive_directory_delete(
     directory_id: &str,
     visible_filesystem: &VisibleFilesystem,
     context: &FilesystemRowContext,
-    rows: &mut Vec<StageRow>,
+    rows: &mut Vec<TransactionWriteRow>,
     count: &mut u64,
 ) {
     if let Some(child_ids) = visible_filesystem
@@ -920,7 +900,7 @@ mod tests {
     use crate::sql2::filesystem_visibility::{
         VisibleBlobRef, VisibleDirectory, VisibleFile, VisibleFilesystem,
     };
-    use crate::{entity_identity::EntityIdentity, live_state::LiveStateRow};
+    use crate::{entity_identity::EntityIdentity, live_state::MaterializedLiveStateRow};
 
     fn test_id_generator(ids: &'static [&'static str]) -> impl FnMut() -> String {
         let mut ids = ids.iter();
@@ -942,10 +922,8 @@ mod tests {
             Some(&crate::entity_identity::EntityIdentity::single("dir-docs"))
         );
         assert_eq!(row.schema_key, "lix_directory_descriptor");
-        assert_eq!(row.schema_version.as_str(), "1");
         assert_eq!(row.version_id, "version-a");
-        let snapshot: JsonValue =
-            serde_json::from_str(row.snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "dir-docs");
         assert_eq!(snapshot["parent_id"], JsonValue::Null);
         assert_eq!(snapshot["name"], "docs");
@@ -969,9 +947,7 @@ mod tests {
             ))
         );
         assert_eq!(row.schema_key, "lix_file_descriptor");
-        assert_eq!(row.schema_version.as_str(), "1");
-        let snapshot: JsonValue =
-            serde_json::from_str(row.snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["directory_id"], "dir-docs");
         assert_eq!(snapshot["name"], "readme.md");
     }
@@ -993,9 +969,7 @@ mod tests {
         );
         assert_eq!(row.file_id.as_deref(), Some("file-readme"));
         assert_eq!(row.schema_key, "lix_binary_blob_ref");
-        assert_eq!(row.schema_version.as_str(), "1");
-        let snapshot: JsonValue =
-            serde_json::from_str(row.snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "file-readme");
         assert_eq!(snapshot["size_bytes"], 5);
         assert!(snapshot["blob_hash"]
@@ -1025,8 +999,7 @@ mod tests {
             Some("dir-generated-nested")
         );
 
-        let snapshot: JsonValue =
-            serde_json::from_str(rows[0].snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = rows[0].snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "dir-generated-nested");
         assert_eq!(snapshot["parent_id"], "dir-docs");
         assert_eq!(snapshot["name"], "nested");
@@ -1057,8 +1030,7 @@ mod tests {
             .expect("nested directory should plan");
 
         assert_eq!(nested_rows.len(), 1);
-        let snapshot: JsonValue =
-            serde_json::from_str(nested_rows[0].snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = nested_rows[0].snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "dir-generated-nested");
         assert_eq!(snapshot["parent_id"], "dir-generated-docs");
         assert_eq!(snapshot["name"], "nested");
@@ -1089,8 +1061,7 @@ mod tests {
             Some("dir-nested")
         );
 
-        let snapshot: JsonValue =
-            serde_json::from_str(rows[1].snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = rows[1].snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "dir-nested");
         assert_eq!(snapshot["parent_id"], "dir-generated-docs");
         assert_eq!(snapshot["name"], "nested");
@@ -1163,8 +1134,7 @@ mod tests {
             .iter()
             .find(|row| row.schema_key == "lix_file_descriptor")
             .expect("file descriptor row should be planned");
-        let snapshot: JsonValue =
-            serde_json::from_str(file_row.snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = file_row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "file-readme");
         assert_eq!(snapshot["directory_id"], "dir-generated-guides");
         assert_eq!(snapshot["name"], "readme.md");
@@ -1204,8 +1174,7 @@ mod tests {
             .iter()
             .find(|row| row.schema_key == "lix_file_descriptor")
             .expect("file descriptor row should be planned");
-        let snapshot: JsonValue =
-            serde_json::from_str(file_row.snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = file_row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["directory_id"], "dir-guides");
     }
 
@@ -1234,8 +1203,7 @@ mod tests {
             .iter()
             .all(|row| row.schema_key != "lix_binary_blob_ref"));
 
-        let snapshot: JsonValue =
-            serde_json::from_str(plan.rows[0].snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = plan.rows[0].snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["id"], "file-readme");
         assert_eq!(snapshot["directory_id"], "dir-docs");
         assert_eq!(snapshot["name"], "renamed.md");
@@ -1278,8 +1246,7 @@ mod tests {
             .iter()
             .find(|row| row.schema_key == "lix_file_descriptor")
             .expect("file descriptor row should be planned");
-        let snapshot: JsonValue =
-            serde_json::from_str(file_row.snapshot_content.as_deref().unwrap()).unwrap();
+        let snapshot: JsonValue = file_row.snapshot.as_ref().unwrap().value().clone();
         assert_eq!(snapshot["directory_id"], "dir-generated-guides");
         assert_eq!(snapshot["name"], "readme.md");
         assert_eq!(snapshot["hidden"], true);
@@ -1338,8 +1305,7 @@ mod tests {
             ))
         );
         assert_eq!(descriptor.file_id, None);
-        assert_eq!(descriptor.snapshot_content, None);
-        assert_eq!(descriptor.schema_version.as_str(), "1");
+        assert_eq!(descriptor.snapshot, None);
 
         let blob_ref = plan
             .rows
@@ -1353,8 +1319,7 @@ mod tests {
             ))
         );
         assert_eq!(blob_ref.file_id.as_deref(), Some("file-readme"));
-        assert_eq!(blob_ref.snapshot_content, None);
-        assert_eq!(blob_ref.schema_version.as_str(), "1");
+        assert_eq!(blob_ref.snapshot, None);
     }
 
     #[test]
@@ -1368,7 +1333,7 @@ mod tests {
         assert_eq!(plan.count, 1);
         assert_eq!(plan.rows.len(), 1);
         assert_eq!(plan.rows[0].schema_key, "lix_file_descriptor");
-        assert_eq!(plan.rows[0].snapshot_content, None);
+        assert_eq!(plan.rows[0].snapshot, None);
     }
 
     #[test]
@@ -1386,8 +1351,7 @@ mod tests {
         );
         assert_eq!(plan.rows[0].schema_key, "lix_directory_descriptor");
         assert_eq!(plan.rows[0].file_id, None);
-        assert_eq!(plan.rows[0].snapshot_content, None);
-        assert_eq!(plan.rows[0].schema_version.as_str(), "1");
+        assert_eq!(plan.rows[0].snapshot, None);
     }
 
     #[test]
@@ -1447,7 +1411,7 @@ mod tests {
                         row.entity_id
                             .as_ref()
                             .expect("planned recursive delete row should carry entity_id")
-                            .as_string()
+                            .as_single_string_owned()
                             .expect("planned recursive delete row should project entity_id"),
                     )
                 })
@@ -1460,7 +1424,7 @@ mod tests {
                 ("lix_directory_descriptor", "dir-docs".to_string()),
             ]
         );
-        assert!(plan.rows.iter().all(|row| row.snapshot_content.is_none()));
+        assert!(plan.rows.iter().all(|row| row.snapshot.is_none()));
     }
 
     fn visible_directory(
@@ -1506,14 +1470,14 @@ mod tests {
         entity_id: &str,
         version_id: &str,
         snapshot_content: &str,
-    ) -> LiveStateRow {
-        LiveStateRow {
-            entity_id: EntityIdentity::from_string(entity_id).expect("entity id should decode"),
+    ) -> MaterializedLiveStateRow {
+        MaterializedLiveStateRow {
+            entity_id: EntityIdentity::single(entity_id),
             schema_key: "lix_directory_descriptor".to_string(),
             file_id: None,
             snapshot_content: Some(snapshot_content.to_string()),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             version_id: version_id.to_string(),
             change_id: Some(format!("change-{entity_id}")),
             commit_id: Some(format!("commit-{entity_id}")),

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

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use serde::Deserialize;
 
-use crate::live_state::LiveStateRow;
+use crate::live_state::MaterializedLiveStateRow;
 use crate::live_state::{LiveStateFilter, LiveStateReader, LiveStateScanRequest};
 use crate::LixError;
 
@@ -16,7 +16,7 @@ use super::filesystem_planner::{
 
 /// Execution-visible filesystem metadata decoded from live-state rows.
 ///
-/// The helper intentionally depends only on `LiveStateReader`. In engine2
+/// The helper intentionally depends only on `LiveStateReader`. In engine
 /// write execution that context may include staged rows, so filesystem planning
 /// sees pending writes without reaching into write-execution internals.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
@@ -53,7 +53,7 @@ impl VisibleFilesystem {
 
     /// Builds filesystem lookup indexes from rows that are already known to be
     /// transaction-visible.
-    pub(crate) fn from_live_rows(rows: Vec<LiveStateRow>) -> Result<Self, LixError> {
+    pub(crate) fn from_live_rows(rows: Vec<MaterializedLiveStateRow>) -> Result<Self, LixError> {
         let mut visible = Self::default();
 
         for row in rows {
@@ -74,7 +74,7 @@ impl VisibleFilesystem {
                         parent_id: snapshot.parent_id,
                         name: snapshot.name,
                         hidden: snapshot.hidden.unwrap_or(false),
-                        context: filesystem_row_context(&row),
+                        context: filesystem_row_context(&row)?,
                     };
                     visible
                         .directory_children_by_parent_id
@@ -98,7 +98,7 @@ impl VisibleFilesystem {
                         directory_id: snapshot.directory_id,
                         name: snapshot.name,
                         hidden: snapshot.hidden,
-                        context: filesystem_row_context(&row),
+                        context: filesystem_row_context(&row)?,
                     };
                     visible
                         .files_by_directory_id
@@ -120,7 +120,7 @@ impl VisibleFilesystem {
                             file_id: snapshot.id,
                             blob_hash: snapshot.blob_hash,
                             size_bytes: snapshot.size_bytes,
-                            context: filesystem_row_context(&row),
+                            context: filesystem_row_context(&row)?,
                         },
                     );
                 }
@@ -181,21 +181,36 @@ struct BlobRefSnapshot {
     size_bytes: Option<u64>,
 }
 
-fn filesystem_row_context(row: &LiveStateRow) -> FilesystemRowContext {
-    FilesystemRowContext {
+fn filesystem_row_context(
+    row: &MaterializedLiveStateRow,
+) -> Result<FilesystemRowContext, LixError> {
+    Ok(FilesystemRowContext {
         version_id: row.version_id.clone(),
         global: row.global,
         untracked: row.untracked,
         file_id: row.file_id.clone(),
-        metadata: row.metadata.clone(),
-    }
+        metadata: row
+            .metadata
+            .as_deref()
+            .map(|metadata| {
+                crate::parse_row_metadata_value(metadata, "filesystem row metadata").and_then(
+                    |metadata| {
+                        crate::transaction::types::TransactionJson::from_value(
+                            metadata,
+                            "filesystem row metadata",
+                        )
+                    },
+                )
+            })
+            .transpose()?,
+    })
 }
 
 #[cfg(test)]
 mod tests {
     use async_trait::async_trait;
 
-    use crate::live_state::LiveStateRow;
+    use crate::live_state::MaterializedLiveStateRow;
     use crate::live_state::{LiveStateReader, LiveStateRowRequest, LiveStateScanRequest};
     use crate::LixError;
 
@@ -281,12 +296,12 @@ mod tests {
         assert_eq!(blob_ref.size_bytes, Some(5));
     }
 
-    fn live_state(rows: Vec<LiveStateRow>) -> std::sync::Arc<dyn LiveStateReader> {
+    fn live_state(rows: Vec<MaterializedLiveStateRow>) -> std::sync::Arc<dyn LiveStateReader> {
         std::sync::Arc::new(RowsLiveStateReader { rows })
     }
 
     struct RowsLiveStateReader {
-        rows: Vec<LiveStateRow>,
+        rows: Vec<MaterializedLiveStateRow>,
     }
 
     #[async_trait]
@@ -294,7 +309,7 @@ mod tests {
         async fn scan_rows(
             &self,
             request: &LiveStateScanRequest,
-        ) -> Result<Vec<LiveStateRow>, LixError> {
+        ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
             Ok(self
                 .rows
                 .iter()
@@ -311,12 +326,12 @@ mod tests {
         async fn load_row(
             &self,
             _request: &LiveStateRowRequest,
-        ) -> Result<Option<LiveStateRow>, LixError> {
+        ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
             Ok(None)
         }
     }
 
-    fn directory_row(entity_id: &str, snapshot_content: &str) -> LiveStateRow {
+    fn directory_row(entity_id: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
         live_row(
             entity_id,
             DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
@@ -325,7 +340,7 @@ mod tests {
         )
     }
 
-    fn file_row(entity_id: &str, snapshot_content: &str) -> LiveStateRow {
+    fn file_row(entity_id: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
         live_row(
             entity_id,
             FILE_DESCRIPTOR_SCHEMA_KEY,
@@ -334,7 +349,7 @@ mod tests {
         )
     }
 
-    fn blob_ref_row(entity_id: &str, snapshot_content: &str) -> LiveStateRow {
+    fn blob_ref_row(entity_id: &str, snapshot_content: &str) -> MaterializedLiveStateRow {
         live_row(
             entity_id,
             BLOB_REF_SCHEMA_KEY,
@@ -348,15 +363,14 @@ mod tests {
         schema_key: &str,
         file_id: Option<String>,
         snapshot_content: &str,
-    ) -> LiveStateRow {
-        LiveStateRow {
-            entity_id: crate::entity_identity::EntityIdentity::from_string(entity_id)
-                .expect("entity id should decode"),
+    ) -> MaterializedLiveStateRow {
+        MaterializedLiveStateRow {
+            entity_id: crate::entity_identity::EntityIdentity::single(entity_id),
             schema_key: schema_key.to_string(),
             file_id,
             snapshot_content: Some(snapshot_content.to_string()),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             version_id: "version-a".to_string(),
             change_id: Some(format!("change-{entity_id}")),
             commit_id: Some(format!("commit-{entity_id}")),

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

@@ -1,6 +1,6 @@
 use serde_json::Value as JsonValue;
 
-use crate::entity_identity::{EntityIdentity, EntityIdentityPart};
+use crate::entity_identity::EntityIdentity;
 use crate::LixError;
 
 /// Shared projection contract for typed history views.
@@ -44,7 +44,7 @@ fn primary_key_tombstone_value(
         return Ok(None);
     };
 
-    let identity = EntityIdentity::from_string(entity_id).map_err(|error| {
+    let identity = EntityIdentity::from_json_array_text(entity_id).map_err(|error| {
         LixError::unknown(format!(
             "failed to decode history tombstone entity identity: {error}"
         ))
@@ -52,29 +52,5 @@ fn primary_key_tombstone_value(
     Ok(identity
         .parts
         .get(part_index)
-        .map(entity_identity_part_json_value))
-}
-
-fn entity_identity_part_json_value(part: &EntityIdentityPart) -> JsonValue {
-    match part {
-        EntityIdentityPart::String(value) => JsonValue::String(value.clone()),
-        EntityIdentityPart::Bool(value) => JsonValue::Bool(*value),
-        EntityIdentityPart::Number(value) => value
-            .parse::<i64>()
-            .map(|value| JsonValue::Number(value.into()))
-            .or_else(|_| {
-                value
-                    .parse::<u64>()
-                    .map(|value| JsonValue::Number(value.into()))
-            })
-            .ok()
-            .or_else(|| {
-                value
-                    .parse::<f64>()
-                    .ok()
-                    .and_then(serde_json::Number::from_f64)
-                    .map(JsonValue::Number)
-            })
-            .unwrap_or_else(|| JsonValue::String(value.clone())),
-    }
+        .map(|part| JsonValue::String(part.clone())))
 }