magmastream 2.9.0-dev.4 → 2.9.0-dev.41

package/dist/structures/Utils.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrackSourceTypes = exports.SeverityTypes = exports.TrackEndReasonTypes = exports.StateTypes = exports.LoadTypes = exports.Structure = exports.AutoPlayUtils = exports.TrackUtils = void 0;
+exports.Structure = exports.AutoPlayUtils = exports.TrackUtils = void 0;
 const tslib_1 = require("tslib");
-const Manager_1 = require("./Manager");
+/* eslint-disable @typescript-eslint/no-require-imports */
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const jsdom_1 = require("jsdom");
-const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const Enums_1 = require("./Enums");
+// import playwright from "playwright";
 /** @hidden */
 const SIZES = ["0", "1", "2", "3", "default", "mqdefault", "hqdefault", "maxresdefault"];
 class TrackUtils {
@@ -29,27 +30,27 @@ class TrackUtils {
         if (!Array.isArray(partial) || !partial.every((str) => typeof str === "string"))
             throw new Error("Provided partial is not an array or not a string array.");
         const defaultProperties = [
-            Manager_1.TrackPartial.Track,
-            Manager_1.TrackPartial.Title,
-            Manager_1.TrackPartial.Identifier,
-            Manager_1.TrackPartial.Author,
-            Manager_1.TrackPartial.Duration,
-            Manager_1.TrackPartial.Isrc,
-            Manager_1.TrackPartial.IsSeekable,
-            Manager_1.TrackPartial.IsStream,
-            Manager_1.TrackPartial.Uri,
-            Manager_1.TrackPartial.ArtworkUrl,
-            Manager_1.TrackPartial.SourceName,
-            Manager_1.TrackPartial.ThumbNail,
-            Manager_1.TrackPartial.Requester,
-            Manager_1.TrackPartial.PluginInfo,
-            Manager_1.TrackPartial.CustomData,
+            Enums_1.TrackPartial.Track,
+            Enums_1.TrackPartial.Title,
+            Enums_1.TrackPartial.Identifier,
+            Enums_1.TrackPartial.Author,
+            Enums_1.TrackPartial.Duration,
+            Enums_1.TrackPartial.Isrc,
+            Enums_1.TrackPartial.IsSeekable,
+            Enums_1.TrackPartial.IsStream,
+            Enums_1.TrackPartial.Uri,
+            Enums_1.TrackPartial.ArtworkUrl,
+            Enums_1.TrackPartial.SourceName,
+            Enums_1.TrackPartial.ThumbNail,
+            Enums_1.TrackPartial.Requester,
+            Enums_1.TrackPartial.PluginInfo,
+            Enums_1.TrackPartial.CustomData,
         ];
         /** The array of property names that will be removed from the Track class */
         this.trackPartial = Array.from(new Set([...defaultProperties, ...partial]));
         /** Make sure that the "track" property is always included */
-        if (!this.trackPartial.includes(Manager_1.TrackPartial.Track))
-            this.trackPartial.unshift(Manager_1.TrackPartial.Track);
+        if (!this.trackPartial.includes(Enums_1.TrackPartial.Track))
+            this.trackPartial.unshift(Enums_1.TrackPartial.Track);
     }
     /**
      * Checks if the provided argument is a valid Track.
@@ -129,19 +130,32 @@ class TrackUtils {
             throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
         }
     }
+    /**
+     * Validates a search result.
+     * @param result The search result to validate.
+     * @returns Whether the search result is valid.
+     */
+    static isErrorOrEmptySearchResult(result) {
+        return result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error;
+    }
 }
 exports.TrackUtils = TrackUtils;
 class AutoPlayUtils {
     static manager;
+    // private static cachedAccessToken: string | null = null;
+    // private static cachedAccessTokenExpiresAt: number = 0;
     /**
      * Initializes the AutoPlayUtils class with the given manager.
      * @param manager The manager instance to use.
      * @hidden
      */
-    static init(manager) {
+    static async init(manager) {
         if (!manager)
             throw new Error("AutoPlayUtils.init() requires a valid Manager instance.");
         this.manager = manager;
+        // if (this.manager.options.autoPlaySearchPlatforms.includes(AutoPlayPlatform.Spotify)) {
+        // 	await this.getSpotifyAccessToken();
+        // }
     }
     /**
      * Gets recommended tracks for the given track.
@@ -154,6 +168,10 @@ class AutoPlayUtils {
             throw new Error("No available nodes.");
         }
         const apiKey = this.manager.options.lastFmApiKey;
+        // Check if Last.fm API is available
+        if (apiKey) {
+            return await this.getRecommendedTracksFromLastFm(track, apiKey);
+        }
         const enabledSources = node.info.sourceManagers;
         const autoPlaySearchPlatforms = this.manager.options.autoPlaySearchPlatforms;
         // Iterate over autoplay platforms in order of priority
@@ -166,10 +184,6 @@ class AutoPlayUtils {
                 }
             }
         }
-        // Check if Last.fm API is available
-        if (apiKey) {
-            return await this.getRecommendedTracksFromLastFm(track, apiKey);
-        }
         return [];
     }
     /**
@@ -190,15 +204,10 @@ class AutoPlayUtils {
                     return [];
                 }
                 const randomTrack = response.data.toptracks.track[Math.floor(Math.random() * response.data.toptracks.track.length)];
-                const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-                if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                const resolvedTracks = await this.resolveTracksFromQuery(`${randomTrack.artist.name} - ${randomTrack.name}`, this.manager.options.defaultSearchPlatform, track.requester);
+                if (!resolvedTracks.length)
                     return [];
-                }
-                const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
-                if (!filteredTracks.length) {
-                    return [];
-                }
-                return filteredTracks;
+                return resolvedTracks;
             }
             if (!artist) {
                 // No artist provided, search for the track title
@@ -228,11 +237,10 @@ class AutoPlayUtils {
                 return [];
             }
             const randomTrack = retryResponse.data.toptracks.track[Math.floor(Math.random() * retryResponse.data.toptracks.track.length)];
-            const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-            if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+            const resolvedTracks = await this.resolveTracksFromQuery(`${randomTrack.artist.name} - ${randomTrack.name}`, this.manager.options.defaultSearchPlatform, track.requester);
+            if (!resolvedTracks.length)
                 return [];
-            }
-            const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
+            const filteredTracks = resolvedTracks.filter((t) => t.uri !== track.uri);
             if (!filteredTracks.length) {
                 return [];
             }
@@ -242,16 +250,10 @@ class AutoPlayUtils {
         if (!randomTrack) {
             return [];
         }
-        const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-            return [];
-        }
-        if (res.loadType === LoadTypes.Playlist)
-            res.tracks = res.playlist.tracks;
-        if (!res.tracks.length) {
+        const resolvedTracks = await this.resolveTracksFromQuery(`${randomTrack.artist.name} - ${randomTrack.name}`, this.manager.options.defaultSearchPlatform, track.requester);
+        if (!resolvedTracks.length)
             return [];
-        }
-        return res.tracks;
+        return resolvedTracks;
     }
     /**
      * Gets recommended tracks from the given source.
@@ -260,157 +262,47 @@ class AutoPlayUtils {
      * @returns An array of recommended tracks.
      */
     static async getRecommendedTracksFromSource(track, platform) {
+        const requester = track.requester;
+        const parsedURL = new URL(track.uri);
         switch (platform) {
-            case "spotify":
-                try {
-                    if (!track.uri.includes("spotify")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
-                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                            return [];
-                        }
-                        if (res.loadType === LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
-                            return [];
-                        }
-                        track = res.tracks[0];
-                    }
-                    const TOTP_SECRET = new Uint8Array([
-                        53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
-                    ]);
-                    const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
-                    function generateTotp() {
-                        const counter = Math.floor(Date.now() / 30000);
-                        const counterBuffer = Buffer.alloc(8);
-                        counterBuffer.writeBigInt64BE(BigInt(counter));
-                        hmac.update(counterBuffer);
-                        const hmacResult = hmac.digest();
-                        const offset = hmacResult[hmacResult.length - 1] & 15;
-                        const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
-                        const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
-                        return [totp, counter * 30000];
-                    }
-                    const [totp, timestamp] = generateTotp();
-                    const params = {
-                        reason: "transport",
-                        productType: "embed",
-                        totp: totp,
-                        totpVer: 5,
-                        ts: timestamp,
-                    };
-                    let body;
-                    try {
-                        const response = await axios_1.default.get("https://open.spotify.com/get_access_token", { params });
-                        body = response.data;
-                    }
-                    catch (error) {
-                        console.error("[AutoPlay] Failed to get spotify access token:", error.response?.status, error.response?.data || error.message);
-                        return [];
-                    }
-                    let json;
-                    try {
-                        const response = await axios_1.default.get(`https://api.spotify.com/v1/recommendations`, {
-                            params: { limit: 10, seed_tracks: track.identifier },
-                            headers: {
-                                Authorization: `Bearer ${body.accessToken}`,
-                                "Content-Type": "application/json",
-                            },
-                        });
-                        json = response.data;
-                    }
-                    catch (error) {
-                        console.error("[AutoPlay] Failed to fetch spotify recommendations:", error.response?.status, error.response?.data || error.message);
+            case Enums_1.AutoPlayPlatform.Spotify: {
+                const allowedSpotifyHosts = ["open.spotify.com", "www.spotify.com"];
+                if (!allowedSpotifyHosts.includes(parsedURL.host)) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.Spotify, requester);
+                    if (!resolvedTrack)
                         return [];
-                    }
-                    if (!json.tracks || !json.tracks.length) {
-                        return [];
-                    }
-                    const recommendedTrackId = json.tracks[Math.floor(Math.random() * json.tracks.length)].id;
-                    const res = await this.manager.search({ query: `https://open.spotify.com/track/${recommendedTrackId}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        return [];
-                    }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
-                    }
-                    if (!res.tracks.length) {
-                        return [];
-                    }
-                    return res.tracks;
-                }
-                catch (error) {
-                    console.error("[AutoPlay] Unexpected spotify error:", error.message || error);
-                    return [];
+                    track = resolvedTrack;
                 }
-                break;
-            case "deezer":
-                if (!track.uri.includes("deezer")) {
-                    const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Deezer }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        return [];
-                    }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
-                    }
-                    if (!res.tracks.length) {
+                const extractSpotifyArtistID = (url) => {
+                    const regex = /https:\/\/open\.spotify\.com\/artist\/([a-zA-Z0-9]+)/;
+                    const match = url.match(regex);
+                    return match ? match[1] : null;
+                };
+                const identifier = `sprec:seed_artists=${extractSpotifyArtistID(track.pluginInfo.artistUrl)}&seed_tracks=${track.identifier}`;
+                const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                return tracks;
+            }
+            case Enums_1.AutoPlayPlatform.Deezer: {
+                const allowedDeezerHosts = ["deezer.com", "www.deezer.com", "www.deezer.page.link"];
+                if (!allowedDeezerHosts.includes(parsedURL.host)) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.Deezer, requester);
+                    if (!resolvedTrack)
                         return [];
-                    }
-                    track = res.tracks[0];
+                    track = resolvedTrack;
                 }
                 const identifier = `dzrec:${track.identifier}`;
                 const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                if (!recommendedResult) {
-                    return [];
-                }
-                let tracks = [];
-                let playlist = null;
-                const requester = track.requester;
-                switch (recommendedResult.loadType) {
-                    case LoadTypes.Search:
-                        tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
-                        break;
-                    case LoadTypes.Track:
-                        tracks = [TrackUtils.build(recommendedResult.data, requester)];
-                        break;
-                    case LoadTypes.Playlist: {
-                        const playlistData = recommendedResult.data;
-                        tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
-                        playlist = {
-                            name: playlistData.info.name,
-                            playlistInfo: playlistData.pluginInfo,
-                            requester: requester,
-                            tracks,
-                            duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
-                        };
-                        break;
-                    }
-                }
-                const result = { loadType: recommendedResult.loadType, tracks, playlist };
-                if (result.loadType === LoadTypes.Empty || result.loadType === LoadTypes.Error) {
-                    return [];
-                }
-                if (result.loadType === LoadTypes.Playlist) {
-                    result.tracks = result.playlist.tracks;
-                }
-                if (!result.tracks.length) {
-                    return [];
-                }
-                return result.tracks;
-                break;
-            case "soundcloud":
-                if (!track.uri.includes("soundcloud")) {
-                    const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        return [];
-                    }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
-                    }
-                    if (!res.tracks.length) {
+                const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                return tracks;
+            }
+            case Enums_1.AutoPlayPlatform.SoundCloud: {
+                const allowedSoundCloudHosts = ["soundcloud.com", "www.soundcloud.com"];
+                if (!allowedSoundCloudHosts.includes(parsedURL.host)) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.SoundCloud, requester);
+                    if (!resolvedTrack)
                         return [];
-                    }
-                    track = res.tracks[0];
+                    track = resolvedTrack;
                 }
                 try {
                     const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
@@ -422,50 +314,52 @@ class AutoPlayUtils {
                     }
                     const html = recommendedRes.data;
                     const dom = new jsdom_1.JSDOM(html);
-                    const document = dom.window.document;
-                    const secondNoscript = document.querySelectorAll("noscript")[1];
+                    const window = dom.window;
+                    // Narrow the element types using instanceof
+                    const secondNoscript = window.querySelectorAll("noscript")[1];
+                    if (!secondNoscript || !(secondNoscript instanceof window.Element))
+                        return [];
                     const sectionElement = secondNoscript.querySelector("section");
+                    if (!sectionElement || !(sectionElement instanceof window.HTMLElement))
+                        return [];
                     const articleElements = sectionElement.querySelectorAll("article");
-                    if (!articleElements || articleElements.length === 0) {
+                    if (!articleElements || articleElements.length === 0)
                         return [];
-                    }
                     const urls = Array.from(articleElements)
-                        .map((articleElement) => {
-                        const h2Element = articleElement.querySelector('h2[itemprop="name"]');
-                        const aElement = h2Element?.querySelector('a[itemprop="url"]');
-                        return aElement ? `https://soundcloud.com${aElement.getAttribute("href")}` : null;
+                        .map((element) => {
+                        const h2 = element.querySelector('h2[itemprop="name"]');
+                        if (!h2)
+                            return null;
+                        const a = h2.querySelector('a[itemprop="url"]');
+                        if (!a)
+                            return null;
+                        const href = a.getAttribute("href");
+                        return href ? `https://soundcloud.com${href}` : null;
                     })
                         .filter(Boolean);
-                    if (!urls.length) {
+                    if (!urls.length)
                         return [];
-                    }
                     const randomUrl = urls[Math.floor(Math.random() * urls.length)];
-                    const res = await this.manager.search({ query: randomUrl, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        return [];
-                    }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
-                    }
-                    if (!res.tracks.length) {
-                        return [];
-                    }
-                    return res.tracks;
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(randomUrl, Enums_1.SearchPlatform.SoundCloud, requester);
+                    return resolvedTrack ? [resolvedTrack] : [];
                 }
                 catch (error) {
                     console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
                     return [];
                 }
-                break;
-            case "youtube":
-                const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
+            }
+            case Enums_1.AutoPlayPlatform.YouTube: {
+                const allowedYouTubeHosts = ["youtube.com", "youtu.be"];
+                const hasYouTubeURL = allowedYouTubeHosts.some((url) => track.uri.includes(url));
                 let videoID = null;
                 if (hasYouTubeURL) {
                     videoID = track.uri.split("=").pop();
                 }
                 else {
-                    const searchResult = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.YouTube }, track.requester);
-                    videoID = searchResult.tracks[0]?.uri.split("=").pop();
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.YouTube, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    videoID = resolvedTrack.uri.split("=").pop();
                 }
                 if (!videoID) {
                     return [];
@@ -476,16 +370,213 @@ class AutoPlayUtils {
                     randomIndex = Math.floor(Math.random() * 23) + 2;
                     searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}&index=${randomIndex}`;
                 } while (track.uri.includes(searchURI));
-                const res = await this.manager.search({ query: searchURI, source: Manager_1.SearchPlatform.YouTube }, track.requester);
-                if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                    return [];
-                }
-                const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
+                const resolvedTracks = await this.resolveTracksFromQuery(searchURI, Enums_1.SearchPlatform.YouTube, requester);
+                const filteredTracks = resolvedTracks.filter((t) => t.uri !== track.uri);
                 return filteredTracks;
+            }
+            case Enums_1.AutoPlayPlatform.Tidal: {
+                const allowedTidalHosts = ["tidal.com", "www.tidal.com"];
+                if (!allowedTidalHosts.includes(parsedURL.host)) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.Tidal, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    track = resolvedTrack;
+                }
+                const identifier = `tdrec:${track.identifier}`;
+                const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                return tracks;
+            }
+            case Enums_1.AutoPlayPlatform.VKMusic: {
+                const allowedVKHosts = ["vk.com", "www.vk.com", "vk.ru", "www.vk.ru"];
+                if (!allowedVKHosts.includes(parsedURL.host)) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.VKMusic, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    track = resolvedTrack;
+                }
+                const identifier = `vkrec:${track.identifier}`;
+                const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                return tracks;
+            }
+            case Enums_1.AutoPlayPlatform.Qobuz: {
+                const allowedQobuzHosts = ["qobuz.com", "www.qobuz.com", "play.qobuz.com"];
+                if (!allowedQobuzHosts.includes(parsedURL.host)) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.Qobuz, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    track = resolvedTrack;
+                }
+                const identifier = `qbrec:${track.identifier}`;
+                const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                return tracks;
+            }
             default:
                 return [];
         }
     }
+    /**
+     * Searches for a track using the manager and returns resolved tracks.
+     * @param query The search query (artist - title).
+     * @param requester The requester who initiated the search.
+     * @returns An array of resolved tracks, or an empty array if not found or error occurred.
+     */
+    static async resolveTracksFromQuery(query, source, requester) {
+        try {
+            const searchResult = await this.manager.search({ query, source }, requester);
+            if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
+                return [];
+            }
+            switch (searchResult.loadType) {
+                case Enums_1.LoadTypes.Album:
+                case Enums_1.LoadTypes.Artist:
+                case Enums_1.LoadTypes.Station:
+                case Enums_1.LoadTypes.Podcast:
+                case Enums_1.LoadTypes.Show:
+                case Enums_1.LoadTypes.Playlist:
+                    return searchResult.playlist.tracks;
+                case Enums_1.LoadTypes.Track:
+                case Enums_1.LoadTypes.Search:
+                case Enums_1.LoadTypes.Short:
+                    return searchResult.tracks;
+                default:
+                    return [];
+            }
+        }
+        catch (error) {
+            console.error("[TrackResolver] Failed to resolve query:", query, error);
+            return [];
+        }
+    }
+    /**
+     * Resolves the first available track from a search query using the specified source.
+     * Useful for normalizing tracks that lack platform-specific metadata or URIs.
+     *
+     * @param query - The search query string (usually "Artist - Title").
+     * @param source - The search platform to use (e.g., Spotify, Deezer, YouTube).
+     * @param requester - The requester object, used for context or attribution.
+     * @returns A single resolved {@link Track} object if found, or `null` if the search fails or returns no results.
+     */
+    static async resolveFirstTrackFromQuery(query, source, requester) {
+        try {
+            const searchResult = await this.manager.search({ query, source }, requester);
+            if (TrackUtils.isErrorOrEmptySearchResult(searchResult))
+                return null;
+            switch (searchResult.loadType) {
+                case Enums_1.LoadTypes.Album:
+                case Enums_1.LoadTypes.Artist:
+                case Enums_1.LoadTypes.Station:
+                case Enums_1.LoadTypes.Podcast:
+                case Enums_1.LoadTypes.Show:
+                case Enums_1.LoadTypes.Playlist:
+                    return searchResult.playlist.tracks[0] || null;
+                case Enums_1.LoadTypes.Track:
+                case Enums_1.LoadTypes.Search:
+                case Enums_1.LoadTypes.Short:
+                    return searchResult.tracks[0] || null;
+                default:
+                    return null;
+            }
+        }
+        catch (err) {
+            console.error(`[AutoPlay] Failed to resolve track from query: "${query}" on source: ${source}`, err);
+            return null;
+        }
+    }
+    // static async getSpotifyAccessToken() {
+    // 	const timeoutMs = 15000;
+    // 	let browser;
+    // 	let timeout;
+    // 	try {
+    // 		browser = await playwright.chromium.launch({ headless: true, args: ["--no-sandbox", "--disable-gpu", "--disable-dev-shm-usage"] });
+    // 		const page = await browser.newPage();
+    // 		let tokenCaptured = false;
+    // 		timeout = setTimeout(async () => {
+    // 			if (!tokenCaptured) {
+    // 				console.warn("[Spotify] Token request timeout — did Spotify change their internals?");
+    // 				await browser?.close();
+    // 			}
+    // 		}, timeoutMs);
+    // 		page.on("requestfinished", async (request) => {
+    // 			if (!request.url().includes("/api/token")) return;
+    // 			tokenCaptured = true;
+    // 			try {
+    // 				const response = await request.response();
+    // 				if (response && response.ok()) {
+    // 					const data = await response.json();
+    // 					this.cachedAccessToken = data?.accessToken ?? null;
+    // 					this.cachedAccessTokenExpiresAt = data?.accessTokenExpirationTimestampMs ?? 0;
+    // 				}
+    // 			} catch (err) {
+    // 				console.error("[Spotify] Error reading token response:", err);
+    // 			}
+    // 			clearTimeout(timeout);
+    // 			page.removeAllListeners();
+    // 			await browser.close();
+    // 		});
+    // 		try {
+    // 			await page.goto("https://open.spotify.com/", { waitUntil: "domcontentloaded" });
+    // 		} catch (err) {
+    // 			clearTimeout(timeout);
+    // 			await browser.close();
+    // 			console.error("[Spotify] Failed to navigate:", err);
+    // 			return [];
+    // 		}
+    // 	} catch (err) {
+    // 		clearTimeout(timeout);
+    // 		await browser?.close();
+    // 		console.error("[Spotify] Failed to launch Playwright:", err);
+    // 	}
+    // }
+    static isPlaylistRawData(data) {
+        return typeof data === "object" && data !== null && Array.isArray(data.tracks);
+    }
+    static isTrackData(data) {
+        return typeof data === "object" && data !== null && "encoded" in data && "info" in data;
+    }
+    static isTrackDataArray(data) {
+        return (Array.isArray(data) &&
+            data.every((track) => typeof track === "object" && track !== null && "encoded" in track && "info" in track && typeof track.encoded === "string"));
+    }
+    static buildTracksFromResponse(recommendedResult, requester) {
+        if (!recommendedResult)
+            return [];
+        if (TrackUtils.isErrorOrEmptySearchResult(recommendedResult))
+            return [];
+        switch (recommendedResult.loadType) {
+            case Enums_1.LoadTypes.Track: {
+                const data = recommendedResult.data;
+                if (!this.isTrackData(data)) {
+                    throw new Error("[TrackBuilder] Invalid TrackData object.");
+                }
+                return [TrackUtils.build(data, requester)];
+            }
+            case Enums_1.LoadTypes.Short:
+            case Enums_1.LoadTypes.Search: {
+                const data = recommendedResult.data;
+                if (!this.isTrackDataArray(data)) {
+                    throw new Error("[TrackBuilder] Invalid TrackData[] array for LoadTypes.Search or Short.");
+                }
+                return data.map((d) => TrackUtils.build(d, requester));
+            }
+            case Enums_1.LoadTypes.Album:
+            case Enums_1.LoadTypes.Artist:
+            case Enums_1.LoadTypes.Station:
+            case Enums_1.LoadTypes.Podcast:
+            case Enums_1.LoadTypes.Show:
+            case Enums_1.LoadTypes.Playlist: {
+                const data = recommendedResult.data;
+                if (this.isPlaylistRawData(data)) {
+                    return data.tracks.map((d) => TrackUtils.build(d, requester));
+                }
+                throw new Error(`[TrackBuilder] Invalid playlist data for loadType: ${recommendedResult.loadType}`);
+            }
+            default:
+                throw new Error(`[TrackBuilder] Unsupported loadType: ${recommendedResult.loadType}`);
+        }
+    }
 }
 exports.AutoPlayUtils = AutoPlayUtils;
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
@@ -516,7 +607,7 @@ class Structure {
 exports.Structure = Structure;
 const structures = {
     Player: require("./Player").Player,
-    Queue: require("./Queue").Queue,
+    Queue: require("../statestorage/MemoryQueue").MemoryQueue,
     Node: require("./Node").Node,
     Filters: require("./Filters").Filters,
     Manager: require("./Manager").Manager,
@@ -524,45 +615,3 @@ const structures = {
     Rest: require("./Rest").Rest,
     Utils: require("./Utils"),
 };
-var LoadTypes;
-(function (LoadTypes) {
-    LoadTypes["Track"] = "track";
-    LoadTypes["Playlist"] = "playlist";
-    LoadTypes["Search"] = "search";
-    LoadTypes["Empty"] = "empty";
-    LoadTypes["Error"] = "error";
-})(LoadTypes || (exports.LoadTypes = LoadTypes = {}));
-var StateTypes;
-(function (StateTypes) {
-    StateTypes["Connected"] = "CONNECTED";
-    StateTypes["Connecting"] = "CONNECTING";
-    StateTypes["Disconnected"] = "DISCONNECTED";
-    StateTypes["Disconnecting"] = "DISCONNECTING";
-    StateTypes["Destroying"] = "DESTROYING";
-})(StateTypes || (exports.StateTypes = StateTypes = {}));
-var TrackEndReasonTypes;
-(function (TrackEndReasonTypes) {
-    TrackEndReasonTypes["Finished"] = "finished";
-    TrackEndReasonTypes["LoadFailed"] = "loadFailed";
-    TrackEndReasonTypes["Stopped"] = "stopped";
-    TrackEndReasonTypes["Replaced"] = "replaced";
-    TrackEndReasonTypes["Cleanup"] = "cleanup";
-})(TrackEndReasonTypes || (exports.TrackEndReasonTypes = TrackEndReasonTypes = {}));
-var SeverityTypes;
-(function (SeverityTypes) {
-    SeverityTypes["Common"] = "common";
-    SeverityTypes["Suspicious"] = "suspicious";
-    SeverityTypes["Fault"] = "fault";
-})(SeverityTypes || (exports.SeverityTypes = SeverityTypes = {}));
-var TrackSourceTypes;
-(function (TrackSourceTypes) {
-    TrackSourceTypes["AppleMusic"] = "applemusic";
-    TrackSourceTypes["Bandcamp"] = "bandcamp";
-    TrackSourceTypes["Deezer"] = "deezer";
-    TrackSourceTypes["Jiosaavn"] = "jiosaavn";
-    TrackSourceTypes["SoundCloud"] = "soundcloud";
-    TrackSourceTypes["Spotify"] = "spotify";
-    TrackSourceTypes["Tidal"] = "tidal";
-    TrackSourceTypes["VKMusic"] = "vkmusic";
-    TrackSourceTypes["YouTube"] = "youtube";
-})(TrackSourceTypes || (exports.TrackSourceTypes = TrackSourceTypes = {}));