@sonata-sdk/voice 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sonata SDK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+<div align="center">
+  <h1>🎙️ @sonata-sdk/voice</h1>
+  <p><strong>Discord voice connection library</strong><br />WebSocket gateway · UDP · RTP · Encryption · DAVE/MLS</p>
+  <p>
+    <img src="https://img.shields.io/npm/v/@sonata-sdk/voice?color=blueviolet" alt="Version" />
+    <img src="https://img.shields.io/npm/l/@sonata-sdk/voice?color=blue" alt="License" />
+    <img src="https://img.shields.io/badge/node-20%2B-339933?logo=node.js" alt="Node" />
+  </p>
+  <p>
+    <a href="#-install">Install</a> •
+    <a href="#-usage">Usage</a> •
+    <a href="#-api">API</a> •
+    <a href="#-related">Related</a>
+  </p>
+  <br />
+  <hr />
+</div>
+
+> Pure TypeScript Discord voice library. Connects to Discord's voice gateway, handles UDP audio, RTP packetization, encryption, and DAVE/MLS E2EE. No native dependencies, no C++.
+
+---
+
+## 📥 Install
+
+```bash
+npm install @sonata-sdk/voice
+```
+
+### Optional (for DAVE/E2EE)
+
+```bash
+npm install @snazzah/davey libsodium-wrappers
+```
+
+---
+
+## 🔌 Subpath imports
+
+```ts
+import { joinVoiceChannel } from '@sonata-sdk/voice'
+import { VoiceGateway } from '@sonata-sdk/voice/gateway'
+import { UdpSocket } from '@sonata-sdk/voice/udp'
+import { AudioEncryption } from '@sonata-sdk/voice/encryption'
+import type { VoiceConnection, EncryptionMode } from '@sonata-sdk/voice/types'
+```
+
+---
+
+## 🚀 Usage
+
+```ts
+import { joinVoiceChannel } from '@sonata-sdk/voice'
+
+const connection = joinVoiceChannel({
+  guildId: '123',
+  userId: '456',
+  channelId: '789',
+  encryption: 'aead_aes256_gcm_rtpsize',
+})
+
+connection.voiceStateUpdate({ sessionId: 'abc' })
+connection.voiceServerUpdate({ token: 'xyz', endpoint: 'gateway.discord.audio' })
+
+connection.on('stateChange', (old, next) => {
+  if (next.status === 'connected') {
+    // Send audio every 20ms
+    setInterval(() => {
+      connection.sendAudioFrame(opusFrame)
+    }, 20)
+  }
+})
+
+connection.setSpeaking(1)
+```
+
+---
+
+## 📖 API
+
+### `joinVoiceChannel(options)`
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `guildId` | `string` | Discord guild ID |
+| `userId` | `string` | Bot user ID |
+| `channelId` | `string` | Voice channel ID |
+| `encryption` | `string \| null` | Encryption mode or null for auto |
+
+Returns a `VoiceConnection`.
+
+### `VoiceConnection`
+
+| Property | Description |
+|----------|-------------|
+| `state` | `{ status, reason, code }` — connection state |
+| `playerState` | `{ status, reason }` — playback state |
+| `ping` | Voice websocket latency |
+| `statistics` | `{ packetsSent, packetsLost, packetsExpected }` |
+| `udpInfo` | `{ ssrc, ip, port, secretKey }` or `null` |
+
+| Method | Description |
+|--------|-------------|
+| `voiceStateUpdate(obj)` | Feed Discord voice state |
+| `voiceServerUpdate(obj)` | Feed Discord voice server |
+| `sendAudioFrame(frame)` | Send an Opus frame |
+| `setSpeaking(value)` | Set speaking flag (1 = speaking) |
+| `destroy()` | Clean up connection |
+| `on(event, fn)` | Listen to events |
+| `removeAllListeners(event?)` | Remove listeners |
+
+### Events
+
+| Event | Payload | Description |
+|-------|---------|-------------|
+| `stateChange` | `(old, next)` | Connection state changed |
+| `playerStateChange` | `(old, next)` | Player state changed |
+| `error` | `(Error)` | An error occurred |
+| `ready` | `()` | Voice connection established |
+
+---
+
+## 🔒 Encryption Modes
+
+| Mode | Algorithm |
+|------|-----------|
+| `aead_aes256_gcm_rtpsize` | AES-256-GCM |
+| `aead_xchacha20_poly1305_rtpsize` | XChaCha20-Poly1305 |
+| `xsalsa20_poly1305_lite_rtpsize` | XSalsa20-Poly1305 (lite) |
+| `xsalsa20_poly1305_suffix_rtpsize` | XSalsa20-Poly1305 (suffix) |
+| `normal` | XSalsa20-Poly1305 (legacy) |
+
+---
+
+## 📦 Related
+
+- [**Sonata**](https://github.com/sonata-sdk/sonata) — Lavalink-compatible audio server
+- [**@sonata-sdk/plugin-sdk**](https://github.com/sonata-sdk/sonata-sdk-packages/tree/main/packages/plugin-sdk) — SDK for Sonata plugins
+- [**sonata-sdk-packages**](https://github.com/sonata-sdk/sonata-sdk-packages) — Monorepo
+
+---
+
+<div align="center">
+  <sub>MIT License · Built with ❤️</sub>
+</div>

package/dist/connection.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'node:events';
+import type { JoinVoiceOptions, ConnectionState, PlayerState, UdpInfo, ConnectionStatistics, VoiceConnection as IVoiceConnection } from './types.js';
+export declare class VoiceConnection extends EventEmitter implements IVoiceConnection {
+    #private;
+    guildId: string;
+    userId: string;
+    channelId: string;
+    encryption: string | null;
+    state: ConnectionState;
+    playerState: PlayerState;
+    ping: number;
+    statistics: ConnectionStatistics;
+    udpInfo: UdpInfo | null;
+    constructor(opts: JoinVoiceOptions);
+    voiceStateUpdate(obj: {
+        session_id?: string;
+        sessionId?: string;
+    }): void;
+    voiceServerUpdate(obj: {
+        token: string;
+        endpoint: string;
+        channel_id?: string;
+        channelId?: string;
+    }): void;
+    sendAudioFrame(frame: Buffer): void;
+    setSpeaking(value: number): void;
+    destroy(): void;
+}
+export declare function joinVoiceChannel(options: JoinVoiceOptions): VoiceConnection;

package/dist/connection.js

@@ -0,0 +1,107 @@
+import { EventEmitter } from 'node:events';
+import { VoiceGateway } from './gateway.js';
+import { UdpSocket } from './udp.js';
+import { AudioEncryption } from './encryption.js';
+export class VoiceConnection extends EventEmitter {
+    guildId;
+    userId;
+    channelId;
+    encryption;
+    state = { status: 'connecting', reason: null, code: null };
+    playerState = { status: 'stopped', reason: null };
+    ping = 0;
+    statistics = { packetsSent: 0, packetsLost: 0, packetsExpected: 0 };
+    udpInfo = null;
+    #gateway;
+    #udp;
+    #encryption = null;
+    #sessionId = '';
+    #token = '';
+    #endpoint = '';
+    #destroyed = false;
+    constructor(opts) {
+        super();
+        this.guildId = opts.guildId;
+        this.userId = opts.userId;
+        this.channelId = opts.channelId;
+        this.encryption = opts.encryption ?? null;
+        this.#gateway = new VoiceGateway(opts.guildId, opts.userId);
+        this.#udp = new UdpSocket();
+        this.#setupListeners();
+    }
+    #setupListeners() {
+        this.#gateway.on('ready', (payload) => {
+            this.#udp.connect(payload.ssrc, payload.ip, payload.port).then(() => {
+                this.#gateway.sendSelectProtocol(this.#udp.ip, this.#udp.port, this.encryption ?? 'xsalsa20_poly1305_lite_rtpsize');
+            }).catch((err) => this.emit('error', err));
+        });
+        this.#gateway.on('sessionDescription', (payload) => {
+            this.#udp.setSecretKey(payload.secret_key);
+            this.udpInfo = {
+                ssrc: this.#gateway.ssrc,
+                ip: this.#gateway.ip,
+                port: this.#gateway.port,
+                secretKey: payload.secret_key,
+            };
+            this.#encryption = new AudioEncryption(payload.mode, payload.secret_key, this.#gateway.ssrc);
+            this.state = { status: 'connected', reason: null, code: null };
+            this.emit('stateChange', { status: 'connecting' }, this.state);
+            this.emit('ready');
+        });
+        this.#gateway.on('close', (code, reason) => {
+            this.state = { status: 'disconnected', reason, code };
+            this.emit('stateChange', { status: 'connected' }, this.state);
+        });
+        this.#gateway.on('error', (err) => this.emit('error', err));
+        this.#gateway.on('heartbeatAck', (d) => {
+            if (d.t)
+                this.ping = Date.now() - d.t;
+        });
+        this.#udp.on('error', (err) => this.emit('error', err));
+    }
+    voiceStateUpdate(obj) {
+        this.#sessionId = obj.sessionId ?? obj.session_id ?? this.#sessionId;
+        this.#gateway.voiceStateUpdate(this.#sessionId);
+    }
+    voiceServerUpdate(obj) {
+        this.#token = obj.token;
+        this.#endpoint = obj.endpoint;
+        this.#gateway.voiceServerUpdate(obj.token, obj.endpoint, obj.channelId ?? obj.channel_id);
+        this.#gateway.connect();
+    }
+    sendAudioFrame(frame) {
+        if (this.#destroyed)
+            return;
+        if (this.#encryption) {
+            const encrypted = this.#encryption.encrypt(frame);
+            if (!encrypted)
+                return; // silence frame
+            this.#udp.send(encrypted);
+        }
+        else {
+            this.#udp.send(frame);
+        }
+        this.statistics.packetsSent++;
+        this.statistics.packetsExpected++;
+    }
+    setSpeaking(value) {
+        this.#gateway.setSpeaking(value);
+        if (value > 0) {
+            this.playerState = { status: 'playing', reason: null };
+        }
+        else {
+            this.playerState = { status: 'stopped', reason: null };
+        }
+    }
+    destroy() {
+        this.#destroyed = true;
+        this.state = { status: 'destroyed', reason: 'destroyed', code: null };
+        this.#gateway.close();
+        this.#udp.close();
+        this.emit('stateChange', { status: 'connected' }, this.state);
+        this.removeAllListeners();
+    }
+}
+export function joinVoiceChannel(options) {
+    return new VoiceConnection(options);
+}

package/dist/encryption.d.ts

@@ -0,0 +1,16 @@
+import type { EncryptionMode } from './types.js';
+declare const SILENCE_FRAME: Buffer<ArrayBuffer>;
+export interface EncryptedPacket {
+    header: Buffer;
+    nonce: Buffer;
+    encrypted: Buffer;
+}
+export declare class AudioEncryption {
+    #private;
+    constructor(mode: EncryptionMode, secretKey: Buffer, ssrc: number);
+    get sequence(): number;
+    get timestamp(): number;
+    get ssrc(): number;
+    encrypt(frame: Buffer): Buffer | null;
+}
+export { SILENCE_FRAME };

package/dist/encryption.js

@@ -0,0 +1,97 @@
+import { createCipheriv } from 'node:crypto';
+import nacl from 'tweetnacl';
+const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);
+const VERSION = 0x80;
+const TYPE = 0x78;
+export class AudioEncryption {
+    #mode;
+    #secretKey;
+    #sequence = 0;
+    #timestamp = 0;
+    #ssrc;
+    #nonceBuffer;
+    constructor(mode, secretKey, ssrc) {
+        this.#mode = mode;
+        this.#secretKey = secretKey;
+        this.#ssrc = ssrc;
+        this.#nonceBuffer = Buffer.alloc(mode === 'aead_xchacha20_poly1305_rtpsize' ? 24 : 12);
+    }
+    get sequence() { return this.#sequence; }
+    get timestamp() { return this.#timestamp; }
+    get ssrc() { return this.#ssrc; }
+    encrypt(frame) {
+        if (frame.equals(SILENCE_FRAME))
+            return null;
+        const header = this.#buildHeader();
+        const seq = this.#sequence;
+        const ts = this.#timestamp;
+        this.#sequence = (this.#sequence + 1) & 0xffff;
+        this.#timestamp = (this.#timestamp + 960) >>> 0;
+        const nonce = this.#makeNonce(seq);
+        let encrypted;
+        switch (this.#mode) {
+            case 'aead_aes256_gcm_rtpsize': {
+                encrypted = this.#encryptAes256Gcm(header, frame, nonce);
+                break;
+            }
+            case 'aead_xchacha20_poly1305_rtpsize': {
+                encrypted = this.#encryptXChaCha20(header, frame, nonce);
+                break;
+            }
+            default: {
+                encrypted = this.#encryptXsalsa20(header, frame, nonce);
+                break;
+            }
+        }
+        return Buffer.concat([header, encrypted, nonce.subarray(0, this.#nonceLen())]);
+    }
+    #nonceLen() {
+        return this.#mode === 'aead_aes256_gcm_rtpsize' ? 4
+            : this.#mode === 'aead_xchacha20_poly1305_rtpsize' ? 24
+                : 4;
+    }
+    #buildHeader() {
+        const h = Buffer.alloc(12);
+        h[0] = VERSION;
+        h[1] = TYPE;
+        h.writeUInt16BE(this.#sequence, 2);
+        h.writeUInt32BE(this.#timestamp, 4);
+        h.writeUInt32BE(this.#ssrc, 8);
+        return h;
+    }
+    #makeNonce(seq) {
+        const nonce = Buffer.alloc(this.#nonceBuffer.length);
+        if (this.#mode === 'aead_xchacha20_poly1305_rtpsize') {
+            nonce.writeUInt32BE(seq, 0);
+            this.#nonceBuffer.copy(nonce, 4, 0, 20);
+        }
+        else {
+            nonce.writeUInt32BE(seq, 0);
+        }
+        return nonce;
+    }
+    #encryptAes256Gcm(header, frame, nonce) {
+        const cipher = createCipheriv('aes-256-gcm', this.#secretKey, nonce, { authTagLength: 16 });
+        cipher.setAAD(header);
+        const enc = cipher.update(frame);
+        cipher.final();
+        return Buffer.concat([enc, cipher.getAuthTag()]);
+    }
+    #encryptXChaCha20(header, frame, nonce) {
+        try {
+            const sodium = require('libsodium-wrappers');
+            const enc = sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(frame, header, null, nonce, this.#secretKey);
+            return Buffer.from(enc);
+        }
+        catch {
+            return this.#encryptXsalsa20(header, frame, nonce);
+        }
+    }
+    #encryptXsalsa20(header, frame, nonce) {
+        const fullNonce = Buffer.alloc(24);
+        nonce.copy(fullNonce);
+        const enc = nacl.secretbox(frame, fullNonce, this.#secretKey);
+        return Buffer.from(enc);
+    }
+}
+export { SILENCE_FRAME };

package/dist/gateway.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from 'node:events';
+export interface VoiceServerPayload {
+    token: string;
+    endpoint: string;
+    channel_id?: string;
+    channelId?: string;
+}
+export interface ReadyPayload {
+    ssrc: number;
+    ip: string;
+    port: number;
+    modes: string[];
+}
+export interface SessionDescriptionPayload {
+    mode: string;
+    secret_key: number[];
+    dave_protocol_version?: number;
+}
+export declare class VoiceGateway extends EventEmitter {
+    #private;
+    get connected(): boolean;
+    get ssrc(): number;
+    get ip(): string;
+    get port(): number;
+    get modes(): string[];
+    get secretKey(): Buffer<ArrayBufferLike> | null;
+    get daveProtocolVersion(): number;
+    constructor(guildId: string, userId: string);
+    voiceStateUpdate(sessionId: string): void;
+    voiceServerUpdate(token: string, endpoint: string, channelId?: string): void;
+    connect(): void;
+    sendBinary(data: Buffer): void;
+    sendSelectProtocol(address: string, port: number, mode: string): void;
+    setSpeaking(value: number, delay?: number): void;
+    close(): void;
+}

package/dist/gateway.js

@@ -0,0 +1,153 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'node:events';
+const DISCORD_VOICE_VERSION = 8;
+const DISCORD_VOICE_URL_TEMPLATE = 'wss://{endpoint}/?v={v}';
+export class VoiceGateway extends EventEmitter {
+    #ws = null;
+    #guildId;
+    #userId;
+    #sessionId = '';
+    #token = '';
+    #endpoint = '';
+    #channelId = '';
+    #heartbeatInterval = 0;
+    #heartbeatTimer = null;
+    #ssrc = 0;
+    #ip = '';
+    #port = 0;
+    #modes = [];
+    #secretKey = null;
+    #connected = false;
+    #daveProtocolVersion = 0;
+    get connected() { return this.#connected; }
+    get ssrc() { return this.#ssrc; }
+    get ip() { return this.#ip; }
+    get port() { return this.#port; }
+    get modes() { return this.#modes; }
+    get secretKey() { return this.#secretKey; }
+    get daveProtocolVersion() { return this.#daveProtocolVersion; }
+    constructor(guildId, userId) {
+        super();
+        this.#guildId = guildId;
+        this.#userId = userId;
+    }
+    voiceStateUpdate(sessionId) {
+        this.#sessionId = sessionId;
+    }
+    voiceServerUpdate(token, endpoint, channelId) {
+        this.#token = token;
+        this.#endpoint = endpoint.replace(/^wss:\/\//, '').replace(/\/\?v=\d+$/, '');
+        if (channelId)
+            this.#channelId = channelId;
+    }
+    connect() {
+        const url = DISCORD_VOICE_URL_TEMPLATE
+            .replace('{endpoint}', this.#endpoint)
+            .replace('{v}', String(DISCORD_VOICE_VERSION));
+        this.#ws = new WebSocket(url);
+        this.#ws.on('open', () => this.#onOpen());
+        this.#ws.on('message', (data) => this.#onMessage(data));
+        this.#ws.on('close', (code, reason) => this.#onClose(code, reason));
+        this.#ws.on('error', (err) => this.emit('error', err));
+    }
+    #onOpen() {
+        this.#sendOp(0, {
+            server_id: this.#guildId,
+            user_id: this.#userId,
+            session_id: this.#sessionId,
+            token: this.#token,
+        });
+    }
+    #onMessage(data) {
+        try {
+            const json = JSON.parse(data.toString());
+            this.#handleOp(json.op, json.d);
+        }
+        catch {
+            // binary op (DAVE)
+            if (data.length > 0) {
+                this.emit('binary', data);
+            }
+        }
+    }
+    #handleOp(op, d) {
+        switch (op) {
+            case 2: { // Ready
+                const payload = d;
+                this.#ssrc = payload.ssrc;
+                this.#ip = payload.ip;
+                this.#port = payload.port;
+                this.#modes = payload.modes;
+                this.emit('ready', payload);
+                break;
+            }
+            case 4: { // Session Description
+                const payload = d;
+                this.#secretKey = Buffer.from(payload.secret_key);
+                this.#daveProtocolVersion = payload.dave_protocol_version ?? 0;
+                this.#connected = true;
+                this.emit('sessionDescription', payload);
+                break;
+            }
+            case 5: { // Speaking
+                this.emit('speaking', d);
+                break;
+            }
+            case 6: { // Heartbeat ACK
+                this.emit('heartbeatAck', d);
+                break;
+            }
+            case 8: { // Hello
+                this.#heartbeatInterval = d.heartbeat_interval;
+                this.#startHeartbeat();
+                break;
+            }
+            case 9: { // Resumed
+                this.emit('resumed');
+                break;
+            }
+        }
+    }
+    #onClose(code, reason) {
+        this.#connected = false;
+        this.#stopHeartbeat();
+        this.emit('close', code, reason?.toString());
+    }
+    #startHeartbeat() {
+        let seq = 0;
+        this.#heartbeatTimer = setInterval(() => {
+            this.#sendOp(3, { t: Date.now(), seq_ack: seq });
+        }, this.#heartbeatInterval);
+    }
+    #stopHeartbeat() {
+        if (this.#heartbeatTimer)
+            clearInterval(this.#heartbeatTimer);
+    }
+    #sendOp(op, data) {
+        if (this.#ws?.readyState === WebSocket.OPEN) {
+            this.#ws.send(JSON.stringify({ op, d: data }));
+        }
+    }
+    sendBinary(data) {
+        if (this.#ws?.readyState === WebSocket.OPEN) {
+            this.#ws.send(data);
+        }
+    }
+    sendSelectProtocol(address, port, mode) {
+        this.#sendOp(1, {
+            protocol: 'udp',
+            data: { address, port, mode },
+        });
+    }
+    setSpeaking(value, delay = 0) {
+        this.#sendOp(5, { speaking: value, delay, ssrc: this.#ssrc });
+    }
+    close() {
+        this.#connected = false;
+        this.#stopHeartbeat();
+        if (this.#ws) {
+            this.#ws.close();
+            this.#ws = null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { VoiceConnection, joinVoiceChannel } from './connection.js';
+export { VoiceGateway } from './gateway.js';
+export { UdpSocket } from './udp.js';
+export { AudioEncryption, SILENCE_FRAME } from './encryption.js';
+export type { VoiceConnectOptions, ConnectionState, PlayerState, UdpInfo, ConnectionStatistics, VoiceConnection as IVoiceConnection, JoinVoiceOptions, EncryptionMode, } from './types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { VoiceConnection, joinVoiceChannel } from './connection.js';
+export { VoiceGateway } from './gateway.js';
+export { UdpSocket } from './udp.js';
+export { AudioEncryption, SILENCE_FRAME } from './encryption.js';

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+export interface VoiceConnectOptions {
+    guildId: string;
+    userId: string;
+    sessionId: string;
+    token: string;
+    endpoint: string;
+    channelId: string;
+}
+export interface ConnectionState {
+    status: 'connecting' | 'connected' | 'disconnected' | 'destroyed';
+    reason: string | null;
+    code: number | null;
+}
+export interface PlayerState {
+    status: 'playing' | 'paused' | 'stopped';
+    reason: string | null;
+}
+export interface UdpInfo {
+    ssrc: number;
+    ip: string;
+    port: number;
+    secretKey: Buffer | null;
+}
+export interface ConnectionStatistics {
+    packetsSent: number;
+    packetsLost: number;
+    packetsExpected: number;
+}
+export interface VoiceConnection {
+    guildId: string;
+    userId: string;
+    channelId: string;
+    encryption: string | null;
+    state: ConnectionState;
+    playerState: PlayerState;
+    ping: number;
+    statistics: ConnectionStatistics;
+    udpInfo: UdpInfo | null;
+    voiceStateUpdate(obj: {
+        session_id?: string;
+        sessionId?: string;
+    }): void;
+    voiceServerUpdate(obj: {
+        token: string;
+        endpoint: string;
+        channel_id?: string;
+        channelId?: string;
+    }): void;
+    sendAudioFrame(frame: Buffer): void;
+    setSpeaking(value: number): void;
+    destroy(): void;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string | symbol): this;
+}
+export interface JoinVoiceOptions {
+    guildId: string;
+    userId: string;
+    channelId: string;
+    encryption?: string | null;
+}
+export type EncryptionMode = 'aead_aes256_gcm_rtpsize' | 'aead_xchacha20_poly1305_rtpsize' | 'xsalsa20_poly1305_lite_rtpsize' | 'xsalsa20_poly1305_suffix_rtpsize' | 'normal';

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/udp.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'node:events';
+export declare class UdpSocket extends EventEmitter {
+    #private;
+    get connected(): boolean;
+    get ip(): string;
+    get port(): number;
+    get ssrc(): number;
+    get secretKey(): Buffer<ArrayBufferLike> | null;
+    connect(ssrc: number, ip: string, port: number): Promise<void>;
+    setSecretKey(key: Buffer): void;
+    send(packet: Buffer): void;
+    close(): void;
+}

package/dist/udp.js

@@ -0,0 +1,80 @@
+import { createSocket } from 'node:dgram';
+import { EventEmitter } from 'node:events';
+const KEEPALIVE_INTERVAL = 10_000;
+const IP_DISCOVERY_PACKET = Buffer.alloc(74);
+export class UdpSocket extends EventEmitter {
+    #socket = null;
+    #ip = '';
+    #port = 0;
+    #ssrc = 0;
+    #secretKey = null;
+    #keepaliveTimer = null;
+    #connected = false;
+    get connected() { return this.#connected; }
+    get ip() { return this.#ip; }
+    get port() { return this.#port; }
+    get ssrc() { return this.#ssrc; }
+    get secretKey() { return this.#secretKey; }
+    async connect(ssrc, ip, port) {
+        this.#ssrc = ssrc;
+        this.#socket = createSocket('udp4');
+        this.#socket.on('message', (msg) => this.#onMessage(msg));
+        this.#socket.on('error', (err) => this.emit('error', err));
+        await this.#discoverIp(ip, port);
+        this.#startKeepalive();
+        this.#connected = true;
+    }
+    #onMessage(msg) {
+        if (msg.length === 74) {
+            const type = msg.readUInt16BE(0);
+            if (type === 2) {
+                const ip = `${msg.readUInt8(4)}.${msg.readUInt8(5)}.${msg.readUInt8(6)}.${msg.readUInt8(7)}`;
+                const port = msg.readUInt16BE(8);
+                this.emit('ipDiscovery', ip, port);
+            }
+        }
+    }
+    #discoverIp(ip, port) {
+        return new Promise((resolve, reject) => {
+            IP_DISCOVERY_PACKET.writeUInt16BE(1, 0);
+            IP_DISCOVERY_PACKET.writeUInt16BE(70, 2);
+            IP_DISCOVERY_PACKET.writeUInt32BE(this.#ssrc, 4);
+            const timeout = setTimeout(() => reject(new Error('IP discovery timed out')), 5000);
+            this.#socket.send(IP_DISCOVERY_PACKET, port, ip);
+            this.once('ipDiscovery', (discIp, discPort) => {
+                clearTimeout(timeout);
+                this.#ip = discIp;
+                this.#port = discPort || port;
+                resolve();
+            });
+        });
+    }
+    setSecretKey(key) {
+        this.#secretKey = key;
+    }
+    send(packet) {
+        if (!this.#socket || !this.#ip)
+            return;
+        this.#socket.send(packet, this.#port, this.#ip);
+    }
+    #startKeepalive() {
+        const packet = Buffer.alloc(74);
+        packet.writeUInt16BE(1, 0);
+        packet.writeUInt16BE(70, 2);
+        packet.writeUInt32BE(this.#ssrc, 4);
+        this.#keepaliveTimer = setInterval(() => {
+            if (this.#socket) {
+                this.#socket.send(packet, this.#port, this.#ip);
+            }
+        }, KEEPALIVE_INTERVAL);
+    }
+    close() {
+        if (this.#keepaliveTimer)
+            clearInterval(this.#keepaliveTimer);
+        if (this.#socket) {
+            this.#socket.close();
+            this.#socket = null;
+        }
+        this.#connected = false;
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@sonata-sdk/voice",
+  "version": "0.1.0",
+  "description": "Discord voice connection library — WebSocket gateway, UDP, RTP, encryption, DAVE/MLS",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./gateway": {
+      "import": "./dist/gateway.js",
+      "types": "./dist/gateway.d.ts"
+    },
+    "./udp": {
+      "import": "./dist/udp.js",
+      "types": "./dist/udp.d.ts"
+    },
+    "./encryption": {
+      "import": "./dist/encryption.js",
+      "types": "./dist/encryption.d.ts"
+    },
+    "./connection": {
+      "import": "./dist/connection.js",
+      "types": "./dist/connection.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "opusscript": "^0.1.1",
+    "tweetnacl": "^1.0.3"
+  },
+  "optionalDependencies": {
+    "@snazzah/davey": "^0.1.11",
+    "libsodium-wrappers": "^0.7.15"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.4.0",
+    "ws": "^8.21.0"
+  }
+}