@peerbit/native-backbone 0.2.9 → 0.2.11

package/src/append_tx/facts.rs

@@ -1,5 +1,5 @@
 use js_sys::{Array, Uint8Array};
-use peerbit_log_rust::LogIndexEntry;
+use peerbit_log_rust::{LogIndexEntry, NativeCommittedEntryFacts};
 use wasm_bindgen::prelude::*;
 
 use crate::append_tx::{
@@ -41,8 +41,82 @@ fn log_trim_entries_to_rows(values: Vec<LogIndexEntry>) -> Array {
     out
 }
 
+/// Additive compact row carrying the gid paired with every trimmed hash.
+/// The legacy hash-only compact row remains frozen in `append_tx::mod`.
+fn compact_committed_entry_facts_trim_refs_to_row(
+    entry: &NativeCommittedEntryFacts,
+    trim_hashes: Vec<String>,
+    trim_gids: Vec<String>,
+    document_trimmed_heads_processed: bool,
+) -> Array {
+    let row = Array::new();
+    row.push(&JsValue::from_str(&entry.hash));
+    row.push(&JsValue::from_f64(entry.byte_length as f64));
+    row.push(&Uint8Array::from(entry.meta_bytes.as_slice()));
+    row.push(&Uint8Array::from(entry.hash_digest_bytes.as_slice()));
+    row.push(&strings_to_array(trim_hashes));
+    row.push(&strings_to_array(trim_gids));
+    row.push(&JsValue::from_bool(document_trimmed_heads_processed));
+    row
+}
+
 #[wasm_bindgen]
 impl NativePeerbitBackbone {
+    /// Compact counterpart to `prepare_plain_entry_commit_facts`. This is an
+    /// additive export so older native bundles retain their frozen row shape.
+    #[allow(clippy::too_many_arguments)]
+    pub fn prepare_plain_entry_commit_facts_trim_refs(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        gid: String,
+        next: Array,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: usize,
+    ) -> Result<Array, JsValue> {
+        let (entry_facts, trim_refs) = if next.length() == 0 {
+            self.log
+                .prepare_entry_v0_plain_entry_commit_no_next_facts_core_profiled_and_put_with_builder_trim_refs(
+                    &self.builder,
+                    &mut self.blocks,
+                    wall_time,
+                    logical,
+                    gid,
+                    entry_type,
+                    optional_bytes_from_js(meta_data, "meta data")?,
+                    payload_data.to_vec(),
+                    trim_length_to,
+                    None,
+                )?
+        } else {
+            self.log
+                .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder_trim_refs(
+                    &self.builder,
+                    &mut self.blocks,
+                    wall_time,
+                    logical,
+                    gid,
+                    strings_from_array(next)?,
+                    entry_type,
+                    optional_bytes_from_js(meta_data, "meta data")?,
+                    payload_data.to_vec(),
+                    Some(trim_length_to),
+                    None,
+                )?
+        };
+        let out = Array::new();
+        out.push(&committed_entry_facts_to_row(
+            &entry_facts,
+            !entry_facts.next.is_empty(),
+        ));
+        let (trim_hashes, trim_gids) = trim_refs.into_iter().unzip();
+        out.push(&strings_to_array(trim_hashes));
+        out.push(&strings_to_array(trim_gids));
+        Ok(out)
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn prepare_plain_entry_commit_facts(
         &mut self,
@@ -472,6 +546,55 @@ impl NativePeerbitBackbone {
         )
     }
 
+    /// Additive trim-ref counterpart to the compact inline document-index
+    /// append. The hash-only export above retains its frozen row layout.
+    #[allow(clippy::too_many_arguments)]
+    pub fn prepare_plain_entry_commit_no_next_facts_document_index_compact_trim_refs(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: usize,
+        document_key: String,
+        document_value_prefix_bytes: Vec<u8>,
+        document_existing_created: String,
+        document_byte_element_index_limit: usize,
+        document_delete_trimmed_heads: bool,
+        document_projection_plan: JsValue,
+        document_projection_encoded_document: JsValue,
+        document_projection_signer: JsValue,
+    ) -> Result<Array, JsValue> {
+        let document_gid = gid.clone();
+        let payload_size = payload_data.length();
+        let document_index_commit = document_index_append_commit(
+            document_key,
+            document_value_prefix_bytes,
+            document_existing_created,
+            document_byte_element_index_limit,
+            document_delete_trimmed_heads,
+            document_projection_plan,
+            document_projection_encoded_document,
+            document_projection_signer,
+        )?;
+        Ok(
+            self.prepare_plain_entry_commit_no_next_document_index_compact_trim_refs(
+                wall_time,
+                logical,
+                gid,
+                entry_type,
+                meta_data,
+                payload_data,
+                trim_length_to,
+                document_gid,
+                payload_size,
+                document_index_commit,
+            )?,
+        )
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_trim_hashes(
         &mut self,
@@ -560,6 +683,50 @@ impl NativePeerbitBackbone {
         )
     }
 
+    /// Additive trim-ref counterpart to the latest-context document-index
+    /// append. Gids are returned parallel to the existing trimmed hashes.
+    #[allow(clippy::too_many_arguments)]
+    pub fn prepare_plain_entry_commit_latest_facts_document_index_trim_refs(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        fallback_gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: JsValue,
+        document_key: String,
+        document_value_prefix_bytes: Vec<u8>,
+        document_byte_element_index_limit: usize,
+        document_delete_trimmed_heads: bool,
+        document_projection_plan: JsValue,
+        document_projection_encoded_document: JsValue,
+        document_projection_signer: JsValue,
+    ) -> Result<Array, JsValue> {
+        let document_index_commit = document_index_append_commit(
+            document_key,
+            document_value_prefix_bytes,
+            String::new(),
+            document_byte_element_index_limit,
+            document_delete_trimmed_heads,
+            document_projection_plan,
+            document_projection_encoded_document,
+            document_projection_signer,
+        )?;
+        Ok(
+            self.prepare_plain_entry_commit_latest_document_index_trim_refs_inner(
+                wall_time,
+                logical,
+                fallback_gid,
+                entry_type,
+                meta_data,
+                payload_data,
+                trim_length_to,
+                document_index_commit,
+            )?,
+        )
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn prepare_plain_entry_commit_latest_facts_document_index_cached_plan_trim_hashes(
         &mut self,
@@ -600,6 +767,48 @@ impl NativePeerbitBackbone {
         )
     }
 
+    /// Cached-plan counterpart to
+    /// `prepare_plain_entry_commit_latest_facts_document_index_trim_refs`.
+    #[allow(clippy::too_many_arguments)]
+    pub fn prepare_plain_entry_commit_latest_facts_document_index_cached_plan_trim_refs(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        fallback_gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: JsValue,
+        document_key: String,
+        document_byte_element_index_limit: usize,
+        document_delete_trimmed_heads: bool,
+        document_projection_plan_id: u32,
+        document_projection_encoded_document: JsValue,
+        document_projection_signer: JsValue,
+    ) -> Result<Array, JsValue> {
+        let document_index_commit = document_index_cached_projection_append_commit(
+            document_key,
+            String::new(),
+            document_byte_element_index_limit,
+            document_delete_trimmed_heads,
+            document_projection_plan_id,
+            document_projection_encoded_document,
+            document_projection_signer,
+        )?;
+        Ok(
+            self.prepare_plain_entry_commit_latest_document_index_trim_refs_inner(
+                wall_time,
+                logical,
+                fallback_gid,
+                entry_type,
+                meta_data,
+                payload_data,
+                trim_length_to,
+                document_index_commit,
+            )?,
+        )
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_trim_hashes(
         &mut self,
@@ -646,6 +855,52 @@ impl NativePeerbitBackbone {
         )
     }
 
+    /// Additive trim-ref counterpart to the cached-plan compact append.
+    #[allow(clippy::too_many_arguments)]
+    pub fn prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_trim_refs(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: usize,
+        document_key: String,
+        document_existing_created: String,
+        document_byte_element_index_limit: usize,
+        document_delete_trimmed_heads: bool,
+        document_projection_plan_id: u32,
+        document_projection_encoded_document: JsValue,
+        document_projection_signer: JsValue,
+    ) -> Result<Array, JsValue> {
+        let document_gid = gid.clone();
+        let payload_size = payload_data.length();
+        let document_index_commit = document_index_cached_projection_append_commit(
+            document_key,
+            document_existing_created,
+            document_byte_element_index_limit,
+            document_delete_trimmed_heads,
+            document_projection_plan_id,
+            document_projection_encoded_document,
+            document_projection_signer,
+        )?;
+        Ok(
+            self.prepare_plain_entry_commit_no_next_document_index_compact_trim_refs(
+                wall_time,
+                logical,
+                gid,
+                entry_type,
+                meta_data,
+                payload_data,
+                trim_length_to,
+                document_gid,
+                payload_size,
+                document_index_commit,
+            )?,
+        )
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_trim_hashes_plain_put_payload(
         &mut self,
@@ -706,6 +961,71 @@ impl NativePeerbitBackbone {
             document_trimmed_heads_processed,
         ))
     }
+
+    /// Additive trim-ref counterpart to the cached-plan compact append that
+    /// reuses the plain payload bytes for the document-index put.
+    #[allow(clippy::too_many_arguments)]
+    pub fn prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_trim_refs_plain_put_payload(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: usize,
+        document_key: String,
+        document_existing_created: String,
+        document_byte_element_index_limit: usize,
+        document_delete_trimmed_heads: bool,
+        document_projection_plan_id: u32,
+        document_projection_signer: JsValue,
+    ) -> Result<Array, JsValue> {
+        let document_gid = gid.clone();
+        let payload_size = payload_data.length();
+        let payload_data = payload_data.to_vec();
+        let document_index_commit =
+            document_index_cached_projection_plain_put_payload_append_commit(
+                document_key,
+                document_existing_created,
+                document_byte_element_index_limit,
+                document_delete_trimmed_heads,
+                document_projection_plan_id,
+                document_projection_signer,
+            )?;
+        let delete_trimmed_document_heads = document_index_commit.delete_trimmed_heads;
+        let (entry_facts, trim_refs) = self
+            .log
+            .prepare_entry_v0_plain_entry_commit_no_next_facts_core_profiled_and_put_with_builder_trim_refs_borrowed(
+                &self.builder,
+                &mut self.blocks,
+                wall_time,
+                logical,
+                gid,
+                entry_type,
+                optional_bytes_from_js(meta_data, "meta data")?,
+                &payload_data,
+                trim_length_to,
+                None,
+            )?;
+        self.put_document_index_for_append_with_plain_put_payload(
+            Some(document_index_commit),
+            wall_time,
+            &entry_facts.hash,
+            &document_gid,
+            payload_size,
+            Some(&payload_data),
+        )?;
+        let (trim_hashes, trim_gids): (Vec<String>, Vec<String>) = trim_refs.into_iter().unzip();
+        let document_trimmed_heads_processed = delete_trimmed_document_heads
+            && self.delete_documents_by_context_heads_profiled(&trim_hashes);
+        Ok(compact_committed_entry_facts_trim_refs_to_row(
+            &entry_facts,
+            trim_hashes,
+            trim_gids,
+            document_trimmed_heads_processed,
+        ))
+    }
 }
 
 impl NativePeerbitBackbone {
@@ -798,6 +1118,53 @@ impl NativePeerbitBackbone {
         Ok(out)
     }
 
+    #[allow(clippy::too_many_arguments)]
+    fn prepare_plain_entry_commit_no_next_document_index_compact_trim_refs(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: usize,
+        document_gid: String,
+        payload_size: u32,
+        document_index_commit: DocumentIndexAppendCommit,
+    ) -> Result<Array, BackboneError> {
+        let delete_trimmed_document_heads = document_index_commit.delete_trimmed_heads;
+        let (entry_facts, trim_refs) = self
+            .log
+            .prepare_entry_v0_plain_entry_commit_no_next_facts_core_profiled_and_put_with_builder_trim_refs(
+                &self.builder,
+                &mut self.blocks,
+                wall_time,
+                logical,
+                gid,
+                entry_type,
+                optional_bytes_from_js(meta_data, "meta data")?,
+                payload_data.to_vec(),
+                trim_length_to,
+                None,
+            )?;
+        self.put_document_index_for_append(
+            Some(document_index_commit),
+            wall_time,
+            &entry_facts.hash,
+            &document_gid,
+            payload_size,
+        )?;
+        let (trim_hashes, trim_gids): (Vec<String>, Vec<String>) = trim_refs.into_iter().unzip();
+        let document_trimmed_heads_processed = delete_trimmed_document_heads
+            && self.delete_documents_by_context_heads_profiled(&trim_hashes);
+        Ok(compact_committed_entry_facts_trim_refs_to_row(
+            &entry_facts,
+            trim_hashes,
+            trim_gids,
+            document_trimmed_heads_processed,
+        ))
+    }
+
     #[allow(clippy::too_many_arguments)]
     fn prepare_plain_entry_commit_latest_document_index_trim_hashes_inner(
         &mut self,
@@ -854,4 +1221,63 @@ impl NativePeerbitBackbone {
         );
         Ok(out)
     }
+
+    #[allow(clippy::too_many_arguments)]
+    fn prepare_plain_entry_commit_latest_document_index_trim_refs_inner(
+        &mut self,
+        wall_time: u64,
+        logical: u32,
+        fallback_gid: String,
+        entry_type: u8,
+        meta_data: JsValue,
+        payload_data: Uint8Array,
+        trim_length_to: JsValue,
+        mut document_index_commit: DocumentIndexAppendCommit,
+    ) -> Result<Array, BackboneError> {
+        let trim_length_to = optional_usize_from_js(trim_length_to, "trimLengthTo")?;
+        let (previous_context, gid, next_hashes) =
+            self.resolve_latest_document_append_context(&mut document_index_commit, fallback_gid)?;
+        let delete_trimmed_document_heads = document_index_commit.delete_trimmed_heads;
+        let payload_size = payload_data.length();
+        let (entry_facts, trim_refs) = self
+            .log
+            .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder_trim_refs(
+                &self.builder,
+                &mut self.blocks,
+                wall_time,
+                logical,
+                gid.clone(),
+                next_hashes,
+                entry_type,
+                optional_bytes_from_js(meta_data, "meta data")?,
+                payload_data.to_vec(),
+                trim_length_to,
+                None,
+            )?;
+        self.put_document_index_for_append(
+            Some(document_index_commit),
+            wall_time,
+            &entry_facts.hash,
+            &gid,
+            payload_size,
+        )?;
+        let (trim_hashes, trim_gids): (Vec<String>, Vec<String>) = trim_refs.into_iter().unzip();
+        let document_trimmed_heads_processed = delete_trimmed_document_heads
+            && self.delete_documents_by_context_heads_profiled(&trim_hashes);
+        let out = Array::new();
+        out.push(&committed_entry_facts_to_row(
+            &entry_facts,
+            !entry_facts.next.is_empty(),
+        ));
+        out.push(&strings_to_array(trim_hashes));
+        out.push(&strings_to_array(trim_gids));
+        out.push(&JsValue::from_bool(document_trimmed_heads_processed));
+        out.push(
+            &previous_context
+                .as_ref()
+                .map(|context| document_context_facts_to_row(context).into())
+                .unwrap_or(JsValue::UNDEFINED),
+        );
+        Ok(out)
+    }
 }

package/src/append_tx/mod.rs

@@ -32,6 +32,7 @@ struct LatestCompactBatchPendingAppend {
     gid: String,
     entry_facts: NativeCommittedEntryFacts,
     trim_hashes: Vec<String>,
+    trim_gids: Vec<String>,
     document_index_commit: DocumentIndexAppendCommit,
     previous_document_context: Option<DocumentContextFacts>,
     delete_trimmed_document_heads: bool,
@@ -44,6 +45,7 @@ struct LatestBatchPendingAppend {
     next_hashes: Vec<String>,
     meta_bytes: Vec<u8>,
     trim_hashes: Vec<String>,
+    trim_gids: Vec<String>,
     // Owned committed-append facts and resolved trimmed entries; the frozen JS
     // `entry_row`/`trim_rows` layouts are rebuilt at the consume boundary so
     // this pending state stays JS-free (no `js_sys::Array` captured in core
@@ -186,6 +188,14 @@ fn push_optional_trim_result(row: &Array, trim_hashes: Vec<String>, document_tri
     }
 }
 
+fn push_trim_gid_extension(row: &Array, trim_gids: Vec<String>) {
+    if trim_gids.is_empty() {
+        return;
+    }
+    row.push(&JsValue::UNDEFINED);
+    row.push(&strings_to_array(trim_gids));
+}
+
 fn ensure_batch_append_lens(
     len: usize,
     wall_times: &BigUint64Array,
@@ -276,13 +286,13 @@ impl NativePeerbitBackbone {
         meta_data: Option<Vec<u8>>,
         payload_data: &[u8],
         trim_length_to: Option<usize>,
-    ) -> Result<(NativeCommittedEntryFacts, Vec<String>), BackboneError> {
+    ) -> Result<(NativeCommittedEntryFacts, Vec<String>, Vec<String>), BackboneError> {
         let profile_enabled = self.append_profile_enabled;
         let log_started = profile_enabled.then(crate::time::now_ms);
         let mut log_profile = NativeLogAppendProfile::default();
-        let result = if let Some(trim_length_to) = trim_length_to {
+        let (entry, refs) = if let Some(trim_length_to) = trim_length_to {
             self.log
-                .prepare_entry_v0_plain_entry_commit_no_next_facts_core_profiled_and_put_with_builder_trim_hashes_borrowed(
+                .prepare_entry_v0_plain_entry_commit_no_next_facts_core_profiled_and_put_with_builder_trim_refs_borrowed(
                     &self.builder,
                     &mut self.blocks,
                     wall_time,
@@ -311,11 +321,12 @@ impl NativePeerbitBackbone {
                 Vec::new(),
             )
         };
+        let (hashes, gids) = refs.into_iter().unzip();
         if let Some(started) = log_started {
             self.append_profile.log_total_ms += crate::time::now_ms() - started;
             self.append_profile.add_log_profile(&log_profile);
         }
-        Ok(result)
+        Ok((entry, hashes, gids))
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -329,13 +340,13 @@ impl NativePeerbitBackbone {
         meta_data: Option<Vec<u8>>,
         payload_data: &[u8],
         trim_length_to: Option<usize>,
-    ) -> Result<(NativeCommittedEntryFacts, Vec<String>), BackboneError> {
+    ) -> Result<(NativeCommittedEntryFacts, Vec<String>, Vec<String>), BackboneError> {
         let profile_enabled = self.append_profile_enabled;
         let log_started = profile_enabled.then(crate::time::now_ms);
         let mut log_profile = NativeLogAppendProfile::default();
-        let result = self
+        let (entry, refs) = self
             .log
-            .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder_trim_hashes_borrowed(
+            .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder_trim_refs_borrowed(
                 &self.builder,
                 &mut self.blocks,
                 wall_time,
@@ -352,7 +363,8 @@ impl NativePeerbitBackbone {
             self.append_profile.log_total_ms += crate::time::now_ms() - started;
             self.append_profile.add_log_profile(&log_profile);
         }
-        Ok(result)
+        let (hashes, gids) = refs.into_iter().unzip();
+        Ok((entry, hashes, gids))
     }
 
     /// JS-free committed-log append: performs the log append and (optionally)
@@ -373,11 +385,19 @@ impl NativePeerbitBackbone {
         payload_data: Vec<u8>,
         trim_length_to: Option<usize>,
         resolve_trimmed_entries: bool,
-    ) -> Result<(NativeCommittedEntryFacts, Vec<LogIndexEntry>, Vec<String>), BackboneError> {
+    ) -> Result<
+        (
+            NativeCommittedEntryFacts,
+            Vec<LogIndexEntry>,
+            Vec<String>,
+            Vec<String>,
+        ),
+        BackboneError,
+    > {
         let profile_enabled = self.append_profile_enabled;
         let log_started = profile_enabled.then(crate::time::now_ms);
         let mut log_profile = NativeLogAppendProfile::default();
-        let (entry_facts, trimmed_entries, trim_hashes) = if resolve_trimmed_entries {
+        let (entry_facts, trimmed_entries, trim_hashes, trim_gids) = if resolve_trimmed_entries {
             let (entry_facts, trimmed_entries) = self
                 .log
                 .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder(
@@ -397,11 +417,14 @@ impl NativePeerbitBackbone {
                 .iter()
                 .map(|entry| entry.hash.clone())
                 .collect::<Vec<_>>();
-            (entry_facts, trimmed_entries, trim_hashes)
+            // Resolved trim rows already carry their gids. Keep the additive
+            // gid suffix for hashes-only mode, where the rows cannot provide
+            // them, and avoid cloning the strings on materialized paths.
+            (entry_facts, trimmed_entries, trim_hashes, Vec::new())
         } else {
-            let (entry_facts, trim_hashes) = self
+            let (entry_facts, trim_refs) = self
                 .log
-                .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder_trim_hashes(
+                .prepare_entry_v0_plain_entry_commit_facts_core_profiled_and_put_with_builder_trim_refs(
                     &self.builder,
                     &mut self.blocks,
                     wall_time,
@@ -414,13 +437,14 @@ impl NativePeerbitBackbone {
                     trim_length_to,
                     profile_enabled.then_some(&mut log_profile),
                 )?;
-            (entry_facts, Vec::new(), trim_hashes)
+            let (trim_hashes, trim_gids) = trim_refs.into_iter().unzip();
+            (entry_facts, Vec::new(), trim_hashes, trim_gids)
         };
         if let Some(started) = log_started {
             self.append_profile.log_total_ms += crate::time::now_ms() - started;
             self.append_profile.add_log_profile(&log_profile);
         }
-        Ok((entry_facts, trimmed_entries, trim_hashes))
+        Ok((entry_facts, trimmed_entries, trim_hashes, trim_gids))
     }
 
     /// Build the frozen committed-append entry row from owned facts, timing the
@@ -471,8 +495,17 @@ impl NativePeerbitBackbone {
         payload_data: Vec<u8>,
         trim_length_to: Option<usize>,
         resolve_trimmed_entries: bool,
-    ) -> Result<(NativeCommittedEntryFacts, Vec<String>, Array, Array), BackboneError> {
-        let (entry_facts, trimmed_entries, trim_hashes) = self
+    ) -> Result<
+        (
+            NativeCommittedEntryFacts,
+            Vec<String>,
+            Vec<String>,
+            Array,
+            Array,
+        ),
+        BackboneError,
+    > {
+        let (entry_facts, trimmed_entries, trim_hashes, trim_gids) = self
             .prepare_committed_log_append_owned_profiled(
                 wall_time,
                 logical,
@@ -489,7 +522,7 @@ impl NativePeerbitBackbone {
             trimmed_entries,
             resolve_trimmed_entries,
         );
-        Ok((entry_facts, trim_hashes, entry_row, trim_rows))
+        Ok((entry_facts, trim_hashes, trim_gids, entry_row, trim_rows))
     }
 
     #[allow(clippy::too_many_arguments)]