Struct Axon 

pub struct Axon<In, Out, E, Res = ()> {
    pub schematic: Schematic,
    /* private fields */
}

The Axon Builder and Runtime.

Axon represents an executable decision tree. It is reusable and thread-safe.

Example

use ranvier_core::prelude::*;
// ...
// Start with an identity Axon (In -> In)
let axon = Axon::<(), (), _>::new("My Axon")
    .then(StepA)
    .then(StepB);

// Execute multiple times
let res1 = axon.execute((), &mut bus1).await;
let res2 = axon.execute((), &mut bus2).await;

Fields

schematic: Schematic

The static structure (for visualization/analysis)

Implementations

impl<In, E, Res> Axon<In, In, E, Res>

where In: Send + Sync + 'static, E: Send + 'static, Res: ResourceRequirement,

pub fn new(label: &str) -> Self

Create a new Axon flow with the given label. This is the preferred entry point per Flat API guidelines.

pub fn start(label: &str) -> Self

Start defining a new Axon flow. This creates an Identity Axon (In -> In) with no initial resource requirements.

impl<In, Out, E, Res> Axon<In, Out, E, Res>

where In: Send + Sync + 'static, Out: Send + Sync + 'static, E: Send + 'static, Res: ResourceRequirement,

pub fn then<Next, Trans>(self, transition: Trans) -> Axon<In, Next, E, Res>

where Next: Send + Sync + 'static, Trans: Transition<Out, Next, Resources = Res, Error = E> + Clone + Send + Sync + 'static,

Chain a transition to this Axon.

Requires the transition to use the SAME resource bundle as the previous steps.

pub fn branch(self, branch_id: impl Into<String>, label: &str) -> Self

Add a branch point

pub async fn execute( &self, input: In, resources: &Res, bus: &mut Bus, ) -> Outcome<Out, E>

Execute the Axon with the given input and resources.

pub fn serve_inspector(self, port: u16) -> Self

Starts the Ranvier Inspector for this Axon on the specified port. This spawns a background task to serve the Schematic.

pub fn schematic(&self) -> &Schematic

Get a reference to the Schematic (structural view).

pub fn into_schematic(self) -> Schematic

Consume and return the Schematic.

pub fn schematic_export_request(&self) -> Option<SchematicExportRequest>

Detect schematic export mode from runtime flags.

Supported triggers:

• RANVIER_SCHEMATIC=1|true|on|yes
• --schematic

Optional output path:

• RANVIER_SCHEMATIC_OUTPUT=<path>
• --schematic-output <path> / --schematic-output=<path>
• --output <path> / --output=<path> (only relevant in schematic mode)

pub fn maybe_export_and_exit(&self) -> Result<bool>

Export schematic and return true when schematic mode is active.

Use this once after circuit construction and before server/custom loops:

let axon = build_axon();
if axon.maybe_export_and_exit()? {
    return Ok(());
}
// Normal runtime path...

pub fn maybe_export_and_exit_with<F>(&self, on_before_exit: F) -> Result<bool>

where F: FnOnce(&SchematicExportRequest),

Same as Self::maybe_export_and_exit but allows a custom hook right before export/exit.

This is useful when your app has custom loop/bootstrap behavior and you want to skip or cleanup that logic in schematic mode.

pub fn export_schematic(&self, request: &SchematicExportRequest) -> Result<()>

Export schematic according to the provided request.

Trait Implementations

impl<In, Out, E, Res> Clone for Axon<In, Out, E, Res>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.