🥮 mooncakes.io

gaato/discord/voice does not have a README file

AudioSource

source
pub(open) trait AudioSource {
  async fn next_frame(Self) -> Bytes?
}

A source of pre-encoded 20 ms Opus frames. None marks end of stream.

DaveBackend

source
trait DaveBackend

The private seam between gateway orchestration and the official libdave wrapper. Keeping this package-private lets white-box tests model protocol outcomes without making an alternate crypto provider part of the API.

VoiceTransport

source
pub(open) trait VoiceTransport {
  async fn recv(Self) -> VoiceFrame
  async fn send_text(Self, String) -> Unit
  async fn send_binary(Self, Bytes) -> Unit
  async fn close(Self, code~ : Int) -> Unit
}

The network seam used by VoiceGateway. Tests can provide an in-memory implementation without opening a WebSocket.

VoiceUdp

source
pub(open) trait VoiceUdp {
  async fn recv(Self, FixedArray[Byte]) -> Int
  async fn send(Self, Bytes) -> Unit
  async fn close(Self) -> Unit
}

UDP seam used by voice discovery and media transport.

DaveError

source
pub(all) suberror DaveError {
  DaveInvalid(reason~ : String)
  DaveUnavailable(reason~ : String)
  DaveInternal(reason~ : String)
} derive(Eq, 
Debug)

Errors reported while coordinating Discord's DAVE protocol.

OggOpusError

source
pub(all) suberror OggOpusError {
  InvalidOggPage(reason~ : String)
  InvalidOpusStream(reason~ : String)
} derive(Eq, 
Debug)

Errors raised while parsing Ogg pages and Opus stream headers.

RtpError

source
pub(all) suberror RtpError {
  InvalidRtpPacket(reason~ : String)
} derive(Eq, 
Debug)

Errors raised while validating an RTP packet.

VoiceCryptoError

source
pub(all) suberror VoiceCryptoError {
  NoCompatibleMode(modes~ : Array[String])
  ShimUnavailable(reason~ : String)
  InvalidSecretKey(length~ : Int)
  InvalidEncryptedPacket(reason~ : String)
  AuthenticationFailed(reason~ : String)
  AeadFailed(status~ : Int, reason~ : String)
} derive(Eq, 
Debug)

Errors raised by transport-mode negotiation and packet encryption.

VoiceEnvelopeError

source
pub(all) suberror VoiceEnvelopeError {
  InvalidTextFrame(reason~ : String)
  InvalidBinaryFrame(reason~ : String)
} derive(Eq, 
Debug)

A malformed JSON or binary voice gateway envelope.

VoiceError

source
pub(all) suberror VoiceError {
  MissingIntent(intent~ : String)
  JoinTimeout
  ShimUnavailable(reason~ : String)
  NoCompatibleMode(offered~ : Array[String])
  GatewayClosed(code~ : Int?)
  IpDiscoveryFailed(reason~ : String)
  Disconnected
} derive(
Debug)

Errors surfaced while joining or operating a voice connection.

VoiceTransportClosed

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

Raised when a voice transport is closed or cannot continue.

VoiceUdpError

source
pub(all) suberror VoiceUdpError {
  InvalidDiscoveryPacket(reason~ : String)
  IpDiscoveryFailed(attempts~ : Int, reason~ : String)
} derive(Eq, 
Debug)

Errors raised by voice UDP setup and IP discovery.

DaveAction

source
pub(all) enum DaveAction {
  SendJson(Json)
  SendBinary(op~ : Int, payload~ : Bytes)
  SwitchMediaContext(protocol_version~ : Int)
} derive(Eq, 
Debug)

Side effects requested by the DAVE gateway/MLS orchestration state machine.

DaveCommitOutcome

source
type DaveCommitOutcome derive(Eq, 
Debug)

DaveMachine

source
pub struct DaveMachine {
  // private fields
}

DAVE gateway/MLS orchestration. Networking remains outside this type.

DaveMachine::active_protocol_version

source
fn DaveMachine::active_protocol_version(self : DaveMachine) -> Int

Return the protocol version currently selected for outbound media.

DaveMachine::encrypt_opus_frame

source
fn DaveMachine::encrypt_opus_frame(self : DaveMachine, ssrc~ : UInt, frame : Bytes) -> Bytes raise DaveError

Encrypt one Opus frame. Passthrough is delegated to libdave as well, so the encryptor remains the sole owner of media-transition state.

DaveMachine::handle

source
fn DaveMachine::handle(self : DaveMachine, message : VoiceMessage) -> Array[DaveAction] raise DaveError

Handle one decoded voice-gateway message and return transport actions.

DaveMachine::new

source
fn DaveMachine::new(protocol_version~ : Int, self_user_id~ : String, channel_id~ : UInt64, roster? : Array[String]) -> DaveMachine raise DaveError

Create the production DAVE state machine backed by the official libdave wrapper. protocol_version is the version selected by the voice gateway.

DaveRosterChange

source
type DaveRosterChange derive(Eq, 
Debug)

DaveWelcomeOutcome

source
type DaveWelcomeOutcome derive(Eq, 
Debug)

EncryptionMode

source
pub(all) enum EncryptionMode {
  AeadAes256GcmRtpsize
  AeadXChaCha20Poly1305Rtpsize
} derive(Eq, 
Debug)

Discord voice transport encryption modes supported by this package.

EncryptionMode::negotiate

source
fn EncryptionMode::negotiate(modes : Array[String]) -> EncryptionMode raise VoiceCryptoError

Select the preferred common Discord transport encryption mode.

OggOpusSource

source
pub struct OggOpusSource {
  // private fields
}

In-memory Ogg/Opus source. Opus packets must already represent 20 ms audio frames; this demuxer does not decode or resample them.

OggOpusSource::channels

source
fn OggOpusSource::channels(self : OggOpusSource) -> Int

The channel count declared by the stream's OpusHead header.

OggOpusSource::from_bytes

source
fn OggOpusSource::from_bytes(bytes : Bytes) -> OggOpusSource raise OggOpusError

Parse a complete in-memory Ogg Opus file into an audio source, validating its OpusHead/OpusTags headers.

OggOpusSource::from_reader

source

Open an Ogg/Opus source backed by an asynchronous reader. The constructor consumes and validates the OpusHead and OpusTags packets; audio packets are read lazily by AudioSource::next_frame.

Example

async test {
  let file = @fs.open("voice.ogg")
  defer file.close()
  let source = @voice.OggOpusSource::from_reader(file)
  let audio : &@voice.AudioSource = source
  while audio.next_frame() is Some(frame) {
    play_opus_frame(frame)
  }
}

OggOpusSource::pre_skip

source
fn OggOpusSource::pre_skip(self : OggOpusSource) -> Int

Samples (at 48 kHz) to drop before playback, from the OpusHead header.

OggOpusWriter

source
pub struct OggOpusWriter {
  // private fields
}

Pure in-memory Ogg/Opus muxer. Header pages are available immediately from take_output; audio pages become available as packet or lacing limits are reached, and finish emits the final EOS page.

OggOpusWriter::finish

source
fn OggOpusWriter::finish(self : OggOpusWriter) -> Unit

Flush remaining packets in a final EOS page. Repeated calls are no-ops.

OggOpusWriter::new

source
fn OggOpusWriter::new(channels? : Int, pre_skip? : Int, serial? : UInt, max_packets_per_page? : Int) -> OggOpusWriter

Create an Ogg/Opus muxer and queue its OpusHead and OpusTags pages.

Example

async test {
  let writer = @voice.OggOpusWriter::new(channels=2, pre_skip=312)
  for frame in recorded_opus_frames() {
    writer.write_frame(frame)
  }
  writer.finish()
  let file = @fs.create("recording.ogg")
  defer file.close()
  file.write(writer.take_output())
}

Panics

Panics if channels or pre_skip cannot be represented in an Opus header, or if max_packets_per_page is not positive.

OggOpusWriter::take_output

source
fn OggOpusWriter::take_output(self : OggOpusWriter) -> Bytes

Drain all complete Ogg pages generated so far.

OggOpusWriter::write_frame

source
fn OggOpusWriter::write_frame(self : OggOpusWriter, opus : Bytes, samples? : Int) -> Unit raise OggOpusError

Queue one complete Opus packet and advance the 48 kHz granule position.

OggPacketReader

source
pub struct OggPacketReader {
  // private fields
}

Streaming Ogg packet reassembler. Feed arbitrary chunks with push, then pull complete packets with next_packet.

OggPacketReader::new

source

Create an empty reader; feed it Ogg data with push and drain packets with next_packet.

OggPacketReader::next_packet

source
fn OggPacketReader::next_packet(self : OggPacketReader) -> Bytes? raise OggOpusError

Return the next complete Ogg packet, or None when more input is needed.

OggPacketReader::push

source
fn OggPacketReader::push(self : OggPacketReader, bytes : Bytes) -> Unit

Add bytes to the streaming input without requiring a page boundary.

ReorderBuffer

source
pub struct ReorderBuffer[T] {
  // private fields
}

A small RTP reorder window. The first packet establishes the expected sequence; later gaps are held until hold_ms elapses or eight packets are buffered.

ReorderBuffer::new

source
fn[T] ReorderBuffer::new(hold_ms? : Int) -> ReorderBuffer[T]

Create an empty window that holds packets behind a sequence gap for up to hold_ms milliseconds.

ReorderBuffer::push

source
fn[T] ReorderBuffer::push(self : ReorderBuffer[T], seq~ : Int, arrival_ms~ : Int64, packet : T) -> Array[ReorderOutput[T]]

Insert one RTP packet. Arrival time is supplied by the caller so timeout behavior is deterministic in tests.

ReorderOutput

source
pub(all) enum ReorderOutput[T] {
  Deliver(T)
  Lost(count~ : Int)
} derive(Eq, 
Debug)

Values produced while restoring RTP sequence order.

RtpPacket

source
pub(all) struct RtpPacket {
  sequence : UInt16
  timestamp : UInt
  ssrc : UInt
  header_len : Int
  header : Bytes
  payload : Bytes
} derive(Eq, 
Debug)

A parsed RTP packet with the rtpsize cleartext header separated.

TransportCipher

source
pub struct TransportCipher {
  // private fields
}

Stateful voice transport cipher. The sender counter wraps modulo 2^32; receivers reconstruct nonces from the packet suffix and need no counter.

TransportCipher::new

source
fn TransportCipher::new(mode : EncryptionMode, secret_key : Bytes) -> TransportCipher raise VoiceCryptoError

Create a cipher for mode from the 32-byte session secret_key delivered by the voice gateway.

TransportCipher::open

source
fn TransportCipher::open(self : TransportCipher, packet : Bytes, header_len~ : Int) -> Bytes raise VoiceCryptoError

Authenticate and decrypt a packet, returning header || plaintext.

TransportCipher::seal

source
fn TransportCipher::seal(self : TransportCipher, header~ : Bytes, plaintext : Bytes) -> Bytes raise VoiceCryptoError

Encrypt an RTP payload and append the four-byte nonce suffix.

VoiceConnection

source
pub struct VoiceConnection {
  // private fields
}

High-level owner of voice gateway, UDP media, DAVE, sender, and receiver tasks. All background work is attached to the task group passed to start.

VoiceConnection::disconnect

source
async fn VoiceConnection::disconnect(self : VoiceConnection) -> Unit

Leave the Discord voice state and tear down media transports. Repeated calls are harmless.

VoiceConnection::latency_ms

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

Latest voice gateway heartbeat round-trip in milliseconds, if measured.

VoiceConnection::next_event

source
async fn VoiceConnection::next_event(self : VoiceConnection) -> VoiceEvent

Pull the next received media or voice membership event.

VoiceConnection::play

source
async fn VoiceConnection::play(self : VoiceConnection, source : &AudioSource) -> Unit

Replace the current source. The old sender is asked to stop and flush its five silence frames before the latest source begins.

VoiceConnection::set_speaking

source
async fn VoiceConnection::set_speaking(self : VoiceConnection, flags : Int) -> Unit

Send a Speaking (opcode 5) frame with the given flag bits. The playback loop manages this automatically; call it directly only for custom speaking indicators.

VoiceConnection::start

source
fn[X] VoiceConnection::start(group : 
TaskGroup[X], credentials : VoiceCredentials, user_id~ : String, channel_id~ : UInt64, leave~ : async () -> Unit, rejoin~ : async () -> VoiceCredentials, connector? : async (String) -> &VoiceTransport, udp_opener? : async (String, Int) -> &VoiceUdp, receive? : Bool, telemetry? : (VoiceTelemetry) -> Unit, sleeper? : async (Int) -> Unit, rand? : 
Rand) -> VoiceConnection

Start a voice connection and attach all of its tasks to group.

VoiceConnection::state

source

The current lifecycle state of this voice connection.

VoiceConnection::stop

source
async fn VoiceConnection::stop(self : VoiceConnection) -> Unit

Stop the active source; the send loop emits five silence frames and clears the speaking flag.

VoiceConnection::subscribe

source
fn VoiceConnection::subscribe(self : VoiceConnection, user_id~ : String, end_after_silence_ms? : Int?) -> VoiceReceiveStream

Subscribe to received Opus packets for one Discord user. With end_after_silence_ms, the first frame waits indefinitely and subsequent reads end the stream after the requested silence interval.

Example

async test {
  // Echo one speaker until they are silent for one second.
  connection.play(
    connection.subscribe(user_id="1234", end_after_silence_ms=Some(1000)),
  )

  // Or record the same stream into an Ogg/Opus file.
  let stream = connection.subscribe(user_id="1234")
  let audio : &@voice.AudioSource = stream
  let writer = @voice.OggOpusWriter::new(channels=2)
  while audio.next_frame() is Some(frame) {
    writer.write_frame(frame)
  }
  writer.finish()
}

VoiceConnection::wait_ready

source
async fn VoiceConnection::wait_ready(self : VoiceConnection, timeout_ms? : Int) -> Unit raise VoiceError

Wait until the current connection handshake reaches Ready.

VoiceConnectionState

source
pub(all) enum VoiceConnectionState {
  Connecting
  Ready
  Reconnecting
  Rejoining
  Closed(code~ : Int?)
} derive(Eq, 
Debug)

Public voice connection lifecycle.

VoiceCredentials

source
pub(all) struct VoiceCredentials {
  server_id : String
  session_id : String
  token : String
  endpoint : String
} derive(Eq, 
Debug)

Credentials supplied by the main Discord gateway voice-state handshake.

VoiceEvent

source
pub(all) enum VoiceEvent {
  OpusReceived(user_id~ : String?, ssrc~ : UInt, sequence~ : Int, timestamp~ : UInt, opus~ : Bytes)
  PacketsLost(user_id~ : String?, ssrc~ : UInt, count~ : Int)
  SpeakingChanged(user_id~ : String, ssrc~ : UInt, flags~ : Int)
  UserConnected(user_id~ : String)
  UserDisconnected(user_id~ : String)
  ConnectionReady
  ConnectionResumed
} derive(Eq, 
Debug)

Events emitted by a live voice connection.

VoiceFrame

source
pub(all) enum VoiceFrame {
  Text(String)
  Binary(Bytes)
} derive(Eq, 
Debug)

A complete WebSocket message received from the voice gateway.

VoiceGateway

source
pub struct VoiceGateway {
  // private fields
}

Voice gateway v8 driver. The caller-owned task group controls its lifetime; cancelling the group tears down connection and heartbeat tasks.

VoiceGateway::close

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

Request graceful shutdown of the voice WebSocket.

VoiceGateway::latency_ms

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

Latest matched heartbeat round-trip time in milliseconds.

VoiceGateway::next

source
async fn VoiceGateway::next(self : VoiceGateway) -> VoiceGatewayEvent

Pull the next voice gateway event. Blocks until one is available.

VoiceGateway::send_binary

source
async fn VoiceGateway::send_binary(self : VoiceGateway, op~ : Int, payload : Bytes) -> Unit

Send a client-to-server DAVE binary envelope.

VoiceGateway::send_json

source
async fn VoiceGateway::send_json(self : VoiceGateway, payload : Json) -> Unit

Send an arbitrary JSON voice gateway envelope.

VoiceGateway::start

source
fn[X] VoiceGateway::start(group : 
TaskGroup[X], server_id~ : String, user_id~ : String, session_id~ : String, token~ : String, endpoint~ : String, max_dave_protocol_version? : UInt16, select_protocol~ : async (UInt, String, Int, Array[String]) -> (String, Int, String), connector? : async (String) -> &VoiceTransport, queue_capacity? : Int, telemetry? : (VoiceGatewayEvent) -> Unit, sleeper? : async (Int) -> Unit, rand? : 
Rand) -> VoiceGateway

Spawn a voice gateway driver into group and return its handle. max_dave_protocol_version is advertised in Identify. It defaults to zero so low-level callers do not negotiate DAVE without an active backend; pass a supported maximum explicitly to enable it.

VoiceGateway::state

source

Current voice gateway lifecycle state.

VoiceGatewayEvent

source
pub(all) enum VoiceGatewayEvent {
  ReadyReceived
  SessionEstablished(mode~ : String, secret_key~ : Bytes, dave_protocol_version~ : Int)
  Message(VoiceMessage)
  Connected(resumed~ : Bool)
  Disconnected(code~ : Int?, resuming~ : Bool)
  ConnectFailed(reason~ : String)
  NeedsRejoin(code~ : Int?)
  FatallyClosed(code~ : Int)
} derive(Eq, 
Debug)

Events surfaced by VoiceGateway::next.

VoiceGatewayState

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

Voice gateway lifecycle state.

VoiceMessage

source
pub(all) enum VoiceMessage {
  Ready(ssrc~ : UInt, ip~ : String, port~ : Int, modes~ : Array[String])
  Hello(heartbeat_interval~ : Int)
  SessionDescription(mode~ : String, secret_key~ : Bytes, dave_protocol_version~ : Int)
  HeartbeatAck(nonce~ : Int64)
  Speaking(ssrc~ : UInt, user_id~ : String, flags~ : Int)
  ClientsConnect(user_ids~ : Array[String])
  ClientDisconnect(user_id~ : String)
  Resumed
  DavePrepareTransition(transition_id~ : Int, protocol_version~ : Int)
  DaveExecuteTransition(transition_id~ : Int)
  DavePrepareEpoch(epoch~ : Int, protocol_version~ : Int)
  DaveMlsExternalSender(payload~ : Bytes)
  DaveMlsProposals(payload~ : Bytes)
  DaveMlsAnnounceCommitTransition(transition_id~ : Int, commit~ : Bytes)
  DaveMlsWelcome(transition_id~ : Int, welcome~ : Bytes)
  Unknown(op~ : Int)
} derive(Eq, 
Debug)

A decoded voice gateway v8 message.

VoiceReceiveStream

source
pub struct VoiceReceiveStream {
  // private fields
}

A per-user stream of received Opus packets. Streams are created with VoiceConnection::subscribe and can be passed directly to play or read through the AudioSource trait.

VoiceReceiveStream::close

source
fn VoiceReceiveStream::close(self : VoiceReceiveStream) -> Unit

End this stream and unregister it from its connection. Repeated calls are harmless, and a blocked next_frame wakes with None.

VoiceReconnectPolicy

source
pub(all) enum VoiceReconnectPolicy {
  Resume
  Rejoin
  Fatal
} derive(Eq, 
Debug)

Action after a voice WebSocket close: resume the session, rejoin from scratch, or give up because reconnecting cannot succeed.

VoiceTelemetry

source
pub(all) enum VoiceTelemetry {
  GatewayEvent(VoiceGatewayEvent)
  DaveMediaContextActivated(protocol_version~ : Int)
  DaveBinaryControlSent(opcode~ : Int, payload_bytes~ : Int)
  PacketDropped(reason~ : String)
  DaveEncryptDropped(reason~ : String)
  DaveDecryptDropped(user_id~ : String?, ssrc~ : UInt, count~ : Int, reason~ : String)
} derive(Eq, 
Debug)

Non-fatal diagnostics from the connection's gateway and media paths.

SILENCE_FRAME

source
let SILENCE_FRAME : Bytes

Discord's canonical Opus silence frame.

build_ip_discovery_request

source
fn build_ip_discovery_request(ssrc : UInt) -> Bytes

Build Discord's 74-byte voice IP discovery request.

build_rtp_header

source
fn build_rtp_header(sequence~ : UInt16, timestamp~ : UInt, ssrc~ : UInt) -> Bytes

Build Discord's RTP header for a 20 ms Opus frame.

connect_voice_websocket

source
async fn connect_voice_websocket(url : String) -> &VoiceTransport

Connect to a voice-gateway WebSocket. The caller supplies the complete v8 URL, normally wss://<endpoint>?v=8.

discover_external_address

source
async fn discover_external_address(udp : &VoiceUdp, ssrc : UInt, retries? : Int, timeout_ms? : Int) -> (String, Int)

Run voice IP discovery, retrying only receive timeouts.

encode_binary_client_frame

source
fn encode_binary_client_frame(op : Int, payload : Bytes) -> Bytes

Prefix a client-to-server binary DAVE payload with its one-byte opcode.

encode_heartbeat

source
fn encode_heartbeat(t~ : Int64, seq_ack~ : Int) -> Json

Voice gateway Heartbeat (opcode 3) payload carrying the nonce and last acknowledged server sequence.

encode_identify

source
fn encode_identify(server_id~ : String, user_id~ : String, session_id~ : String, token~ : String, max_dave_protocol_version? : UInt16) -> Json

Voice gateway Identify (opcode 0) payload, advertising the selected maximum DAVE protocol version. It defaults to zero so low-level callers do not advertise DAVE without an active backend; pass a supported maximum explicitly to enable negotiation.

encode_invalid_commit_welcome

source
fn encode_invalid_commit_welcome(transition_id~ : Int) -> Json

DAVE Invalid Commit/Welcome (opcode 31) payload asking the server to reset the group after a rejected MLS message.

encode_resume

source
fn encode_resume(server_id~ : String, session_id~ : String, token~ : String, seq_ack~ : Int) -> Json

Voice gateway Resume (opcode 7) payload for reattaching to an existing session.

encode_select_protocol

source
fn encode_select_protocol(address~ : String, port~ : Int, mode~ : String) -> Json

Voice gateway Select Protocol (opcode 1) payload announcing the discovered UDP address and chosen encryption mode.

encode_speaking

source
fn encode_speaking(ssrc~ : UInt, flags~ : Int, delay? : Int) -> Json

Voice gateway Speaking (opcode 5) payload for the sender's SSRC.

encode_transition_ready

source
fn encode_transition_ready(transition_id~ : Int) -> Json

DAVE Transition Ready (opcode 23) payload acknowledging an announced protocol transition.

open_voice_udp

source
async fn open_voice_udp(ip : String, port : Int) -> &VoiceUdp

Open a connected UDP socket for a Discord voice server.

parse_binary_frame

source
fn parse_binary_frame(bytes : Bytes) -> (VoiceMessage, Int?) raise VoiceEnvelopeError

Decode a server-to-client binary DAVE frame. Its first two bytes are the big-endian v8 sequence number and the third byte is the opcode.

parse_ip_discovery_response

source
fn parse_ip_discovery_response(bytes : Bytes, expected_ssrc~ : UInt) -> (String, Int) raise VoiceUdpError

Parse Discord's 74-byte voice IP discovery response.

parse_rtp_packet

source
fn parse_rtp_packet(bytes : Bytes) -> RtpPacket raise RtpError

Parse an RTP v2 packet and retain extension data in payload.

parse_text_frame

source
fn parse_text_frame(text : String) -> (VoiceMessage, Int?) raise VoiceEnvelopeError

Decode a JSON voice gateway message and return its optional top-level buffered-resume sequence number.

rtpsize_header_len

source
fn rtpsize_header_len(bytes : Bytes) -> Int

Return the cleartext RTP header length used as AEAD associated data.

run_send_loop

source
async fn run_send_loop(source : &AudioSource, cipher : TransportCipher, udp : &VoiceUdp, gateway : VoiceGateway, ssrc~ : UInt, initial_sequence? : UInt16, initial_timestamp? : UInt, stop? : 
Ref[Bool], frame_duration_ms? : Int, dave? : DaveMachine, on_dave_error? : (String) -> Unit) -> Unit

Internal paced sender used by the M4 connection driver.

shim_available

source
fn shim_available() -> Bool

Whether a compatible transport-only ABI v3 voice shim is available.

shim_unavailable_reason

source
fn shim_unavailable_reason() -> String?

Explain why the native voice shim could not be loaded.

voice_on_close

source
fn voice_on_close(code : Int?, has_session : Bool) -> VoiceReconnectPolicy

Classify a voice WebSocket close code. A resumable transport failure still requires a fresh join when no established voice session exists.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io