@vyla-entertainment/sdk 1.12.0 → 1.13.0

package/src/sources/hexa.js

@@ -1,82 +0,0 @@
-import crypto from 'node:crypto';
-import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
-
-const API_BASE = 'https://enc-dec.app/api';
-const DOMAINS = ['hexa.su', 'flixer.su'];
-
-async function getChallengeToken() {
-    try {
-        const data = await fetchJson(`${API_BASE}/enc-hexa`, { signal: AbortSignal.timeout(6000) });
-        return data?.status === 200 ? data.result.token : null;
-    } catch { return null; }
-}
-
-export async function getStream({ id, s, e, server }) {
-    try {
-        const apiKey = crypto.randomBytes(32).toString('hex');
-        const capToken = await getChallengeToken();
-        if (!capToken) return null;
-
-        const isTv = s != null && e != null;
-        let decrypted = null;
-
-        for (const domain of DOMAINS) {
-            try {
-                const url = isTv
-                    ? `https://theemoviedb.${domain}/api/tmdb/tv/${id}/season/${s}/episode/${e}/images`
-                    : `https://theemoviedb.${domain}/api/tmdb/movie/${id}/images`;
-
-                const encrypted = await fetchText(url, {
-                    headers: {
-                        'User-Agent': USER_AGENT,
-                        'Referer': `https://${domain}/`,
-                        'Accept': 'text/plain',
-                        'X-Fingerprint-Lite': 'e9136c41504646444',
-                        'X-Api-Key': apiKey,
-                        'X-Cap-Token': capToken
-                    },
-                    signal: AbortSignal.timeout(10000)
-                });
-
-                if (!encrypted) continue;
-
-                const decData = await fetchJson(`${API_BASE}/dec-hexa`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ text: encrypted, key: apiKey }),
-                    signal: AbortSignal.timeout(8000)
-                });
-
-                if (decData?.status === 200 && decData.result?.sources?.length) {
-                    decrypted = decData.result;
-                    break;
-                }
-            } catch { continue; }
-        }
-
-        if (!decrypted?.sources?.length) return null;
-
-        let sources = decrypted.sources.map(src => ({
-            url: src.url,
-            server: `Hexa - ${src.name || src.server || 'Server'}`,
-            type: src.url.includes('.m3u8') ? 'hls' : 'mp4',
-            quality: src.quality || 'Auto',
-            subtitles: (decrypted.subtitles || []).map(sub => ({
-                url: sub.url,
-                lang: sub.label || sub.lang || 'Unknown'
-            })),
-            skipProxy: false
-        }));
-
-        if (server && server !== 'all') {
-            const cleanName = server.replace('Hexa - ', '');
-            sources = sources.filter(u => u.server.includes(cleanName));
-        }
-
-        return sources.length ? { allUrls: sources } : null;
-    } catch { return null; }
-}
-
-export async function getSources() {
-    return ['Hexa'];
-}

package/src/sources/luna.js

@@ -1,125 +0,0 @@
-import { USER_AGENT, fetchText, getTmdbInfo, tmdbToAnilist } from '../utils/helpers.js';
-
-const ACTION_FETCH_SOURCES = 'afb0491c5516f9fff5fcb464d627638df76062f8';
-const WATCH_URL = 'https://luna-stream.me/anime/watch/21/gogoanime/1';
-
-const PROVIDERS = [
-    { id: 'megaplay', name: 'Helios' },
-    { id: 'anibd', name: 'Nova' },
-    { id: 'pahe', name: 'Polaris' },
-    { id: 'gogoanime', name: 'Quasar' },
-    { id: 'zoro', name: 'Zenith' },
-    { id: 'animepahe', name: 'Vega' },
-    { id: 'animekai', name: 'Cosmos' },
-    { id: 'crysoline', name: 'CrysOline' },
-    { id: 'orion', name: 'Orion' },
-    { id: 'pulsar', name: 'Pulsar' }
-];
-
-function parseRscResponse(text) {
-    for (const line of text.split('\n')) {
-        if (line.startsWith('1:')) {
-            try {
-                return JSON.parse(line.slice(2));
-            } catch { }
-        }
-    }
-    return null;
-}
-
-function cleanUrl(rawUrl) {
-    if (!rawUrl) return '';
-    return rawUrl.replace(/^https:\/\/api\.luna-stream\.mehttps:\/\/api\.luna-stream\.me/, 'https://api.luna-stream.me');
-}
-
-async function fetchProviderStreams(anilistId, epNum, provider, subtype) {
-    try {
-        const text = await fetchText(WATCH_URL, {
-            method: 'POST',
-            headers: {
-                'User-Agent': USER_AGENT,
-                'Next-Action': ACTION_FETCH_SOURCES,
-                'Content-Type': 'text/plain;charset=UTF-8',
-                'Accept': 'text/x-component',
-                'Referer': WATCH_URL,
-                'Origin': 'https://luna-stream.me'
-            },
-            body: JSON.stringify([anilistId, provider.id, String(epNum), epNum, subtype, null]),
-            signal: AbortSignal.timeout(10000)
-        });
-
-        if (!text) return [];
-
-        const parsed = parseRscResponse(text);
-        if (!parsed || !Array.isArray(parsed.sources)) return [];
-
-        const streams = [];
-        for (const s of parsed.sources) {
-            if (!s || !s.url) continue;
-
-            const url = cleanUrl(s.url);
-            const format = String(s.type || '').toLowerCase();
-            const isM3U8 = format === 'hls' || format === 'm3u8' || url.includes('.m3u8') || url.includes('.txt');
-
-            streams.push({
-                url,
-                server: `Luna (${provider.name})`,
-                quality: String(s.quality || 'Auto'),
-                type: isM3U8 ? 'hls' : 'mp4',
-                headers: {
-                    'User-Agent': USER_AGENT,
-                    'Referer': 'https://luna-stream.me/'
-                }
-            });
-        }
-
-        return streams;
-    } catch {
-        return [];
-    }
-}
-
-export async function getStream(args) {
-    const { id, s, e, ep, audio, server, tmdbApiKey } = args;
-    const isTv = s != null && e != null;
-    const mediaType = isTv ? 'tv' : 'movie';
-
-    let anilistId = null;
-    try {
-        const info = await getTmdbInfo(tmdbApiKey, id, mediaType, s);
-        anilistId = await tmdbToAnilist(id, mediaType, s, info?.titles || [], info?.year);
-    } catch { }
-
-    if (!anilistId) {
-        anilistId = Number(id);
-    }
-
-    if (!anilistId || isNaN(anilistId)) return null;
-
-    const epNum = Number(e || ep || 1);
-    const resolvedSubtype = audio === 'dub' ? 'dub' : 'sub';
-
-    let targets = PROVIDERS;
-    if (server && server !== 'all') {
-        const clean = server.toLowerCase().replace('luna (', '').replace(')', '').replace('luna', '').trim();
-        targets = PROVIDERS.filter(p => p.id.toLowerCase() === clean || p.name.toLowerCase().includes(clean));
-        if (!targets.length) targets = PROVIDERS;
-    }
-
-    const settled = await Promise.allSettled(
-        targets.map(p => fetchProviderStreams(anilistId, epNum, p, resolvedSubtype))
-    );
-
-    const allUrls = [];
-    for (const r of settled) {
-        if (r.status === 'fulfilled' && Array.isArray(r.value)) {
-            allUrls.push(...r.value);
-        }
-    }
-
-    return allUrls.length ? { allUrls } : null;
-}
-
-export async function getSources() {
-    return PROVIDERS.map(p => `Luna (${p.name})`);
-}

package/src/sources/meowtv.js

@@ -1,142 +0,0 @@
-import { fetchJson, USER_AGENT } from '../utils/helpers.js';
-
-const API_BASE = 'https://api.meowtv.ru';
-const REFERER = 'https://meowtv.ru/';
-const ENC_DEC_API = 'https://enc-dec.app/api/dec-meowtv';
-
-const BASE_HEADERS = {
-    'User-Agent': USER_AGENT,
-    'Accept': 'application/json',
-    'Referer': REFERER,
-    'Origin': 'https://meowtv.ru',
-    'Accept-Language': 'en-US,en;q=0.9'
-};
-
-const SERVERS = [
-    'dcloud', 'acme', 'tcloud', 'ipcloud', 'turkce', 'hindiv3'
-];
-
-const TIMEOUT_MS = 15000;
-
-export const VERIFY_HEADERS = { 'User-Agent': USER_AGENT, 'Referer': REFERER, 'Origin': 'https://meowtv.ru' };
-
-let cachedTicket = null;
-let ticketExpiry = 0;
-
-/**
- * Fetches a stream ticket or returns a cached valid ticket.
- */
-async function getTicket(forceRefresh = false) {
-    const now = Date.now();
-    if (!forceRefresh && cachedTicket && now < ticketExpiry - 10000) {
-        return cachedTicket;
-    }
-
-    try {
-        const res = await fetchJson(`${API_BASE}/streams/ticket`, {
-            method: 'POST',
-            headers: {
-                ...BASE_HEADERS,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({})
-        });
-
-        if (res?.ticket) {
-            cachedTicket = res.ticket;
-            ticketExpiry = typeof res.exp === 'number' ? res.exp : now + 60000;
-            return cachedTicket;
-        }
-    } catch {
-    }
-
-    return null;
-}
-
-async function decryptPayload(payload) {
-    try {
-        const response = await fetchJson(ENC_DEC_API, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ data: payload })
-        });
-
-        if (response?.status !== 200 || !response?.result) {
-            return null;
-        }
-
-        return typeof response.result === 'string' ? JSON.parse(response.result) : response.result;
-    } catch (e) {
-        return null;
-    }
-}
-
-export async function getStream({ id, s, e, server }) {
-    try {
-        const isTv = !!s;
-        let targets = SERVERS;
-        if (server && server !== 'all') {
-            const cleanName = server.replace('MeowTV - ', '');
-            targets = SERVERS.includes(cleanName) ? [cleanName] : [targets[0]];
-        }
-
-        const ticket = await getTicket();
-        const requestHeaders = {
-            ...BASE_HEADERS,
-            ...(ticket ? { 'x-stream-ticket': ticket } : {})
-        };
-
-        const results = await Promise.all(targets.map(async srv => {
-            try {
-                return await Promise.race([
-                    (async () => {
-                        const path = isTv
-                            ? `/streams/tv/${id}/${s}/${e}?s=${encodeURIComponent(srv)}`
-                            : `/streams/movie/${id}?s=${encodeURIComponent(srv)}`;
-
-                        const payload = await fetchJson(`${API_BASE}${path}`, {
-                            headers: requestHeaders
-                        });
-
-                        if (!payload) return null;
-
-                        const data = await decryptPayload(payload);
-                        if (!data) return null;
-
-                        const urls = [];
-                        if (data?.url?.startsWith('http')) {
-                            urls.push({
-                                url: data.url,
-                                server: `MeowTV - ${srv}`,
-                            });
-                        }
-
-                        if (Array.isArray(data?.streams)) {
-                            for (const stream of data.streams) {
-                                if (stream?.url?.startsWith('http')) {
-                                    urls.push({
-                                        url: stream.url,
-                                        server: `MeowTV - ${srv} (${stream.language || 'Unknown'})`,
-                                    });
-                                }
-                            }
-                        }
-                        return urls;
-                    })(),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout exceeded')), TIMEOUT_MS))
-                ]);
-            } catch (err) {
-                return null;
-            }
-        }));
-
-        const allUrls = results.filter(Boolean).flat();
-        return allUrls.length ? { allUrls } : null;
-    } catch (e) {
-        return null;
-    }
-}
-
-export async function getSources() {
-    return SERVERS.map(s => `MeowTV - ${s}`);
-}

package/src/sources/peestream.js

@@ -1,122 +0,0 @@
-import { USER_AGENT, fetchJson, getTmdbInfo } from '../utils/helpers.js';
-
-const BASE_URL = 'https://providers.peestream.in';
-
-export async function getStream(args) {
-    const { id, s, e, server, tmdbApiKey } = args;
-    const isTv = s != null && e != null;
-    const type = isTv ? 'tv' : 'movie';
-
-    let title = args.title || '';
-    let releaseYear = args.year || '';
-    let imdbId = args.imdbId || '';
-
-    if (!title) {
-        try {
-            const info = await getTmdbInfo(id, type, s, tmdbApiKey);
-            if (info) {
-                title = info.title || '';
-                if (info.year) releaseYear = info.year;
-                if (info.imdbId) imdbId = info.imdbId;
-            }
-        } catch { }
-    }
-
-    const queryParams = new URLSearchParams({
-        type,
-        tmdbId: String(id),
-        title: title || String(id)
-    });
-    if (releaseYear) queryParams.set('releaseYear', String(releaseYear));
-    if (imdbId) queryParams.set('imdbId', String(imdbId));
-    if (isTv) {
-        queryParams.set('season', String(s));
-        queryParams.set('episode', String(e));
-    }
-
-    const allUrls = [];
-
-    try {
-        const scrapeUrl = `${BASE_URL}/scrape?${queryParams.toString()}`;
-        const res = await fetch(scrapeUrl, {
-            headers: {
-                'User-Agent': USER_AGENT,
-                'Accept': 'text/event-stream',
-                'Referer': `${BASE_URL}/`
-            },
-            signal: AbortSignal.timeout(15000)
-        });
-
-        if (res.ok) {
-            const text = await res.text();
-            const events = text.split('\n\n');
-            for (const ev of events) {
-                if (ev.includes('event: completed')) {
-                    const dataMatch = ev.match(/data:\s*(.+)/);
-                    if (dataMatch) {
-                        try {
-                            const parsed = JSON.parse(dataMatch[1].trim());
-                            const stream = parsed.stream;
-                            const streamUrl = stream?.playlist || stream?.url || stream?.file;
-                            if (streamUrl) {
-                                allUrls.push({
-                                    url: streamUrl,
-                                    server: `PeeStream - ${parsed.sourceId || 'Poseidon'}`,
-                                    quality: 'Auto',
-                                    type: stream.type === 'hls' || streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
-                                    headers: stream.headers || {
-                                        'User-Agent': USER_AGENT
-                                    }
-                                });
-                            }
-                        } catch { }
-                    }
-                }
-            }
-        }
-    } catch { }
-
-    if (!allUrls.length) {
-        try {
-            const searchUrl = `${BASE_URL}/api/search?q=${encodeURIComponent(title || id)}&type=${type}&tmdbId=${id}${isTv ? `&season=${s}&episode=${e}` : ''}`;
-            const data = await fetchJson(searchUrl, {
-                headers: {
-                    'User-Agent': USER_AGENT,
-                    'Accept': 'application/json',
-                    'Referer': `${BASE_URL}/`
-                },
-                signal: AbortSignal.timeout(10000)
-            });
-
-            if (data && Array.isArray(data.results)) {
-                for (const result of data.results) {
-                    const pName = result.providerName || result.provider || 'PeeStream';
-                    for (const stream of result.streams || []) {
-                        if (!stream || !stream.url) continue;
-                        allUrls.push({
-                            url: stream.url,
-                            server: `PeeStream - ${stream.name || pName}`,
-                            quality: stream.quality || 'Auto',
-                            type: stream.type === 'm3u8' || stream.url.includes('.m3u8') ? 'hls' : 'mp4',
-                            headers: stream.headers || {
-                                'User-Agent': USER_AGENT
-                            }
-                        });
-                    }
-                }
-            }
-        } catch { }
-    }
-
-    if (server && server !== 'all') {
-        const clean = server.toLowerCase().replace('peestream - ', '');
-        const filtered = allUrls.filter(u => u.server.toLowerCase().includes(clean));
-        if (filtered.length) return { allUrls: filtered };
-    }
-
-    return allUrls.length ? { allUrls } : null;
-}
-
-export async function getSources() {
-    return ['PeeStream - vaplayer'];
-}

package/src/sources/vadapav.js

@@ -1,85 +0,0 @@
-import { getUA } from '../utils/helpers.js';
-
-const ADDON_BASE = 'https://stremio.vadapav.mov';
-
-async function resolveImdbId(sdk, id, isTv) {
-    const apiKey = sdk?.tmdbApiKey || process.env.TMDB_API_KEY;
-    if (!apiKey) return null;
-    const type = isTv ? 'tv' : 'movie';
-    try {
-        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}&append_to_response=external_ids`, {
-            signal: AbortSignal.timeout(6000),
-        });
-        if (!res.ok) return null;
-        const data = await res.json();
-        return data.imdb_id || data.external_ids?.imdb_id || null;
-    } catch {
-        return null;
-    }
-}
-
-export async function getStream({ id, s, e, sdk }) {
-    const isTv = Boolean(s && e);
-    const ua = getUA();
-
-    const imdbId = await resolveImdbId(sdk, id, isTv);
-    const targetIds = [];
-    if (imdbId && imdbId.startsWith('tt')) {
-        targetIds.push(imdbId);
-    }
-    targetIds.push(`tmdb:${id}`);
-
-    const seenUrls = new Set();
-    const allUrls = [];
-
-    const defaultHeaders = {
-        'User-Agent': ua,
-        Accept: 'application/json, text/plain, */*',
-    };
-
-    for (const targetId of targetIds) {
-        const streamPath = isTv
-            ? `${ADDON_BASE}/stream/series/${targetId}:${s}:${e}.json`
-            : `${ADDON_BASE}/stream/movie/${targetId}.json`;
-
-        try {
-            const res = await fetch(streamPath, {
-                headers: defaultHeaders,
-                signal: AbortSignal.timeout(12000),
-            });
-
-            if (!res.ok) continue;
-            const data = await res.json();
-
-            if (Array.isArray(data?.streams) && data.streams.length > 0) {
-                for (const item of data.streams) {
-                    if (!item || typeof item !== 'object') continue;
-                    const url = String(item.url || '').trim();
-                    if (!url || !url.startsWith('http') || seenUrls.has(url)) continue;
-
-                    seenUrls.add(url);
-
-                    const rawTitle = item.title ? String(item.title).trim() : '';
-                    const rawName = item.name ? String(item.name).trim() : 'vadapav.mov';
-                    const label = rawTitle || rawName;
-
-                    allUrls.push({
-                        url,
-                        label,
-                        headers: defaultHeaders,
-                    });
-                }
-
-                if (allUrls.length > 0) break;
-            }
-        } catch { }
-    }
-
-    if (allUrls.length === 0) return null;
-
-    return {
-        url: allUrls[0].url,
-        allUrls,
-        headers: allUrls[0].headers,
-    };
-}

package/src/sources/vidcore.js

@@ -1,43 +0,0 @@
-import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
-
-const API_BASE = 'https://enc-dec.app/api';
-const HEADERS = { 'User-Agent': USER_AGENT, 'Referer': 'https://vidcore.net/', 'X-Requested-With': 'XMLHttpRequest' };
-
-async function getDynamicServers(id, s, e) {
-    try {
-        const html = await fetchText(s != null && e != null ? `https://vidcore.net/tv/${id}/${s}/${e}/` : `https://vidcore.net/movie/${id}/`, { headers: HEADERS });
-
-        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/) || html.match(/"(?:en|token)":"(.*?)"/);
-        if (!match?.[1]) return null;
-
-        const encData = await fetchJson(`${API_BASE}/enc-vidcore?text=${encodeURIComponent(match[1])}`);
-        if (!encData?.result) return null;
-        const { servers: serversUrl, stream: streamUrl, token } = encData.result;
-        const reqHeaders = { ...HEADERS, 'X-CSRF-Token': token };
-        const serversEncrypted = await fetchText(serversUrl, { method: 'POST', headers: reqHeaders });
-        const decData = await fetchJson(`${API_BASE}/dec-vidcore`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: serversEncrypted }) });
-        return decData?.result ? { servers: decData.result, streamUrl, reqHeaders } : null;
-    } catch { return null; }
-}
-
-export async function getStream({ id, s, e }) {
-    const data = await getDynamicServers(id, s, e);
-    if (!data?.servers?.length) return null;
-    for (const srv of data.servers) {
-        try {
-            const streamEncrypted = await fetchText(`${data.streamUrl}/${srv.data}`, { method: 'POST', headers: data.reqHeaders });
-            const decData = await fetchJson(`${API_BASE}/dec-vidcore`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: streamEncrypted }) });
-            const url = decData?.result?.url;
-            if (url) {
-                const r = await fetch(url, { headers: { ...HEADERS, 'Range': 'bytes=0-511' }, signal: AbortSignal.timeout(5000) });
-                if (r.ok || r.status === 206) return { url, subtitles: (decData.result.captions || []).map(c => ({ url: c.file, lang: c.label || 'Unknown' })), headers: { ...HEADERS, 'Origin': 'https://vidcore.net' }, server: srv.name };
-            }
-        } catch { }
-    }
-    return null;
-}
-
-export async function getSources(args) {
-    const data = await getDynamicServers(args.id, args.s, args.e);
-    return data?.servers ? data.servers.map(s => s.name) : [];
-}

package/src/sources/vidfast.js

@@ -1,53 +0,0 @@
-import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
-
-const API_BASE = 'https://enc-dec.app/api';
-const DOMAIN = 'https://vidfast.vc';
-const HEADERS = { 'User-Agent': USER_AGENT, 'Referer': `${DOMAIN}/`, 'X-Requested-With': 'XMLHttpRequest' };
-
-async function getVidfastMeta(id, s, e) {
-    try {
-        const embedUrl = s != null && e != null ? `${DOMAIN}/tv/${id}/${s}/${e}/` : `${DOMAIN}/movie/${id}/`;
-        const html = await fetchText(embedUrl, { headers: { 'User-Agent': USER_AGENT } });
-
-        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/) || html.match(/"(?:en|token)":"(.*?)"/);
-        if (!match?.[1]) return null;
-
-        const encData = await fetchJson(`${API_BASE}/enc-vidfast?text=${encodeURIComponent(match[1])}`);
-        if (encData.status !== 200 || !encData.result) return null;
-
-        const { servers: serversUrl, stream: streamUrl, token } = encData.result;
-        const reqHeaders = { ...HEADERS, 'X-CSRF-Token': token };
-
-        const serversEncrypted = await fetchText(serversUrl, { method: 'POST', headers: reqHeaders });
-        const decServersData = await fetchJson(`${API_BASE}/dec-vidfast`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: serversEncrypted }) });
-
-        if (decServersData.status !== 200 || !decServersData.result) return null;
-        return { servers: decServersData.result, streamUrl, reqHeaders };
-    } catch { return null; }
-}
-
-export async function getStream({ id, s, e, server }) {
-    const meta = await getVidfastMeta(id, s, e);
-    if (!meta?.servers?.length) return null;
-    const { servers, streamUrl, reqHeaders } = meta;
-    let targets = servers;
-    if (server && server !== 'all') {
-        const cleanName = server.replace('VidFast - ', '');
-        targets = servers.filter(srv => srv.name === cleanName);
-        if (!targets.length) targets = servers;
-    }
-    const results = await Promise.allSettled(targets.map(async srv => {
-        const streamEncrypted = await fetchText(`${streamUrl}/${srv.data}`, { method: 'POST', headers: reqHeaders });
-        const decStreamData = await fetchJson(`${API_BASE}/dec-vidfast`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: streamEncrypted }) });
-        if (decStreamData.status !== 200 || !decStreamData.result?.url) throw new Error();
-        return { url: decStreamData.result.url, server: `VidFast - ${srv.name || 'Server'}`, type: decStreamData.result.url.includes('.m3u8') ? 'hls' : 'mp4', subtitles: (decStreamData.result.captions || []).map(c => ({ url: c.file, lang: c.label || 'Unknown' })), headers: { ...HEADERS, 'Origin': DOMAIN } };
-    }));
-    const allUrls = [];
-    for (const r of results) if (r.status === 'fulfilled') allUrls.push(r.value);
-    return allUrls.length ? { allUrls } : null;
-}
-
-export async function getSources(args) {
-    const meta = await getVidfastMeta(args.id, args.s, args.e);
-    return meta?.servers ? meta.servers.map(srv => `VidFast - ${srv.name}`) : [];
-}