magmastream 2.10.3-dev.2 → 2.10.4

package/dist/structures/Player.d.ts

@@ -1,7 +1,7 @@
 import { Filters } from "./Filters";
 import { Manager } from "./Manager";
 import { Node } from "./Node";
-import { AnyMessage, IQueue, Lyrics, PlayerOptions, PlayerVoiceState, PlayOptions, SearchQuery, SearchResult, Track } from "./Types";
+import { AnyMessage, IQueue, Lyrics, NodeLinkChapter, NodeLinkFadingConfig, NodeLinkMeaningResult, NodeLinkMix, NodeLinkNextTrackOptions, NodeLinkSponsorBlockSegment, NodeLinkSponsorBlockState, NodeLinkSponsorBlockUpdate, PlayerOptions, PlayerVoiceState, PlayOptions, SearchQuery, SearchResult, Track } from "./Types";
 import { SponsorBlockSegment, StateTypes } from "./Enums";
 import { WebSocket } from "ws";
 export declare class Player {
@@ -58,6 +58,7 @@ export declare class Player {
     protected voiceReceiverReconnectTimeout?: NodeJS.Timeout;
     protected voiceReceiverAttempt: number;
     protected voiceReceiverReconnectTries: number;
+    private readonly voiceReceiverStreams;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -148,6 +149,15 @@ export declare class Player {
     play(track: Track): Promise<Player>;
     play(options: PlayOptions): Promise<Player>;
     play(track: Track, options: PlayOptions): Promise<Player>;
+    private assertNodeLinkPlayOptionsSupported;
+    /** Preloads or clears NodeLink's next track for gapless playback. */
+    preloadNextTrack(track: Track | null, options?: NodeLinkNextTrackOptions): Promise<this>;
+    /** Updates NodeLink playback fading behavior. */
+    setNodeLinkFading(fading: NodeLinkFadingConfig): Promise<this>;
+    /** Enables or disables NodeLink loudness normalization. */
+    setNodeLinkLoudnessNormalizer(enabled: boolean): Promise<this>;
+    private assertNodeLinkFeature;
+    private assertNodeLinkFading;
     /**
      * Sets the autoplay-state of the player.
      *
@@ -167,6 +177,70 @@ export declare class Player {
      * @returns {Promise<Track[]>} - Array of recommended tracks.
      */
     getRecommendedTracks(track: Track): Promise<Track[]>;
+    /**
+     * Loads chapters for the current or provided track using NodeLink.
+     * @param {Track} [track] - The track to load chapters for. Defaults to the current queue track.
+     * @returns {Promise<NodeLinkChapter[]>} The loaded chapters.
+     */
+    getChapters(track?: Track): Promise<NodeLinkChapter[]>;
+    /**
+     * Loads chapters for the current or provided track using NodeLink.
+     * @param {Track} [track] - The track to load chapters for. Defaults to the current queue track.
+     * @returns {Promise<NodeLinkChapter[]>} The loaded chapters.
+     */
+    getNodeLinkChapters(track?: Track): Promise<NodeLinkChapter[]>;
+    /** Loads NodeLink meaning/background information for the current or provided track. */
+    getNodeLinkMeaning(track?: Track, language?: string): Promise<NodeLinkMeaningResult>;
+    /**
+     * Adds a NodeLink audio mix layer over the current playback.
+     * @param {Track} track - The track to mix.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    addMix(track: Track, volume?: number): Promise<NodeLinkMix>;
+    /**
+     * Adds a NodeLink audio mix layer over the current playback.
+     * @param {Track} track - The track to mix.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    addNodeLinkMix(track: Track, volume?: number): Promise<NodeLinkMix>;
+    /**
+     * Gets the active NodeLink audio mix layers.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    getMixes(): Promise<NodeLinkMix[]>;
+    /**
+     * Gets the active NodeLink audio mix layers.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    getNodeLinkMixes(): Promise<NodeLinkMix[]>;
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    updateMix(mixId: string, volume: number): Promise<void>;
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    updateNodeLinkMix(mixId: string, volume: number): Promise<void>;
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    removeMix(mixId: string): Promise<void>;
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    removeNodeLinkMix(mixId: string): Promise<void>;
     /**
      * Sets the volume of the player.
      * @param {number} volume - The new volume. Must be between 0 and 500 when using filter mode (100 = 100%).
@@ -189,6 +263,12 @@ export declare class Player {
      * @returns {Promise<SponsorBlockSegment[]>} The sponsorblock segments.
      */
     getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    /** Returns the complete NodeLink SponsorBlock state. */
+    getNodeLinkSponsorBlockState(): Promise<NodeLinkSponsorBlockState>;
+    /** Updates NodeLink SponsorBlock categories, actions, margin, or enabled state. */
+    updateNodeLinkSponsorBlock(update: NodeLinkSponsorBlockUpdate): Promise<NodeLinkSponsorBlockState>;
+    /** Replaces NodeLink's SponsorBlock segments with an explicit segment list. */
+    setNodeLinkSponsorBlockSegments(segments: NodeLinkSponsorBlockSegment[]): Promise<NodeLinkSponsorBlockState>;
     /**
      * Deletes the sponsorblock for the player. This will remove all sponsorblock segments that have been set for the player.
      * @returns {Promise<void>}
@@ -329,10 +409,13 @@ export declare class Player {
     private openVoiceReceiver;
     /**
      * Handles a voice receiver message.
-     * @param {string} payload - The payload to handle.
+     * @param {RawData} payload - The payload to handle.
      * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
      */
     private onVoiceReceiverMessage;
+    private toVoiceReceiverBuffer;
+    private parseNodeLinkVoiceFrame;
+    private handleNodeLinkVoiceFrame;
     /**
      * Handles a voice receiver error.
      * @param {Error} error - The error to handle.

package/dist/structures/Player.js

@@ -61,11 +61,12 @@ class Player {
     dynamicRepeatIntervalMs = null;
     static _manager;
     /** Should only be used when the node is a NodeLink */
-    voiceReceiverWsClient;
-    isConnectToVoiceReceiver;
+    voiceReceiverWsClient = null;
+    isConnectToVoiceReceiver = false;
     voiceReceiverReconnectTimeout;
-    voiceReceiverAttempt;
-    voiceReceiverReconnectTries;
+    voiceReceiverAttempt = 1;
+    voiceReceiverReconnectTries = 30;
+    voiceReceiverStreams = new Map();
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -270,6 +271,7 @@ class Player {
             this.voiceReceiverWsClient.close();
             this.voiceReceiverWsClient = null;
         }
+        this.voiceReceiverStreams.clear();
         if (disconnect) {
             await this.disconnect().catch(() => { });
         }
@@ -381,23 +383,101 @@ class Player {
             console.error(error);
             return this;
         }
-        const isPlayOptions = (v) => typeof v === "object" && v !== null && ("startTime" in v || "endTime" in v || "noReplace" in v);
+        const isPlayOptions = (v) => typeof v === "object" && v !== null && ("startTime" in v || "endTime" in v || "noReplace" in v || "audioTrackId" in v || "language" in v || "loudnessNormalizer" in v);
         const finalOptions = playOptions ? playOptions : isPlayOptions(optionsOrTrack) ? optionsOrTrack : {};
+        this.assertNodeLinkPlayOptionsSupported(finalOptions);
         await this.node.rest.updatePlayer({
             guildId: this.guildId,
             noReplace: finalOptions.noReplace,
             data: {
                 track: {
                     encoded: currentTrack.track,
+                    ...(typeof finalOptions.audioTrackId === "string" && { audioTrackId: finalOptions.audioTrackId }),
+                    ...(typeof finalOptions.language === "string" && { language: finalOptions.language }),
                 },
                 ...(typeof finalOptions.startTime === "number" && { position: finalOptions.startTime }),
                 ...(typeof finalOptions.endTime === "number" && finalOptions.endTime > 0 && { endTime: finalOptions.endTime }),
+                ...(typeof finalOptions.loudnessNormalizer === "boolean" && { loudnessNormalizer: finalOptions.loudnessNormalizer }),
             },
         });
         this.playing = true;
         this.position = finalOptions.startTime ?? 0;
         return this;
     }
+    assertNodeLinkPlayOptionsSupported(options) {
+        if (this.node.isNodeLink)
+            return;
+        const nodeLinkOnlyFields = [
+            ...(options.audioTrackId !== undefined ? ["audioTrackId"] : []),
+            ...(options.language !== undefined ? ["language"] : []),
+            ...(options.loudnessNormalizer !== undefined ? ["loudnessNormalizer"] : []),
+        ];
+        if (!nodeLinkOnlyFields.length)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: `NodeLink-only play options cannot be used on Lavalink node "${this.node.options.identifier}": ${nodeLinkOnlyFields.join(", ")}.`,
+            context: { identifier: this.node.options.identifier, guildId: this.guildId, fields: nodeLinkOnlyFields },
+        });
+    }
+    /** Preloads or clears NodeLink's next track for gapless playback. */
+    async preloadNextTrack(track, options = {}) {
+        this.assertNodeLinkFeature("preload a next track");
+        await this.node.rest.updatePlayer({
+            guildId: this.guildId,
+            data: {
+                nextTrack: track
+                    ? {
+                        encoded: track.track,
+                        ...(options.audioTrackId !== undefined ? { audioTrackId: options.audioTrackId } : {}),
+                        ...(options.language !== undefined ? { language: options.language } : {}),
+                    }
+                    : null,
+            },
+        });
+        return this;
+    }
+    /** Updates NodeLink playback fading behavior. */
+    async setNodeLinkFading(fading) {
+        this.assertNodeLinkFeature("set playback fading");
+        this.assertNodeLinkFading(fading);
+        await this.node.rest.updatePlayer({ guildId: this.guildId, data: { fading } });
+        return this;
+    }
+    /** Enables or disables NodeLink loudness normalization. */
+    async setNodeLinkLoudnessNormalizer(enabled) {
+        this.assertNodeLinkFeature("set loudness normalization");
+        if (typeof enabled !== "boolean") {
+            throw new MagmastreamError_1.MagmaStreamError({ code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR, message: "NodeLink loudness normalization must be a boolean." });
+        }
+        await this.node.rest.updatePlayer({ guildId: this.guildId, data: { loudnessNormalizer: enabled } });
+        return this;
+    }
+    assertNodeLinkFeature(action) {
+        if (this.node.isNodeLink)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: `NodeLink is required to ${action} on node "${this.node.options.identifier}".`,
+            context: { identifier: this.node.options.identifier, guildId: this.guildId },
+        });
+    }
+    assertNodeLinkFading(fading) {
+        if (!fading || typeof fading !== "object") {
+            throw new MagmastreamError_1.MagmaStreamError({ code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR, message: "NodeLink fading must be an object." });
+        }
+        for (const key of ["trackStart", "trackEnd", "trackStop", "seek", "pause", "resume"]) {
+            const section = fading[key];
+            if (section === undefined)
+                continue;
+            if (typeof section.duration !== "number" || !Number.isFinite(section.duration) || section.duration < 0) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                    message: `NodeLink fading section "${key}" requires a non-negative duration.`,
+                });
+            }
+        }
+    }
     /**
      * Sets the autoplay-state of the player.
      *
@@ -458,6 +538,107 @@ class Player {
         const tracks = await Utils_1.AutoPlayUtils.getRecommendedTracks(track);
         return tracks;
     }
+    /**
+     * Loads chapters for the current or provided track using NodeLink.
+     * @param {Track} [track] - The track to load chapters for. Defaults to the current queue track.
+     * @returns {Promise<NodeLinkChapter[]>} The loaded chapters.
+     */
+    async getChapters(track) {
+        const targetTrack = track ?? (await this.queue.getCurrent());
+        if (!targetTrack) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_QUEUE_EMPTY,
+                message: "The queue is empty.",
+            });
+        }
+        return this.node.getChapters(targetTrack);
+    }
+    /**
+     * Loads chapters for the current or provided track using NodeLink.
+     * @param {Track} [track] - The track to load chapters for. Defaults to the current queue track.
+     * @returns {Promise<NodeLinkChapter[]>} The loaded chapters.
+     */
+    async getNodeLinkChapters(track) {
+        return this.getChapters(track);
+    }
+    /** Loads NodeLink meaning/background information for the current or provided track. */
+    async getNodeLinkMeaning(track, language = "en") {
+        const target = track ?? (await this.queue.getCurrent());
+        if (!target) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_QUEUE_EMPTY,
+                message: "Cannot load meaning without a current track.",
+                context: { guildId: this.guildId },
+            });
+        }
+        return this.node.getNodeLinkMeaning(target, language);
+    }
+    /**
+     * Adds a NodeLink audio mix layer over the current playback.
+     * @param {Track} track - The track to mix.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    async addMix(track, volume) {
+        return this.node.addMix(this, track, volume);
+    }
+    /**
+     * Adds a NodeLink audio mix layer over the current playback.
+     * @param {Track} track - The track to mix.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    async addNodeLinkMix(track, volume) {
+        return this.addMix(track, volume);
+    }
+    /**
+     * Gets the active NodeLink audio mix layers.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    async getMixes() {
+        return this.node.getMixes(this);
+    }
+    /**
+     * Gets the active NodeLink audio mix layers.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    async getNodeLinkMixes() {
+        return this.getMixes();
+    }
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    async updateMix(mixId, volume) {
+        return this.node.updateMix(this, mixId, volume);
+    }
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    async updateNodeLinkMix(mixId, volume) {
+        return this.updateMix(mixId, volume);
+    }
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    async removeMix(mixId) {
+        return this.node.removeMix(this, mixId);
+    }
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    async removeNodeLinkMix(mixId) {
+        return this.removeMix(mixId);
+    }
     /**
      * Sets the volume of the player.
      * @param {number} volume - The new volume. Must be between 0 and 500 when using filter mode (100 = 100%).
@@ -526,6 +707,18 @@ class Player {
     async getSponsorBlock() {
         return this.node.getSponsorBlock(this);
     }
+    /** Returns the complete NodeLink SponsorBlock state. */
+    async getNodeLinkSponsorBlockState() {
+        return this.node.getNodeLinkSponsorBlockState(this);
+    }
+    /** Updates NodeLink SponsorBlock categories, actions, margin, or enabled state. */
+    async updateNodeLinkSponsorBlock(update) {
+        return this.node.updateNodeLinkSponsorBlock(this, update);
+    }
+    /** Replaces NodeLink's SponsorBlock segments with an explicit segment list. */
+    async setNodeLinkSponsorBlockSegments(segments) {
+        return this.node.setNodeLinkSponsorBlockSegments(this, segments);
+    }
     /**
      * Deletes the sponsorblock for the player. This will remove all sponsorblock segments that have been set for the player.
      * @returns {Promise<void>}
@@ -1040,10 +1233,11 @@ class Player {
             "Client-Name": this.manager.options.clientName,
         };
         const { host, useSSL, port } = this.node.options;
-        this.voiceReceiverWsClient = new ws_1.WebSocket(`${useSSL ? "wss" : "ws"}://${host}:${port}/connection/data`, { headers });
+        this.voiceReceiverReconnectTries = this.node.options.maxRetryAttempts ?? this.voiceReceiverReconnectTries;
+        this.voiceReceiverWsClient = new ws_1.WebSocket(`${useSSL ? "wss" : "ws"}://${host}:${port}/v4/websocket/voice/${this.guildId}`, { headers });
         this.voiceReceiverWsClient.on("open", () => this.openVoiceReceiver());
         this.voiceReceiverWsClient.on("error", (err) => this.onVoiceReceiverError(err));
-        this.voiceReceiverWsClient.on("message", (rawMessage) => this.onVoiceReceiverMessage(rawMessage.toString()));
+        this.voiceReceiverWsClient.on("message", (rawMessage) => this.onVoiceReceiverMessage(rawMessage));
         this.voiceReceiverWsClient.on("close", (code, reason) => this.closeVoiceReceiver(code, reason.toString()));
     }
     /**
@@ -1065,6 +1259,7 @@ class Player {
             this.voiceReceiverWsClient = null;
         }
         this.isConnectToVoiceReceiver = false;
+        this.voiceReceiverStreams.clear();
     }
     /**
      * Closes the voice receiver for the player.
@@ -1108,6 +1303,8 @@ class Player {
         this.voiceReceiverWsClient?.close(1000, "destroy");
         this.voiceReceiverWsClient?.removeAllListeners();
         this.voiceReceiverWsClient = null;
+        this.voiceReceiverStreams.clear();
+        this.isConnectToVoiceReceiver = false;
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Disconnected from voice receiver for player ${this.guildId}`);
         this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverDisconnect, this);
     }
@@ -1125,14 +1322,28 @@ class Player {
     }
     /**
      * Handles a voice receiver message.
-     * @param {string} payload - The payload to handle.
+     * @param {RawData} payload - The payload to handle.
      * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
      */
     async onVoiceReceiverMessage(payload) {
-        const packet = JSON.parse(payload);
+        const buffer = this.toVoiceReceiverBuffer(payload);
+        const parsedFrame = this.parseNodeLinkVoiceFrame(buffer);
+        if (parsedFrame) {
+            this.handleNodeLinkVoiceFrame(parsedFrame);
+            return;
+        }
+        const textPayload = buffer.toString();
+        let packet;
+        try {
+            packet = JSON.parse(textPayload);
+        }
+        catch {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved an unknown binary payload for player ${this.guildId}`);
+            return;
+        }
         if (!packet?.op)
             return;
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved a payload: ${Utils_1.JSONUtils.safe(payload, 2)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved a payload: ${Utils_1.JSONUtils.safe(textPayload, 2)}`);
         switch (packet.type) {
             case "startSpeakingEvent": {
                 this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverStartSpeaking, this, packet.data);
@@ -1141,17 +1352,94 @@ class Player {
             case "endSpeakingEvent": {
                 const data = {
                     ...packet.data,
-                    data: Buffer.from(packet.data.data, "base64"),
+                    data: Buffer.isBuffer(packet.data.data) ? packet.data.data : Buffer.from(packet.data.data, "base64"),
                 };
                 this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverEndSpeaking, this, data);
                 break;
             }
             default: {
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved an unknown payload: ${Utils_1.JSONUtils.safe(payload, 2)}`);
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved an unknown payload: ${Utils_1.JSONUtils.safe(textPayload, 2)}`);
                 break;
             }
         }
     }
+    toVoiceReceiverBuffer(payload) {
+        if (Buffer.isBuffer(payload))
+            return payload;
+        if (payload instanceof ArrayBuffer)
+            return Buffer.from(payload);
+        return Buffer.concat(payload);
+    }
+    parseNodeLinkVoiceFrame(payload) {
+        if (payload.length < 12)
+            return null;
+        let offset = 0;
+        const op = payload.readUInt8(offset++);
+        if (op < 1 || op > 3)
+            return null;
+        const format = payload.readUInt8(offset++);
+        const guildLength = payload.readUInt8(offset++);
+        if (offset + guildLength > payload.length)
+            return null;
+        const guildId = payload.toString("utf8", offset, offset + guildLength);
+        offset += guildLength;
+        if (offset >= payload.length)
+            return null;
+        const userLength = payload.readUInt8(offset++);
+        if (offset + userLength + 8 > payload.length)
+            return null;
+        const userId = payload.toString("utf8", offset, offset + userLength);
+        offset += userLength;
+        const ssrc = payload.readUInt32BE(offset);
+        offset += 4;
+        const timestamp = payload.readUInt32BE(offset);
+        offset += 4;
+        const type = format === 2 ? "pcm_s16le" : format === 1 ? "ogg" : "opus";
+        return { op, type, guildId, userId, ssrc, timestamp, data: payload.subarray(offset) };
+    }
+    handleNodeLinkVoiceFrame(frame) {
+        const key = `${frame.guildId}:${frame.ssrc}`;
+        if (frame.op === 1) {
+            this.voiceReceiverStreams.set(key, { guildId: frame.guildId, userId: frame.userId, type: frame.type, chunks: [] });
+            this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverStartSpeaking, this, {
+                userId: frame.userId,
+                guildId: frame.guildId,
+                ssrc: frame.ssrc,
+                type: frame.type,
+                timestamp: frame.timestamp,
+            });
+            return;
+        }
+        if (frame.op === 3) {
+            const stream = this.voiceReceiverStreams.get(key) ?? { guildId: frame.guildId, userId: frame.userId, type: frame.type, chunks: [] };
+            stream.chunks.push(frame.data);
+            this.voiceReceiverStreams.set(key, stream);
+            this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverData, this, {
+                userId: frame.userId,
+                guildId: frame.guildId,
+                data: frame.data,
+                type: frame.type,
+                ssrc: frame.ssrc,
+                timestamp: frame.timestamp,
+            });
+            return;
+        }
+        if (frame.op === 2) {
+            const stream = this.voiceReceiverStreams.get(key);
+            const chunks = stream?.chunks ?? [];
+            if (frame.data.length > 0)
+                chunks.push(frame.data);
+            this.voiceReceiverStreams.delete(key);
+            this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverEndSpeaking, this, {
+                userId: stream?.userId ?? frame.userId,
+                guildId: stream?.guildId ?? frame.guildId,
+                data: Buffer.concat(chunks),
+                type: stream?.type ?? frame.type,
+                ssrc: frame.ssrc,
+                timestamp: frame.timestamp,
+            });
+        }
+    }
     /**
      * Handles a voice receiver error.
      * @param {Error} error - The error to handle.

package/dist/structures/Rest.d.ts

@@ -1,6 +1,7 @@
 import { Node } from "./Node";
+import { type Response as UndiciResponse } from "undici";
 import { Manager } from "./Manager";
-import { LavalinkSession, LavaPlayer, RestPlayOptions } from "./Types";
+import { LavalinkInfo, LavalinkSession, LavaPlayer, NodeLinkConnectionInfo, NodeLinkLoadStreamOptions, NodeLinkMeaningResult, NodeLinkTrackEncodeInput, NodeLinkTrackStreamResult, NodeStats, RestPlayOptions, RoutePlannerStatus, TrackData } from "./Types";
 /** Handles the requests sent to the Lavalink REST API. */
 export declare class Rest {
     /** The Node that this Rest instance is connected to. */
@@ -32,6 +33,11 @@ export declare class Rest {
      * @returns {Promise<LavaPlayer>} Returns the player.
      */
     getPlayer(guildId: string): Promise<LavaPlayer>;
+    /**
+     * Retrieves all players that belong to the current session.
+     * @returns {Promise<LavaPlayer[]>} Returns the players.
+     */
+    getPlayers(): Promise<LavaPlayer[]>;
     /**
      * Sends a PATCH request to update player related data.
      * @param {RestPlayOptions} options The options to update the player with.
@@ -51,6 +57,59 @@ export declare class Rest {
      * @returns {Promise<LavalinkSession>} The updated session.
      */
     updateSession(resuming: boolean, timeout: number): Promise<LavalinkSession>;
+    /**
+     * Decodes a single Lavalink track.
+     * @param {string} encodedTrack The encoded track string.
+     * @returns {Promise<TrackData>} The decoded track.
+     */
+    decodeTrack(encodedTrack: string): Promise<TrackData>;
+    /**
+     * Decodes multiple Lavalink tracks.
+     * @param {string[]} encodedTracks The encoded track strings.
+     * @returns {Promise<TrackData[]>} The decoded tracks.
+     */
+    decodeTracks(encodedTracks: string[]): Promise<TrackData[]>;
+    /**
+     * Retrieves this node's Lavalink info.
+     * @returns {Promise<LavalinkInfo>} The node info.
+     */
+    getInfo(): Promise<LavalinkInfo>;
+    /**
+     * Retrieves this node's current stats.
+     * @returns {Promise<NodeStats>} The node stats.
+     */
+    getStats(): Promise<NodeStats>;
+    /** Returns NodeLink connection diagnostics. */
+    getNodeLinkConnection(): Promise<NodeLinkConnectionInfo>;
+    /** Encodes one track info payload using NodeLink. */
+    encodeNodeLinkTrack(track: NodeLinkTrackEncodeInput): Promise<string>;
+    /** Encodes multiple track info payloads using NodeLink. */
+    encodeNodeLinkTracks(tracks: NodeLinkTrackEncodeInput[]): Promise<string[]>;
+    /** Loads NodeLink meaning/background information for an encoded track. */
+    getNodeLinkMeaning(encodedTrack: string, language?: string): Promise<NodeLinkMeaningResult>;
+    /** Resolves NodeLink's direct stream URL and format metadata. */
+    getNodeLinkTrackStream(encodedTrack: string, itag?: number): Promise<NodeLinkTrackStreamResult>;
+    /** Opens NodeLink's raw PCM stream response. The caller consumes response.body. */
+    loadNodeLinkPcmStream(encodedTrack: string, options?: NodeLinkLoadStreamOptions): Promise<UndiciResponse>;
+    /**
+     * Retrieves the route planner status.
+     * @returns {Promise<RoutePlannerStatus>} The route planner status.
+     */
+    getRoutePlannerStatus(): Promise<RoutePlannerStatus>;
+    /**
+     * Unmarks a failed route planner address.
+     * @param {string} address The address to free.
+     * @returns {Promise<void>} Void.
+     */
+    freeRoutePlannerAddress(address: string): Promise<void>;
+    /**
+     * Unmarks all failed route planner addresses.
+     * @returns {Promise<void>} Void.
+     */
+    freeAllRoutePlannerAddresses(): Promise<void>;
+    private assertUpdatePlayerSupported;
+    private assertNodeLink;
+    private assertEncodedTrack;
     /**
      * Sends a request to the specified endpoint and returns the response data.
      * @param {string} method The HTTP method to use for the request.
@@ -78,7 +137,7 @@ export declare class Rest {
      * @param {unknown} body The data to send in the request body.
      * @returns {Promise<T>} The response data of the POST request.
      */
-    post<T>(endpoint: string, body: unknown): Promise<T>;
+    post<T>(endpoint: string, body?: unknown): Promise<T>;
     /**
      * Sends a PUT request to the specified endpoint and returns the response data.
      * @param {string} endpoint The endpoint to send the PUT request to.