feat(reconstruction): Add mutable construtors

Author: rkuris

firewood/src/db.rs

@@ -21,7 +21,7 @@ use crate::manager::{ConfigManager, RevisionManager, RevisionManagerConfig};
 use firewood_metrics::firewood_counter;
 use firewood_storage::{
     CheckOpt, CheckerReport, Committed, FileBacked, FileIoError, HashedNodeReader,
-    ImmutableProposal, NodeHashAlgorithm, NodeStore, Parentable, ReadableStorage,
+    ImmutableProposal, MutableProposal, NodeHashAlgorithm, NodeStore, Parentable, ReadableStorage,
     Reconstructed as StorageReconstructed, TrieReader,
 };
 use nonzero_ext::nonzero;
@@ -488,9 +488,7 @@ impl api::Reconstructible for &NodeStore<Committed, FileBacked> {
     where
         Self: Sized,
     {
-        let _ = batch.into_iter();
-        let _ = self;
-        todo!("historical reconstruction pipeline is not implemented yet")
+        reconstruct_with_parent(self, batch)
     }
 }
 
@@ -501,12 +499,41 @@ impl api::Reconstructible for Reconstructed {
     where
         Self: Sized,
     {
-        let _ = batch.into_iter();
-        let _ = self;
-        todo!("linear reconstructed->reconstructed pipeline is not implemented yet")
+        reconstruct_with_parent(&*self.nodestore, batch)
     }
 }
 
+fn reconstruct_with_parent<P>(
+    parent: &NodeStore<P, FileBacked>,
+    batch: impl IntoBatchIter,
+) -> Result<Reconstructed, api::Error>
+where
+    NodeStore<P, FileBacked>: TrieReader + HashedNodeReader,
+{
+    let proposal = NodeStore::<MutableProposal, _>::new_for_reconstruction(parent)?;
+    let mut merkle = Merkle::from(proposal);
+
+    for res in batch.into_iter().into_batch_iter::<api::Error>() {
+        match res? {
+            BatchOp::Put { key, value } => {
+                merkle.insert(key.as_ref(), value.as_ref().into())?;
+            }
+            BatchOp::Delete { key } => {
+                merkle.remove(key.as_ref())?;
+            }
+            BatchOp::DeleteRange { prefix } => {
+                merkle.remove_prefix(prefix.as_ref())?;
+            }
+        }
+    }
+
+    let nodestore = merkle.into_inner();
+    let reconstructed = Arc::new(nodestore.try_into()?);
+    Ok(Reconstructed {
+        nodestore: reconstructed,
+    })
+}
+
 #[cfg(test)]
 mod test {
     #![expect(clippy::unwrap_used)]

storage/src/nodestore/mod.rs

@@ -282,6 +282,40 @@ impl<S: ReadableStorage> NodeStore<MutableProposal, S> {
         })
     }
 
+    /// Create a new mutable nodestore for reconstruction from a read-capable parent.
+    ///
+    /// Unlike [`NodeStore::new`], this constructor does not require `Parentable`.
+    /// It is intended for linear reconstruction flows (e.g. historical or reconstructed views)
+    /// that should not participate in proposal parent/reparent semantics.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`FileIoError`] if the parent root cannot be read.
+    pub fn new_for_reconstruction<T>(parent: &NodeStore<T, S>) -> Result<Self, FileIoError>
+    where
+        NodeStore<T, S>: TrieReader + HashedNodeReader,
+    {
+        let mut deleted = Vec::default();
+        let root = if let Some(root) = parent.root_as_maybe_persisted_node() {
+            deleted.push(root.clone());
+            let root = root.as_shared_node(parent)?.deref().clone();
+            Some(root)
+        } else {
+            None
+        };
+
+        let kind = MutableProposal {
+            root,
+            deleted,
+            parent: NodeStoreParent::Committed(parent.root_hash()),
+        };
+
+        Ok(NodeStore {
+            kind,
+            storage: parent.storage.clone(),
+        })
+    }
+
     /// Marks the node at `addr` as deleted in this proposal.
     pub fn delete_node(&mut self, node: MaybePersistedNode) {
         trace!("Pending delete at {node:?}");