Method assemble_and_hash

atomic-repository/src/repository/record.rs:885–953

Fast path for external importers (e.g. git-import) that already have pre-built `RecordedFile`s and just need globalization + assembly + hashing. Returns `(Change, Hash)`.

(
        &self,
        header: ChangeHeader,
        recorded_files: &[atomic_core::record::workflow::RecordedFile],
    )

    ///
    /// Returns `(Change, Hash)`.
    pub fn assemble_and_hash(
        &self,
        header: ChangeHeader,
        recorded_files: &[atomic_core::record::workflow::RecordedFile],
    ) -> Result<(Change, Hash), RecordError> {
        use atomic_core::record::workflow::assemble_change;
        use atomic_core::record::workflow::assembly::AssemblyOptions;

        let overall_start = std::time::Instant::now();

        let txn = self
            .pristine
            .read_txn()
            .map_err(|e| RecordError::Database(e.to_string()))?;

        // Use a bare transaction — no ViewGraph filter needed.
        //
        // This method is the fast path for git import, where every change
        // is written to a shared view and all edges land in the global
        // GRAPH table.  A bare ReadTxn sees every edge directly.
        //
        // Wrapping in ViewGraph + collect_visible_change_ids would scan
        // the entire view change log on every call (O(N) per commit,
        // O(N²) total for N commits), which makes large imports
        // progressively slower.
        let assembly_options = AssemblyOptions::default();

        let assembly_result = assemble_change(&txn, recorded_files, header, &assembly_options)?;

        let change = assembly_result.into_change();
        log::debug!(
            "assemble_and_hash: assembly complete, content_size={} hunks={}",
            change.contents.len(),
            change.hunks().len(),
        );

        let step = std::time::Instant::now();
        let mut v3_bytes = Vec::new();
        let hash = change
            .serialize(&mut v3_bytes)
            .map_err(|e| RecordError::ChangeStore(e.to_string()))?;
        let serialize_ms = step.elapsed().as_millis();

        let step = std::time::Instant::now();
        let (final_change, _) = Change::deserialize(&mut v3_bytes.as_slice())
            .map_err(|e| RecordError::ChangeStore(e.to_string()))?;
        let deserialize_ms = step.elapsed().as_millis();

        let total_ms = overall_start.elapsed().as_millis();
        if serialize_ms + deserialize_ms > 100 {
            log::warn!(
                "assemble_and_hash: serialize={}ms ({} bytes) deserialize={}ms total={}ms",
                serialize_ms,
                v3_bytes.len(),
                deserialize_ms,
                total_ms,
            );
        } else {