Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-core/src/trace/lifecycle.rs

Raw
//! Fixed-state lifecycle replay, never model-tool attribution (SMH-SPEC-PLUG0001).
use super::{EntryFrame, Result, SessionId, TraceKind, TraceRecord};
use crate::metadata::lifecycle as evidence;
use smith::EntryId;

#[derive(Default)]
pub(super) struct PendingLifecycle {
    invocation: Option<(EntryId, EntryId)>,
    effect: Option<EntryId>,
}
impl PendingLifecycle {
    pub(super) fn observe(
        &mut self,
        session_id: SessionId,
        entry: &EntryFrame,
    ) -> Result<Option<TraceRecord>> {
        let crate::content_codec::EntryContentView::Meta { kind, detail } =
            crate::content_codec::EntryContentView::decode(&entry.content)?
        else {
            return Ok(None);
        };
        if !evidence::reserved(kind) {
            return Ok(None);
        }
        let malformed = |_| smith::SmithError::Session {
            code: smith::error::SessionCode::EntryDecode,
            message: "invalid lifecycle trace identity".into(),
        };
        let root = evidence::identity(detail, "root_entry_id").map_err(malformed)?;
        let invocation = evidence::identity(detail, "invocation_id").map_err(malformed)?;
        let (trace_kind, effect) = match kind {
            evidence::INVOCATION_INTENT => {
                self.invocation = Some((root, invocation));
                (TraceKind::LifecycleInvocationStarted, None)
            }
            evidence::INVOCATION_COMPLETION => {
                self.invocation = None;
                (TraceKind::LifecycleInvocationCompleted, None)
            }
            evidence::EFFECT_INTENT => {
                let effect = evidence::identity(detail, "effect_id").map_err(malformed)?;
                self.invocation = Some((root, invocation));
                self.effect = Some(effect);
                (TraceKind::LifecycleEffectStarted, Some(effect))
            }
            evidence::EFFECT_COMPLETION => {
                self.invocation = Some((root, invocation));
                let effect = evidence::identity(detail, "effect_id").map_err(malformed)?;
                self.effect = None;
                (TraceKind::LifecycleEffectCompleted, Some(effect))
            }
            _ => return Ok(None),
        };
        Ok(Some(TraceRecord {
            session_id,
            timestamp_ms: entry.timestamp_ms,
            kind: trace_kind,
            event_ref: format!(
                "root:{root}:invocation:{invocation}:effect:{}:entry:{}",
                effect.map_or_else(|| "none".into(), |id| id.to_string()),
                entry.id
            ),
        }))
    }

    pub(super) fn finish(
        &mut self,
        session_id: SessionId,
        timestamp_ms: i64,
        visit: &mut impl FnMut(TraceRecord) -> Result<()>,
    ) -> Result<()> {
        if let Some((root, invocation)) = self.invocation.take() {
            if let Some(effect) = self.effect.take() {
                visit(TraceRecord {
                    session_id,
                    timestamp_ms,
                    kind: TraceKind::LifecycleEffectIncomplete,
                    event_ref: format!(
                        "root:{root}:invocation:{invocation}:effect:{effect}:mutation:unknown"
                    ),
                })?;
            }
            visit(TraceRecord {
                session_id,
                timestamp_ms,
                kind: TraceKind::LifecycleInvocationIncomplete,
                event_ref: format!("root:{root}:invocation:{invocation}:outcome:unknown"),
            })?;
        }
        Ok(())
    }
}