Struct Tx 

pub struct Tx<T: 'static> {
    pub conn_id: ConnectionId,
    pub channel_id: ChannelId,
    pub sender: SenderSlot,
    pub driver_tx: DriverTxSlot,
    /* private fields */
}

Tx stream handle - caller sends data to callee.

r[impl channeling.caller-pov] - From caller’s perspective, Tx means “I send”. r[impl channeling.type] - Serializes as u64 stream ID on wire. r[impl channeling.holder-semantics] - The holder sends on this stream. r[impl channeling.channels-outlive-response] - Tx streams may outlive Response. r[impl channeling.lifecycle.immediate-data] - Can send Data before Response. r[impl channeling.lifecycle.speculative] - Early Data may be wasted on error.

Facet Implementation

Uses #[facet(proxy = u64)] so that:

• channel_id is pokeable (Connection can walk args and set stream IDs)
• Serializes as just a u64 on the wire
• T is exposed as a type parameter for codegen introspection

Two modes of operation

• Client side: sender holds a channel to an intermediate drain task. ConnectionHandle::call takes the receiver and drains it to wire.
• Server side: task_tx holds a direct channel to the connection driver. ChannelRegistry::bind_streams sets this, and send() writes DriverMessage::Data.

Fields

conn_id: ConnectionId

The connection ID this stream belongs to.

channel_id: ChannelId

The unique stream ID for this stream. Public so Connection can poke it when binding streams.

sender: SenderSlot

Channel sender for outgoing data (client-side mode). Used when Tx is created via roam::channel().

driver_tx: DriverTxSlot

Direct driver message sender (server-side mode). Used when Tx is hydrated by ChannelRegistry::bind_streams.

Implementations

impl<T: 'static> Tx<T>

pub fn new(channel_id: ChannelId, tx: Sender<Vec<u8>>) -> Self

Create a new Tx stream with the given ID and sender channel (client-side mode).

pub fn unbound(tx: Sender<Vec<u8>>) -> Self

Create an unbound Tx with a sender but channel_id 0.

Used by roam::channel() to create a pair before binding. Connection will poke the channel_id and conn_id when binding.

pub fn bound( conn_id: ConnectionId, channel_id: ChannelId, tx: Sender<Vec<u8>>, driver_tx: Sender<DriverMessage>, ) -> Self

Create a bound Tx with conn_id, channel_id and driver_tx already set.

Used by roam::channel() when called during dispatch to create response channels that can send Data directly over the wire.

pub fn channel_id(&self) -> ChannelId

Get the stream ID.

pub async fn send(&self, value: &T) -> Result<(), TxError>

where T: Facet<'static>,

Send a value on this stream.

r[impl channeling.data] - Data messages carry serialized values.

Works in two modes:

• Client-side (or passthrough): sends raw bytes to intermediate channel (drained by connection)
• Server-side: sends DriverMessage::Data directly to connection driver

IMPORTANT: We prefer sender over driver_tx because when a channel created during dispatch is passed to a callback, the rx gets a NEW channel_id allocated by the caller’s bind_streams. The drain task uses that new channel_id, while self.channel_id still has the old dispatch-context channel_id. By using sender, data flows through the drain task which uses the correct channel_id.

Trait Implementations

impl<T: 'static> Drop for Tx<T>

When a Tx is dropped, send a Close message.

r[impl channeling.close] - Close terminates the stream.

The Close path depends on how data was sent:

• If sender is present: data went through drain task, drain task sends Close when channel closes
• If only driver_tx is present: data went directly to driver, we send Close via driver_tx

fn drop(&mut self)

Executes the destructor for this type.

impl<'ʄ, T> Facet<'ʄ> for Tx<T>

where T: Facet<'ʄ> + 'static,

const SHAPE: &'static Shape

The shape of this type, including: whether it’s a Struct, an Enum, something else?

impl<T: 'static> TryFrom<&Tx<T>> for u64

Serialization: &Tx<T> -> u64 (extracts channel_id)

Uses TryFrom rather than From because facet’s proxy mechanism requires TryFrom.

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(tx: &Tx<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: 'static> TryFrom<u64> for Tx<T>

Deserialization: u64 -> Tx<T> (creates a “hollow” Tx)

Both sender slots are empty - the real sender gets set up by Connection after deserialization when it binds the stream.

Uses TryFrom rather than From because facet’s proxy mechanism requires TryFrom.

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(channel_id: u64) -> Result<Self, Self::Error>

Performs the conversion.