Upload turbo.js

turbo.js

@@ -1,14 +1,11 @@
 /**
- * Turbo (obrut.show) stream extractor
- * Flow: embed URL → fetch HTML → parse Player() base64 → extract entries via regex
+ * Turbo (kinojump.com → obrut.show) stream extractor using Puppeteer
+ * kinojump.com and obrut.show use Cloudflare — data only available after JS execution
  */
 const { getBrowser } = require('./alloha');
 const https = require('https');
 const http = require('http');
 
-const KINOJUMP_BASE = 'https://kinojump.com';
-
-// ── HTTP helper ───────────────────────────────────────────────────────────────
 function fetchRaw(reqUrl, headers) {
     return new Promise((resolve, reject) => {
         let u; try { u = new URL(reqUrl); } catch(e) { return reject(e); }
@@ -20,33 +17,23 @@ function fetchRaw(reqUrl, headers) {
             if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
                 let loc = res.headers.location.startsWith('http')
                     ? res.headers.location
-                    : new URL(reqUrl).origin + res.headers.location;
-                // Don't follow redirect to web.kinojump.com — stay on kinojump.com
+                    : u.origin + res.headers.location;
                 loc = loc.replace('web.kinojump.com', 'kinojump.com');
+                res.resume();
                 return fetchRaw(loc, headers).then(resolve).catch(reject);
             }
-            let d = ''; 
-            // Handle gzip/deflate (Railway proxy may add it)
-            const encoding = res.headers['content-encoding'];
-            let stream = res;
-            if (encoding === 'gzip' || encoding === 'deflate') {
-                const zlib = require('zlib');
-                stream = encoding === 'gzip' ? res.pipe(zlib.createGunzip()) : res.pipe(zlib.createInflate());
-            }
-            stream.setEncoding('utf8');
-            stream.on('data', c => d += c);
-            stream.on('end', () => resolve(d));
-            stream.on('error', reject);
+            let d = ''; res.setEncoding('utf8');
+            res.on('data', c => d += c);
+            res.on('end', () => resolve(d));
         });
         req.on('error', reject);
-        req.setTimeout(15000, () => { req.destroy(); reject(new Error('timeout')); });
+        req.setTimeout(12000, () => { req.destroy(); reject(new Error('timeout')); });
         req.end();
     });
 }
 
 // ── Search kinojump ───────────────────────────────────────────────────────────
 async function turboSearch(query) {
-    // Search on web.kinojump.com (kinojump.com redirects to web. for search)
     const searchUrl = 'https://web.kinojump.com/index.php?do=search&subaction=search&story=' + encodeURIComponent(query);
     const html = await fetchRaw(searchUrl, {
         'user-agent': 'Mozilla/5.0 Chrome/120',
@@ -57,7 +44,6 @@ async function turboSearch(query) {
     let m;
     while ((m = re.exec(html)) !== null) {
         if (!results.find(r => r.id === m[2])) {
-            // Always use kinojump.com (not web.) — web. has no player
             const url = m[1].replace('web.kinojump.com', 'kinojump.com');
             results.push({ url, id: m[2], slug: m[3] });
         }
@@ -65,191 +51,89 @@ async function turboSearch(query) {
     return results.slice(0, 10);
 }
 
-// ── Get kinojump page HTML — try plain HTTP first, then Puppeteer ────────────
+// ── Get kinojump page HTML via Puppeteer (bypasses Cloudflare) ───────────────
 async function getKinojumpHtml(pageUrl, browser) {
     const normalizedUrl = pageUrl.replace('web.kinojump.com', 'kinojump.com');
-    // Try plain HTTP first — with PHPSESSID cookie to bypass Cloudflare Rocket Loader
-    // Retry multiple times since kinojump may load-balance between servers
-    for (let attempt = 0; attempt < 5; attempt++) {
+    
+    // Try plain HTTP first with retry
+    for (let attempt = 0; attempt < 3; attempt++) {
         try {
             const html = await fetchRaw(normalizedUrl, {
                 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36',
-                'referer': KINOJUMP_BASE + '/',
+                'referer': 'https://kinojump.com/',
                 'accept': 'text/html',
-                'accept-language': 'ru-RU,ru;q=0.9',
-                'accept-encoding': 'identity',
-                'cookie': 'PHPSESSID=a1b2c3d4e5f6; dle_user_id=0; dle_password=0'
+                'cookie': 'PHPSESSID=a1b2c3d4e5f6'
             });
-            if (html.includes('obrut')) { 
-                const refs = html.match(/[a-z0-9]*obrut[^\s"'<>]{0,100}/g);
-                console.log('[turbo] got HTML via plain HTTP');
-                console.log('[turbo] obrut refs:', refs ? refs.slice(0,3) : 'none');
-                const hasEmbed = html.includes('obrut.show/embed/');
-                if (hasEmbed) return html;
-                if (attempt < 4) {
-                    console.log('[turbo] no embed URL, retrying... (' + (attempt+1) + '/5)');
-                    await new Promise(r => setTimeout(r, 500));
-                    continue;
-                }
-                console.log('[turbo] obrut found but no embed URL - trying Puppeteer');
+            if (html.includes('obrut.show/embed/')) {
+                console.log('[turbo] got embed URL via plain HTTP');
+                return html;
             }
-            console.log('[turbo] plain HTTP no obrut, len:', html.length, 'has helper:', html.includes('s1obrut'), 'has rocket:', html.includes('rocket-loader'));
-            const playerIdx = html.indexOf('pmovie__player');
-            if (playerIdx > 0) console.log('[turbo] player area:', html.substring(playerIdx, playerIdx + 500));
-        } catch(e) { console.log('[turbo] plain HTTP failed:', e.message); }
-        break;
+            if (attempt < 2) {
+                console.log('[turbo] no embed URL, retrying... (' + (attempt+1) + '/3)');
+                await new Promise(r => setTimeout(r, 1000));
+            }
+        } catch(e) {
+            console.log('[turbo] plain HTTP failed:', e.message);
+        }
     }
 
-    // Fallback: Puppeteer — intercept network requests to catch obrut embed URL
+    // Fallback: Puppeteer
     console.log('[turbo] using Puppeteer for kinojump page');
     const page = await browser.newPage();
     try {
         await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36');
         await page.setExtraHTTPHeaders({ 'Accept-Language': 'ru-RU,ru;q=0.9' });
-        await page.setCookie({ name: 'PHPSESSID', value: 'a1b2c3d4e5f6', domain: 'kinojump.com' });
+        
+        // Disable automation detection
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            window.chrome = { runtime: {} };
+        });
 
         let obrutEmbedUrl = null;
-        let generalJsContent = null;
-
         await page.setRequestInterception(true);
         page.on('request', req => {
             const u = req.url();
             if (u.includes('obrut.show/embed/') && !obrutEmbedUrl) {
                 obrutEmbedUrl = u;
-                console.log('[turbo] intercepted obrut embed request:', u.substring(0, 120));
+                console.log('[turbo] intercepted obrut embed:', u.substring(0, 100));
+            }
+            // Block images/fonts to speed up
+            const resourceType = req.resourceType();
+            if (['image', 'stylesheet', 'font', 'media'].includes(resourceType)) {
+                req.abort();
+            } else {
+                req.continue();
             }
-            req.continue();
-        });
-        page.on('response', async res => {
-            try {
-                const u = res.url();
-                if (u.includes('general') && u.includes('kinojump') && !generalJsContent) {
-                    generalJsContent = await res.text().catch(() => null);
-                    if (generalJsContent) console.log('[turbo] captured general.js len:', generalJsContent.length);
-                }
-            } catch(e) {}
-        });
-
-        await page.goto(normalizedUrl, { waitUntil: 'domcontentloaded', timeout: 20000 });
-        await new Promise(r => setTimeout(r, 2000));
-
-        if (obrutEmbedUrl) return `<!-- obrut-embed: ${obrutEmbedUrl} -->`;
-
-        // Try executing general.js to trigger iframe creation
-        if (generalJsContent) {
-            try {
-                await page.evaluate(generalJsContent);
-                console.log('[turbo] executed general.js');
-                await new Promise(r => setTimeout(r, 3000));
-                if (obrutEmbedUrl) return `<!-- obrut-embed: ${obrutEmbedUrl} -->`;
-            } catch(e) { console.log('[turbo] general.js exec error:', e.message); }
-        }
-
-        // Fix Rocket Loader — re-execute blocked scripts
-        await page.evaluate(() => {
-            document.querySelectorAll('script[type]').forEach(s => {
-                if (s.type && s.type !== 'text/javascript' && s.type !== 'module' && s.src) {
-                    const ns = document.createElement('script');
-                    ns.src = s.src;
-                    document.head.appendChild(ns);
-                }
-            });
         });
 
-        // Wait up to 10s for obrut request
-        for (let i = 0; i < 10; i++) {
+        await page.goto(normalizedUrl, { waitUntil: 'domcontentloaded', timeout: 25000 });
+        
+        // Wait for Cloudflare challenge
+        console.log('[turbo] waiting for Cloudflare challenge...');
+        await new Promise(r => setTimeout(r, 5000));
+        
+        // Wait for obrut embed
+        for (let i = 0; i < 10 && !obrutEmbedUrl; i++) {
             await new Promise(r => setTimeout(r, 1000));
-            if (obrutEmbedUrl) return `<!-- obrut-embed: ${obrutEmbedUrl} -->`;
-            // Also check DOM
             const html = await page.content();
-            if (html.includes('obrut.show/embed/')) return html;
+            if (html.includes('obrut.show/embed/')) {
+                console.log('[turbo] found obrut embed in DOM');
+                return html;
+            }
         }
 
+        if (obrutEmbedUrl) return `<!-- obrut-embed: ${obrutEmbedUrl} -->`;
+
         const finalHtml = await page.content();
-        console.log('[turbo] Puppeteer final HTML len:', finalHtml.length, 'has embed:', finalHtml.includes('obrut.show/embed/'));
+        console.log('[turbo] Puppeteer final HTML len:', finalHtml.length);
         return finalHtml;
     } finally {
         await page.close();
     }
 }
 
-// ── Get embed URL from kinojump via Puppeteer ─────────────────────────────────
-async function getEmbedUrlViaPuppeteer(browser, pageUrl) {
-    // First try plain HTTP — embed URL is in raw HTML without https:// prefix
-    try {
-        // kinojump may redirect to web.kinojump.com — force stay on kinojump.com
-        const normalizedUrl = pageUrl.replace('web.kinojump.com', 'kinojump.com');
-        const html = await fetchRaw(normalizedUrl, {
-            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36',
-            'referer': KINOJUMP_BASE + '/',
-            'accept': 'text/html',
-            'accept-language': 'ru-RU,ru;q=0.9',
-            'accept-encoding': 'identity'
-        });
-        // Pattern: XXXXXXXX.obrut.show/embed/... OR obrut.show/embed/... (with or without subdomain)
-        const m = html.match(/([a-z0-9]*\.?obrut\.show\/embed\/[A-Za-z0-9]+\/content\/[A-Za-z0-9]+)/);
-        if (m) {
-            // Ensure it has a subdomain — if not, use default
-            let embedPath = m[1];
-            if (!embedPath.includes('.obrut.show')) {
-                embedPath = '49372504.' + embedPath; // fallback subdomain
-            }
-            const embedUrl = 'https://' + embedPath;
-            console.log('[turbo] found embed URL in raw HTML:', embedUrl);
-            return embedUrl;
-        }
-        console.log('[turbo] embed not found in raw HTML, falling back to Puppeteer');
-        console.log('[turbo] HTML length:', html.length, '| contains obrut:', html.includes('obrut'));
-        // Log what URL we actually got (after redirects)
-        const titleMatch = html.match(/<title>([^<]{0,80})<\/title>/);
-        if (titleMatch) console.log('[turbo] page title from raw HTML:', titleMatch[1]);
-    } catch(e) {
-        console.log('[turbo] raw HTTP failed:', e.message);
-    }
-    const page = await browser.newPage();
-    try {
-        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36');
-        await page.setExtraHTTPHeaders({ 'Accept-Language': 'ru-RU,ru;q=0.9' });
-        let foundUrl = null;
-        await page.setRequestInterception(true);
-        page.on('request', req => {
-            const u = req.url();
-            if (u.includes('obrut.show') && u.includes('/embed/') && !foundUrl) {
-                foundUrl = u;
-                console.log('[turbo] caught embed URL:', u.substring(0, 120));
-            }
-            req.continue();
-        });
-        await page.goto(pageUrl, { waitUntil: 'networkidle2', timeout: 30000 });
-        for (let i = 0; i < 20 && !foundUrl; i++) {
-            await new Promise(r => setTimeout(r, 1000));
-            const found = await page.evaluate((host) => {
-                for (const el of document.querySelectorAll('iframe, [src], [data-src]')) {
-                    const src = el.src || el.getAttribute('src') || el.getAttribute('data-src') || '';
-                    if (src.includes(host) && src.includes('/embed/')) return src;
-                }
-                return null;
-            }, 'obrut.show');
-            if (found) { foundUrl = found; break; }
-            if (i % 5 === 4) console.log('[turbo] waiting for obrut embed... (' + (i+1) + 's)');
-        }
-        if (!foundUrl) {
-            const html = await page.content();
-            const m = html.match(/https?:\/\/[^"'\s<>]*obrut\.show\/embed\/[^"'\s<>]*/g);
-            if (m && m.length) foundUrl = m[0];
-            console.log('[turbo] page title:', await page.title());
-            console.log('[turbo] obrut embed in HTML:', m ? m.slice(0,3) : 'none');
-        }
-        return foundUrl;
-    } finally {
-        await page.close();
-    }
-}
-
-// ── Parse obrut embed page ────────────────────────────────────────────────────
-// The Player() data has a random prefix + base64 JSON with garbage bytes injected.
-// We extract entries via regex on the decoded text, retrying until we get enough.
-
+// ── Parse obrut embed ─────────────────────────────────────────────────────────
 function getCleanText(raw) {
     const eyJIdx = raw.indexOf('eyJ');
     const b64 = eyJIdx > 0 ? raw.substring(eyJIdx) : raw;
@@ -272,7 +156,6 @@ function parseFileStr(fileStr) {
 }
 
 function extractEntries(text) {
-    // Serial: t1 is non-empty like "S01E01 - Title"
     const re = /"title":"([^"]+)","t1":"([^"]+)","poster":"[^"]*","file":"((?:\[\w+\]https?:\\\/\\\/[^"]+))"/g;
     const entries = [];
     let m;
@@ -286,85 +169,121 @@ function extractEntries(text) {
 }
 
 function extractMovieVoices(text) {
-    // Movie: t1 is empty string ""
     const re = /"title":"([^"]+)","t1":"","poster":"[^"]*","file":"((?:\[\w+\]https?:\\\/\\\/[^"]+))"/g;
     const voices = [];
     let m;
     while ((m = re.exec(text)) !== null) {
-        const fileStr = m[3].replace(/\\\//g, '/');
+        const fileStr = m[2].replace(/\\\//g, '/');
         const streams = parseFileStr(fileStr);
-        if (streams.length > 0) voices.push({ label: m[1], url: streams[0].url, qualities: streams, subtitles: [] });
+        if (streams.length > 0) voices.push({ label: m[1], url: streams[0].url, qualities: streams });
     }
     return voices;
 }
 
-async function parseObrutEmbed(embedUrl) {
-    // Run parallel batches of requests and merge results
-    // obrut injects random garbage bytes that truncate data — more parallel requests = better coverage
-    const BATCH_SIZE = 10;
-    const MAX_BATCHES = 8;
-    
-    // Merged data structures
-    const mergedEntries = new Map(); // key: voice+episode -> entry
-    const mergedVoices = new Map();  // key: label -> voice
-
-    // First try plain HTTP
-    const testHtml = await fetchRaw(embedUrl, {
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36',
-        'referer': 'https://web.kinojump.com/',
-        'accept': 'text/html,application/xhtml+xml',
-        'accept-encoding': 'identity'
-    }).catch(() => '');
-    
-    const hasPlayer = testHtml.includes('new Player(');
-    console.log('[turbo] obrut embed test: len=', testHtml.length, 'hasPlayer=', hasPlayer, 'start:', testHtml.substring(0, 100));
-    
-    if (!hasPlayer) {
-        // obrut blocked plain HTTP — use Puppeteer to get embed HTML
-        console.log('[turbo] obrut blocked plain HTTP, using Puppeteer for embed');
-        const browser = await getBrowser();
-        const page = await browser.newPage();
-        try {
-            await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36');
-            await page.setExtraHTTPHeaders({ 'referer': 'https://web.kinojump.com/' });
-            await page.goto(embedUrl, { waitUntil: 'networkidle2', timeout: 25000 });
-            await new Promise(r => setTimeout(r, 2000));
-            const html = await page.content();
-            console.log('[turbo] Puppeteer embed len:', html.length, 'hasPlayer:', html.includes('new Player('));
-            
-            if (html.includes('new Player(')) {
-                const pm = html.match(/new\s+Player\s*\(\s*"([A-Za-z0-9+/=]{20,})"/);
-                if (pm) {
-                    const text = getCleanText(pm[1]);
-                    const entries = extractEntries(text);
-                    const movieVoices = extractMovieVoices(text);
-                    console.log('[turbo] Puppeteer embed: entries=', entries.length, 'voices=', movieVoices.length);
-                    if (entries.length > 0 || movieVoices.length > 0) {
-                        return { entries, movieVoices };
-                    }
-                    // If Puppeteer got data but not enough, continue with parallel HTTP
-                    console.log('[turbo] Puppeteer got Player but no entries, trying parallel HTTP');
-                }
+async function parseObrutEmbed(embedUrl, browser) {
+    // obrut.show uses Cloudflare - need Puppeteer with anti-detection
+    console.log('[turbo] parsing obrut embed with Puppeteer (Cloudflare bypass)');
+    const page = await browser.newPage();
+    try {
+        // More realistic browser fingerprint
+        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
+        await page.setExtraHTTPHeaders({ 
+            'Accept-Language': 'ru-RU,ru;q=0.9,en;q=0.8',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Referer': 'https://kinojump.com/',
+            'Sec-Fetch-Dest': 'iframe',
+            'Sec-Fetch-Mode': 'navigate',
+            'Sec-Fetch-Site': 'cross-site',
+        });
+
+        await page.setViewport({ width: 1920, height: 1080 });
+
+        // Disable automation detection
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            window.chrome = { runtime: {} };
+            Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
+            Object.defineProperty(navigator, 'languages', { get: () => ['ru-RU', 'ru', 'en-US', 'en'] });
+        });
+
+        await page.setRequestInterception(true);
+        page.on('request', req => {
+            const resourceType = req.resourceType();
+            if (['image', 'stylesheet', 'font', 'media'].includes(resourceType)) {
+                req.abort();
+            } else {
+                req.continue();
             }
-        } finally {
-            await page.close();
+        });
+
+        console.log('[turbo] navigating to obrut embed:', embedUrl.substring(0, 80));
+        
+        await page.goto(embedUrl, {
+            waitUntil: 'domcontentloaded',
+            timeout: 30000,
+        });
+
+        // Wait for Cloudflare challenge to complete
+        console.log('[turbo] waiting for Cloudflare challenge...');
+        await new Promise(r => setTimeout(r, 5000));
+
+        const currentUrl = page.url();
+        const title = await page.title().catch(() => '');
+        console.log('[turbo] current URL:', currentUrl.substring(0, 80));
+        console.log('[turbo] page title:', title);
+
+        if (title.includes('Just a moment') || title.includes('Checking your browser')) {
+            console.log('[turbo] still on Cloudflare challenge, waiting more...');
+            await new Promise(r => setTimeout(r, 5000));
+        }
+
+        // Wait for player to initialize
+        await new Promise(r => setTimeout(r, 2000));
+
+        const html = await page.content();
+        console.log('[turbo] Puppeteer got HTML, len:', html.length, 'hasPlayer:', html.includes('new Player('));
+        
+        if (!html.includes('new Player(')) {
+            console.log('[turbo] no Player() found after Cloudflare bypass');
+            return null;
+        }
+
+        const pm = html.match(/new\s+Player\s*\(\s*"([A-Za-z0-9+/=]{20,})"/);
+        if (!pm) {
+            console.log('[turbo] Player() found but no base64 data');
+            return null;
         }
+
+        const text = getCleanText(pm[1]);
+        const entries = extractEntries(text);
+        const movieVoices = extractMovieVoices(text);
+        console.log('[turbo] Puppeteer: entries=', entries.length, 'voices=', movieVoices.length);
+        
+        if (entries.length === 0 && movieVoices.length === 0) {
+            console.log('[turbo] no data extracted, retrying with parallel requests...');
+            // Fallback to parallel HTTP if Puppeteer got Player but no data
+        } else {
+            return { entries, movieVoices };
+        }
+    } finally {
+        await page.close();
     }
 
+    // Fallback: parallel HTTP requests (may work after Puppeteer warmed up the session)
+    const BATCH_SIZE = 10;
+    const MAX_BATCHES = 5;
+    const mergedEntries = new Map();
+    const mergedVoices = new Map();
+
     for (let batch = 0; batch < MAX_BATCHES; batch++) {
-        // Fetch BATCH_SIZE pages in parallel
         const promises = Array.from({ length: BATCH_SIZE }, () =>
             fetchRaw(embedUrl, {
                 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36',
-                'referer': 'https://web.kinojump.com/',
-                'accept': 'text/html,application/xhtml+xml',
-                'accept-encoding': 'identity'
+                'referer': 'https://kinojump.com/',
+                'accept': 'text/html'
             }).then(html => {
                 const pm = html.match(/new\s+Player\s*\(\s*"([A-Za-z0-9+/=]{20,})"/);
-                if (!pm) {
-                    if (batch === 0) console.log('[turbo] no Player() in embed, len:', html.length, 'start:', html.substring(0, 150));
-                    return null;
-                }
+                if (!pm) return null;
                 const text = getCleanText(pm[1]);
                 return { entries: extractEntries(text), movieVoices: extractMovieVoices(text) };
             }).catch(() => null)
@@ -384,8 +303,7 @@ async function parseObrutEmbed(embedUrl) {
         }
 
         const e = mergedEntries.size, v = mergedVoices.size;
-        console.log(`[turbo] batch ${batch + 1}: merged entries=${e} voices=${v}`);
-        // For movies stop early, for serials always run all batches
+        console.log(`[turbo] batch ${batch + 1}: entries=${e} voices=${v}`);
         if (v >= 5) break;
     }
 
@@ -396,16 +314,10 @@ async function parseObrutEmbed(embedUrl) {
     return { entries, movieVoices };
 }
 
-// ── Build serial structure from entries ────────────────────────��─────────────
+// ── Build serial structure ────────────────────────────────────────────────────
 function buildSerialFromEntries(entries) {
-    // entries: [{voice, episode (e.g. "S01E01 - Title"), streams}]
-    // Group by season/episode
     const seasonMap = {};
-    const voiceSet = new Set();
-
     for (const e of entries) {
-        voiceSet.add(e.voice);
-        // Parse season/episode from t1: "S01E01 - Title" or "S01E01"
         const seMatch = e.episode.match(/S(\d+)E(\d+)/i);
         if (!seMatch) continue;
         const sNum = parseInt(seMatch[1], 10);
@@ -424,41 +336,28 @@ function buildSerialFromEntries(entries) {
         episodes[sk] = Object.keys(seasonMap[sk]).sort().map(ek => ({ id: ek, title: 'Episode ' + parseInt(ek.slice(1), 10) }));
         voices[sk] = {};
         for (const ek of Object.keys(seasonMap[sk])) {
-            voices[sk][ek] = seasonMap[sk][ek].map(v => ({
-                label: v.label,
-                url: v.url,
-                qualities: v.streams,
-                subtitles: []
-            }));
+            voices[sk][ek] = seasonMap[sk][ek].map(v => ({ label: v.label, url: v.url, qualities: v.streams, subtitles: [] }));
         }
     }
 
     return { seasons, episodes, voices };
 }
 
-// ── Main: get stream for a kinojump page URL ──────────────────────────────────
+// ── Main: get stream ──────────────────────────────────────────────────────────
 async function getTurboStream(pageUrl) {
     const browser = await getBrowser();
 
-    // Step 1: try plain HTTP first (fast, no Puppeteer)
-    console.log('[turbo] Step 1 - getting embed URL from:', pageUrl);
-    let embedUrl = null;
-    try {
-        const html = await getKinojumpHtml(pageUrl, browser);
-        const m = html.match(/(?:([a-z0-9]+)\.)?obrut\.show\/embed\/([A-Za-z0-9]+)\/content\/([A-Za-z0-9]+)/);
-        if (m) {
-            // m[1] = subdomain (may be undefined), m[2] = content type, m[3] = content id
-            const subdomain = m[1] ? m[1] + '.obrut.show' : '49372504.obrut.show';
-            embedUrl = 'https://' + subdomain + '/embed/' + m[2] + '/content/' + m[3];
-            console.log('[turbo] embed URL:', embedUrl);
-        } else { console.log('[turbo] embed not found in HTML'); }
-    } catch(e) { console.log('[turbo] getKinojumpHtml failed:', e.message); }
-
-    if (!embedUrl) throw new Error('obrut embed URL not found on kinojump page');
-
-    // Step 3: parse embed
-    console.log('[turbo] Step 2 - parsing obrut embed:', embedUrl);
-    const result = await parseObrutEmbed(embedUrl);
+    console.log('[turbo] getting embed URL from:', pageUrl);
+    const html = await getKinojumpHtml(pageUrl, browser);
+    const m = html.match(/(?:([a-z0-9]+)\.)?obrut\.show\/embed\/([A-Za-z0-9]+)\/content\/([A-Za-z0-9]+)/);
+    if (!m) throw new Error('obrut embed URL not found');
+
+    const subdomain = m[1] ? m[1] + '.obrut.show' : '49372504.obrut.show';
+    const embedUrl = 'https://' + subdomain + '/embed/' + m[2] + '/content/' + m[3];
+    console.log('[turbo] embed URL:', embedUrl);
+
+    console.log('[turbo] parsing obrut embed');
+    const result = await parseObrutEmbed(embedUrl, browser);
     if (!result) throw new Error('failed to extract data from obrut embed');
 
     const hasSerial = result.entries.length > 0;
@@ -472,8 +371,8 @@ async function getTurboStream(pageUrl) {
         console.log('[turbo] movie:', result.movieVoices.length, 'voices');
         return { embed_url: embedUrl, content_type: 'movie', voices: result.movieVoices };
     } else {
-        throw new Error('no entries or voices found in obrut embed');
+        throw new Error('no data found in obrut embed');
     }
 }
 
-module.exports = { turboSearch, getTurboStream, parseObrutEmbed, extractEntries, extractMovieVoices, buildSerialFromEntries, getKinojumpHtml };
+module.exports = { turboSearch, getTurboStream };