Struct RuntimeContext 

pub struct RuntimeContext { /* private fields */ }

RuntimeContext - Runtime’s implementation of Context trait

Design Features

• Zero vtable: internally uses Gate enum dispatch (not dyn)
• Smart routing: automatically selects Host or Peer based on Dest
• Full implementation: contains complete call/tell logic (encode, send, decode)
• Type safety: generic methods provide compile-time type checking

Performance

• Gate is an enum, uses static dispatch
• Compiler can fully inline the entire call chain
• Zero virtual function call overhead

Implementations

impl RuntimeContext

pub async fn call_raw( &self, target: &Dest, route_key: String, payload_type: PayloadType, payload: Bytes, timeout_ms: i64, ) -> ActorResult<Bytes>

Execute a non-generic RPC request call (useful for language bindings).

pub async fn tell_raw( &self, target: &Dest, route_key: String, payload_type: PayloadType, payload: Bytes, ) -> ActorResult<()>

Execute a non-generic RPC message call (fire-and-forget, useful for language bindings).

pub async fn send_data_stream_with_type( &self, target: &Dest, payload_type: PayloadType, chunk: DataStream, ) -> ActorResult<()>

Send DataStream with an explicit payload type (lane selection).

Convenience wrapper for language bindings that prefer positional payload_type before chunk. Equivalent to calling Context::send_data_stream directly.

Trait Implementations

impl Clone for RuntimeContext

fn clone(&self) -> RuntimeContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Context for RuntimeContext

fn self_id(&self) -> &ActrId

Get the current Actor’s ID

fn caller_id(&self) -> Option<&ActrId>

Get the caller’s Actor ID

fn request_id(&self) -> &str

Get the unique request ID

fn call<'life0, 'life1, 'async_trait, R>( &'life0 self, target: &'life1 Dest, request: R, ) -> Pin<Box<dyn Future<Output = ActorResult<R::Response>> + Send + 'async_trait>>

where R: 'async_trait + RpcRequest, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a type-safe RPC request and wait for response

fn tell<'life0, 'life1, 'async_trait, R>( &'life0 self, target: &'life1 Dest, message: R, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where R: 'async_trait + RpcRequest, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a type-safe one-way message (no response expected)

fn register_stream<'life0, 'async_trait, F>( &'life0 self, stream_id: String, callback: F, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where F: Fn(DataStream, ActrId) -> BoxFuture<'static, ActorResult<()>> + Send + Sync + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Register a DataStream callback for a specific stream

fn unregister_stream<'life0, 'life1, 'async_trait>( &'life0 self, stream_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unregister a DataStream callback

fn send_data_stream<'life0, 'life1, 'async_trait>( &'life0 self, target: &'life1 Dest, chunk: DataStream, payload_type: PayloadType, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a DataStream to a destination with explicit lane selection.

fn discover_route_candidate<'life0, 'life1, 'async_trait>( &'life0 self, target_type: &'life1 ActrType, ) -> Pin<Box<dyn Future<Output = ActorResult<ActrId>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Discover a remote Actor of the specified type via the signaling server.

fn call_raw<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 ActrId, route_key: &'life2 str, payload: Bytes, ) -> Pin<Box<dyn Future<Output = ActorResult<Bytes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send a raw RPC request (untyped bytes) and wait for response

fn register_media_track<'life0, 'async_trait, F>( &'life0 self, track_id: String, callback: F, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where F: Fn(MediaSample, ActrId) -> BoxFuture<'static, ActorResult<()>> + Send + Sync + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Register a WebRTC native media track callback

fn unregister_media_track<'life0, 'life1, 'async_trait>( &'life0 self, track_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unregister a media track callback

fn send_media_sample<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 Dest, track_id: &'life2 str, sample: MediaSample, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send media samples via WebRTC native track

fn add_media_track<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, target: &'life1 Dest, track_id: &'life2 str, codec: &'life3 str, media_type: &'life4 str, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Add a media track to the WebRTC connection with the target

fn remove_media_track<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 Dest, track_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = ActorResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remove a media track from the WebRTC connection with the target.

fn log(&self, level: LogLevel, msg: &str)

Emit a log record from the workload side, routed through whichever observability pipeline the runtime installs.