Enum FlowStep 

pub enum FlowStep {
    Step(StepNode),
    If(ConditionalNode),
    ForIn(ForInStatement),
    Let(LetStatement),
    Return(ReturnStatement),
    Break(BreakStatement),
    Continue(ContinueStatement),
    LambdaDataApply(LambdaDataApplyNode),
    Probe(ProbeStep),
    Reason(ReasonStep),
    Validate(ValidateStep),
    Refine(RefineStep),
    Weave(WeaveStep),
    UseTool(UseToolStep),
    Remember(RememberStep),
    Recall(RecallStep),
    Par(ParBlock),
    Hibernate(HibernateStep),
    Deliberate(DeliberateBlock),
    Consensus(ConsensusBlock),
    Forge(ForgeBlock),
    Focus(FocusStep),
    Grad(GradStep),
    Associate(AssociateStep),
    Aggregate(AggregateStep),
    ExploreStep(ExploreStepNode),
    Ingest(IngestStep),
    ShieldApply(ShieldApplyStep),
    Stream(StreamBlock),
    Navigate(NavigateStep),
    Drill(DrillStep),
    Trail(TrailStep),
    Corroborate(CorroborateStep),
    OtsApply(OtsApplyStep),
    MandateApply(MandateApplyStep),
    ComputeApply(ComputeApplyStep),
    Listen(ListenStep),
    DaemonStep(DaemonStepNode),
    Emit(EmitStatement),
    Mint(MintStep),
    Rotate(RotateStep),
    Publish(PublishStatement),
    Discover(DiscoverStatement),
    Persist(PersistStep),
    Retrieve(RetrieveStep),
    Mutate(MutateStep),
    Purge(PurgeStep),
    Transact(TransactBlock),
    Warden(WardenBlock),
    Quant(QuantBlock),
    Yield(YieldStatement),
    Run(RunStatement),
    GenericStep(GenericFlowStep),
}

Statements that can appear inside a flow body.

Variants

Step(StepNode)

If(ConditionalNode)

ForIn(ForInStatement)

Let(LetStatement)

Return(ReturnStatement)

Break(BreakStatement)

Fase 19.e — break keyword. Payload-free; carries only its source location for error reporting.

Continue(ContinueStatement)

Fase 19.e — continue keyword. Payload-free; same shape as Break.

LambdaDataApply(LambdaDataApplyNode)

Lambda Data application in a flow step.

Probe(ProbeStep)

Reason(ReasonStep)

Validate(ValidateStep)

Refine(RefineStep)

Weave(WeaveStep)

UseTool(UseToolStep)

Remember(RememberStep)

Recall(RecallStep)

Par(ParBlock)

Hibernate(HibernateStep)

Deliberate(DeliberateBlock)

Consensus(ConsensusBlock)

Forge(ForgeBlock)

Focus(FocusStep)

Grad(GradStep)

§Fase 109 — the proof-carrying derivative step.

Associate(AssociateStep)

Aggregate(AggregateStep)

ExploreStep(ExploreStepNode)

Ingest(IngestStep)

ShieldApply(ShieldApplyStep)

Stream(StreamBlock)

Navigate(NavigateStep)

Drill(DrillStep)

Trail(TrailStep)

Corroborate(CorroborateStep)

OtsApply(OtsApplyStep)

MandateApply(MandateApplyStep)

ComputeApply(ComputeApplyStep)

Listen(ListenStep)

DaemonStep(DaemonStepNode)

Emit(EmitStatement)

§λ-L-E Fase 13 — π-calculus output prefix c⟨v⟩.P (Chan-Output / Chan-Mobility).

Mint(MintStep)

§Fase 92.b — mint <Credential> as <binding>: ephemeral-credential minting (attenuated, TTL-bounded; authority_only_attenuates).

Rotate(RotateStep)

§Fase 94.b — rotate <SecretsStore> [where "…"] with <Tool> as <binding>: mediated secret renewal (rotation_without_revelation).

Publish(PublishStatement)

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

Discover(DiscoverStatement)

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

Persist(PersistStep)

Retrieve(RetrieveStep)

Mutate(MutateStep)

Purge(PurgeStep)

Transact(TransactBlock)

Warden(WardenBlock)

§Fase 88.a — warden(<target>) within <Scope> { … } adversarial security-analysis block. A flow-body block (like quant): a target reference + a mandatory within <Scope> authorization clause + a nested body (find_exploits() → list[Vulnerability], fortify). NOT a top-level declaration.

Quant(QuantBlock)

§Fase 51.a — quant { … } cognitive block (Hilbert-space projection). Carries an optional attribute header + a real nested body of flow steps (so §51.b’s Continuous Type Invariant can scan it). Lives inside a flow body like par; NOT a top-level declaration.

Yield(YieldStatement)

§Fase 51.d.2 — yield <expr> measurement point inside a quant block. Collapses the evolved amplitudes back to classical silicon; the effect operation whose resolution is a one-shot delimited continuation. Only well-formed inside a quant block (the checker rejects it elsewhere).

Run(RunStatement)

§Fase 52.c — run <Flow>(args) as a flow-step: invoke a declared flow from inside a body (notably a daemon’s listen handler — the Q3 ask). Reuses the top-level RunStatement shape (flow name + args + optional persona/context/anchors). Distinct from Declaration::Run only by position (a step inside a body vs. a program-root run).

GenericStep(GenericFlowStep)

Flow-level statements we recognize but parse structurally.

Trait Implementations

impl Debug for FlowStep

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

Formats the value using the given formatter.