@vyla-entertainment/sdk 1.20.0 → 1.21.0

package/src/utils/helpers.js

@@ -1,247 +1,586 @@
-import crypto from 'node:crypto';
-
-export const UA_LIST = [
-    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
-    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
-    'Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0',
-    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0',
-];
-
-export const getUA = () => UA_LIST[Math.floor(Math.random() * UA_LIST.length)];
-export const USER_AGENT = UA_LIST[0];
-
-let sharedDcKey = null;
-
-export function decryptPartner(responseText, keyEnv) {
-    try {
-        const sep = responseText.indexOf(':');
-        if (sep === -1) return null;
-        const iv = Buffer.from(responseText.slice(0, sep), 'base64');
-        const encrypted = responseText.slice(sep + 1);
-        if (!sharedDcKey) sharedDcKey = crypto.createHash('sha256').update(keyEnv || '').digest();
-        const decipher = crypto.createDecipheriv('aes-256-cbc', sharedDcKey, iv);
-        return JSON.parse(decipher.update(encrypted, 'base64', 'utf8') + decipher.final('utf8'));
-    } catch {
-        return null;
-    }
-}
-
-export async function fetchJson(url, options) {
-    const res = await fetch(url, options);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    return res.json();
-}
-
-export async function fetchText(url, options) {
-    const res = await fetch(url, options);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    return res.text();
-}
-
-const tmdbInfoCache = new Map();
-const anilistCache = new Map();
-const tmdbValidationCache = new Map();
-
-function pruneHelperCache(cache) {
-    const now = Date.now();
-    for (const [k, v] of cache) if (now - v.ts >= v.ttl) cache.delete(k);
-    if (cache.size > 3000) {
-        const overflow = cache.size - 3000;
-        const it = cache.keys();
-        for (let i = 0; i < overflow; i++) cache.delete(it.next().value);
-    }
-}
-
-export async function resolveImdbId(id, isTv, tmdbApiKey) {
-    if (typeof id === 'string' && id.startsWith('tt')) return id;
-    const apiKey = tmdbApiKey || process.env.TMDB_API_KEY;
-    if (!apiKey) return `tt${id}`;
-    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(5000),
-        });
-        if (!res.ok) return `tt${id}`;
-        const data = await res.json();
-        return data.imdb_id || data.external_ids?.imdb_id || `tt${id}`;
-    } catch {
-        return `tt${id}`;
-    }
-}
-
-setInterval(() => {
-    pruneHelperCache(tmdbValidationCache);
-    pruneHelperCache(tmdbInfoCache);
-    pruneHelperCache(anilistCache);
-}, 60000).unref();
-
-function cacheGet(cache, key) {
-    const entry = cache.get(key);
-    if (!entry) return undefined;
-    if (Date.now() - entry.ts >= entry.ttl) { cache.delete(key); return undefined; }
-    return entry.val;
-}
-
-function cacheSet(cache, key, val, ttl) { cache.set(key, { val, ts: Date.now(), ttl }); }
-
-export async function createStreamArgs(source, sdk, id, s, e, clientIP = null) {
-    const audio = /dub$/.test(source.key) ? 'dub' : 'sub';
-    return {
-        id: id,
-        s: s,
-        e: e,
-        clientIP: clientIP,
-        absoluteBase: '/',
-        audio,
-        sdk,
-        config: source,
-    }
-}
-
-export async function validateTmdbId(tmdbApiKey, tmdbId, mediaType = 'movie') {
-    let apiKey = tmdbApiKey;
-    let id = tmdbId;
-    let type = mediaType;
-    if (id === 'movie' || id === 'tv' || !id) {
-        if (apiKey && apiKey !== 'movie' && apiKey !== 'tv') {
-            type = id || 'movie';
-            id = apiKey;
-            apiKey = process.env.TMDB_API_KEY;
-        }
-    }
-    if (!apiKey) {
-        apiKey = process.env.TMDB_API_KEY;
-    }
-    const key = `${id}-${type}`;
-    const cached = cacheGet(tmdbValidationCache, key);
-    if (cached !== undefined) return cached;
-    if (!apiKey) return { valid: false, error: 'TMDB API key not configured' };
-    try {
-        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`, { signal: AbortSignal.timeout(5000) });
-        if (res.ok) {
-            const data = await res.json();
-            const isValid = !!(data?.id && (data?.title || data?.name));
-            const result = { valid: isValid, error: isValid ? null : 'Invalid TMDB ID' };
-            cacheSet(tmdbValidationCache, key, result, 300000);
-            return result;
-        }
-        const result = { valid: false, error: `TMDB API error: ${res.status}` };
-        cacheSet(tmdbValidationCache, key, result, 60000);
-        return result;
-    } catch (error) {
-        const result = { valid: false, error: `Failed to validate TMDB ID: ${error.message}` };
-        cacheSet(tmdbValidationCache, key, result, 60000);
-        return result;
-    }
-}
-
-export async function getTmdbInfo(tmdbApiKey, tmdbId, mediaType, season) {
-    let apiKey = tmdbApiKey;
-    let id = tmdbId;
-    let type = mediaType;
-    let s = season;
-    if (apiKey === 'movie' || apiKey === 'tv') {
-        type = apiKey;
-        id = tmdbId;
-        apiKey = process.env.TMDB_API_KEY;
-    } else if (id === 'movie' || id === 'tv') {
-        type = id;
-        id = apiKey;
-        apiKey = process.env.TMDB_API_KEY;
-    }
-    if (!apiKey) {
-        apiKey = process.env.TMDB_API_KEY;
-    }
-    const key = `${id}-${type}-${s || ''}`;
-    const cached = cacheGet(tmdbInfoCache, key);
-    if (cached !== undefined) return cached;
-    if (!apiKey) return { isAnime: false, titles: [], year: null, imdbId: null };
-    try {
-        const [mainRes, seasonRes] = await Promise.all([
-            fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}&append_to_response=external_ids`, { signal: AbortSignal.timeout(5000) }),
-            s && type === 'tv' ? fetch(`https://api.themoviedb.org/3/tv/${id}/season/${s}?api_key=${apiKey}`, { signal: AbortSignal.timeout(5000) }) : Promise.resolve(null),
-        ]);
-        let mainData = null, seasonData = null;
-        if (mainRes.ok) mainData = await mainRes.json(); else mainRes.body?.cancel();
-        if (seasonRes) { if (seasonRes.ok) seasonData = await seasonRes.json(); else seasonRes.body?.cancel(); }
-        const genres = mainData?.genres || [];
-        const isAnime = genres.some(g => g.id === 16) && ((mainData?.origin_country || []).includes('JP') || mainData?.original_language === 'ja');
-        const titles = [];
-        if (seasonData?.name) titles.push(seasonData.name);
-        const titleText = mainData?.title || mainData?.name || '';
-        const ot = mainData?.original_title || mainData?.original_name || '';
-        if (titleText) titles.push(titleText);
-        if (ot && ot !== titleText) titles.push(ot);
-        const dateStr = seasonData?.air_date || mainData?.release_date || mainData?.first_air_date || '';
-        const result = { isAnime, titles: [...new Set(titles.filter(Boolean))], year: dateStr ? parseInt(dateStr.slice(0, 4), 10) : null, imdbId: mainData?.imdb_id || mainData?.external_ids?.imdb_id || null };
-        cacheSet(tmdbInfoCache, key, result, 600000);
-        return result;
-    } catch { return { isAnime: false, titles: [], year: null, imdbId: null }; }
-}
-
-export async function tmdbToAnilist(tmdbId, mediaType, season, titles = [], year = null) {
-    const key = `${tmdbId}-${mediaType}-${season || ''}`;
-    const cached = cacheGet(anilistCache, key);
-    if (cached !== undefined) return cached;
-    try {
-        const res = await fetch(`https://api.ani.zip/mappings?tmdb_id=${tmdbId}&type=${mediaType}&season=${season || 1}`, { signal: AbortSignal.timeout(6000) });
-        if (res.ok) {
-            const id = (await res.json())?.mappings?.[0]?.anilist_id;
-            if (id) { cacheSet(anilistCache, key, id, 600000); return id; }
-        } else res.body?.cancel();
-    } catch { }
-    if (!titles.length) return null;
-    const query = `query ($s: String) { Page(page:1,perPage:10) { media(search:$s,type:ANIME) { id title { romaji english native } startDate { year } format } } }`;
-    let bestId = null, bestScore = -1;
-    for (const searchTitle of titles) {
-        try {
-            const res = await fetch('https://graphql.anilist.co', { method: 'POST', headers: { 'Content-Type': 'application/json', Accept: 'application/json' }, body: JSON.stringify({ query, variables: { s: searchTitle } }), signal: AbortSignal.timeout(6000) });
-            if (!res.ok) { res.body?.cancel(); continue; }
-            for (const entry of (await res.json())?.data?.Page?.media || []) {
-                const entryTitles = [entry.title?.romaji, entry.title?.english, entry.title?.native].filter(Boolean).map(t => t.toLowerCase());
-                const sl = searchTitle.toLowerCase();
-                let score = 0;
-                if (entryTitles.some(t => t === sl)) score += 5;
-                else if (entryTitles.some(t => t.includes(sl) || sl.includes(t))) score += 3;
-                else if (entryTitles.some(t => { const w = sl.split(/\s+/).filter(x => x.length > 3); return w.length > 0 && w.every(x => t.includes(x)); })) score += 2;
-                else continue;
-                if (year && entry.startDate?.year) {
-                    const diff = Math.abs(entry.startDate.year - year);
-                    if (diff === 0) score += 3; else if (diff === 1) score += 1; else if (diff > 2) score -= 3;
-                }
-                if (mediaType === 'tv' && ['TV', 'TV_SHORT', 'ONA', 'OVA'].includes(entry.format)) score += 1;
-                if (mediaType === 'movie' && entry.format === 'MOVIE') score += 1;
-                if (score > bestScore) { bestScore = score; bestId = entry.id; }
-            }
-            if (bestScore >= 8) break;
-        } catch { }
-    }
-    if (bestId) cacheSet(anilistCache, key, bestId, 600000);
-    return bestId;
-}
-
-export async function imdbToTmdb(tmdbApiKey, imdbId, mediaType = 'movie') {
-    let apiKey = tmdbApiKey;
-    let id = imdbId;
-    let type = mediaType;
-    if (id === 'movie' || id === 'tv') {
-        type = id;
-        id = apiKey;
-        apiKey = process.env.TMDB_API_KEY;
-    }
-    if (!apiKey) {
-        apiKey = process.env.TMDB_API_KEY;
-    }
-    const key = `imdb-${id}`;
-    const cached = cacheGet(tmdbInfoCache, key);
-    if (cached !== undefined) return cached;
-    if (!apiKey) return null;
-    try {
-        const data = await fetchJson(`https://api.themoviedb.org/3/find/${id}?api_key=${apiKey}&external_source=imdb_id`, { signal: AbortSignal.timeout(5000) });
-        let result = null;
-        if (type === 'movie' && data.movie_results?.length) result = data.movie_results[0].id;
-        else if (type === 'tv' && data.tv_results?.length) result = data.tv_results[0].id;
-        if (result) cacheSet(tmdbInfoCache, key, result, 600000);
-        return result;
-    } catch { return null; }
-}
+import crypto from 'node:crypto';
+
+export const UA_LIST = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
+    'Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0',
+];
+
+export const getUA = () => UA_LIST[Math.floor(Math.random() * UA_LIST.length)];
+export const USER_AGENT = UA_LIST[0];
+
+const DEFAULT_TMDB_KEY = '45dbdd5e714da212424bda0336167447';
+
+let sharedDcKey = null;
+
+const tmdbInfoCache = new Map();
+const anilistCache = new Map();
+const tmdbValidationCache = new Map();
+const tmdbMetaCache = new Map();
+
+function pruneCache(cache) {
+    const now = Date.now();
+    for (const [k, v] of cache) {
+        if (now - v.ts >= v.ttl) cache.delete(k);
+    }
+    if (cache.size > 3000) {
+        const overflow = cache.size - 3000;
+        const it = cache.keys();
+        for (let i = 0; i < overflow; i++) cache.delete(it.next().value);
+    }
+}
+
+setInterval(() => {
+    pruneCache(tmdbValidationCache);
+    pruneCache(tmdbInfoCache);
+    pruneCache(anilistCache);
+    pruneCache(tmdbMetaCache);
+}, 60000).unref();
+
+function cacheGet(cache, key) {
+    const entry = cache.get(key);
+    if (!entry) return undefined;
+    if (Date.now() - entry.ts >= entry.ttl) {
+        cache.delete(key);
+        return undefined;
+    }
+    return entry.val;
+}
+
+function cacheSet(cache, key, val, ttl) {
+    cache.set(key, { val, ts: Date.now(), ttl });
+}
+
+export function resolveTmdbKey(args = {}, sdk = null) {
+    return (
+        args?.tmdbApiKey ||
+        args?.sdk?.tmdbApiKey ||
+        sdk?.tmdbApiKey ||
+        process.env.TMDB_API_KEY ||
+        DEFAULT_TMDB_KEY
+    );
+}
+
+export function slugify(text) {
+    if (!text) return '';
+    return String(text)
+        .toLowerCase()
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+
+export function cleanTitle(text) {
+    if (!text) return '';
+    return String(text)
+        .toLowerCase()
+        .replace(/\(\d{4}\)/g, '')
+        .replace(/[^a-z0-9]/g, '')
+        .trim();
+}
+
+export function formatBytes(bytes, decimals = 2) {
+    if (!bytes || bytes <= 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
+    return `${(bytes / Math.pow(k, i)).toFixed(decimals)} ${sizes[i]}`;
+}
+
+export function getRandomHex(size = 32) {
+    return crypto.randomBytes(size).toString('hex');
+}
+
+export async function fetchJson(url, options = {}) {
+    const res = await fetch(url, options);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return res.json();
+}
+
+export async function fetchText(url, options = {}) {
+    const res = await fetch(url, options);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return res.text();
+}
+
+export function decryptPartner(responseText, keyEnv) {
+    try {
+        const sep = responseText.indexOf(':');
+        if (sep === -1) return null;
+        const iv = Buffer.from(responseText.slice(0, sep), 'base64');
+        const encrypted = responseText.slice(sep + 1);
+        if (!sharedDcKey) sharedDcKey = crypto.createHash('sha256').update(keyEnv || '').digest();
+        const decipher = crypto.createDecipheriv('aes-256-cbc', sharedDcKey, iv);
+        return JSON.parse(decipher.update(encrypted, 'base64', 'utf8') + decipher.final('utf8'));
+    } catch {
+        return null;
+    }
+}
+
+export async function getTmdbMetadata(id, isTv, apiKey = null) {
+    const key = apiKey || process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+    const type = isTv ? 'tv' : 'movie';
+    const cacheKey = `${id}-${type}-${key}`;
+    const cached = cacheGet(tmdbMetaCache, cacheKey);
+    if (cached !== undefined) return cached;
+
+    const fallback = {
+        title: '',
+        originalTitle: '',
+        titles: [],
+        year: null,
+        releaseDate: '',
+        imdbId: null,
+        isAnime: false,
+        runtime: 0,
+        seasons: [],
+    };
+
+    try {
+        const url = `https://api.themoviedb.org/3/${type}/${id}?api_key=${key}&append_to_response=external_ids,alternative_titles`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(6000) });
+        if (!res.ok) {
+            cacheSet(tmdbMetaCache, cacheKey, fallback, 60000);
+            return fallback;
+        }
+
+        const data = await res.json();
+        const title = data.name || data.title || '';
+        const originalTitle = data.original_name || data.original_title || '';
+        const releaseDate = data.first_air_date || data.release_date || '';
+        const year = releaseDate ? parseInt(releaseDate.slice(0, 4), 10) : null;
+        const imdbId = data.imdb_id || data.external_ids?.imdb_id || null;
+        const runtime = isTv ? (data.episode_run_time?.[0] || 24) : (data.runtime || 90);
+
+        const titles = [];
+        if (title) titles.push(title);
+        if (originalTitle && !titles.includes(originalTitle)) titles.push(originalTitle);
+
+        const alts = data.alternative_titles?.titles || data.alternative_titles?.results || [];
+        for (const alt of alts) {
+            const altTitle = alt.title || alt.name;
+            if (altTitle && !titles.includes(altTitle)) titles.push(altTitle);
+        }
+
+        const genres = data.genres || [];
+        const isAnime = genres.some(g => g.id === 16) && ((data.origin_country || []).includes('JP') || data.original_language === 'ja');
+
+        const result = {
+            title,
+            originalTitle,
+            titles,
+            year,
+            releaseDate,
+            imdbId,
+            isAnime,
+            runtime,
+            seasons: Array.isArray(data.seasons) ? data.seasons : [],
+        };
+
+        cacheSet(tmdbMetaCache, cacheKey, result, 600000);
+        return result;
+    } catch {
+        cacheSet(tmdbMetaCache, cacheKey, fallback, 60000);
+        return fallback;
+    }
+}
+
+export async function resolveImdbId(id, isTv, tmdbApiKey = null) {
+    if (typeof id === 'string' && id.startsWith('tt')) return id;
+    const meta = await getTmdbMetadata(id, isTv, tmdbApiKey);
+    return meta?.imdbId || `tt${id}`;
+}
+
+export async function getTmdbInfo(arg1, arg2, arg3, arg4) {
+    let apiKey = null;
+    let id = null;
+    let type = null;
+    let season = null;
+
+    if (arg1 === 'movie' || arg1 === 'tv') {
+        type = arg1;
+        id = arg2;
+        season = arg3;
+        apiKey = arg4 || process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+    } else if (arg2 === 'movie' || arg2 === 'tv') {
+        if (typeof arg1 === 'string' && arg1.length > 20 && !/^\d+$/.test(arg1)) {
+            apiKey = arg1;
+            id = arg3;
+            type = arg2;
+            season = arg4;
+        } else {
+            id = arg1;
+            type = arg2;
+            season = arg3;
+            apiKey = arg4 || process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+        }
+    } else if (arg3 === 'movie' || arg3 === 'tv') {
+        apiKey = arg1;
+        id = arg2;
+        type = arg3;
+        season = arg4;
+    } else {
+        id = arg1;
+        type = arg2 || 'movie';
+        season = arg3;
+        apiKey = arg4 || process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+    }
+
+    if (!apiKey) apiKey = process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+
+    const isTv = type === 'tv';
+    const key = `${id}-${type}-${season || ''}-${apiKey}`;
+    const cached = cacheGet(tmdbInfoCache, key);
+    if (cached !== undefined) return cached;
+
+    try {
+        const meta = await getTmdbMetadata(id, isTv, apiKey);
+        let seasonTitle = null;
+
+        if (season && isTv) {
+            try {
+                const seasonRes = await fetch(`https://api.themoviedb.org/3/tv/${id}/season/${season}?api_key=${apiKey}`, { signal: AbortSignal.timeout(5000) });
+                if (seasonRes.ok) {
+                    const seasonData = await seasonRes.json();
+                    if (seasonData?.name) seasonTitle = seasonData.name;
+                }
+            } catch { }
+        }
+
+        const titles = seasonTitle ? [seasonTitle, ...meta.titles] : meta.titles;
+        const result = {
+            name: meta.title,
+            title: meta.title,
+            isAnime: meta.isAnime,
+            titles: [...new Set(titles.filter(Boolean))],
+            year: meta.year,
+            release_date: meta.releaseDate,
+            first_air_date: meta.releaseDate,
+            imdbId: meta.imdbId,
+            imdb_id: meta.imdbId,
+            external_ids: { imdb_id: meta.imdbId },
+            seasons: meta.seasons,
+            runtime: meta.runtime,
+        };
+
+        cacheSet(tmdbInfoCache, key, result, 600000);
+        return result;
+    } catch {
+        const fallback = {
+            name: '',
+            title: '',
+            isAnime: false,
+            titles: [],
+            year: null,
+            release_date: '',
+            first_air_date: '',
+            imdbId: null,
+            imdb_id: null,
+            external_ids: { imdb_id: null },
+            seasons: [],
+            runtime: 0,
+        };
+        return fallback;
+    }
+}
+
+export async function validateTmdbId(tmdbApiKey, tmdbId, mediaType = 'movie') {
+    let apiKey = tmdbApiKey;
+    let id = tmdbId;
+    let type = mediaType;
+
+    if (id === 'movie' || id === 'tv' || !id) {
+        if (apiKey && apiKey !== 'movie' && apiKey !== 'tv') {
+            type = id || 'movie';
+            id = apiKey;
+            apiKey = process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+        }
+    }
+    if (!apiKey) apiKey = process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+
+    const key = `${id}-${type}`;
+    const cached = cacheGet(tmdbValidationCache, key);
+    if (cached !== undefined) return cached;
+
+    try {
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`, { signal: AbortSignal.timeout(5000) });
+        if (res.ok) {
+            const data = await res.json();
+            const isValid = Boolean(data?.id && (data?.title || data?.name));
+            const result = { valid: isValid, error: isValid ? null : 'Invalid TMDB ID' };
+            cacheSet(tmdbValidationCache, key, result, 300000);
+            return result;
+        }
+        const result = { valid: false, error: `TMDB API error: ${res.status}` };
+        cacheSet(tmdbValidationCache, key, result, 60000);
+        return result;
+    } catch (error) {
+        const result = { valid: false, error: `Failed to validate TMDB ID: ${error.message}` };
+        cacheSet(tmdbValidationCache, key, result, 60000);
+        return result;
+    }
+}
+
+export async function imdbToTmdb(tmdbApiKey, imdbId, mediaType = 'movie') {
+    let apiKey = tmdbApiKey;
+    let id = imdbId;
+    let type = mediaType;
+
+    if (id === 'movie' || id === 'tv') {
+        type = id;
+        id = apiKey;
+        apiKey = process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+    }
+    if (!apiKey) apiKey = process.env.TMDB_API_KEY || DEFAULT_TMDB_KEY;
+
+    const key = `imdb-${id}`;
+    const cached = cacheGet(tmdbInfoCache, key);
+    if (cached !== undefined) return cached;
+
+    try {
+        const data = await fetchJson(`https://api.themoviedb.org/3/find/${id}?api_key=${apiKey}&external_source=imdb_id`, { signal: AbortSignal.timeout(5000) });
+        let result = null;
+        if (type === 'movie' && data.movie_results?.length) result = data.movie_results[0].id;
+        else if (type === 'tv' && data.tv_results?.length) result = data.tv_results[0].id;
+        if (result) cacheSet(tmdbInfoCache, key, result, 600000);
+        return result;
+    } catch {
+        return null;
+    }
+}
+
+export async function tmdbToAnilist(tmdbId, mediaType, season, titles = [], year = null) {
+    const key = `${tmdbId}-${mediaType}-${season || ''}`;
+    const cached = cacheGet(anilistCache, key);
+    if (cached !== undefined) return cached;
+
+    try {
+        const res = await fetch(`https://api.ani.zip/mappings?tmdb_id=${tmdbId}&type=${mediaType}&season=${season || 1}`, { signal: AbortSignal.timeout(6000) });
+        if (res.ok) {
+            const data = await res.json();
+            const id = data?.mappings?.[0]?.anilist_id;
+            if (id) {
+                cacheSet(anilistCache, key, id, 600000);
+                return id;
+            }
+        }
+    } catch { }
+
+    if (!titles.length) return null;
+
+    const query = `query ($s: String) { Page(page:1,perPage:10) { media(search:$s,type:ANIME) { id title { romaji english native } startDate { year } format } } }`;
+    let bestId = null;
+    let bestScore = -1;
+
+    for (const searchTitle of titles) {
+        try {
+            const res = await fetch('https://graphql.anilist.co', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+                body: JSON.stringify({ query, variables: { s: searchTitle } }),
+                signal: AbortSignal.timeout(6000)
+            });
+            if (!res.ok) continue;
+
+            const resJson = await res.json();
+            for (const entry of resJson?.data?.Page?.media || []) {
+                const entryTitles = [entry.title?.romaji, entry.title?.english, entry.title?.native].filter(Boolean).map(t => t.toLowerCase());
+                const sl = searchTitle.toLowerCase();
+                let score = 0;
+
+                if (entryTitles.some(t => t === sl)) score += 5;
+                else if (entryTitles.some(t => t.includes(sl) || sl.includes(t))) score += 3;
+                else if (entryTitles.some(t => {
+                    const w = sl.split(/\s+/).filter(x => x.length > 3);
+                    return w.length > 0 && w.every(x => t.includes(x));
+                })) score += 2;
+                else continue;
+
+                if (year && entry.startDate?.year) {
+                    const diff = Math.abs(entry.startDate.year - year);
+                    if (diff === 0) score += 3;
+                    else if (diff === 1) score += 1;
+                    else if (diff > 2) score -= 3;
+                }
+
+                if (mediaType === 'tv' && ['TV', 'TV_SHORT', 'ONA', 'OVA'].includes(entry.format)) score += 1;
+                if (mediaType === 'movie' && entry.format === 'MOVIE') score += 1;
+
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestId = entry.id;
+                }
+            }
+            if (bestScore >= 8) break;
+        } catch { }
+    }
+
+    if (bestId) cacheSet(anilistCache, key, bestId, 600000);
+    return bestId;
+}
+
+export async function createStreamArgs(source, sdk, id, s, e, clientIP = null) {
+    const audio = /dub$/.test(source.key) ? 'dub' : 'sub';
+    return {
+        id,
+        s,
+        e,
+        clientIP,
+        absoluteBase: '/',
+        audio,
+        sdk,
+        config: source,
+        tmdbApiKey: resolveTmdbKey(null, sdk),
+    };
+}
+
+export function formatStreamResult(streams, defaultHeaders = {}, extra = {}) {
+    if (!streams) return null;
+    const list = Array.isArray(streams) ? streams.filter(Boolean) : [streams];
+    if (!list.length) return null;
+
+    const allUrls = list.map(item => {
+        const itemUrl = item.url || item.file || item.stream || item.src;
+        if (!itemUrl) return null;
+        return {
+            url: itemUrl,
+            server: item.server || item.label || item.name || 'Server',
+            quality: item.quality || 'Auto',
+            type: item.type || (itemUrl.includes('.m3u8') ? 'hls' : (itemUrl.includes('.mpd') ? 'dash' : 'mp4')),
+            headers: item.headers || defaultHeaders,
+            ...(item.subtitles ? { subtitles: item.subtitles } : {}),
+            ...(item.skipProxy !== undefined ? { skipProxy: item.skipProxy } : {}),
+            ...(item.audio ? { audio: item.audio } : {}),
+            ...(item.label ? { label: item.label } : {}),
+        };
+    }).filter(Boolean);
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        server: allUrls[0].server,
+        quality: allUrls[0].quality,
+        type: allUrls[0].type,
+        allUrls,
+        ...extra,
+    };
+}
+
+export async function scrapeVidcoreFamily({ id, s, e, baseUrl, apiName, serverLabel }) {
+    const isTv = Boolean(s && e);
+    const targetUrl = isTv
+        ? `${baseUrl}/tv/${id}/${s}/${e}/`
+        : `${baseUrl}/movie/${id}`;
+
+    const ua = getUA();
+    const baseHeaders = {
+        'User-Agent': ua,
+        Referer: `${baseUrl}/`,
+        'X-Requested-With': 'XMLHttpRequest',
+    };
+
+    try {
+        const pageRes = await fetch(targetUrl, {
+            headers: { 'User-Agent': ua },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!pageRes.ok) return null;
+        const html = await pageRes.text();
+
+        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/);
+        if (!match || !match[1]) return null;
+        const enToken = match[1];
+
+        const s1Res = await fetch(`https://enc-dec.app/api/enc-${apiName}?text=${encodeURIComponent(enToken)}&stage=1`, {
+            signal: AbortSignal.timeout(8000),
+        });
+        const s1Data = await s1Res.json();
+        if (s1Data?.status !== 200 || !s1Data?.result?.stage1) return null;
+
+        const token1 = s1Data.result.token;
+        const stage1Url = s1Data.result.stage1;
+
+        const post1Res = await fetch(stage1Url, {
+            method: 'POST',
+            headers: { ...baseHeaders, 'X-CSRF-Token': token1 },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!post1Res.ok) return null;
+        const stage1Text = await post1Res.text();
+
+        const s2Res = await fetch(`https://enc-dec.app/api/enc-${apiName}?text=${encodeURIComponent(stage1Text)}&stage=2`, {
+            signal: AbortSignal.timeout(8000),
+        });
+        const s2Data = await s2Res.json();
+        if (s2Data?.status !== 200 || !s2Data?.result?.servers) return null;
+
+        const { servers: serversUrl, stream: streamBaseUrl, token: token2 } = s2Data.result;
+        const currentHeaders = { ...baseHeaders, 'X-CSRF-Token': token2 };
+
+        const serversRes = await fetch(serversUrl, {
+            method: 'POST',
+            headers: currentHeaders,
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!serversRes.ok) return null;
+        const serversEncrypted = await serversRes.text();
+
+        const decServersRes = await fetch(`https://enc-dec.app/api/dec-${apiName}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ text: serversEncrypted }),
+            signal: AbortSignal.timeout(8000),
+        });
+        const decServersData = await decServersRes.json();
+        if (decServersData?.status !== 200 || !Array.isArray(decServersData.result)) return null;
+
+        const allUrls = [];
+
+        for (const server of decServersData.result) {
+            if (!server?.data) continue;
+            try {
+                const streamUrl = `${streamBaseUrl}/${server.data}`;
+                const streamEncRes = await fetch(streamUrl, {
+                    method: 'POST',
+                    headers: currentHeaders,
+                    signal: AbortSignal.timeout(8000),
+                });
+                if (!streamEncRes.ok) continue;
+                const streamEncText = await streamEncRes.text();
+
+                const decStreamRes = await fetch(`https://enc-dec.app/api/dec-${apiName}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ text: streamEncText }),
+                    signal: AbortSignal.timeout(8000),
+                });
+                const decStreamData = await decStreamRes.json();
+                if (decStreamData?.status !== 200 || !decStreamData.result) continue;
+
+                const streamResult = decStreamData.result;
+                const resultUrl = typeof streamResult === 'string' ? streamResult : streamResult?.url || streamResult?.file;
+
+                if (typeof resultUrl === 'string' && resultUrl.startsWith('http')) {
+                    allUrls.push({
+                        url: resultUrl,
+                        server: `${serverLabel} - ${server.name || server.title || 'Server'}`,
+                        label: server.name || server.title || serverLabel,
+                        type: resultUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                        headers: {
+                            'User-Agent': ua,
+                            Referer: `${baseUrl}/`,
+                        },
+                    });
+                }
+            } catch { }
+        }
+
+        return formatStreamResult(allUrls);
+    } catch {
+        return null;
+    }
+}