Enum Inode 

pub enum Inode {
    Null,
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
    DurationMs(u64),
    Quantity {
        value: NodeId,
        unit: UnitTag,
    },
    Array {
        elements: Vec<NodeId>,
    },
    Table {
        fields: Vec<(String, NodeId)>,
    },
    Secret(SecretBytes),
    SecretRef {
        locator: NodeId,
    },
    Ref(NodeId),
    Env {
        name: String,
        default: Option<NodeId>,
    },
    Ident(String),
    Interpolate {
        parts: Vec<InterpPart>,
    },
    Binary {
        op: BinOp,
        lhs: NodeId,
        rhs: NodeId,
    },
    Unary {
        op: UnOp,
        expr: NodeId,
    },
    Constrained {
        target: NodeId,
        constraint: Constraint,
    },
    Patch(PatchOp),
    SchemaField(SchemaFieldSpec),
    SchemaTable {
        fields: Vec<(String, NodeId)>,
        closed: bool,
    },
    SchemaArray {
        element: NodeId,
    },
    Semantic {
        tag: SemanticTag,
        inner: NodeId,
    },
    ContentAddressed {
        media_type: NodeId,
        data: NodeId,
    },
    Blob {
        hash: [u8; 32],
        size: u64,
        tainted: bool,
        media_type: String,
        payload: Option<Vec<u8>>,
    },
}

A module node.

Every variant is a value of the Active IR after name resolution; Ident is retained only because decoded third-party modules may still contain one (the encoder never emits it for canonical modules produced from active-core).

Debug is written by hand (never derived): blob payloads are summarized by identity and secrets render as Secret(***), so logging a module can never dump payload or secret bytes.

Variants

Null

Bool(bool)

Int(i64)

Float(f64)

Str(String)

DurationMs(u64)

Quantity

Fields

value: NodeId

unit: UnitTag

Array

Fields

elements: Vec<NodeId>

Table

Fields

fields: Vec<(String, NodeId)>

Secret(SecretBytes)

A structural secret literal. Never equals anything.

SecretRef

A secret derived from a locator node (secret.env(NAME), secret(<expr>)).

Fields

locator: NodeId

Ref(NodeId)

Env

Fields

name: String

default: Option<NodeId>

Ident(String)

Interpolate

Fields

parts: Vec<InterpPart>

Binary

Fields

op: BinOp

lhs: NodeId

rhs: NodeId

Unary

Fields

op: UnOp

expr: NodeId

Constrained

Fields

target: NodeId

constraint: Constraint

Patch(PatchOp)

SchemaField(SchemaFieldSpec)

SchemaTable

Fields

fields: Vec<(String, NodeId)>

closed: bool

SchemaArray

Fields

element: NodeId

Semantic

Fields

tag: SemanticTag

inner: NodeId

ContentAddressed

blob(media_type, data) construction site (reserved kind 24).

Fields

media_type: NodeId

data: NodeId

Blob

A materialised content-addressed blob identity.

payload is present only for untainted blobs that were materialised; a tainted blob never carries bytes, and the codec refuses a tainted blob entry whose payload is non-empty.

Fields

hash: [u8; 32]

size: u64

tainted: bool

media_type: String

payload: Option<Vec<u8>>

Implementations

impl Inode

pub const fn kind(&self) -> SerializedKind

Stable kind identity of this node.

impl Inode

pub const fn kind_code(&self) -> u8

Stable kind discriminant (wire contract, docs/spec/layout.md §5.1).

pub const fn is_secret(&self) -> bool

Whether this node carries secret material or a secret locator.

pub fn children(&self) -> Vec<NodeId>

Node references in canonical child order.

This is the single source of truth for the dependency edges, the canonical numbering traversal, cycle detection and graph queries. It must list every node reference the variant holds.

pub fn strings(&self, out: &mut Vec<String>)

Every string this node owns, for heap construction.

Trait Implementations

impl Clone for Inode

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Inode

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

Formats the value using the given formatter.

impl PartialEq for Inode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Inode