lavalink-client 1.0.4 → 1.0.6

package/dist/esm/structures/LavalinkManager.js

@@ -42,10 +42,6 @@ export class LavalinkManager extends EventEmitter {
             };
         if (!this.options.autoSkip)
             this.options.autoSkip = true;
-        if (!this.options.defaultLeastLoadNodeSortType)
-            this.options.defaultLeastLoadNodeSortType = "memory";
-        if (!this.options.defaultLeastUsedNodeSortType)
-            this.options.defaultLeastUsedNodeSortType = "players";
         if (!this.options.playerOptions.defaultSearchPlatform)
             this.options.playerOptions.defaultSearchPlatform = "ytsearch";
         // default queue options
@@ -63,13 +59,9 @@ export class LavalinkManager extends EventEmitter {
         if (typeof options.sendToShard !== "function")
             throw new SyntaxError("ManagerOption.sendToShard was not provided, which is required!");
         // only check in .init()
-        // if(typeof options.client !== "object" || typeof options.client.id !== "string") throw new SyntaxError("ManagerOption.client = { id: string, username?:string, shards?: 'auto'|number } was not provided, which is required");
+        // if(typeof options.client !== "object" || typeof options.client.id !== "string") throw new SyntaxError("ManagerOption.client = { id: string, username?:string } was not provided, which is required");
         if (options.autoSkip && typeof options.autoSkip !== "boolean")
             throw new SyntaxError("ManagerOption.autoSkip must be either false | true aka boolean");
-        if (options.defaultLeastLoadNodeSortType && !["memory", "cpu"].includes(options.defaultLeastLoadNodeSortType))
-            throw new SyntaxError("ManagerOption.defaultLeastLoadNodeSortType must be 'memory' | 'cpu'");
-        if (options.defaultLeastUsedNodeSortType && !["memory", "players", "calls"].includes(options.defaultLeastUsedNodeSortType))
-            throw new SyntaxError("ManagerOption.defaultLeastLoadNodeSortType must be 'memory' | 'calls' | 'players'");
         if (!options.nodes || !Array.isArray(options.nodes) || !options.nodes.every(node => this.utils.isNodeOptions(node)))
             throw new SyntaxError("ManagerOption.nodes must be an Array of NodeOptions and is required of at least 1 Node");
         /* QUEUE STORE */
@@ -154,9 +146,7 @@ export class LavalinkManager extends EventEmitter {
      * @param data
      */
     async sendRawData(data) {
-        if (!this.initiated)
-            return;
-        if (!("t" in data))
+        if (!this.initiated || !("t" in data))
             return;
         // for channel Delete
         if ("CHANNEL_DELETE" === data.t) {
@@ -164,9 +154,8 @@ export class LavalinkManager extends EventEmitter {
             if (!update.guild_id)
                 return;
             const player = this.getPlayer(update.guild_id);
-            if (player.voiceChannelId === update.id) {
+            if (player && player.voiceChannelId === update.id)
                 return player.destroy(DestroyReasons.ChannelDeleted);
-            }
         }
         // for voice updates
         if (["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) {

package/dist/esm/structures/Node.d.ts

@@ -4,7 +4,7 @@ import { NodeManager } from "./NodeManager";
 import internal from "stream";
 import { InvalidLavalinkRestRequest, LavalinkPlayer, PlayerUpdateInfo, RoutePlanner, Session, Base64 } from "./Utils";
 import { DestroyReasonsType } from "./Player";
-import { TrackInfo } from "./Track";
+import { Track } from "./Track";
 /** Modifies any outgoing REST requests. */
 export type ModifyRequest = (options: Dispatcher.RequestOptions) => void;
 export interface LavalinkNodeOptions {
@@ -185,13 +185,13 @@ export declare class LavalinkNode {
          * @param encoded
          * @returns
          */
-        singleTrack: (encoded: Base64) => Promise<TrackInfo>;
+        singleTrack: (encoded: Base64, requester: unknown) => Promise<Track>;
         /**
          *
          * @param encodeds Decodes multiple tracks into their info
          * @returns
          */
-        multipleTracks: (encodeds: Base64[]) => Promise<TrackInfo[]>;
+        multipleTracks: (encodeds: Base64[], requester: unknown) => Promise<Track[]>;
     };
     /**
      * Request Lavalink statistics.

package/dist/esm/structures/Node.js

@@ -133,9 +133,8 @@ export class LavalinkNode {
             return;
         const headers = {
             Authorization: this.options.authorization,
-            "Num-Shards": String(this.NodeManager.LavalinkManager.options.client.shards || "auto"),
             "User-Id": this.NodeManager.LavalinkManager.options.client.id,
-            "User-Name": this.NodeManager.LavalinkManager.options.client.username || "Lavalink-Client",
+            "Client-Name": this.NodeManager.LavalinkManager.options.client.username || "Lavalink-Client",
         };
         if (typeof this.options.sessionId === "string" || typeof sessionId === "string") {
             headers["Session-Id"] = this.options.sessionId || sessionId;
@@ -224,25 +223,27 @@ export class LavalinkNode {
          * @param encoded
          * @returns
          */
-        singleTrack: async (encoded) => {
+        singleTrack: async (encoded, requester) => {
             if (!encoded)
                 throw new SyntaxError("No encoded (Base64 string) was provided");
-            return await this.request(`/decodetrack?encodedTrack=${encoded}`);
+            // return the decoded + builded track
+            return this.NodeManager.LavalinkManager.utils.buildTrack(await this.request(`/decodetrack?encodedTrack=${encoded}`), requester);
         },
         /**
          *
          * @param encodeds Decodes multiple tracks into their info
          * @returns
          */
-        multipleTracks: async (encodeds) => {
+        multipleTracks: async (encodeds, requester) => {
             if (!Array.isArray(encodeds) || !encodeds.every(v => typeof v === "string" && v.length > 1))
                 throw new SyntaxError("You need to provide encodeds, which is an array of base64 strings");
+            // return the decoded + builded tracks
             return await this.request(`/decodetracks`, r => {
                 r.method = "POST";
                 r.body = JSON.stringify(encodeds);
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 r.headers["Content-Type"] = "application/json";
-            });
+            }).then((r) => r.map(track => this.NodeManager.LavalinkManager.utils.buildTrack(track, requester)));
         }
     };
     /**
@@ -473,6 +474,7 @@ export class LavalinkNode {
                         player.filterManager.filterUpdatedState = 0;
                     }
                 }
+                this.NodeManager.LavalinkManager.emit("playerUpdate", player);
                 break;
             case "event":
                 this.handleEvent(payload);
@@ -519,6 +521,7 @@ export class LavalinkNode {
         return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
     }
     async trackEnd(player, track, payload) {
+        console.log(payload.reason);
         // If there are no songs in the queue
         if (!player.queue.tracks.length && player.repeatMode === "off")
             return this.queueEnd(player, track, payload);
@@ -527,7 +530,7 @@ export class LavalinkNode {
             return this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
         // If a track had an error while starting
         if (["loadFailed", "cleanup"].includes(payload.reason)) {
-            await queueTrackEnd(player.queue, false);
+            await queueTrackEnd(player);
             // if no track available, end queue
             if (!player.queue.current)
                 return this.queueEnd(player, track, payload);
@@ -538,7 +541,7 @@ export class LavalinkNode {
         }
         // remove tracks from the queue
         if (player.repeatMode !== "track")
-            await queueTrackEnd(player.queue, player.repeatMode === "queue");
+            await queueTrackEnd(player);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
@@ -548,15 +551,17 @@ export class LavalinkNode {
         return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
     async queueEnd(player, track, payload) {
+        // add previous track to the queue!
         player.queue.current = null;
         player.playing = false;
         if (typeof this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function") {
             await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
             if (player.queue.tracks.length > 0)
-                await queueTrackEnd(player.queue, player.repeatMode === "queue");
+                await queueTrackEnd(player);
             if (player.queue.current)
                 return player.play({ noReplace: true, paused: false });
         }
+        player.queue.previous.unshift(track);
         if (payload?.reason !== "stopped") {
             await player.queue.utils.save();
         }
@@ -581,7 +586,7 @@ export class LavalinkNode {
         if (!player.queue.tracks.length && player.repeatMode === "off")
             return;
         // remove the current track, and enqueue the next one
-        await queueTrackEnd(player.queue, player.repeatMode === "queue");
+        await queueTrackEnd(player);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
@@ -591,7 +596,7 @@ export class LavalinkNode {
     async trackError(player, track, payload) {
         this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
         // remove the current track, and enqueue the next one
-        await queueTrackEnd(player.queue, player.repeatMode === "queue");
+        await queueTrackEnd(player);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);

package/dist/esm/structures/NodeManager.d.ts

@@ -55,18 +55,7 @@ export declare class NodeManager extends EventEmitter {
     nodes: MiniMap<string, LavalinkNode>;
     constructor(LavalinkManager: LavalinkManager);
     createNode(options: LavalinkNodeOptions): LavalinkNode;
-    get leastUsedNodes(): LavalinkNode[];
-    /** Returns the least used Nodes sorted by amount of calls. */
-    private get leastUsedNodesCalls();
-    /** Returns the least used Nodes sorted by amount of players. */
-    private get leastUsedNodesPlayers();
-    /** Returns the least used Nodes sorted by amount of memory usage. */
-    private get leastUsedNodesMemory();
-    /** Returns the least system load Nodes. */
-    get leastLoadNodes(): LavalinkNode[];
-    get leastLoadNodesMemory(): LavalinkNode[];
-    /** Returns the least system load Nodes. */
-    get leastLoadNodesCpu(): LavalinkNode[];
+    leastUsedNodes(sortType?: "memory" | "cpuLavalink" | "cpuSystem" | "calls" | "playingPlayers" | "players"): LavalinkNode[];
     deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
 }
 export {};

package/dist/esm/structures/NodeManager.js

@@ -17,68 +17,61 @@ export class NodeManager extends EventEmitter {
         this.nodes.set(newNode.id, newNode);
         return newNode;
     }
-    get leastUsedNodes() {
-        if (this.LavalinkManager.options.defaultLeastUsedNodeSortType === "memory")
-            return this.leastUsedNodesMemory;
-        else if (this.LavalinkManager.options.defaultLeastUsedNodeSortType === "calls")
-            return this.leastUsedNodesCalls;
-        else
-            return this.leastUsedNodesPlayers; // this.options.defaultLeastUsedNodeSortType === "players"
-    }
-    /** Returns the least used Nodes sorted by amount of calls. */
-    get leastUsedNodesCalls() {
-        return [...this.nodes.values()]
-            .filter((node) => node.connected)
-            .sort((a, b) => b.calls - a.calls); // client sided sorting
-    }
-    /** Returns the least used Nodes sorted by amount of players. */
-    get leastUsedNodesPlayers() {
-        return [...this.nodes.values()]
-            .filter((node) => node.connected)
-            .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
-    }
-    /** Returns the least used Nodes sorted by amount of memory usage. */
-    get leastUsedNodesMemory() {
-        return [...this.nodes.values()]
-            .filter((node) => node.connected)
-            .sort((a, b) => (b.stats?.memory?.used || 0) - (a.stats?.memory?.used || 0)); // sort after memory
-    }
-    /** Returns the least system load Nodes. */
-    get leastLoadNodes() {
-        if (this.LavalinkManager.options.defaultLeastLoadNodeSortType === "cpu")
-            return this.leastLoadNodesCpu;
-        else
-            return this.leastLoadNodesMemory; // this.options.defaultLeastLoadNodeSortType === "memory"
-    }
-    get leastLoadNodesMemory() {
-        return [...this.nodes.values()]
-            .filter((node) => node.connected)
-            .sort((a, b) => {
-            const aload = a.stats.memory?.used
-                ? a.stats.memory.used
-                : 0;
-            const bload = b.stats.memory?.used
-                ? b.stats.memory.used
-                : 0;
-            return aload - bload;
-        });
-    }
-    /** Returns the least system load Nodes. */
-    get leastLoadNodesCpu() {
-        return [...this.nodes.values()]
-            .filter((node) => node.connected)
-            .sort((a, b) => {
-            const aload = a.stats.cpu
-                ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100
-                : 0;
-            const bload = b.stats.cpu
-                ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100
-                : 0;
-            return aload - bload;
-        });
+    leastUsedNodes(sortType = "players") {
+        switch (sortType) {
+            case "memory":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0)); // sort after memor
+                }
+                break;
+            case "cpuLavalink":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.cpu?.lavalinkLoad || 0) - (b.stats?.cpu?.lavalinkLoad || 0)); // sort after memor
+                }
+                break;
+            case "cpuSystem":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0)); // sort after memor
+                }
+                break;
+            case "calls":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => a.calls - b.calls); // client sided sorting
+                }
+                break;
+            case "playingPlayers":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0));
+                }
+                break;
+            case "players":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+                }
+                break;
+            default:
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+                }
+                break;
+        }
     }
     deleteNode(node) {
-        const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes[0];
+        const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)
             throw new Error("Node was not found");
         decodeNode.destroy(DestroyReasons.NodeDeleted);

package/dist/esm/structures/Player.d.ts

@@ -110,7 +110,7 @@ export declare class Player {
      * Play the next track from the queue / a specific track, with playoptions for Lavalink
      * @param options
      */
-    play(options?: Partial<PlayOptions>): Promise<void>;
+    play(options?: Partial<PlayOptions>): any;
     /**
      * Set the Volume for the Player
      * @param volume The Volume in percent
@@ -143,12 +143,12 @@ export declare class Player {
      * Set the Repeatmode of the Player
      * @param repeatMode
      */
-    setRepeatMode(repeatMode: RepeatMode): Promise<void>;
+    setRepeatMode(repeatMode: RepeatMode): Promise<RepeatMode>;
     /**
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to
      */
-    skip(skipTo?: number): Promise<true | void>;
+    skip(skipTo?: number): Promise<any>;
     /**
      * Connects the Player to the Voice Channel
      * @returns
@@ -172,6 +172,7 @@ export declare class Player {
     /** Converts the Player including Queue to a Json state */
     toJSON(): {
         guildId: string;
+        options: PlayerOptions;
         voiceChannelId: string;
         textChannelId: string;
         position: number;
@@ -184,7 +185,6 @@ export declare class Player {
         createdTimeStamp: number;
         filters: {};
         equalizer: import("./Filters").EQBand[];
-        queue: import("./Queue").StoredQueue;
         nodeId: string;
     };
 }

package/dist/esm/structures/Player.js

@@ -64,8 +64,10 @@ export class Player {
         this.voiceChannelId = this.options.voiceChannelId;
         this.textChannelId = this.options.textChannelId || null;
         this.node = typeof this.options.node === "string" ? this.LavalinkManager.nodeManager.nodes.get(this.options.node) : this.options.node;
-        if (!this.node || typeof this.node?.request !== "function")
-            this.node = this.LavalinkManager.nodeManager.leastUsedNodes.filter(v => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || this.LavalinkManager.nodeManager.leastUsedNodes[0] || null;
+        if (!this.node || typeof this.node.request !== "function") {
+            const least = this.LavalinkManager.nodeManager.leastUsedNodes();
+            this.node = least.filter(v => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || least[0] || null;
+        }
         if (!this.node)
             throw new Error("No available Node was found, please add a LavalinkNode to the Manager via Manager.NodeManager#createNode");
         if (this.LavalinkManager.options.playerOptions.volumeDecrementer)
@@ -120,10 +122,22 @@ export class Player {
         }
         if (options?.track && this.LavalinkManager.utils.isTrack(options?.track)) {
             await this.queue.add(options?.track, 0);
-            await queueTrackEnd(this.queue, this.repeatMode === "queue");
+            await queueTrackEnd(this);
         }
         if (!this.queue.current && this.queue.tracks.length)
-            await queueTrackEnd(this.queue, this.repeatMode === "queue");
+            await queueTrackEnd(this);
+        // @ts-ignore
+        if (this.queue.current && this.LavalinkManager.utils.isUnresolvedTrack(this.queue.current)) {
+            try {
+                this.queue.current = await this.LavalinkManager.utils.getClosestTrack({ ...(this.queue.current || {}) }, this);
+            }
+            catch (error) {
+                this.LavalinkManager.emit("trackError", this, this.queue.current, error);
+                if (this.queue.tracks[0])
+                    return this.play();
+                return;
+            }
+        }
         const track = this.queue.current;
         if (!track)
             throw new Error(`There is no Track in the Queue, nor provided in the PlayOptions`);
@@ -274,8 +288,7 @@ export class Player {
     async setRepeatMode(repeatMode) {
         if (!["off", "track", "queue"].includes(repeatMode))
             throw new RangeError("Repeatmode must be either 'off', 'track', or 'queue'");
-        this.repeatMode = repeatMode;
-        return;
+        return this.repeatMode = repeatMode;
     }
     /**
      * Skip the current song, or a specific amount of songs
@@ -375,6 +388,7 @@ export class Player {
     toJSON() {
         return {
             guildId: this.guildId,
+            options: this.options,
             voiceChannelId: this.voiceChannelId,
             textChannelId: this.textChannelId,
             position: this.position,
@@ -387,7 +401,6 @@ export class Player {
             createdTimeStamp: this.createdTimeStamp,
             filters: this.filterManager?.data || {},
             equalizer: this.filterManager?.equalizerBands || [],
-            queue: this.queue?.utils?.getStored?.() || { current: null, tracks: [], previous: [] },
             nodeId: this.node?.id,
         };
     }

package/dist/esm/structures/Queue.d.ts

@@ -1,4 +1,4 @@
-import { Track } from "./Track";
+import { Track, UnresolvedTrack } from "./Track";
 export interface StoredQueue {
     current: Track | null;
     previous: Track[];
@@ -45,23 +45,23 @@ export declare class DefaultQueueStore {
 }
 export declare class QueueChangesWatcher {
     constructor();
-    tracksAdd(guildId: string, tracks: Track[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
-    tracksRemoved(guildId: string, tracks: Track[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+    tracksAdd(guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+    tracksRemoved(guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
     shuffled(guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
 }
 export declare class Queue {
-    readonly tracks: Track[];
+    readonly tracks: (Track | UnresolvedTrack)[];
     readonly previous: Track[];
     current: Track | null;
     options: {
         maxPreviousTracks: number;
     };
     private readonly guildId;
-    protected readonly QueueSaver: QueueSaver | null;
-    static readonly StaticSymbol: Symbol;
+    private readonly QueueSaver;
     private managerUtils;
     private queueChanges;
     constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: QueueSaverOptions);
+    private applyData;
     /**
      * Utils for a Queue
      */
@@ -79,7 +79,7 @@ export declare class Queue {
         /**
          * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
          */
-        getStored: () => StoredQueue;
+        toJSON: () => StoredQueue;
         /**
          * Get the Total Duration of the Queue-Songs summed up
          * @returns {number}
@@ -97,7 +97,7 @@ export declare class Queue {
      * @param {number} index At what position to add the Track
      * @returns {number} Queue-Size (for the next Tracks)
      */
-    add(TrackOrTracks: Track | Track[], index?: number): any;
+    add(TrackOrTracks: Track | UnresolvedTrack | (Track | UnresolvedTrack)[], index?: number): any;
     /**
      * Splice the tracks in the Queue
      * @param {number} index Where to remove the Track
@@ -105,5 +105,5 @@ export declare class Queue {
      * @param {Track | Track[]} TrackOrTracks Want to Add more Tracks?
      * @returns {Track} Spliced Track
      */
-    splice(index: number, amount: number, TrackOrTracks?: Track | Track[]): any;
+    splice(index: number, amount: number, TrackOrTracks?: Track | UnresolvedTrack | (Track | UnresolvedTrack)[]): any;
 }

package/dist/esm/structures/Queue.js

@@ -1,4 +1,4 @@
-import { ManagerUitls, QueueSymbol } from "./Utils";
+import { ManagerUitls } from "./Utils";
 export class QueueSaver {
     constructor(options) {
         this._ = options.queueStore || new DefaultQueueStore();
@@ -59,7 +59,6 @@ export class Queue {
     options = { maxPreviousTracks: 25 };
     guildId = "";
     QueueSaver = null;
-    static StaticSymbol = QueueSymbol;
     managerUtils = new ManagerUitls();
     queueChanges;
     constructor(guildId, data = {}, QueueSaver, queueOptions) {
@@ -68,8 +67,10 @@ export class Queue {
         this.QueueSaver = QueueSaver;
         this.options.maxPreviousTracks = this.QueueSaver?.options?.maxPreviousTracks ?? this.options.maxPreviousTracks;
         this.current = this.managerUtils.isTrack(data.current) ? data.current : null;
-        this.previous = Array.isArray(data.previous) && data.previous.some(track => this.managerUtils.isTrack(track)) ? data.previous.filter(track => this.managerUtils.isTrack(track)) : [];
-        this.tracks = Array.isArray(data.tracks) && data.tracks.some(track => this.managerUtils.isTrack(track)) ? data.tracks.filter(track => this.managerUtils.isTrack(track)) : [];
+        this.previous = Array.isArray(data.previous) && data.previous.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) ? data.previous.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) : [];
+        this.tracks = Array.isArray(data.tracks) && data.tracks.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) ? data.tracks.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) : [];
+    }
+    applyData(data) {
     }
     /**
      * Utils for a Queue
@@ -81,7 +82,7 @@ export class Queue {
         save: async () => {
             if (this.previous.length > this.options.maxPreviousTracks)
                 this.previous.splice(this.options.maxPreviousTracks, this.previous.length);
-            return await this.QueueSaver.set(this.guildId, this.utils.getStored());
+            return await this.QueueSaver.set(this.guildId, this.utils.toJSON());
         },
         /**
          * Sync the current queue database/server with the cached one
@@ -91,12 +92,12 @@ export class Queue {
             const data = await this.QueueSaver.get(this.guildId);
             if (!data)
                 return console.log("No data found to sync for guildId: ", this.guildId);
-            if (!dontSyncCurrent && !this.current && this.managerUtils.isTrack(data.current))
+            if (!dontSyncCurrent && !this.current && (this.managerUtils.isTrack(data.current)))
                 this.current = data.current;
-            if (Array.isArray(data.tracks) && data?.tracks.length && data.tracks.some(track => this.managerUtils.isTrack(track)))
-                this.tracks.splice(override ? 0 : this.tracks.length, override ? this.tracks.length : 0, ...data.tracks.filter(track => this.managerUtils.isTrack(track)));
-            if (Array.isArray(data.previous) && data?.previous.length && data.previous.some(track => this.managerUtils.isTrack(track)))
-                this.previous.splice(0, override ? this.tracks.length : 0, ...data.previous.filter(track => this.managerUtils.isTrack(track)));
+            if (Array.isArray(data.tracks) && data?.tracks.length && data.tracks.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)))
+                this.tracks.splice(override ? 0 : this.tracks.length, override ? this.tracks.length : 0, ...data.tracks.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)));
+            if (Array.isArray(data.previous) && data?.previous.length && data.previous.some(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)))
+                this.previous.splice(0, override ? this.tracks.length : 0, ...data.previous.filter(track => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)));
             await this.utils.save();
             return;
         },
@@ -106,13 +107,13 @@ export class Queue {
         /**
          * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
          */
-        getStored: () => {
+        toJSON: () => {
             if (this.previous.length > this.options.maxPreviousTracks)
                 this.previous.splice(this.options.maxPreviousTracks, this.previous.length);
             return {
-                current: this.current,
-                previous: this.previous,
-                tracks: this.tracks,
+                current: this.current ? { ...this.current } : null,
+                previous: this.previous ? [...this.previous] : [],
+                tracks: this.tracks ? [...this.tracks] : [],
             };
         },
         /**
@@ -128,7 +129,7 @@ export class Queue {
      * @returns Amount of Tracks in the Queue
      */
     async shuffle() {
-        const oldStored = typeof this.queueChanges?.shuffled === "function" ? this.utils.getStored() : null;
+        const oldStored = typeof this.queueChanges?.shuffled === "function" ? this.utils.toJSON() : null;
         if (this.tracks.length <= 1)
             return this.tracks.length;
         // swap #1 and #2 if only 2 tracks.
@@ -143,7 +144,7 @@ export class Queue {
         }
         // LOG
         if (typeof this.queueChanges?.shuffled === "function")
-            this.queueChanges.shuffled(this.guildId, oldStored, this.utils.getStored());
+            this.queueChanges.shuffled(this.guildId, oldStored, this.utils.toJSON());
         await this.utils.save();
         return this.tracks.length;
     }
@@ -155,14 +156,14 @@ export class Queue {
      */
     async add(TrackOrTracks, index) {
         if (typeof index === "number" && index >= 0 && index < this.tracks.length)
-            return await this.splice(index, 0, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)));
-        const oldStored = typeof this.queueChanges?.tracksAdd === "function" ? this.utils.getStored() : null;
+            return await this.splice(index, 0, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)));
+        const oldStored = typeof this.queueChanges?.tracksAdd === "function" ? this.utils.toJSON() : null;
         // add the track(s)
-        this.tracks.push(...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)));
+        this.tracks.push(...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)));
         // log if available
         if (typeof this.queueChanges?.tracksAdd === "function")
             try {
-                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)), this.tracks.length, oldStored, this.utils.getStored());
+                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)), this.tracks.length, oldStored, this.utils.toJSON());
             }
             catch (e) { /*  */ }
         // save the queue
@@ -178,7 +179,7 @@ export class Queue {
      * @returns {Track} Spliced Track
      */
     async splice(index, amount, TrackOrTracks) {
-        const oldStored = typeof this.queueChanges?.tracksAdd === "function" || typeof this.queueChanges?.tracksRemoved === "function" ? this.utils.getStored() : null;
+        const oldStored = typeof this.queueChanges?.tracksAdd === "function" || typeof this.queueChanges?.tracksRemoved === "function" ? this.utils.toJSON() : null;
         // if no tracks to splice, add the tracks
         if (!this.tracks.length) {
             if (TrackOrTracks)
@@ -188,17 +189,17 @@ export class Queue {
         // Log if available
         if ((TrackOrTracks) && typeof this.queueChanges?.tracksAdd === "function")
             try {
-                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v)), index, oldStored, this.utils.getStored());
+                this.queueChanges.tracksAdd(this.guildId, (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)), index, oldStored, this.utils.toJSON());
             }
             catch (e) { /*  */ }
         // remove the tracks (and add the new ones)
-        let spliced = TrackOrTracks ? this.tracks.splice(index, amount, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v))) : this.tracks.splice(index, amount);
+        let spliced = TrackOrTracks ? this.tracks.splice(index, amount, ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).filter(v => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v))) : this.tracks.splice(index, amount);
         // get the spliced array
         spliced = (Array.isArray(spliced) ? spliced : [spliced]);
         // Log if available
         if (typeof this.queueChanges?.tracksRemoved === "function")
             try {
-                this.queueChanges.tracksRemoved(this.guildId, spliced, index, oldStored, this.utils.getStored());
+                this.queueChanges.tracksRemoved(this.guildId, spliced, index, oldStored, this.utils.toJSON());
             }
             catch (e) { /* */ }
         // save the queue