@vyla-entertainment/sdk 1.5.0 → 1.8.0

package/src/sources/cinejoy.js

@@ -0,0 +1,210 @@
+import crypto from "crypto";
+
+export const ID = "cinejoy";
+export const DOMAIN = "https://cinejoy.to";
+export const API_DOMAIN = "https://api.shegu.st";
+export const ENC_DEC_API = "https://enc-dec.app/api";
+export const RETURN_ALL_URLS = true;
+
+const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36";
+
+function countLeadingZeroBits(buffer) {
+    let count = 0;
+    for (const value of buffer) {
+        if (value === 0) {
+            count += 8;
+            continue;
+        }
+        count += 8 - value.toString(2).length;
+        break;
+    }
+    return count;
+}
+
+function solveChallenge(data) {
+    const saltStr = `pow2-salt|${data.s}|${data.b}`;
+    const salt = crypto.createHash("sha256").update(saltStr).digest();
+    const n = data.n;
+    const r = data.r;
+    const p = data.p;
+    const d = data.d;
+    const b = data.b;
+    const s = data.s;
+
+    for (let counter = 0; counter < 1000000; counter++) {
+        const payload = `pow2|${b}|${s}|${counter}`;
+        const result = crypto.scryptSync(payload, salt, 32, {
+            N: n,
+            r: r,
+            p: p,
+            maxmem: 128 * n * r * 2
+        });
+
+        if (countLeadingZeroBits(result) >= d) {
+            const solved = { ...data, c: counter };
+            return Buffer.from(JSON.stringify(solved)).toString("base64");
+        }
+    }
+    throw new Error("Challenge solve failed");
+}
+
+async function getTmdbMetadata(tmdbId, isTv) {
+    const apiKey = process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? "tv" : "movie";
+    try {
+        const url = `https://api.themoviedb.org/3/${type}/${tmdbId}?api_key=${apiKey}&append_to_response=external_ids`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const year = isTv ? (data.first_air_date ? data.first_air_date.split("-")[0] : "") : (data.release_date ? data.release_date.split("-")[0] : "");
+        const imdbId = data.external_ids?.imdb_id || "";
+        return { title, year, imdbId };
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, clientIP }) {
+    try {
+        const isTv = s && e && s !== "null" && e !== "null";
+        const meta = await getTmdbMetadata(id, isTv);
+        if (!meta) return null;
+
+        let servers = [];
+        try {
+            const serverRes = await fetch(`${API_DOMAIN}/servers`, {
+                headers: {
+                    "Origin": DOMAIN,
+                    "Referer": DOMAIN + "/",
+                    "User-Agent": UA
+                },
+                signal: AbortSignal.timeout(15000)
+            });
+            if (serverRes.ok) {
+                const data = await serverRes.json();
+                servers = data.servers || [];
+            }
+        } catch (err) { }
+
+        const activeServers = servers
+            .filter(srv => srv.status === "ok" && srv.name)
+            .map(srv => srv.name);
+
+        if (activeServers.length === 0) return null;
+
+        const allUrls = [];
+
+        for (const serverName of activeServers) {
+            try {
+                const queryParts = [
+                    `title=${encodeURIComponent(meta.title)}`,
+                    `type=${isTv ? "series" : "movie"}`,
+                    `year=${meta.year}`,
+                    `imdb=${meta.imdbId}`,
+                    `tmdb=${id}`,
+                    `server=${serverName}`
+                ];
+                if (isTv) {
+                    queryParts.push(`season=${s}`, `episode=${e}`);
+                }
+
+                const plainUrl = `${API_DOMAIN}/?${queryParts.join("&")}`;
+
+                const encRes = await fetch(`${ENC_DEC_API}/enc-cinejoy?url=${encodeURIComponent(plainUrl)}`, {
+                    headers: { "User-Agent": UA },
+                    signal: AbortSignal.timeout(15000)
+                });
+                if (!encRes.ok) continue;
+                const encData = await encRes.json();
+                if (encData.status !== 200) continue;
+
+                const rid = encData.result;
+
+                const challengeRes = await fetch(`${API_DOMAIN}/challenge?rid=${rid}`, {
+                    headers: {
+                        "Origin": DOMAIN,
+                        "Referer": DOMAIN + "/",
+                        "User-Agent": UA
+                    },
+                    signal: AbortSignal.timeout(30000)
+                });
+                if (!challengeRes.ok) continue;
+
+                const challengeData = await challengeRes.json();
+
+                const solved = solveChallenge(challengeData);
+
+                const streamRes = await fetch(`${API_DOMAIN}/${rid}`, {
+                    headers: {
+                        "Origin": DOMAIN,
+                        "Referer": DOMAIN + "/",
+                        "User-Agent": UA,
+                        "X-At": solved
+                    },
+                    signal: AbortSignal.timeout(30000)
+                });
+
+                if (!streamRes.ok) continue;
+
+                const encryptedText = await streamRes.text();
+
+                const decRes = await fetch(`${ENC_DEC_API}/dec-cinejoy`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "User-Agent": UA
+                    },
+                    body: JSON.stringify({ text: encryptedText }),
+                    signal: AbortSignal.timeout(15000)
+                });
+                if (!decRes.ok) continue;
+                const decData = await decRes.json();
+                if (decData.status !== 200) continue;
+
+                let decryptedText = decData.result;
+
+                if (!decryptedText) continue;
+
+                if (typeof decryptedText === "string") {
+                    try {
+                        decryptedText = JSON.parse(decryptedText);
+                    } catch (e) { }
+                }
+
+                let streamUrl = "";
+                if (decryptedText && typeof decryptedText === "object") {
+                    if (decryptedText.stream && decryptedText.stream[0]) {
+                        streamUrl = decryptedText.stream[0].playlist || decryptedText.stream[0].url || "";
+                    } else {
+                        streamUrl = decryptedText.url || decryptedText.playlist || decryptedText.file || "";
+                    }
+                } else if (typeof decryptedText === "string") {
+                    streamUrl = decryptedText.trim();
+                }
+
+                if (streamUrl.startsWith("http")) {
+                    allUrls.push({
+                        url: streamUrl,
+                        headers: {
+                            "User-Agent": UA,
+                            "Referer": DOMAIN + "/",
+                            "Origin": DOMAIN
+                        },
+                        server: serverName,
+                        quality: "Auto",
+                        type: "hls",
+                        skipVerify: true,
+                        skipProxy: true
+                    });
+                }
+            } catch (err) { }
+        }
+
+        if (allUrls.length > 0) {
+            return { ...allUrls[0], allUrls };
+        }
+    } catch (err) { }
+    return null;
+}

package/src/sources/flaxmovies.js

@@ -1,14 +1,26 @@
 import { fetchJson } from '../utils/helpers.js';
 
-const API_BASE = 'https://itjiocunahckqxcnzpoy.supabase.co/functions/v1';
-const APIKEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Iml0amlvY3VuYWhja3F4Y256cG95Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzczMzM1MjQsImV4cCI6MjA5MjkwOTUyNH0.9x9ykdHAzrv_GSvnawPeQaOxQeh3sZg0QAh4u9VOF4M';
-const HEADERS = { 'apikey': APIKEY, 'authorization': `Bearer ${APIKEY}`, 'content-type': 'application/json', 'origin': 'https://flaxmovies.xyz', 'referer': 'https://flaxmovies.xyz/' };
-
 export async function getStream({ id, s, e }) {
     try {
-        const isMovie = !s;
-        const data = await fetchJson(isMovie ? `${API_BASE}/get-movie` : `${API_BASE}/get-tv`, { method: 'POST', headers: HEADERS, body: JSON.stringify(isMovie ? { id: String(id) } : { id: String(id), season: Number(s), episode: Number(e) }), signal: AbortSignal.timeout(15000) });
-        if (!data?.signed_url) return null;
-        return { allUrls: [{ url: data.signed_url, headers: { 'Referer': 'https://flaxmovies.xyz/', 'Origin': 'https://flaxmovies.xyz' } }] };
-    } catch { return null; }
+        const url = s && e
+            ? `https://sparkling-mode-a1ed.fillatame.workers.dev/?tmdb_id=${id}&season=${s}&episode=${e}`
+            : `https://sparkling-mode-a1ed.fillatame.workers.dev/?tmdb_id=${id}`;
+        const data = await fetchJson(url, { signal: AbortSignal.timeout(15000) });
+        if (!data || !Array.isArray(data.streams)) return null;
+        const allUrls = [];
+        for (const stream of data.streams) {
+            const streamUrl = stream.url || stream.link;
+            if (!streamUrl) continue;
+            const isHls = stream.format === 'HLS' || stream.isM3U8 === true || streamUrl.includes('m3u8');
+            allUrls.push({
+                url: streamUrl,
+                server: stream.provider || 'FlaxMovies',
+                quality: stream.resolution || 'Auto',
+                type: isHls ? 'hls' : 'mp4'
+            });
+        }
+        return allUrls.length ? { allUrls } : null;
+    } catch {
+        return null;
+    }
 }

package/src/sources/fsonic.js

@@ -4,10 +4,10 @@ const BASE_URL = 'https://www.fsonic.net';
 const FSHARE_BASE = 'https://fsharetv.co';
 const HEADERS = { 'User-Agent': USER_AGENT, 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.9' };
 
-export async function getStream({ id, s }) {
+export async function getStream({ id, s, tmdbApiKey }) {
     if (s != null) return null;
     try {
-        const info = await getTmdbInfo(id, 'movie');
+        const info = await getTmdbInfo(tmdbApiKey, id, 'movie');
         if (!info?.titles?.length) return null;
         let watchSlug = null;
         for (const title of info.titles) {

package/src/sources/fsonline.js

@@ -4,10 +4,10 @@ const ORIGIN = 'https://www3.fsonline.app';
 const AJAX_URL = `${ORIGIN}/wp-admin/admin-ajax.php`;
 const HEADERS = { 'User-Agent': USER_AGENT, 'Origin': ORIGIN, 'Referer': `${ORIGIN}/` };
 
-export async function getStream({ id, s, e }) {
+export async function getStream({ id, s, e, tmdbApiKey }) {
     try {
         const isTv = s != null && e != null;
-        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+        const info = await getTmdbInfo(tmdbApiKey, id, isTv ? 'tv' : 'movie');
         if (!info?.titles?.length) return null;
         const searchHtml = await fetchText(`${ORIGIN}/?s=${encodeURIComponent(info.titles[0] + (info.year ? ' ' + info.year : ''))}`, { headers: HEADERS });
         const typeFolder = isTv ? 'seriale' : 'film';

package/src/sources/lmscript.js

@@ -0,0 +1,43 @@
+import { getTmdbInfo } from '../utils/helpers.js';
+
+export async function getStream(args) {
+    const { id, s, e, tmdbApiKey } = args;
+    const type = (s != null && e != null) ? 'tv' : 'movie';
+
+    try {
+        const tmdbInfo = await getTmdbInfo(tmdbApiKey, id, type, s);
+        const name = tmdbInfo.titles[0] || '';
+        if (!name) return null;
+
+        if (type === 'tv') {
+            return null;
+        } else {
+            const url = `https://lmscript.xyz/v1/movies?filters[q]=${encodeURIComponent(name)}&expand=streams`;
+            const response = await fetch(url);
+            const data = await response.json();
+
+            const movie = data.items?.find(item => `${item.tmdb_prefix}` === `${id}` || `${item.tmdb_id}` === `${id}`);
+            if (!movie) return null;
+
+            const streams = movie.streams || {};
+            const SOURCE_ORDER = ["1080p", "720p", "480p", "360p"];
+            const sortedStreams = Object.keys(streams).sort((a, b) => SOURCE_ORDER.indexOf(a) - SOURCE_ORDER.indexOf(b));
+
+            if (!sortedStreams.length) return null;
+
+            const allUrls = sortedStreams.map(quality => {
+                const streamUrl = streams[quality];
+                return {
+                    url: streamUrl,
+                    quality,
+                    type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                    headers: {}
+                };
+            });
+
+            return { allUrls };
+        }
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/videasy.js

@@ -1,28 +1,24 @@
 import { getTmdbInfo, fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
 
-const WINGS_BASE = "https://api.wingsdatabase.com";
+const SPEEDRACE_BASE = "https://api.speedracelight.com";
 const HEADERS = { "Accept": "*/*", "Origin": "https://player.videasy.to", "Referer": "https://player.videasy.to/", "User-Agent": USER_AGENT };
 const SERVERS = [
-    { id: 'jett', name: 'Jett' },
     { id: 'cdn', name: 'Yoru' },
-    { id: 'tejo', name: 'Tejo' },
-    { id: 'neon2', name: 'Neon' },
-    { id: 'ym', name: 'Sage' },
-    { id: 'downloader2', name: 'Cypher' },
     { id: 'm4uhd', name: 'Breach' },
+    { id: 'vsrc', name: 'Neon' },
     { id: 'hdmovie', name: 'Vyse' },
     { id: 'meine', name: 'Killjoy' },
     { id: 'lamovie', name: 'Omen' },
     { id: 'superflix', name: 'Raze' }
 ];
 
-export async function getStream({ id, s, e, server }) {
+export async function getStream({ id, s, e, server, tmdbApiKey }) {
     try {
         const isTv = s != null && e != null;
-        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+        const info = await getTmdbInfo(tmdbApiKey, id, isTv ? 'tv' : 'movie');
         if (!info?.titles?.length) return null;
 
-        const seedData = await fetchJson(`${WINGS_BASE}/seed?mediaId=${id}`, { headers: HEADERS, signal: AbortSignal.timeout(5000) });
+        const seedData = await fetchJson(`${SPEEDRACE_BASE}/seed?mediaId=${id}`, { headers: HEADERS, signal: AbortSignal.timeout(5000) });
         const seed = seedData?.seed;
         if (!seed) return null;
 
@@ -36,9 +32,7 @@ export async function getStream({ id, s, e, server }) {
         }
 
         const settled = await Promise.allSettled(targets.map(async srv => {
-            if (srv.id === 'cdn' && isTv) throw new Error();
-
-            let url = `${WINGS_BASE}/${srv.id}/sources-with-title?title=${encTitle}&mediaType=${isTv ? 'tv' : 'movie'}&year=${info.year || ''}&tmdbId=${id}&imdbId=${info.imdbId || "tt0000000"}&enc=2&seed=${seed}`;
+            let url = `${SPEEDRACE_BASE}/${srv.id}/sources-with-title?title=${encTitle}&mediaType=${isTv ? 'tv' : 'movie'}&year=${info.year || ''}&tmdbId=${id}&imdbId=${info.imdbId || "tt0000000"}&enc=2&seed=${seed}`;
             if (isTv) url += `&episodeId=${e}&seasonId=${s}`;
 
             const encText = await fetchText(url, { headers: HEADERS, signal: AbortSignal.timeout(10000) });

package/src/sources/vidvault.js

@@ -0,0 +1,114 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = "https://vidvault.ru";
+const HEADERS = {
+    "Referer": `${BASE_URL}/`,
+    "Origin": BASE_URL,
+    "User-Agent": USER_AGENT,
+};
+
+async function getToken() {
+    const res = await fetch(`${BASE_URL}/api/get-token`, {
+        method: "GET",
+        headers: HEADERS
+    });
+    const data = await res.json();
+    return data.t;
+}
+
+function getCaptionType(url) {
+    return url.toLowerCase().includes(".vtt") ? "vtt" : "srt";
+}
+
+export async function getStream(args) {
+    const { id, s, e } = args;
+    const type = (s != null && e != null) ? "tv" : "movie";
+
+    try {
+        const token = await getToken();
+
+        const payload = { type, tmdbId: String(id) };
+        if (type === "tv") {
+            payload.season = String(s);
+            payload.episode = String(e);
+        }
+
+        const res = await fetch(`${BASE_URL}/api/download-proxy`, {
+            method: "POST",
+            headers: {
+                ...HEADERS,
+                "Content-Type": "application/json",
+                "x-request-token": token
+            },
+            body: JSON.stringify(payload)
+        });
+        const data = await res.json();
+
+        const allUrls = [];
+        const subtitles = [];
+
+        const mp4 = data?.mp4Data;
+        if (mp4) {
+            const country = mp4.country || "";
+            const lanName = mp4.lanName || "";
+            const detailPath = mp4.detailPath || "";
+
+            const downloads = mp4.downloadInfo?.data?.downloads || [];
+            for (const d of downloads) {
+                if (!d?.url) continue;
+                allUrls.push({
+                    quality: `${d.resolution}p ${detailPath} ${country} ${lanName}`.trim(),
+                    url: d.url,
+                    type: "mp4",
+                    headers: HEADERS
+                });
+            }
+
+            const srtCaptions = mp4.downloadInfo?.data?.captions || [];
+            for (const c of srtCaptions) {
+                if (!c?.url) continue;
+                subtitles.push({
+                    label: c.lanName || c.lan || "Unknown",
+                    type: getCaptionType(c.url),
+                    language: c.lan || "",
+                    url: c.url
+                });
+            }
+        }
+
+        const mkvFiles = data?.mkvData?.files || [];
+        for (const f of mkvFiles) {
+            if (!f?.url) continue;
+            allUrls.push({
+                quality: `MKV ${f.size || ""}`.trim(),
+                url: f.url,
+                type: "mp4",
+                headers: HEADERS
+            });
+        }
+
+        const mkvV2 = data?.mkvV2Data;
+        if (mkvV2?.url) {
+            allUrls.push({
+                quality: `${mkvV2.quality || ""} ${mkvV2.language || ""} ${mkvV2.country || ""} (${mkvV2.size || ""})`.trim(),
+                url: mkvV2.url,
+                type: "mp4",
+                headers: HEADERS
+            });
+        }
+
+        const mkvV3 = data?.mkvV3Data;
+        if (mkvV3?.url) {
+            allUrls.push({
+                quality: `${mkvV3.quality || ""} ${mkvV3.language || ""} ${mkvV3.country || ""} (${mkvV3.size || ""})`.trim(),
+                url: mkvV3.url,
+                type: "mp4",
+                headers: HEADERS
+            });
+        }
+
+        return allUrls.length ? { allUrls, subtitles } : null;
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/vidzee.js

@@ -1,70 +1,47 @@
-import { webcrypto } from 'node:crypto';
+// i can't fix this, i'll wait for someone else to fix this lol
+
+import crypto from 'node:crypto';
 import { fetchJson, USER_AGENT } from '../utils/helpers.js';
 
-const PLAYER_URL = 'https://player.vidzee.wtf';
 const CORE_URL = 'https://core.vidzee.wtf';
+const PLAYER_URL = 'https://player.vidzee.wtf';
+const KEY = 'c4a8f1d7e2b9a6c3d0f5e8a1b7c4d9e2';
 
-let cachedKey = null, cachedKeyTs = 0;
-
-async function getDecKey(headers) {
-    const now = Date.now();
-    if (cachedKey && now - cachedKeyTs < 300000) return cachedKey;
-
-    const res = await fetch(`${CORE_URL}/api-key`, {
-        headers,
-        signal: AbortSignal.timeout(7000)
-    });
-    if (!res.ok) throw new Error(`API key fetch failed: ${res.status}`);
-
-    const e = await res.text();
-    const t = Buffer.from(e.replace(/\s+/g, ''), 'base64');
-
-    const s = new Uint8Array(t.length - 28 + 16);
-    s.set(t.subarray(28), 0);
-    s.set(t.subarray(12, 28), t.length - 28);
-
-    const keyMat = await webcrypto.subtle.digest('SHA-256', new TextEncoder().encode('c4a8f1d7e2b9a6c3d0f5e8a1b7c4d9e2'));
-    const key = await webcrypto.subtle.importKey('raw', keyMat, { name: 'AES-GCM' }, false, ['decrypt']);
+function decryptAes(encryptedBase64) {
+    const keyBuf = Buffer.from(KEY, 'utf8');
+    const ciphertext = Buffer.from(encryptedBase64, 'base64');
 
     try {
-        const decrypted = await webcrypto.subtle.decrypt({
-            name: 'AES-GCM',
-            iv: t.subarray(0, 12),
-            tagLength: 128
-        }, key, s);
-
-        cachedKey = new TextDecoder().decode(decrypted);
-        cachedKeyTs = now;
-        return cachedKey;
-    } catch (err) {
-        throw new Error('Failed to decrypt Vidzee master key');
-    }
-}
+        const decipher = crypto.createDecipheriv('aes-256-ecb', keyBuf, null);
+        decipher.setAutoPadding(true);
+        let dec = decipher.update(ciphertext);
+        dec = Buffer.concat([dec, decipher.final()]);
+        const text = dec.toString('utf8');
+        if (text.startsWith('http') || text.includes('{')) return text;
+    } catch { }
 
-function decrypt(enc, key) {
     try {
-        const dec = Buffer.from(enc, 'base64').toString('utf8');
-        const sep = dec.indexOf(':');
-        if (sep === -1) return '';
+        const iv = Buffer.alloc(16, 0);
+        const decipher = crypto.createDecipheriv('aes-256-cbc', keyBuf, iv);
+        decipher.setAutoPadding(true);
+        let dec = decipher.update(ciphertext);
+        dec = Buffer.concat([dec, decipher.final()]);
+        const text = dec.toString('utf8');
+        if (text.startsWith('http') || text.includes('{')) return text;
+    } catch { }
 
-        const ivBase64 = dec.slice(0, sep);
-        const ciphertext = dec.slice(sep + 1);
-        const keyPadded = key.padEnd(32, '\0');
-
-        const decrypted = CryptoJS.AES.decrypt(
-            ciphertext,
-            CryptoJS.enc.Utf8.parse(keyPadded),
-            {
-                iv: CryptoJS.enc.Base64.parse(ivBase64),
-                mode: CryptoJS.mode.CBC,
-                padding: CryptoJS.pad.Pkcs7
-            }
-        );
-
-        return decrypted.toString(CryptoJS.enc.Utf8) || '';
-    } catch (err) {
-        return '';
-    }
+    try {
+        const iv = ciphertext.subarray(0, 16);
+        const data = ciphertext.subarray(16);
+        const decipher = crypto.createDecipheriv('aes-256-cbc', keyBuf, iv);
+        decipher.setAutoPadding(true);
+        let dec = decipher.update(data);
+        dec = Buffer.concat([dec, decipher.final()]);
+        const text = dec.toString('utf8');
+        if (text.startsWith('http') || text.includes('{')) return text;
+    } catch { }
+
+    return null;
 }
 
 export async function getStream({ id, s, e, clientIP }) {
@@ -77,44 +54,53 @@ export async function getStream({ id, s, e, clientIP }) {
     };
 
     try {
-        const decKey = await getDecKey(headers);
-
-        const serversToTry = [3, 0, 1, 2, 4, 5, 6, 8];
+        const isTv = s != null && e != null;
+        const servers = ['tik', 'ipcloud', 'v6:Hindi'];
+        const results = [];
 
-        for (const sr of serversToTry) {
+        for (const sr of servers) {
             try {
-                const url = `${PLAYER_URL}/api/server?id=${id}&sr=${sr}${s ? `&ss=${s}&ep=${e || 1}` : ''}`;
-                const data = await fetchJson(url, { headers, signal: AbortSignal.timeout(5000) });
-
-                if (data?.url?.length) {
-                    for (const entry of data.url) {
-                        if (!entry.link) continue;
-
-                        const decrypted = decrypt(entry.link, decKey);
-                        if (decrypted?.startsWith('http')) {
+                const url = isTv
+                    ? `${CORE_URL}/streams/tv/${id}/${s}/${e}?s=${encodeURIComponent(sr)}&e=${e}`
+                    : `${CORE_URL}/streams/movie/${id}?s=${encodeURIComponent(sr)}&e=1`;
+
+                const data = await fetchJson(url, { headers, signal: AbortSignal.timeout(6000) });
+
+                if (data && data.c) {
+                    const decryptedText = decryptAes(data.c);
+                    if (decryptedText) {
+                        let streamUrl = decryptedText;
+                        let extraHeaders = {};
+
+                        if (decryptedText.startsWith('{')) {
+                            try {
+                                const parsed = JSON.parse(decryptedText);
+                                streamUrl = parsed.url || parsed.link || parsed.file;
+                                if (parsed.headers) extraHeaders = parsed.headers;
+                            } catch { }
+                        }
 
-                            return {
-                                allUrls: [
-                                    {
-                                        url: decrypted,
-                                        skipHlsCheck: true,
-                                        headers: {
-                                            'User-Agent': USER_AGENT,
-                                            'Referer': PLAYER_URL,
-                                            'Origin': PLAYER_URL
-                                        }
-                                    }
-                                ]
-                            };
+                        if (streamUrl && streamUrl.startsWith('http')) {
+                            results.push({
+                                url: streamUrl,
+                                server: `VidZee - ${sr}`,
+                                skipHlsCheck: true,
+                                headers: {
+                                    'User-Agent': USER_AGENT,
+                                    'Referer': PLAYER_URL,
+                                    'Origin': PLAYER_URL,
+                                    ...extraHeaders
+                                }
+                            });
                         }
                     }
                 }
             } catch (err) {
-                continue;
             }
         }
-        return null;
-    } catch (err) {
+
+        return results.length ? { allUrls: results } : null;
+    } catch {
         return null;
     }
 }