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

package/dist-engine-src/src/plugin/install.rs

@@ -44,7 +44,7 @@ const FILESYSTEM_BINARY_BLOB_REF_SCHEMA_KEY: &str = "lix_binary_blob_ref";
 pub(crate) struct PluginInstallWriteContext {
     function_bindings: PreparedWriteFunctionBindings,
     public_surface_registry: SurfaceRegistry,
-    target_version_id: String,
+    target_branch_id: String,
     active_account_ids: Vec<String>,
     origin_key: Option<String>,
 }
@@ -53,21 +53,21 @@ impl PluginInstallWriteContext {
     pub(crate) fn new(
         function_bindings: PreparedWriteFunctionBindings,
         public_surface_registry: SurfaceRegistry,
-        target_version_id: impl Into<String>,
+        target_branch_id: impl Into<String>,
         active_account_ids: Vec<String>,
         origin_key: Option<String>,
     ) -> Self {
         Self {
             function_bindings,
             public_surface_registry,
-            target_version_id: target_version_id.into(),
+            target_branch_id: target_branch_id.into(),
             active_account_ids,
             origin_key,
         }
     }
 
-    fn target_version_id(&self) -> &str {
-        &self.target_version_id
+    fn target_branch_id(&self) -> &str {
+        &self.target_branch_id
     }
 }
 
@@ -140,7 +140,7 @@ async fn install_plugin_with_writer(
 
 #[derive(Clone)]
 struct RegisteredSchemaRowSpec {
-    entity_id: String,
+    entity_pk: String,
     registered_schema_key: String,
     snapshot: JsonValue,
     schema_json: JsonValue,
@@ -152,7 +152,7 @@ fn prepare_registered_schema_write_statement_from_schemas(
 ) -> Result<WriteCommand, LixError> {
     let target = require_resolved_surface(
         &context.public_surface_registry,
-        "lix_registered_schema_by_version",
+        "lix_registered_schema_by_branch",
     )?;
     let schema_rows = schemas
         .iter()
@@ -160,18 +160,18 @@ fn prepare_registered_schema_write_statement_from_schemas(
         .collect::<Result<Vec<_>, _>>()?;
     let intended_post_state = schema_rows
         .iter()
-        .map(|row| registered_schema_planned_row(row, context.target_version_id()))
+        .map(|row| registered_schema_planned_row(row, context.target_branch_id()))
         .collect::<Vec<_>>();
     let changes = schema_rows
         .iter()
         .map(|row| PublicChange {
-            entity_id: row.entity_id.clone(),
+            entity_pk: row.entity_pk.clone(),
             schema_key: REGISTERED_SCHEMA_STORAGE_SCHEMA_KEY.to_string(),
             file_id: None,
             plugin_key: None,
             snapshot_content: Some(row.snapshot.to_string()),
             metadata: None,
-            version_id: context.target_version_id().to_string(),
+            branch_id: context.target_branch_id().to_string(),
             origin_key: context.origin_key.clone(),
         })
         .collect::<Vec<_>>();
@@ -186,7 +186,7 @@ fn prepare_registered_schema_write_statement_from_schemas(
     prepare_public_tracked_write_statement(
         context,
         target,
-        "lix_registered_schema_by_version",
+        "lix_registered_schema_by_branch",
         intended_post_state,
         PlannedFilesystemState::default(),
         changes,
@@ -211,7 +211,7 @@ fn prepare_plugin_archive_write_statement(
     plugin_directory_id: &str,
     context: &PluginInstallWriteContext,
 ) -> Result<WriteCommand, LixError> {
-    let target = require_resolved_surface(&context.public_surface_registry, "lix_file_by_version")?;
+    let target = require_resolved_surface(&context.public_surface_registry, "lix_file_by_branch")?;
     let archive_id = plugin_storage_archive_file_id(parsed.manifest.key.as_str());
     let archive_path = plugin_storage_archive_path(parsed.manifest.key.as_str())?;
     let parsed_path = ParsedFilePath::try_from_path(&archive_path)?;
@@ -221,13 +221,13 @@ fn prepare_plugin_archive_write_statement(
         metadata: None,
         hidden: false,
     };
-    let target_version_id = context.target_version_id();
+    let target_branch_id = context.target_branch_id();
     let filesystem_state = PlannedFilesystemState {
         files: [(
-            (archive_id.clone(), target_version_id.to_string()),
+            (archive_id.clone(), target_branch_id.to_string()),
             PlannedFilesystemFile {
                 file_id: archive_id.clone(),
-                version_id: target_version_id.to_string(),
+                branch_id: target_branch_id.to_string(),
                 untracked: false,
                 descriptor: Some(descriptor.clone()),
                 metadata_patch: OptionalTextPatch::Unchanged,
@@ -239,8 +239,8 @@ fn prepare_plugin_archive_write_statement(
         .collect(),
     };
     let intended_post_state = vec![
-        plugin_archive_file_descriptor_row(&archive_id, target_version_id, &descriptor),
-        plugin_archive_binary_blob_ref_row(&archive_id, target_version_id, archive_bytes)?,
+        plugin_archive_file_descriptor_row(&archive_id, target_branch_id, &descriptor),
+        plugin_archive_binary_blob_ref_row(&archive_id, target_branch_id, archive_bytes)?,
     ];
     let changes = intended_post_state
         .iter()
@@ -250,7 +250,7 @@ fn prepare_plugin_archive_write_statement(
     prepare_public_tracked_write_statement(
         context,
         target,
-        "lix_file_by_version",
+        "lix_file_by_branch",
         intended_post_state,
         filesystem_state,
         changes,
@@ -266,7 +266,7 @@ fn registered_schema_row_spec_from_json(
     validate_lix_schema_definition(schema)?;
     let schema_key = schema_key_from_definition(schema)?;
     Ok(RegisteredSchemaRowSpec {
-        entity_id: schema_key.entity_id(),
+        entity_pk: schema_key.entity_pk(),
         registered_schema_key: schema_key.schema_key,
         snapshot: json!({ "value": schema }),
         schema_json: schema.clone(),
@@ -275,10 +275,10 @@ fn registered_schema_row_spec_from_json(
 
 fn registered_schema_planned_row(
     row: &RegisteredSchemaRowSpec,
-    target_version_id: &str,
+    target_branch_id: &str,
 ) -> PlannedStateRow {
     let mut values = BTreeMap::new();
-    values.insert("entity_id".to_string(), Value::Text(row.entity_id.clone()));
+    values.insert("entity_pk".to_string(), Value::Text(row.entity_pk.clone()));
     values.insert(
         "schema_key".to_string(),
         Value::Text(REGISTERED_SCHEMA_STORAGE_SCHEMA_KEY.to_string()),
@@ -290,13 +290,13 @@ fn registered_schema_planned_row(
         Value::Json(row.snapshot.clone()),
     );
     values.insert(
-        "version_id".to_string(),
-        Value::Text(target_version_id.to_string()),
+        "branch_id".to_string(),
+        Value::Text(target_branch_id.to_string()),
     );
     PlannedStateRow {
-        entity_id: row.entity_id.clone(),
+        entity_pk: row.entity_pk.clone(),
         schema_key: REGISTERED_SCHEMA_STORAGE_SCHEMA_KEY.to_string(),
-        version_id: Some(target_version_id.to_string()),
+        branch_id: Some(target_branch_id.to_string()),
         values,
         origin_key: None,
         tombstone: false,
@@ -305,7 +305,7 @@ fn registered_schema_planned_row(
 
 fn plugin_archive_file_descriptor_row(
     archive_id: &str,
-    target_version_id: &str,
+    target_branch_id: &str,
     descriptor: &PlannedFilesystemDescriptor,
 ) -> PlannedStateRow {
     let snapshot_content = json!({
@@ -316,7 +316,7 @@ fn plugin_archive_file_descriptor_row(
     })
     .to_string();
     let mut values = BTreeMap::new();
-    values.insert("entity_id".to_string(), Value::Text(archive_id.to_string()));
+    values.insert("entity_pk".to_string(), Value::Text(archive_id.to_string()));
     values.insert(
         "schema_key".to_string(),
         Value::Text(FILESYSTEM_DESCRIPTOR_SCHEMA_KEY.to_string()),
@@ -328,13 +328,13 @@ fn plugin_archive_file_descriptor_row(
         Value::Text(snapshot_content),
     );
     values.insert(
-        "version_id".to_string(),
-        Value::Text(target_version_id.to_string()),
+        "branch_id".to_string(),
+        Value::Text(target_branch_id.to_string()),
     );
     PlannedStateRow {
-        entity_id: archive_id.to_string(),
+        entity_pk: archive_id.to_string(),
         schema_key: FILESYSTEM_DESCRIPTOR_SCHEMA_KEY.to_string(),
-        version_id: Some(target_version_id.to_string()),
+        branch_id: Some(target_branch_id.to_string()),
         values,
         origin_key: None,
         tombstone: false,
@@ -343,7 +343,7 @@ fn plugin_archive_file_descriptor_row(
 
 fn plugin_archive_binary_blob_ref_row(
     archive_id: &str,
-    target_version_id: &str,
+    target_branch_id: &str,
     archive_bytes: &[u8],
 ) -> Result<PlannedStateRow, LixError> {
     let size_bytes = u64::try_from(archive_bytes.len()).map_err(|_| {
@@ -362,7 +362,7 @@ fn plugin_archive_binary_blob_ref_row(
     })
     .to_string();
     let mut values = BTreeMap::new();
-    values.insert("entity_id".to_string(), Value::Text(archive_id.to_string()));
+    values.insert("entity_pk".to_string(), Value::Text(archive_id.to_string()));
     values.insert(
         "schema_key".to_string(),
         Value::Text(FILESYSTEM_BINARY_BLOB_REF_SCHEMA_KEY.to_string()),
@@ -374,13 +374,13 @@ fn plugin_archive_binary_blob_ref_row(
         Value::Text(snapshot_content),
     );
     values.insert(
-        "version_id".to_string(),
-        Value::Text(target_version_id.to_string()),
+        "branch_id".to_string(),
+        Value::Text(target_branch_id.to_string()),
     );
     Ok(PlannedStateRow {
-        entity_id: archive_id.to_string(),
+        entity_pk: archive_id.to_string(),
         schema_key: FILESYSTEM_BINARY_BLOB_REF_SCHEMA_KEY.to_string(),
-        version_id: Some(target_version_id.to_string()),
+        branch_id: Some(target_branch_id.to_string()),
         values,
         origin_key: None,
         tombstone: false,
@@ -414,7 +414,7 @@ fn prepare_public_tracked_write_statement(
                     operation_kind: PreparedWriteOperationKind::Insert,
                     target,
                     on_conflict_action: None,
-                    requested_version_id: Some(context.target_version_id().to_string()),
+                    requested_branch_id: Some(context.target_branch_id().to_string()),
                     active_account_ids: context.active_account_ids.clone(),
                     origin_key: context.origin_key.clone(),
                     resolved_write_plan: Some(PreparedResolvedWritePlan {
@@ -480,7 +480,7 @@ fn semantic_effect_markers_from_changes(changes: &[PublicChange]) -> Vec<Semanti
             effect_key: "state.upsert".to_string(),
             target: format!(
                 "{}:{}@{}",
-                change.schema_key, change.entity_id, change.version_id
+                change.schema_key, change.entity_pk, change.branch_id
             ),
         })
         .collect()
@@ -488,7 +488,7 @@ fn semantic_effect_markers_from_changes(changes: &[PublicChange]) -> Vec<Semanti
 
 fn planned_row_to_public_change(row: &PlannedStateRow) -> Result<PublicChange, LixError> {
     Ok(PublicChange {
-        entity_id: row.entity_id.clone(),
+        entity_pk: row.entity_pk.clone(),
         schema_key: row.schema_key.clone(),
         file_id: planned_row_text_value(row, "file_id"),
         plugin_key: planned_row_text_value(row, "plugin_key"),
@@ -498,14 +498,14 @@ fn planned_row_to_public_change(row: &PlannedStateRow) -> Result<PublicChange, L
             planned_row_json_text_value(row, "snapshot_content")
         },
         metadata: planned_row_json_text_value(row, "metadata"),
-        version_id: row
-            .version_id
+        branch_id: row
+            .branch_id
             .clone()
-            .or_else(|| planned_row_text_value(row, "version_id"))
+            .or_else(|| planned_row_text_value(row, "branch_id"))
             .ok_or_else(|| {
                 LixError::new(
                     "LIX_ERROR_UNKNOWN",
-                    "semantic tracked write requires a concrete version_id",
+                    "semantic tracked write requires a concrete branch_id",
                 )
             })?,
         origin_key: row.origin_key.clone(),
@@ -550,11 +550,11 @@ fn semantic_idempotency_key(
 
 fn summarize_change(change: &PublicChange) -> JsonValue {
     json!({
-        "entity_id": change.entity_id,
+        "entity_pk": change.entity_pk,
         "schema_key": change.schema_key,
         "file_id": change.file_id,
         "plugin_key": change.plugin_key,
-        "version_id": change.version_id,
+        "branch_id": change.branch_id,
         "origin_key": change.origin_key,
         "snapshot_content": change.snapshot_content.as_ref().map(|snapshot| {
             stable_content_fingerprint_hex(snapshot.as_bytes())
@@ -564,9 +564,9 @@ fn summarize_change(change: &PublicChange) -> JsonValue {
 
 fn summarize_planned_row(row: &PlannedStateRow) -> JsonValue {
     json!({
-        "entity_id": row.entity_id,
+        "entity_pk": row.entity_pk,
         "schema_key": row.schema_key,
-        "version_id": row.version_id,
+        "branch_id": row.branch_id,
         "tombstone": row.tombstone,
         "values": row
             .values

package/dist-engine-src/src/plugin/manifest.rs

@@ -100,13 +100,13 @@ impl DetectStateContextConfig {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum StateContextColumn {
-    EntityId,
+    EntityPk,
     SchemaKey,
     SchemaVersion,
     SnapshotContent,
     FileId,
     PluginKey,
-    VersionId,
+    BranchId,
     ChangeId,
     Metadata,
     CreatedAt,
@@ -117,7 +117,7 @@ pub enum StateContextColumn {
 impl StateContextColumn {
     pub const fn default_active_state_columns() -> &'static [StateContextColumn] {
         &[
-            StateContextColumn::EntityId,
+            StateContextColumn::EntityPk,
             StateContextColumn::SchemaKey,
             StateContextColumn::SchemaVersion,
             StateContextColumn::SnapshotContent,
@@ -357,7 +357,7 @@ mod tests {
         let config = DetectStateContextConfig {
             include_active_state: Some(true),
             columns: Some(vec![
-                StateContextColumn::EntityId,
+                StateContextColumn::EntityPk,
                 StateContextColumn::SchemaKey,
             ]),
         };
@@ -365,7 +365,7 @@ mod tests {
         assert_eq!(
             config.resolved_columns_or_default(),
             Some(vec![
-                StateContextColumn::EntityId,
+                StateContextColumn::EntityPk,
                 StateContextColumn::SchemaKey
             ])
         );
@@ -457,7 +457,7 @@ mod tests {
                 "detect_changes": {
                     "state_context": {
                         "include_active_state": true,
-                        "columns": ["entity_id", "schema_key", "snapshot_content"]
+                        "columns": ["entity_pk", "schema_key", "snapshot_content"]
                     }
                 }
             }"#,
@@ -475,7 +475,7 @@ mod tests {
         assert_eq!(
             state_context.columns,
             Some(vec![
-                StateContextColumn::EntityId,
+                StateContextColumn::EntityPk,
                 StateContextColumn::SchemaKey,
                 StateContextColumn::SnapshotContent
             ])

package/dist-engine-src/src/plugin/materializer.rs

@@ -200,278 +200,3 @@ where
         apply_changes_with_plugin(self, plugin, payload).await
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::binary_cas::codec::{
-        binary_blob_hash_bytes, encode_binary_cas_chunk, encode_binary_cas_manifest,
-        encode_binary_cas_manifest_chunk, BinaryCasManifest, BinaryChunkCodec,
-    };
-    use crate::binary_cas::kv::{
-        BINARY_CAS_CHUNK_NAMESPACE, BINARY_CAS_MANIFEST_CHUNK_NAMESPACE,
-        BINARY_CAS_MANIFEST_NAMESPACE,
-    };
-    use crate::{
-        BackendKvEntryPage, BackendKvExistsBatch, BackendKvExistsGroup,
-        BackendKvGetRequest, BackendKvKeyPage, BackendKvScanRange, BackendKvScanRequest,
-        BackendKvValueBatch, BackendKvValueGroup, BackendKvValuePage, BackendKvWriteBatch,
-        BackendKvWriteStats, BackendReadTransaction, BackendWriteTransaction, BytePageBuilder,
-    };
-    use async_trait::async_trait;
-    use std::io::{Cursor, Write};
-    use zip::write::SimpleFileOptions;
-    use zip::{CompressionMethod, ZipWriter};
-
-    struct InstalledPluginLookupBackend {
-        archive_bytes: Vec<u8>,
-    }
-
-    struct PluginLookupTransaction {
-        archive_bytes: Vec<u8>,
-    }
-
-    #[async_trait]
-    impl Backend for InstalledPluginLookupBackend {
-        async fn begin_read_transaction(
-            &self,
-        ) -> Result<Box<dyn BackendReadTransaction + Send + Sync + 'static>, LixError> {
-            Ok(Box::new(PluginLookupTransaction {
-                archive_bytes: self.archive_bytes.clone(),
-            }))
-        }
-
-        async fn begin_write_transaction(
-            &self,
-        ) -> Result<Box<dyn BackendWriteTransaction + Send + Sync + 'static>, LixError> {
-            Ok(Box::new(PluginLookupTransaction {
-                archive_bytes: self.archive_bytes.clone(),
-            }))
-        }
-    }
-
-    #[async_trait]
-    impl BackendReadTransaction for PluginLookupTransaction {
-        async fn get_values(
-            &mut self,
-            request: BackendKvGetRequest,
-        ) -> Result<BackendKvValueBatch, LixError> {
-            let mut groups = Vec::with_capacity(request.groups.len());
-            for group in request.groups {
-            let namespace = group.namespace.clone();
-            let mut values = BytePageBuilder::with_capacity(group.keys.len(), 0);
-                let mut present = Vec::with_capacity(group.keys.len());
-                for key in group.keys {
-                    if let Some(value) = test_kv_get(&self.archive_bytes, &group.namespace, &key)? {
-                        values.push(value);
-                        present.push(true);
-                    } else {
-                        values.push([]);
-                        present.push(false);
-                    }
-                }
-                groups.push(BackendKvValueGroup::new(namespace, values.finish(), present));
-            }
-            Ok(BackendKvValueBatch { groups })
-        }
-
-        async fn exists_many(
-            &mut self,
-            request: BackendKvGetRequest,
-        ) -> Result<BackendKvExistsBatch, LixError> {
-            let mut groups = Vec::with_capacity(request.groups.len());
-            for group in request.groups {
-            let namespace = group.namespace.clone();
-            let exists = group
-                    .keys
-                    .iter()
-                    .map(|key| test_kv_get(&self.archive_bytes, &group.namespace, key))
-                    .collect::<Result<Vec<_>, LixError>>()?
-                    .into_iter()
-                    .map(|value| value.is_some())
-                    .collect();
-                groups.push(BackendKvExistsGroup {
-                    namespace,
-                    exists,
-                });
-            }
-            Ok(BackendKvExistsBatch { groups })
-        }
-
-        async fn scan_keys(
-            &mut self,
-            request: BackendKvScanRequest,
-        ) -> Result<BackendKvKeyPage, LixError> {
-            let entries = test_kv_scan(&self.archive_bytes, request)?;
-            Ok(BackendKvKeyPage {
-                keys: entries.keys,
-                resume_after: entries.resume_after,
-            })
-        }
-
-        async fn scan_values(
-            &mut self,
-            request: BackendKvScanRequest,
-        ) -> Result<BackendKvValuePage, LixError> {
-            let entries = test_kv_scan(&self.archive_bytes, request)?;
-            Ok(BackendKvValuePage {
-                values: entries.values,
-                resume_after: entries.resume_after,
-            })
-        }
-
-        async fn scan_entries(
-            &mut self,
-            request: BackendKvScanRequest,
-        ) -> Result<BackendKvEntryPage, LixError> {
-            test_kv_scan(&self.archive_bytes, request)
-        }
-
-        async fn rollback(self: Box<Self>) -> Result<(), LixError> {
-            Ok(())
-        }
-    }
-
-    #[async_trait]
-    impl BackendWriteTransaction for PluginLookupTransaction {
-        async fn write_kv_batch(&mut self, _batch: BackendKvWriteBatch) -> Result<BackendKvWriteStats, LixError> {
-            Err(LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "plugin lookup test backend is read-only",
-            ))
-        }
-
-        async fn commit(self: Box<Self>) -> Result<(), LixError> {
-            Ok(())
-        }
-    }
-
-    fn test_kv_get(
-        archive_bytes: &[u8],
-        namespace: &str,
-        key: &[u8],
-    ) -> Result<Option<Vec<u8>>, LixError> {
-        match (namespace, key) {
-            (BINARY_CAS_MANIFEST_NAMESPACE, key)
-                if key == binary_blob_hash_bytes(archive_bytes).as_slice() =>
-            {
-                Ok(Some(encode_binary_cas_manifest(
-                    &BinaryCasManifest::Chunked {
-                        size_bytes: archive_bytes.len() as u64,
-                        chunk_count: 1,
-                    },
-                )))
-            }
-            (BINARY_CAS_CHUNK_NAMESPACE, key)
-                if key == binary_blob_hash_bytes(archive_bytes).as_slice() =>
-            {
-                Ok(Some(encode_binary_cas_chunk(
-                    BinaryChunkCodec::Raw,
-                    archive_bytes.len() as u64,
-                    archive_bytes,
-                )))
-            }
-            _ => Ok(None),
-        }
-    }
-
-    fn test_kv_scan(
-        archive_bytes: &[u8],
-        request: BackendKvScanRequest,
-    ) -> Result<BackendKvEntryPage, LixError> {
-        if request.namespace != BINARY_CAS_MANIFEST_CHUNK_NAMESPACE {
-            return Ok(BackendKvEntryPage {
-                keys: BytePageBuilder::new().finish(),
-                values: BytePageBuilder::new().finish(),
-                resume_after: None,
-            });
-        }
-        let blob_hash = binary_blob_hash_bytes(archive_bytes);
-        let chunk_hash = binary_blob_hash_bytes(archive_bytes);
-        let mut key = blob_hash.to_vec();
-        key.extend_from_slice(&0u64.to_be_bytes());
-        let include = match request.range {
-            BackendKvScanRange::Prefix(prefix) => key.starts_with(&prefix),
-            BackendKvScanRange::Range { start, end } => key >= start && key < end,
-        };
-        if !include || request.after.as_deref().is_some_and(|after| key.as_slice() <= after) {
-            return Ok(BackendKvEntryPage {
-                keys: BytePageBuilder::new().finish(),
-                values: BytePageBuilder::new().finish(),
-                resume_after: None,
-            });
-        }
-        let value = encode_binary_cas_manifest_chunk(&chunk_hash, archive_bytes.len() as u64);
-        let mut keys = BytePageBuilder::with_capacity(1, key.len());
-        let mut values = BytePageBuilder::with_capacity(1, value.len());
-        let mut resume_after = None;
-        if request.limit > 0 {
-            resume_after = Some(key.clone());
-            keys.push(&key);
-            values.push(&value);
-        }
-        let resume_after = (request.limit == 0).then_some(resume_after).flatten();
-        Ok(BackendKvEntryPage {
-            keys: keys.finish(),
-            values: values.finish(),
-            resume_after,
-        })
-    }
-
-    fn build_archive(entries: &[(&str, &[u8])]) -> Vec<u8> {
-        let options = SimpleFileOptions::default().compression_method(CompressionMethod::Stored);
-        let cursor = Cursor::new(Vec::new());
-        let mut writer = ZipWriter::new(cursor);
-        for (path, bytes) in entries {
-            writer
-                .start_file(*path, options)
-                .expect("archive entry start should succeed");
-            writer
-                .write_all(bytes)
-                .expect("archive entry write should succeed");
-        }
-        writer
-            .finish()
-            .expect("archive finish should succeed")
-            .into_inner()
-    }
-
-    fn build_plugin_archive(manifest_json: &str) -> Vec<u8> {
-        let wasm = [0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00];
-        build_archive(&[
-            ("manifest.json", manifest_json.as_bytes()),
-            ("plugin.wasm", &wasm),
-        ])
-    }
-
-    fn plugin_manifest_json(key: &str) -> String {
-        format!(
-            r#"{{
-  "key":"{key}",
-  "runtime":"wasm-component-v1",
-  "api_version":"0.1.0",
-  "match":{{"path_glob":"*.json"}},
-  "entry":"plugin.wasm",
-  "schemas":["schema/plugin_json_schema.json"]
-}}"#
-        )
-    }
-
-    #[tokio::test]
-    async fn installed_plugin_manifest_key_exists_reads_installed_manifest_keys() {
-        let backend = InstalledPluginLookupBackend {
-            archive_bytes: build_plugin_archive(&plugin_manifest_json("plugin_json")),
-        };
-
-        assert!(
-            installed_plugin_manifest_key_exists(&backend, "plugin_json")
-                .await
-                .expect("installed manifest key lookup should succeed")
-        );
-        assert!(
-            !installed_plugin_manifest_key_exists(&backend, "missing_plugin")
-                .await
-                .expect("missing manifest key lookup should succeed")
-        );
-    }
-}

package/dist-engine-src/src/plugin/plugin_manifest.json

@@ -60,12 +60,13 @@
               "items": {
                 "type": "string",
                 "enum": [
-                  "entity_id",
+                  "entity_pk",
                   "schema_key",
+                  "schema_version",
                   "snapshot_content",
                   "file_id",
                   "plugin_key",
-                  "version_id",
+                  "branch_id",
                   "change_id",
                   "metadata",
                   "created_at",
@@ -73,7 +74,7 @@
                 ]
               },
               "contains": {
-                "const": "entity_id"
+                "const": "entity_pk"
               }
             }
           },

package/dist-engine-src/src/schema/builtin/lix_binary_blob_ref.json

@@ -1,6 +1,6 @@
 {
   "x-lix-key": "lix_binary_blob_ref",
-  "description": "Metadata pointer from a file version to its binary payload in internal CAS storage.",
+  "description": "Metadata pointer from a file row to its binary payload in internal CAS storage.",
   "x-lix-primary-key": [
     "/id"
   ],
@@ -8,7 +8,7 @@
   "properties": {
     "id": {
       "type": "string",
-      "description": "File/entity identifier (matches lix_file.id) for this binary reference row."
+      "description": "File primary-key value (matches lix_file.id) for this binary reference row."
     },
     "blob_hash": {
       "type": "string",