Struct Evaluator 

pub struct Evaluator {
    pub facade: Arc<AreevFacade>,
    pub clock: Arc<dyn Clock>,
    pub connector: Option<Arc<dyn HostToolExecutor>>,
    pub starter: Option<Arc<dyn RunStarter>>,
    pub credentials: BTreeMap<String, CredentialSource>,
    pub ns: String,
    pub principal: String,
}

Evaluates triggers against one memory.

Fields

facade: Arc<AreevFacade>

clock: Arc<dyn Clock>

connector: Option<Arc<dyn HostToolExecutor>>

Executes connector commands. None means a due polling trigger fails loudly with TRG-E003 rather than quietly doing nothing — a poll that silently returns no items is indistinguishable from a healthy source.

starter: Option<Arc<dyn RunStarter>>

Starts the bound workflow. None ingests the item and records the firing without starting anything — what --no-start is for, and what the ingest-only tests use.

credentials: BTreeMap<String, CredentialSource>

Credentials the broker may attach, by name. Values live here and never in a grain or a connector’s environment: a declaration names a credential, it never carries one. A SOURCE per name, not a resolved value (#113): the heartbeat is the path that most needs short-lived credentials, because it is the one nobody is watching. An env-var source resolves once, as before; a cmd:/vault: source is minted per TTL window inside the broker, so a cadence that outlives a token’s hour does not start 401’ing overnight.

ns: String

principal: String

Implementations

impl Evaluator

pub fn read_only( facade: Arc<AreevFacade>, clock: Arc<dyn Clock>, ns: &str, ) -> Evaluator

An evaluator that can inspect but not act: no connector, no runtime, no credentials. What list, show and status want, and the shape that makes “reading cannot fire anything” true by construction rather than by remembering to pass None four times.

pub fn declarations(&self) -> Result<Vec<(String, Trigger)>>

Every trigger declaration in the memory, newest first.

pub fn status(&self) -> Result<Vec<TriggerStatus>>

What every trigger’s state looks like right now.

pub fn deliver(&self, trigger_hash: &str, payload: Value) -> Result<EvalReport>

Ingest a payload delivered by the host for a webhook or manual trigger.

Areev never opens a port. The host already terminates TLS and authenticates the sender — it is far better at both than a memory engine would be — and hands the payload to a one-shot invocation. That keeps the useful half of webhooks without a listening daemon.

Idempotent on the same terms as a poll: the payload’s dedup value mints the run id, so a webhook delivered twice (which every provider does) produces one run and one recorded skip.

pub fn run(&self, opts: &EvalOptions) -> Result<EvalReport>

Run one evaluation pass.