Struct LiveFrontierOwner 

pub struct LiveFrontierOwner { /* private fields */ }

Complete executable frontier, closure-accounting, and keyed-retention owner.

The owner is intentionally move-only. It is the only live mutation input and never exposes a constructor from independent frontier/accounting components. Frontier, closure, retained charges, and participant history therefore cannot be cloned or recombined from different owners:

use liminal_protocol::lifecycle::LiveFrontierOwner;

fn clone_frontier(owner: &LiveFrontierOwner) -> LiveFrontierOwner {
    owner.clone()
}

use liminal_protocol::lifecycle::LiveFrontierOwner;

fn splice(left: &mut LiveFrontierOwner, right: LiveFrontierOwner) {
    left.frontiers = right.frontiers;
    left.closure_accounting = right.closure_accounting;
    left.retained_charges = right.retained_charges;
}

Implementations

impl LiveFrontierOwner

pub fn complete_pending_died_ordinary_finalizer( self, finalizer: PendingDiedOrdinaryFinalizer, ) -> Result<Self, LiveFrontierError>

Applies a measured Ordinary floor after its enclosing finalizer transition.

Errors

Returns LiveFrontierError if retained charges, the measured floor, marker precedence, or closure accounting disagree with the post-finalizer owner.

impl LiveFrontierOwner

pub fn prepare_binding_fate( self, token: SealedBindingFateToken, terminal: BindingFateTerminal, hard_observer_progress: DeliverySeq, ) -> Result<PreparedBindingFate, Box<BindingFateMeasurementRefused>>

Consumes one sealed fate token after measuring its real post-release floor.

The server supplies only hard observer progress and the closed terminal class. The participant, binding epoch, current retained floor, candidate high watermark, and remaining member cursors all come from protocol-owned state. Recovered internally mints its event and accepts no terminal.

Errors

Returns every input unchanged when authority, terminal class, observer progress, or checked floor validation fails.

pub fn prepare_pending_died_ordinary_finalizer( self, token: SealedBindingFateToken, terminal: CommittedDiedTerminal, hard_observer_progress: DeliverySeq, ) -> Result<PreparedPendingDiedOrdinaryFinalizer, Box<BindingFateMeasurementRefused>>

Measures Ordinary without installing its owner transition before an enclosing finalizer.

Errors

Returns every move-only input unchanged when the token, terminal, observer progress, measured floor, or pre-finalizer owner transition is inconsistent.

pub fn prepare_pending_died_ordinary_after_fenced_proof( self, token: SealedBindingFateToken, terminal: CommittedDiedTerminal, hard_observer_progress: DeliverySeq, ) -> Result<PreparedPendingDiedOrdinaryFinalizer, Box<BindingFateMeasurementRefused>>

Measures Ordinary after fenced proof minting consumed marker authority.

The fenced attach transition itself owns the pending identity change, so this preparation validates the token, terminal, cursor, and exact floor but defers floor installation to the post-attach owner.

Errors

Returns every move-only input unchanged when token authority, terminal, observer progress, or checked floor measurement is inconsistent.

impl LiveFrontierOwner

pub fn prepare_binding_terminal( self, active_binding: ActiveBinding, cause_class: BindingTerminalCauseClass, next_transaction_order: TransactionOrder, next_delivery_sequence: DeliverySeq, hard_observer_progress: DeliverySeq, ) -> Result<PreparedBindingTerminal, Box<BindingTerminalPrepareRefused>>

Validates one active binding and checked candidate positions without mutation.

Errors

Returns the unchanged owner when binding authority, checked order or sequence, or hard-observer progress disagrees with the coupled protocol state.

impl LiveFrontierOwner

pub fn from_initial_enrollment<F>( initial: InitialEnrollmentFrontierCommit<F>, retained_record_limit: u64, ) -> (InitialEnrollmentOperationCommit<F>, Self)

Acquires live ownership from the protocol’s atomic initial-enrollment result.

pub const fn frontiers(&self) -> &ClaimFrontiers

Borrows the coupled claim frontiers.

pub const fn closure_accounting(&self) -> ClosureAccounting

Returns complete current closure accounting.

pub fn retained_charges(&self) -> &[RetainedRecordCharge]

Borrows canonical keyed charges for the retained suffix.

pub const fn retained_record_limit(&self) -> u64

Returns the signed retained causal-row cap.

pub fn into_parts( self, ) -> (ClaimFrontiers, ClosureAccounting, Vec<RetainedRecordCharge>, u64)

Consumes the complete owner for RecordAdmission, Leave, or persistence.

pub fn from_unchanged_record_admission<EF, V, LF>( unchanged: UnchangedRecordAdmission<'_, EF, V, LF>, retained_record_limit: u64, ) -> (Self, RecordAdmission, ResourceVector)

Restores the exact owner returned by a non-committing admission and recovers the same request for a same-lock retry.

pub fn from_record_admission_persistence( persistence: RecordAdmissionPersistenceParts, retained_record_limit: u64, ) -> Self

Acquires the exact owner from the complete sealed successful RecordAdmission persistence authority.

pub fn from_marker_drain( commit: MarkerDrainCommit, retained_record_limit: u64, ) -> (Self, StoredEdge, MarkerDeliveryProjection)

Acquires the exact post-drain owner and durable marker successor.

pub fn retain_fenced_marker_source( self, recovery: DetachedCredentialRecovery, ) -> Result<RetainedFencedMarkerSource, Box<FencedMarkerSourceRetentionRefused>>

Retains this move-only owner and the exact recovery while its durable marker source row is read and validated.

Errors

Returns the unchanged owner and recovery when the fully restored frontier does not contain their exact delivered marker occurrence.

pub fn mint_fenced_attach( self, marker_source_sequence: u64, recovery: DetachedCredentialRecovery, debt: ClosureDebt, event: Event, successor: DebtCompletion, ) -> MintFencedAttachResult

Consumes the complete owner and the exact descriptive inputs to mint one fenced attach proof from the selected retained marker occurrence.

This is the sole public production mint. The caller cannot supply a raw marker token: the owner removes it from its fully validated frontiers. Refusal returns this owner and every input unchanged after reinstalling that same occurrence authority, allowing serial retry but no fork.

Trait Implementations

impl Debug for LiveFrontierOwner

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

Formats the value using the given formatter.

impl Eq for LiveFrontierOwner

impl PartialEq for LiveFrontierOwner

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LiveFrontierOwner