Struct PersistedSession 

#[non_exhaustive]
pub struct PersistedSession {

    pub schema_version: u32,
    pub session_id: String,
    pub state: SessionState,
    pub ttl_expiry: i64,
    pub ttl_ms: i64,
    pub started_at_unix_ms: i64,
    pub resolution: Option<Vec<u8>>,
    pub mode: String,
    pub mode_state: Vec<u8>,
    pub participants: Vec<String>,
    pub seen_message_ids: Vec<String>,
    pub intent: String,
    pub mode_version: String,
    pub configuration_version: String,
    pub policy_version: String,
    pub context_id: String,
    pub extensions: HashMap<String, Vec<u8>>,
    pub roots: Vec<PersistedRoot>,
    pub initiator_sender: String,
    pub policy_definition: Option<PolicyDefinition>,
    pub suspended_at_ms: Option<i64>,
    pub accumulated_suspended_ms: i64,
    pub suspension_intervals: Vec<(i64, i64)>,
    pub semantics_rev: u32,
    pub max_suspend_ms: i64,
}

A Session flattened for the storage backends and the checkpoint entry.

#[non_exhaustive] (0.8.0, DECISIONS.md D7 — extended here from the handoff and quorum mode-state records, which plans/defer/follow_ons.md item 12 flagged as an unaudited sibling of the same class — the audit found it was not a hypothetical sibling but one of the two breaks 0.8.0 is already forced to take). This is the fastest-growing persisted record in the workspace: suspension_intervals lands in 0.8.0, on top of semantics_rev and max_suspend_ms a release earlier, and every one of those is a constructible_struct_adds_field major against an external exhaustive struct literal. cargo semver-checks check-release --workspace --baseline-version 0.7.6 reports exactly that for suspension_intervals. Sealing the struct here spends nothing extra and stops the next persisted field from forcing a major of its own.

Fields stay pub, readable and writable; only construction by struct literal from another crate is refused. The supported way in is PersistedSession::from(&Session) followed by field assignment — which is exactly what src/replay.rs and the storage backends already do.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

schema_version: u32

session_id: String

state: SessionState

ttl_expiry: i64

ttl_ms: i64

started_at_unix_ms: i64

resolution: Option<Vec<u8>>

mode: String

mode_state: Vec<u8>

participants: Vec<String>

seen_message_ids: Vec<String>

intent: String

mode_version: String

configuration_version: String

policy_version: String

context_id: String

extensions: HashMap<String, Vec<u8>>

roots: Vec<PersistedRoot>

initiator_sender: String

policy_definition: Option<PolicyDefinition>

suspended_at_ms: Option<i64>

accumulated_suspended_ms: i64

suspension_intervals: Vec<(i64, i64)>

Completed (suspended_at, resumed_at) pairs on the session timeline (see macp_core::session::Session::suspension_intervals). Snapshots written before this field existed deserialize as empty, which is the safe direction — the deadline walk only under-counts.

semantics_rev: u32

Session-semantics revision (see macp_core::session::CURRENT_SEMANTICS_REV). Legacy snapshots deserialize as 0 and keep legacy behavior.

max_suspend_ms: i64

Suspension cap bound at SessionStart. Legacy snapshots deserialize as 0 (= default-cap semantics via Session::effective_max_suspend_ms).

Trait Implementations

impl<'de> Deserialize<'de> for PersistedSession

fn deserialize<__D>( __deserializer: __D, ) -> Result<PersistedSession, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Session> for PersistedSession

fn from(session: &Session) -> PersistedSession

Converts to this type from the input type.

impl From<PersistedSession> for Session

fn from(session: PersistedSession) -> Session

Converts to this type from the input type.

impl Serialize for PersistedSession

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

where __S: Serializer,

Serialize this value into the given Serde serializer.