Struct CaseBlock 

pub struct CaseBlock {
    pub kind: &'static str,
    pub case: Case,
    pub deadlines: Vec<Deadline>,
    pub blobs: Vec<Digest>,
    pub hold: Option<LegalHold>,
    pub erasure: Option<Erasure>,
}

One case, as an export line — the case layer’s whole account of one matter.

Emitted after the run blocks because the two halves answer different questions: the journal is what happened, the case is what it happened to. A restore of the journal alone rebuilds every index the journal owns and none of these rows, because case state is not derivable from records — which is exactly why the export has to carry it.

state travels as stored: sealed on a sealed plane. Exporting plaintext would quietly undo erasure — see the module docs, which make the same refusal for record payloads.

blobs carries digests, never bytes. Presence and integrity of the bytes are a question about a live blob store, which an offline file cannot answer and honestly reports as unchecked.

hold is always written, null for a matter nobody ordered preserved. A restore that brought a held matter back without its hold would hand the next retention pass a closed, old, unheld case to erase.

erasure is always written too, null for a matter nobody erased. A restore that dropped it would bring back a case whose key is destroyed as an ordinary closed one — reopenable, writable, and a drill finding.

Fields

kind: &'static str

Always "agentplane.export.case".

case: Case

deadlines: Vec<Deadline>

blobs: Vec<Digest>

hold: Option<LegalHold>

The legal hold on this matter: instant, reason and operator.

erasure: Option<Erasure>

The erasure record on this matter: instant, reason, and whether it completed.

Trait Implementations

impl Clone for CaseBlock

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CaseBlock

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

Formats the value using the given formatter.

impl PartialEq for CaseBlock

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CaseBlock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CaseBlock