Struct HostSessionConnector 

pub struct HostSessionConnector { /* private fields */ }

A one-shot host handoff factory, evaluated on the SDK worker’s LocalSet.

The platform host supplies this to shared toolkit bootstrap. It must verify host/app/workspace handoff authority before returning its two connections. This type neither authenticates a transport nor certifies a supplied grant. The actual brokers still enforce certified joins and live signing policy. No inherited service or app-local identity is used if the factory fails.

Consumed on both success and failure. There is no automatic reconnect. A host retry must create a fresh connector and repeat admission for the same durable identity and requested route; an old handoff must not be replayed.

Implementations

impl HostSessionConnector

pub fn new<F, Fut, C, I>(connect: F) -> HostSessionConnector

where F: FnOnce(RouteSpec) -> Fut + Send + 'static, Fut: Future<Output = Result<(C, I), NotAvailable>> + 'static, C: AsyncRead + AsyncWrite + 'static, I: AsyncRead + AsyncWrite + 'static,

Supply a factory for an owned collaboration stream and broker signer.

The factory runs only inside the SDK worker’s Tokio runtime/LocalSet and returns separate owned collaboration and identity transports. Only the factory and its captures cross threads; its future and streams may be !Send. It must authenticate both endpoints and enforce the requested route. Shared code frames and bounds every identity exchange async. The manager waits for the factory’s own outcome: a factory that cannot connect returns why.

Merely returning metadata does not establish authentication. Do not use this constructor as a replacement for host transport/grant validation.

pub fn with_descriptor_lane<F, Fut, C, I>(connect: F) -> HostSessionConnector

where F: FnOnce(RouteSpec) -> Fut + Send + 'static, Fut: Future<Output = Result<(C, I), NotAvailable>> + 'static, C: DescriptorStreamSource + 'static, I: AsyncRead + AsyncWrite + 'static,

Self::new for a collaboration stream that is a local socket: its writes also carry the descriptors the app hands the broker, as the launcher’s inherited service connection does, so an in-process app can hand Files’ selected objects over exactly as a launched one. A host whose streams carry no descriptors gives an empty lane.

impl HostSessionConnector

pub fn once_ready<F, Fut>(self, ready: F) -> HostSessionConnector

where F: FnOnce() -> Fut + Send + 'static, Fut: Future<Output = ()> + 'static,

Connect only once ready resolves: when the host says the services this connection reaches are listening, or that their start is over. A host showing an app while it is still starting those services (a session restoring its tabs before it binds its broker) waits for them; connecting before then finds no socket and leaves the app offline. ready must resolve once the host’s start is over, whatever its outcome.