magmastream 2.9.0-dev.35 → 2.9.0-dev.37

package/dist/structures/Utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Structure = exports.AutoPlayUtils = exports.TrackUtils = void 0;
 const tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/no-require-imports */
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const jsdom_1 = require("jsdom");
 const Enums_1 = require("./Enums");
@@ -167,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
@@ -179,10 +184,6 @@ class AutoPlayUtils {
                 }
             }
         }
-        // Check if Last.fm API is available
-        if (apiKey) {
-            return await this.getRecommendedTracksFromLastFm(track, apiKey);
-        }
         return [];
     }
     /**
@@ -203,22 +204,7 @@ class AutoPlayUtils {
                     return [];
                 }
                 const randomTrack = response.data.toptracks.track[Math.floor(Math.random() * response.data.toptracks.track.length)];
-                const searchResult = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-                if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
-                    return [];
-                }
-                let resolvedTracks;
-                switch (searchResult.loadType) {
-                    case Enums_1.LoadTypes.Playlist:
-                        resolvedTracks = searchResult.playlist.tracks;
-                        break;
-                    case Enums_1.LoadTypes.Track:
-                    case Enums_1.LoadTypes.Search:
-                        resolvedTracks = searchResult.tracks;
-                        break;
-                    default:
-                        return [];
-                }
+                const resolvedTracks = await this.resolveTracksFromQuery(`${randomTrack.artist.name} - ${randomTrack.name}`, this.manager.options.defaultSearchPlatform, track.requester);
                 if (!resolvedTracks.length)
                     return [];
                 return resolvedTracks;
@@ -251,22 +237,7 @@ class AutoPlayUtils {
                 return [];
             }
             const randomTrack = retryResponse.data.toptracks.track[Math.floor(Math.random() * retryResponse.data.toptracks.track.length)];
-            const searchResult = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-            if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
-                return [];
-            }
-            let resolvedTracks;
-            switch (searchResult.loadType) {
-                case Enums_1.LoadTypes.Playlist:
-                    resolvedTracks = searchResult.playlist.tracks;
-                    break;
-                case Enums_1.LoadTypes.Track:
-                case Enums_1.LoadTypes.Search:
-                    resolvedTracks = searchResult.tracks;
-                    break;
-                default:
-                    return [];
-            }
+            const resolvedTracks = await this.resolveTracksFromQuery(`${randomTrack.artist.name} - ${randomTrack.name}`, this.manager.options.defaultSearchPlatform, track.requester);
             if (!resolvedTracks.length)
                 return [];
             const filteredTracks = resolvedTracks.filter((t) => t.uri !== track.uri);
@@ -279,22 +250,7 @@ class AutoPlayUtils {
         if (!randomTrack) {
             return [];
         }
-        const searchResult = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-        if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
-            return [];
-        }
-        let resolvedTracks;
-        switch (searchResult.loadType) {
-            case Enums_1.LoadTypes.Playlist:
-                resolvedTracks = searchResult.playlist.tracks;
-                break;
-            case Enums_1.LoadTypes.Track:
-            case Enums_1.LoadTypes.Search:
-                resolvedTracks = searchResult.tracks;
-                break;
-            default:
-                return [];
-        }
+        const resolvedTracks = await this.resolveTracksFromQuery(`${randomTrack.artist.name} - ${randomTrack.name}`, this.manager.options.defaultSearchPlatform, track.requester);
         if (!resolvedTracks.length)
             return [];
         return resolvedTracks;
@@ -308,285 +264,219 @@ class AutoPlayUtils {
     static async getRecommendedTracksFromSource(track, platform) {
         const requester = track.requester;
         switch (platform) {
-            case Enums_1.AutoPlayPlatform.Spotify:
-                {
-                    if (!track.uri.includes("spotify")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Spotify }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(res))
-                            return [];
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        if (!resolvedTrack)
-                            return [];
-                        track = resolvedTrack;
-                    }
-                    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.Spotify: {
+                if (!track.uri.includes("spotify")) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.Spotify, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    track = resolvedTrack;
                 }
-                break;
-            case Enums_1.AutoPlayPlatform.Deezer:
-                {
-                    if (!track.uri.includes("deezer")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Deezer }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(res))
-                            return [];
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        if (!resolvedTrack)
-                            return [];
-                        track = resolvedTrack;
-                    }
-                    const identifier = `dzrec:${track.identifier}`;
-                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                    const tracks = this.buildTracksFromResponse(recommendedResult, requester);
-                    return tracks;
+                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: {
+                if (!track.uri.includes("deezer")) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.Deezer, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    track = resolvedTrack;
                 }
-                break;
-            case Enums_1.AutoPlayPlatform.SoundCloud:
-                {
-                    if (!track.uri.includes("soundcloud")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.SoundCloud }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(res))
-                            return [];
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        if (!resolvedTrack)
-                            return [];
-                        track = resolvedTrack;
-                    }
-                    try {
-                        const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
-                            console.error(`[AutoPlay] Failed to fetch SoundCloud recommendations. Status: ${err.response?.status || "Unknown"}`, err.message);
-                            return null;
-                        });
-                        if (!recommendedRes) {
-                            return [];
-                        }
-                        const html = recommendedRes.data;
-                        const dom = new jsdom_1.JSDOM(html);
-                        const document = dom.window.document;
-                        const secondNoscript = document.querySelectorAll("noscript")[1];
-                        const sectionElement = secondNoscript.querySelector("section");
-                        const articleElements = sectionElement.querySelectorAll("article");
-                        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;
-                        })
-                            .filter(Boolean);
-                        if (!urls.length) {
-                            return [];
-                        }
-                        const randomUrl = urls[Math.floor(Math.random() * urls.length)];
-                        const res = await this.manager.search({ query: randomUrl, source: Enums_1.SearchPlatform.SoundCloud }, requester);
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        if (!resolvedTrack)
-                            return [];
-                        return [resolvedTrack];
-                    }
-                    catch (error) {
-                        console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
+                const identifier = `dzrec:${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.SoundCloud: {
+                if (!track.uri.includes("soundcloud")) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.SoundCloud, requester);
+                    if (!resolvedTrack)
                         return [];
-                    }
+                    track = resolvedTrack;
                 }
-                break;
-            case Enums_1.AutoPlayPlatform.YouTube:
-                {
-                    const hasYouTubeURL = ["youtube.com", "youtu.be"].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: Enums_1.SearchPlatform.YouTube }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
-                            return [];
-                        }
-                        let resolvedTrack;
-                        switch (searchResult.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = searchResult.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = searchResult.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        if (!resolvedTrack)
-                            return [];
-                        videoID = resolvedTrack.uri.split("=").pop();
-                    }
-                    if (!videoID) {
+                try {
+                    const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
+                        console.error(`[AutoPlay] Failed to fetch SoundCloud recommendations. Status: ${err.response?.status || "Unknown"}`, err.message);
+                        return null;
+                    });
+                    if (!recommendedRes) {
                         return [];
                     }
-                    let randomIndex;
-                    let searchURI;
-                    do {
-                        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: Enums_1.SearchPlatform.YouTube }, requester);
-                    if (TrackUtils.isErrorOrEmptySearchResult(res)) {
+                    const html = recommendedRes.data;
+                    const dom = new jsdom_1.JSDOM(html);
+                    const window = dom.window;
+                    // Narrow the element types using instanceof
+                    const secondNoscript = window.querySelectorAll("noscript")[1];
+                    if (!secondNoscript || !(secondNoscript instanceof window.Element))
                         return [];
-                    }
-                    let resolvedTracks;
-                    switch (res.loadType) {
-                        case Enums_1.LoadTypes.Playlist:
-                            resolvedTracks = res.playlist.tracks;
-                            break;
-                        case Enums_1.LoadTypes.Track:
-                        case Enums_1.LoadTypes.Search:
-                            resolvedTracks = res.tracks;
-                            break;
-                        default:
-                            return [];
-                    }
-                    const filteredTracks = resolvedTracks.filter((t) => t.uri !== track.uri);
-                    return filteredTracks;
+                    const sectionElement = secondNoscript.querySelector("section");
+                    if (!sectionElement || !(sectionElement instanceof window.HTMLElement))
+                        return [];
+                    const articleElements = sectionElement.querySelectorAll("article");
+                    if (!articleElements || articleElements.length === 0)
+                        return [];
+                    const urls = Array.from(articleElements)
+                        .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)
+                        return [];
+                    const randomUrl = urls[Math.floor(Math.random() * urls.length)];
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(randomUrl, Enums_1.SearchPlatform.SoundCloud, requester);
+                    return resolvedTrack ? [resolvedTrack] : [];
                 }
-                break;
-            case Enums_1.AutoPlayPlatform.Tidal:
-                {
-                    if (!track.uri.includes("tidal")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Tidal }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(res))
-                            return [];
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        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;
+                catch (error) {
+                    console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
+                    return [];
                 }
-                break;
-            case Enums_1.AutoPlayPlatform.VKMusic:
-                {
-                    if (!track.uri.includes("vk.com") && !track.uri.includes("vk.ru")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.VKMusic }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(res))
-                            return [];
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        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.YouTube: {
+                const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
+                let videoID = null;
+                if (hasYouTubeURL) {
+                    videoID = track.uri.split("=").pop();
                 }
-                break;
-            case Enums_1.AutoPlayPlatform.Qobuz:
-                {
-                    if (!track.uri.includes("qobuz.com")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Qobuz }, requester);
-                        if (TrackUtils.isErrorOrEmptySearchResult(res))
-                            return [];
-                        let resolvedTrack;
-                        switch (res.loadType) {
-                            case Enums_1.LoadTypes.Playlist:
-                                resolvedTrack = res.playlist.tracks[0];
-                                break;
-                            case Enums_1.LoadTypes.Track:
-                            case Enums_1.LoadTypes.Search:
-                                resolvedTrack = res.tracks[0];
-                                break;
-                            default:
-                                return [];
-                        }
-                        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;
+                else {
+                    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 [];
+                }
+                let randomIndex;
+                let searchURI;
+                do {
+                    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 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: {
+                if (!track.uri.includes("tidal")) {
+                    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: {
+                if (!track.uri.includes("vk.com") && !track.uri.includes("vk.ru")) {
+                    const resolvedTrack = await this.resolveFirstTrackFromQuery(`${track.author} - ${track.title}`, Enums_1.SearchPlatform.VKMusic, requester);
+                    if (!resolvedTrack)
+                        return [];
+                    track = resolvedTrack;
                 }
-                break;
+                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: {
+                if (!track.uri.includes("qobuz.com")) {
+                    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;
@@ -652,7 +542,7 @@ class AutoPlayUtils {
                 return tracks;
             }
             default:
-                throw new Error(`Unsupported loadType: ${recommendedResult.loadType}`);
+                throw new Error(`[TrackBuilder] Unsupported loadType: ${recommendedResult.loadType}`);
         }
     }
 }
@@ -685,7 +575,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,

package/dist/wrappers/seyfert.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeyfertManager = void 0;
+const tslib_1 = require("tslib");
+const Manager_1 = require("../structures/Manager");
+const common_1 = require("seyfert/lib/common");
+tslib_1.__exportStar(require("../index"), exports);
+/**
+ * Seyfert wrapper for Magmastream.
+ *
+ * @note This wrapper does require the manual implementation of the "raw" and "ready" events, to call the `updateVoiceState` and `init` methods respectively.
+ *
+ * @example
+ * ```typescript
+ * const client = new Client();
+ * const manager = new SeyfertManager(client, options);
+ *
+ * client.events.values.RAW = {
+ *     data: { name: "raw" },
+ *     run: async (data) => {
+ *         await manager.updateVoiceState(data);
+ *     }
+ * }
+ *
+ * client.events.values.READY = {
+ *     data: { name: "ready" },
+ *     run: async (user, client) => {
+ *         await manager.init({ clientId: client.botId });
+ *     }
+ * }
+ * ```
+ */
+class SeyfertManager extends Manager_1.Manager {
+    client;
+    constructor(client, options) {
+        super(options);
+        this.client = client;
+    }
+    send(packet) {
+        this.client.gateway.send((0, common_1.calculateShardId)(packet.d.guild_id), packet);
+    }
+}
+exports.SeyfertManager = SeyfertManager;