Enum ExecutionPlan 

#[non_exhaustive]
pub enum ExecutionPlan {
    Sequence(Vec<ExecutionPlan>),
    Parallel(Vec<ExecutionPlan>),
    Execute {
        node_id: NodeId,
    },
    Step {
        node_id: NodeId,
        handoffs: Vec<(NodeId, ExecutionPlan)>,
    },
    Loop {
        node_id: NodeId,
        body: Box<ExecutionPlan>,
        max_iterations: Option<usize>,
        until: LoopCondition,
        carry_from: Option<NodeId>,
    },
    Branch {
        node_id: NodeId,
        arms: Vec<(String, ExecutionPlan)>,
    },
    Remote {
        node_id: NodeId,
        target: RemoteTarget,
        plan: Box<ExecutionPlan>,
    },
    Composite {
        node_ids: Vec<NodeId>,
    },
    Stream {
        node_ids: Vec<NodeId>,
        chunk_size: usize,
    },
    Empty,
}

A compiled execution plan produced by the compiler.

This is a recursive tree that the runtime walks to execute a pipeline. The compiler resolves caching, parallelism, and distribution before the runtime sees the plan.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Sequence(Vec<ExecutionPlan>)

Execute steps sequentially, one after another.

Parallel(Vec<ExecutionPlan>)

Execute branches concurrently (fork-join).

Execute

Execute a single filter node.

Fields

node_id: NodeId

The graph node to execute.

Step

Run an effectful step to completion: poll, perform its effects, repeat. Distinct from Execute because the runtime has to drive a turn loop and journal what it performs, not call a function once.

Fields

node_id: NodeId

The effectful node the runtime drives.

handoffs: Vec<(NodeId, ExecutionPlan)>

Where this step may hand control, by target node id.

A handoff is a branch the step decides rather than a condition value, so it compiles the same way: each target is claimed by the step and appears exactly once, inside it. A Goto naming something not listed here is an error, not a jump into the dark.

Loop

Iterate: run body until until says stop, or max_iterations is hit.

Fields

node_id: NodeId

The loop controller node — the id events and assignments are reported under, distinct from any node inside body.

body: Box<ExecutionPlan>

The sub-plan executed once per iteration.

max_iterations: Option<usize>

Hard iteration cap; None leaves stopping entirely to until.

until: LoopCondition

Already resolved by the compiler — never BodyTerminal here. The executor reads the signal from exactly this node.

carry_from: Option<NodeId>

The node whose output each pass hands to the next one.

Separate from until on purpose: what a loop carries and what tells it to stop are different questions. A debate that runs a fixed number of rounds has no stop signal at all, but every round still has to start from what the last one said — otherwise the loop just repeats its first iteration.

None when the body has no single terminal to carry from.

Branch

Conditional branching: evaluate condition, pick an arm.

Fields

node_id: NodeId

The node whose output selects an arm. The selector is control, not data: the chosen arm receives the branch’s input.

arms: Vec<(String, ExecutionPlan)>

(label, sub-plan) per arm; the condition value picks by label.

Remote

Execute a sub-plan on a remote worker.

Fields

node_id: NodeId

The node the distribution directive was attached to. The wrapped plan names it again, which is why this wrapper contributes no ids of its own to node_ids().

target: RemoteTarget

Where to run: a specific worker by id, or any worker with a tag.

plan: Box<ExecutionPlan>

The sub-plan the remote worker executes.

Composite

Execute multiple differentiable nodes as a single block. The executor passes tensors directly between filters (no Value conversion), preserving PyTorch autograd for gradient flow.

Fields

node_ids: Vec<NodeId>

The differentiable nodes fused into the block, in execution order.

Stream

Streaming execution: process input in chunks through a filter chain. Each filter’s StreamMode (FixedState/Evolving/Barrier) defines its per-chunk contract. Results flow progressively — no full materialization.

Fields

node_ids: Vec<NodeId>

The filter chain each chunk flows through, in order.

chunk_size: usize

How many input rows each chunk carries.

Empty

No-op: nothing to execute (e.g. empty graph).

Implementations

impl ExecutionPlan

pub fn children(&self) -> impl Iterator<Item = (Option<&str>, &ExecutionPlan)>

The sub-plans nested inside this one, each with its edge label if it has one — a branch arm’s label, a handoff’s target.

One structural walk, so the accessors below cannot disagree about the shape of the tree. They used to: node_count skipped a step’s handoffs while node_ids collected them, so an agentic plan reported fewer nodes than it had.

pub fn node_count(&self) -> usize

Count total nodes in the plan.

pub fn parallel_branch_count(&self) -> usize

Count parallel branches at the top level of the plan.

Top level only, deliberately: this feeds a run’s summary, and a fan-out inside a loop body happens once per iteration rather than once per run.

pub fn node_ids(&self) -> Vec<&str>

Collect all node IDs referenced in the plan.

pub fn summary(&self) -> PlanSummary

Create a PlanSummary for event payloads.

pub fn simplify(self) -> Self

Flatten unnecessary nesting (e.g. Sequence of one element).

impl ExecutionPlan

pub fn to_mermaid(&self) -> String

Render the execution plan as a Mermaid flowchart.

pub fn to_graph(&self) -> Graph

Synthesize a displayable Graph from this plan — the same node synthesis as Self::to_mermaid (fork nodes for Parallel, arm nodes for Branch, pills for streams) — so every Graph renderer applies: to_svg(), to_mermaid(), to_graphviz().

Trait Implementations

impl Clone for ExecutionPlan

fn clone(&self) -> ExecutionPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecutionPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExecutionPlan

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

Formats the value using the given formatter.

impl Serialize for ExecutionPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.