Struct CompiledGraph 

pub struct CompiledGraph {
    nodes: HashMap<String, Box<dyn Plugin>>,
    success_edges: HashMap<String, String>,
    error_edges: HashMap<String, String>,
    entry_node_id: String,
    terminal_node_ids: HashSet<String>,
    catch_all_handler: Option<String>,
    policy_name: String,
    resources: Arc<PluginResources>,
}

A compiled, ready-to-execute graph with instantiated plugins.

Built by compile_policy and shared read-only by the data-plane; one instance serves all requests matching the route that references its policy.

Fields

nodes: HashMap<String, Box<dyn Plugin>>

success_edges: HashMap<String, String>

node_id -> next node_id on success

error_edges: HashMap<String, String>

node_id -> next node_id on error

entry_node_id: String

The node that starts the pipeline (first node after listener)

terminal_node_ids: HashSet<String>

Node IDs that are terminal (client nodes) — execution stops when we reach one

catch_all_handler: Option<String>

Policy-level catch-all error handler node ID

policy_name: String

Policy name, used as a metrics label.

resources: Arc<PluginResources>

Process-wide services (metrics registry, shared clients); per-node metrics recording is disabled when resources.metrics is None.

Implementations

impl CompiledGraph

pub async fn execute(&self, ctx: Context) -> Context

Executes the graph with the given initial context and returns the final context (with response populated).

Walks nodes starting at the entry node (the first node after the listener), following the success edge after each Ok result. On a plugin error the error is tagged with the failing node’s ID, pushed onto ctx.errors, and execution jumps to the node’s error edge if one exists, otherwise to the policy-level catch-all handler; with neither, execution stops and a generic JSON 500 response is written. Reaching a terminal client node (or a node with no success edge) ends the walk. This method never fails: every outcome is expressed through the returned context’s response.

pub async fn execute_traced( &self, ctx: Context, recorder: TraceRecorder, ) -> (Context, TraceRecorder)

Same walk as execute, additionally recording a [Trace] of every node: the context after each one, the outcome, and which edge the engine followed.

Used by debug mode and the sandbox. Deliberately the same loop rather than a parallel implementation — a trace that could drift from the real execution path would be worse than no trace at all.

async fn run( &self, ctx: Context, recorder: Option<TraceRecorder>, ) -> (Context, Option<TraceRecorder>)

The single graph walk, optionally recording each step.

When recorder is None the only added cost is one Option discriminant check per node — the same shape as the existing metrics branch, and perfectly branch-predicted.