Package-level declarations

Which peers hold the voter seats of a game's consensus cluster.

Everything a game bootstrap has wired by the time it asks a ConsensusPlacement for its RaftNode.

Where a game session's consensus authority lives — an injectable, bootstrap-time choice.

Thrown by gameHost when another peer on the same session has already declared itself host.

Lobby presence over seam, backed by an EphemeralMap replicated by Quilter.

A running game session: the consensus node plus any named application channels riding the same fabric.

An application action that has been committed to the replicated log at index.

Thrown by gameJoin when the host never signals admission (neither admits nor closes the roster) within the gameJoin joinAdmissionTimeout bound.

Controls when gameHost returns the leader RaftNode to the caller.

A GameSession bootstrapped over a membership-aware Room — so the game speaks the same presence vocabulary the room already emits, with no second source of truth.

Thrown by gameJoin when the host signals that admission is closed and this peer is not in the final voter set.

Thrown by gameSpectate when the host never signals spectator admission or rejection within the gameSpectate spectateAdmissionTimeout bound.

Thrown by gameSpectate when the host's spectator gallery is closed — either because the host did not enable spectators (allowSpectators = false, the default) or because maxSpectators has already been reached.

Consumer-owned description of a deterministic turn-based game, used by SpeculativeSequencer to apply, snapshot, and restore game state.

A wrapper over TurnSequencer that applies local actions optimistically before their committed index arrives, then rolls back and replays if the committed order differs from what was predicted.

One instruction in a TurnSequencer's in-order TurnSequencer.events stream.

A game-developer-friendly facade over RaftNode.

Host a game session over seam: check for duplicate hosts, bootstrap a singleton-voter cluster, then admit each connecting peer as learner→voter until the cluster reaches the returnAt watermark, then returns a GameSession whose GameSession.node is the leader.

Host a turn-based game over a ConnectionSource: accept-pump a raw hub mesh (us.tractat.kuilt.gossip.hostedMesh) and run gameHost on it with a star-relay (us.tractat.kuilt.gossip.starOverlay, us.tractat.kuilt.gossip.FullFanout) overlay. Clients connect as usual — they call gameJoin over a KtorClientLoom seam, unchanged.

Host one appoint-the-host game in the room named gameId over rooms — the game-per-room analogue of gameHosted.

Join a game session over seam hosted by exactly one gameHost. Starts as a non-voting learner and waits until the host admits this peer as a voter. Returns the local GameSession (its GameSession.node is the admitted follower) once admitted.

Join the hosted game in the room named gameId over rooms — the game-per-room analogue of gameJoin.

Constructs a RaftNode over seam for a session whose full voter roster is already known to every peer (e.g. from matchmaking). Every peer builds the identical ClusterConfig.ofVoters and Raft's own election picks the leader — symmetric, no pre-Raft coordination step required.

Run the fixed-authority bootstrap for the game in the room named gameId over rooms — the game-per-room analogue of gameNode, and the entry point of the server-core game-per-room composition.

Run one game-per-room across a federated server core — the gameNodeRoom analogue for a game whose players are spread over several servers instead of one.

Bootstrap a RoomGameSession over an already-adopted Room, so the game surfaces the room's presence directly instead of the caller hand-wiring a room.events → presence adapter.

Join a game session over seam as a permanent, non-voting spectator learner.