Method write_recorded

atomic-repository/src/repository/insert.rs:2069–2252

Write a recorded change to the repository. This method inserts a change that was just recorded, updating both the graph and the tree tables. It's the integration point between recording and inserting. Unlike `insert_change`, this method: - Takes the change directly (doesn't load from store) - Updates tree tables for FileAdd hunks - Assigns new inodes to added files # Arguments `outcome` - The

(
        &self,
        outcome: &RecordOutcome,
        mut options: InsertOptions,
    )

    /// println!("Inserted with state: {}", apply_outcome.new_state.to_base32());
    /// ```
    pub fn write_recorded(
        &self,
        outcome: &RecordOutcome,
        mut options: InsertOptions,
    ) -> Result<InsertOutcome, RepositoryError> {
        let trace_record = std::env::var_os("ATOMIC_TRACE_RECORD").is_some();
        let change = outcome.change();
        let hash = outcome.hash();

        // A freshly-recorded change is applied to the view it was recorded on.
        // Its dependency closure is complete by construction, so it cannot
        // produce zombie or missing-context conflicts. Disable conflict
        // detection to skip the per-hunk zombie/deleted-context graph scans
        // (the dominant apply cost on large changes); the graph written is
        // identical, only the (empty) conflict report is skipped.
        options.track_conflicts = false;

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

        // Register the change to get an internal ID
        let change_id = txn
            .register_change(hash)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        txn.put_change_deps(change_id, change.dependencies())
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        // Determine which view to use
        let view_name = options.view.as_deref().unwrap_or(&self.current_view);
        let preserve_existing_tree_paths = view_name != self.current_view;
        let tree_ops = collect_tree_ops(&txn, *hash, change, outcome.deleted_files())?;

        // Before applying atoms, set up tree entries for FileAdd hunks.
        // This creates the inode→position and path→inode mappings needed
        // for the graph operations.
        //
        // Note: put_tree creates both TREE and REV_TREE entries.
        //       put_inode creates both INODES and REV_INODES entries.
        for graph_op in change.hunks() {
            match graph_op {
                GraphOp::FileAdd {
                    add_inode, path, ..
                } => {
                    // Allocate a new inode for this file
                    let new_inode = txn
                        .alloc_inode()
                        .map_err(|e| RepositoryError::Database(e.to_string()))?;

                    // The inode span position is relative to this change.
                    // Since add_inode.start is a ChangePosition within this change's content,
                    // we create an internal position using the change_id we just registered.
                    let inode_position = Position::new(change_id, add_inode.start);

                    // Add to tree tables:
                    // - put_tree: path ↔ inode (TREE and REV_TREE)