Struct IRProgram 

pub struct IRProgram {

    pub node_type: &'static str,
    pub source_line: u32,
    pub source_column: u32,
    pub personas: Vec<IRPersona>,
    pub contexts: Vec<IRContext>,
    pub anchors: Vec<IRAnchor>,
    pub tools: Vec<IRToolSpec>,
    pub memories: Vec<IRMemory>,
    pub types: Vec<IRType>,
    pub flows: Vec<IRFlow>,
    pub runs: Vec<IRRun>,
    pub imports: Vec<IRImport>,
    pub agents: Vec<IRAgent>,
    pub shields: Vec<IRShield>,
    pub daemons: Vec<IRDaemon>,
    pub ots_specs: Vec<IROts>,
    pub pix_specs: Vec<IRPix>,
    pub corpus_specs: Vec<IRCorpus>,
    pub psyche_specs: Vec<IRPsyche>,
    pub mandate_specs: Vec<IRMandate>,
    pub lambda_data_specs: Vec<IRLambdaData>,
    pub compute_specs: Vec<IRCompute>,
    pub axonstore_specs: Vec<IRAxonStore>,
    pub endpoints: Vec<IRAxonEndpoint>,
    pub extensions: Vec<IRExtension>,
    pub dataspace_specs: Vec<IRDataspace>,
    pub resources: Vec<IRResource>,
    pub fabrics: Vec<IRFabric>,
    pub manifests: Vec<IRManifest>,
    pub observations: Vec<IRObserve>,
    pub intention_tree: Option<IRIntentionTree>,
    pub reconciles: Vec<IRReconcile>,
    pub leases: Vec<IRLease>,
    pub ensembles: Vec<IREnsemble>,
    pub sessions: Vec<IRSession>,
    pub topologies: Vec<IRTopology>,
    pub immunes: Vec<IRImmune>,
    pub reflexes: Vec<IRReflex>,
    pub heals: Vec<IRHeal>,
    pub components: Vec<IRComponent>,
    pub views: Vec<IRView>,
    pub channels: Vec<IRChannel>,
    pub sockets: Vec<IRSocket>,
    pub effects: Vec<IREffectDeclaration>,
}

Fields

node_type: &'static str

source_line: u32

source_column: u32

personas: Vec<IRPersona>

contexts: Vec<IRContext>

anchors: Vec<IRAnchor>

tools: Vec<IRToolSpec>

memories: Vec<IRMemory>

types: Vec<IRType>

flows: Vec<IRFlow>

runs: Vec<IRRun>

imports: Vec<IRImport>

agents: Vec<IRAgent>

shields: Vec<IRShield>

daemons: Vec<IRDaemon>

ots_specs: Vec<IROts>

pix_specs: Vec<IRPix>

corpus_specs: Vec<IRCorpus>

psyche_specs: Vec<IRPsyche>

mandate_specs: Vec<IRMandate>

lambda_data_specs: Vec<IRLambdaData>

compute_specs: Vec<IRCompute>

axonstore_specs: Vec<IRAxonStore>

endpoints: Vec<IRAxonEndpoint>

extensions: Vec<IRExtension>

§Fase 53 — closed-catalog extension declarations (compiled). #[serde(skip)] so the field is NOT emitted into the IR JSON — this keeps the static IR-JSON drift-gate fixtures green without regenerating them (same established pattern as dataspace_specs). The in-memory field feeds the §53.c type-checker + §53.d PCC (both read &IRProgram); soundness invariant #1 holds via SOURCE re-derivation — both the prover and the verifier read the source-derived IR, which carries the extensions. §53.x hardening (optional): un-skip + regenerate fixtures + bind extensions into the PCC artifact_digest (today the digest omits them; the witness still binds them by re-derivation). Deterministically sorted by name at the end of IR generation (§53.b founder refinement B) so multi-file declaration order can never perturb the proof-bundle hash.

dataspace_specs: Vec<IRDataspace>

Local-only: IRDataspace specs are computed during IR generation so the cost estimator and inspectors can reach them, but Python’s reference IRProgram does not serialise this field. Hidden from JSON output for byte-identical parity (§8.2.h.1).

resources: Vec<IRResource>

§λ-L-E Fase 1 — I/O cognitivo primitives (compiled).

fabrics: Vec<IRFabric>

manifests: Vec<IRManifest>

observations: Vec<IRObserve>

intention_tree: Option<IRIntentionTree>

§λ-L-E Fase 1 (Free Monad root) — populated when the program declares manifests/observes. None ⇒ serialises as null (matches Python when the field is None).

reconciles: Vec<IRReconcile>

§λ-L-E Fase 3 — Control cognitivo primitives (compiled).

leases: Vec<IRLease>

ensembles: Vec<IREnsemble>

sessions: Vec<IRSession>

§λ-L-E Fase 4 — Topology + Session (compiled).

topologies: Vec<IRTopology>

immunes: Vec<IRImmune>

§λ-L-E Fase 5 — Immune system (compiled).

reflexes: Vec<IRReflex>

heals: Vec<IRHeal>

components: Vec<IRComponent>

§λ-L-E Fase 9 — UI cognitiva declarativa (compiled).

views: Vec<IRView>

channels: Vec<IRChannel>

§λ-L-E Fase 13 — Mobile typed channels (compiled).

sockets: Vec<IRSocket>

§Fase 41.b — typed WebSocket transports (compiled). Each carries its referenced session protocol + the credit-window backpressure so axon-rs can realise the typed endpoint over a tokio WebSocket.

effects: Vec<IREffectDeclaration>

§Fase 23 — algebraic effect declarations (compiled). Each declared effect persists into IR so axon-rs can build the per-effect operation table at startup. The CPS state graph for perform/handle sites lives inline within IRFlow.steps (each IRPerform / IRHandlerFrame carries its assigned state_id / frame_id).

This Rust port mirrors the Python-side IRProgram.effects: tuple[IREffectDeclaration, ...] field so the byte-identical structural-parity gate stays green. The Rust frontend (axon-frontend) does not yet emit Fase 23 IR itself — the field exists to preserve serialization shape; the actual algebraic-effects compiler lives on the Python side, and the Rust runtime (axon-rs/src/effects/) consumes the JSON IR emitted by Python.

Implementations

impl IRProgram

pub fn new() -> IRProgram

Trait Implementations

impl Debug for IRProgram

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

Formats the value using the given formatter.

impl Serialize for IRProgram

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.