Struct DelayNode 

pub struct DelayNode {
    pub id: String,
    pub name: Option<String>,
    pub seconds: u64,
}

A delay node: a durable wait that parks the run, then continues the walk.

Why the wait is a DURATION and not an instant

A graph document is authored once, content-addressed, and then run any number of times: the hash IS the identity, and the same document backs salvor graph run, POST /v1/graph-runs, and every fork of every run that referenced it. An absolute wake instant baked into the document would make it a single-use artifact: correct on the first run and already in the past on the second, where every delay would fall through instantly and the document would silently mean something else than it did the day it was written.

A duration says the thing that stays true across runs (“hold this for an hour”), and it is what every other author-time number in this format already is: a map’s concurrency, a fold’s max_iterations. Nothing in a graph document is a value belonging to one particular run, and this field keeps it that way. The instant is resolved at EXECUTION, by salvor_runtime::RunCtx::sleep_for, which observes the clock into the log first and derives wake_at from that recorded reading, so the wake instant is recorded once and replays identically forever.

There is deliberately no second, absolute spelling. Two ways to say a wait would need a mutual-exclusion rule in the validator and would leave authors choosing between one form that composes and one that expires; a format with one answer is the smaller thing to keep true.

Fields

id: String

The node’s stable id, unique within the document.

name: Option<String>

Optional short display label for this node. See the module docs’ “The optional node display name” section for the bound and the deliberate hash-inclusion contrast with the agent name field. Additive: absent on the wire when unset.

seconds: u64

How long the run waits, in whole seconds, measured from the clock reading the engine records on entering the node. Must be at least 1; crate::validate reports a zero wait by node id.

Trait Implementations

impl Clone for DelayNode

fn clone(&self) -> DelayNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DelayNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DelayNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DelayNode

impl JsonSchema for DelayNode

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for DelayNode

fn eq(&self, other: &DelayNode) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for DelayNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DelayNode