Struct Held 

pub struct Held {
    conversation: Mutex<Conversation>,
    folded: Condvar,
}

One seat’s conversation, and the fold that may be running over it.

Two locks, because a fold must not be held against the stream and a reader must not see half of one. A fold takes the messages out in O(1) under the mutex, renders them outside it - so the socket’s single stream folder never waits on a render - and puts them back under the mutex with the spans. Between those two the seat holds no messages and the PREVIOUS fold’s boundaries, and a page sliced on those walks off the end of an empty list.

So the mutex is paired with a condvar: a reader waits out a fold in progress rather than looking at it. The wait is on the reader’s own blocking task, and it is bounded by one render.

Fields

conversation: Mutex<Conversation>

folded: Condvar

Implementations

impl Held

pub fn new(conversation: Conversation) -> Self

pub fn holds_occupant(&self, occupant: Option<&SessionId>) -> bool

Whether this copy belongs to the seat’s current occupant.

A copy with no occupant matches anything, and so does a header naming nobody: a transcript that named no session seeds a copy with no occupant, and a sleeping seat’s header names no run - neither is discarded for lacking a fact nothing ever recorded.

pub fn lock(&self) -> MutexGuard<'_, Conversation>

The conversation, waiting out a fold that is running over it.

fn install(&self, window: Window, rendered: Rendered, complete: bool)

Put a fold’s result back and wake every reader waiting on it.

pub fn read<T>(&self, read: impl FnOnce(&Conversation) -> T) -> T

Fold if needed, then read, retrying once if a reseed landed in between.

Two acquisitions, and the gap between them is why this retries. A Connected or a /resume can replace the conversation between the fold and the read, and what a reader then holds is the new messages against boundaries the fold cleared - one turn covering the whole conversation rather than a window of them. The retry closes the common case; a second reseed inside the second window still gets through, which is stated in the PR rather than claimed away.

pub fn fold(&self)

Fold if the messages moved, outside the lock and off the reactor.

The caller is a blocking task that has nothing else to do with the conversation until this returns.