@discordjs/voice 0.18.1-dev.1732709130-97ffa201a → 0.19.0

package/dist/index.mjs

@@ -10,7 +10,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/VoiceConnection.ts
-import { EventEmitter as EventEmitter7 } from "node:events";
+import { EventEmitter as EventEmitter8 } from "events";
 
 // src/DataStore.ts
 import { GatewayOpcodes } from "discord-api-types/v10";
@@ -109,13 +109,13 @@ function deleteAudioPlayer(player) {
 __name(deleteAudioPlayer, "deleteAudioPlayer");
 
 // src/networking/Networking.ts
-import { Buffer as Buffer4 } from "node:buffer";
-import crypto from "node:crypto";
-import { EventEmitter as EventEmitter3 } from "node:events";
-import { VoiceOpcodes as VoiceOpcodes2 } from "discord-api-types/voice/v4";
+import { Buffer as Buffer7 } from "buffer";
+import crypto from "crypto";
+import { EventEmitter as EventEmitter5 } from "events";
+import { VoiceEncryptionMode, VoiceOpcodes as VoiceOpcodes2 } from "discord-api-types/voice/v8";
 
 // src/util/Secretbox.ts
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer as Buffer2 } from "buffer";
 var libs = {
   "sodium-native": /* @__PURE__ */ __name((sodium) => ({
     crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => {
@@ -130,20 +130,12 @@ var libs = {
     }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
   }), "sodium-native"),
   sodium: /* @__PURE__ */ __name((sodium) => ({
-    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => {
-      return sodium.api.crypto_aead_xchacha20poly1305_ietf_decrypt(cipherText, additionalData, null, nonce2, key);
-    }, "crypto_aead_xchacha20poly1305_ietf_decrypt"),
-    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
-      return sodium.api.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce2, key);
-    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
+    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => sodium.api.crypto_aead_xchacha20poly1305_ietf_decrypt(cipherText, additionalData, null, nonce2, key), "crypto_aead_xchacha20poly1305_ietf_decrypt"),
+    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => sodium.api.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce2, key), "crypto_aead_xchacha20poly1305_ietf_encrypt")
   }), "sodium"),
   "libsodium-wrappers": /* @__PURE__ */ __name((sodium) => ({
-    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => {
-      return sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(null, cipherText, additionalData, nonce2, key);
-    }, "crypto_aead_xchacha20poly1305_ietf_decrypt"),
-    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
-      return sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce2, key);
-    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
+    crypto_aead_xchacha20poly1305_ietf_decrypt: /* @__PURE__ */ __name((cipherText, additionalData, nonce2, key) => sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(null, cipherText, additionalData, nonce2, key), "crypto_aead_xchacha20poly1305_ietf_decrypt"),
+    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce2, key), "crypto_aead_xchacha20poly1305_ietf_encrypt")
   }), "libsodium-wrappers"),
   "@stablelib/xchacha20poly1305": /* @__PURE__ */ __name((stablelib) => ({
     crypto_aead_xchacha20poly1305_ietf_decrypt(plaintext, additionalData, nonce2, key) {
@@ -201,1094 +193,1608 @@ var secretboxLoadPromise = new Promise(async (resolve2) => {
 var noop = /* @__PURE__ */ __name(() => {
 }, "noop");
 
-// src/networking/VoiceUDPSocket.ts
-import { Buffer as Buffer3 } from "node:buffer";
-import { createSocket } from "node:dgram";
-import { EventEmitter } from "node:events";
-import { isIPv4 } from "node:net";
-function parseLocalPacket(message) {
-  const packet = Buffer3.from(message);
-  const ip = packet.slice(8, packet.indexOf(0, 8)).toString("utf8");
-  if (!isIPv4(ip)) {
-    throw new Error("Malformed IP address");
-  }
-  const port = packet.readUInt16BE(packet.length - 2);
-  return { ip, port };
-}
-__name(parseLocalPacket, "parseLocalPacket");
-var KEEP_ALIVE_INTERVAL = 5e3;
-var MAX_COUNTER_VALUE = 2 ** 32 - 1;
-var VoiceUDPSocket = class extends EventEmitter {
+// src/networking/DAVESession.ts
+import { Buffer as Buffer4 } from "buffer";
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/audio/AudioPlayer.ts
+import { Buffer as Buffer3 } from "buffer";
+import { EventEmitter } from "events";
+
+// src/audio/AudioPlayerError.ts
+var AudioPlayerError = class extends Error {
   static {
-    __name(this, "VoiceUDPSocket");
-  }
-  /**
-   * The underlying network Socket for the VoiceUDPSocket.
-   */
-  socket;
-  /**
-   * The socket details for Discord (remote)
-   */
-  remote;
-  /**
-   * The counter used in the keep alive mechanism.
-   */
-  keepAliveCounter = 0;
-  /**
-   * The buffer used to write the keep alive counter into.
-   */
-  keepAliveBuffer;
-  /**
-   * The Node.js interval for the keep-alive mechanism.
-   */
-  keepAliveInterval;
-  /**
-   * The time taken to receive a response to keep alive messages.
-   *
-   * @deprecated This field is no longer updated as keep alive messages are no longer tracked.
-   */
-  ping;
-  /**
-   * Creates a new VoiceUDPSocket.
-   *
-   * @param remote - Details of the remote socket
-   */
-  constructor(remote) {
-    super();
-    this.socket = createSocket("udp4");
-    this.socket.on("error", (error) => this.emit("error", error));
-    this.socket.on("message", (buffer) => this.onMessage(buffer));
-    this.socket.on("close", () => this.emit("close"));
-    this.remote = remote;
-    this.keepAliveBuffer = Buffer3.alloc(8);
-    this.keepAliveInterval = setInterval(() => this.keepAlive(), KEEP_ALIVE_INTERVAL);
-    setImmediate(() => this.keepAlive());
+    __name(this, "AudioPlayerError");
   }
   /**
-   * Called when a message is received on the UDP socket.
-   *
-   * @param buffer - The received buffer
+   * The resource associated with the audio player at the time the error was thrown.
    */
-  onMessage(buffer) {
-    this.emit("message", buffer);
+  resource;
+  constructor(error, resource) {
+    super(error.message);
+    this.resource = resource;
+    this.name = error.name;
+    this.stack = error.stack;
   }
-  /**
-   * Called at a regular interval to check whether we are still able to send datagrams to Discord.
-   */
-  keepAlive() {
-    this.keepAliveBuffer.writeUInt32LE(this.keepAliveCounter, 0);
-    this.send(this.keepAliveBuffer);
-    this.keepAliveCounter++;
-    if (this.keepAliveCounter > MAX_COUNTER_VALUE) {
-      this.keepAliveCounter = 0;
-    }
+};
+
+// src/audio/PlayerSubscription.ts
+var PlayerSubscription = class {
+  static {
+    __name(this, "PlayerSubscription");
   }
   /**
-   * Sends a buffer to Discord.
-   *
-   * @param buffer - The buffer to send
+   * The voice connection of this subscription.
    */
-  send(buffer) {
-    this.socket.send(buffer, this.remote.port, this.remote.ip);
-  }
+  connection;
   /**
-   * Closes the socket, the instance will not be able to be reused.
+   * The audio player of this subscription.
    */
-  destroy() {
-    try {
-      this.socket.close();
-    } catch {
-    }
-    clearInterval(this.keepAliveInterval);
+  player;
+  constructor(connection, player) {
+    this.connection = connection;
+    this.player = player;
   }
   /**
-   * Performs IP discovery to discover the local address and port to be used for the voice connection.
-   *
-   * @param ssrc - The SSRC received from Discord
+   * Unsubscribes the connection from the audio player, meaning that the
+   * audio player cannot stream audio to it until a new subscription is made.
    */
-  async performIPDiscovery(ssrc) {
-    return new Promise((resolve2, reject) => {
-      const listener = /* @__PURE__ */ __name((message) => {
-        try {
-          if (message.readUInt16BE(0) !== 2) return;
-          const packet = parseLocalPacket(message);
-          this.socket.off("message", listener);
-          resolve2(packet);
-        } catch {
-        }
-      }, "listener");
-      this.socket.on("message", listener);
-      this.socket.once("close", () => reject(new Error("Cannot perform IP discovery - socket closed")));
-      const discoveryBuffer = Buffer3.alloc(74);
-      discoveryBuffer.writeUInt16BE(1, 0);
-      discoveryBuffer.writeUInt16BE(70, 2);
-      discoveryBuffer.writeUInt32BE(ssrc, 4);
-      this.send(discoveryBuffer);
-    });
+  unsubscribe() {
+    this.connection["onSubscriptionRemoved"](this);
+    this.player["unsubscribe"](this);
   }
 };
 
-// src/networking/VoiceWebSocket.ts
-import { EventEmitter as EventEmitter2 } from "node:events";
-import { VoiceOpcodes } from "discord-api-types/voice/v4";
-import WebSocket from "ws";
-var VoiceWebSocket = class extends EventEmitter2 {
+// src/audio/AudioPlayer.ts
+var SILENCE_FRAME = Buffer3.from([248, 255, 254]);
+var NoSubscriberBehavior = /* @__PURE__ */ ((NoSubscriberBehavior2) => {
+  NoSubscriberBehavior2["Pause"] = "pause";
+  NoSubscriberBehavior2["Play"] = "play";
+  NoSubscriberBehavior2["Stop"] = "stop";
+  return NoSubscriberBehavior2;
+})(NoSubscriberBehavior || {});
+var AudioPlayerStatus = /* @__PURE__ */ ((AudioPlayerStatus2) => {
+  AudioPlayerStatus2["AutoPaused"] = "autopaused";
+  AudioPlayerStatus2["Buffering"] = "buffering";
+  AudioPlayerStatus2["Idle"] = "idle";
+  AudioPlayerStatus2["Paused"] = "paused";
+  AudioPlayerStatus2["Playing"] = "playing";
+  return AudioPlayerStatus2;
+})(AudioPlayerStatus || {});
+function stringifyState(state) {
+  return JSON.stringify({
+    ...state,
+    resource: Reflect.has(state, "resource"),
+    stepTimeout: Reflect.has(state, "stepTimeout")
+  });
+}
+__name(stringifyState, "stringifyState");
+var AudioPlayer = class extends EventEmitter {
   static {
-    __name(this, "VoiceWebSocket");
+    __name(this, "AudioPlayer");
   }
   /**
-   * The current heartbeat interval, if any.
-   */
-  heartbeatInterval;
-  /**
-   * The time (milliseconds since UNIX epoch) that the last heartbeat acknowledgement packet was received.
-   * This is set to 0 if an acknowledgement packet hasn't been received yet.
-   */
-  lastHeartbeatAck;
-  /**
-   * The time (milliseconds since UNIX epoch) that the last heartbeat was sent. This is set to 0 if a heartbeat
-   * hasn't been sent yet.
+   * The state that the AudioPlayer is in.
    */
-  lastHeartbeatSend;
+  _state;
   /**
-   * The number of consecutively missed heartbeats.
+   * A list of VoiceConnections that are registered to this AudioPlayer. The player will attempt to play audio
+   * to the streams in this list.
    */
-  missedHeartbeats = 0;
+  subscribers = [];
   /**
-   * The last recorded ping.
+   * The behavior that the player should follow when it enters certain situations.
    */
-  ping;
+  behaviors;
   /**
    * The debug logger function, if debugging is enabled.
    */
   debug;
   /**
-   * The underlying WebSocket of this wrapper.
+   * Creates a new AudioPlayer.
    */
-  ws;
+  constructor(options = {}) {
+    super();
+    this._state = { status: "idle" /* Idle */ };
+    this.behaviors = {
+      noSubscriber: "pause" /* Pause */,
+      maxMissedFrames: 5,
+      ...options.behaviors
+    };
+    this.debug = options.debug === false ? null : (message) => this.emit("debug", message);
+  }
   /**
-   * Creates a new VoiceWebSocket.
-   *
-   * @param address - The address to connect to
+   * A list of subscribed voice connections that can currently receive audio to play.
    */
-  constructor(address, debug) {
-    super();
-    this.ws = new WebSocket(address);
-    this.ws.onmessage = (err) => this.onMessage(err);
-    this.ws.onopen = (err) => this.emit("open", err);
-    this.ws.onerror = (err) => this.emit("error", err instanceof Error ? err : err.error);
-    this.ws.onclose = (err) => this.emit("close", err);
-    this.lastHeartbeatAck = 0;
-    this.lastHeartbeatSend = 0;
-    this.debug = debug ? (message) => this.emit("debug", message) : null;
+  get playable() {
+    return this.subscribers.filter(({ connection }) => connection.state.status === "ready" /* Ready */).map(({ connection }) => connection);
   }
   /**
-   * Destroys the VoiceWebSocket. The heartbeat interval is cleared, and the connection is closed.
+   * Subscribes a VoiceConnection to the audio player's play list. If the VoiceConnection is already subscribed,
+   * then the existing subscription is used.
+   *
+   * @remarks
+   * This method should not be directly called. Instead, use VoiceConnection#subscribe.
+   * @param connection - The connection to subscribe
+   * @returns The new subscription if the voice connection is not yet subscribed, otherwise the existing subscription
    */
-  destroy() {
-    try {
-      this.debug?.("destroyed");
-      this.setHeartbeatInterval(-1);
-      this.ws.close(1e3);
-    } catch (error) {
-      const err = error;
-      this.emit("error", err);
+  // @ts-ignore
+  subscribe(connection) {
+    const existingSubscription = this.subscribers.find((subscription) => subscription.connection === connection);
+    if (!existingSubscription) {
+      const subscription = new PlayerSubscription(connection, this);
+      this.subscribers.push(subscription);
+      setImmediate(() => this.emit("subscribe", subscription));
+      return subscription;
     }
+    return existingSubscription;
   }
   /**
-   * Handles message events on the WebSocket. Attempts to JSON parse the messages and emit them
-   * as packets.
+   * Unsubscribes a subscription - i.e. removes a voice connection from the play list of the audio player.
    *
-   * @param event - The message event
+   * @remarks
+   * This method should not be directly called. Instead, use PlayerSubscription#unsubscribe.
+   * @param subscription - The subscription to remove
+   * @returns Whether or not the subscription existed on the player and was removed
    */
-  onMessage(event) {
-    if (typeof event.data !== "string") return;
-    this.debug?.(`<< ${event.data}`);
-    let packet;
-    try {
-      packet = JSON.parse(event.data);
-    } catch (error) {
-      const err = error;
-      this.emit("error", err);
+  // @ts-ignore
+  unsubscribe(subscription) {
+    const index = this.subscribers.indexOf(subscription);
+    const exists = index !== -1;
+    if (exists) {
+      this.subscribers.splice(index, 1);
+      subscription.connection.setSpeaking(false);
+      this.emit("unsubscribe", subscription);
+    }
+    return exists;
+  }
+  /**
+   * The state that the player is in.
+   *
+   * @remarks
+   * The setter will perform clean-up operations where necessary.
+   */
+  get state() {
+    return this._state;
+  }
+  set state(newState) {
+    const oldState = this._state;
+    const newResource = Reflect.get(newState, "resource");
+    if (oldState.status !== "idle" /* Idle */ && oldState.resource !== newResource) {
+      oldState.resource.playStream.on("error", noop);
+      oldState.resource.playStream.off("error", oldState.onStreamError);
+      oldState.resource.audioPlayer = void 0;
+      oldState.resource.playStream.destroy();
+      oldState.resource.playStream.read();
+    }
+    if (oldState.status === "buffering" /* Buffering */ && (newState.status !== "buffering" /* Buffering */ || newState.resource !== oldState.resource)) {
+      oldState.resource.playStream.off("end", oldState.onFailureCallback);
+      oldState.resource.playStream.off("close", oldState.onFailureCallback);
+      oldState.resource.playStream.off("finish", oldState.onFailureCallback);
+      oldState.resource.playStream.off("readable", oldState.onReadableCallback);
+    }
+    if (newState.status === "idle" /* Idle */) {
+      this._signalStopSpeaking();
+      deleteAudioPlayer(this);
+    }
+    if (newResource) {
+      addAudioPlayer(this);
+    }
+    const didChangeResources = oldState.status !== "idle" /* Idle */ && newState.status === "playing" /* Playing */ && oldState.resource !== newState.resource;
+    this._state = newState;
+    this.emit("stateChange", oldState, this._state);
+    if (oldState.status !== newState.status || didChangeResources) {
+      this.emit(newState.status, oldState, this._state);
+    }
+    this.debug?.(`state change:
+from ${stringifyState(oldState)}
+to ${stringifyState(newState)}`);
+  }
+  /**
+   * Plays a new resource on the player. If the player is already playing a resource, the existing resource is destroyed
+   * (it cannot be reused, even in another player) and is replaced with the new resource.
+   *
+   * @remarks
+   * The player will transition to the Playing state once playback begins, and will return to the Idle state once
+   * playback is ended.
+   *
+   * If the player was previously playing a resource and this method is called, the player will not transition to the
+   * Idle state during the swap over.
+   * @param resource - The resource to play
+   * @throws Will throw if attempting to play an audio resource that has already ended, or is being played by another player
+   */
+  play(resource) {
+    if (resource.ended) {
+      throw new Error("Cannot play a resource that has already ended.");
+    }
+    if (resource.audioPlayer) {
+      if (resource.audioPlayer === this) {
+        return;
+      }
+      throw new Error("Resource is already being played by another audio player.");
+    }
+    resource.audioPlayer = this;
+    const onStreamError = /* @__PURE__ */ __name((error) => {
+      if (this.state.status !== "idle" /* Idle */) {
+        this.emit("error", new AudioPlayerError(error, this.state.resource));
+      }
+      if (this.state.status !== "idle" /* Idle */ && this.state.resource === resource) {
+        this.state = {
+          status: "idle" /* Idle */
+        };
+      }
+    }, "onStreamError");
+    resource.playStream.once("error", onStreamError);
+    if (resource.started) {
+      this.state = {
+        status: "playing" /* Playing */,
+        missedFrames: 0,
+        playbackDuration: 0,
+        resource,
+        onStreamError
+      };
+    } else {
+      const onReadableCallback = /* @__PURE__ */ __name(() => {
+        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
+          this.state = {
+            status: "playing" /* Playing */,
+            missedFrames: 0,
+            playbackDuration: 0,
+            resource,
+            onStreamError
+          };
+        }
+      }, "onReadableCallback");
+      const onFailureCallback = /* @__PURE__ */ __name(() => {
+        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
+          this.state = {
+            status: "idle" /* Idle */
+          };
+        }
+      }, "onFailureCallback");
+      resource.playStream.once("readable", onReadableCallback);
+      resource.playStream.once("end", onFailureCallback);
+      resource.playStream.once("close", onFailureCallback);
+      resource.playStream.once("finish", onFailureCallback);
+      this.state = {
+        status: "buffering" /* Buffering */,
+        resource,
+        onReadableCallback,
+        onFailureCallback,
+        onStreamError
+      };
+    }
+  }
+  /**
+   * Pauses playback of the current resource, if any.
+   *
+   * @param interpolateSilence - If true, the player will play 5 packets of silence after pausing to prevent audio glitches
+   * @returns `true` if the player was successfully paused, otherwise `false`
+   */
+  pause(interpolateSilence = true) {
+    if (this.state.status !== "playing" /* Playing */) return false;
+    this.state = {
+      ...this.state,
+      status: "paused" /* Paused */,
+      silencePacketsRemaining: interpolateSilence ? 5 : 0
+    };
+    return true;
+  }
+  /**
+   * Unpauses playback of the current resource, if any.
+   *
+   * @returns `true` if the player was successfully unpaused, otherwise `false`
+   */
+  unpause() {
+    if (this.state.status !== "paused" /* Paused */) return false;
+    this.state = {
+      ...this.state,
+      status: "playing" /* Playing */,
+      missedFrames: 0
+    };
+    return true;
+  }
+  /**
+   * Stops playback of the current resource and destroys the resource. The player will either transition to the Idle state,
+   * or remain in its current state until the silence padding frames of the resource have been played.
+   *
+   * @param force - If true, will force the player to enter the Idle state even if the resource has silence padding frames
+   * @returns `true` if the player will come to a stop, otherwise `false`
+   */
+  stop(force = false) {
+    if (this.state.status === "idle" /* Idle */) return false;
+    if (force || this.state.resource.silencePaddingFrames === 0) {
+      this.state = {
+        status: "idle" /* Idle */
+      };
+    } else if (this.state.resource.silenceRemaining === -1) {
+      this.state.resource.silenceRemaining = this.state.resource.silencePaddingFrames;
+    }
+    return true;
+  }
+  /**
+   * Checks whether the underlying resource (if any) is playable (readable)
+   *
+   * @returns `true` if the resource is playable, otherwise `false`
+   */
+  checkPlayable() {
+    const state = this._state;
+    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */) return false;
+    if (!state.resource.readable) {
+      this.state = {
+        status: "idle" /* Idle */
+      };
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Called roughly every 20ms by the global audio player timer. Dispatches any audio packets that are buffered
+   * by the active connections of this audio player.
+   */
+  // @ts-ignore
+  _stepDispatch() {
+    const state = this._state;
+    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */) return;
+    for (const connection of this.playable) {
+      connection.dispatchAudio();
+    }
+  }
+  /**
+   * Called roughly every 20ms by the global audio player timer. Attempts to read an audio packet from the
+   * underlying resource of the stream, and then has all the active connections of the audio player prepare it
+   * (encrypt it, append header data) so that it is ready to play at the start of the next cycle.
+   */
+  // @ts-ignore
+  _stepPrepare() {
+    const state = this._state;
+    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */) return;
+    const playable = this.playable;
+    if (state.status === "autopaused" /* AutoPaused */ && playable.length > 0) {
+      this.state = {
+        ...state,
+        status: "playing" /* Playing */,
+        missedFrames: 0
+      };
+    }
+    if (state.status === "paused" /* Paused */ || state.status === "autopaused" /* AutoPaused */) {
+      if (state.silencePacketsRemaining > 0) {
+        state.silencePacketsRemaining--;
+        this._preparePacket(SILENCE_FRAME, playable, state);
+        if (state.silencePacketsRemaining === 0) {
+          this._signalStopSpeaking();
+        }
+      }
+      return;
+    }
+    if (playable.length === 0) {
+      if (this.behaviors.noSubscriber === "pause" /* Pause */) {
+        this.state = {
+          ...state,
+          status: "autopaused" /* AutoPaused */,
+          silencePacketsRemaining: 5
+        };
+        return;
+      } else if (this.behaviors.noSubscriber === "stop" /* Stop */) {
+        this.stop(true);
+      }
+    }
+    const packet = state.resource.read();
+    if (state.status === "playing" /* Playing */) {
+      if (packet) {
+        this._preparePacket(packet, playable, state);
+        state.missedFrames = 0;
+      } else {
+        this._preparePacket(SILENCE_FRAME, playable, state);
+        state.missedFrames++;
+        if (state.missedFrames >= this.behaviors.maxMissedFrames) {
+          this.stop();
+        }
+      }
+    }
+  }
+  /**
+   * Signals to all the subscribed connections that they should send a packet to Discord indicating
+   * they are no longer speaking. Called once playback of a resource ends.
+   */
+  _signalStopSpeaking() {
+    for (const { connection } of this.subscribers) {
+      connection.setSpeaking(false);
+    }
+  }
+  /**
+   * Instructs the given connections to each prepare this packet to be played at the start of the
+   * next cycle.
+   *
+   * @param packet - The Opus packet to be prepared by each receiver
+   * @param receivers - The connections that should play this packet
+   */
+  _preparePacket(packet, receivers, state) {
+    state.playbackDuration += 20;
+    for (const connection of receivers) {
+      connection.prepareAudioPacket(packet);
+    }
+  }
+};
+function createAudioPlayer(options) {
+  return new AudioPlayer(options);
+}
+__name(createAudioPlayer, "createAudioPlayer");
+
+// src/networking/DAVESession.ts
+var Davey = null;
+var TRANSITION_EXPIRY = 10;
+var TRANSITION_EXPIRY_PENDING_DOWNGRADE = 24;
+var DEFAULT_DECRYPTION_FAILURE_TOLERANCE = 36;
+var daveLoadPromise = new Promise(async (resolve2) => {
+  try {
+    const lib = await import("@snazzah/davey");
+    Davey = lib;
+  } catch {
+  }
+  resolve2();
+});
+function getMaxProtocolVersion() {
+  return Davey?.DAVE_PROTOCOL_VERSION;
+}
+__name(getMaxProtocolVersion, "getMaxProtocolVersion");
+var DAVESession = class extends EventEmitter2 {
+  static {
+    __name(this, "DAVESession");
+  }
+  /**
+   * The channel id represented by this session.
+   */
+  channelId;
+  /**
+   * The user id represented by this session.
+   */
+  userId;
+  /**
+   * The protocol version being used.
+   */
+  protocolVersion;
+  /**
+   * The last transition id executed.
+   */
+  lastTransitionId;
+  /**
+   * The pending transition.
+   */
+  pendingTransition;
+  /**
+   * Whether this session was downgraded previously.
+   */
+  downgraded = false;
+  /**
+   * The amount of consecutive failures encountered when decrypting.
+   */
+  consecutiveFailures = 0;
+  /**
+   * The amount of consecutive failures needed to attempt to recover.
+   */
+  failureTolerance;
+  /**
+   * Whether this session is currently re-initializing due to an invalid transition.
+   */
+  reinitializing = false;
+  /**
+   * The underlying DAVE Session of this wrapper.
+   */
+  session;
+  constructor(protocolVersion, userId, channelId, options) {
+    if (Davey === null)
+      throw new Error(
+        `Cannot utilize the DAVE protocol as the @snazzah/davey package has not been installed.
+- Use the generateDependencyReport() function for more information.
+`
+      );
+    super();
+    this.protocolVersion = protocolVersion;
+    this.userId = userId;
+    this.channelId = channelId;
+    this.failureTolerance = options.decryptionFailureTolerance ?? DEFAULT_DECRYPTION_FAILURE_TOLERANCE;
+  }
+  /**
+   * The current voice privacy code of the session. Will be `null` if there is no session.
+   */
+  get voicePrivacyCode() {
+    if (this.protocolVersion === 0 || !this.session?.voicePrivacyCode) {
+      return null;
+    }
+    return this.session.voicePrivacyCode;
+  }
+  /**
+   * Gets the verification code for a user in the session.
+   *
+   * @throws Will throw if there is not an active session or the user id provided is invalid or not in the session.
+   */
+  async getVerificationCode(userId) {
+    if (!this.session) throw new Error("Session not available");
+    return this.session.getVerificationCode(userId);
+  }
+  /**
+   * Re-initializes (or initializes) the underlying session.
+   */
+  reinit() {
+    if (this.protocolVersion > 0) {
+      if (this.session) {
+        this.session.reinit(this.protocolVersion, this.userId, this.channelId);
+        this.emit("debug", `Session reinitialized for protocol version ${this.protocolVersion}`);
+      } else {
+        this.session = new Davey.DAVESession(this.protocolVersion, this.userId, this.channelId);
+        this.emit("debug", `Session initialized for protocol version ${this.protocolVersion}`);
+      }
+      this.emit("keyPackage", this.session.getSerializedKeyPackage());
+    } else if (this.session) {
+      this.session.reset();
+      this.session.setPassthroughMode(true, TRANSITION_EXPIRY);
+      this.emit("debug", "Session reset");
+    }
+  }
+  /**
+   * Set the external sender for this session.
+   *
+   * @param externalSender - The external sender
+   */
+  setExternalSender(externalSender) {
+    if (!this.session) throw new Error("No session available");
+    this.session.setExternalSender(externalSender);
+    this.emit("debug", "Set MLS external sender");
+  }
+  /**
+   * Prepare for a transition.
+   *
+   * @param data - The transition data
+   * @returns Whether we should signal to the voice server that we are ready
+   */
+  prepareTransition(data) {
+    this.emit("debug", `Preparing for transition (${data.transition_id}, v${data.protocol_version})`);
+    this.pendingTransition = data;
+    if (data.transition_id === 0) {
+      this.executeTransition(data.transition_id);
+    } else {
+      if (data.protocol_version === 0) this.session?.setPassthroughMode(true, TRANSITION_EXPIRY_PENDING_DOWNGRADE);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Execute a transition.
+   *
+   * @param transitionId - The transition id to execute on
+   */
+  executeTransition(transitionId) {
+    this.emit("debug", `Executing transition (${transitionId})`);
+    if (!this.pendingTransition) {
+      this.emit("debug", `Received execute transition, but we don't have a pending transition for ${transitionId}`);
       return;
     }
-    if (packet.op === VoiceOpcodes.HeartbeatAck) {
-      this.lastHeartbeatAck = Date.now();
-      this.missedHeartbeats = 0;
-      this.ping = this.lastHeartbeatAck - this.lastHeartbeatSend;
+    let transitioned = false;
+    if (transitionId === this.pendingTransition.transition_id) {
+      const oldVersion = this.protocolVersion;
+      this.protocolVersion = this.pendingTransition.protocol_version;
+      if (oldVersion !== this.protocolVersion && this.protocolVersion === 0) {
+        this.downgraded = true;
+        this.emit("debug", "Session downgraded");
+      } else if (transitionId > 0 && this.downgraded) {
+        this.downgraded = false;
+        this.session?.setPassthroughMode(true, TRANSITION_EXPIRY);
+        this.emit("debug", "Session upgraded");
+      }
+      transitioned = true;
+      this.reinitializing = false;
+      this.lastTransitionId = transitionId;
+      this.emit("debug", `Transition executed (v${oldVersion} -> v${this.protocolVersion}, id: ${transitionId})`);
+    } else {
+      this.emit(
+        "debug",
+        `Received execute transition for an unexpected transition id (expected: ${this.pendingTransition.transition_id}, actual: ${transitionId})`
+      );
     }
-    this.emit("packet", packet);
+    this.pendingTransition = void 0;
+    return transitioned;
   }
   /**
-   * Sends a JSON-stringifiable packet over the WebSocket.
+   * Prepare for a new epoch.
    *
-   * @param packet - The packet to send
+   * @param data - The epoch data
    */
-  sendPacket(packet) {
+  prepareEpoch(data) {
+    this.emit("debug", `Preparing for epoch (${data.epoch})`);
+    if (data.epoch === 1) {
+      this.protocolVersion = data.protocol_version;
+      this.reinit();
+    }
+  }
+  /**
+   * Recover from an invalid transition by re-initializing.
+   *
+   * @param transitionId - The transition id to invalidate
+   */
+  recoverFromInvalidTransition(transitionId) {
+    if (this.reinitializing) return;
+    this.emit("debug", `Invalidating transition ${transitionId}`);
+    this.reinitializing = true;
+    this.consecutiveFailures = 0;
+    this.emit("invalidateTransition", transitionId);
+    this.reinit();
+  }
+  /**
+   * Processes proposals from the MLS group.
+   *
+   * @param payload - The binary message payload
+   * @param connectedClients - The set of connected client IDs
+   * @returns The payload to send back to the voice server, if there is one
+   */
+  processProposals(payload, connectedClients) {
+    if (!this.session) throw new Error("No session available");
+    const optype = payload.readUInt8(0);
+    const { commit, welcome } = this.session.processProposals(
+      optype,
+      payload.subarray(1),
+      Array.from(connectedClients)
+    );
+    this.emit("debug", "MLS proposals processed");
+    if (!commit) return;
+    return welcome ? Buffer4.concat([commit, welcome]) : commit;
+  }
+  /**
+   * Processes a commit from the MLS group.
+   *
+   * @param payload - The payload
+   * @returns The transaction id and whether it was successful
+   */
+  processCommit(payload) {
+    if (!this.session) throw new Error("No session available");
+    const transitionId = payload.readUInt16BE(0);
     try {
-      const stringified = JSON.stringify(packet);
-      this.debug?.(`>> ${stringified}`);
-      this.ws.send(stringified);
+      this.session.processCommit(payload.subarray(2));
+      if (transitionId === 0) {
+        this.reinitializing = false;
+        this.lastTransitionId = transitionId;
+      } else {
+        this.pendingTransition = { transition_id: transitionId, protocol_version: this.protocolVersion };
+      }
+      this.emit("debug", `MLS commit processed (transition id: ${transitionId})`);
+      return { transitionId, success: true };
     } catch (error) {
-      const err = error;
-      this.emit("error", err);
+      this.emit("debug", `MLS commit errored from transition ${transitionId}: ${error}`);
+      this.recoverFromInvalidTransition(transitionId);
+      return { transitionId, success: false };
     }
   }
   /**
-   * Sends a heartbeat over the WebSocket.
+   * Processes a welcome from the MLS group.
+   *
+   * @param payload - The payload
+   * @returns The transaction id and whether it was successful
    */
-  sendHeartbeat() {
-    this.lastHeartbeatSend = Date.now();
-    this.missedHeartbeats++;
-    const nonce2 = this.lastHeartbeatSend;
-    this.sendPacket({
-      op: VoiceOpcodes.Heartbeat,
-      // eslint-disable-next-line id-length
-      d: nonce2
-    });
+  processWelcome(payload) {
+    if (!this.session) throw new Error("No session available");
+    const transitionId = payload.readUInt16BE(0);
+    try {
+      this.session.processWelcome(payload.subarray(2));
+      if (transitionId === 0) {
+        this.reinitializing = false;
+        this.lastTransitionId = transitionId;
+      } else {
+        this.pendingTransition = { transition_id: transitionId, protocol_version: this.protocolVersion };
+      }
+      this.emit("debug", `MLS welcome processed (transition id: ${transitionId})`);
+      return { transitionId, success: true };
+    } catch (error) {
+      this.emit("debug", `MLS welcome errored from transition ${transitionId}: ${error}`);
+      this.recoverFromInvalidTransition(transitionId);
+      return { transitionId, success: false };
+    }
   }
   /**
-   * Sets/clears an interval to send heartbeats over the WebSocket.
+   * Encrypt a packet using end-to-end encryption.
    *
-   * @param ms - The interval in milliseconds. If negative, the interval will be unset
+   * @param packet - The packet to encrypt
    */
-  setHeartbeatInterval(ms) {
-    if (this.heartbeatInterval !== void 0) clearInterval(this.heartbeatInterval);
-    if (ms > 0) {
-      this.heartbeatInterval = setInterval(() => {
-        if (this.lastHeartbeatSend !== 0 && this.missedHeartbeats >= 3) {
-          this.ws.close();
-          this.setHeartbeatInterval(-1);
+  encrypt(packet) {
+    if (this.protocolVersion === 0 || !this.session?.ready || packet.equals(SILENCE_FRAME)) return packet;
+    return this.session.encryptOpus(packet);
+  }
+  /**
+   * Decrypt a packet using end-to-end encryption.
+   *
+   * @param packet - The packet to decrypt
+   * @param userId - The user id that sent the packet
+   * @returns The decrypted packet, or `null` if the decryption failed but should be ignored
+   */
+  decrypt(packet, userId) {
+    const canDecrypt = this.session?.ready && (this.protocolVersion !== 0 || this.session?.canPassthrough(userId));
+    if (packet.equals(SILENCE_FRAME) || !canDecrypt || !this.session) return packet;
+    try {
+      const buffer = this.session.decrypt(userId, Davey.MediaType.AUDIO, packet);
+      this.consecutiveFailures = 0;
+      return buffer;
+    } catch (error) {
+      if (!this.reinitializing && !this.pendingTransition) {
+        this.consecutiveFailures++;
+        this.emit("debug", `Failed to decrypt a packet (${this.consecutiveFailures} consecutive fails)`);
+        if (this.consecutiveFailures > this.failureTolerance) {
+          if (this.lastTransitionId) this.recoverFromInvalidTransition(this.lastTransitionId);
+          else throw error;
         }
-        this.sendHeartbeat();
-      }, ms);
+      } else if (this.reinitializing) {
+        this.emit("debug", "Failed to decrypt a packet (reinitializing session)");
+      } else if (this.pendingTransition) {
+        this.emit(
+          "debug",
+          `Failed to decrypt a packet (pending transition ${this.pendingTransition.transition_id} to v${this.pendingTransition.protocol_version})`
+        );
+      }
+    }
+    return null;
+  }
+  /**
+   * Resets the session.
+   */
+  destroy() {
+    try {
+      this.session?.reset();
+    } catch {
     }
   }
 };
 
-// src/networking/Networking.ts
-var CHANNELS = 2;
-var TIMESTAMP_INC = 48e3 / 100 * CHANNELS;
-var MAX_NONCE_SIZE = 2 ** 32 - 1;
-var SUPPORTED_ENCRYPTION_MODES = ["aead_xchacha20_poly1305_rtpsize"];
-if (crypto.getCiphers().includes("aes-256-gcm")) {
-  SUPPORTED_ENCRYPTION_MODES.unshift("aead_aes256_gcm_rtpsize");
-}
-var nonce = Buffer4.alloc(24);
-function stringifyState(state) {
-  return JSON.stringify({
-    ...state,
-    ws: Reflect.has(state, "ws"),
-    udp: Reflect.has(state, "udp")
-  });
-}
-__name(stringifyState, "stringifyState");
-function chooseEncryptionMode(options) {
-  const option = options.find((option2) => SUPPORTED_ENCRYPTION_MODES.includes(option2));
-  if (!option) {
-    throw new Error(`No compatible encryption modes. Available include: ${options.join(", ")}`);
+// src/networking/VoiceUDPSocket.ts
+import { Buffer as Buffer5 } from "buffer";
+import { createSocket } from "dgram";
+import { EventEmitter as EventEmitter3 } from "events";
+import { isIPv4 } from "net";
+function parseLocalPacket(message) {
+  const packet = Buffer5.from(message);
+  const ip = packet.slice(8, packet.indexOf(0, 8)).toString("utf8");
+  if (!isIPv4(ip)) {
+    throw new Error("Malformed IP address");
   }
-  return option;
-}
-__name(chooseEncryptionMode, "chooseEncryptionMode");
-function randomNBit(numberOfBits) {
-  return Math.floor(Math.random() * 2 ** numberOfBits);
+  const port = packet.readUInt16BE(packet.length - 2);
+  return { ip, port };
 }
-__name(randomNBit, "randomNBit");
-var Networking = class extends EventEmitter3 {
+__name(parseLocalPacket, "parseLocalPacket");
+var KEEP_ALIVE_INTERVAL = 5e3;
+var MAX_COUNTER_VALUE = 2 ** 32 - 1;
+var VoiceUDPSocket = class extends EventEmitter3 {
   static {
-    __name(this, "Networking");
+    __name(this, "VoiceUDPSocket");
   }
-  _state;
   /**
-   * The debug logger function, if debugging is enabled.
+   * The underlying network Socket for the VoiceUDPSocket.
    */
-  debug;
+  socket;
   /**
-   * Creates a new Networking instance.
+   * The socket details for Discord (remote)
    */
-  constructor(options, debug) {
-    super();
-    this.onWsOpen = this.onWsOpen.bind(this);
-    this.onChildError = this.onChildError.bind(this);
-    this.onWsPacket = this.onWsPacket.bind(this);
-    this.onWsClose = this.onWsClose.bind(this);
-    this.onWsDebug = this.onWsDebug.bind(this);
-    this.onUdpDebug = this.onUdpDebug.bind(this);
-    this.onUdpClose = this.onUdpClose.bind(this);
-    this.debug = debug ? (message) => this.emit("debug", message) : null;
-    this._state = {
-      code: 0 /* OpeningWs */,
-      ws: this.createWebSocket(options.endpoint),
-      connectionOptions: options
-    };
-  }
+  remote;
   /**
-   * Destroys the Networking instance, transitioning it into the Closed state.
+   * The counter used in the keep alive mechanism.
    */
-  destroy() {
-    this.state = {
-      code: 6 /* Closed */
-    };
-  }
+  keepAliveCounter = 0;
   /**
-   * The current state of the networking instance.
+   * The buffer used to write the keep alive counter into.
    */
-  get state() {
-    return this._state;
-  }
+  keepAliveBuffer;
   /**
-   * Sets a new state for the networking instance, performing clean-up operations where necessary.
+   * The Node.js interval for the keep-alive mechanism.
    */
-  set state(newState) {
-    const oldWs = Reflect.get(this._state, "ws");
-    const newWs = Reflect.get(newState, "ws");
-    if (oldWs && oldWs !== newWs) {
-      oldWs.off("debug", this.onWsDebug);
-      oldWs.on("error", noop);
-      oldWs.off("error", this.onChildError);
-      oldWs.off("open", this.onWsOpen);
-      oldWs.off("packet", this.onWsPacket);
-      oldWs.off("close", this.onWsClose);
-      oldWs.destroy();
-    }
-    const oldUdp = Reflect.get(this._state, "udp");
-    const newUdp = Reflect.get(newState, "udp");
-    if (oldUdp && oldUdp !== newUdp) {
-      oldUdp.on("error", noop);
-      oldUdp.off("error", this.onChildError);
-      oldUdp.off("close", this.onUdpClose);
-      oldUdp.off("debug", this.onUdpDebug);
-      oldUdp.destroy();
-    }
-    const oldState = this._state;
-    this._state = newState;
-    this.emit("stateChange", oldState, newState);
-    this.debug?.(`state change:
-from ${stringifyState(oldState)}
-to ${stringifyState(newState)}`);
-  }
+  keepAliveInterval;
   /**
-   * Creates a new WebSocket to a Discord Voice gateway.
+   * The time taken to receive a response to keep alive messages.
    *
-   * @param endpoint - The endpoint to connect to
+   * @deprecated This field is no longer updated as keep alive messages are no longer tracked.
    */
-  createWebSocket(endpoint) {
-    const ws = new VoiceWebSocket(`wss://${endpoint}?v=4`, Boolean(this.debug));
-    ws.on("error", this.onChildError);
-    ws.once("open", this.onWsOpen);
-    ws.on("packet", this.onWsPacket);
-    ws.once("close", this.onWsClose);
-    ws.on("debug", this.onWsDebug);
-    return ws;
-  }
+  ping;
   /**
-   * Propagates errors from the children VoiceWebSocket and VoiceUDPSocket.
+   * Creates a new VoiceUDPSocket.
    *
-   * @param error - The error that was emitted by a child
-   */
-  onChildError(error) {
-    this.emit("error", error);
-  }
-  /**
-   * Called when the WebSocket opens. Depending on the state that the instance is in,
-   * it will either identify with a new session, or it will attempt to resume an existing session.
+   * @param remote - Details of the remote socket
    */
-  onWsOpen() {
-    if (this.state.code === 0 /* OpeningWs */) {
-      const packet = {
-        op: VoiceOpcodes2.Identify,
-        d: {
-          server_id: this.state.connectionOptions.serverId,
-          user_id: this.state.connectionOptions.userId,
-          session_id: this.state.connectionOptions.sessionId,
-          token: this.state.connectionOptions.token
-        }
-      };
-      this.state.ws.sendPacket(packet);
-      this.state = {
-        ...this.state,
-        code: 1 /* Identifying */
-      };
-    } else if (this.state.code === 5 /* Resuming */) {
-      const packet = {
-        op: VoiceOpcodes2.Resume,
-        d: {
-          server_id: this.state.connectionOptions.serverId,
-          session_id: this.state.connectionOptions.sessionId,
-          token: this.state.connectionOptions.token
-        }
-      };
-      this.state.ws.sendPacket(packet);
-    }
+  constructor(remote) {
+    super();
+    this.socket = createSocket("udp4");
+    this.socket.on("error", (error) => this.emit("error", error));
+    this.socket.on("message", (buffer) => this.onMessage(buffer));
+    this.socket.on("close", () => this.emit("close"));
+    this.remote = remote;
+    this.keepAliveBuffer = Buffer5.alloc(8);
+    this.keepAliveInterval = setInterval(() => this.keepAlive(), KEEP_ALIVE_INTERVAL);
+    setImmediate(() => this.keepAlive());
   }
   /**
-   * Called when the WebSocket closes. Based on the reason for closing (given by the code parameter),
-   * the instance will either attempt to resume, or enter the closed state and emit a 'close' event
-   * with the close code, allowing the user to decide whether or not they would like to reconnect.
+   * Called when a message is received on the UDP socket.
    *
-   * @param code - The close code
+   * @param buffer - The received buffer
    */
-  onWsClose({ code }) {
-    const canResume = code === 4015 || code < 4e3;
-    if (canResume && this.state.code === 4 /* Ready */) {
-      this.state = {
-        ...this.state,
-        code: 5 /* Resuming */,
-        ws: this.createWebSocket(this.state.connectionOptions.endpoint)
-      };
-    } else if (this.state.code !== 6 /* Closed */) {
-      this.destroy();
-      this.emit("close", code);
-    }
+  onMessage(buffer) {
+    this.emit("message", buffer);
   }
   /**
-   * Called when the UDP socket has closed itself if it has stopped receiving replies from Discord.
+   * Called at a regular interval to check whether we are still able to send datagrams to Discord.
    */
-  onUdpClose() {
-    if (this.state.code === 4 /* Ready */) {
-      this.state = {
-        ...this.state,
-        code: 5 /* Resuming */,
-        ws: this.createWebSocket(this.state.connectionOptions.endpoint)
-      };
+  keepAlive() {
+    this.keepAliveBuffer.writeUInt32LE(this.keepAliveCounter, 0);
+    this.send(this.keepAliveBuffer);
+    this.keepAliveCounter++;
+    if (this.keepAliveCounter > MAX_COUNTER_VALUE) {
+      this.keepAliveCounter = 0;
     }
   }
   /**
-   * Called when a packet is received on the connection's WebSocket.
+   * Sends a buffer to Discord.
    *
-   * @param packet - The received packet
+   * @param buffer - The buffer to send
    */
-  onWsPacket(packet) {
-    if (packet.op === VoiceOpcodes2.Hello && this.state.code !== 6 /* Closed */) {
-      this.state.ws.setHeartbeatInterval(packet.d.heartbeat_interval);
-    } else if (packet.op === VoiceOpcodes2.Ready && this.state.code === 1 /* Identifying */) {
-      const { ip, port, ssrc, modes } = packet.d;
-      const udp = new VoiceUDPSocket({ ip, port });
-      udp.on("error", this.onChildError);
-      udp.on("debug", this.onUdpDebug);
-      udp.once("close", this.onUdpClose);
-      udp.performIPDiscovery(ssrc).then((localConfig) => {
-        if (this.state.code !== 2 /* UdpHandshaking */) return;
-        this.state.ws.sendPacket({
-          op: VoiceOpcodes2.SelectProtocol,
-          d: {
-            protocol: "udp",
-            data: {
-              address: localConfig.ip,
-              port: localConfig.port,
-              mode: chooseEncryptionMode(modes)
-            }
-          }
-        });
-        this.state = {
-          ...this.state,
-          code: 3 /* SelectingProtocol */
-        };
-      }).catch((error) => this.emit("error", error));
-      this.state = {
-        ...this.state,
-        code: 2 /* UdpHandshaking */,
-        udp,
-        connectionData: {
-          ssrc
-        }
-      };
-    } else if (packet.op === VoiceOpcodes2.SessionDescription && this.state.code === 3 /* SelectingProtocol */) {
-      const { mode: encryptionMode, secret_key: secretKey } = packet.d;
-      this.state = {
-        ...this.state,
-        code: 4 /* Ready */,
-        connectionData: {
-          ...this.state.connectionData,
-          encryptionMode,
-          secretKey: new Uint8Array(secretKey),
-          sequence: randomNBit(16),
-          timestamp: randomNBit(32),
-          nonce: 0,
-          nonceBuffer: encryptionMode === "aead_aes256_gcm_rtpsize" ? Buffer4.alloc(12) : Buffer4.alloc(24),
-          speaking: false,
-          packetsPlayed: 0
-        }
-      };
-    } else if (packet.op === VoiceOpcodes2.Resumed && this.state.code === 5 /* Resuming */) {
-      this.state = {
-        ...this.state,
-        code: 4 /* Ready */
-      };
-      this.state.connectionData.speaking = false;
-    }
+  send(buffer) {
+    this.socket.send(buffer, this.remote.port, this.remote.ip);
   }
   /**
-   * Propagates debug messages from the child WebSocket.
-   *
-   * @param message - The emitted debug message
+   * Closes the socket, the instance will not be able to be reused.
    */
-  onWsDebug(message) {
-    this.debug?.(`[WS] ${message}`);
+  destroy() {
+    try {
+      this.socket.close();
+    } catch {
+    }
+    clearInterval(this.keepAliveInterval);
   }
   /**
-   * Propagates debug messages from the child UDPSocket.
+   * Performs IP discovery to discover the local address and port to be used for the voice connection.
    *
-   * @param message - The emitted debug message
+   * @param ssrc - The SSRC received from Discord
    */
-  onUdpDebug(message) {
-    this.debug?.(`[UDP] ${message}`);
+  async performIPDiscovery(ssrc) {
+    return new Promise((resolve2, reject) => {
+      const listener = /* @__PURE__ */ __name((message) => {
+        try {
+          if (message.readUInt16BE(0) !== 2) return;
+          const packet = parseLocalPacket(message);
+          this.socket.off("message", listener);
+          resolve2(packet);
+        } catch {
+        }
+      }, "listener");
+      this.socket.on("message", listener);
+      this.socket.once("close", () => reject(new Error("Cannot perform IP discovery - socket closed")));
+      const discoveryBuffer = Buffer5.alloc(74);
+      discoveryBuffer.writeUInt16BE(1, 0);
+      discoveryBuffer.writeUInt16BE(70, 2);
+      discoveryBuffer.writeUInt32BE(ssrc, 4);
+      this.send(discoveryBuffer);
+    });
+  }
+};
+
+// src/networking/VoiceWebSocket.ts
+import { Buffer as Buffer6 } from "buffer";
+import { EventEmitter as EventEmitter4 } from "events";
+import { VoiceOpcodes } from "discord-api-types/voice/v8";
+import WebSocket from "ws";
+var VoiceWebSocket = class extends EventEmitter4 {
+  static {
+    __name(this, "VoiceWebSocket");
   }
   /**
-   * Prepares an Opus packet for playback. This includes attaching metadata to it and encrypting it.
-   * It will be stored within the instance, and can be played by dispatchAudio()
-   *
-   * @remarks
-   * Calling this method while there is already a prepared audio packet that has not yet been dispatched
-   * will overwrite the existing audio packet. This should be avoided.
-   * @param opusPacket - The Opus packet to encrypt
-   * @returns The audio packet that was prepared
+   * The current heartbeat interval, if any.
    */
-  prepareAudioPacket(opusPacket) {
-    const state = this.state;
-    if (state.code !== 4 /* Ready */) return;
-    state.preparedPacket = this.createAudioPacket(opusPacket, state.connectionData);
-    return state.preparedPacket;
-  }
+  heartbeatInterval;
   /**
-   * Dispatches the audio packet previously prepared by prepareAudioPacket(opusPacket). The audio packet
-   * is consumed and cannot be dispatched again.
+   * The time (milliseconds since UNIX epoch) that the last heartbeat acknowledgement packet was received.
+   * This is set to 0 if an acknowledgement packet hasn't been received yet.
    */
-  dispatchAudio() {
-    const state = this.state;
-    if (state.code !== 4 /* Ready */) return false;
-    if (state.preparedPacket !== void 0) {
-      this.playAudioPacket(state.preparedPacket);
-      state.preparedPacket = void 0;
-      return true;
-    }
-    return false;
-  }
+  lastHeartbeatAck;
   /**
-   * Plays an audio packet, updating timing metadata used for playback.
-   *
-   * @param audioPacket - The audio packet to play
+   * The time (milliseconds since UNIX epoch) that the last heartbeat was sent. This is set to 0 if a heartbeat
+   * hasn't been sent yet.
    */
-  playAudioPacket(audioPacket) {
-    const state = this.state;
-    if (state.code !== 4 /* Ready */) return;
-    const { connectionData } = state;
-    connectionData.packetsPlayed++;
-    connectionData.sequence++;
-    connectionData.timestamp += TIMESTAMP_INC;
-    if (connectionData.sequence >= 2 ** 16) connectionData.sequence = 0;
-    if (connectionData.timestamp >= 2 ** 32) connectionData.timestamp = 0;
-    this.setSpeaking(true);
-    state.udp.send(audioPacket);
-  }
+  lastHeartbeatSend;
   /**
-   * Sends a packet to the voice gateway indicating that the client has start/stopped sending
-   * audio.
+   * The number of consecutively missed heartbeats.
+   */
+  missedHeartbeats = 0;
+  /**
+   * The last recorded ping.
+   */
+  ping;
+  /**
+   * The last sequence number acknowledged from Discord. Will be `-1` if no sequence numbered messages have been received.
+   */
+  sequence = -1;
+  /**
+   * The debug logger function, if debugging is enabled.
+   */
+  debug;
+  /**
+   * The underlying WebSocket of this wrapper.
+   */
+  ws;
+  /**
+   * Creates a new VoiceWebSocket.
    *
-   * @param speaking - Whether or not the client should be shown as speaking
+   * @param address - The address to connect to
    */
-  setSpeaking(speaking) {
-    const state = this.state;
-    if (state.code !== 4 /* Ready */) return;
-    if (state.connectionData.speaking === speaking) return;
-    state.connectionData.speaking = speaking;
-    state.ws.sendPacket({
-      op: VoiceOpcodes2.Speaking,
-      d: {
-        speaking: speaking ? 1 : 0,
-        delay: 0,
-        ssrc: state.connectionData.ssrc
-      }
-    });
+  constructor(address, debug) {
+    super();
+    this.ws = new WebSocket(address);
+    this.ws.onmessage = (err) => this.onMessage(err);
+    this.ws.onopen = (err) => this.emit("open", err);
+    this.ws.onerror = (err) => this.emit("error", err instanceof Error ? err : err.error);
+    this.ws.onclose = (err) => this.emit("close", err);
+    this.lastHeartbeatAck = 0;
+    this.lastHeartbeatSend = 0;
+    this.debug = debug ? (message) => this.emit("debug", message) : null;
   }
   /**
-   * Creates a new audio packet from an Opus packet. This involves encrypting the packet,
-   * then prepending a header that includes metadata.
-   *
-   * @param opusPacket - The Opus packet to prepare
-   * @param connectionData - The current connection data of the instance
+   * Destroys the VoiceWebSocket. The heartbeat interval is cleared, and the connection is closed.
    */
-  createAudioPacket(opusPacket, connectionData) {
-    const rtpHeader = Buffer4.alloc(12);
-    rtpHeader[0] = 128;
-    rtpHeader[1] = 120;
-    const { sequence, timestamp, ssrc } = connectionData;
-    rtpHeader.writeUIntBE(sequence, 2, 2);
-    rtpHeader.writeUIntBE(timestamp, 4, 4);
-    rtpHeader.writeUIntBE(ssrc, 8, 4);
-    rtpHeader.copy(nonce, 0, 0, 12);
-    return Buffer4.concat([rtpHeader, ...this.encryptOpusPacket(opusPacket, connectionData, rtpHeader)]);
+  destroy() {
+    try {
+      this.debug?.("destroyed");
+      this.setHeartbeatInterval(-1);
+      this.ws.close(1e3);
+    } catch (error) {
+      const err = error;
+      this.emit("error", err);
+    }
   }
   /**
-   * Encrypts an Opus packet using the format agreed upon by the instance and Discord.
+   * Handles message events on the WebSocket. Attempts to JSON parse the messages and emit them
+   * as packets. Binary messages will be parsed and emitted.
    *
-   * @param opusPacket - The Opus packet to encrypt
-   * @param connectionData - The current connection data of the instance
+   * @param event - The message event
    */
-  encryptOpusPacket(opusPacket, connectionData, additionalData) {
-    const { secretKey, encryptionMode } = connectionData;
-    connectionData.nonce++;
-    if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;
-    connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);
-    const noncePadding = connectionData.nonceBuffer.subarray(0, 4);
-    let encrypted;
-    switch (encryptionMode) {
-      case "aead_aes256_gcm_rtpsize": {
-        const cipher = crypto.createCipheriv("aes-256-gcm", secretKey, connectionData.nonceBuffer);
-        cipher.setAAD(additionalData);
-        encrypted = Buffer4.concat([cipher.update(opusPacket), cipher.final(), cipher.getAuthTag()]);
-        return [encrypted, noncePadding];
-      }
-      case "aead_xchacha20_poly1305_rtpsize": {
-        encrypted = methods.crypto_aead_xchacha20poly1305_ietf_encrypt(
-          opusPacket,
-          additionalData,
-          connectionData.nonceBuffer,
-          secretKey
-        );
-        return [encrypted, noncePadding];
-      }
-      default: {
-        throw new RangeError(`Unsupported encryption method: ${encryptionMode}`);
-      }
+  onMessage(event) {
+    if (event.data instanceof Buffer6 || event.data instanceof ArrayBuffer) {
+      const buffer = event.data instanceof ArrayBuffer ? Buffer6.from(event.data) : event.data;
+      const seq = buffer.readUInt16BE(0);
+      const op = buffer.readUInt8(2);
+      const payload = buffer.subarray(3);
+      this.sequence = seq;
+      this.debug?.(`<< [bin] opcode ${op}, seq ${seq}, ${payload.byteLength} bytes`);
+      this.emit("binary", { op, seq, payload });
+      return;
+    } else if (typeof event.data !== "string") {
+      return;
     }
-  }
-};
-
-// src/receive/VoiceReceiver.ts
-import { Buffer as Buffer6 } from "node:buffer";
-import crypto2 from "node:crypto";
-import { VoiceOpcodes as VoiceOpcodes3 } from "discord-api-types/voice/v4";
-
-// src/receive/AudioReceiveStream.ts
-import { Readable } from "node:stream";
-
-// src/audio/AudioPlayer.ts
-import { Buffer as Buffer5 } from "node:buffer";
-import { EventEmitter as EventEmitter4 } from "node:events";
-
-// src/audio/AudioPlayerError.ts
-var AudioPlayerError = class extends Error {
-  static {
-    __name(this, "AudioPlayerError");
+    this.debug?.(`<< ${event.data}`);
+    let packet;
+    try {
+      packet = JSON.parse(event.data);
+    } catch (error) {
+      const err = error;
+      this.emit("error", err);
+      return;
+    }
+    if (packet.seq) {
+      this.sequence = packet.seq;
+    }
+    if (packet.op === VoiceOpcodes.HeartbeatAck) {
+      this.lastHeartbeatAck = Date.now();
+      this.missedHeartbeats = 0;
+      this.ping = this.lastHeartbeatAck - this.lastHeartbeatSend;
+    }
+    this.emit("packet", packet);
   }
   /**
-   * The resource associated with the audio player at the time the error was thrown.
+   * Sends a JSON-stringifiable packet over the WebSocket.
+   *
+   * @param packet - The packet to send
    */
-  resource;
-  constructor(error, resource) {
-    super(error.message);
-    this.resource = resource;
-    this.name = error.name;
-    this.stack = error.stack;
-  }
-};
-
-// src/audio/PlayerSubscription.ts
-var PlayerSubscription = class {
-  static {
-    __name(this, "PlayerSubscription");
+  sendPacket(packet) {
+    try {
+      const stringified = JSON.stringify(packet);
+      this.debug?.(`>> ${stringified}`);
+      this.ws.send(stringified);
+    } catch (error) {
+      const err = error;
+      this.emit("error", err);
+    }
   }
   /**
-   * The voice connection of this subscription.
+   * Sends a binary message over the WebSocket.
+   *
+   * @param opcode - The opcode to use
+   * @param payload - The payload to send
    */
-  connection;
+  sendBinaryMessage(opcode, payload) {
+    try {
+      const message = Buffer6.concat([new Uint8Array([opcode]), payload]);
+      this.debug?.(`>> [bin] opcode ${opcode}, ${payload.byteLength} bytes`);
+      this.ws.send(message);
+    } catch (error) {
+      const err = error;
+      this.emit("error", err);
+    }
+  }
   /**
-   * The audio player of this subscription.
+   * Sends a heartbeat over the WebSocket.
    */
-  player;
-  constructor(connection, player) {
-    this.connection = connection;
-    this.player = player;
+  sendHeartbeat() {
+    this.lastHeartbeatSend = Date.now();
+    this.missedHeartbeats++;
+    const nonce2 = this.lastHeartbeatSend;
+    this.sendPacket({
+      op: VoiceOpcodes.Heartbeat,
+      // eslint-disable-next-line id-length
+      d: {
+        // eslint-disable-next-line id-length
+        t: nonce2,
+        seq_ack: this.sequence
+      }
+    });
   }
   /**
-   * Unsubscribes the connection from the audio player, meaning that the
-   * audio player cannot stream audio to it until a new subscription is made.
+   * Sets/clears an interval to send heartbeats over the WebSocket.
+   *
+   * @param ms - The interval in milliseconds. If negative, the interval will be unset
    */
-  unsubscribe() {
-    this.connection["onSubscriptionRemoved"](this);
-    this.player["unsubscribe"](this);
+  setHeartbeatInterval(ms) {
+    if (this.heartbeatInterval !== void 0) clearInterval(this.heartbeatInterval);
+    if (ms > 0) {
+      this.heartbeatInterval = setInterval(() => {
+        if (this.lastHeartbeatSend !== 0 && this.missedHeartbeats >= 3) {
+          this.ws.close();
+          this.setHeartbeatInterval(-1);
+        }
+        this.sendHeartbeat();
+      }, ms);
+    }
   }
 };
 
-// src/audio/AudioPlayer.ts
-var SILENCE_FRAME = Buffer5.from([248, 255, 254]);
-var NoSubscriberBehavior = /* @__PURE__ */ ((NoSubscriberBehavior2) => {
-  NoSubscriberBehavior2["Pause"] = "pause";
-  NoSubscriberBehavior2["Play"] = "play";
-  NoSubscriberBehavior2["Stop"] = "stop";
-  return NoSubscriberBehavior2;
-})(NoSubscriberBehavior || {});
-var AudioPlayerStatus = /* @__PURE__ */ ((AudioPlayerStatus2) => {
-  AudioPlayerStatus2["AutoPaused"] = "autopaused";
-  AudioPlayerStatus2["Buffering"] = "buffering";
-  AudioPlayerStatus2["Idle"] = "idle";
-  AudioPlayerStatus2["Paused"] = "paused";
-  AudioPlayerStatus2["Playing"] = "playing";
-  return AudioPlayerStatus2;
-})(AudioPlayerStatus || {});
+// src/networking/Networking.ts
+var CHANNELS = 2;
+var TIMESTAMP_INC = 48e3 / 100 * CHANNELS;
+var MAX_NONCE_SIZE = 2 ** 32 - 1;
+var SUPPORTED_ENCRYPTION_MODES = [VoiceEncryptionMode.AeadXChaCha20Poly1305RtpSize];
+if (crypto.getCiphers().includes("aes-256-gcm")) {
+  SUPPORTED_ENCRYPTION_MODES.unshift(VoiceEncryptionMode.AeadAes256GcmRtpSize);
+}
+var NetworkingStatusCode = /* @__PURE__ */ ((NetworkingStatusCode2) => {
+  NetworkingStatusCode2[NetworkingStatusCode2["OpeningWs"] = 0] = "OpeningWs";
+  NetworkingStatusCode2[NetworkingStatusCode2["Identifying"] = 1] = "Identifying";
+  NetworkingStatusCode2[NetworkingStatusCode2["UdpHandshaking"] = 2] = "UdpHandshaking";
+  NetworkingStatusCode2[NetworkingStatusCode2["SelectingProtocol"] = 3] = "SelectingProtocol";
+  NetworkingStatusCode2[NetworkingStatusCode2["Ready"] = 4] = "Ready";
+  NetworkingStatusCode2[NetworkingStatusCode2["Resuming"] = 5] = "Resuming";
+  NetworkingStatusCode2[NetworkingStatusCode2["Closed"] = 6] = "Closed";
+  return NetworkingStatusCode2;
+})(NetworkingStatusCode || {});
+var nonce = Buffer7.alloc(24);
 function stringifyState2(state) {
   return JSON.stringify({
     ...state,
-    resource: Reflect.has(state, "resource"),
-    stepTimeout: Reflect.has(state, "stepTimeout")
+    ws: Reflect.has(state, "ws"),
+    udp: Reflect.has(state, "udp")
   });
 }
 __name(stringifyState2, "stringifyState");
-var AudioPlayer = class extends EventEmitter4 {
+function chooseEncryptionMode(options) {
+  const option = options.find((option2) => SUPPORTED_ENCRYPTION_MODES.includes(option2));
+  if (!option) {
+    throw new Error(`No compatible encryption modes. Available include: ${options.join(", ")}`);
+  }
+  return option;
+}
+__name(chooseEncryptionMode, "chooseEncryptionMode");
+function randomNBit(numberOfBits) {
+  return Math.floor(Math.random() * 2 ** numberOfBits);
+}
+__name(randomNBit, "randomNBit");
+var Networking = class extends EventEmitter5 {
   static {
-    __name(this, "AudioPlayer");
+    __name(this, "Networking");
   }
-  /**
-   * The state that the AudioPlayer is in.
-   */
   _state;
   /**
-   * A list of VoiceConnections that are registered to this AudioPlayer. The player will attempt to play audio
-   * to the streams in this list.
+   * The debug logger function, if debugging is enabled.
    */
-  subscribers = [];
+  debug;
   /**
-   * The behavior that the player should follow when it enters certain situations.
+   * The options used to create this Networking instance.
    */
-  behaviors;
+  options;
   /**
-   * The debug logger function, if debugging is enabled.
+   * Creates a new Networking instance.
    */
-  debug;
+  constructor(connectionOptions, options) {
+    super();
+    this.onWsOpen = this.onWsOpen.bind(this);
+    this.onChildError = this.onChildError.bind(this);
+    this.onWsPacket = this.onWsPacket.bind(this);
+    this.onWsBinary = this.onWsBinary.bind(this);
+    this.onWsClose = this.onWsClose.bind(this);
+    this.onWsDebug = this.onWsDebug.bind(this);
+    this.onUdpDebug = this.onUdpDebug.bind(this);
+    this.onUdpClose = this.onUdpClose.bind(this);
+    this.onDaveDebug = this.onDaveDebug.bind(this);
+    this.onDaveKeyPackage = this.onDaveKeyPackage.bind(this);
+    this.onDaveInvalidateTransition = this.onDaveInvalidateTransition.bind(this);
+    this.debug = options?.debug ? (message) => this.emit("debug", message) : null;
+    this._state = {
+      code: 0 /* OpeningWs */,
+      ws: this.createWebSocket(connectionOptions.endpoint),
+      connectionOptions
+    };
+    this.options = options;
+  }
   /**
-   * Creates a new AudioPlayer.
+   * Destroys the Networking instance, transitioning it into the Closed state.
    */
-  constructor(options = {}) {
-    super();
-    this._state = { status: "idle" /* Idle */ };
-    this.behaviors = {
-      noSubscriber: "pause" /* Pause */,
-      maxMissedFrames: 5,
-      ...options.behaviors
+  destroy() {
+    this.state = {
+      code: 6 /* Closed */
     };
-    this.debug = options.debug === false ? null : (message) => this.emit("debug", message);
   }
   /**
-   * A list of subscribed voice connections that can currently receive audio to play.
+   * The current state of the networking instance.
+   *
+   * @remarks
+   * The setter will perform clean-up operations where necessary.
    */
-  get playable() {
-    return this.subscribers.filter(({ connection }) => connection.state.status === "ready" /* Ready */).map(({ connection }) => connection);
+  get state() {
+    return this._state;
+  }
+  set state(newState) {
+    const oldWs = Reflect.get(this._state, "ws");
+    const newWs = Reflect.get(newState, "ws");
+    if (oldWs && oldWs !== newWs) {
+      oldWs.off("debug", this.onWsDebug);
+      oldWs.on("error", noop);
+      oldWs.off("error", this.onChildError);
+      oldWs.off("open", this.onWsOpen);
+      oldWs.off("packet", this.onWsPacket);
+      oldWs.off("binary", this.onWsBinary);
+      oldWs.off("close", this.onWsClose);
+      oldWs.destroy();
+    }
+    const oldUdp = Reflect.get(this._state, "udp");
+    const newUdp = Reflect.get(newState, "udp");
+    if (oldUdp && oldUdp !== newUdp) {
+      oldUdp.on("error", noop);
+      oldUdp.off("error", this.onChildError);
+      oldUdp.off("close", this.onUdpClose);
+      oldUdp.off("debug", this.onUdpDebug);
+      oldUdp.destroy();
+    }
+    const oldDave = Reflect.get(this._state, "dave");
+    const newDave = Reflect.get(newState, "dave");
+    if (oldDave && oldDave !== newDave) {
+      oldDave.off("error", this.onChildError);
+      oldDave.off("debug", this.onDaveDebug);
+      oldDave.off("keyPackage", this.onDaveKeyPackage);
+      oldDave.off("invalidateTransition", this.onDaveInvalidateTransition);
+      oldDave.destroy();
+    }
+    const oldState = this._state;
+    this._state = newState;
+    this.emit("stateChange", oldState, newState);
+    this.debug?.(`state change:
+from ${stringifyState2(oldState)}
+to ${stringifyState2(newState)}`);
+  }
+  /**
+   * Creates a new WebSocket to a Discord Voice gateway.
+   *
+   * @param endpoint - The endpoint to connect to
+   * @param lastSequence - The last sequence to set for this WebSocket
+   */
+  createWebSocket(endpoint, lastSequence) {
+    const ws = new VoiceWebSocket(`wss://${endpoint}?v=8`, Boolean(this.debug));
+    if (lastSequence !== void 0) {
+      ws.sequence = lastSequence;
+    }
+    ws.on("error", this.onChildError);
+    ws.once("open", this.onWsOpen);
+    ws.on("packet", this.onWsPacket);
+    ws.on("binary", this.onWsBinary);
+    ws.once("close", this.onWsClose);
+    ws.on("debug", this.onWsDebug);
+    return ws;
   }
   /**
-   * Subscribes a VoiceConnection to the audio player's play list. If the VoiceConnection is already subscribed,
-   * then the existing subscription is used.
+   * Creates a new DAVE session for this voice connection if we can create one.
    *
-   * @remarks
-   * This method should not be directly called. Instead, use VoiceConnection#subscribe.
-   * @param connection - The connection to subscribe
-   * @returns The new subscription if the voice connection is not yet subscribed, otherwise the existing subscription
+   * @param protocolVersion - The protocol version to use
    */
-  // @ts-ignore
-  subscribe(connection) {
-    const existingSubscription = this.subscribers.find((subscription) => subscription.connection === connection);
-    if (!existingSubscription) {
-      const subscription = new PlayerSubscription(connection, this);
-      this.subscribers.push(subscription);
-      setImmediate(() => this.emit("subscribe", subscription));
-      return subscription;
+  createDaveSession(protocolVersion) {
+    if (getMaxProtocolVersion() === null || this.options.daveEncryption === false || this.state.code !== 3 /* SelectingProtocol */ && this.state.code !== 4 /* Ready */ && this.state.code !== 5 /* Resuming */) {
+      return;
     }
-    return existingSubscription;
+    const session = new DAVESession(
+      protocolVersion,
+      this.state.connectionOptions.userId,
+      this.state.connectionOptions.channelId,
+      {
+        decryptionFailureTolerance: this.options.decryptionFailureTolerance
+      }
+    );
+    session.on("error", this.onChildError);
+    session.on("debug", this.onDaveDebug);
+    session.on("keyPackage", this.onDaveKeyPackage);
+    session.on("invalidateTransition", this.onDaveInvalidateTransition);
+    session.reinit();
+    return session;
   }
   /**
-   * Unsubscribes a subscription - i.e. removes a voice connection from the play list of the audio player.
+   * Propagates errors from the children VoiceWebSocket, VoiceUDPSocket and DAVESession.
    *
-   * @remarks
-   * This method should not be directly called. Instead, use PlayerSubscription#unsubscribe.
-   * @param subscription - The subscription to remove
-   * @returns Whether or not the subscription existed on the player and was removed
+   * @param error - The error that was emitted by a child
    */
-  // @ts-ignore
-  unsubscribe(subscription) {
-    const index = this.subscribers.indexOf(subscription);
-    const exists = index !== -1;
-    if (exists) {
-      this.subscribers.splice(index, 1);
-      subscription.connection.setSpeaking(false);
-      this.emit("unsubscribe", subscription);
-    }
-    return exists;
+  onChildError(error) {
+    this.emit("error", error);
   }
   /**
-   * The state that the player is in.
+   * Called when the WebSocket opens. Depending on the state that the instance is in,
+   * it will either identify with a new session, or it will attempt to resume an existing session.
    */
-  get state() {
-    return this._state;
+  onWsOpen() {
+    if (this.state.code === 0 /* OpeningWs */) {
+      this.state.ws.sendPacket({
+        op: VoiceOpcodes2.Identify,
+        d: {
+          server_id: this.state.connectionOptions.serverId,
+          user_id: this.state.connectionOptions.userId,
+          session_id: this.state.connectionOptions.sessionId,
+          token: this.state.connectionOptions.token,
+          max_dave_protocol_version: this.options.daveEncryption === false ? 0 : getMaxProtocolVersion() ?? 0
+        }
+      });
+      this.state = {
+        ...this.state,
+        code: 1 /* Identifying */
+      };
+    } else if (this.state.code === 5 /* Resuming */) {
+      this.state.ws.sendPacket({
+        op: VoiceOpcodes2.Resume,
+        d: {
+          server_id: this.state.connectionOptions.serverId,
+          session_id: this.state.connectionOptions.sessionId,
+          token: this.state.connectionOptions.token,
+          seq_ack: this.state.ws.sequence
+        }
+      });
+    }
   }
   /**
-   * Sets a new state for the player, performing clean-up operations where necessary.
+   * Called when the WebSocket closes. Based on the reason for closing (given by the code parameter),
+   * the instance will either attempt to resume, or enter the closed state and emit a 'close' event
+   * with the close code, allowing the user to decide whether or not they would like to reconnect.
+   *
+   * @param code - The close code
    */
-  set state(newState) {
-    const oldState = this._state;
-    const newResource = Reflect.get(newState, "resource");
-    if (oldState.status !== "idle" /* Idle */ && oldState.resource !== newResource) {
-      oldState.resource.playStream.on("error", noop);
-      oldState.resource.playStream.off("error", oldState.onStreamError);
-      oldState.resource.audioPlayer = void 0;
-      oldState.resource.playStream.destroy();
-      oldState.resource.playStream.read();
-    }
-    if (oldState.status === "buffering" /* Buffering */ && (newState.status !== "buffering" /* Buffering */ || newState.resource !== oldState.resource)) {
-      oldState.resource.playStream.off("end", oldState.onFailureCallback);
-      oldState.resource.playStream.off("close", oldState.onFailureCallback);
-      oldState.resource.playStream.off("finish", oldState.onFailureCallback);
-      oldState.resource.playStream.off("readable", oldState.onReadableCallback);
-    }
-    if (newState.status === "idle" /* Idle */) {
-      this._signalStopSpeaking();
-      deleteAudioPlayer(this);
-    }
-    if (newResource) {
-      addAudioPlayer(this);
+  onWsClose({ code }) {
+    const canResume = code === 4015 || code < 4e3;
+    if (canResume && this.state.code === 4 /* Ready */) {
+      const lastSequence = this.state.ws.sequence;
+      this.state = {
+        ...this.state,
+        code: 5 /* Resuming */,
+        ws: this.createWebSocket(this.state.connectionOptions.endpoint, lastSequence)
+      };
+    } else if (this.state.code !== 6 /* Closed */) {
+      this.destroy();
+      this.emit("close", code);
     }
-    const didChangeResources = oldState.status !== "idle" /* Idle */ && newState.status === "playing" /* Playing */ && oldState.resource !== newState.resource;
-    this._state = newState;
-    this.emit("stateChange", oldState, this._state);
-    if (oldState.status !== newState.status || didChangeResources) {
-      this.emit(newState.status, oldState, this._state);
+  }
+  /**
+   * Called when the UDP socket has closed itself if it has stopped receiving replies from Discord.
+   */
+  onUdpClose() {
+    if (this.state.code === 4 /* Ready */) {
+      const lastSequence = this.state.ws.sequence;
+      this.state = {
+        ...this.state,
+        code: 5 /* Resuming */,
+        ws: this.createWebSocket(this.state.connectionOptions.endpoint, lastSequence)
+      };
     }
-    this.debug?.(`state change:
-from ${stringifyState2(oldState)}
-to ${stringifyState2(newState)}`);
   }
   /**
-   * Plays a new resource on the player. If the player is already playing a resource, the existing resource is destroyed
-   * (it cannot be reused, even in another player) and is replaced with the new resource.
-   *
-   * @remarks
-   * The player will transition to the Playing state once playback begins, and will return to the Idle state once
-   * playback is ended.
+   * Called when a packet is received on the connection's WebSocket.
    *
-   * If the player was previously playing a resource and this method is called, the player will not transition to the
-   * Idle state during the swap over.
-   * @param resource - The resource to play
-   * @throws Will throw if attempting to play an audio resource that has already ended, or is being played by another player
+   * @param packet - The received packet
    */
-  play(resource) {
-    if (resource.ended) {
-      throw new Error("Cannot play a resource that has already ended.");
-    }
-    if (resource.audioPlayer) {
-      if (resource.audioPlayer === this) {
-        return;
-      }
-      throw new Error("Resource is already being played by another audio player.");
-    }
-    resource.audioPlayer = this;
-    const onStreamError = /* @__PURE__ */ __name((error) => {
-      if (this.state.status !== "idle" /* Idle */) {
-        this.emit("error", new AudioPlayerError(error, this.state.resource));
-      }
-      if (this.state.status !== "idle" /* Idle */ && this.state.resource === resource) {
+  onWsPacket(packet) {
+    if (packet.op === VoiceOpcodes2.Hello && this.state.code !== 6 /* Closed */) {
+      this.state.ws.setHeartbeatInterval(packet.d.heartbeat_interval);
+    } else if (packet.op === VoiceOpcodes2.Ready && this.state.code === 1 /* Identifying */) {
+      const { ip, port, ssrc, modes } = packet.d;
+      const udp = new VoiceUDPSocket({ ip, port });
+      udp.on("error", this.onChildError);
+      udp.on("debug", this.onUdpDebug);
+      udp.once("close", this.onUdpClose);
+      udp.performIPDiscovery(ssrc).then((localConfig) => {
+        if (this.state.code !== 2 /* UdpHandshaking */) return;
+        this.state.ws.sendPacket({
+          op: VoiceOpcodes2.SelectProtocol,
+          d: {
+            protocol: "udp",
+            data: {
+              address: localConfig.ip,
+              port: localConfig.port,
+              mode: chooseEncryptionMode(modes)
+            }
+          }
+        });
         this.state = {
-          status: "idle" /* Idle */
+          ...this.state,
+          code: 3 /* SelectingProtocol */
         };
-      }
-    }, "onStreamError");
-    resource.playStream.once("error", onStreamError);
-    if (resource.started) {
+      }).catch((error) => this.emit("error", error));
       this.state = {
-        status: "playing" /* Playing */,
-        missedFrames: 0,
-        playbackDuration: 0,
-        resource,
-        onStreamError
-      };
-    } else {
-      const onReadableCallback = /* @__PURE__ */ __name(() => {
-        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
-          this.state = {
-            status: "playing" /* Playing */,
-            missedFrames: 0,
-            playbackDuration: 0,
-            resource,
-            onStreamError
-          };
+        ...this.state,
+        code: 2 /* UdpHandshaking */,
+        udp,
+        connectionData: {
+          ssrc,
+          connectedClients: /* @__PURE__ */ new Set()
         }
-      }, "onReadableCallback");
-      const onFailureCallback = /* @__PURE__ */ __name(() => {
-        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
-          this.state = {
-            status: "idle" /* Idle */
-          };
+      };
+    } else if (packet.op === VoiceOpcodes2.SessionDescription && this.state.code === 3 /* SelectingProtocol */) {
+      const { mode: encryptionMode, secret_key: secretKey, dave_protocol_version: daveProtocolVersion } = packet.d;
+      this.state = {
+        ...this.state,
+        code: 4 /* Ready */,
+        dave: this.createDaveSession(daveProtocolVersion),
+        connectionData: {
+          ...this.state.connectionData,
+          encryptionMode,
+          secretKey: new Uint8Array(secretKey),
+          sequence: randomNBit(16),
+          timestamp: randomNBit(32),
+          nonce: 0,
+          nonceBuffer: encryptionMode === "aead_aes256_gcm_rtpsize" ? Buffer7.alloc(12) : Buffer7.alloc(24),
+          speaking: false,
+          packetsPlayed: 0
         }
-      }, "onFailureCallback");
-      resource.playStream.once("readable", onReadableCallback);
-      resource.playStream.once("end", onFailureCallback);
-      resource.playStream.once("close", onFailureCallback);
-      resource.playStream.once("finish", onFailureCallback);
+      };
+    } else if (packet.op === VoiceOpcodes2.Resumed && this.state.code === 5 /* Resuming */) {
       this.state = {
-        status: "buffering" /* Buffering */,
-        resource,
-        onReadableCallback,
-        onFailureCallback,
-        onStreamError
+        ...this.state,
+        code: 4 /* Ready */
       };
+      this.state.connectionData.speaking = false;
+    } else if ((packet.op === VoiceOpcodes2.ClientsConnect || packet.op === VoiceOpcodes2.ClientDisconnect) && (this.state.code === 4 /* Ready */ || this.state.code === 2 /* UdpHandshaking */ || this.state.code === 3 /* SelectingProtocol */ || this.state.code === 5 /* Resuming */)) {
+      const { connectionData } = this.state;
+      if (packet.op === VoiceOpcodes2.ClientsConnect)
+        for (const id of packet.d.user_ids) connectionData.connectedClients.add(id);
+      else {
+        connectionData.connectedClients.delete(packet.d.user_id);
+      }
+    } else if ((this.state.code === 4 /* Ready */ || this.state.code === 5 /* Resuming */) && this.state.dave) {
+      if (packet.op === VoiceOpcodes2.DavePrepareTransition) {
+        const sendReady = this.state.dave.prepareTransition(packet.d);
+        if (sendReady)
+          this.state.ws.sendPacket({
+            op: VoiceOpcodes2.DaveTransitionReady,
+            d: { transition_id: packet.d.transition_id }
+          });
+        if (packet.d.transition_id === 0) {
+          this.emit("transitioned", 0);
+        }
+      } else if (packet.op === VoiceOpcodes2.DaveExecuteTransition) {
+        const transitioned = this.state.dave.executeTransition(packet.d.transition_id);
+        if (transitioned) this.emit("transitioned", packet.d.transition_id);
+      } else if (packet.op === VoiceOpcodes2.DavePrepareEpoch) this.state.dave.prepareEpoch(packet.d);
+    }
+  }
+  /**
+   * Called when a binary message is received on the connection's WebSocket.
+   *
+   * @param message - The received message
+   */
+  onWsBinary(message) {
+    if (this.state.code === 4 /* Ready */ && this.state.dave) {
+      if (message.op === VoiceOpcodes2.DaveMlsExternalSender) {
+        this.state.dave.setExternalSender(message.payload);
+      } else if (message.op === VoiceOpcodes2.DaveMlsProposals) {
+        const payload = this.state.dave.processProposals(message.payload, this.state.connectionData.connectedClients);
+        if (payload) this.state.ws.sendBinaryMessage(VoiceOpcodes2.DaveMlsCommitWelcome, payload);
+      } else if (message.op === VoiceOpcodes2.DaveMlsAnnounceCommitTransition) {
+        const { transitionId, success } = this.state.dave.processCommit(message.payload);
+        if (success) {
+          if (transitionId === 0) this.emit("transitioned", transitionId);
+          else
+            this.state.ws.sendPacket({
+              op: VoiceOpcodes2.DaveTransitionReady,
+              d: { transition_id: transitionId }
+            });
+        }
+      } else if (message.op === VoiceOpcodes2.DaveMlsWelcome) {
+        const { transitionId, success } = this.state.dave.processWelcome(message.payload);
+        if (success) {
+          if (transitionId === 0) this.emit("transitioned", transitionId);
+          else
+            this.state.ws.sendPacket({
+              op: VoiceOpcodes2.DaveTransitionReady,
+              d: { transition_id: transitionId }
+            });
+        }
+      }
     }
   }
   /**
-   * Pauses playback of the current resource, if any.
+   * Called when a new key package is ready to be sent to the voice server.
+   *
+   * @param keyPackage - The new key package
+   */
+  onDaveKeyPackage(keyPackage) {
+    if (this.state.code === 3 /* SelectingProtocol */ || this.state.code === 4 /* Ready */)
+      this.state.ws.sendBinaryMessage(VoiceOpcodes2.DaveMlsKeyPackage, keyPackage);
+  }
+  /**
+   * Called when the DAVE session wants to invalidate their transition and re-initialize.
+   *
+   * @param transitionId - The transition to invalidate
+   */
+  onDaveInvalidateTransition(transitionId) {
+    if (this.state.code === 3 /* SelectingProtocol */ || this.state.code === 4 /* Ready */)
+      this.state.ws.sendPacket({
+        op: VoiceOpcodes2.DaveMlsInvalidCommitWelcome,
+        d: { transition_id: transitionId }
+      });
+  }
+  /**
+   * Propagates debug messages from the child WebSocket.
+   *
+   * @param message - The emitted debug message
+   */
+  onWsDebug(message) {
+    this.debug?.(`[WS] ${message}`);
+  }
+  /**
+   * Propagates debug messages from the child UDPSocket.
    *
-   * @param interpolateSilence - If true, the player will play 5 packets of silence after pausing to prevent audio glitches
-   * @returns `true` if the player was successfully paused, otherwise `false`
+   * @param message - The emitted debug message
    */
-  pause(interpolateSilence = true) {
-    if (this.state.status !== "playing" /* Playing */) return false;
-    this.state = {
-      ...this.state,
-      status: "paused" /* Paused */,
-      silencePacketsRemaining: interpolateSilence ? 5 : 0
-    };
-    return true;
+  onUdpDebug(message) {
+    this.debug?.(`[UDP] ${message}`);
   }
   /**
-   * Unpauses playback of the current resource, if any.
+   * Propagates debug messages from the child DAVESession.
    *
-   * @returns `true` if the player was successfully unpaused, otherwise `false`
+   * @param message - The emitted debug message
    */
-  unpause() {
-    if (this.state.status !== "paused" /* Paused */) return false;
-    this.state = {
-      ...this.state,
-      status: "playing" /* Playing */,
-      missedFrames: 0
-    };
-    return true;
+  onDaveDebug(message) {
+    this.debug?.(`[DAVE] ${message}`);
   }
   /**
-   * Stops playback of the current resource and destroys the resource. The player will either transition to the Idle state,
-   * or remain in its current state until the silence padding frames of the resource have been played.
+   * Prepares an Opus packet for playback. This includes attaching metadata to it and encrypting it.
+   * It will be stored within the instance, and can be played by dispatchAudio()
    *
-   * @param force - If true, will force the player to enter the Idle state even if the resource has silence padding frames
-   * @returns `true` if the player will come to a stop, otherwise `false`
+   * @remarks
+   * Calling this method while there is already a prepared audio packet that has not yet been dispatched
+   * will overwrite the existing audio packet. This should be avoided.
+   * @param opusPacket - The Opus packet to encrypt
+   * @returns The audio packet that was prepared
    */
-  stop(force = false) {
-    if (this.state.status === "idle" /* Idle */) return false;
-    if (force || this.state.resource.silencePaddingFrames === 0) {
-      this.state = {
-        status: "idle" /* Idle */
-      };
-    } else if (this.state.resource.silenceRemaining === -1) {
-      this.state.resource.silenceRemaining = this.state.resource.silencePaddingFrames;
-    }
-    return true;
+  prepareAudioPacket(opusPacket) {
+    const state = this.state;
+    if (state.code !== 4 /* Ready */) return;
+    state.preparedPacket = this.createAudioPacket(opusPacket, state.connectionData, state.dave);
+    return state.preparedPacket;
   }
   /**
-   * Checks whether the underlying resource (if any) is playable (readable)
-   *
-   * @returns `true` if the resource is playable, otherwise `false`
+   * Dispatches the audio packet previously prepared by prepareAudioPacket(opusPacket). The audio packet
+   * is consumed and cannot be dispatched again.
    */
-  checkPlayable() {
-    const state = this._state;
-    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */) return false;
-    if (!state.resource.readable) {
-      this.state = {
-        status: "idle" /* Idle */
-      };
-      return false;
+  dispatchAudio() {
+    const state = this.state;
+    if (state.code !== 4 /* Ready */) return false;
+    if (state.preparedPacket !== void 0) {
+      this.playAudioPacket(state.preparedPacket);
+      state.preparedPacket = void 0;
+      return true;
     }
-    return true;
+    return false;
   }
   /**
-   * Called roughly every 20ms by the global audio player timer. Dispatches any audio packets that are buffered
-   * by the active connections of this audio player.
+   * Plays an audio packet, updating timing metadata used for playback.
+   *
+   * @param audioPacket - The audio packet to play
    */
-  // @ts-ignore
-  _stepDispatch() {
-    const state = this._state;
-    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */) return;
-    for (const connection of this.playable) {
-      connection.dispatchAudio();
-    }
+  playAudioPacket(audioPacket) {
+    const state = this.state;
+    if (state.code !== 4 /* Ready */) return;
+    const { connectionData } = state;
+    connectionData.packetsPlayed++;
+    connectionData.sequence++;
+    connectionData.timestamp += TIMESTAMP_INC;
+    if (connectionData.sequence >= 2 ** 16) connectionData.sequence = 0;
+    if (connectionData.timestamp >= 2 ** 32) connectionData.timestamp = 0;
+    this.setSpeaking(true);
+    state.udp.send(audioPacket);
   }
   /**
-   * Called roughly every 20ms by the global audio player timer. Attempts to read an audio packet from the
-   * underlying resource of the stream, and then has all the active connections of the audio player prepare it
-   * (encrypt it, append header data) so that it is ready to play at the start of the next cycle.
+   * Sends a packet to the voice gateway indicating that the client has start/stopped sending
+   * audio.
+   *
+   * @param speaking - Whether or not the client should be shown as speaking
    */
-  // @ts-ignore
-  _stepPrepare() {
-    const state = this._state;
-    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */) return;
-    const playable = this.playable;
-    if (state.status === "autopaused" /* AutoPaused */ && playable.length > 0) {
-      this.state = {
-        ...state,
-        status: "playing" /* Playing */,
-        missedFrames: 0
-      };
-    }
-    if (state.status === "paused" /* Paused */ || state.status === "autopaused" /* AutoPaused */) {
-      if (state.silencePacketsRemaining > 0) {
-        state.silencePacketsRemaining--;
-        this._preparePacket(SILENCE_FRAME, playable, state);
-        if (state.silencePacketsRemaining === 0) {
-          this._signalStopSpeaking();
-        }
-      }
-      return;
-    }
-    if (playable.length === 0) {
-      if (this.behaviors.noSubscriber === "pause" /* Pause */) {
-        this.state = {
-          ...state,
-          status: "autopaused" /* AutoPaused */,
-          silencePacketsRemaining: 5
-        };
-        return;
-      } else if (this.behaviors.noSubscriber === "stop" /* Stop */) {
-        this.stop(true);
-      }
-    }
-    const packet = state.resource.read();
-    if (state.status === "playing" /* Playing */) {
-      if (packet) {
-        this._preparePacket(packet, playable, state);
-        state.missedFrames = 0;
-      } else {
-        this._preparePacket(SILENCE_FRAME, playable, state);
-        state.missedFrames++;
-        if (state.missedFrames >= this.behaviors.maxMissedFrames) {
-          this.stop();
-        }
+  setSpeaking(speaking) {
+    const state = this.state;
+    if (state.code !== 4 /* Ready */) return;
+    if (state.connectionData.speaking === speaking) return;
+    state.connectionData.speaking = speaking;
+    state.ws.sendPacket({
+      op: VoiceOpcodes2.Speaking,
+      d: {
+        speaking: speaking ? 1 : 0,
+        delay: 0,
+        ssrc: state.connectionData.ssrc
       }
-    }
+    });
   }
   /**
-   * Signals to all the subscribed connections that they should send a packet to Discord indicating
-   * they are no longer speaking. Called once playback of a resource ends.
+   * Creates a new audio packet from an Opus packet. This involves encrypting the packet,
+   * then prepending a header that includes metadata.
+   *
+   * @param opusPacket - The Opus packet to prepare
+   * @param connectionData - The current connection data of the instance
+   * @param daveSession - The DAVE session to use for encryption
    */
-  _signalStopSpeaking() {
-    for (const { connection } of this.subscribers) {
-      connection.setSpeaking(false);
-    }
+  createAudioPacket(opusPacket, connectionData, daveSession) {
+    const rtpHeader = Buffer7.alloc(12);
+    rtpHeader[0] = 128;
+    rtpHeader[1] = 120;
+    const { sequence, timestamp, ssrc } = connectionData;
+    rtpHeader.writeUIntBE(sequence, 2, 2);
+    rtpHeader.writeUIntBE(timestamp, 4, 4);
+    rtpHeader.writeUIntBE(ssrc, 8, 4);
+    rtpHeader.copy(nonce, 0, 0, 12);
+    return Buffer7.concat([rtpHeader, ...this.encryptOpusPacket(opusPacket, connectionData, rtpHeader, daveSession)]);
   }
   /**
-   * Instructs the given connections to each prepare this packet to be played at the start of the
-   * next cycle.
+   * Encrypts an Opus packet using the format agreed upon by the instance and Discord.
    *
-   * @param packet - The Opus packet to be prepared by each receiver
-   * @param receivers - The connections that should play this packet
+   * @param opusPacket - The Opus packet to encrypt
+   * @param connectionData - The current connection data of the instance
+   * @param daveSession - The DAVE session to use for encryption
    */
-  _preparePacket(packet, receivers, state) {
-    state.playbackDuration += 20;
-    for (const connection of receivers) {
-      connection.prepareAudioPacket(packet);
+  encryptOpusPacket(opusPacket, connectionData, additionalData, daveSession) {
+    const { secretKey, encryptionMode } = connectionData;
+    const packet = daveSession?.encrypt(opusPacket) ?? opusPacket;
+    connectionData.nonce++;
+    if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;
+    connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);
+    const noncePadding = connectionData.nonceBuffer.subarray(0, 4);
+    let encrypted;
+    switch (encryptionMode) {
+      case "aead_aes256_gcm_rtpsize": {
+        const cipher = crypto.createCipheriv("aes-256-gcm", secretKey, connectionData.nonceBuffer);
+        cipher.setAAD(additionalData);
+        encrypted = Buffer7.concat([cipher.update(packet), cipher.final(), cipher.getAuthTag()]);
+        return [encrypted, noncePadding];
+      }
+      case "aead_xchacha20_poly1305_rtpsize": {
+        encrypted = methods.crypto_aead_xchacha20poly1305_ietf_encrypt(
+          packet,
+          additionalData,
+          connectionData.nonceBuffer,
+          secretKey
+        );
+        return [encrypted, noncePadding];
+      }
+      default: {
+        throw new RangeError(`Unsupported encryption method: ${encryptionMode}`);
+      }
     }
   }
 };
-function createAudioPlayer(options) {
-  return new AudioPlayer(options);
-}
-__name(createAudioPlayer, "createAudioPlayer");
+
+// src/receive/VoiceReceiver.ts
+import { Buffer as Buffer8 } from "buffer";
+import crypto2 from "crypto";
+import { VoiceOpcodes as VoiceOpcodes3 } from "discord-api-types/voice/v8";
 
 // src/receive/AudioReceiveStream.ts
+import { nextTick } from "process";
+import { Readable } from "stream";
 var EndBehaviorType = /* @__PURE__ */ ((EndBehaviorType2) => {
   EndBehaviorType2[EndBehaviorType2["Manual"] = 0] = "Manual";
   EndBehaviorType2[EndBehaviorType2["AfterSilence"] = 1] = "AfterSilence";
@@ -1312,9 +1818,10 @@ var AudioReceiveStream = class extends Readable {
    */
   end;
   endTimeout;
-  constructor({ end, ...options }) {
+  constructor(options) {
+    const { end, ...rest } = options;
     super({
-      ...options,
+      ...rest,
       objectMode: true
     });
     this.end = end;
@@ -1323,6 +1830,9 @@ var AudioReceiveStream = class extends Readable {
     if (buffer && (this.end.behavior === 2 /* AfterInactivity */ || this.end.behavior === 1 /* AfterSilence */ && (buffer.compare(SILENCE_FRAME) !== 0 || this.endTimeout === void 0))) {
       this.renewEndTimeout(this.end);
     }
+    if (buffer === null) {
+      nextTick(() => this.destroy());
+    }
     return super.push(buffer);
   }
   renewEndTimeout(end) {
@@ -1336,8 +1846,8 @@ var AudioReceiveStream = class extends Readable {
 };
 
 // src/receive/SSRCMap.ts
-import { EventEmitter as EventEmitter5 } from "node:events";
-var SSRCMap = class extends EventEmitter5 {
+import { EventEmitter as EventEmitter6 } from "events";
+var SSRCMap = class extends EventEmitter6 {
   static {
     __name(this, "SSRCMap");
   }
@@ -1407,8 +1917,8 @@ var SSRCMap = class extends EventEmitter5 {
 };
 
 // src/receive/SpeakingMap.ts
-import { EventEmitter as EventEmitter6 } from "node:events";
-var SpeakingMap = class _SpeakingMap extends EventEmitter6 {
+import { EventEmitter as EventEmitter7 } from "events";
+var SpeakingMap = class _SpeakingMap extends EventEmitter7 {
   static {
     __name(this, "SpeakingMap");
   }
@@ -1449,7 +1959,7 @@ var SpeakingMap = class _SpeakingMap extends EventEmitter6 {
 };
 
 // src/receive/VoiceReceiver.ts
-var HEADER_EXTENSION_BYTE = Buffer6.from([190, 222]);
+var HEADER_EXTENSION_BYTE = Buffer8.from([190, 222]);
 var UNPADDED_NONCE_LENGTH = 4;
 var AUTH_TAG_LENGTH = 16;
 var VoiceReceiver = class {
@@ -1494,16 +2004,10 @@ var VoiceReceiver = class {
    * @internal
    */
   onWsPacket(packet) {
-    if (packet.op === VoiceOpcodes3.ClientDisconnect && typeof packet.d?.user_id === "string") {
+    if (packet.op === VoiceOpcodes3.ClientDisconnect) {
       this.ssrcMap.delete(packet.d.user_id);
-    } else if (packet.op === VoiceOpcodes3.Speaking && typeof packet.d?.user_id === "string" && typeof packet.d?.ssrc === "number") {
+    } else if (packet.op === VoiceOpcodes3.Speaking) {
       this.ssrcMap.update({ userId: packet.d.user_id, audioSSRC: packet.d.ssrc });
-    } else if (packet.op === VoiceOpcodes3.ClientConnect && typeof packet.d?.user_id === "string" && typeof packet.d?.audio_ssrc === "number") {
-      this.ssrcMap.update({
-        userId: packet.d.user_id,
-        audioSSRC: packet.d.audio_ssrc,
-        videoSSRC: packet.d.video_ssrc === 0 ? void 0 : packet.d.video_ssrc
-      });
     }
   }
   decrypt(buffer, mode, nonce2, secretKey) {
@@ -1522,12 +2026,12 @@ var VoiceReceiver = class {
         const decipheriv = crypto2.createDecipheriv("aes-256-gcm", secretKey, nonce2);
         decipheriv.setAAD(header);
         decipheriv.setAuthTag(authTag);
-        return Buffer6.concat([decipheriv.update(encrypted), decipheriv.final()]);
+        return Buffer8.concat([decipheriv.update(encrypted), decipheriv.final()]);
       }
       case "aead_xchacha20_poly1305_rtpsize": {
-        return Buffer6.from(
+        return Buffer8.from(
           methods.crypto_aead_xchacha20poly1305_ietf_decrypt(
-            Buffer6.concat([encrypted, authTag]),
+            Buffer8.concat([encrypted, authTag]),
             header,
             nonce2,
             secretKey
@@ -1546,15 +2050,20 @@ var VoiceReceiver = class {
    * @param mode - The encryption mode
    * @param nonce - The nonce buffer used by the connection for encryption
    * @param secretKey - The secret key used by the connection for encryption
+   * @param userId - The user id that sent the packet
    * @returns The parsed Opus packet
    */
-  parsePacket(buffer, mode, nonce2, secretKey) {
+  parsePacket(buffer, mode, nonce2, secretKey, userId) {
     let packet = this.decrypt(buffer, mode, nonce2, secretKey);
-    if (!packet) return;
+    if (!packet) throw new Error("Failed to parse packet");
     if (buffer.subarray(12, 14).compare(HEADER_EXTENSION_BYTE) === 0) {
       const headerExtensionLength = buffer.subarray(14).readUInt16BE();
       packet = packet.subarray(4 * headerExtensionLength);
     }
+    if (this.voiceConnection.state.status === "ready" /* Ready */ && (this.voiceConnection.state.networking.state.code === 4 /* Ready */ || this.voiceConnection.state.networking.state.code === 5 /* Resuming */)) {
+      const daveSession = this.voiceConnection.state.networking.state.dave;
+      if (daveSession) packet = daveSession.decrypt(packet, userId);
+    }
     return packet;
   }
   /**
@@ -1572,16 +2081,17 @@ var VoiceReceiver = class {
     const stream = this.subscriptions.get(userData.userId);
     if (!stream) return;
     if (this.connectionData.encryptionMode && this.connectionData.nonceBuffer && this.connectionData.secretKey) {
-      const packet = this.parsePacket(
-        msg,
-        this.connectionData.encryptionMode,
-        this.connectionData.nonceBuffer,
-        this.connectionData.secretKey
-      );
-      if (packet) {
-        stream.push(packet);
-      } else {
-        stream.destroy(new Error("Failed to parse packet"));
+      try {
+        const packet = this.parsePacket(
+          msg,
+          this.connectionData.encryptionMode,
+          this.connectionData.nonceBuffer,
+          this.connectionData.secretKey,
+          userData.userId
+        );
+        if (packet) stream.push(packet);
+      } catch (error) {
+        stream.destroy(error);
       }
     }
   }
@@ -1620,7 +2130,7 @@ var VoiceConnectionDisconnectReason = /* @__PURE__ */ ((VoiceConnectionDisconnec
   VoiceConnectionDisconnectReason2[VoiceConnectionDisconnectReason2["Manual"] = 3] = "Manual";
   return VoiceConnectionDisconnectReason2;
 })(VoiceConnectionDisconnectReason || {});
-var VoiceConnection = class extends EventEmitter7 {
+var VoiceConnection = class extends EventEmitter8 {
   static {
     __name(this, "VoiceConnection");
   }
@@ -1653,6 +2163,10 @@ var VoiceConnection = class extends EventEmitter7 {
    * The debug logger function, if debugging is enabled.
    */
   debug;
+  /**
+   * The options used to create this voice connection.
+   */
+  options;
   /**
    * Creates a new voice connection.
    *
@@ -1668,6 +2182,7 @@ var VoiceConnection = class extends EventEmitter7 {
     this.onNetworkingStateChange = this.onNetworkingStateChange.bind(this);
     this.onNetworkingError = this.onNetworkingError.bind(this);
     this.onNetworkingDebug = this.onNetworkingDebug.bind(this);
+    this.onNetworkingTransitioned = this.onNetworkingTransitioned.bind(this);
     const adapter = options.adapterCreator({
       onVoiceServerUpdate: /* @__PURE__ */ __name((data) => this.addServerPacket(data), "onVoiceServerUpdate"),
       onVoiceStateUpdate: /* @__PURE__ */ __name((data) => this.addStatePacket(data), "onVoiceStateUpdate"),
@@ -1679,16 +2194,17 @@ var VoiceConnection = class extends EventEmitter7 {
       state: void 0
     };
     this.joinConfig = joinConfig;
+    this.options = options;
   }
   /**
    * The current state of the voice connection.
+   *
+   * @remarks
+   * The setter will perform clean-up operations where necessary.
    */
   get state() {
     return this._state;
   }
-  /**
-   * Updates the state of the voice connection, performing clean-up operations where necessary.
-   */
   set state(newState) {
     const oldState = this._state;
     const oldNetworking = Reflect.get(oldState, "networking");
@@ -1702,6 +2218,7 @@ var VoiceConnection = class extends EventEmitter7 {
         oldNetworking.off("error", this.onNetworkingError);
         oldNetworking.off("close", this.onNetworkingClose);
         oldNetworking.off("stateChange", this.onNetworkingStateChange);
+        oldNetworking.off("transitioned", this.onNetworkingTransitioned);
         oldNetworking.destroy();
       }
       if (newNetworking) this.updateReceiveBindings(newNetworking.state, oldNetworking?.state);
@@ -1797,14 +2314,20 @@ var VoiceConnection = class extends EventEmitter7 {
         serverId: server.guild_id,
         token: server.token,
         sessionId: state.session_id,
-        userId: state.user_id
+        userId: state.user_id,
+        channelId: state.channel_id
       },
-      Boolean(this.debug)
+      {
+        debug: Boolean(this.debug),
+        daveEncryption: this.options.daveEncryption ?? true,
+        decryptionFailureTolerance: this.options.decryptionFailureTolerance
+      }
     );
     networking.once("close", this.onNetworkingClose);
     networking.on("stateChange", this.onNetworkingStateChange);
     networking.on("error", this.onNetworkingError);
     networking.on("debug", this.onNetworkingDebug);
+    networking.on("transitioned", this.onNetworkingTransitioned);
     this.state = {
       ...this.state,
       status: "connecting" /* Connecting */,
@@ -1885,6 +2408,14 @@ var VoiceConnection = class extends EventEmitter7 {
   onNetworkingDebug(message) {
     this.debug?.(`[NW] ${message}`);
   }
+  /**
+   * Propagates transitions from the underlying network instance.
+   *
+   * @param transitionId - The transition id
+   */
+  onNetworkingTransitioned(transitionId) {
+    this.emit("transitioned", transitionId);
+  }
   /**
    * Prepares an audio packet for dispatch.
    *
@@ -2040,6 +2571,30 @@ var VoiceConnection = class extends EventEmitter7 {
       udp: void 0
     };
   }
+  /**
+   * The current voice privacy code of the encrypted session.
+   *
+   * @remarks
+   * For this data to be available, the VoiceConnection must be in the Ready state,
+   * and the connection would have to be end-to-end encrypted.
+   */
+  get voicePrivacyCode() {
+    if (this.state.status === "ready" /* Ready */ && this.state.networking.state.code === 4 /* Ready */) {
+      return this.state.networking.state.dave?.voicePrivacyCode ?? void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Gets the verification code for a user in the session.
+   *
+   * @throws Will throw if end-to-end encryption is not on or if the user id provided is not in the session.
+   */
+  async getVerificationCode(userId) {
+    if (this.state.status === "ready" /* Ready */ && this.state.networking.state.code === 4 /* Ready */ && this.state.networking.state.dave) {
+      return this.state.networking.state.dave.getVerificationCode(userId);
+    }
+    throw new Error("Session not available");
+  }
   /**
    * Called when a subscription of this voice connection to an audio player is removed.
    *
@@ -2096,13 +2651,15 @@ function joinVoiceChannel(options) {
   };
   return createVoiceConnection(joinConfig, {
     adapterCreator: options.adapterCreator,
-    debug: options.debug
+    debug: options.debug,
+    daveEncryption: options.daveEncryption,
+    decryptionFailureTolerance: options.decryptionFailureTolerance
   });
 }
 __name(joinVoiceChannel, "joinVoiceChannel");
 
 // src/audio/AudioResource.ts
-import { pipeline } from "node:stream";
+import { pipeline } from "stream";
 import prism2 from "prism-media";
 
 // src/audio/TransformerGraph.ts
@@ -2130,6 +2687,16 @@ var StreamType = /* @__PURE__ */ ((StreamType2) => {
   StreamType2["WebmOpus"] = "webm/opus";
   return StreamType2;
 })(StreamType || {});
+var TransformerType = /* @__PURE__ */ ((TransformerType2) => {
+  TransformerType2["FFmpegOgg"] = "ffmpeg ogg";
+  TransformerType2["FFmpegPCM"] = "ffmpeg pcm";
+  TransformerType2["InlineVolume"] = "volume transformer";
+  TransformerType2["OggOpusDemuxer"] = "ogg/opus demuxer";
+  TransformerType2["OpusDecoder"] = "opus decoder";
+  TransformerType2["OpusEncoder"] = "opus encoder";
+  TransformerType2["WebmOpusDemuxer"] = "webm/opus demuxer";
+  return TransformerType2;
+})(TransformerType || {});
 var Node = class {
   static {
     __name(this, "Node");
@@ -2419,7 +2986,8 @@ function createAudioResource(input, options = {}) {
 __name(createAudioResource, "createAudioResource");
 
 // src/util/generateDependencyReport.ts
-import { resolve, dirname } from "node:path";
+import { getCiphers } from "crypto";
+import { resolve, dirname } from "path";
 import prism3 from "prism-media";
 function findPackageJSON(dir, packageName, depth) {
   if (depth === 0) return void 0;
@@ -2436,7 +3004,7 @@ __name(findPackageJSON, "findPackageJSON");
 function version(name) {
   try {
     if (name === "@discordjs/voice") {
-      return "0.18.1-dev.1732709130-97ffa201a";
+      return "0.19.0";
     }
     const pkg = findPackageJSON(dirname(__require.resolve(name)), name, 3);
     return pkg?.version ?? "not found";
@@ -2457,12 +3025,16 @@ function generateDependencyReport() {
   addVersion("opusscript");
   report.push("");
   report.push("Encryption Libraries");
+  report.push(`- native crypto support for aes-256-gcm: ${getCiphers().includes("aes-256-gcm") ? "yes" : "no"}`);
   addVersion("sodium-native");
   addVersion("sodium");
   addVersion("libsodium-wrappers");
   addVersion("@stablelib/xchacha20poly1305");
   addVersion("@noble/ciphers");
   report.push("");
+  report.push("DAVE Libraries");
+  addVersion("@snazzah/davey");
+  report.push("");
   report.push("FFmpeg");
   try {
     const info = prism3.FFmpeg.getInfo();
@@ -2476,7 +3048,7 @@ function generateDependencyReport() {
 __name(generateDependencyReport, "generateDependencyReport");
 
 // src/util/entersState.ts
-import { once } from "node:events";
+import { once } from "events";
 
 // src/util/abortAfter.ts
 function abortAfter(delay) {
@@ -2502,9 +3074,9 @@ async function entersState(target, status, timeoutOrSignal) {
 __name(entersState, "entersState");
 
 // src/util/demuxProbe.ts
-import { Buffer as Buffer7 } from "node:buffer";
-import process from "node:process";
-import { Readable as Readable2 } from "node:stream";
+import { Buffer as Buffer9 } from "buffer";
+import process from "process";
+import { Readable as Readable2 } from "stream";
 import prism4 from "prism-media";
 function validateDiscordOpusHead(opusHead) {
   const channels = opusHead.readUInt8(9);
@@ -2522,7 +3094,7 @@ async function demuxProbe(stream, probeSize = 1024, validator = validateDiscordO
       reject(new Error("Cannot probe a stream that has ended"));
       return;
     }
-    let readBuffer = Buffer7.alloc(0);
+    let readBuffer = Buffer9.alloc(0);
     let resolved;
     const finish = /* @__PURE__ */ __name((type) => {
       stream.off("data", onData);
@@ -2562,7 +3134,7 @@ async function demuxProbe(stream, probeSize = 1024, validator = validateDiscordO
       }
     }, "onClose");
     const onData = /* @__PURE__ */ __name((buffer) => {
-      readBuffer = Buffer7.concat([readBuffer, buffer]);
+      readBuffer = Buffer9.concat([readBuffer, buffer]);
       webm.write(buffer);
       ogg.write(buffer);
       if (readBuffer.length >= probeSize) {
@@ -2580,23 +3152,30 @@ async function demuxProbe(stream, probeSize = 1024, validator = validateDiscordO
 __name(demuxProbe, "demuxProbe");
 
 // src/index.ts
-var version2 = "0.18.1-dev.1732709130-97ffa201a";
+var version2 = "0.19.0";
 export {
   AudioPlayer,
   AudioPlayerError,
   AudioPlayerStatus,
   AudioReceiveStream,
   AudioResource,
+  DAVESession,
   EndBehaviorType,
+  Networking,
+  NetworkingStatusCode,
   NoSubscriberBehavior,
+  Node,
   PlayerSubscription,
   SSRCMap,
   SpeakingMap,
   StreamType,
+  TransformerType,
   VoiceConnection,
   VoiceConnectionDisconnectReason,
   VoiceConnectionStatus,
   VoiceReceiver,
+  VoiceUDPSocket,
+  VoiceWebSocket,
   createAudioPlayer,
   createAudioResource,
   createDefaultAudioReceiveStreamOptions,