Struct MergeStateFile 

pub struct MergeStateFile {
    pub phase: MergePhase,
    pub sources: Vec<WorkspaceId>,
    pub epoch_before: EpochId,
    pub frozen_heads: BTreeMap<WorkspaceId, GitOid>,
    pub epoch_candidate: Option<GitOid>,
    pub validation_result: Option<ValidationResult>,
    pub epoch_after: Option<EpochId>,
    pub started_at: u64,
    pub updated_at: u64,
    pub abort_reason: Option<String>,
}

The persisted merge-state file.

Written to .manifold/merge-state.json. Every mutation is fsynced to disk so a crash always leaves a valid, recoverable file.

Fields

phase: MergePhase

Current merge phase.

sources: Vec<WorkspaceId>

Source workspaces being merged.

epoch_before: EpochId

The epoch before this merge started.

frozen_heads: BTreeMap<WorkspaceId, GitOid>

Frozen workspace HEAD commit OIDs, recorded during PREPARE.

Maps each source workspace to its HEAD at the time inputs were frozen. After PREPARE, these are immutable references — the merge operates on these exact commits regardless of any concurrent workspace activity.

epoch_candidate: Option<GitOid>

The candidate commit produced during BUILD (set in Build phase).

validation_result: Option<ValidationResult>

The validation result (set in Validate phase).

epoch_after: Option<EpochId>

The new epoch after COMMIT (set in Commit phase).

started_at: u64

Unix timestamp (seconds) when the merge started.

updated_at: u64

Unix timestamp (seconds) of the last state update.

abort_reason: Option<String>

Abort reason, if the merge was aborted.

Implementations

impl MergeStateFile

pub const fn new( sources: Vec<WorkspaceId>, epoch_before: EpochId, now: u64, ) -> Self

Create a new merge-state file in the Prepare phase.

Arguments

• sources - The workspaces being merged.
• epoch_before - The current epoch at the start of the merge.
• now - The current Unix timestamp in seconds.

pub fn advance( &mut self, next: MergePhase, now: u64, ) -> Result<(), MergeStateError>

Advance to the next phase, updating the timestamp.

Errors

Returns MergeStateError::InvalidTransition if the transition is not allowed.

pub fn abort( &mut self, reason: impl Into<String>, now: u64, ) -> Result<(), MergeStateError>

Abort the merge with a reason.

Errors

Returns MergeStateError::InvalidTransition if the merge is already in a terminal state.

pub fn to_json(&self) -> Result<String, MergeStateError>

Serialize to pretty-printed JSON.

Errors

Returns MergeStateError::Serialize on serialization failure.

pub fn from_json(json: &str) -> Result<Self, MergeStateError>

Deserialize from a JSON string.

Errors

Returns MergeStateError::Deserialize on parse failure.

pub fn write_exclusive(&self, path: &Path) -> Result<bool, MergeStateError>

Create the merge-state file exclusively (O_CREAT | O_EXCL).

Uses OpenOptions::create_new(true) so exactly one writer wins. Returns Ok(true) on success, Ok(false) if the file already exists, and Err on any other I/O error.

The write is crash-safe: data is serialized, written, and fsynced directly to the target path. Unlike write_atomic, there is no temp+rename dance because the O_EXCL flag already guarantees the file did not exist.

pub fn write_atomic(&self, path: &Path) -> Result<(), MergeStateError>

Write the merge-state file atomically with fsync.

1. Serialize to pretty JSON.
2. Write to a temporary file in the same directory.
3. fsync the temporary file.
4. Rename (atomic on POSIX) over the target path.

Errors

Returns MergeStateError on I/O or serialization failure.

pub fn read(path: &Path) -> Result<Self, MergeStateError>

Read a merge-state file from disk.

Errors

Returns MergeStateError::NotFound if the file does not exist. Returns MergeStateError::Deserialize if the file is malformed.

pub fn default_path(manifold_dir: &Path) -> PathBuf

Return the default merge-state file path for a .manifold/ directory.

Trait Implementations

impl Clone for MergeStateFile

fn clone(&self) -> MergeStateFile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MergeStateFile

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MergeStateFile

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MergeStateFile

fn eq(&self, other: &MergeStateFile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MergeStateFile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MergeStateFile

impl StructuralPartialEq for MergeStateFile