Enum Message 

pub enum Message {
    Flow,
    Event(EncodableValue),
    Boolean(bool),
    Integer(i64),
    Float(f64),
    String(Arc<String>),
    Object(Arc<EncodableValue>),
    Array(Arc<Vec<EncodableValue>>),
    Bytes(Arc<Vec<u8>>),
    StreamHandle(Arc<StreamHandle>),
    Encoded(Arc<Vec<u8>>),
    Optional(Option<Arc<EncodableValue>>),
    Any(Arc<EncodableValue>),
    Error(Arc<String>),
    RemoteReference {
        network_id: String,
        actor_id: String,
        port: String,
    },
    NetworkEvent {
        event_type: NetworkEventType,
        data: EncodableValue,
    },
}

Variants

Flow

Control-flow signal carrying no data. Used to trigger execution or propagate completion through the graph.

Event(EncodableValue)

Arbitrary event payload. Carries a dynamically-typed value typically originating from external triggers or user interactions.

Boolean(bool)

Boolean value.

Integer(i64)

Signed 64-bit integer value.

Float(f64)

64-bit floating-point value.

String(Arc<String>)

UTF-8 text data (ref-counted for cheap cloning through connectors).

Object(Arc<EncodableValue>)

Structured key-value object (JSON-like). Schema is dynamic; use PortType::Object(name) at the port level for type hints.

Array(Arc<Vec<EncodableValue>>)

Ordered list of dynamically-typed elements.

Bytes(Arc<Vec<u8>>)

Raw binary data blob. For static binary payloads (images, encoded buffers, etc.) that fit in memory. Not a live stream — see StreamHandle for async streaming between actors.

StreamHandle(Arc<StreamHandle>)

Handle to a live data stream managed by the [StreamRegistry].

The actual data flows through a bounded side-channel; this variant carries only the serializable metadata needed to locate the channel. Consumers call ActorContext::take_stream_receiver() to obtain the flume::Receiver<StreamFrame> for async iteration.

Encoded(Arc<Vec<u8>>)

Pre-encoded binary payload (bitcode/zstd compressed). Used for efficient serialization across network boundaries or persistence.

Optional(Option<Arc<EncodableValue>>)

Nullable wrapper around any value. None represents an absent or skipped input on an optional port.

Any(Arc<EncodableValue>)

Escape hatch for values that don’t fit other variants. Accepts any EncodableValue and matches PortType::Any.

Error(Arc<String>)

Error message propagated through the graph. Actors can pattern-match on this to implement error-handling branches.

RemoteReference

Proxy reference to an actor port on a remote network. Used by distributed graph composition to route messages across boundaries.

Fields

network_id: String

actor_id: String

port: String

NetworkEvent

Internal network lifecycle event (actor registered, heartbeat missed, etc.). Consumed by system-level actors, not user graphs.

Fields

event_type: NetworkEventType

data: EncodableValue

Implementations

impl Message

pub fn encode(&self) -> Result<Vec<u8>, MessageError>

Encode message with optional compression

pub fn decode(bytes: &[u8]) -> Result<Message, MessageError>

Decode message

pub fn decode_with_config( bytes: &[u8], config: CompressionConfig, ) -> Result<Message, MessageError>

pub fn get_type(&self) -> PortType

Get the port type of this message

pub fn validate_type(&self, port_type: &PortType) -> Result<(), MessageError>

Validate message against a port type

pub fn encoded_size(&self) -> Result<usize, MessageError>

Get encoded size

pub fn encode_with_config( &self, config: &CompressionConfig, ) -> Result<EncodedMessage, MessageError>

Encode message with configurable compression

pub fn compress_data( &self, data: &[u8], config: &CompressionConfig, ) -> Result<Vec<u8>, MessageError>

Compress data with configured compression level

pub fn compress_streaming( &self, data: &[u8], config: &CompressionConfig, ) -> Result<Vec<u8>, MessageError>

Streaming compression for large data

pub fn decode_compressed( bytes: &[u8], config: &CompressionConfig, ) -> Result<Message, MessageError>

Decode message with automatic decompression

impl Message

pub fn object(value: EncodableValue) -> Message

pub fn any(value: EncodableValue) -> Message

pub fn event(value: EncodableValue) -> Message

pub fn array(messages: Vec<EncodableValue>) -> Message

pub fn bytes(bytes: Vec<u8>) -> Message

pub fn stream_handle(handle: StreamHandle) -> Message

pub fn encoded(encoded: Vec<u8>) -> Message

pub fn error(msg: String) -> Message

pub fn boolean(value: bool) -> Message

pub fn integer(value: i64) -> Message

pub fn float(value: f64) -> Message

pub fn string(value: String) -> Message

pub fn flow() -> Message

pub fn optional(msg: Option<EncodableValue>) -> Message

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl Default for Message

fn default() -> Message

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Message

fn deserialize<__D>( __deserializer: __D, ) -> Result<Message, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Value> for Message

fn from(value: Value) -> Message

Converts to this type from the input type.

impl PartialEq for Message

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Message

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.

impl<'__de> Decode<'__de> for Message

impl Encode for Message

impl StructuralPartialEq for Message