🥮 mooncakes.io
    Sign in

    gaato/discord/gateway does not have a README file

    GatewayTransport

    source
    pub(open) trait GatewayTransport {
      async fn recv(Self) -> GatewayFrame
      async fn send(Self, String) -> Unit
      async fn close(Self, code~ : Int) -> Unit
    }

    The seam between the shard driver and the network: implemented by the real WebSocket connection in production and by an in-memory fake in tests.

    Inflater

    source
    pub(open) trait Inflater {
      fn push(Self, Bytes) -> String? raise
    }

    Stateful decoder seam for Gateway compression. Implementations retain one inflate context across messages. None means the Z_SYNC_FLUSH suffix has not arrived yet.

    GatewayConfigError

    source
    pub(all) suberror GatewayConfigError {
      InvalidMaxMessageBytes(value~ : Int)
    } derive(
    Debug    )

    Raised for a Gateway configuration that cannot work.

    InflateError

    source
    pub(all) suberror InflateError {
      Malformed(message~ : String)
      InvalidUtf8
      TooLarge(limit~ : Int)
    } derive(
    Debug    )

    Raised when a compressed Gateway stream cannot be decoded.

    TransportClosed

    source
    pub(all) suberror TransportClosed {
      TransportClosed(code~ : Int?, reason~ : String)
    } derive(
    Debug    )

    Raised by transports when the peer closed the connection. code is the WebSocket close code (Discord uses 4xxx application codes), None for abnormal/transport-level termination.

    CommandLimiter

    source
    pub struct CommandLimiter {
      // private fields
    }

    Sliding-window log limiter for gateway commands: Discord allows 120 sends per 60 seconds per connection; a few slots are reserved for heartbeats (which bypass this limiter), so user commands default to 115.

    CommandLimiter::CommandLimiter

    source
    fn CommandLimiter::CommandLimiter(limit? : Int, window_ms? : Int, clock? : &
    Clock    ) -> CommandLimiter

    Create a limiter allowing limit sends per sliding window (60 seconds by default).

    CommandLimiter::acquire

    source
    async fn CommandLimiter::acquire(self : CommandLimiter) -> Unit

    Wait until a send slot is available within the window, then consume it.

    GatewayFrame

    source
    pub(all) enum GatewayFrame {
      Text(String)
      Binary(Bytes)
    } derive(
    Debug    )

    A complete WebSocket message received from the Gateway.

    ReconnectPolicy

    source
    pub(all) enum ReconnectPolicy {
      Resume
      Reidentify
      Fatal
    } derive(Eq, 
    Debug    )

    Action after a gateway close: resume the session, identify from scratch, or give up because reconnecting cannot succeed.

    Session

    source
    pub(all) struct Session {
      id : String
      resume_url : String
      sequence : Int64
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    Gateway session state retained across reconnects for RESUME. Persist it (for example with to_json) and pass it to Shard::start(resume~) after a process restart. sequence serializes as a JSON string (core's Int64 encoding); from_json accepts that form.

    Session::to_json

    source
    fn Session::to_json(Session) -> Json

    Shard

    source
    pub struct Shard {
      // private fields
    }

    A single gateway connection with automatic heartbeat, resume, and reconnect. Pull events with next; the shard's tasks live in the task group passed to start, so cancelling the group tears the shard down.

    Shard::close

    source
    async fn Shard::close(self : Shard) -> Unit noraise

    Request a graceful shutdown: closes the connection with code 1000 (which invalidates the session — Discord will not allow a resume after it).

    Shard::latency_ms

    source
    fn Shard::latency_ms(self : Shard) -> Int64?

    Latest heartbeat round-trip time in milliseconds.

    Shard::next

    source
    async fn Shard::next(self : Shard) -> ShardEvent

    Pull the next event. Blocks until one is available.

    Shard::request_channel_info

    source
    async fn Shard::request_channel_info(self : Shard, request : 
    RequestChannelInfo    ) -> Unit

    Send opcode 43 on the shard that owns the request's guild.

    Shard::request_guild_members

    source
    async fn Shard::request_guild_members(self : Shard, request : 
    RequestGuildMembers    ) -> Unit

    Validate and send opcode 8 on the shard that owns the request's guild.

    Shard::request_soundboard_sounds

    source
    async fn Shard::request_soundboard_sounds(self : Shard, request : 
    RequestSoundboardSounds    ) -> Unit

    Send opcode 31 for guilds owned by this shard.

    Shard::send

    source
    async fn Shard::send(self : Shard, command : Json) -> Unit

    Send a gateway command (presence update, request guild members, ...). Rate limited (120/60s minus heartbeat reserve) and serialized with the shard's other writes.

    Shard::session

    source
    fn Shard::session(self : Shard) -> Session?

    A copy of the current gateway session, or None before the first READY and after the session was invalidated. Persist it to RESUME after a restart.

    Shard::start

    source
    fn[X] Shard::start(group : 
    TaskGroup    [X], token~ : String, intents~ : 
    Intents    , capabilities? : 
    GatewayCapabilities    , gateway_url? : String, shard_id? : Int, shard_count? : Int, identify_queue? : &
    IdentifyQueue    , event_filter? : (
    EventKind    ) -> Bool, connector? : async (String) -> &GatewayTransport, compress? : Bool, inflater_factory? : () -> &Inflater raise, max_message_bytes? : Int, queue_capacity? : Int, telemetry? : (
    TelemetryEvent    ) -> Unit, clock? : &
    Clock    , rand? : 
    Rand    , resume? : Session, presence? : 
    UpdatePresence    ) -> Shard

    Spawn a shard into group and return its handle. resume seeds the session so the first connection attempts RESUME at its resume_url. The initial presence is retained with a copy of its activities array. A message larger than max_message_bytes, compressed or inflated, ends the connection and the shard resumes; a limit below 1 closes the shard fatally with code 0 before it connects.

    Shard::state

    source
    fn Shard::state(self : Shard) -> ShardState

    The current lifecycle state of this shard.

    Shard::update_presence

    source
    async fn Shard::update_presence(self : Shard, presence : 
    UpdatePresence    ) -> Unit

    Send opcode 3 and retain a snapshot of the last successfully sent presence for Identify. Serializes presence updates and waits for the general command limit before pacing updates at five per 20-second sliding window. The presence window records successful writes only, after they complete.

    Shard::update_voice_state

    source
    async fn Shard::update_voice_state(self : Shard, state : 
    UpdateVoiceState    ) -> Unit

    Send opcode 4 (Update Voice State) on this shard. Send it on the shard that owns state.guild_id; @bot.GatewayCtx::update_voice_state picks it.

    ShardEvent

    source
    pub(all) enum ShardEvent {
      Dispatch(
    Event    )
      Connected(resumed~ : Bool)
      Disconnected(code~ : Int?, resuming~ : Bool)
      FatallyClosed(code~ : Int)
    } derive(
    Debug    )

    Events surfaced by Shard::next.

    ShardState

    source
    pub(all) enum ShardState {
      Disconnected(reconnect_attempts~ : Int)
      Connecting
      Identifying
      Resuming
      Active
      FatallyClosed(code~ : Int)
    } derive(Eq, 
    Debug    )

    Shard lifecycle state.

    DEFAULT_MAX_MESSAGE_BYTES

    source
    let DEFAULT_MAX_MESSAGE_BYTES : Int

    The largest Gateway message a shard accepts by default, compressed or not: far above anything Discord sends, but a bound on what one message can make the process allocate.

    connect_websocket

    source
    async fn connect_websocket(url : String, max_message_bytes? : Int) -> &GatewayTransport

    Connect to the gateway over WebSocket (the default connector). A message larger than max_message_bytes ends the connection with code 1009 (Message Too Big), or 4000 on JavaScript, whose WebSocket API can send only 1000 and 3000-4999.

    on_close

    source
    fn on_close(code : Int?, has_session : Bool) -> ReconnectPolicy

    Classify a close code into the action to take, per the Discord docs.

    • fatal: authentication failure or invalid shard/intent configuration — reconnecting cannot succeed;
    • re-identify: the session is gone (invalid seq, session timeout);
    • resume: everything else (transient errors, unclean closes), provided a session exists.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io