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 windows: Vec<IRWindow>,
    pub budgets: Vec<IRBudget>,
    pub daemons: Vec<IRDaemon>,
    pub ots_specs: Vec<IROts>,
    pub pix_specs: Vec<IRPix>,
    pub ledger_specs: Vec<IRLedger>,
    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 observables: Vec<IRObservable>,
    pub witnesses: Vec<IRWitness>,
    pub upstreams: Vec<IRUpstream>,
    pub cors_policies: Vec<IRCors>,
    pub caches: Vec<IRCache>,
    pub credentials: Vec<IRCredential>,
    pub savants: Vec<IRSavant>,
    pub documents: Vec<IRDocument>,
    pub deliveries: Vec<IRDeliver>,
    pub notifications: Vec<IRNotify>,
    pub synths: Vec<IRSynth>,
    pub scopes: Vec<IRScope>,
    pub effects: Vec<IREffectDeclaration>,
    pub modules: Vec<IRModuleProvenance>,
}

§Fase 112.b — Clone is additive and every member IR type already derives it. The Cognitive-I/O supervisor owns the compiled program it drives (it outlives the deploy call that built it), and a lifetime-bound supervisor would have to be threaded through ServerState for no benefit.

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>

windows: Vec<IRWindow>

§Fase 71.a — temporal execution-window guards.

budgets: Vec<IRBudget>

§Fase 114.a — top-level budget declarations. A daemon’s anonymous budget stays on the daemon; these govern EVERY flow that calls the tools they name, including the HTTP endpoints adopters actually deploy.

daemons: Vec<IRDaemon>

ots_specs: Vec<IROts>

pix_specs: Vec<IRPix>

ledger_specs: Vec<IRLedger>

§Fase 62.0 — audit-chain (ledger) declarations. Distinct from pix_specs (the retrieval navigator); a ledger binds a hash-linked recorder to an audited surface.

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 (the pattern dataspace_specs also used until §108.b un-skipped it). 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>

§Fase 108.b — the compiled dataspace schemas, SERIALIZED into the IR JSON (un-skipped). History: this field was #[serde(skip)] for byte-identical parity with the retired Python reference frontend (§8.2.h.1) — which meant the runtime literally could not see a declared dataspace (the §108 ground-truth finding). The parity constraint is gone; the deploy hook walks this field to instantiate the deterministic columnar engine’s stores. Additive for consumers: no IR deserializer uses deny_unknown_fields (verified 2026-07-12), and IRProgram is Serialize-only — consumers re-derive from source.

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.

observables: Vec<IRObservable>

§Fase 51.c.2 — Pauli-sum observable declarations (compiled). Each carries its real-coefficient × Pauli-string terms so axon-rs can build the Hermitian measurement operator M = Σ cₖ Pₖ a quant block measures against. #[serde(skip)] (like extensions / dataspace_specs) so the static IR-JSON drift fixtures stay green; the in-memory field feeds the §51.c.2 checker + the §51.d/e runtime. The checker resolves quant(observable: …) against the AST symbol table, not this field.

witnesses: Vec<IRWitness>

§Fase 69.a — Advantage-Witness declarations. skip_serializing_if = empty keeps a witness-less program’s IR JSON byte-identical (zero IR-SHA drift, the §52/§67 pattern); when present it rides the IR to the enterprise deploy/runtime evaluator (§69.b+).

upstreams: Vec<IRUpstream>

§Fase 80.b — outbound vendor connections (compiled). Each carries its axon-facing session binding (protocol/role), the per-tenant config keys (resolve/secret), the auth handshake, the total wire↔session projection (map) and the reconnect/overflow policies, so axon-rs can dial + transcode without vendor-specific code. skip_serializing_if = empty keeps an upstream-less program’s IR JSON byte-identical (zero IR-SHA drift — the standing §76.d discipline).

cors_policies: Vec<IRCors>

§Fase 83.a — named, referenced browser-origin policies. skip_serializing_if = empty keeps a cors-less program’s IR JSON byte-identical (zero IR-SHA drift — the standing §76.d discipline).

caches: Vec<IRCache>

§Fase 85.b — named, referenced result-memoization policies. Same skip_serializing_if = empty IR-SHA discipline as cors_policies.

credentials: Vec<IRCredential>

§Fase 92.a — ephemeral-credential contracts (credential { ttl: grants: }), minted at runtime by the mint flow verb under the attenuation law (authority_only_attenuates). Same skip_serializing_if = empty IR-SHA discipline.

savants: Vec<IRSavant>

§Fase 87.a — long-horizon autonomous research primitives (compiled). Each carries its domain, cognition params, memory binding, compute budget and mandates so the enterprise engine (§87.h+) can drive the active-inference loop. Same skip_serializing_if = empty IR-SHA discipline as caches (a savant-less program’s IR JSON stays byte-identical — zero drift).

documents: Vec<IRDocument>

§Fase 99.b — compiled document declarations. Same skip_serializing_if = empty IR-SHA discipline (a document-less program’s IR JSON stays byte-identical). Consumed by the runtime DocumentRenderer tool + the DocumentProvenanceSoundness PCC class.

deliveries: Vec<IRDeliver>

§Fase 105 — compiled CRM delivery declarations. Same skip_serializing_if = empty IR-SHA discipline (a delivery-less program’s IR JSON stays byte-identical). Consumed by the runtime delivery dispatch (axon::delivery) + the DeliveryProvenanceSoundness PCC class (T920).

notifications: Vec<IRNotify>

§Fase 110 — governed human notifications (the third egress dual).

synths: Vec<IRSynth>

§Fase 87.d — dynamic tool-synthesis policies (compiled). Same skip_serializing_if = empty IR-SHA discipline as savants.

scopes: Vec<IRScope>

§Fase 88.a — authorization-scope policies (compiled). Same skip_serializing_if = empty IR-SHA discipline as synths.

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.

modules: Vec<IRModuleProvenance>

§Fase 115.e — per-module provenance of a LINKED program: for every module the linker merged, its path, origin file, both EMS hashes and the virtual-line window its declarations occupy (the driver renumbers each module’s lines by a base offset so diagnostics and IR source_lines stay globally unambiguous — map back with line − line_base). skip_serializing_if = empty keeps every single-file program’s IR JSON byte-identical (zero IR-SHA drift — the standing §76.d discipline).

Implementations

impl IRProgram

pub fn new() -> IRProgram

Trait Implementations

impl Clone for IRProgram

fn clone(&self) -> IRProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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.