Struct SessionActivationRouter 

pub struct SessionActivationRouter { /* private fields */ }

One router per owning runtime/AppState. All keys are logical Session ids.

Implementations

impl SessionActivationRouter

pub fn new() -> Arc<Self>

pub async fn set_spawner(&self, spawner: Arc<dyn SessionActivationSpawner>)

Late-bind the real server/SDK reservation adapter after its dependency graph has been assembled.

pub async fn current_run_id(&self, target_session_id: &str) -> Option<String>

Snapshot the current logical run, including its terminal handoff.

pub fn set_inbox(&self, inbox: Arc<dyn SessionInboxPort>)

Bind the durable inbox used by abandoned-run reconciliation.

pub async fn reconcile_wake( &self, target_session_id: &str, now: DateTime<Utc>, ) -> Result<SessionWakeReconcileResult, SessionActivationError>

Reconcile one target against a storage-locked proof of claimable work. A later claim still CAS-checks the lease and activation policy. The router keeps only a bounded retry guard, never queue truth.

pub async fn register_run( self: &Arc<Self>, target_session_id: &str, run_id: &str, ) -> Result<SessionRunRegistration, SessionRunRegistrationError>

Register an execution created by any entry point. The returned receiver is a safe-point wake signal; the loop also drains the durable inbox at every round boundary, so missed/coalesced notifications do not lose data.

pub async fn register_session_run( self: &Arc<Self>, session: &Session, run_id: &str, ) -> Result<SessionRunRegistration, SessionRunRegistrationError>

Register from the actual execution’s Session, enabling birth-fenced steer. This is a trusted host entrypoint, not model-supplied authority.

pub async fn revoke_supervisor_loop_control( &self, target: &str, grant_id: &Uuid, ) -> bool

Host revocation shares the target publication fence with physical writes. It does not stop another run or retain a grant after owner exit.

pub async fn attach_delivery_sink( &self, target_session_id: &str, sink: UnboundedSender<u64>, ) -> Option<String>

Bind an external actor driver to the current logical-session owner.

Returns the active run id used to correlate every forwarded claim and confirmation. A pending generation is pushed immediately, closing the delivery-before-bind race without making this in-memory signal durable.

pub async fn detach_delivery_sink(&self, target_session_id: &str, run_id: &str)

Remove a driver only when it still belongs to the same activation run. A stale driver can therefore never unbind its successor.

pub async fn owns_run(&self, target_session_id: &str, run_id: &str) -> bool

True only while this exact activation run remains the logical owner.

pub async fn begin_finalization(&self, target_session_id: &str, run_id: &str)

Mark the current run as finalizing before its runner slot becomes available. Deliveries racing this interval are retained in latest_generation and handed to one successor by finish_finalization.

pub async fn finish_finalization( &self, target_session_id: &str, run_id: &str, admitted_generation: u64, ) -> Result<Option<SessionActivationDisposition>, SessionActivationError>

Release the terminal owner and, if the durable transcript cursor is behind a concurrently delivered inbox generation, reserve and launch exactly one successor using the injected real runtime adapter.

pub async fn subscribe(&self, target_session_id: &str) -> Receiver<u64>

Trait Implementations

impl Clone for SessionActivationRouter

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for SessionActivationRouter

fn default() -> Self

Returns the “default value” for a type.

impl SessionActivationPort for SessionActivationRouter

fn scoped_transport_runtime_instance(&self) -> Option<Arc<()>>

Opaque in-process runtime identity, never serialized or a model grant.

fn retain_closed_scoped_transport_blocking( &self, binding: &ScopedLoopControlBinding, ) -> Result<Arc<dyn SessionRunDeliveryGuard>, SessionRunConflict>

Disposal only: a real closed owner in this exact runtime. An absent owner, a fresh router, contention or a failed retain is NOT a dead-run proof. This guard must never notify, admit, resume or publish runtime.

fn retain_expected_run_blocking( &self, target_session_id: &str, target_created_at: DateTime<Utc>, expected_run_id: &str, ) -> Result<Arc<dyn SessionRunDeliveryGuard>, SessionRunConflict>

Called only from an already-owned blocking filesystem job. Retain the exact registered non-finalizing owner across the synchronous publication boundary. Implementations must not emulate this with a read-then-act. Fence only this target: never retain a runtime-global state lock over filesystem I/O. The guard must not be held across an async wait or re-enter this router. Notification runs in the same blocking job.

fn observe_supervisor_loop<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, supervisor: &'life1 SupervisorReference, target: &'life2 str, expected_link_revision: Option<u64>, action: LoopControlAction, ) -> Pin<Box<dyn Future<Output = Result<ScopedLoopControlBinding, SessionInboxError>> + Send + 'async_trait>>

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

Observe the host-installed grant on a live owner. Canonical storage independently revalidates caller/link/permissions before each use.

fn retain_supervisor_loop_blocking( &self, binding: &ScopedLoopControlBinding, ) -> Result<Arc<dyn SessionRunDeliveryGuard>, SessionRunConflict>

Retain the exact owner AND the equal installed grant in a blocking job. Like retain_expected_run_blocking, this must never cross an async wait.

fn notify_active_delivery<'life0, 'life1, 'async_trait>( &'life0 self, target_session_id: &'life1 str, inbox_generation: u64, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

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

Signal only a currently running, non-finalizing owner. Never reserve a runner or retain successor activation intent. False is not a failure of durable admission: an idle target keeps the message until a later turn.

fn request_activation<'life0, 'life1, 'async_trait>( &'life0 self, target_session_id: &'life1 str, inbox_generation: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionActivationDisposition, SessionActivationError>> + Send + 'async_trait>>

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