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

package/dist-engine-src/src/untracked_state/codec.rs

@@ -1,18 +1,28 @@
-use crate::entity_identity::EntityIdentity;
-use crate::untracked_state::{UntrackedStateRow, UntrackedStateRowRef};
+use crate::entity_pk::EntityPk;
+use crate::untracked_state::{UntrackedStateIdentity, UntrackedStateRow, UntrackedStateRowRef};
 use crate::LixError;
 
 const UNTRACKED_STATE_FILE_IDENTIFIER: &str = "LXUS";
+// Durable payload bytes:
+//   b"LXUP" | branch:u8 |
+//   snapshot_content_tag:u8 | [snapshot_content_len:u32be | snapshot_content:utf8] |
+//   metadata_tag:u8 | [metadata_len:u32be | metadata:utf8] |
+//   created_at_len:u32be | created_at:utf8 |
+//   updated_at_len:u32be | updated_at:utf8 |
+//   global:u8
+const UNTRACKED_STATE_PAYLOAD_IDENTIFIER: &[u8; 4] = b"LXUP";
+const UNTRACKED_STATE_PAYLOAD_BRANCH_V1: u8 = 1;
 
+#[cfg_attr(not(feature = "storage-benches"), allow(dead_code))]
 pub(crate) fn encode_row_ref(row: UntrackedStateRowRef<'_>) -> Result<Vec<u8>, LixError> {
-    let entity_id = row.entity_id.as_json_array_text().map_err(|error| {
+    let entity_pk = row.entity_pk.as_json_array_text().map_err(|error| {
         LixError::unknown(format!(
-            "failed to encode untracked-state entity identity: {error}"
+            "failed to encode untracked-state entity primary key: {error}"
         ))
     })?;
 
     let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(256);
-    let entity_id = builder.create_string(&entity_id);
+    let entity_pk = builder.create_string(&entity_pk);
     let schema_key = builder.create_string(row.schema_key);
     let file_id = row.file_id.map(|value| builder.create_string(value));
     let snapshot_content = row
@@ -21,12 +31,12 @@ pub(crate) fn encode_row_ref(row: UntrackedStateRowRef<'_>) -> Result<Vec<u8>, L
     let metadata = row.metadata.map(|value| builder.create_string(value));
     let created_at = builder.create_string(row.created_at);
     let updated_at = builder.create_string(row.updated_at);
-    let version_id = builder.create_string(row.version_id);
+    let branch_id = builder.create_string(row.branch_id);
 
     let root = flatbuffer::create_untracked_state_row(
         &mut builder,
         &flatbuffer::UntrackedStateRowArgs {
-            entity_id,
+            entity_pk,
             schema_key,
             file_id,
             snapshot_content,
@@ -34,13 +44,70 @@ pub(crate) fn encode_row_ref(row: UntrackedStateRowRef<'_>) -> Result<Vec<u8>, L
             created_at,
             updated_at,
             global: row.global,
-            version_id,
+            branch_id,
         },
     );
     builder.finish(root, Some(UNTRACKED_STATE_FILE_IDENTIFIER));
     Ok(builder.finished_data().to_vec())
 }
 
+pub(crate) fn encode_payload_ref(row: UntrackedStateRowRef<'_>) -> Result<Vec<u8>, LixError> {
+    let mut out = Vec::with_capacity(payload_capacity(row));
+    out.extend_from_slice(UNTRACKED_STATE_PAYLOAD_IDENTIFIER);
+    out.push(UNTRACKED_STATE_PAYLOAD_BRANCH_V1);
+    push_optional_string(&mut out, row.snapshot_content)?;
+    push_optional_string(&mut out, row.metadata)?;
+    push_string(&mut out, row.created_at)?;
+    push_string(&mut out, row.updated_at)?;
+    out.push(u8::from(row.global));
+    Ok(out)
+}
+
+pub(crate) fn decode_payload_with_identity(
+    identity: UntrackedStateIdentity,
+    bytes: &[u8],
+) -> Result<UntrackedStateRow, LixError> {
+    if !bytes.starts_with(UNTRACKED_STATE_PAYLOAD_IDENTIFIER) {
+        return Err(LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            "failed to decode untracked-state payload: invalid payload identifier",
+        ));
+    }
+
+    let mut cursor = UNTRACKED_STATE_PAYLOAD_IDENTIFIER.len();
+    let branch = read_u8(bytes, &mut cursor, "branch")?;
+    if branch != UNTRACKED_STATE_PAYLOAD_BRANCH_V1 {
+        return Err(LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: unsupported branch {branch}"),
+        ));
+    }
+    let snapshot_content = read_optional_string(bytes, &mut cursor, "snapshot_content")?;
+    let metadata = read_optional_string(bytes, &mut cursor, "metadata")?;
+    let created_at = read_string(bytes, &mut cursor, "created_at")?;
+    let updated_at = read_string(bytes, &mut cursor, "updated_at")?;
+    let global = read_bool(bytes, &mut cursor, "global")?;
+    if cursor != bytes.len() {
+        return Err(LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            "failed to decode untracked-state payload: trailing bytes",
+        ));
+    }
+
+    Ok(UntrackedStateRow {
+        entity_pk: identity.entity_pk,
+        schema_key: identity.schema_key,
+        file_id: identity.file_id,
+        snapshot_content,
+        metadata,
+        created_at,
+        updated_at,
+        global,
+        branch_id: identity.branch_id,
+    })
+}
+
+#[allow(dead_code)]
 pub(crate) fn decode_row(bytes: &[u8]) -> Result<UntrackedStateRow, LixError> {
     if bytes.len() < flatbuffers::SIZE_UOFFSET + flatbuffers::FILE_IDENTIFIER_LENGTH
         || !flatbuffers::buffer_has_identifier(bytes, UNTRACKED_STATE_FILE_IDENTIFIER, false)
@@ -58,15 +125,15 @@ pub(crate) fn decode_row(bytes: &[u8]) -> Result<UntrackedStateRow, LixError> {
         )
     })?;
 
-    let entity_id = required_str(row.entity_id(), "entity_id")?;
-    let entity_id = EntityIdentity::from_json_array_text(entity_id).map_err(|error| {
+    let entity_pk = required_str(row.entity_pk(), "entity_pk")?;
+    let entity_pk = EntityPk::from_json_array_text(entity_pk).map_err(|error| {
         LixError::unknown(format!(
-            "failed to decode untracked-state entity identity: {error}"
+            "failed to decode untracked-state entity primary key: {error}"
         ))
     })?;
 
     Ok(UntrackedStateRow {
-        entity_id,
+        entity_pk,
         schema_key: required_str(row.schema_key(), "schema_key")?.to_string(),
         file_id: row.file_id().map(ToString::to_string),
         snapshot_content: row.snapshot_content().map(ToString::to_string),
@@ -74,10 +141,134 @@ pub(crate) fn decode_row(bytes: &[u8]) -> Result<UntrackedStateRow, LixError> {
         created_at: required_str(row.created_at(), "created_at")?.to_string(),
         updated_at: required_str(row.updated_at(), "updated_at")?.to_string(),
         global: row.global(),
-        version_id: required_str(row.version_id(), "version_id")?.to_string(),
+        branch_id: required_str(row.branch_id(), "branch_id")?.to_string(),
     })
 }
 
+fn payload_capacity(row: UntrackedStateRowRef<'_>) -> usize {
+    UNTRACKED_STATE_PAYLOAD_IDENTIFIER.len()
+        + 1
+        + optional_string_capacity(row.snapshot_content)
+        + optional_string_capacity(row.metadata)
+        + string_capacity(row.created_at)
+        + string_capacity(row.updated_at)
+        + 1
+}
+
+fn optional_string_capacity(value: Option<&str>) -> usize {
+    1 + value.map_or(0, string_capacity)
+}
+
+fn string_capacity(value: &str) -> usize {
+    4 + value.len()
+}
+
+fn push_optional_string(out: &mut Vec<u8>, value: Option<&str>) -> Result<(), LixError> {
+    match value {
+        Some(value) => {
+            out.push(1);
+            push_string(out, value)?;
+        }
+        None => out.push(0),
+    }
+    Ok(())
+}
+
+fn push_string(out: &mut Vec<u8>, value: &str) -> Result<(), LixError> {
+    let len = u32::try_from(value.len()).map_err(|_| {
+        LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            "failed to encode untracked-state payload: string length exceeds u32",
+        )
+    })?;
+    out.extend_from_slice(&len.to_be_bytes());
+    out.extend_from_slice(value.as_bytes());
+    Ok(())
+}
+
+fn read_optional_string(
+    bytes: &[u8],
+    cursor: &mut usize,
+    field: &str,
+) -> Result<Option<String>, LixError> {
+    let tag = read_u8(bytes, cursor, field)?;
+    match tag {
+        0 => Ok(None),
+        1 => read_string(bytes, cursor, field).map(Some),
+        _ => Err(LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: invalid optional tag for `{field}`"),
+        )),
+    }
+}
+
+fn read_string(bytes: &[u8], cursor: &mut usize, field: &str) -> Result<String, LixError> {
+    let len = read_u32(bytes, cursor, field)? as usize;
+    let end = cursor.checked_add(len).ok_or_else(|| {
+        LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: `{field}` length overflow"),
+        )
+    })?;
+    let value = bytes.get(*cursor..end).ok_or_else(|| {
+        LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: truncated `{field}`"),
+        )
+    })?;
+    *cursor = end;
+    std::str::from_utf8(value)
+        .map(str::to_string)
+        .map_err(|error| {
+            LixError::new(
+                "LIX_ERROR_UNKNOWN",
+                format!("failed to decode untracked-state payload: invalid utf-8 for `{field}`: {error}"),
+            )
+        })
+}
+
+fn read_bool(bytes: &[u8], cursor: &mut usize, field: &str) -> Result<bool, LixError> {
+    match read_u8(bytes, cursor, field)? {
+        0 => Ok(false),
+        1 => Ok(true),
+        _ => Err(LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: invalid boolean for `{field}`"),
+        )),
+    }
+}
+
+fn read_u32(bytes: &[u8], cursor: &mut usize, field: &str) -> Result<u32, LixError> {
+    let end = cursor.checked_add(4).ok_or_else(|| {
+        LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: `{field}` cursor overflow"),
+        )
+    })?;
+    let raw = bytes.get(*cursor..end).ok_or_else(|| {
+        LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: truncated `{field}` length"),
+        )
+    })?;
+    *cursor = end;
+    Ok(u32::from_be_bytes(
+        raw.try_into().expect("slice length checked"),
+    ))
+}
+
+fn read_u8(bytes: &[u8], cursor: &mut usize, field: &str) -> Result<u8, LixError> {
+    let value = bytes.get(*cursor).copied().ok_or_else(|| {
+        LixError::new(
+            "LIX_ERROR_UNKNOWN",
+            format!("failed to decode untracked-state payload: truncated `{field}`"),
+        )
+    })?;
+    *cursor += 1;
+    Ok(value)
+}
+
+#[allow(dead_code)]
 fn required_str<'a>(value: Option<&'a str>, field: &str) -> Result<&'a str, LixError> {
     value.ok_or_else(|| {
         LixError::new(
@@ -87,6 +278,121 @@ fn required_str<'a>(value: Option<&'a str>, field: &str) -> Result<&'a str, LixE
     })
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn row_ref<'a>(
+        entity_pk: &'a EntityPk,
+        snapshot_content: Option<&'a str>,
+        metadata: Option<&'a str>,
+    ) -> UntrackedStateRowRef<'a> {
+        UntrackedStateRowRef {
+            entity_pk,
+            schema_key: "schema.unicode",
+            file_id: Some("file-1"),
+            snapshot_content,
+            metadata,
+            created_at: "2026-05-19T00:00:00.000Z",
+            updated_at: "2026-05-19T00:00:01.000Z",
+            global: false,
+            branch_id: "branch-1",
+        }
+    }
+
+    fn identity(entity_pk: EntityPk) -> UntrackedStateIdentity {
+        UntrackedStateIdentity {
+            branch_id: "branch-1".to_string(),
+            schema_key: "schema.unicode".to_string(),
+            entity_pk,
+            file_id: Some("file-1".to_string()),
+        }
+    }
+
+    #[test]
+    fn payload_v1_roundtrips_with_key_identity() {
+        let entity_pk = EntityPk::tuple(vec!["id-1".to_string(), "東京".to_string()])
+            .expect("entity primary key should build");
+        let bytes = encode_payload_ref(row_ref(
+            &entity_pk,
+            Some("{\"hello\":\"world\"}"),
+            Some("{\"meta\":true}"),
+        ))
+        .expect("payload should encode");
+
+        assert_eq!(&bytes[..4], b"LXUP");
+        assert_eq!(bytes[4], 1);
+
+        let decoded = decode_payload_with_identity(identity(entity_pk.clone()), &bytes)
+            .expect("payload should decode");
+        assert_eq!(decoded.entity_pk, entity_pk);
+        assert_eq!(decoded.schema_key, "schema.unicode");
+        assert_eq!(decoded.file_id.as_deref(), Some("file-1"));
+        assert_eq!(
+            decoded.snapshot_content.as_deref(),
+            Some("{\"hello\":\"world\"}")
+        );
+        assert_eq!(decoded.metadata.as_deref(), Some("{\"meta\":true}"));
+        assert_eq!(decoded.created_at, "2026-05-19T00:00:00.000Z");
+        assert_eq!(decoded.updated_at, "2026-05-19T00:00:01.000Z");
+        assert!(!decoded.global);
+        assert_eq!(decoded.branch_id, "branch-1");
+    }
+
+    #[test]
+    fn payload_v1_roundtrips_absent_optional_fields() {
+        let entity_pk = EntityPk::single("id-1");
+        let bytes =
+            encode_payload_ref(row_ref(&entity_pk, None, None)).expect("payload should encode");
+        let decoded = decode_payload_with_identity(identity(entity_pk), &bytes)
+            .expect("payload should decode");
+        assert_eq!(decoded.snapshot_content, None);
+        assert_eq!(decoded.metadata, None);
+    }
+
+    #[test]
+    fn payload_decode_rejects_invalid_identifier() {
+        let entity_pk = EntityPk::single("id-1");
+        let error = decode_payload_with_identity(identity(entity_pk), b"LXUSnot-payload")
+            .expect_err("old full-row values are not accepted in v1 payload storage");
+        assert!(error.to_string().contains("invalid payload identifier"));
+    }
+
+    #[test]
+    fn payload_decode_rejects_unknown_branch() {
+        let entity_pk = EntityPk::single("id-1");
+        let mut bytes = encode_payload_ref(row_ref(&entity_pk, Some("{}"), None))
+            .expect("payload should encode");
+        bytes[4] = 2;
+        let error = decode_payload_with_identity(identity(entity_pk), &bytes)
+            .expect_err("unknown payload branch should fail");
+        assert!(error.to_string().contains("unsupported branch 2"));
+    }
+
+    #[test]
+    fn payload_decode_rejects_trailing_bytes() {
+        let entity_pk = EntityPk::single("id-1");
+        let mut bytes = encode_payload_ref(row_ref(&entity_pk, Some("{}"), None))
+            .expect("payload should encode");
+        bytes.push(0);
+        let error = decode_payload_with_identity(identity(entity_pk), &bytes)
+            .expect_err("trailing bytes should fail");
+        assert!(error.to_string().contains("trailing bytes"));
+    }
+
+    #[test]
+    fn payload_decode_rejects_truncated_string() {
+        let entity_pk = EntityPk::single("id-1");
+        let mut bytes = encode_payload_ref(row_ref(&entity_pk, Some("{}"), None))
+            .expect("payload should encode");
+        bytes.truncate(bytes.len() - 2);
+        let error = decode_payload_with_identity(identity(entity_pk), &bytes)
+            .expect_err("truncated payload should fail");
+        assert!(error.to_string().contains("truncated"));
+    }
+}
+
+#[allow(dead_code)]
 mod flatbuffer {
     #[derive(Copy, Clone, PartialEq)]
     pub(super) struct UntrackedStateRow<'a> {
@@ -105,7 +411,7 @@ mod flatbuffer {
     }
 
     impl<'a> UntrackedStateRow<'a> {
-        const VT_ENTITY_ID: flatbuffers::VOffsetT = 4;
+        const VT_ENTITY_PK: flatbuffers::VOffsetT = 4;
         const VT_SCHEMA_KEY: flatbuffers::VOffsetT = 6;
         const VT_FILE_ID: flatbuffers::VOffsetT = 8;
         const VT_SNAPSHOT_CONTENT: flatbuffers::VOffsetT = 10;
@@ -113,13 +419,13 @@ mod flatbuffer {
         const VT_CREATED_AT: flatbuffers::VOffsetT = 14;
         const VT_UPDATED_AT: flatbuffers::VOffsetT = 16;
         const VT_GLOBAL: flatbuffers::VOffsetT = 18;
-        const VT_VERSION_ID: flatbuffers::VOffsetT = 20;
+        const VT_BRANCH_ID: flatbuffers::VOffsetT = 20;
 
         #[inline]
-        pub(super) fn entity_id(&self) -> Option<&'a str> {
+        pub(super) fn entity_pk(&self) -> Option<&'a str> {
             unsafe {
                 self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_ENTITY_ID, None)
+                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_ENTITY_PK, None)
             }
         }
 
@@ -176,10 +482,10 @@ mod flatbuffer {
         }
 
         #[inline]
-        pub(super) fn version_id(&self) -> Option<&'a str> {
+        pub(super) fn branch_id(&self) -> Option<&'a str> {
             unsafe {
                 self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_VERSION_ID, None)
+                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_BRANCH_ID, None)
             }
         }
     }
@@ -193,8 +499,8 @@ mod flatbuffer {
             verifier
                 .visit_table(position)?
                 .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "entity_id",
-                    Self::VT_ENTITY_ID,
+                    "entity_pk",
+                    Self::VT_ENTITY_PK,
                     true,
                 )?
                 .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
@@ -229,8 +535,8 @@ mod flatbuffer {
                 )?
                 .visit_field::<bool>("global", Self::VT_GLOBAL, false)?
                 .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "version_id",
-                    Self::VT_VERSION_ID,
+                    "branch_id",
+                    Self::VT_BRANCH_ID,
                     true,
                 )?
                 .finish();
@@ -238,8 +544,9 @@ mod flatbuffer {
         }
     }
 
+    #[cfg_attr(not(feature = "storage-benches"), allow(dead_code))]
     pub(super) struct UntrackedStateRowArgs<'a> {
-        pub(super) entity_id: flatbuffers::WIPOffset<&'a str>,
+        pub(super) entity_pk: flatbuffers::WIPOffset<&'a str>,
         pub(super) schema_key: flatbuffers::WIPOffset<&'a str>,
         pub(super) file_id: Option<flatbuffers::WIPOffset<&'a str>>,
         pub(super) snapshot_content: Option<flatbuffers::WIPOffset<&'a str>>,
@@ -247,17 +554,18 @@ mod flatbuffer {
         pub(super) created_at: flatbuffers::WIPOffset<&'a str>,
         pub(super) updated_at: flatbuffers::WIPOffset<&'a str>,
         pub(super) global: bool,
-        pub(super) version_id: flatbuffers::WIPOffset<&'a str>,
+        pub(super) branch_id: flatbuffers::WIPOffset<&'a str>,
     }
 
+    #[cfg_attr(not(feature = "storage-benches"), allow(dead_code))]
     pub(super) fn create_untracked_state_row<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
         builder: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
         args: &'args UntrackedStateRowArgs<'args>,
     ) -> flatbuffers::WIPOffset<UntrackedStateRow<'bldr>> {
         let start = builder.start_table();
         builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            UntrackedStateRow::VT_VERSION_ID,
-            args.version_id,
+            UntrackedStateRow::VT_BRANCH_ID,
+            args.branch_id,
         );
         builder.push_slot::<bool>(UntrackedStateRow::VT_GLOBAL, args.global, false);
         builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
@@ -291,8 +599,8 @@ mod flatbuffer {
             args.schema_key,
         );
         builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            UntrackedStateRow::VT_ENTITY_ID,
-            args.entity_id,
+            UntrackedStateRow::VT_ENTITY_PK,
+            args.entity_pk,
         );
         let offset = builder.end_table(start);
         flatbuffers::WIPOffset::new(offset.value())

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

@@ -1,4 +1,4 @@
-use crate::storage::{StorageReader, StorageWriteSet};
+use crate::storage::{StorageRead, StorageWriteSet};
 use crate::untracked_state::{
     MaterializedUntrackedStateRow, UntrackedStateIdentity, UntrackedStateIdentityRef,
     UntrackedStateRowRef, UntrackedStateRowRequest, UntrackedStateScanRequest,
@@ -23,7 +23,7 @@ impl UntrackedStateContext {
     /// The caller decides which KV store supplies visibility for the read.
     pub(crate) fn reader<S>(&self, store: S) -> UntrackedStateStoreReader<S>
     where
-        S: StorageReader,
+        S: StorageRead + Send + Sync,
     {
         UntrackedStateStoreReader { store }
     }
@@ -44,20 +44,20 @@ pub(crate) struct UntrackedStateStoreReader<S> {
 
 impl<S> UntrackedStateStoreReader<S>
 where
-    S: StorageReader,
+    S: StorageRead + Send + Sync,
 {
     pub(crate) async fn scan_rows(
         &mut self,
         request: &UntrackedStateScanRequest,
     ) -> Result<Vec<MaterializedUntrackedStateRow>, LixError> {
-        crate::untracked_state::storage::scan_rows(&mut self.store, request).await
+        crate::untracked_state::storage::scan_rows(&self.store, request).await
     }
 
     pub(crate) async fn load_row(
         &mut self,
         request: &UntrackedStateRowRequest,
     ) -> Result<Option<MaterializedUntrackedStateRow>, LixError> {
-        crate::untracked_state::storage::load_row(&mut self.store, request).await
+        crate::untracked_state::storage::load_row(&self.store, request).await
     }
 
     pub(crate) async fn existing_identities<'a, I>(
@@ -67,7 +67,7 @@ where
     where
         I: IntoIterator<Item = UntrackedStateIdentityRef<'a>>,
     {
-        crate::untracked_state::storage::existing_identities(&mut self.store, identities).await
+        crate::untracked_state::storage::existing_identities(&self.store, identities).await
     }
 }
 
@@ -89,7 +89,7 @@ impl UntrackedStateWriter<'_> {
     }
 
     /// Removes untracked rows by exact identity.
-    pub(crate) fn stage_delete_rows<'a, I>(&mut self, identities: I)
+    pub(crate) fn stage_delete_rows<'a, I>(&mut self, identities: I) -> Result<(), LixError>
     where
         I: IntoIterator<Item = UntrackedStateIdentityRef<'a>>,
     {

package/dist-engine-src/src/untracked_state/materialization.rs

@@ -17,7 +17,7 @@ pub(crate) fn materialize_row(
         None
     };
     Ok(MaterializedUntrackedStateRow {
-        entity_id: row.entity_id,
+        entity_pk: row.entity_pk,
         schema_key: row.schema_key,
         file_id: row.file_id,
         snapshot_content,
@@ -26,7 +26,7 @@ pub(crate) fn materialize_row(
         created_at: row.created_at,
         updated_at: row.updated_at,
         global: row.global,
-        version_id: row.version_id,
+        branch_id: row.branch_id,
     })
 }
 

package/dist-engine-src/src/untracked_state/mod.rs

@@ -1,4 +1,4 @@
-mod codec;
+pub(crate) mod codec;
 mod context;
 mod materialization;
 pub(crate) mod storage;