Struct SignablePersona 

pub struct SignablePersona<'a> {
    pub persona_id: &'a str,
    pub entity_id: &'a str,
    pub namespace: &'a str,
    pub version: i32,
    pub generated_at: &'a str,
    pub sources: &'a [String],
    pub body_md_sha256: &'a [u8; 32],
}

The seven fields the persona signature commits to.

body_md_sha256 is the SHA-256 of the UTF-8 bytes of the rendered persona Markdown body (the same string that lands in memories.content). Hashing it before signing keeps the canonical payload bounded at ~200 bytes regardless of body length — a 300-500 word persona body would otherwise dominate the signed envelope and inflate every signed_events.payload_hash recomputation.

Fields

persona_id: &'a str

The Persona memory’s id (UUIDv4). Stable per (entity_id, namespace, version) tuple — PersonaGenerator::generate mints it before computing the signature.

entity_id: &'a str

Subject the persona distils. Mirrors Persona::entity_id.

namespace: &'a str

Namespace the persona was minted under.

version: i32

Monotonic version counter — 1 on the first generation, then prev + 1 per regeneration. Pinned in the signature so a regeneration cannot replay an earlier version’s signed bytes.

generated_at: &'a str

RFC3339 generation timestamp pinned in metadata.persona.generated_at.

sources: &'a [String]

Source reflection ids — one derives_from edge per element. Order matters at the byte level (the CBOR encoder preserves the slice order); the writer pins the order to match metadata.persona.sources.

body_md_sha256: &'a [u8; 32]

SHA-256 (32 bytes) over the rendered persona Markdown body’s UTF-8 bytes. Bounds the signed payload size.

Trait Implementations

impl<'a> Clone for SignablePersona<'a>

fn clone(&self) -> SignablePersona<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SignablePersona<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for SignablePersona<'a>

impl<'a> PartialEq for SignablePersona<'a>

fn eq(&self, other: &SignablePersona<'a>) -> 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<'a> StructuralPartialEq for SignablePersona<'a>