Enum CompositionNode 

pub enum CompositionNode {
    Stage {
        id: StageId,
        pinning: Pinning,
        config: Option<BTreeMap<String, Value>>,
    },
    RemoteStage {
        url: String,
        input: NType,
        output: NType,
    },
    Const {
        value: Value,
    },
    Sequential {
        stages: Vec<CompositionNode>,
    },
    Parallel {
        branches: BTreeMap<String, CompositionNode>,
    },
    Branch {
        predicate: Box<CompositionNode>,
        if_true: Box<CompositionNode>,
        if_false: Box<CompositionNode>,
    },
    Fanout {
        source: Box<CompositionNode>,
        targets: Vec<CompositionNode>,
    },
    Merge {
        sources: Vec<CompositionNode>,
        target: Box<CompositionNode>,
    },
    Retry {
        stage: Box<CompositionNode>,
        max_attempts: u32,
        delay_ms: Option<u64>,
    },
    Let {
        bindings: BTreeMap<String, CompositionNode>,
        body: Box<CompositionNode>,
    },
}

A composition graph node. The core AST for Noether’s composition language.

Variants

Stage

Leaf node: reference to a stage in the store.

The id field is interpreted according to pinning:

• Pinning::Signature (default): id is a signature-level hash (SignatureId) and the resolver returns the currently Active implementation with that signature.
• Pinning::Both: id is an implementation-inclusive hash (ImplementationId / StageId) and the resolver requires an exact match. No fallback.

The optional config provides static parameter values merged with the pipeline input before the stage executes.

Use CompositionNode::stage to construct a node with default pinning; use the struct literal only when you need a non-default pinning or a config.

Known gap in M2 (v0.6.0)

resolve_stage_ref is only wired into the type checker and executor runner. Other passes (effect inference, Ed25519 verify, planner cost/parallel grouping, budget, grid-broker splitter) still look up by StageId directly, which means a Pinning::Signature node may type-check but fail at those downstream passes. The resolver-normalisation pass lands as a follow-up: it rewrites graph nodes to implementation IDs before any downstream pass runs, so the rest of the engine keeps operating on concrete implementation hashes.

Fields

id: StageId

pinning: Pinning

config: Option<BTreeMap<String, Value>>

RemoteStage

Call a remote Noether API endpoint over HTTP.

The declared input and output types are verified by the type checker at build time — the remote server does not need to be running during noether build. In native builds, execution uses reqwest. In browser builds, the JS runtime makes a fetch() call.

Fields

url: String

URL of the remote Noether API (e.g. “http://localhost:8080”)

input: NType

Declared input type — what this node accepts from the pipeline

output: NType

Declared output type — what this node returns to the pipeline

Const

Emits a constant JSON value, ignoring its input entirely. Used to inject literal strings, numbers, or objects into a pipeline.

Fields

value: Value

Sequential

A >> B >> C: output of each stage feeds the next.

Fields

stages: Vec<CompositionNode>

Parallel

Execute branches concurrently, merge outputs into a Record keyed by branch name. Each branch receives input[branch_name] if the input is a Record containing that key; otherwise it receives the full input. Const branches ignore their input entirely — use them for literals.

Fields

branches: BTreeMap<String, CompositionNode>

Branch

Conditional routing based on a predicate stage.

Fields

predicate: Box<CompositionNode>

if_true: Box<CompositionNode>

if_false: Box<CompositionNode>

Fanout

Source output sent to all targets concurrently.

Fields

source: Box<CompositionNode>

targets: Vec<CompositionNode>

Merge

Multiple sources merge into a single target.

Fields

sources: Vec<CompositionNode>

target: Box<CompositionNode>

Retry

Retry a stage up to max_attempts times on failure.

Fields

stage: Box<CompositionNode>

max_attempts: u32

delay_ms: Option<u64>

Let

Bind named intermediate computations and reference them in body.

Each binding sub-node receives the outer Let input (the same value passed to the Let node). After all bindings have produced a value, the body runs against an augmented input record:

{ ...outer-input fields, <binding-name>: <binding-output>, ... }

Bindings with the same name as an outer-input field shadow it. This makes it possible to carry original-input fields into stages later in a Sequential pipeline — the canonical example is scan → hash → diff, where diff needs state_path from the original input but hash would otherwise erase it.

All bindings are scheduled concurrently — there are no inter-binding references. If you need a binding to depend on another, wrap it in a nested Sequential.

Fields

bindings: BTreeMap<String, CompositionNode>

body: Box<CompositionNode>

Implementations

impl CompositionNode

pub fn stage(id: impl Into<String>) -> Self

Build a Stage node with default pinning (Signature) and no config. Use this in place of the struct literal when you don’t need to set pinning or config explicitly.

pub fn stage_pinned(id: impl Into<String>) -> Self

Build a Stage node with an explicit Both pinning — the resolver will require the exact implementation named by id.

Trait Implementations

impl Clone for CompositionNode

fn clone(&self) -> CompositionNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompositionNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompositionNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompositionNode

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CompositionNode

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 CompositionNode