Struct CommitWorkspace 

pub struct CommitWorkspace {
    pub landing: LandingWorkspace,
    pub object_directory: PathBuf,
    pub hooks_directory: PathBuf,
    /* private fields */
}

What: The owned state of one transaction. Why: The landing reads the LandingWorkspace part; the rest names the places disposal and preparation use.

In TS you’d write (pseudocode):

type CommitTransactionWorkspace = { transactionId; directory; commitIndexPath; capturedIndexPath; shadowPath; objectDirectory; hooksDirectory };

Fields

landing: LandingWorkspace

The part the landing attempt reads and marks.

object_directory: PathBuf

Shadow object store receiving every object the transaction writes before landing migrates them.

hooks_directory: PathBuf

Hook dispatcher directory.

Implementations

impl CommitWorkspace

pub fn finish_transaction(&mut self)

What: Mark durable completion, so disposal removes the recovery artifacts. Why: After the landed commit’s cleanup the landing’s preserved mark no longer protects anything.

In TS you’d write (pseudocode):

workspace.finishTransaction();

pub fn dispose(&mut self) -> Result<(), RecoveryError>

What: Remove the shadow repository, then the directory, then prune landed captures, unless recovery owns them. Why: Later calls do nothing, and a failed removal is reported while the directory stays for recovery.

In TS you’d write (pseudocode):

await workspace[Symbol.asyncDispose]();

pub fn git_dir(&self) -> &Path

What: The Git directory of the owning worktree. Why: Post-landing completion prunes the capture store there.

In TS you’d write (pseudocode):

capture.gitDir

pub fn registry_root(&self) -> &Path

What: The transaction registry root. Why: Post-landing completion and the reservation read it.

In TS you’d write (pseudocode):

capture.registryRoot

pub fn mark_disposed(&mut self)

What: Hand the disposal to a later step, which has already removed what the workspace owns. Why: The post-landing completion removes the shadow and the directory itself, so the drop must not repeat it.

In TS you’d write (pseudocode):

workspace.finishTransaction(); await workspace[Symbol.asyncDispose]();

Trait Implementations

impl Debug for CommitWorkspace

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for CommitWorkspace

fn drop(&mut self)

What: Dispose of the workspace when the transaction ends by any route. Why: A failure before the landing must not leave a shadow repository or a directory behind.

In TS you’d write (pseudocode):

await using workspace = ...;

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.