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

package/dist-engine-src/src/version/refs.rs

@@ -1,17 +1,15 @@
 use std::sync::Arc;
 
-use serde_json::json;
 use tokio::sync::Mutex;
 
 use crate::entity_identity::EntityIdentity;
-use crate::json_store::JsonStoreWriter;
 use crate::storage::{StorageReader, StorageWriteSet};
 use crate::untracked_state::{
-    canonicalize_materialized_row, MaterializedUntrackedStateRow, UntrackedStateContext,
-    UntrackedStateFilter, UntrackedStateRow, UntrackedStateRowRequest, UntrackedStateScanRequest,
+    MaterializedUntrackedStateRow, UntrackedStateContext, UntrackedStateFilter, UntrackedStateRow,
+    UntrackedStateRowRequest, UntrackedStateScanRequest,
 };
+use crate::version::VERSION_REF_SCHEMA_KEY;
 use crate::version::{VersionHead, VersionRefReader};
-use crate::version::{VERSION_REF_SCHEMA_KEY, VERSION_REF_SCHEMA_VERSION};
 use crate::GLOBAL_VERSION_ID;
 use crate::{LixError, NullableKeyFilter};
 
@@ -109,7 +107,7 @@ where
         let mut heads = rows
             .iter()
             .map(|row| {
-                let version_id = row.entity_id.as_string()?;
+                let version_id = row.entity_id.as_single_string_owned()?;
                 decode_version_head(&version_id, row)
             })
             .collect::<Result<Vec<_>, _>>()?
@@ -147,21 +145,12 @@ pub(super) struct VersionRefWriter<'a> {
 
 impl VersionRefWriter<'_> {
     pub(crate) fn stage_rows(&mut self, rows: &[UntrackedStateRow]) -> Result<(), LixError> {
-        self.untracked_state.writer(self.writes).stage_rows(rows)
+        self.untracked_state
+            .writer(self.writes)
+            .stage_rows(rows.iter().map(|row| row.as_ref()))
     }
 }
 
-pub(super) fn canonical_version_ref_row(
-    writes: &mut StorageWriteSet,
-    json_writer: &mut JsonStoreWriter,
-    version_id: &str,
-    commit_id: &str,
-    timestamp: &str,
-) -> Result<UntrackedStateRow, LixError> {
-    let row = version_ref_row(version_id, commit_id, timestamp)?;
-    canonicalize_materialized_row(writes, json_writer, &row)
-}
-
 fn decode_version_head(
     requested_version_id: &str,
     row: &MaterializedUntrackedStateRow,
@@ -173,7 +162,7 @@ fn decode_version_head(
         serde_json::from_str::<serde_json::Value>(snapshot_content).map_err(|error| {
             LixError::new(
                 "LIX_ERROR_UNKNOWN",
-                format!("engine2 version-ref snapshot parse failed: {error}"),
+                format!("engine version-ref snapshot parse failed: {error}"),
             )
         })?;
     let commit_id = snapshot
@@ -191,46 +180,14 @@ fn decode_version_head(
     }))
 }
 
-fn version_ref_row(
-    version_id: &str,
-    commit_id: &str,
-    timestamp: &str,
-) -> Result<MaterializedUntrackedStateRow, LixError> {
-    let snapshot_content = serde_json::to_string(&json!({
-        "id": version_id,
-        "commit_id": commit_id,
-    }))
-    .map_err(|error| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!("engine2 version-ref snapshot serialization failed: {error}"),
-        )
-    })?;
-
-    Ok(MaterializedUntrackedStateRow {
-        entity_id: crate::entity_identity::EntityIdentity::single(version_id),
-        schema_key: VERSION_REF_SCHEMA_KEY.to_string(),
-        file_id: None,
-        snapshot_content: Some(snapshot_content),
-        metadata: None,
-        schema_version: VERSION_REF_SCHEMA_VERSION.to_string(),
-        created_at: timestamp.to_string(),
-        updated_at: timestamp.to_string(),
-        global: true,
-        version_id: GLOBAL_VERSION_ID.to_string(),
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
 
     use crate::backend::testing::UnitTestBackend;
-    use crate::json_store::JsonStoreContext;
     use crate::storage::{StorageContext, StorageWriteSet};
-    use crate::untracked_state::{
-        canonicalize_materialized_row, UntrackedStateContext, UntrackedStateRowRequest,
-    };
+    use crate::transaction::prepare_version_ref_row;
+    use crate::untracked_state::{UntrackedStateContext, UntrackedStateRowRequest};
 
     use super::*;
 
@@ -356,51 +313,6 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn malformed_snapshot_errors_clearly() {
-        let storage = StorageContext::new(Arc::new(UnitTestBackend::new()));
-        let untracked_state = UntrackedStateContext::new();
-        let version_ref = VersionRefContext::new(Arc::new(UntrackedStateContext::new()));
-        let mut transaction = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let mut row = version_ref_row("version-b", "commit-b", "2026-01-01T00:00:00Z")
-            .expect("version-ref row should plan");
-        row.snapshot_content = Some("{not-json".to_string());
-        let mut writes = StorageWriteSet::new();
-        let canonical_row = {
-            let mut json_writer = JsonStoreContext::new().writer();
-            canonicalize_materialized_row(&mut writes, &mut json_writer, &row)
-                .expect("malformed row should canonicalize for test setup")
-        };
-        untracked_state
-            .writer(&mut writes)
-            .stage_rows(&[canonical_row])
-            .expect("malformed row should write for test setup");
-        writes
-            .apply(&mut transaction.as_mut())
-            .await
-            .expect("malformed row should apply for test setup");
-        transaction
-            .commit()
-            .await
-            .expect("transaction should commit");
-
-        let error = version_ref
-            .reader(storage)
-            .load_head("version-b")
-            .await
-            .expect_err("malformed snapshot should error");
-
-        assert!(
-            error
-                .message
-                .contains("engine2 version-ref snapshot parse failed"),
-            "unexpected error: {error:?}"
-        );
-    }
-
     fn test_version_ref() -> VersionRefContext {
         VersionRefContext::new(Arc::new(UntrackedStateContext::new()))
     }
@@ -412,10 +324,7 @@ mod tests {
         commit_id: &str,
         timestamp: &str,
     ) -> Result<(), LixError> {
-        let canonical_row = {
-            let mut json_writer = JsonStoreContext::new().writer();
-            canonical_version_ref_row(writes, &mut json_writer, version_id, commit_id, timestamp)?
-        };
-        version_ref.writer(writes).stage_rows(&[canonical_row])
+        let canonical_row = prepare_version_ref_row(version_id, commit_id, timestamp)?;
+        version_ref.writer(writes).stage_rows(&[canonical_row.row])
     }
 }

package/dist-engine-src/src/version/stage_rows.rs

@@ -1,27 +1,28 @@
 use serde_json::json;
 
 use crate::entity_identity::EntityIdentity;
-use crate::transaction::types::StageRow;
+use crate::transaction::types::{TransactionJson, TransactionWriteRow};
 use crate::GLOBAL_VERSION_ID;
 
 pub(crate) const VERSION_DESCRIPTOR_SCHEMA_KEY: &str = "lix_version_descriptor";
-pub(crate) const VERSION_DESCRIPTOR_SCHEMA_VERSION: &str = "1";
 pub(crate) const VERSION_REF_SCHEMA_KEY: &str = "lix_version_ref";
-pub(crate) const VERSION_REF_SCHEMA_VERSION: &str = "1";
 
-pub(crate) fn version_descriptor_stage_row(version_id: &str, name: &str, hidden: bool) -> StageRow {
-    StageRow {
+pub(crate) fn version_descriptor_stage_row(
+    version_id: &str,
+    name: &str,
+    hidden: bool,
+) -> TransactionWriteRow {
+    TransactionWriteRow {
         entity_id: Some(EntityIdentity::single(version_id)),
         schema_key: VERSION_DESCRIPTOR_SCHEMA_KEY.to_string(),
         file_id: None,
-        snapshot_content: Some(encode_snapshot(json!({
+        snapshot: Some(TransactionJson::from_value_unchecked(json!({
             "id": version_id,
             "name": name,
             "hidden": hidden,
         }))),
         metadata: None,
         origin: None,
-        schema_version: VERSION_DESCRIPTOR_SCHEMA_VERSION.to_string(),
         created_at: None,
         updated_at: None,
         global: true,
@@ -32,18 +33,17 @@ pub(crate) fn version_descriptor_stage_row(version_id: &str, name: &str, hidden:
     }
 }
 
-pub(crate) fn version_ref_stage_row(version_id: &str, commit_id: &str) -> StageRow {
-    StageRow {
+pub(crate) fn version_ref_stage_row(version_id: &str, commit_id: &str) -> TransactionWriteRow {
+    TransactionWriteRow {
         entity_id: Some(EntityIdentity::single(version_id)),
         schema_key: VERSION_REF_SCHEMA_KEY.to_string(),
         file_id: None,
-        snapshot_content: Some(encode_snapshot(json!({
+        snapshot: Some(TransactionJson::from_value_unchecked(json!({
             "id": version_id,
             "commit_id": commit_id,
         }))),
         metadata: None,
         origin: None,
-        schema_version: VERSION_REF_SCHEMA_VERSION.to_string(),
         created_at: None,
         updated_at: None,
         global: true,
@@ -54,18 +54,14 @@ pub(crate) fn version_ref_stage_row(version_id: &str, commit_id: &str) -> StageR
     }
 }
 
-pub(crate) fn version_descriptor_tombstone_row(version_id: &str) -> StageRow {
+pub(crate) fn version_descriptor_tombstone_row(version_id: &str) -> TransactionWriteRow {
     let mut row = version_descriptor_stage_row(version_id, "", false);
-    row.snapshot_content = None;
+    row.snapshot = None;
     row
 }
 
-pub(crate) fn version_ref_tombstone_row(version_id: &str) -> StageRow {
+pub(crate) fn version_ref_tombstone_row(version_id: &str) -> TransactionWriteRow {
     let mut row = version_ref_stage_row(version_id, "");
-    row.snapshot_content = None;
+    row.snapshot = None;
     row
 }
-
-fn encode_snapshot(value: serde_json::Value) -> String {
-    serde_json::to_string(&value).expect("version snapshot should be serializable")
-}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.6.0-preview.2",
+	"version": "0.6.0-preview.4",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"files": [

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

@@ -1,321 +0,0 @@
-use crate::changelog::CanonicalChange;
-use crate::entity_identity::EntityIdentity;
-use crate::json_store::JsonRef;
-use crate::LixError;
-
-const CHANGELOG_FILE_IDENTIFIER: &str = "LXCH";
-
-pub(crate) fn encode_change(change: &CanonicalChange) -> Result<Vec<u8>, LixError> {
-    let entity_id = change.entity_id.as_string().map_err(|error| {
-        LixError::unknown(format!(
-            "failed to encode changelog entity identity: {error}"
-        ))
-    })?;
-
-    let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(256);
-    let id = builder.create_string(&change.id);
-    let entity_id = builder.create_string(&entity_id);
-    let schema_key = builder.create_string(&change.schema_key);
-    let schema_version = builder.create_string(&change.schema_version);
-    let file_id = change
-        .file_id
-        .as_ref()
-        .map(|value| builder.create_string(value));
-    let snapshot_ref = change
-        .snapshot_ref
-        .as_ref()
-        .map(|value| builder.create_vector(value.as_hash_bytes()));
-    let metadata_ref = change
-        .metadata_ref
-        .as_ref()
-        .map(|value| builder.create_vector(value.as_hash_bytes()));
-    let created_at = builder.create_string(&change.created_at);
-
-    let root = flatbuffer::create_canonical_change(
-        &mut builder,
-        &flatbuffer::CanonicalChangeArgs {
-            id,
-            entity_id,
-            schema_key,
-            schema_version,
-            file_id,
-            snapshot_ref,
-            metadata_ref,
-            created_at,
-        },
-    );
-    builder.finish(root, Some(CHANGELOG_FILE_IDENTIFIER));
-    Ok(builder.finished_data().to_vec())
-}
-
-pub(crate) fn decode_change(bytes: &[u8]) -> Result<CanonicalChange, LixError> {
-    if bytes.len() < flatbuffers::SIZE_UOFFSET + flatbuffers::FILE_IDENTIFIER_LENGTH
-        || !flatbuffers::buffer_has_identifier(bytes, CHANGELOG_FILE_IDENTIFIER, false)
-    {
-        return Err(LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            "failed to decode changelog change: invalid FlatBuffers file identifier",
-        ));
-    }
-
-    let change = flatbuffer::root_as_canonical_change(bytes).map_err(|error| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!("failed to decode changelog change: {error}"),
-        )
-    })?;
-
-    let entity_id = required_str(change.entity_id(), "entity_id")?;
-    let entity_id = EntityIdentity::from_string(entity_id).map_err(|error| {
-        LixError::unknown(format!(
-            "failed to decode changelog entity identity: {error}"
-        ))
-    })?;
-
-    Ok(CanonicalChange {
-        id: required_str(change.id(), "id")?.to_string(),
-        entity_id,
-        schema_key: required_str(change.schema_key(), "schema_key")?.to_string(),
-        schema_version: required_str(change.schema_version(), "schema_version")?.to_string(),
-        file_id: change.file_id().map(ToString::to_string),
-        snapshot_ref: optional_json_ref(change.snapshot_ref(), "snapshot_ref")?,
-        metadata_ref: optional_json_ref(change.metadata_ref(), "metadata_ref")?,
-        created_at: required_str(change.created_at(), "created_at")?.to_string(),
-    })
-}
-
-fn required_str<'a>(value: Option<&'a str>, field: &str) -> Result<&'a str, LixError> {
-    value.ok_or_else(|| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!("failed to decode changelog change: missing required field `{field}`"),
-        )
-    })
-}
-
-fn optional_json_ref(
-    value: Option<flatbuffers::Vector<'_, u8>>,
-    field: &str,
-) -> Result<Option<JsonRef>, LixError> {
-    let Some(value) = value else {
-        return Ok(None);
-    };
-    let bytes = value.bytes();
-    let hash = <[u8; 32]>::try_from(bytes).map_err(|_| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!("failed to decode changelog change: field `{field}` must be exactly 32 bytes"),
-        )
-    })?;
-    Ok(Some(JsonRef::from_hash_bytes(hash)))
-}
-
-mod flatbuffer {
-    #[derive(Copy, Clone, PartialEq)]
-    pub(super) struct CanonicalChange<'a> {
-        table: flatbuffers::Table<'a>,
-    }
-
-    impl<'a> flatbuffers::Follow<'a> for CanonicalChange<'a> {
-        type Inner = CanonicalChange<'a>;
-
-        #[inline]
-        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            Self {
-                table: unsafe { flatbuffers::Table::new(buf, loc) },
-            }
-        }
-    }
-
-    impl<'a> CanonicalChange<'a> {
-        const VT_ID: flatbuffers::VOffsetT = 4;
-        const VT_ENTITY_ID: flatbuffers::VOffsetT = 6;
-        const VT_SCHEMA_KEY: flatbuffers::VOffsetT = 8;
-        const VT_SCHEMA_VERSION: flatbuffers::VOffsetT = 10;
-        const VT_FILE_ID: flatbuffers::VOffsetT = 12;
-        const VT_SNAPSHOT_REF: flatbuffers::VOffsetT = 14;
-        const VT_METADATA_REF: flatbuffers::VOffsetT = 16;
-        const VT_CREATED_AT: flatbuffers::VOffsetT = 18;
-
-        #[inline]
-        pub(super) fn id(&self) -> Option<&'a str> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_ID, None)
-            }
-        }
-
-        #[inline]
-        pub(super) fn entity_id(&self) -> Option<&'a str> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_ENTITY_ID, None)
-            }
-        }
-
-        #[inline]
-        pub(super) fn schema_key(&self) -> Option<&'a str> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_SCHEMA_KEY, None)
-            }
-        }
-
-        #[inline]
-        pub(super) fn schema_version(&self) -> Option<&'a str> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_SCHEMA_VERSION, None)
-            }
-        }
-
-        #[inline]
-        pub(super) fn file_id(&self) -> Option<&'a str> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_FILE_ID, None)
-            }
-        }
-
-        #[inline]
-        pub(super) fn snapshot_ref(&self) -> Option<flatbuffers::Vector<'a, u8>> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
-                        Self::VT_SNAPSHOT_REF,
-                        None,
-                    )
-            }
-        }
-
-        #[inline]
-        pub(super) fn metadata_ref(&self) -> Option<flatbuffers::Vector<'a, u8>> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
-                        Self::VT_METADATA_REF,
-                        None,
-                    )
-            }
-        }
-
-        #[inline]
-        pub(super) fn created_at(&self) -> Option<&'a str> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_CREATED_AT, None)
-            }
-        }
-    }
-
-    impl flatbuffers::Verifiable for CanonicalChange<'_> {
-        #[inline]
-        fn run_verifier(
-            verifier: &mut flatbuffers::Verifier,
-            position: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            verifier
-                .visit_table(position)?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, true)?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "entity_id",
-                    Self::VT_ENTITY_ID,
-                    true,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "schema_key",
-                    Self::VT_SCHEMA_KEY,
-                    true,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "schema_version",
-                    Self::VT_SCHEMA_VERSION,
-                    true,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "file_id",
-                    Self::VT_FILE_ID,
-                    false,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
-                    "snapshot_ref",
-                    Self::VT_SNAPSHOT_REF,
-                    false,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
-                    "metadata_ref",
-                    Self::VT_METADATA_REF,
-                    false,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "created_at",
-                    Self::VT_CREATED_AT,
-                    true,
-                )?
-                .finish();
-            Ok(())
-        }
-    }
-
-    pub(super) struct CanonicalChangeArgs<'a> {
-        pub(super) id: flatbuffers::WIPOffset<&'a str>,
-        pub(super) entity_id: flatbuffers::WIPOffset<&'a str>,
-        pub(super) schema_key: flatbuffers::WIPOffset<&'a str>,
-        pub(super) schema_version: flatbuffers::WIPOffset<&'a str>,
-        pub(super) file_id: Option<flatbuffers::WIPOffset<&'a str>>,
-        pub(super) snapshot_ref: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub(super) metadata_ref: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub(super) created_at: flatbuffers::WIPOffset<&'a str>,
-    }
-
-    pub(super) fn create_canonical_change<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
-        builder: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
-        args: &'args CanonicalChangeArgs<'args>,
-    ) -> flatbuffers::WIPOffset<CanonicalChange<'bldr>> {
-        let start = builder.start_table();
-        builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            CanonicalChange::VT_CREATED_AT,
-            args.created_at,
-        );
-        if let Some(metadata_ref) = args.metadata_ref {
-            builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-                CanonicalChange::VT_METADATA_REF,
-                metadata_ref,
-            );
-        }
-        if let Some(snapshot_ref) = args.snapshot_ref {
-            builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-                CanonicalChange::VT_SNAPSHOT_REF,
-                snapshot_ref,
-            );
-        }
-        if let Some(file_id) = args.file_id {
-            builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-                CanonicalChange::VT_FILE_ID,
-                file_id,
-            );
-        }
-        builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            CanonicalChange::VT_SCHEMA_VERSION,
-            args.schema_version,
-        );
-        builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            CanonicalChange::VT_SCHEMA_KEY,
-            args.schema_key,
-        );
-        builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            CanonicalChange::VT_ENTITY_ID,
-            args.entity_id,
-        );
-        builder.push_slot_always::<flatbuffers::WIPOffset<_>>(CanonicalChange::VT_ID, args.id);
-        let offset = builder.end_table(start);
-        flatbuffers::WIPOffset::new(offset.value())
-    }
-
-    #[inline]
-    pub(super) fn root_as_canonical_change(
-        bytes: &[u8],
-    ) -> Result<CanonicalChange<'_>, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::root::<CanonicalChange>(bytes)
-    }
-}

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

@@ -1,92 +0,0 @@
-use crate::changelog::{CanonicalChange, ChangelogReader, ChangelogScanRequest};
-use crate::storage::{StorageReader, StorageWriteSet};
-use crate::LixError;
-use tokio::sync::Mutex;
-
-/// Durable append-only ledger for Lix changes.
-///
-/// This layer only records already-generated change facts. Transaction commit
-/// code is responsible for producing user changes plus normal `lix_commit`
-/// rows before appending them here.
-#[derive(Clone, Copy)]
-pub(crate) struct ChangelogContext;
-
-impl ChangelogContext {
-    pub(crate) fn new() -> Self {
-        Self
-    }
-
-    /// Creates a changelog reader over a caller-provided KV store.
-    ///
-    /// The caller decides which KV store supplies visibility for the read.
-    pub(crate) fn reader<S>(&self, store: S) -> ChangelogStoreReader<S>
-    where
-        S: StorageReader,
-    {
-        ChangelogStoreReader {
-            store: Mutex::new(store),
-        }
-    }
-
-    /// Creates a changelog writer over a transaction-local storage write set.
-    pub(crate) fn writer<'a>(&self, writes: &'a mut StorageWriteSet) -> ChangelogWriter<'a> {
-        ChangelogWriter { writes }
-    }
-}
-
-/// KV-backed changelog reader created by `ChangelogContext`.
-pub(crate) struct ChangelogStoreReader<S> {
-    store: Mutex<S>,
-}
-
-impl<S> ChangelogStoreReader<S>
-where
-    S: StorageReader,
-{
-    #[allow(dead_code)]
-    pub(crate) async fn load_change(
-        &self,
-        change_id: &str,
-    ) -> Result<Option<CanonicalChange>, LixError> {
-        let mut store = self.store.lock().await;
-        crate::changelog::storage::load_change(&mut *store, change_id).await
-    }
-
-    #[allow(dead_code)]
-    pub(crate) async fn scan_changes(
-        &self,
-        request: &ChangelogScanRequest,
-    ) -> Result<Vec<CanonicalChange>, LixError> {
-        let mut store = self.store.lock().await;
-        crate::changelog::storage::scan_changes(&mut *store, request).await
-    }
-}
-
-#[async_trait::async_trait]
-impl<S> ChangelogReader for ChangelogStoreReader<S>
-where
-    S: StorageReader,
-{
-    async fn load_change(&self, change_id: &str) -> Result<Option<CanonicalChange>, LixError> {
-        ChangelogStoreReader::load_change(self, change_id).await
-    }
-
-    async fn scan_changes(
-        &self,
-        request: &ChangelogScanRequest,
-    ) -> Result<Vec<CanonicalChange>, LixError> {
-        ChangelogStoreReader::scan_changes(self, request).await
-    }
-}
-
-/// Changelog writer over a transaction-local storage write set.
-pub(crate) struct ChangelogWriter<'a> {
-    writes: &'a mut StorageWriteSet,
-}
-
-impl ChangelogWriter<'_> {
-    #[allow(dead_code)]
-    pub(crate) fn stage_changes(&mut self, changes: &[CanonicalChange]) -> Result<(), LixError> {
-        crate::changelog::storage::stage_changes(self.writes, changes)
-    }
-}