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

package/dist-engine-src/src/entity_identity.rs

@@ -1,39 +1,25 @@
-use base64::Engine as _;
 use serde_json::Value as JsonValue;
 
 use crate::common::json_pointer_get;
 use crate::LixError;
 
-const COMPOSITE_ENTITY_ID_PREFIX: &str = "pk:v1:";
-
 /// Logical entity identity derived from a schema primary key.
 ///
-/// Keep this as typed tuple data inside engine2. The string projection exists
-/// only for SQL/canonical boundaries that still expose a single `entity_id`.
+/// Keep this as typed tuple data inside engine. SQL `entity_id` surfaces
+/// should use the JSON-array projection.
 #[derive(
     Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
 )]
 pub(crate) struct EntityIdentity {
-    pub(crate) parts: Vec<EntityIdentityPart>,
-}
-
-#[derive(
-    Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
-)]
-#[serde(tag = "type", content = "value")]
-pub(crate) enum EntityIdentityPart {
-    String(String),
-    Bool(bool),
-    Number(String),
+    pub(crate) parts: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum EntityIdentityError {
     EmptyPrimaryKey,
     EmptyPrimaryKeyPath { index: usize },
-    MissingPrimaryKeyValue { index: usize },
-    NullPrimaryKeyValue { index: usize },
     EmptyPrimaryKeyValue { index: usize },
+    MissingPrimaryKeyValue { index: usize },
     UnsupportedPrimaryKeyValue { index: usize },
     InvalidEncodedEntityIdentity,
 }
@@ -50,27 +36,24 @@ impl std::fmt::Display for EntityIdentityError {
                     "primary-key path at index {index} must not be empty"
                 )
             }
-            Self::MissingPrimaryKeyValue { index } => {
-                write!(formatter, "primary-key value at index {index} is missing")
-            }
-            Self::NullPrimaryKeyValue { index } => {
-                write!(
-                    formatter,
-                    "primary-key value at index {index} must not be null"
-                )
-            }
             Self::EmptyPrimaryKeyValue { index } => {
                 write!(
                     formatter,
-                    "primary-key string value at index {index} must not be empty"
+                    "primary-key value at index {index} must not be empty"
                 )
             }
+            Self::MissingPrimaryKeyValue { index } => {
+                write!(formatter, "primary-key value at index {index} is missing")
+            }
             Self::UnsupportedPrimaryKeyValue { index } => write!(
                 formatter,
-                "primary-key value at index {index} must be a string, number, or boolean"
+                "primary-key value at index {index} must be a JSON string"
             ),
             Self::InvalidEncodedEntityIdentity => {
-                write!(formatter, "encoded entity identity is invalid")
+                write!(
+                    formatter,
+                    "encoded entity identity must be a non-empty JSON array of strings"
+                )
             }
         }
     }
@@ -79,15 +62,18 @@ impl std::fmt::Display for EntityIdentityError {
 impl EntityIdentity {
     pub(crate) fn single(value: impl Into<String>) -> Self {
         Self {
-            parts: vec![EntityIdentityPart::String(value.into())],
+            parts: vec![value.into()],
         }
     }
 
     #[cfg(test)]
-    pub(crate) fn tuple(parts: Vec<EntityIdentityPart>) -> Result<Self, EntityIdentityError> {
+    pub(crate) fn tuple(parts: Vec<String>) -> Result<Self, EntityIdentityError> {
         if parts.is_empty() {
             return Err(EntityIdentityError::EmptyPrimaryKey);
         }
+        if let Some((index, _)) = parts.iter().enumerate().find(|(_, part)| part.is_empty()) {
+            return Err(EntityIdentityError::EmptyPrimaryKeyValue { index });
+        }
         Ok(Self { parts })
     }
 
@@ -107,65 +93,110 @@ impl EntityIdentity {
             let Some(value) = json_pointer_get(snapshot, path) else {
                 return Err(EntityIdentityError::MissingPrimaryKeyValue { index });
             };
-            parts.push(EntityIdentityPart::from_json_value(value, index)?);
+            parts.push(string_part_from_json_value(value, index)?);
         }
 
         Ok(Self { parts })
     }
 
-    pub(crate) fn as_string(&self) -> Result<String, LixError> {
+    pub(crate) fn as_json_array_value(&self) -> Result<JsonValue, LixError> {
         if self.parts.is_empty() {
             return Err(LixError::unknown(
                 "entity identity must contain at least one primary-key part",
             ));
         }
 
-        if let [EntityIdentityPart::String(value)] = self.parts.as_slice() {
-            return Ok(value.clone());
+        Ok(JsonValue::Array(
+            self.parts
+                .iter()
+                .map(|part| JsonValue::String(part.clone()))
+                .collect(),
+        ))
+    }
+
+    pub(crate) fn as_json_array_text(&self) -> Result<String, LixError> {
+        serde_json::to_string(&self.as_json_array_value()?).map_err(|error| {
+            LixError::unknown(format!("failed to encode entity id as JSON: {error}"))
+        })
+    }
+
+    pub(crate) fn as_single_string(&self) -> Result<&str, LixError> {
+        if self.parts.is_empty() {
+            return Err(LixError::unknown(
+                "entity identity must contain at least one primary-key part",
+            ));
         }
 
-        let payload = serde_json::to_vec(self).map_err(|error| {
-            LixError::unknown(format!(
-                "failed to encode composite entity identity: {error}"
-            ))
-        })?;
-        Ok(format!(
-            "{COMPOSITE_ENTITY_ID_PREFIX}{}",
-            base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(payload)
+        if let [value] = self.parts.as_slice() {
+            return Ok(value.as_str());
+        }
+
+        Err(LixError::unknown(
+            "entity identity is not a single string primary-key tuple",
         ))
     }
 
-    pub(crate) fn from_string(entity_id: &str) -> Result<Self, EntityIdentityError> {
-        if let Some(encoded) = entity_id.strip_prefix(COMPOSITE_ENTITY_ID_PREFIX) {
-            let payload = base64::engine::general_purpose::URL_SAFE_NO_PAD
-                .decode(encoded)
-                .map_err(|_| EntityIdentityError::InvalidEncodedEntityIdentity)?;
-            let identity = serde_json::from_slice::<Self>(&payload)
-                .map_err(|_| EntityIdentityError::InvalidEncodedEntityIdentity)?;
-            if identity.parts.is_empty() {
-                return Err(EntityIdentityError::InvalidEncodedEntityIdentity);
-            }
-            return Ok(identity);
+    pub(crate) fn as_single_string_owned(&self) -> Result<String, LixError> {
+        Ok(self.as_single_string()?.to_owned())
+    }
+
+    pub(crate) fn from_json_array_text(entity_id: &str) -> Result<Self, EntityIdentityError> {
+        let value = serde_json::from_str::<JsonValue>(entity_id)
+            .map_err(|_| EntityIdentityError::InvalidEncodedEntityIdentity)?;
+        Self::from_json_array_value(&value)
+    }
+
+    pub(crate) fn from_json_array_value(
+        entity_id: &JsonValue,
+    ) -> Result<Self, EntityIdentityError> {
+        let JsonValue::Array(values) = entity_id else {
+            return Err(EntityIdentityError::InvalidEncodedEntityIdentity);
+        };
+        if values.is_empty() {
+            return Err(EntityIdentityError::EmptyPrimaryKey);
         }
 
-        Ok(Self::single(entity_id))
+        let mut parts = Vec::with_capacity(values.len());
+        for (index, value) in values.iter().enumerate() {
+            parts.push(string_part_from_json_value(value, index)?);
+        }
+        Ok(Self { parts })
     }
 }
 
-impl EntityIdentityPart {
-    fn from_json_value(value: &JsonValue, index: usize) -> Result<Self, EntityIdentityError> {
-        match value {
-            JsonValue::Null => Err(EntityIdentityError::NullPrimaryKeyValue { index }),
-            JsonValue::String(value) if value.is_empty() => {
-                Err(EntityIdentityError::EmptyPrimaryKeyValue { index })
-            }
-            JsonValue::String(value) => Ok(Self::String(value.clone())),
-            JsonValue::Bool(value) => Ok(Self::Bool(*value)),
-            JsonValue::Number(value) => Ok(Self::Number(value.to_string())),
-            JsonValue::Array(_) | JsonValue::Object(_) => {
-                Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index })
+fn string_part_from_json_value(
+    value: &JsonValue,
+    index: usize,
+) -> Result<String, EntityIdentityError> {
+    match value {
+        JsonValue::String(value) if value.is_empty() => {
+            Err(EntityIdentityError::EmptyPrimaryKeyValue { index })
+        }
+        JsonValue::String(value) => Ok(value.clone()),
+        _ => Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index }),
+    }
+}
+
+pub(crate) fn canonical_json_text(value: &JsonValue) -> serde_json::Result<String> {
+    serde_json::to_string(&canonical_json_value(value))
+}
+
+fn canonical_json_value(value: &JsonValue) -> JsonValue {
+    match value {
+        JsonValue::Array(values) => {
+            JsonValue::Array(values.iter().map(canonical_json_value).collect())
+        }
+        JsonValue::Object(object) => {
+            let mut entries = object.iter().collect::<Vec<_>>();
+            entries.sort_by(|(left, _), (right, _)| left.cmp(right));
+
+            let mut canonical = serde_json::Map::new();
+            for (key, value) in entries {
+                canonical.insert(key.clone(), canonical_json_value(value));
             }
+            JsonValue::Object(canonical)
         }
+        _ => value.clone(),
     }
 }
 
@@ -176,70 +207,101 @@ mod tests {
     use super::*;
 
     #[test]
-    fn single_string_identity_projects_to_plain_entity_id() {
+    fn single_string_identity_projects_to_single_string() {
         let identity = EntityIdentity::single("plain-id");
 
         assert_eq!(
-            identity.as_string().expect("projection should work"),
+            identity.as_single_string().expect("projection should work"),
             "plain-id"
         );
     }
 
     #[test]
-    fn composite_identity_projects_to_versioned_opaque_entity_id() {
-        let identity = EntityIdentity::tuple(vec![
-            EntityIdentityPart::String("namespace".to_string()),
-            EntityIdentityPart::String("key".to_string()),
-        ])
-        .expect("tuple identity");
-
-        let encoded = identity.as_string().expect("projection should work");
+    fn single_identity_projects_to_json_array_entity_id() {
+        let identity = EntityIdentity::single("plain-id");
 
-        assert!(encoded.starts_with(COMPOSITE_ENTITY_ID_PREFIX));
-        assert!(!encoded.contains("namespace~key"));
+        assert_eq!(
+            identity
+                .as_json_array_text()
+                .expect("projection should work"),
+            "[\"plain-id\"]"
+        );
     }
 
     #[test]
-    fn composite_identity_roundtrips_from_string() {
-        let identity = EntityIdentity::tuple(vec![
-            EntityIdentityPart::String("namespace".to_string()),
-            EntityIdentityPart::Number("42".to_string()),
-            EntityIdentityPart::Bool(true),
-        ])
-        .expect("tuple identity");
+    fn composite_identity_projects_to_json_array_entity_id() {
+        let identity = EntityIdentity::tuple(vec!["namespace".to_string(), "42".to_string()])
+            .expect("tuple identity");
 
-        let encoded = identity.as_string().expect("projection should work");
+        assert_eq!(
+            identity
+                .as_json_array_text()
+                .expect("projection should work"),
+            "[\"namespace\",\"42\"]"
+        );
+    }
+
+    #[test]
+    fn entity_id_json_array_roundtrips() {
+        let identity = EntityIdentity::tuple(vec!["namespace".to_string(), "42".to_string()])
+            .expect("tuple identity");
+        let encoded = identity
+            .as_json_array_text()
+            .expect("projection should work");
 
         assert_eq!(
-            EntityIdentity::from_string(&encoded).expect("decode should work"),
+            EntityIdentity::from_json_array_text(&encoded).expect("decode should work"),
             identity
         );
     }
 
     #[test]
-    fn composite_identity_does_not_collide_on_delimiter_like_values() {
-        let left = EntityIdentity::tuple(vec![
-            EntityIdentityPart::String("a~b".to_string()),
-            EntityIdentityPart::String("1".to_string()),
-        ])
-        .expect("left tuple identity");
-        let right = EntityIdentity::tuple(vec![
-            EntityIdentityPart::String("a".to_string()),
-            EntityIdentityPart::String("b~1".to_string()),
-        ])
-        .expect("right tuple identity");
+    fn entity_id_json_array_rejects_empty_string_part() {
+        assert_eq!(
+            EntityIdentity::from_json_array_text("[\"\"]"),
+            Err(EntityIdentityError::EmptyPrimaryKeyValue { index: 0 })
+        );
+    }
+
+    #[test]
+    fn tuple_rejects_empty_string_part() {
+        assert_eq!(
+            EntityIdentity::tuple(vec!["namespace".to_string(), "".to_string()]),
+            Err(EntityIdentityError::EmptyPrimaryKeyValue { index: 1 })
+        );
+    }
+
+    #[test]
+    fn entity_id_json_array_does_not_collide_on_delimiter_like_values() {
+        let left = EntityIdentity::tuple(vec!["a~b".to_string(), "c".to_string()])
+            .expect("left tuple identity");
+        let right = EntityIdentity::tuple(vec!["a".to_string(), "b~c".to_string()])
+            .expect("right tuple identity");
 
         assert_ne!(
-            left.as_string().expect("left should encode"),
-            right.as_string().expect("right should encode")
+            left.as_json_array_text().expect("left should encode"),
+            right.as_json_array_text().expect("right should encode")
         );
     }
 
     #[test]
-    fn from_string_treats_plain_string_as_single_string_identity() {
-        assert_eq!(
-            EntityIdentity::single("plain-id"),
-            EntityIdentity::single("plain-id")
+    fn composite_identity_rejects_single_string_projection() {
+        let identity = EntityIdentity::tuple(vec!["namespace".to_string(), "42".to_string()])
+            .expect("tuple identity");
+
+        assert!(identity.as_single_string().is_err());
+    }
+
+    #[test]
+    fn composite_identity_does_not_collide_on_delimiter_like_values() {
+        let left = EntityIdentity::tuple(vec!["a~b".to_string(), "1".to_string()])
+            .expect("left tuple identity");
+        let right = EntityIdentity::tuple(vec!["a".to_string(), "b~1".to_string()])
+            .expect("right tuple identity");
+
+        assert_ne!(
+            left.as_json_array_text().expect("left should encode"),
+            right.as_json_array_text().expect("right should encode")
         );
     }
 
@@ -247,32 +309,90 @@ mod tests {
     fn from_primary_key_paths_derives_ordered_parts() {
         let snapshot = json!({
             "namespace": "messages",
-            "index": 7,
-            "active": true
+            "locale": "en"
         });
 
         let identity = EntityIdentity::from_primary_key_paths(
             &snapshot,
-            &[
-                vec!["namespace".to_string()],
-                vec!["index".to_string()],
-                vec!["active".to_string()],
-            ],
+            &[vec!["namespace".to_string()], vec!["locale".to_string()]],
         )
         .expect("primary key should derive");
 
         assert_eq!(
             identity,
             EntityIdentity {
-                parts: vec![
-                    EntityIdentityPart::String("messages".to_string()),
-                    EntityIdentityPart::Number("7".to_string()),
-                    EntityIdentityPart::Bool(true),
-                ],
+                parts: vec!["messages".to_string(), "en".to_string()],
             }
         );
     }
 
+    #[test]
+    fn entity_id_json_array_rejects_non_string_parts() {
+        assert_eq!(
+            EntityIdentity::from_json_array_text("[\"namespace\",42]"),
+            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 1 })
+        );
+        assert_eq!(
+            EntityIdentity::from_json_array_text("[\"namespace\",null]"),
+            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 1 })
+        );
+        assert_eq!(
+            EntityIdentity::from_json_array_text("[[\"nested\"]]"),
+            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 0 })
+        );
+    }
+
+    #[test]
+    fn from_primary_key_paths_rejects_non_string_parts() {
+        let snapshot = json!({
+            "namespace": "messages",
+            "index": 7
+        });
+
+        assert_eq!(
+            EntityIdentity::from_primary_key_paths(
+                &snapshot,
+                &[vec!["namespace".to_string()], vec!["index".to_string()],],
+            ),
+            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 1 })
+        );
+    }
+
+    #[test]
+    fn from_primary_key_paths_rejects_empty_string_parts() {
+        let snapshot = json!({
+            "namespace": "messages",
+            "id": ""
+        });
+
+        assert_eq!(
+            EntityIdentity::from_primary_key_paths(
+                &snapshot,
+                &[vec!["namespace".to_string()], vec!["id".to_string()],],
+            ),
+            Err(EntityIdentityError::EmptyPrimaryKeyValue { index: 1 })
+        );
+    }
+
+    #[test]
+    fn from_primary_key_paths_rejects_nested_json_parts() {
+        let snapshot = json!({
+            "entity_id": ["welcome.title", "en"],
+            "schema_key": "message"
+        });
+
+        assert_eq!(
+            EntityIdentity::from_primary_key_paths(
+                &snapshot,
+                &[
+                    vec!["entity_id".to_string()],
+                    vec!["schema_key".to_string()],
+                ],
+            ),
+            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 0 })
+        );
+    }
+
     #[test]
     fn from_primary_key_paths_rejects_missing_parts() {
         let snapshot = json!({ "id": "a" });

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

@@ -2,9 +2,8 @@ use crate::functions::{
     state, DeterministicFunctionProvider, DeterministicSequence, FunctionProvider,
     FunctionProviderHandle, SharedFunctionProvider, SystemFunctionProvider,
 };
-use crate::json_store::JsonStoreWriter;
-use crate::live_state::{LiveStateReader, LiveStateWriter};
-use crate::storage::{StorageReader, StorageWriteSet};
+use crate::live_state::LiveStateReader;
+use crate::storage::StorageWriteSet;
 use crate::LixError;
 
 /// Execution-scoped runtime function context.
@@ -47,7 +46,7 @@ impl FunctionContext {
         })
     }
 
-    /// Returns the engine2-owned provider used by SQL and transaction staging.
+    /// Returns the engine-owned provider used by SQL and transaction staging.
     pub(crate) fn provider(&self) -> FunctionProviderHandle {
         self.functions.clone()
     }
@@ -56,23 +55,16 @@ impl FunctionContext {
     ///
     /// System functions report no sequence state, so this is a no-op when
     /// deterministic mode is disabled.
-    pub(crate) async fn stage_persist_if_needed<S>(
+    pub(crate) async fn stage_persist_if_needed(
         &self,
-        writer: &mut LiveStateWriter<S>,
         writes: &mut StorageWriteSet,
-        json_writer: &mut JsonStoreWriter,
-    ) -> Result<(), LixError>
-    where
-        S: StorageReader,
-    {
+    ) -> Result<(), LixError> {
         let Some(highest_seen) = self.functions.deterministic_sequence_persist_highest_seen()
         else {
             return Ok(());
         };
         state::stage_sequence(
-            writer,
             writes,
-            json_writer,
             DeterministicSequence { highest_seen },
             &self.bookkeeping_timestamp,
         )
@@ -87,7 +79,7 @@ mod tests {
     use crate::backend::testing::UnitTestBackend;
     use crate::functions::state::{DETERMINISTIC_MODE_KEY, DETERMINISTIC_SEQUENCE_KEY};
     use crate::functions::{state::load_sequence, DeterministicSequence};
-    use crate::live_state::{LiveStateContext, LiveStateRow};
+    use crate::live_state::LiveStateContext;
     use crate::storage::StorageContext;
     use crate::GLOBAL_VERSION_ID;
 
@@ -97,7 +89,7 @@ mod tests {
         LiveStateContext::new(
             crate::tracked_state::TrackedStateContext::new(),
             crate::untracked_state::UntrackedStateContext::new(),
-            crate::commit_graph::CommitGraphContext::new(crate::changelog::ChangelogContext::new()),
+            crate::commit_graph::CommitGraphContext::new(),
         )
     }
 
@@ -128,7 +120,6 @@ mod tests {
         crate::test_support::seed_global_version_head(storage.clone()).await;
         write_key_value(
             storage.clone(),
-            &live_state,
             DETERMINISTIC_MODE_KEY,
             serde_json::json!({
                 "enabled": true,
@@ -163,7 +154,6 @@ mod tests {
         crate::test_support::seed_global_version_head(storage.clone()).await;
         write_key_value(
             storage.clone(),
-            &live_state,
             DETERMINISTIC_MODE_KEY,
             serde_json::json!({
                 "enabled": true,
@@ -172,7 +162,6 @@ mod tests {
         .await;
         write_key_value(
             storage.clone(),
-            &live_state,
             DETERMINISTIC_SEQUENCE_KEY,
             serde_json::json!(41),
         )
@@ -204,7 +193,6 @@ mod tests {
         crate::test_support::seed_global_version_head(storage.clone()).await;
         write_key_value(
             storage.clone(),
-            &live_state,
             DETERMINISTIC_MODE_KEY,
             serde_json::json!({
                 "enabled": true,
@@ -225,13 +213,8 @@ mod tests {
             .await
             .expect("transaction should open");
         let mut writes = StorageWriteSet::new();
-        let mut json_writer = crate::json_store::JsonStoreContext::new().writer();
         context
-            .stage_persist_if_needed(
-                &mut live_state.writer(tx.as_mut()),
-                &mut writes,
-                &mut json_writer,
-            )
+            .stage_persist_if_needed(&mut writes)
             .await
             .expect("sequence should stage");
         writes
@@ -255,18 +238,13 @@ mod tests {
             .await
             .expect("runtime context should prepare");
 
-        let mut tx = storage
+        let tx = storage
             .begin_write_transaction()
             .await
             .expect("transaction should open");
         let mut writes = StorageWriteSet::new();
-        let mut json_writer = crate::json_store::JsonStoreContext::new().writer();
         context
-            .stage_persist_if_needed(
-                &mut live_state.writer(tx.as_mut()),
-                &mut writes,
-                &mut json_writer,
-            )
+            .stage_persist_if_needed(&mut writes)
             .await
             .expect("persist should no-op");
         assert!(writes.is_empty());
@@ -279,12 +257,7 @@ mod tests {
         assert_eq!(sequence, DeterministicSequence::uninitialized());
     }
 
-    async fn write_key_value(
-        storage: StorageContext,
-        live_state: &LiveStateContext,
-        key: &str,
-        value: serde_json::Value,
-    ) {
+    async fn write_key_value(storage: StorageContext, key: &str, value: serde_json::Value) {
         let mut tx = storage
             .begin_write_transaction()
             .await
@@ -294,30 +267,22 @@ mod tests {
             "value": value,
         }))
         .expect("snapshot should serialize");
-        let row = LiveStateRow {
+        let mut writes = StorageWriteSet::new();
+        let row = crate::untracked_state::UntrackedStateRow {
             entity_id: crate::entity_identity::EntityIdentity::single(key),
             schema_key: "lix_key_value".to_string(),
             file_id: None,
             snapshot_content: Some(snapshot_content),
             metadata: None,
-            schema_version: "1".to_string(),
             created_at: "1970-01-01T00:00:00.000Z".to_string(),
             updated_at: "1970-01-01T00:00:00.000Z".to_string(),
             global: true,
-            change_id: None,
-            commit_id: None,
-            untracked: true,
             version_id: GLOBAL_VERSION_ID.to_string(),
         };
-        let mut writes = StorageWriteSet::new();
-        let mut json_writer = crate::json_store::JsonStoreContext::new().writer();
-        {
-            let mut writer = live_state.writer(tx.as_mut());
-            writer
-                .stage_rows(&mut writes, &mut json_writer, &[row])
-                .await
-                .expect("test key-value should stage");
-        }
+        crate::untracked_state::UntrackedStateContext::new()
+            .writer(&mut writes)
+            .stage_rows(std::iter::once(row.as_ref()))
+            .expect("test key-value should stage");
         writes
             .apply(&mut tx.as_mut())
             .await

package/dist-engine-src/src/functions/deterministic.rs

@@ -2,7 +2,7 @@ use crate::functions::FunctionProvider;
 
 const DETERMINISTIC_UUID_COUNTER_MASK: u64 = 0x0000_FFFF_FFFF_FFFF;
 
-/// Deterministic function provider for engine2 execution.
+/// Deterministic function provider for engine execution.
 ///
 /// The provider is pure runtime state: it does not load or persist the sequence
 /// itself. Session/transaction code owns that boundary so tests can decide when