mooncakes.io

README
U
AllowedMentionType
U
AllowedMentions
U
AllowedMentionsError
U
App
U
AppConfigError
U
AppCtx
U
ApplicationEmojiRef
U
ApplicationRef
U
Arg
U
Args
U
ArgsDecodeError
U
AudioSource
U
AutoModerationRuleRef
U
AutocompleteCtx
U
Bot
U
BotError
U
ChannelRef
U
CheckCtx
U
Client
U
Command
U
CommandCheck
U
CommandCtx
U
CommandModel
U
CommandOptions
U
CommandReply
U
CommandSpec
U
CommandSync
U
ComponentCtx
U
ComponentDeferredCtx
U
ComponentHandler
U
ComponentImmediateCtx
U
ComponentReply
U
ComponentWaiter
U
CooldownBucket
U
Coordinator
U
CoordinatorError
U
DeferredCtx
U
EmojiRef
U
EntitlementRef
U
ErrorPolicy
U
Event
U
EventType
U
Events
U
FailureCtx
U
FailureOrigin
U
FailureRaw
U
FileUpload
U
Framework
U
GatewayCtx
U
GlobalCommandRef
U
GuildCommandRef
U
GuildInvocation
U
GuildRef
U
HandlerError
U
ImmediateCtx
U
InitialResponse
U
Intents
U
InteractionContextError
U
InteractionEndpoint
U
InteractionHandler
U
InteractionOutcome
U
InteractionVerifier
U
InteractionVerifierError
U
InteractionsServer
U
InviteRef
U
InvocationScope
U
MemberRef
U
MessageRef
U
Modal
U
ModalCtx
U
ModalDeferredCtx
U
ModalField
U
ModalFields
U
ModalHandle
U
ModalImmediateCtx
U
ModalOrigin
U
ModalSubmitHandler
U
OggOpusError
U
OggOpusSource
U
OggOpusWriter
U
Paginator
U
RegisteredCommand
U
RemoteIdentifyQueue
U
RemoteRateLimiter
U
ResponsePhase
U
RoleRef
U
ScheduledEventRef
U
Shard
U
ShardConfig
U
ShardEvent
U
SkuRef
U
SlashChild
U
SoundboardSoundRef
U
Spawner
U
StickerRef
U
SuggestCtx
U
TargetUser
U
TelemetryEvent
U
TemplateRef
U
UserRef
U
VoiceConnection
U
VoiceConnectionState
U
VoiceError
U
VoiceEvent
U
VoiceReceiveStream
U
VoiceTelemetry
U
WebhookMessageRef
U
WebhookRef
U
WebhookTokenRef
V
API_VERSION
V
SILENCE_FRAME
V
action_row
V
arg_attachment
V
arg_bool
V
arg_channel
V
arg_int
V
arg_mentionable
V
arg_number
V
arg_role
V
arg_string
V
arg_user
V
attachment_option
V
boolean_option
V
button
V
channel_option
V
channel_select
V
container
V
dm_only
V
guild_only
V
int_choice
V
integer_option
V
label
V
link_button
V
media_gallery
V
media_item
V
mentionable_option
V
mentionable_select
V
message_command
V
modal
V
number_choice
V
number_option
V
required_permissions
V
role_option
V
role_select
V
section
V
select_field
V
select_option
V
separator
V
serve_interactions
V
slash
V
slash_group
V
string_choice
V
string_option
V
string_select
V
sub_command
V
sub_command_group
V
subcommand
V
subcommand_group
V
text_display
V
text_field
V
text_input
V
thumbnail
V
user_command
V
user_option
V
user_select
V
verify_signature

gaato/discord/gateway does not have a README file

GatewayTransport

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.

InflateError

source

pub(all) suberror InflateError {
  InflateError(status~ : Int)
  InvalidUtf8
} derive(@moonbitlang/core/debug.Debug
Debug)

Raised when a compressed Gateway stream cannot be initialized or decoded.

TransportClosed

source

pub(all) suberror TransportClosed {
  TransportClosed(code~ : Int?, reason~ : String)
} derive(@moonbitlang/core/debug.Debug
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, sleeper? : async (Int) -> Unit) -> CommandLimiter

Create a limiter allowing limit sends per 60-second sliding window.

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(@moonbitlang/core/debug.Debug
Debug)

A complete WebSocket message received from the Gateway.

ReconnectPolicy

source

pub(all) enum ReconnectPolicy {
  Resume
  Reidentify
  Fatal
} derive(Eq, @moonbitlang/core/debug.Debug
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(@moonbitlang/core/debug.Debug
Debug)

Gateway session state retained across reconnects for RESUME.

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::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::start

source

fn[X] Shard::start(group : @moonbitlang/async.TaskGroup
TaskGroup[X], token~ : String, intents~ : @gaato/discord/model.Intents
Intents, gateway_url? : String, shard_id? : Int, shard_count? : Int, identify_queue? : &@gaato/discord/queue.IdentifyQueue
IdentifyQueue, event_filter? : (@gaato/discord/model.EventKind
EventKind) -> Bool, connector? : async (String) -> &GatewayTransport, compress? : Bool, inflater_factory? : () -> &Inflater raise, queue_capacity? : Int, telemetry? : (@gaato/discord/telemetry.TelemetryEvent
TelemetryEvent) -> Unit, sleeper? : async (Int) -> Unit, rand? : @moonbitlang/core/random.Rand
Rand) -> Shard

Spawn a shard into group and return its handle.

Shard::state

source

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

The current lifecycle state of this shard.

ShardEvent

source

pub(all) enum ShardEvent {
  Dispatch(@gaato/discord/model.Event
Event)
  Connected(resumed~ : Bool)
  Disconnected(code~ : Int?, resuming~ : Bool)
  FatallyClosed(code~ : Int)
} derive(@moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
Debug)

Shard lifecycle state.

connect_websocket

source

async fn connect_websocket(url : String) -> &GatewayTransport

Connect to the gateway over WebSocket (the default connector).

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.