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

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

@@ -1,31 +1,34 @@
-use crate::commit_store::{Change, CommitDraftRef, CommitStoreContext};
-use crate::entity_identity::EntityIdentity;
+use crate::branch::{BRANCH_DESCRIPTOR_SCHEMA_KEY, BRANCH_REF_SCHEMA_KEY};
+use crate::changelog::{
+    ChangeRecord, ChangelogAppend, ChangelogContext, ChangelogWriter, CommitChangeRef,
+    CommitChangeRefSet, CommitRecord,
+};
+use crate::entity_pk::EntityPk;
 use crate::functions::{
     FunctionProvider, FunctionProviderHandle, SharedFunctionProvider, SystemFunctionProvider,
 };
-use crate::json_store::{JsonRef, JsonStoreContext, JsonWritePlacementRef, NormalizedJsonRef};
+use crate::json_store::JsonRef;
+use crate::json_store::{JsonStoreContext, JsonWritePlacementRef, NormalizedJsonRef};
 use crate::schema::{
-    registered_schema_entity_id, schema_key_from_definition, seed_schema_definitions,
+    registered_schema_entity_pk, schema_key_from_definition, seed_schema_definitions,
 };
+use crate::storage::StorageBackend;
 use crate::storage::{StorageContext, StorageWriteSet};
 use crate::tracked_state::{TrackedStateContext, TrackedStateDeltaRef};
 use crate::untracked_state::{UntrackedStateContext, UntrackedStateRow};
-use crate::version::{VERSION_DESCRIPTOR_SCHEMA_KEY, VERSION_REF_SCHEMA_KEY};
 use crate::LixError;
-use crate::GLOBAL_VERSION_ID;
+use crate::GLOBAL_BRANCH_ID;
 use serde_json::json;
-#[cfg(test)]
-use std::sync::Arc;
 
 const KEY_VALUE_SCHEMA_KEY: &str = "lix_key_value";
 const LIX_ID_KEY: &str = "lix_id";
-const WORKSPACE_VERSION_KEY: &str = "lix_workspace_version_id";
+const WORKSPACE_BRANCH_KEY: &str = "lix_workspace_branch_id";
 const REGISTERED_SCHEMA_KEY: &str = "lix_registered_schema";
 
 /// Pure seed plan for initializing an engine repository.
 ///
-/// Tracked bootstrap facts go to the commit store. Moving refs such as
-/// `lix_version_ref` are seeded as untracked local state so repository heads
+/// Tracked bootstrap facts go to the changelog. Moving refs such as
+/// `lix_branch_ref` are seeded as untracked local state so repository heads
 /// can advance without becoming commit members.
 pub(crate) struct InitSeedPlan {
     commit: InitSeedCommit,
@@ -46,7 +49,7 @@ struct InitSeedCommit {
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct InitSeedChange {
     id: String,
-    entity_id: EntityIdentity,
+    entity_pk: EntityPk,
     schema_key: String,
     snapshot_content: String,
     created_at: String,
@@ -54,30 +57,30 @@ struct InitSeedChange {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct InitSeedLiveRow {
-    entity_id: EntityIdentity,
+    entity_pk: EntityPk,
     schema_key: String,
     snapshot_content: String,
     created_at: String,
     updated_at: String,
     global: bool,
-    version_id: String,
+    branch_id: String,
 }
 
 /// Values generated while planning the initial repository seed.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InitReceipt {
     pub lix_id: String,
-    pub global_version_id: String,
-    pub main_version_id: String,
+    pub global_branch_id: String,
+    pub main_branch_id: String,
     pub initial_commit_id: String,
 }
 
 /// Builds the canonical bootstrap changes for a new engine repository.
 ///
-/// The initial commit tracks durable content rows. Version refs are moving
+/// The initial commit tracks durable content rows. Branch refs are moving
 /// pointers and therefore live in untracked local state instead of the commit.
 pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSeedPlan, LixError> {
-    let main_version_id = functions.call_uuid_v7();
+    let main_branch_id = functions.call_uuid_v7();
     let lix_id = functions.call_uuid_v7();
     let initial_commit_id = functions.call_uuid_v7();
     let timestamp = functions.call_timestamp();
@@ -87,30 +90,30 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         let key = schema_key_from_definition(schema)?;
         registered_schema_changes.push(canonical_change(
             functions.call_uuid_v7(),
-            registered_schema_entity_id(&key.schema_key)?,
+            registered_schema_entity_pk(&key.schema_key)?,
             REGISTERED_SCHEMA_KEY,
             registered_schema_snapshot(schema)?,
             &timestamp,
         ));
     }
 
-    let global_version_descriptor_change = canonical_change(
-        GLOBAL_VERSION_ID.to_string(),
-        EntityIdentity::single(GLOBAL_VERSION_ID),
-        VERSION_DESCRIPTOR_SCHEMA_KEY,
-        version_descriptor_snapshot(GLOBAL_VERSION_ID, "global", true)?,
+    let global_branch_descriptor_change = canonical_change(
+        GLOBAL_BRANCH_ID.to_string(),
+        EntityPk::single(GLOBAL_BRANCH_ID),
+        BRANCH_DESCRIPTOR_SCHEMA_KEY,
+        branch_descriptor_snapshot(GLOBAL_BRANCH_ID, "global", true)?,
         &timestamp,
     );
-    let main_version_descriptor_change = canonical_change(
+    let main_branch_descriptor_change = canonical_change(
         functions.call_uuid_v7(),
-        EntityIdentity::single(&main_version_id),
-        VERSION_DESCRIPTOR_SCHEMA_KEY,
-        version_descriptor_snapshot(&main_version_id, "main", false)?,
+        EntityPk::single(&main_branch_id),
+        BRANCH_DESCRIPTOR_SCHEMA_KEY,
+        branch_descriptor_snapshot(&main_branch_id, "main", false)?,
         &timestamp,
     );
     let kv_lix_id_change = canonical_change(
         functions.call_uuid_v7(),
-        EntityIdentity::single(LIX_ID_KEY),
+        EntityPk::single(LIX_ID_KEY),
         KEY_VALUE_SCHEMA_KEY,
         key_value_snapshot(LIX_ID_KEY, &lix_id)?,
         &timestamp,
@@ -123,22 +126,22 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         author_account_ids: Vec::new(),
         created_at: timestamp.clone(),
     };
-    let global_version_ref_row = untracked_row(
-        EntityIdentity::single(GLOBAL_VERSION_ID),
-        VERSION_REF_SCHEMA_KEY,
-        version_ref_snapshot(GLOBAL_VERSION_ID, &initial_commit_id)?,
+    let global_branch_ref_row = untracked_row(
+        EntityPk::single(GLOBAL_BRANCH_ID),
+        BRANCH_REF_SCHEMA_KEY,
+        branch_ref_snapshot(GLOBAL_BRANCH_ID, &initial_commit_id)?,
         &timestamp,
     );
-    let main_version_ref_row = untracked_row(
-        EntityIdentity::single(&main_version_id),
-        VERSION_REF_SCHEMA_KEY,
-        version_ref_snapshot(&main_version_id, &initial_commit_id)?,
+    let main_branch_ref_row = untracked_row(
+        EntityPk::single(&main_branch_id),
+        BRANCH_REF_SCHEMA_KEY,
+        branch_ref_snapshot(&main_branch_id, &initial_commit_id)?,
         &timestamp,
     );
-    let workspace_version_row = untracked_row(
-        EntityIdentity::single(WORKSPACE_VERSION_KEY),
+    let workspace_branch_row = untracked_row(
+        EntityPk::single(WORKSPACE_BRANCH_KEY),
         KEY_VALUE_SCHEMA_KEY,
-        key_value_snapshot(WORKSPACE_VERSION_KEY, &main_version_id)?,
+        key_value_snapshot(WORKSPACE_BRANCH_KEY, &main_branch_id)?,
         &timestamp,
     );
 
@@ -147,20 +150,20 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         changes: registered_schema_changes
             .into_iter()
             .chain([
-                global_version_descriptor_change,
-                main_version_descriptor_change,
+                global_branch_descriptor_change,
+                main_branch_descriptor_change,
                 kv_lix_id_change,
             ])
             .collect(),
         untracked_rows: vec![
-            global_version_ref_row,
-            main_version_ref_row,
-            workspace_version_row,
+            global_branch_ref_row,
+            main_branch_ref_row,
+            workspace_branch_row,
         ],
         receipt: InitReceipt {
             lix_id,
-            global_version_id: GLOBAL_VERSION_ID.to_string(),
-            main_version_id,
+            global_branch_id: GLOBAL_BRANCH_ID.to_string(),
+            main_branch_id,
             initial_commit_id,
         },
     })
@@ -170,56 +173,35 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
 ///
 /// The pure seed planner decides which bootstrap facts exist. This function is
 /// only responsible for durably writing those facts to their owning stores:
-/// commit_store for tracked changes, and live_state for the serving projection
+/// changelog for tracked changes, and live_state for the serving state
 /// plus untracked moving refs.
-pub(crate) async fn initialize(
-    storage: StorageContext,
-    commit_store: &CommitStoreContext,
+pub(crate) async fn initialize<B>(
+    storage: StorageContext<B>,
     tracked_state: &TrackedStateContext,
     untracked_state: &UntrackedStateContext,
-) -> Result<InitReceipt, LixError> {
+) -> Result<InitReceipt, LixError>
+where
+    B: StorageBackend + Clone + Send + Sync + 'static,
+    for<'backend> B::Read<'backend>: Clone + Send + Sync + 'static,
+    for<'backend> B::Write<'backend>: Send,
+{
     let functions = SharedFunctionProvider::new(
         Box::new(SystemFunctionProvider) as Box<dyn FunctionProvider + Send>
     );
     let plan = plan_init_seed(functions)?;
     let receipt = plan.receipt.clone();
 
-    let mut transaction = storage.begin_write_transaction().await?;
+    let mut read = storage.begin_read(crate::storage::StorageReadOptions::default())?;
     let mut writes = StorageWriteSet::new();
 
     let authored_changes = plan
         .changes
         .iter()
-        .map(seed_change_to_commit_store_change)
-        .collect::<Result<Vec<_>, _>>()?;
-    JsonStoreContext::new().writer().stage_batch(
-        &mut writes,
-        JsonWritePlacementRef::CommitPack {
-            commit_id: &plan.commit.id,
-            pack_id: 0,
-        },
-        plan.changes
-            .iter()
-            .map(|change| NormalizedJsonRef::new(change.snapshot_content.as_str())),
-    )?;
+        .map(seed_change_to_change_record)
+        .collect::<Vec<_>>();
 
-    let staged_commit = {
-        let commit = CommitDraftRef {
-            id: &plan.commit.id,
-            change_id: &plan.commit.change_id,
-            parent_ids: &plan.commit.parent_ids,
-            author_account_ids: &plan.commit.author_account_ids,
-            created_at: &plan.commit.created_at,
-        };
-        let mut writer = commit_store.writer(transaction.as_mut(), &mut writes);
-        writer
-            .stage_tracked_commit_draft(
-                commit,
-                authored_changes.iter().map(Change::as_ref).collect(),
-                Vec::new(),
-            )
-            .await?
-    };
+    stage_init_json_payloads(&mut writes, &plan)?;
+    stage_init_changelog_commit(&mut read, &mut writes, &plan, authored_changes.clone()).await?;
 
     let untracked_rows = plan
         .untracked_rows
@@ -231,42 +213,139 @@ pub(crate) async fn initialize(
         untracked_state
             .writer(&mut writes)
             .stage_rows(untracked_rows.iter().map(|row| row.as_ref()))?;
-        let deltas = authored_changes
+        let commit_row_change = seed_commit_row_change_record(&plan.commit)?;
+        let mut deltas = authored_changes
             .iter()
-            .zip(&staged_commit.authored_locators)
-            .map(|(change, locator)| TrackedStateDeltaRef {
-                change: change.as_ref(),
-                locator: locator.as_ref(),
+            .map(|change| TrackedStateDeltaRef {
+                schema_key: &change.schema_key,
+                file_id: change.file_id.as_deref(),
+                entity_pk: &change.entity_pk,
+                change_id: &change.change_id,
+                commit_id: &plan.commit.id,
+                snapshot_ref: change.snapshot_ref.as_ref(),
+                metadata_ref: change.metadata_ref.as_ref(),
+                deleted: change.snapshot_ref.is_none(),
                 created_at: &change.created_at,
                 updated_at: &change.created_at,
             })
             .collect::<Vec<_>>();
-        let mut writer = tracked_state.writer(transaction.as_mut(), &mut writes);
+        deltas.push(TrackedStateDeltaRef {
+            schema_key: &commit_row_change.schema_key,
+            file_id: commit_row_change.file_id.as_deref(),
+            entity_pk: &commit_row_change.entity_pk,
+            change_id: &commit_row_change.change_id,
+            commit_id: &plan.commit.id,
+            snapshot_ref: commit_row_change.snapshot_ref.as_ref(),
+            metadata_ref: commit_row_change.metadata_ref.as_ref(),
+            deleted: commit_row_change.snapshot_ref.is_none(),
+            created_at: &commit_row_change.created_at,
+            updated_at: &commit_row_change.created_at,
+        });
+        let mut writer = tracked_state.writer(&read, &mut writes);
         writer
-            .stage_delta(&receipt.initial_commit_id, None, &deltas)
+            .stage_commit_root(&receipt.initial_commit_id, None, deltas)
             .await?;
     }
 
-    writes.apply(&mut transaction.as_mut()).await?;
-    transaction.commit().await?;
+    storage.commit_write_set(writes, crate::storage::StorageWriteOptions::default())?;
     Ok(receipt)
 }
 
-fn seed_change_to_commit_store_change(change: &InitSeedChange) -> Result<Change, LixError> {
-    Ok(Change {
-        id: change.id.clone(),
-        entity_id: change.entity_id.clone(),
+fn seed_change_to_change_record(change: &InitSeedChange) -> ChangeRecord {
+    ChangeRecord {
+        format_version: 1,
+        change_id: change.id.clone(),
+        entity_pk: change.entity_pk.clone(),
         schema_key: change.schema_key.clone(),
         file_id: None,
         snapshot_ref: Some(JsonRef::for_content(change.snapshot_content.as_bytes())),
         metadata_ref: None,
         created_at: change.created_at.clone(),
+    }
+}
+
+fn seed_commit_row_change_record(commit: &InitSeedCommit) -> Result<ChangeRecord, LixError> {
+    let snapshot_content = commit_row_snapshot_content(&commit.id)?;
+    Ok(ChangeRecord {
+        format_version: 1,
+        change_id: commit.change_id.clone(),
+        entity_pk: EntityPk::single(commit.id.clone()),
+        schema_key: "lix_commit".to_string(),
+        file_id: None,
+        snapshot_ref: Some(JsonRef::for_content(snapshot_content.as_bytes())),
+        metadata_ref: None,
+        created_at: commit.created_at.clone(),
     })
 }
 
+fn stage_init_json_payloads(
+    writes: &mut StorageWriteSet,
+    plan: &InitSeedPlan,
+) -> Result<(), LixError> {
+    let commit_snapshot = commit_row_snapshot_content(&plan.commit.id)?;
+    JsonStoreContext::new().writer().stage_batch(
+        writes,
+        JsonWritePlacementRef::OutOfBand,
+        plan.changes
+            .iter()
+            .map(|change| NormalizedJsonRef::new(change.snapshot_content.as_str()))
+            .chain(std::iter::once(NormalizedJsonRef::new(
+                commit_snapshot.as_str(),
+            ))),
+    )?;
+    Ok(())
+}
+
+async fn stage_init_changelog_commit(
+    read: &mut (impl crate::storage::StorageRead + Send + Sync),
+    writes: &mut StorageWriteSet,
+    plan: &InitSeedPlan,
+    changes: Vec<ChangeRecord>,
+) -> Result<(), LixError> {
+    let commit = CommitRecord {
+        format_version: 1,
+        commit_id: plan.commit.id.clone(),
+        parent_commit_ids: plan.commit.parent_ids.clone(),
+        change_id: plan.commit.change_id.clone(),
+        author_account_ids: plan.commit.author_account_ids.clone(),
+        created_at: plan.commit.created_at.clone(),
+    };
+    let commit_change_refs = CommitChangeRefSet {
+        commit_id: plan.commit.id.clone(),
+        entries: plan
+            .changes
+            .iter()
+            .map(commit_change_ref_from_seed_change)
+            .collect(),
+    };
+    let mut writer = ChangelogContext::new().writer(read, writes);
+    writer
+        .stage_append(ChangelogAppend {
+            commits: vec![commit],
+            changes,
+            commit_change_refs: vec![commit_change_refs],
+        })
+        .await
+}
+
+fn commit_row_snapshot_content(commit_id: &str) -> Result<String, LixError> {
+    encode_snapshot(json!({
+        "id": commit_id,
+    }))
+}
+
+fn commit_change_ref_from_seed_change(change: &InitSeedChange) -> CommitChangeRef {
+    CommitChangeRef {
+        schema_key: change.schema_key.clone(),
+        file_id: None,
+        entity_pk: change.entity_pk.clone(),
+        change_id: change.id.clone(),
+    }
+}
+
 fn untracked_state_row_from_seed(row: &InitSeedLiveRow) -> Result<UntrackedStateRow, LixError> {
     Ok(UntrackedStateRow {
-        entity_id: row.entity_id.clone(),
+        entity_pk: row.entity_pk.clone(),
         schema_key: row.schema_key.clone(),
         file_id: None,
         snapshot_content: Some(row.snapshot_content.clone()),
@@ -274,44 +353,44 @@ fn untracked_state_row_from_seed(row: &InitSeedLiveRow) -> Result<UntrackedState
         created_at: row.created_at.clone(),
         updated_at: row.updated_at.clone(),
         global: row.global,
-        version_id: row.version_id.clone(),
+        branch_id: row.branch_id.clone(),
     })
 }
 
 fn untracked_row(
-    entity_id: EntityIdentity,
+    entity_pk: EntityPk,
     schema_key: &str,
     snapshot_content: String,
     timestamp: &str,
 ) -> InitSeedLiveRow {
     InitSeedLiveRow {
-        entity_id,
+        entity_pk,
         schema_key: schema_key.to_string(),
         snapshot_content,
         created_at: timestamp.to_string(),
         updated_at: timestamp.to_string(),
         global: true,
-        version_id: GLOBAL_VERSION_ID.to_string(),
+        branch_id: GLOBAL_BRANCH_ID.to_string(),
     }
 }
 
 fn canonical_change(
     id: String,
-    entity_id: EntityIdentity,
+    entity_pk: EntityPk,
     schema_key: &str,
     snapshot_content: String,
     created_at: &str,
 ) -> InitSeedChange {
     InitSeedChange {
         id,
-        entity_id,
+        entity_pk,
         schema_key: schema_key.to_string(),
         snapshot_content,
         created_at: created_at.to_string(),
     }
 }
 
-fn version_descriptor_snapshot(id: &str, name: &str, hidden: bool) -> Result<String, LixError> {
+fn branch_descriptor_snapshot(id: &str, name: &str, hidden: bool) -> Result<String, LixError> {
     encode_snapshot(json!({
         "id": id,
         "name": name,
@@ -332,7 +411,7 @@ fn registered_schema_snapshot(schema: &serde_json::Value) -> Result<String, LixE
     }))
 }
 
-fn version_ref_snapshot(id: &str, commit_id: &str) -> Result<String, LixError> {
+fn branch_ref_snapshot(id: &str, commit_id: &str) -> Result<String, LixError> {
     encode_snapshot(json!({
         "id": id,
         "commit_id": commit_id,
@@ -353,8 +432,9 @@ mod tests {
     use serde_json::Value as JsonValue;
 
     use super::*;
-    use crate::backend::{testing::UnitTestBackend, Backend};
+    use crate::changelog::ChangelogReader;
     use crate::functions::{FunctionProvider, SharedFunctionProvider};
+    use crate::storage::InMemoryStorageBackend;
     use crate::storage::StorageContext;
     use crate::tracked_state::TrackedStateContext;
     use crate::untracked_state::UntrackedStateContext;
@@ -365,8 +445,8 @@ mod tests {
 
         assert_eq!(plan.changes.len(), seed_schema_definitions().len() + 3);
         assert_eq!(plan.untracked_rows.len(), 3);
-        assert_eq!(plan.receipt.global_version_id, GLOBAL_VERSION_ID);
-        assert_eq!(plan.receipt.main_version_id, "test-uuid-1");
+        assert_eq!(plan.receipt.global_branch_id, GLOBAL_BRANCH_ID);
+        assert_eq!(plan.receipt.main_branch_id, "test-uuid-1");
         assert_eq!(plan.receipt.lix_id, "test-uuid-2");
         assert_eq!(plan.receipt.initial_commit_id, "test-uuid-3");
     }
@@ -429,22 +509,22 @@ mod tests {
     }
 
     #[test]
-    fn plan_init_seed_version_refs_point_to_initial_commit() {
+    fn plan_init_seed_branch_refs_point_to_initial_commit() {
         let plan = plan_init_seed(test_functions()).expect("init seed should plan");
-        let version_refs = plan
+        let branch_refs = plan
             .untracked_rows
             .iter()
-            .filter(|row| row.schema_key == VERSION_REF_SCHEMA_KEY)
+            .filter(|row| row.schema_key == BRANCH_REF_SCHEMA_KEY)
             .collect::<Vec<_>>();
 
-        assert_eq!(version_refs.len(), 2);
+        assert_eq!(branch_refs.len(), 2);
         assert!(plan
             .changes
             .iter()
-            .all(|change| change.schema_key != VERSION_REF_SCHEMA_KEY));
-        for row in version_refs {
-            assert_eq!(row.schema_key, VERSION_REF_SCHEMA_KEY);
-            assert_eq!(row.version_id, GLOBAL_VERSION_ID);
+            .all(|change| change.schema_key != BRANCH_REF_SCHEMA_KEY));
+        for row in branch_refs {
+            assert_eq!(row.schema_key, BRANCH_REF_SCHEMA_KEY);
+            assert_eq!(row.branch_id, GLOBAL_BRANCH_ID);
             let snapshot = untracked_snapshot(row);
             assert_eq!(
                 snapshot.get("commit_id").and_then(JsonValue::as_str),
@@ -454,74 +534,128 @@ mod tests {
     }
 
     #[test]
-    fn plan_init_seed_workspace_version_points_to_main_version() {
+    fn plan_init_seed_workspace_branch_points_to_main_branch() {
         let plan = plan_init_seed(test_functions()).expect("init seed should plan");
         let workspace_row = plan
             .untracked_rows
             .iter()
             .find(|row| {
                 row.schema_key == KEY_VALUE_SCHEMA_KEY
-                    && row.entity_id
-                        == crate::entity_identity::EntityIdentity::single(WORKSPACE_VERSION_KEY)
+                    && row.entity_pk == crate::entity_pk::EntityPk::single(WORKSPACE_BRANCH_KEY)
             })
-            .expect("workspace version row should exist");
+            .expect("workspace branch row should exist");
 
-        assert_eq!(workspace_row.version_id, GLOBAL_VERSION_ID);
+        assert_eq!(workspace_row.branch_id, GLOBAL_BRANCH_ID);
         assert!(workspace_row.global);
         let snapshot = untracked_snapshot(workspace_row);
         assert_eq!(
             snapshot.get("key").and_then(JsonValue::as_str),
-            Some(WORKSPACE_VERSION_KEY)
+            Some(WORKSPACE_BRANCH_KEY)
         );
         assert_eq!(
             snapshot.get("value").and_then(JsonValue::as_str),
-            Some(plan.receipt.main_version_id.as_str())
+            Some(plan.receipt.main_branch_id.as_str())
         );
     }
 
     #[tokio::test]
-    async fn initialize_writes_initial_commit_through_commit_store() {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
+    async fn initialize_writes_initial_commit_through_changelog() {
+        let backend = InMemoryStorageBackend::new();
         let storage = StorageContext::new(backend);
-        let commit_store = CommitStoreContext::new();
         let tracked_state = TrackedStateContext::new();
         let untracked_state = UntrackedStateContext::new();
 
-        let receipt = initialize(
-            storage.clone(),
-            &commit_store,
-            &tracked_state,
-            &untracked_state,
-        )
-        .await
-        .expect("engine should initialize");
-        let reader = commit_store.reader(storage.clone());
-        let commit = reader
-            .load_commit(&receipt.initial_commit_id)
+        let receipt = initialize(storage.clone(), &tracked_state, &untracked_state)
             .await
-            .expect("commit should load")
-            .expect("initial commit should exist");
-
-        assert_eq!(commit.id, receipt.initial_commit_id);
-        assert_eq!(commit.change_pack_count, 1);
-        assert_eq!(commit.membership_pack_count, 0);
-
-        let change_pack = reader
-            .load_change_pack(&commit.id, 0)
+            .expect("engine should initialize");
+        let mut reader = ChangelogContext::new().reader(
+            storage
+                .begin_read(crate::storage::StorageReadOptions::default())
+                .expect("read should open"),
+        );
+        let commits = reader
+            .load_commits(crate::changelog::CommitLoadRequest {
+                commit_ids: &[receipt.initial_commit_id.clone()],
+                projection: crate::changelog::CommitProjection::Full,
+            })
             .await
-            .expect("change pack should load")
-            .expect("initial change pack should exist");
-        assert_eq!(change_pack.len(), seed_schema_definitions().len() + 3);
-        assert!(change_pack
+            .expect("commit should load");
+        let Some(crate::changelog::CommitLoadEntry::Full {
+            record,
+            change_ref_chunks,
+        }) = commits.entries.into_iter().next().flatten()
+        else {
+            panic!("initial commit should exist");
+        };
+
+        assert_eq!(record.commit_id, receipt.initial_commit_id);
+        let commit_change_id = record.change_id.clone();
+        let change_refs = change_ref_chunks
             .iter()
-            .all(|change| change.id != commit.change_id));
+            .flat_map(|chunk| chunk.entries.iter())
+            .collect::<Vec<_>>();
+        assert_eq!(change_refs.len(), seed_schema_definitions().len() + 3);
+        assert!(
+            !change_refs
+                .iter()
+                .any(|change_ref| change_ref.change_id == record.change_id),
+            "initial commit row is derived from changelog.commit, not stored in commit refs"
+        );
 
-        let entries = reader
-            .load_change_index_entries(&[commit.change_id.clone(), "global".to_string()])
+        let changes = reader
+            .load_changes(crate::changelog::ChangeLoadRequest {
+                change_ids: &["global".to_string()],
+            })
             .await
             .expect("change index should load");
-        assert!(entries[0].is_some());
-        assert!(entries[1].is_some());
+        assert!(matches!(
+            changes.entries.as_slice(),
+            [Some(change)] if change.change_id == "global"
+        ));
+        let missing_derivable = reader
+            .load_changes(crate::changelog::ChangeLoadRequest {
+                change_ids: &[commit_change_id.clone()],
+            })
+            .await
+            .expect("derivable change lookup should load");
+        assert!(matches!(missing_derivable.entries.as_slice(), [None]));
+        {
+            let read = storage
+                .begin_read(crate::storage::StorageReadOptions::default())
+                .expect("read should open");
+            let mut writes = storage.new_write_set();
+            tracked_state
+                .root_rebuilder(&read, &mut writes)
+                .rebuild_commit_root_at(&receipt.initial_commit_id)
+                .await
+                .expect("initial commit root should rebuild from changelog refs");
+            drop(read);
+            storage
+                .commit_write_set(writes, crate::storage::StorageWriteOptions::default())
+                .expect("rebuilt initial commit root should commit");
+        }
+        let mut tracked_reader = tracked_state.reader(
+            storage
+                .begin_read(crate::storage::StorageReadOptions::default())
+                .expect("read should open"),
+        );
+        let rows = tracked_reader
+            .scan_rows_at_commit(
+                &receipt.initial_commit_id,
+                &crate::tracked_state::TrackedStateScanRequest {
+                    filter: crate::tracked_state::TrackedStateFilter {
+                        schema_keys: vec!["lix_commit".to_string()],
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect("tracked initial root should scan");
+        assert!(
+            rows.iter().any(|row| row.change_id == commit_change_id),
+            "initial commit root should surface its lix_commit row"
+        );
     }
 
     fn snapshot(change: &InitSeedChange) -> JsonValue {