Enum Node 

pub enum Node {
    Step {
        ref_: String,
        in_: Expr,
        out: Expr,
    },
    Seq {
        children: Vec<Node>,
    },
    Branch {
        cond: Expr,
        then_: Box<Node>,
        else_: Box<Node>,
    },
    Fanout {
        items: Expr,
        bind: Expr,
        body: Box<Node>,
        join: JoinMode,
        out: Expr,
    },
    Loop {
        counter: Expr,
        cond: Expr,
        body: Box<Node>,
        max: u32,
    },
    Try {
        body: Box<Node>,
        catch: Box<Node>,
        err_at: Option<Expr>,
    },
    Assign {
        at: Expr,
        value: Expr,
    },
}

flow.ir Node kind.

Discriminated with kind tag, deny_unknown_fields (open=false), rename_all = "snake_case". Covers the 7 supported kinds: Step / Seq / Branch / Fanout (canonical schema の fanout Node、 4 join mode) / Loop / Try / Assign. Additional kinds may be added in future versions.

Variants

Step

Step — dispatch a referenced operation with in input, write result to out.

Fields

ref_: String

Dispatcher key (wire field ref), resolved via Dispatcher::dispatch.

in_: Expr

Input Expr, evaluated against the ctx snapshot before dispatch (wire field in).

out: Expr

Path Expr the dispatcher’s output is written to.

Seq

Seq — evaluate children in order, threading the context value through.

Fields

children: Vec<Node>

Child nodes, evaluated in order.

Branch

Branch — eval cond; if true run then, else run else.

Fields

cond: Expr

Condition Expr; must evaluate to a JSON boolean.

then_: Box<Node>

Branch taken when cond is true (wire field then).

else_: Box<Node>

Branch taken when cond is false (wire field else).

Fanout

Fanout — eval items to an array, run body per item against a branch-local ctx (caller ctx + item written to bind), join results per join mode into out. Async parallel runner uses futures::future::{try_join_all|select_ok|join_all} (executor-agnostic).

Fields

items: Expr

Expr evaluated to a JSON array; one branch runs per element.

bind: Expr

Path Expr each branch’s item is written to before running body.

body: Box<Node>

Node run once per items element, against a disjoint branch ctx.

join: JoinMode

How per-branch results are combined into out.

out: Expr

Path Expr the joined result is written to.

Loop

Loop — counter を 0 から、 cond が truthy かつ counter < max の間 body を eval。 各 iter 後 counter を increment して counter path に書く。 VerdictLoop 等の retry/poll パターン primitive (canonical schema 整合)。

Fields

counter: Expr

Path Expr the iteration counter is written to (starts at 0).

cond: Expr

Condition re-evaluated before each iteration; loop stops once falsy.

body: Box<Node>

Node evaluated once per iteration.

max: u32

Hard iteration cap (loop stops once counter >= max, regardless of cond).

Try

Try — body を eval、 raise した場合 catch を eval。 err_at が Some なら catch 開始前に error message を ctx に書く。

Fields

body: Box<Node>

Node evaluated first; failures trigger a ctx rollback + catch.

catch: Box<Node>

Node evaluated when body raises.

err_at: Option<Expr>

Optional Path Expr the error message is written to before catch runs.

Assign

Assign — pure transform Node。 value Expr を ctx snapshot 上で評価し、 結果を at (Path Expr) に write する。 dispatcher 不要、 副作用は CtxStorage.write 1 回のみ。 Seq の中で Step 間の Adhoc update 表現に 使う (= IR primitive、 Command 履歴は CtxStorage の write hook 経由で取得)。

Fields

at: Expr

Path Expr the evaluated value is written to.

value: Expr

Expr evaluated against the ctx snapshot.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Node

fn deserialize<__D>( __deserializer: __D, ) -> Result<Node, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Node

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Node

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Node