Enum Op 

pub enum Op<'a> {
    Remember {
        now: u64,
        valid_from: u64,
        entity: Option<&'a str>,
        text: &'a str,
        tags: Vec<&'a str>,
        links: Vec<(&'a str, &'a str)>,
        vector: Vec<f32>,
        metadata: Vec<(&'a str, &'a str)>,
        revises: FactId,
        assigned: FactId,
    },
    Forget {
        now: u64,
        fact: FactId,
    },
    Link {
        now: u64,
        src: &'a str,
        rel: &'a str,
        dst: &'a str,
        provenance: FactId,
    },
    Maintain {
        now: u64,
    },
}

One decoded engine operation (op table). Revise is Remember with revises set — the two share a payload, only the op byte differs.

Not Eq: the raw f32 vector rides along so replay can re-quantize it deterministically, and f32 is only PartialEq.

Variants

Remember

Op 1/2: a new fact (op 2 additionally closes revises).

Fields

now: u64

Host timestamp of the operation.

valid_from: u64

Resolved validity start (the engine defaults it before journaling — replay never re-derives).

entity: Option<&'a str>

Subject entity name, if any.

text: &'a str

Fact text.

tags: Vec<&'a str>

Tags, verbatim.

links: Vec<(&'a str, &'a str)>

(rel, target_entity) link pairs.

vector: Vec<f32>

The raw embedding as remembered (empty = none). Stored pre-quantization so replay re-quantizes with the same pure function and reproduces every slot byte for byte.

metadata: Vec<(&'a str, &'a str)>

Metadata key→value pairs as remembered (empty = none). Replay re-canonicalizes them (sorts, dedups) the same way remember did, so the stored blob is reproduced byte for byte.

revises: FactId

Predecessor being revised (crate::id::FactId::NONE for op 1).

assigned: FactId

The fact id assigned at execution time — authoritative on replay.

Forget

Op 3: tombstone a fact.

Fields

now: u64

Host timestamp of the operation.

fact: FactId

The fact being forgotten.

Link

Op 4: upsert a typed edge between two entities.

Fields

now: u64

Host timestamp of the operation.

src: &'a str

Source entity name.

rel: &'a str

Relation term, verbatim.

dst: &'a str

Destination entity name.

provenance: FactId

Provenance fact, or crate::id::FactId::NONE.

Maintain

Op 5: marker that a maintenance pass ran at this point.

Fields

now: u64

Host timestamp of the operation.

Implementations

impl<'a> Op<'a>

pub fn encode(&self, out: &mut Vec<u8>)

Encodes the operation as one framed journal entry appended to out (via encode_entry).

pub fn decode(op: u8, payload: &'a [u8]) -> Result<Op<'a>, Error>

Decodes one operation from a scanned entry. The payload is untrusted (the checksum guards transport integrity, not origin): every read is bounds-checked, malformed input is Error::Corrupt, never a panic.

Trait Implementations

impl<'a> Clone for Op<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Op<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Op<'a>

fn eq(&self, other: &Op<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Op<'a>