Enum IRFlowNode 

pub enum IRFlowNode {
    Step(IRStep),
    Probe(IRProbe),
    Reason(IRReasonStep),
    Validate(IRValidateStep),
    Refine(IRRefineStep),
    Weave(IRWeaveStep),
    UseTool(IRUseToolStep),
    Remember(IRRememberStep),
    Recall(IRRecallStep),
    Conditional(IRConditional),
    ForIn(IRForIn),
    Let(IRLetBinding),
    Return(IRReturnStep),
    Break(IRBreakStep),
    Continue(IRContinueStep),
    LambdaDataApply(IRLambdaDataApply),
    Par(IRParallelBlock),
    Hibernate(IRHibernateStep),
    Deliberate(IRDeliberateBlock),
    Consensus(IRConsensusBlock),
    Forge(IRForgeBlock),
    Focus(IRFocusStep),
    Associate(IRAssociateStep),
    Aggregate(IRAggregateStep),
    Explore(IRExploreStep),
    Ingest(IRIngestStep),
    ShieldApply(IRShieldApplyStep),
    Stream(IRStreamBlock),
    Navigate(IRNavigateStep),
    Drill(IRDrillStep),
    Trail(IRTrailStep),
    Corroborate(IRCorroborateStep),
    OtsApply(IROtsApplyStep),
    MandateApply(IRMandateApplyStep),
    ComputeApply(IRComputeApplyStep),
    Listen(IRListenStep),
    DaemonStep(IRDaemonStepNode),
    Emit(IREmit),
    Publish(IRPublish),
    Discover(IRDiscover),
    Persist(IRPersistStep),
    Retrieve(IRRetrieveStep),
    Mutate(IRMutateStep),
    Purge(IRPurgeStep),
    Transact(IRTransactBlock),
}

Polymorphic flow body node — serializes via #[serde(untagged)] so each variant emits its inner struct’s JSON (with its own node_type field).

Variants

Step(IRStep)

Probe(IRProbe)

Reason(IRReasonStep)

Validate(IRValidateStep)

Refine(IRRefineStep)

Weave(IRWeaveStep)

UseTool(IRUseToolStep)

Remember(IRRememberStep)

Recall(IRRecallStep)

Conditional(IRConditional)

ForIn(IRForIn)

Let(IRLetBinding)

Return(IRReturnStep)

Break(IRBreakStep)

Fase 19.e — exit the enclosing for-in body. Payload-free; the runner translates it into a sentinel that terminates the loop. Parser scope check guarantees this only appears inside a for-in body.

Continue(IRContinueStep)

Fase 19.e — skip to the next iteration of the enclosing for-in body. Same shape as Break — payload-free, sentinel-driven at runtime.

LambdaDataApply(IRLambdaDataApply)

Par(IRParallelBlock)

Hibernate(IRHibernateStep)

Deliberate(IRDeliberateBlock)

Consensus(IRConsensusBlock)

Forge(IRForgeBlock)

Focus(IRFocusStep)

Associate(IRAssociateStep)

Aggregate(IRAggregateStep)

Explore(IRExploreStep)

Ingest(IRIngestStep)

ShieldApply(IRShieldApplyStep)

Stream(IRStreamBlock)

Navigate(IRNavigateStep)

Drill(IRDrillStep)

Trail(IRTrailStep)

Corroborate(IRCorroborateStep)

OtsApply(IROtsApplyStep)

MandateApply(IRMandateApplyStep)

ComputeApply(IRComputeApplyStep)

Listen(IRListenStep)

DaemonStep(IRDaemonStepNode)

Emit(IREmit)

§λ-L-E Fase 13 — π-calc output prefix (Chan-Output / Chan-Mobility).

Publish(IRPublish)

§λ-L-E Fase 13 — capability extrusion (Publish-Ext).

Discover(IRDiscover)

§λ-L-E Fase 13 — dual of publish (typed handle import).

Persist(IRPersistStep)

Retrieve(IRRetrieveStep)

Mutate(IRMutateStep)

Purge(IRPurgeStep)

Transact(IRTransactBlock)

Trait Implementations

impl Clone for IRFlowNode

fn clone(&self) -> IRFlowNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IRFlowNode

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

Formats the value using the given formatter.

impl Serialize for IRFlowNode

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.