magmastream 2.10.3-dev.2 → 2.10.4

package/dist/structures/Node.js

@@ -370,8 +370,9 @@ class Node {
      *
      * @param request - The incoming message.
      */
-    upgrade(request) {
-        this.isNodeLink = this.options.isNodeLink ?? Boolean(request.headers.isnodelink) ?? false;
+    upgrade({ headers }) {
+        this.isNodeLink = Boolean(this.options.isNodeLink) || String(headers.iamnodelink ?? headers.isnodelink).includes("true");
+        this.rest.isNodeLink = this.isNodeLink;
     }
     /**
      * Handles the "open" event emitted by the WebSocket connection.
@@ -470,29 +471,29 @@ class Node {
             messagePayload = Buffer.concat(messagePayload);
         else if (messagePayload instanceof ArrayBuffer)
             messagePayload = Buffer.from(messagePayload);
-        const payload = JSON.parse(messagePayload.toString());
-        if (!payload.op)
+        let payload;
+        try {
+            payload = JSON.parse(messagePayload.toString());
+        }
+        catch (cause) {
+            this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                message: "Received an invalid JSON gateway payload.",
+                cause: cause instanceof Error ? cause : undefined,
+            }));
+            return;
+        }
+        if (!payload || typeof payload !== "object" || !("op" in payload) || typeof payload.op !== "string")
             return;
         this.manager.emit(Enums_1.ManagerEventTypes.NodeRaw, payload);
-        let player;
         switch (payload.op) {
             case "stats":
-                delete payload.op;
-                this.stats = { ...payload };
+                this.stats = this.normalizeStats(payload);
                 break;
             case "playerUpdate":
-                player = this.manager.players.get(payload.guildId);
-                if (player && player.node.options.identifier !== this.options.identifier) {
-                    return;
-                }
-                if (player)
-                    player.position = payload.state.position || 0;
+                this.handlePlayerUpdate(payload);
                 break;
             case "event":
-                player = this.manager.players.get(payload.guildId);
-                if (player && player.node.options.identifier !== this.options.identifier) {
-                    return;
-                }
                 this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Node message: ${Utils_1.JSONUtils.safe(payload, 2)}`);
                 await this.handleEvent(payload);
                 break;
@@ -507,6 +508,8 @@ class Node {
                 this.sessionId = payload.sessionId;
                 await this.updateSessionId();
                 this.info = await this.fetchInfo();
+                this.isNodeLink = this.isNodeLink || Boolean(this.info.isNodelink);
+                this.rest.isNodeLink = this.isNodeLink;
                 if (payload.resumed || !hadPreviousSession) {
                     await this.manager.loadPlayerStates(this.options.identifier);
                 }
@@ -518,10 +521,32 @@ class Node {
                 }
                 break;
             default:
-                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new Error(`Unexpected op "${payload.op}" with data: ${payload.message}`));
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new Error("Unexpected gateway operation."));
                 return;
         }
     }
+    normalizeStats(payload) {
+        const stats = { ...payload };
+        delete stats.op;
+        const nodelinkLoad = stats.cpu?.nodelinkLoad;
+        const lavalinkLoad = stats.cpu?.lavalinkLoad ?? nodelinkLoad ?? 0;
+        return {
+            ...stats,
+            cpu: {
+                ...stats.cpu,
+                lavalinkLoad,
+                ...(typeof nodelinkLoad === "number" ? { nodelinkLoad } : {}),
+            },
+        };
+    }
+    handlePlayerUpdate(payload) {
+        const player = this.manager.players.get(payload.guildId);
+        if (!player || player.node.options.identifier !== this.options.identifier)
+            return;
+        player.position = payload.state.position ?? 0;
+        // Transport status can lag lifecycle events; expose it without overwriting player.state.
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerUpdate, player, payload);
+    }
     /**
      * Handles an event emitted from the Lavalink node.
      * @param {PlayerEvent & PlayerEvents} payload The event emitted from the node.
@@ -529,21 +554,42 @@ class Node {
      * @private
      */
     async handleEvent(payload) {
-        if (!payload.guildId)
+        if (payload.type === "ConnectionStatusEvent") {
+            this.markAsNodeLink();
+            this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, payload);
+            this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkConnectionStatus, this, payload);
             return;
+        }
+        if (payload.type === "WorkerFailedEvent") {
+            this.markAsNodeLink();
+            this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, payload);
+            this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkWorkerFailed, this, payload);
+            return;
+        }
+        if (!("guildId" in payload) || typeof payload.guildId !== "string") {
+            if (this.isNodeLink)
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, payload);
+            return;
+        }
         const player = this.manager.players.get(payload.guildId);
-        if (!player)
+        if (!player || player.node.options.identifier !== this.options.identifier) {
+            if (this.isNodeLink)
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, payload);
             return;
-        const track = await player.queue.getCurrent();
+        }
+        if (this.handleNodeLinkEvent(player, payload))
+            return;
+        const track = await this.resolveEventTrack(player, payload);
         const type = payload.type;
-        const TRACK_EVENTS = ["TrackStartEvent", "TrackEndEvent", "TrackStuckEvent", "TrackExceptionEvent"];
-        if (!track && TRACK_EVENTS.includes(type)) {
-            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[Node] Received ${type} for guild ${payload.guildId} but queue has no current track — ignoring.`);
+        const trackRequiredEvents = ["TrackStartEvent", "TrackEndEvent", "TrackStuckEvent", "TrackExceptionEvent"];
+        if (!track && trackRequiredEvents.includes(type)) {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Received ${type} for guild ${payload.guildId}, but neither the payload nor local queue contains a usable track.`);
             return;
         }
-        let error;
         switch (type) {
             case "TrackStartEvent":
+                if ((await player.queue.getCurrent())?.track !== track?.track)
+                    await player.queue.setCurrent(track);
                 this.trackStart(player, track, payload);
                 break;
             case "TrackEndEvent":
@@ -566,9 +612,11 @@ class Node {
                 this.socketClosed(player, payload);
                 break;
             case "SegmentsLoaded":
+            case "SponsorBlockSegmentsLoadedEvent":
                 this.sponsorBlockSegmentLoaded(player, track, payload);
                 break;
             case "SegmentSkipped":
+            case "SponsorBlockSegmentSkippedEvent":
                 this.sponsorBlockSegmentSkipped(player, track, payload);
                 break;
             case "ChaptersLoaded":
@@ -587,11 +635,170 @@ class Node {
                 this.lyricsLine(player, track, payload);
                 break;
             default:
-                error = new Error(`Node#event unknown event '${type}'.`);
-                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, error);
+                if (this.isNodeLink) {
+                    this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, payload);
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Unrecognized NodeLink or plugin event '${type}' was forwarded through nodeLinkEvent.`);
+                    return;
+                }
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new Error(`Node#event unknown event '${type}'.`));
                 break;
         }
     }
+    markAsNodeLink() {
+        this.isNodeLink = true;
+        this.rest.isNodeLink = true;
+    }
+    async resolveEventTrack(player, payload) {
+        const current = await player.queue.getCurrent();
+        const rawTrack = "track" in payload ? payload.track : null;
+        if (!rawTrack || typeof rawTrack !== "object" || !("encoded" in rawTrack) || !("info" in rawTrack) || typeof rawTrack.encoded !== "string")
+            return current;
+        try {
+            return Utils_1.TrackUtils.build(rawTrack, current?.requester, current?.isAutoplay ?? false);
+        }
+        catch (error) {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to normalize event track for guild ${player.guildId}: ${error instanceof Error ? error.message : String(error)}`);
+            return current;
+        }
+    }
+    handleNodeLinkEvent(player, payload) {
+        if (!("guildId" in payload))
+            return false;
+        switch (payload.type) {
+            case "VolumeChangedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                const oldVolume = player.volume;
+                const oldPlayer = { ...player };
+                player.volume = event.volume;
+                player.options.volume = event.volume;
+                this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
+                    changeType: Enums_1.PlayerStateEventTypes.VolumeChange,
+                    details: {
+                        type: "volume",
+                        action: "adjust",
+                        previousVolume: oldVolume,
+                        currentVolume: player.volume,
+                    },
+                });
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkVolumeChanged, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "PauseEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                const oldPaused = player.paused;
+                const oldPlayer = { ...player };
+                player.paused = event.paused;
+                player.playing = !event.paused;
+                this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
+                    changeType: Enums_1.PlayerStateEventTypes.PauseChange,
+                    details: {
+                        type: "pause",
+                        action: event.paused ? "pause" : "resume",
+                        previousPause: oldPaused,
+                        currentPause: player.paused,
+                    },
+                });
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkPause, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "SeekEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                player.position = event.position;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkSeek, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "FiltersChangedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                player.filters.syncFromNode(event.filters);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkFiltersChanged, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "PlayerCreatedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                player.volume = event.player.volume;
+                player.options.volume = event.player.volume;
+                player.paused = event.player.paused;
+                player.playing = Boolean(event.player.track) && !event.player.paused;
+                player.position = event.player.state.position;
+                player.filters.syncFromNode(event.player.filters);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkPlayerCreated, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "PlayerDestroyedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                player.playing = false;
+                player.paused = false;
+                player.state = Enums_1.StateTypes.Disconnected;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkPlayerDestroyed, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "PlayerConnectedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                player.state = Enums_1.StateTypes.Connected;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkPlayerConnected, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "PlayerReconnectingEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                player.state = Enums_1.StateTypes.Connecting;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkPlayerReconnecting, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "MixStartedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                this.manager.emit(Enums_1.ManagerEventTypes.MixStarted, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "MixEndedEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                this.manager.emit(Enums_1.ManagerEventTypes.MixEnded, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "EternalBoxInfoEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEternalBoxInfo, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "EternalBoxJumpEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEternalBoxJump, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            case "StreamMetadataEvent": {
+                this.markAsNodeLink();
+                const event = payload;
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkStreamMetadata, player, event);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeLinkEvent, this, event);
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
     /**
      * Emitted when a new track starts playing.
      * @param {Player} player The player that started playing the track.
@@ -600,7 +807,7 @@ class Node {
      * @private
      */
     trackStart(player, track, payload) {
-        const oldPlayer = player;
+        const oldPlayer = { ...player };
         player.playing = true;
         player.paused = false;
         this.manager.emit(Enums_1.ManagerEventTypes.TrackStart, player, track, payload);
@@ -641,7 +848,7 @@ class Node {
             await player.queue.addPrevious(current);
         }
         player.set("skipFlag", false);
-        const oldPlayer = player;
+        const oldPlayer = { ...player };
         switch (reason) {
             case Enums_1.TrackEndReasonTypes.LoadFailed:
             case Enums_1.TrackEndReasonTypes.Cleanup:
@@ -671,6 +878,12 @@ class Node {
                     await this.queueEnd(player, track, payload);
                 }
                 break;
+            case Enums_1.TrackEndReasonTypes.Gapless:
+                await player.queue.setCurrent((await player.queue.dequeue()) ?? null);
+                player.playing = true;
+                player.paused = false;
+                this.manager.emit(Enums_1.ManagerEventTypes.TrackEnd, player, track, payload);
+                break;
             default:
                 this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new Error(`Unexpected track end reason "${reason}"`));
                 break;
@@ -849,7 +1062,7 @@ class Node {
             });
         }
         if (this.isNodeLink) {
-            return (await this.rest.get(`/v4/loadlyrics?encodedTrack=${encodeURIComponent(track.track)}${language ? `&language=${language}` : ""}`));
+            return (await this.rest.get(`/v4/loadlyrics?encodedTrack=${encodeURIComponent(track.track)}${language ? `&lang=${encodeURIComponent(language)}` : ""}`));
         }
         const requiredPlugins = ["lavalyrics-plugin"];
         for (const plugin of requiredPlugins) {
@@ -871,6 +1084,41 @@ class Node {
         const lyrics = (await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`));
         return lyrics || { source: null, provider: null, text: null, lines: [], plugin: [] };
     }
+    /**
+     * Loads chapters for a track using NodeLink.
+     * @param {Track} track - The track to load chapters for.
+     * @returns {Promise<NodeLinkChapter[]>} A promise that resolves with the chapter list.
+     */
+    async getChapters(track) {
+        if (!this.connected) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_DISCONNECTED,
+                message: `The node is not connected to the lavalink server.`,
+                context: { identifier: this.options.identifier },
+            });
+        }
+        if (!this.isNodeLink) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                message: `The node is not a NodeLink, cannot load chapters.`,
+                context: { identifier: this.options.identifier },
+            });
+        }
+        return (await this.rest.get(`/v4/loadchapters?encodedTrack=${encodeURIComponent(track.track)}`));
+    }
+    /**
+     * Loads chapters for a track using NodeLink.
+     * @param {Track} track - The track to load chapters for.
+     * @returns {Promise<NodeLinkChapter[]>} A promise that resolves with the chapter list.
+     */
+    async getNodeLinkChapters(track) {
+        return this.getChapters(track);
+    }
+    /** Loads NodeLink meaning/background information for a track. */
+    async getNodeLinkMeaning(track, language = "en") {
+        this.assertNodeLinkFeature("load track meaning");
+        return this.rest.getNodeLinkMeaning(track.track, language);
+    }
     /**
      * Subscribes to lyrics for a player.
      * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
@@ -886,13 +1134,8 @@ class Node {
                 context: { identifier: this.options.identifier },
             });
         }
-        if (this.isNodeLink) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
-                message: `The node is a NodeLink, cannot subscribe to lyrics.`,
-                context: { identifier: this.options.identifier },
-            });
-        }
+        if (this.isNodeLink)
+            return await this.rest.post(`/v4/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe?skipTrackSource=${skipTrackSource}`, {});
         const requiredPlugins = ["lavalyrics-plugin"];
         for (const plugin of requiredPlugins) {
             if (!this.info.plugins.some((p) => p.name === plugin)) {
@@ -938,13 +1181,8 @@ class Node {
                 context: { identifier: this.options.identifier },
             });
         }
-        if (this.isNodeLink) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
-                message: `The node is a NodeLink, cannot unsubscribe from lyrics.`,
-                context: { identifier: this.options.identifier },
-            });
-        }
+        if (this.isNodeLink)
+            return await this.rest.delete(`/v4/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe`);
         if (!this.info.plugins.some((plugin) => plugin.name === "java-lyrics-plugin")) {
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.NODE_PLUGIN_ERROR,
@@ -1001,6 +1239,7 @@ class Node {
      * @param {WebSocketClosedEvent} payload - The event payload containing additional data about the WebSocket close event.
      */
     socketClosed(player, payload) {
+        player.state = Enums_1.StateTypes.Disconnected;
         this.manager.emit(Enums_1.ManagerEventTypes.SocketClosed, player, payload);
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Websocket closed for player: ${player.guildId} with payload: ${Utils_1.JSONUtils.safe(payload, 2)}`);
     }
@@ -1079,7 +1318,7 @@ class Node {
      * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
      */
     async fetchInfo() {
-        return (await this.rest.get(`/v4/info`));
+        return await this.rest.getInfo();
     }
     /**
      * Gets the current sponsorblock segments for a player.
@@ -1088,6 +1327,22 @@ class Node {
      * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
      */
     async getSponsorBlock(player) {
+        if (this.isNodeLink) {
+            try {
+                const state = (await this.rest.get(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock`));
+                return state.categories.map((segment) => segment);
+            }
+            catch (err) {
+                throw err instanceof MagmastreamError_1.MagmaStreamError
+                    ? err
+                    : new MagmastreamError_1.MagmaStreamError({
+                        code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                        message: "Failed to fetch NodeLink SponsorBlock state.",
+                        cause: err instanceof Error ? err : undefined,
+                        context: { identifier: this.options.identifier, guildId: player.guildId },
+                    });
+            }
+        }
         if (!this.info.plugins.some((plugin) => plugin.name === "sponsorblock-plugin")) {
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.NODE_PLUGIN_ERROR,
@@ -1109,6 +1364,166 @@ class Node {
                 });
         }
     }
+    /** Returns the complete NodeLink SponsorBlock state for a player. */
+    async getNodeLinkSponsorBlockState(player) {
+        this.assertNodeLinkFeature("get SponsorBlock state");
+        return await this.rest.get(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock`);
+    }
+    /** Updates NodeLink SponsorBlock behavior for a player. */
+    async updateNodeLinkSponsorBlock(player, update) {
+        this.assertNodeLinkFeature("update SponsorBlock state");
+        this.assertNodeLinkSponsorBlockUpdate(update);
+        return await this.rest.patch(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock`, update);
+    }
+    /** Replaces the NodeLink SponsorBlock segment list for a player. */
+    async setNodeLinkSponsorBlockSegments(player, segments) {
+        this.assertNodeLinkFeature("set SponsorBlock segments");
+        if (!Array.isArray(segments) || !segments.every((segment) => this.isValidNodeLinkSponsorBlockSegment(segment))) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                message: "NodeLink SponsorBlock segments must match the NodeLink segment schema.",
+                context: { identifier: this.options.identifier, guildId: player.guildId },
+            });
+        }
+        return await this.rest.post(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock`, { segments });
+    }
+    /**
+     * Adds a NodeLink audio mix layer to the player.
+     * @param {Player} player - The player to add the mix to.
+     * @param {Track} track - The track to mix over the current playback.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    async addMix(player, track, volume) {
+        this.assertNodeLinkFeature("add an audio mix layer");
+        this.assertMixVolume(volume);
+        return (await this.rest.post(`/v4/sessions/${this.sessionId}/players/${player.guildId}/mix`, {
+            track: { encoded: track.track },
+            ...(typeof volume === "number" && { volume }),
+        }));
+    }
+    /**
+     * Adds a NodeLink audio mix layer to the player.
+     * @param {Player} player - The player to add the mix to.
+     * @param {Track} track - The track to mix over the current playback.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    async addNodeLinkMix(player, track, volume) {
+        return this.addMix(player, track, volume);
+    }
+    /**
+     * Gets the active NodeLink audio mix layers for the player.
+     * @param {Player} player - The player to fetch mixes for.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    async getMixes(player) {
+        this.assertNodeLinkFeature("get audio mix layers");
+        const response = (await this.rest.get(`/v4/sessions/${this.sessionId}/players/${player.guildId}/mix`));
+        return response.mixes ?? [];
+    }
+    /**
+     * Gets the active NodeLink audio mix layers for the player.
+     * @param {Player} player - The player to fetch mixes for.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    async getNodeLinkMixes(player) {
+        return this.getMixes(player);
+    }
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    async updateMix(player, mixId, volume) {
+        this.assertNodeLinkFeature("update an audio mix layer");
+        this.assertMixVolume(volume);
+        await this.rest.patch(`/v4/sessions/${this.sessionId}/players/${player.guildId}/mix/${encodeURIComponent(mixId)}`, { volume });
+    }
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    async updateNodeLinkMix(player, mixId, volume) {
+        return this.updateMix(player, mixId, volume);
+    }
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    async removeMix(player, mixId) {
+        this.assertNodeLinkFeature("remove an audio mix layer");
+        await this.rest.delete(`/v4/sessions/${this.sessionId}/players/${player.guildId}/mix/${encodeURIComponent(mixId)}`);
+    }
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    async removeNodeLinkMix(player, mixId) {
+        return this.removeMix(player, mixId);
+    }
+    assertNodeLinkFeature(action) {
+        if (this.isNodeLink && this.connected)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: this.connected ? Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR : Enums_1.MagmaStreamErrorCode.NODE_DISCONNECTED,
+            message: this.connected ? `The node is not a NodeLink, cannot ${action}.` : `The node is not connected to the lavalink server.`,
+            context: { identifier: this.options.identifier },
+        });
+    }
+    assertMixVolume(volume) {
+        if (volume === undefined)
+            return;
+        if (typeof volume === "number" && Number.isFinite(volume) && volume >= 0 && volume <= 1)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: "NodeLink mix volume must be between 0 and 1.",
+            context: { identifier: this.options.identifier, volume },
+        });
+    }
+    assertNodeLinkSponsorBlockUpdate(update) {
+        const valid = update !== null &&
+            typeof update === "object" &&
+            (update.enabled === undefined || typeof update.enabled === "boolean") &&
+            (update.categories === undefined || (Array.isArray(update.categories) && update.categories.every((value) => typeof value === "string"))) &&
+            (update.actionTypes === undefined || (Array.isArray(update.actionTypes) && update.actionTypes.every((value) => typeof value === "string"))) &&
+            (update.skipMarginMs === undefined || (typeof update.skipMarginMs === "number" && Number.isFinite(update.skipMarginMs) && update.skipMarginMs >= 0));
+        if (valid)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: "Invalid NodeLink SponsorBlock update payload.",
+            context: { identifier: this.options.identifier, update },
+        });
+    }
+    isValidNodeLinkSponsorBlockSegment(segment) {
+        return (segment !== null &&
+            typeof segment === "object" &&
+            typeof segment.uuid === "string" &&
+            typeof segment.start === "number" &&
+            Number.isFinite(segment.start) &&
+            typeof segment.end === "number" &&
+            Number.isFinite(segment.end) &&
+            segment.end >= segment.start &&
+            typeof segment.category === "string" &&
+            typeof segment.actionType === "string" &&
+            typeof segment.votes === "number" &&
+            Number.isFinite(segment.votes) &&
+            typeof segment.locked === "boolean" &&
+            typeof segment.videoDuration === "number" &&
+            Number.isFinite(segment.videoDuration) &&
+            typeof segment.description === "string");
+    }
     /**
      * Sets the sponsorblock segments for a player.
      * @param {Player} player - The player to set the sponsor blocks for.
@@ -1124,13 +1539,6 @@ class Node {
      * ```
      */
     async setSponsorBlock(player, segments = [Enums_1.SponsorBlockSegment.Sponsor, Enums_1.SponsorBlockSegment.SelfPromo]) {
-        if (!this.info.plugins.some((plugin) => plugin.name === "sponsorblock-plugin")) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.NODE_PLUGIN_ERROR,
-                message: `The plugin "sponsorblock-plugin" must be present in the lavalink node to set SponsorBlock segments.`,
-                context: { identifier: this.options.identifier, guildId: player.guildId },
-            });
-        }
         if (!segments.length) {
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
@@ -1145,8 +1553,35 @@ class Node {
                 context: { identifier: this.options.identifier, guildId: player.guildId, invalidSegments: segments },
             });
         }
+        const categories = segments.map((segment) => segment.toLowerCase());
+        if (this.isNodeLink) {
+            try {
+                await this.rest.patch(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock`, {
+                    enabled: true,
+                    categories,
+                });
+                return;
+            }
+            catch (err) {
+                throw err instanceof MagmastreamError_1.MagmaStreamError
+                    ? err
+                    : new MagmastreamError_1.MagmaStreamError({
+                        code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                        message: "Failed to set NodeLink SponsorBlock categories.",
+                        cause: err instanceof Error ? err : undefined,
+                        context: { identifier: this.options.identifier, guildId: player.guildId, segments },
+                    });
+            }
+        }
+        if (!this.info.plugins.some((plugin) => plugin.name === "sponsorblock-plugin")) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PLUGIN_ERROR,
+                message: `The plugin "sponsorblock-plugin" must be present in the lavalink node to set SponsorBlock segments.`,
+                context: { identifier: this.options.identifier, guildId: player.guildId },
+            });
+        }
         try {
-            await this.rest.put(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, segments.map((segment) => segment.toLowerCase()));
+            await this.rest.put(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, categories);
         }
         catch (err) {
             throw err instanceof MagmastreamError_1.MagmaStreamError
@@ -1166,6 +1601,22 @@ class Node {
      * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
      */
     async deleteSponsorBlock(player) {
+        if (this.isNodeLink) {
+            try {
+                await this.rest.delete(`/v4/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock`);
+                return;
+            }
+            catch (err) {
+                throw err instanceof MagmastreamError_1.MagmaStreamError
+                    ? err
+                    : new MagmastreamError_1.MagmaStreamError({
+                        code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                        message: "Failed to delete NodeLink SponsorBlock state.",
+                        cause: err instanceof Error ? err : undefined,
+                        context: { identifier: this.options.identifier, guildId: player.guildId },
+                    });
+            }
+        }
         if (!this.info.plugins.some((plugin) => plugin.name === "sponsorblock-plugin")) {
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.NODE_PLUGIN_ERROR,