Enum ParticipantSemanticError 

pub enum ParticipantSemanticError {
    Unavailable,
    Internal {
        message: String,
    },
    ServiceFatal(ParticipantServiceFatal),
    BindingTerminalAdmissionRefused {
        error: BindingTerminalAdmitError,
    },
    BootDrainRefused {
        conversation_id: ConversationId,
        refusal: BootDrainRefusal,
        candidate: String,
        reason: String,
    },
    ConversationSealed {
        conversation_id: ConversationId,
    },
    ConversationUnloadable {
        conversation_id: ConversationId,
        reason: String,
    },
}

Non-wire semantic service failure.

A failure is terminal to the connection attempt. It is deliberately not convertible to ServerValue, preventing the server from inventing a lifecycle response when the protocol-owned transition did not produce one.

Variants

Unavailable

The complete semantic service is not installed.

Internal

Durable state or a protocol invariant prevented semantic completion.

Fields

message: String

Diagnostic text for server logs; never placed on the participant wire.

ServiceFatal(ParticipantServiceFatal)

A process-wide participant fatal has already latched.

BindingTerminalAdmissionRefused

A keyed binding-terminal candidate was refused, carrying the protocol’s own reason rather than a formatted description of it.

BindingTerminalAdmitError::Precedence is lane occupancy: the conversation’s immutable-candidate lane already holds a terminal awaiting its drain. That is a designed structural boundary, and a caller deciding whether to park or to treat the refusal as corruption must be able to tell it from the five genuine authority defects by type.

Fields

error: BindingTerminalAdmitError

Exact protocol refusal reason.

BootDrainRefused

F8B R-BOOT-VERDICT: boot recovery could not empty a restored conversation’s immutable-candidate lane, so the boot refuses HERE, naming the conversation and the shape, instead of starting and dying several collapses downstream on a retained Open it can never replay.

Fields

conversation_id: ConversationId

Conversation whose restored lane refused its drain.

refusal: BootDrainRefusal

Typed reason, so a consumer never discriminates on a substring.

candidate: String

Exact lane head that refused, rendered for the operator.

reason: String

The drain’s own refusal text.

ConversationSealed

F8B R-SEAL: the conversation is Closed — a Died-flavor drain erased its final enrollment token, so its log holds records, terminals and drain rows but no live identity can ever be reached through it again.

Enrollment answers with this NAMED refusal rather than falling through to a fresh identity, which would silently re-open a conversation whose history has already ended. On the wire it rides the existing semantic-error framing; a protocol-native response value with its own discriminant is deferred to a protocol-version leg (§9.8).

Fields

conversation_id: ConversationId

Conversation whose closure refused the request.

ConversationUnloadable

CONTAINMENT: this one conversation’s durable state cannot be loaded, so this one conversation is refused. The node starts, every other conversation is served, and the refusal NAMES its subject.

Attribution is not decoration here, it is half the property. A node that contains an unloadable conversation without naming it boots clean and silently serves nothing on that conversation forever, which is worse than the crash it replaced, because the crash was the only thing telling anyone. The underlying failure travels as reason rather than as a wrapped error because it is already a rendered diagnostic by the time replay refuses it.

Fields

conversation_id: ConversationId

Conversation whose durable state could not be loaded.

reason: String

The load failure’s own text, as the operator needs to see it.

Implementations

impl ParticipantSemanticError

pub const fn class(&self) -> &'static str

Stable operator-facing class for this refusal.

The rendered message is a diagnostic: it carries the subject and the detail, and it is allowed to move. This is the discriminant an operator surface and a log field can be read against without matching on a substring — which is what the containment record’s consumers need, since the failure text a refused load carries (“expected value at line 1 column 1”) names no class at all on its own.

Trait Implementations

impl Clone for ParticipantSemanticError

fn clone(&self) -> ParticipantSemanticError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParticipantSemanticError

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

Formats the value using the given formatter.

impl Display for ParticipantSemanticError

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

Formats the value using the given formatter.

impl Eq for ParticipantSemanticError

impl Error for ParticipantSemanticError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<ParticipantSemanticError> for ParticipantDispatchError

fn from(source: ParticipantSemanticError) -> Self

Converts to this type from the input type.

impl PartialEq for ParticipantSemanticError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParticipantSemanticError