Method write_import_graph_change

atomic-repository/src/repository/insert.rs:924–1065

Save and apply an already-built git-import graph change. This bypasses record/globalize and eager CRDT table writes. The caller has already compiled Git's snapshot delta into line-level graph ops. `preserve_existing_tree_paths` keeps deletions and renames graph-only while a different view owns the materialized working copy.

(
        &self,
        change: Change,
        deleted_paths: &[String],
        preserve_existing_tree_paths: bool,
        options: InsertOptions,
    )

    /// `preserve_existing_tree_paths` keeps deletions and renames graph-only
    /// while a different view owns the materialized working copy.
    pub fn write_import_graph_change(
        &self,
        change: Change,
        deleted_paths: &[String],
        preserve_existing_tree_paths: bool,
        options: InsertOptions,
    ) -> Result<ImportWriteOutcome, RepositoryError> {
        let mut timings = ImportWriteTimings::default();
        let view_name = options.view.as_deref().unwrap_or(&self.current_view);

        let mut txn = self
            .pristine
            .write_txn()
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        let assemble_start = std::time::Instant::now();
        let mut v3_bytes = Vec::new();
        let hash = change
            .serialize(&mut v3_bytes)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        let (final_change, verified_hash) = Change::deserialize(&mut v3_bytes.as_slice())
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        debug_assert_eq!(hash, verified_hash);
        timings.assemble_ms = assemble_start.elapsed().as_millis();

        // Idempotency guard for the single global GRAPH.
        //
        // A change is applied to the graph exactly once; views merely
        // reference it. Because import registers and applies a change in the
        // same transaction, an already-registered change has already been
        // applied — re-running its graph ops here would allocate a second
        // inode for every added path and manufacture a spurious name/order
        // conflict on materialize. This is exactly what `git import --all`
        // hits: a commit shared by two branches (a common ancestor) is
        // imported once per branch. Reference the already-applied change into
        // the target view instead — the same O(1) VIEW_CHANGES metadata
        // operation `insert` performs — rather than re-applying it.
        if let Some(change_id) = txn
            .get_internal(&hash)
            .map_err(|e| RepositoryError::Database(e.to_string()))?
        {
            use atomic_core::apply::compute_new_state;

            txn.put_change_deps(change_id, final_change.dependencies())
                .map_err(|e| RepositoryError::Database(e.to_string()))?;

            let mut view = txn
                .open_or_create_view(view_name)
                .map_err(|e| RepositoryError::Database(e.to_string()))?;

            // Only reference the change if this view does not already contain
            // it, so a genuine re-import never double-advances the merkle.
            let missing = filter_missing_in_view(&txn, &view, std::slice::from_ref(&hash))
                .map_err(|e| RepositoryError::Apply(e.to_string()))?;
            if !missing.is_empty() {
                let new_state = compute_new_state(&view.state, &hash);
                let sequence = view.change_count + 1;
                txn.put_change(&mut view, change_id, &hash)