Struct Atom 

pub struct Atom {
    pub id: AtomId,
    pub ops: Vec<TextOp>,
    pub parents: Vec<AtomId>,
    pub provenance: Provenance,
    pub signature: AtomSignature,
    pub inverse_of: Option<AtomId>,
}

The core flow primitive.

id is derived from the rest of the content; constructors and decoders recompute and validate it. Two atoms that encode the same ops, parents, provenance, and inverse_of always have the same id, regardless of which encoding they were materialized from.

Fields

id: AtomId

ops: Vec<TextOp>

parents: Vec<AtomId>

provenance: Provenance

signature: AtomSignature

inverse_of: Option<AtomId>

Implementations

impl Atom

pub fn sign( ops: Vec<TextOp>, parents: Vec<AtomId>, provenance: Provenance, inverse_of: Option<AtomId>, principal_key: &SigningKey, persona_key: &SigningKey, ) -> Result<Self, AtomError>

Sign and assemble an atom from its content.

Steps: encode the body canonically, derive AtomId as SHA-256(body), sign that 32-byte id with both keys, return the assembled atom.

pub fn invert( target: &Atom, provenance: Provenance, principal_key: &SigningKey, persona_key: &SigningKey, ) -> Result<Self, AtomError>

Build the inverse of target. The new atom’s ops are the reverse list of target.ops, each individually inverted, with inverse_of pointing at target.id. Useful for “undo” — the user-facing model stacks an inverse atom rather than mutating history.

pub fn verify_content_hash(&self) -> Result<(), AtomError>

Recompute id from the body and check that it matches the stored id. Returns Err(ContentHashMismatch) on drift.

pub fn verify_signatures(&self) -> Result<(), AtomError>

Verify both signatures against the atom’s id. Does not consult the trust graph — that’s the caller’s responsibility (the trust graph decides whether the keys themselves are currently trusted).

pub fn verify(&self) -> Result<(), AtomError>

Combined verify_content_hash + verify_signatures. Most callers want this.

pub fn apply(&self, document: &mut Vec<u8>) -> Result<(), AtomError>

Apply this atom’s ops to document in order. Returns Err if any op fails (offset out of range or Delete content mismatch).

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

Encode as JSON. Round-trips with Atom::from_json_slice.

pub fn from_json_slice(bytes: &[u8]) -> Result<Self, AtomError>

Decode from JSON, then verify the content hash (not signatures).

pub fn to_binary(&self) -> Result<Vec<u8>, AtomError>

Encode as canonical binary bytes. Round-trips with Atom::from_binary_slice and is byte-stable across processes.

pub fn from_binary_slice(bytes: &[u8]) -> Result<Self, AtomError>

Decode from canonical binary bytes, then verify the content hash (not signatures).

Trait Implementations

impl Clone for Atom

fn clone(&self) -> Atom

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Atom

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Atom

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Atom

fn eq(&self, other: &Atom) -> 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 Atom

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 Atom

impl StructuralPartialEq for Atom