Struct DeliveryState 

struct DeliveryState {
    deliveries: HashMap<DeliveryKey, Delivery>,
    fallback_claims: HashMap<(String, Reason), i64>,
    fallbacks: HashMap<String, FallbackDelivery>,
    boundary_origins: VecDeque<(String, String, i64)>,
    completed: HashMap<(String, Reason), i64>,
}

Deliveries and fallback claims, behind one lock so “who claimed this event first” is decided atomically.

Fields

deliveries: HashMap<DeliveryKey, Delivery>

fallback_claims: HashMap<(String, Reason), i64>

Events the frontend’s hidden-reinjection fallback claimed: (block, reason) → when.

fallbacks: HashMap<String, FallbackDelivery>

Re-deliveries srv composed for the frontend’s fallback, by delivery_id, until the hidden message that sends one arrives.

boundary_origins: VecDeque<(String, String, i64)>

Which block’s CLI wrote each compaction boundary, and when: (uuid, block, ms), oldest first.

completed: HashMap<(String, Reason), i64>

The newest hook delivery each (block, reason) finished: when it was composed. Unlike deliveries it isn’t pruned, so a fallback deferred behind a long turn still finds it. One entry per block and reason.

Implementations

impl DeliveryState

fn prune(&mut self, now: i64)

fn fallback_claimed(&self, block_id: &str, reason: Reason) -> bool

fn hook_deliveries_mut( &mut self, block_id: &str, reason: Reason, now: i64, since: i64, ) -> Vec<&mut Delivery>

The hook’s deliveries of this event, newest first: inside the claim window and created after since.

fn claim_fallback( &mut self, block_id: &str, reason: Reason, now: i64, since: i64, ) -> FallbackClaim

The fallback’s atomic claim on an event. A Deliver for an unclaimed event records the claim, so the hook’s parts for it come back empty. Hook deliveries created at or before since belong to an earlier event.

fn record_boundary(&mut self, uuid: &str, block_id: &str, now: i64)

fn claim_boundary( &mut self, block_id: &str, reason: Reason, boundary_uuid: Option<&str>, now: i64, ) -> FallbackClaim

A claim naming its compaction boundary. Only the block whose own CLI wrote the boundary may deliver: another block of the agent reads it from the shared transcript zone, and its CLI did not compact. A boundary no stdout here wrote (another srv instance’s) is not this block’s either. A hook delivery from before the block’s previous boundary was that compaction’s, not this one’s.

fn claim_event( &mut self, block_id: &str, reason: Reason, event_at: i64, now: i64, ) -> FallbackClaim

A claim dated by its event: a fresh session, at its agentmux_session_outcome frame’s timestamp (srv’s own clock). A hook delivery composed after the event and finished is that event’s however long ago, so a fallback deferred behind the session’s first turn stands down even past CLAIM_WINDOW_MS. One from before it was an earlier session’s and doesn’t count.

fn note_completed(&mut self, key: &DeliveryKey, created_ms: i64)

The hook finished a delivery: its notice went out.

fn take_over_from_hook(&mut self, block_id: &str, reason: Reason, now: i64)

The fallback gave up waiting for the hook: it delivers, and the hook’s unfinished delivery is closed so a late acknowledgement adds no second notice.

Trait Implementations

impl Default for DeliveryState

fn default() -> DeliveryState

Returns the “default value” for a type.