Upload 6 files

Dockerfile

@@ -0,0 +1,42 @@
+FROM node:20-slim
+
+# Install Chromium for Puppeteer
+RUN apt-get update && apt-get install -y \
+    chromium \
+    fonts-liberation \
+    libatk-bridge2.0-0 \
+    libatk1.0-0 \
+    libcups2 \
+    libdrm2 \
+    libgbm1 \
+    libgtk-3-0 \
+    libnspr4 \
+    libnss3 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxkbcommon0 \
+    libxrandr2 \
+    xdg-utils \
+    --no-install-recommends \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
+ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+
+# Create non-root user (required by Choreo/Back4App security scan)
+RUN useradd -m -u 10014 appuser && chown -R appuser:appuser /app
+USER 10014
+
+# Port is configured via PORT environment variable
+# Back4App: set PORT=80 in container settings
+# HuggingFace: set PORT=7860 in container settings  
+# Railway/Render: PORT is set automatically
+EXPOSE 3000
+
+CMD ["node", "server.js"]

alloha.js

@@ -0,0 +1,165 @@
+/**
+ * Alloha stream extractor using Puppeteer
+ * Opens the player page in a real browser, intercepts the /bnsi request
+ */
+const puppeteer = require('puppeteer');
+
+// Alloha domains config
+const ALLOHA_DOMAINS = [
+    {
+        domain: 'https://streamalloha.live',
+        token: '7fda2b04f6ae5e0e228bda812b0dee',
+        referer: 'https://kinokrad.my/',
+    },
+    {
+        domain: 'https://alloha.videozal.club',
+        token: '7245bc6ce2604536b78f128f818b06',
+        referer: 'https://videozal.club/',
+    },
+    {
+        domain: 'https://no.nextpool.online',
+        token: 'a4ae37fcdff5014cc929230cb83da5',
+        referer: 'https://kinojump.com/',
+    },
+];
+
+let browserInstance = null;
+
+async function getBrowser() {
+    if (browserInstance && browserInstance.connected) {
+        return browserInstance;
+    }
+    console.log('[puppeteer] Launching browser...');
+
+    const launchOptions = {
+        headless: true,
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-dev-shm-usage',
+            '--disable-gpu',
+            '--no-first-run',
+            '--no-zygote',
+            '--single-process',
+            '--disable-extensions',
+            '--disable-background-networking',
+            '--disable-default-apps',
+            '--disable-sync',
+            '--disable-translate',
+            '--hide-scrollbars',
+            '--metrics-recording-only',
+            '--mute-audio',
+            '--safebrowsing-disable-auto-update',
+        ],
+    };
+
+    // Use system Chromium if specified (Docker/Railway)
+    if (process.env.PUPPETEER_EXECUTABLE_PATH) {
+        launchOptions.executablePath = process.env.PUPPETEER_EXECUTABLE_PATH;
+        console.log('[puppeteer] Using system Chromium:', launchOptions.executablePath);
+    }
+
+    browserInstance = await puppeteer.launch(launchOptions);
+    console.log('[puppeteer] Browser launched');
+    return browserInstance;
+}
+
+/**
+ * Try one domain — returns result or throws
+ */
+async function tryDomain(browser, { domain, token, referer }, token_movie, timeout_ms) {
+    const page = await browser.newPage();
+    try {
+        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36');
+        await page.setExtraHTTPHeaders({ 'Accept-Language': 'ru-RU,ru;q=0.9,en;q=0.8' });
+
+        const playerUrl = `${domain}/?token_movie=${token_movie}&token=${encodeURIComponent(token)}`;
+        console.log(`[puppeteer] Trying: ${domain}`);
+
+        const bnsiPromise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`timeout ${timeout_ms}ms`)), timeout_ms);
+
+            page.on('response', async (response) => {
+                const url = response.url();
+                if (url.includes('/bnsi/')) {
+                    clearTimeout(timer);
+                    try {
+                        const status = response.status();
+                        const text = await response.text();
+                        console.log(`[puppeteer] bnsi ${status} ${url.substring(0, 80)}`);
+                        if (status === 200) {
+                            const json = JSON.parse(text);
+                            resolve({ ok: true, domain, url, ...json });
+                        } else {
+                            const decoded = text.replace(/\\u([0-9a-f]{4})/gi, (_, h) => String.fromCharCode(parseInt(h, 16)));
+                            reject(new Error(`bnsi ${status}: ${decoded.substring(0, 100)}`));
+                        }
+                    } catch (e) {
+                        reject(e);
+                    }
+                }
+            });
+        });
+
+        // Navigate with referer
+        await page.goto(playerUrl, {
+            waitUntil: 'domcontentloaded',
+            timeout: timeout_ms,
+            referer: referer,
+        });
+
+        return await bnsiPromise;
+
+    } finally {
+        await page.close();
+    }
+}
+
+/**
+ * Get streams for a movie using Puppeteer
+ * Tries all domains in order, returns first success
+ */
+async function getStreams({ token_movie, partner_token, referer, timeout_ms = 20000 }) {
+    const browser = await getBrowser();
+
+    // Build domain list — if partner_token provided, try to match or prepend custom
+    let domains = [...ALLOHA_DOMAINS];
+    if (partner_token) {
+        // Find matching domain or add custom entry at front
+        const match = domains.find(d => d.token === partner_token);
+        if (!match) {
+            domains.unshift({ domain: 'https://streamalloha.live', token: partner_token, referer: referer || 'https://kinokrad.my/' });
+        } else {
+            // Move matching domain to front
+            domains = [match, ...domains.filter(d => d !== match)];
+        }
+    }
+
+    let lastError = null;
+    for (const domainConfig of domains) {
+        try {
+            const result = await tryDomain(browser, domainConfig, token_movie, timeout_ms);
+            if (result && result.ok) {
+                console.log(`[puppeteer] SUCCESS on ${domainConfig.domain}`);
+                return result;
+            }
+        } catch (e) {
+            console.log(`[puppeteer] ${domainConfig.domain} failed: ${e.message}`);
+            lastError = e;
+        }
+    }
+
+    throw lastError || new Error('all domains failed');
+}
+
+/**
+ * Close the browser (call on shutdown)
+ */
+async function closeBrowser() {
+    if (browserInstance) {
+        await browserInstance.close();
+        browserInstance = null;
+    }
+}
+
+module.exports = { getStreams, closeBrowser, getBrowser };

cinemar.js

@@ -0,0 +1,348 @@
+/**
+ * Cinemar (cinemar.cc) stream extractor using Puppeteer
+ * cinemar.cc now uses Cloudflare Rocket Loader — data only available after JS execution
+ */
+const { getBrowser } = require('./alloha');
+const https = require('https');
+const http = require('http');
+
+function fetchRaw(reqUrl, headers) {
+    return new Promise((resolve, reject) => {
+        let u; try { u = new URL(reqUrl); } catch(e) { return reject(e); }
+        const mod = u.protocol === 'https:' ? https : http;
+        const req = mod.request({
+            hostname: u.hostname, path: u.pathname + u.search,
+            headers: headers || {}
+        }, res => {
+            let d = ''; res.setEncoding('utf8');
+            res.on('data', c => d += c);
+            res.on('end', () => resolve(d));
+        });
+        req.on('error', reject);
+        req.setTimeout(12000, () => { req.destroy(); reject(new Error('timeout')); });
+        req.end();
+    });
+}
+
+// ── Helpers (same as server.js) ───────────────────────────────────────────────
+
+function findAllInBuf(buf, pattern) {
+    const positions = [];
+    let pos = 0;
+    while (pos < buf.length) {
+        const idx = buf.indexOf(pattern, pos);
+        if (idx < 0) break;
+        positions.push(idx);
+        pos = idx + 1;
+    }
+    return positions;
+}
+
+function readJsonStr(buf, pos) {
+    let str = '', i = pos;
+    while (i < buf.length) {
+        const b = buf[i];
+        if (b === 0x22) return { str, end: i };
+        if (b === 0x5C) {
+            i++;
+            if (i >= buf.length) break;
+            const esc = buf[i];
+            if (esc === 0x75 && i + 4 < buf.length) {
+                const hex = buf.slice(i + 1, i + 5).toString('ascii');
+                if (/^[0-9a-fA-F]{4}$/.test(hex)) { str += String.fromCharCode(parseInt(hex, 16)); i += 5; continue; }
+            }
+            str += String.fromCharCode(esc);
+        } else if (b >= 0x20 && b <= 0x7E) {
+            str += String.fromCharCode(b);
+        } else if ((b & 0xE0) === 0xC0 && i + 1 < buf.length) {
+            str += String.fromCodePoint(((b & 0x1F) << 6) | (buf[i+1] & 0x3F)); i += 2; continue;
+        } else if ((b & 0xF0) === 0xE0 && i + 2 < buf.length) {
+            str += String.fromCodePoint(((b & 0x0F) << 12) | ((buf[i+1] & 0x3F) << 6) | (buf[i+2] & 0x3F)); i += 3; continue;
+        } else break;
+        i++;
+    }
+    return { str, end: i };
+}
+
+function findBufVal(buf, key, fromPos, maxDist) {
+    const keyBuf = Buffer.from('"' + key + '":"');
+    const idx = buf.indexOf(keyBuf, fromPos);
+    if (idx < 0 || idx > fromPos + (maxDist || 400)) return null;
+    return readJsonStr(buf, idx + keyBuf.length);
+}
+
+const FOLDER_MARKER_BUF = Buffer.from('"folder":[');
+
+function decodeCinemarFile(fileValue) {
+    const w3sPos = fileValue.indexOf('W3s');
+    if (w3sPos < 0) return null;
+    const raw = fileValue.substring(w3sPos);
+    const chunks = raw.split('&');
+    const buffers = [];
+    for (let i = 0; i < chunks.length; i++) {
+        let chunk = chunks[i];
+        if (i < chunks.length - 1) chunk = chunk.slice(0, -4);
+        const clean = chunk.replace(/[^A-Za-z0-9+/=]/g, '');
+        if (clean.length > 0) {
+            const padded = clean + '='.repeat((4 - clean.length % 4) % 4);
+            try { buffers.push(Buffer.from(padded, 'base64')); } catch(e) {}
+        }
+    }
+    if (!buffers.length) return null;
+    return Buffer.concat(buffers);
+}
+
+function normUrl(f) { return f ? (f.startsWith('//') ? 'https:' + f : f) : ''; }
+
+function parseSubs(subtitle) {
+    const subs = [];
+    if (!subtitle) return subs;
+    subtitle.split(',').forEach(part => {
+        const sm = part.match(/^\[([^\]]+)\](\/\/.+|https?:\/\/.+)/);
+        if (sm) subs.push({ label: sm[1], url: normUrl(sm[2]) });
+    });
+    return subs;
+}
+
+// ── Get HTML via Puppeteer (bypasses Cloudflare Rocket Loader) ────────────────
+async function getEmbedHtmlViaPuppeteer(embedUrl) {
+    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({ 'Accept-Language': 'ru-RU,ru;q=0.9' });
+
+        // Intercept the file data from window object after JS executes
+        let fileData = null;
+
+        await page.setRequestInterception(true);
+        page.on('request', req => req.continue());
+
+        await page.goto(embedUrl, {
+            waitUntil: 'networkidle2',
+            timeout: 25000,
+            referer: 'https://uakinogo.io/'
+        });
+
+        // Wait for player to initialize and extract file data
+        await new Promise(r => setTimeout(r, 2000));
+
+        fileData = await page.evaluate(() => {
+            // Try to find file data in window variables
+            for (const k of Object.keys(window)) {
+                try {
+                    const v = window[k];
+                    if (v && typeof v === 'object' && v.file && typeof v.file === 'string' && v.file.length > 100) {
+                        return JSON.stringify(v);
+                    }
+                } catch(e) {}
+            }
+            // Try to get from DOM — look for script with file data
+            for (const s of document.querySelectorAll('script:not([src])')) {
+                const t = s.textContent || '';
+                if (t.includes('"file"') && t.includes('W3s')) return t;
+            }
+            // Get full page HTML
+            return document.documentElement.outerHTML;
+        });
+
+        console.log('[cinemar] puppeteer got data, length:', fileData ? fileData.length : 0);
+        return fileData || '';
+    } finally {
+        await page.close();
+    }
+}
+
+// ── Parse cinemar HTML/data ───────────────────────────────────────────────────
+function parseCinemarData(html) {
+    const fileMatch = html.match(/"file":"([^"]+)"/);
+    if (!fileMatch) return null;
+    const buf = decodeCinemarFile(fileMatch[1]);
+    if (!buf || buf.length < 20) return null;
+
+    const isSerial = buf.indexOf(FOLDER_MARKER_BUF) >= 0;
+
+    if (!isSerial) {
+        // Try JSON parse first (movie format: array of voice objects)
+        try {
+            const jsonStr = buf.toString('utf8');
+            const arr = JSON.parse(jsonStr);
+            if (Array.isArray(arr) && arr.length && arr[0].title) {
+                const items = arr.map(item => ({
+                    title: item.title || 'Unknown',
+                    file: (item.file || '').replace(/\\\//g, '/').replace(/^\/\//, 'https://'),
+                    subtitle: item.subtitle || ''
+                })).filter(i => i.file && i.file.includes('cinemap'));
+                if (items.length) return { isSerial: false, items };
+            }
+        } catch(e) {}
+
+        // Fallback: binary search for src_id
+        const items = [];
+        findAllInBuf(buf, Buffer.from('"src_id"')).forEach(pos => {
+            const t = findBufVal(buf, 'title', pos, 300);
+            const f = findBufVal(buf, 'file', pos, 5000);
+            const s = findBufVal(buf, 'subtitle', pos, 6000);
+            if (!f) return;
+            const url = normUrl(f.str.replace(/\\\//g, '/'));
+            if (!url || !url.includes('cinemap')) return;
+            const title = t ? t.str : 'Unknown';
+            if (!items.find(i => i.title === title)) items.push({ title, file: url, subtitle: s ? s.str.replace(/\\\//g, '/') : '' });
+        });
+        return { isSerial: false, items };
+    }
+
+    // Serial
+    const epIdPrefix = Buffer.from('"id":"s');
+    const allEpPositions = [];
+    findAllInBuf(buf, epIdPrefix).forEach(pos => {
+        let i = pos + epIdPrefix.length;
+        while (i < buf.length && buf[i] >= 0x30 && buf[i] <= 0x39) i++;
+        if (buf[i] !== 0x65) return;
+        i++;
+        while (i < buf.length && buf[i] >= 0x30 && buf[i] <= 0x39) i++;
+        if (buf[i] !== 0x22) return;
+        const fullId = buf.slice(pos + 6, i).toString('ascii');
+        const seasonMatch = fullId.match(/^(s\d+)e(\d+)$/);
+        if (!seasonMatch) return;
+        const t = findBufVal(buf, 'title', pos, 200);
+        allEpPositions.push({ id: fullId, seasonId: seasonMatch[1], epNum: parseInt(seasonMatch[2], 10), title: t ? t.str : ('Серия ' + seasonMatch[2]), pos });
+    });
+
+    const seasonMap = {};
+    allEpPositions.forEach(ep => {
+        if (!seasonMap[ep.seasonId]) seasonMap[ep.seasonId] = [];
+        if (!seasonMap[ep.seasonId].find(e => e.id === ep.id)) seasonMap[ep.seasonId].push(ep);
+    });
+    const seasonIds = Object.keys(seasonMap).sort((a, b) => parseInt(a.substring(1)) - parseInt(b.substring(1)));
+    if (!seasonIds.length) return null;
+
+    const episodes = {};
+    seasonIds.forEach(seasonId => {
+        const eps = seasonMap[seasonId].sort((a, b) => a.epNum - b.epNum);
+        episodes[seasonId] = eps.map((ep, ei) => {
+            const nextEpPos = ei + 1 < eps.length ? eps[ei + 1].pos : buf.length;
+            const eBuf = buf.slice(ep.pos, nextEpPos);
+            const voices = [];
+            findAllInBuf(eBuf, Buffer.from('"src_id"')).forEach(vpos => {
+                const t = findBufVal(eBuf, 'title', vpos, 300);
+                const f = findBufVal(eBuf, 'file', vpos, 2000);
+                const s = findBufVal(eBuf, 'subtitle', vpos, 3000);
+                if (!f) return;
+                const url = normUrl(f.str.replace(/\\\//g, '/'));
+                if (!url || !url.includes('.m3u8')) return;
+                const title = t ? t.str : 'Unknown';
+                if (!voices.find(v => v.title === title)) voices.push({ title, file: url, subtitle: s ? s.str.replace(/\\\//g, '/') : '' });
+            });
+            return { id: ep.id, title: ep.title, voices };
+        });
+    });
+
+    return { isSerial: true, seasonIds, episodes };
+}
+
+// ── Main: get stream for a uakinogo page URL ──────────────────────────────────
+async function getCinemarStream(pageUrl) {
+    // Step 1: get embed URL from uakinogo page
+    const pageHtml = await fetchRaw(pageUrl, {
+        'user-agent': 'Mozilla/5.0 Chrome/120', 'referer': 'https://uakinogo.io/'
+    });
+    const em = pageHtml.match(/"embedUrl"\s*:\s*"(https:\/\/cinemar\.cc\/embed\/[^"]+)"/);
+    if (!em) throw new Error('embed_url not found');
+    const embedUrl = em[1];
+    console.log('[cinemar] embed URL:', embedUrl.substring(0, 80));
+
+    // Step 2: get embed HTML — try plain HTTP first, fallback to Puppeteer
+    let embedHtml = await fetchRaw(embedUrl, {
+        'user-agent': 'Mozilla/5.0 Chrome/120',
+        'referer': 'https://uakinogo.io/',
+        'origin': 'https://uakinogo.io'
+    });
+
+    if (!embedHtml || !embedHtml.includes('"file"')) {
+        console.log('[cinemar] no file in plain HTML, trying Puppeteer...');
+        embedHtml = await getEmbedHtmlViaPuppeteer(embedUrl);
+    } else {
+        console.log('[cinemar] got file data via plain HTTP');
+    }
+
+    if (!embedHtml || !embedHtml.includes('"file"')) {
+        throw new Error('no file data in embed (Cloudflare blocked?)');
+    }
+
+    // Step 3: parse data
+    const parsed = parseCinemarData(embedHtml);
+    if (!parsed) throw new Error('failed to parse cinemar data');
+
+    if (!parsed.isSerial) {
+        const voices = parsed.items.map(item => ({
+            label: item.title, url: item.file, subtitles: parseSubs(item.subtitle)
+        }));
+        return { content_type: 'movie', embed_url: embedUrl, voices, serial: null, stream: voices[0] ? voices[0].url : null };
+    }
+
+    // Serial: fetch multiple times and merge
+    const merged = {};
+    const addEpisodes = (data) => {
+        if (!data || !data.isSerial) return;
+        data.seasonIds.forEach(sid => {
+            (data.episodes[sid] || []).forEach(ep => {
+                if (!merged[ep.id] || ep.voices.length > (merged[ep.id] ? merged[ep.id].voices.length : 0)) {
+                    merged[ep.id] = { ...ep, seasonId: sid };
+                }
+            });
+        });
+    };
+
+    addEpisodes(parsed);
+
+    // Fetch more in parallel to get all episodes
+    const BATCH = 5, MAX_BATCHES = 4;
+    for (let b = 0; b < MAX_BATCHES; b++) {
+        const prevCount = Object.keys(merged).length;
+        const htmls = await Promise.all(
+            Array.from({ length: BATCH }, () =>
+                fetchRaw(embedUrl, { 'user-agent': 'Mozilla/5.0 Chrome/120', 'referer': 'https://uakinogo.io/', 'origin': 'https://uakinogo.io' }).catch(() => null)
+            )
+        );
+        htmls.filter(Boolean).forEach(html => addEpisodes(parseCinemarData(html)));
+        const newCount = Object.keys(merged).length;
+        console.log(`[cinemar] batch ${b+1}: ${newCount} eps (+${newCount - prevCount})`);
+        if (newCount === prevCount && b >= 1) break;
+        if (b < MAX_BATCHES - 1) await new Promise(r => setTimeout(r, 200));
+    }
+
+    // Build serial structure
+    const seasonMap = {};
+    Object.values(merged).forEach(ep => {
+        if (!seasonMap[ep.seasonId]) seasonMap[ep.seasonId] = [];
+        seasonMap[ep.seasonId].push(ep);
+    });
+    const seasonIds = Object.keys(seasonMap).sort((a, b) => parseInt(a.substring(1)) - parseInt(b.substring(1)));
+    const seasons = [], episodes = {}, voicesMap = {};
+    seasonIds.forEach(sid => {
+        const eps = seasonMap[sid].sort((a, b) => {
+            const an = parseInt(a.id.match(/e(\d+)/)[1]);
+            const bn = parseInt(b.id.match(/e(\d+)/)[1]);
+            return an - bn;
+        });
+        seasons.push({ id: sid, title: 'Сезон ' + parseInt(sid.substring(1)) });
+        episodes[sid] = eps.map(ep => ({ id: ep.id, title: ep.title }));
+        voicesMap[sid] = {};
+        eps.forEach(ep => {
+            voicesMap[sid][ep.id] = ep.voices.map(v => ({ label: v.title, url: normUrl(v.file), subtitles: parseSubs(v.subtitle) }));
+        });
+    });
+
+    const totalEps = Object.values(episodes).reduce((s, e) => s + e.length, 0);
+    console.log(`[cinemar] done: ${seasons.length} seasons, ${totalEps} eps`);
+
+    const serial = { seasons, episodes, voices: voicesMap };
+    const firstVoice = seasons[0] && episodes[seasons[0].id] && episodes[seasons[0].id][0]
+        ? (voicesMap[seasons[0].id][episodes[seasons[0].id][0].id] || [])[0]
+        : null;
+
+    return { content_type: 'serial', embed_url: embedUrl, serial, voices: [], stream: firstVoice ? firstVoice.url : null };
+}
+
+module.exports = { getCinemarStream };

package.json

@@ -0,0 +1,17 @@
+{
+  "name": "alloha-puppeteer",
+  "version": "1.0.0",
+  "description": "Alloha stream extractor using Puppeteer",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "test": "node test.js",
+    "postinstall": "node -e \"try { const p = require('puppeteer'); const path = p.executablePath ? p.executablePath() : 'unknown'; console.log('[postinstall] Chromium path:', path); } catch(e) { console.log('[postinstall] puppeteer error:', e.message); }\""
+  },
+  "dependencies": {
+    "puppeteer": "24.15.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

server.js

@@ -0,0 +1,751 @@
+/**
+ * Alloha + Cinemar + Turbo Proxy Server
+ * Endpoints: /alloha/streams, /alloha/player-info, /hls, /srt2vtt,
+ *            /uakinogo/search, /uakinogo/stream, /uakinogo/embed,
+ *            /turbo/search, /turbo/stream, /health
+ */
+const http = require('http');
+const https = require('https');
+
+// Load alloha with error handling — Puppeteer/Chromium may not be available on all platforms
+let getStreams, closeBrowser;
+try {
+    const alloha = require('./alloha');
+    getStreams = alloha.getStreams;
+    closeBrowser = alloha.closeBrowser;
+    console.log('[server] Alloha/Puppeteer loaded OK');
+} catch(e) {
+    console.log('[server] Alloha/Puppeteer NOT available:', e.message);
+    getStreams = async () => { throw new Error('Puppeteer not available on this platform'); };
+    closeBrowser = async () => {};
+}
+
+const { turboSearch, getTurboStream } = require('./turbo');
+const { getCinemarStream } = require('./cinemar');
+
+const PORT = process.env.PORT || 3000;
+const ALLOHA_HOST = 'streamalloha.live';
+const ALLOHA_TOKEN = '7fda2b04f6ae5e0e228bda812b0dee';
+
+const CORS = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': '*',
+    'Content-Type': 'application/json',
+};
+
+function jsonResp(res, data, status) {
+    res.writeHead(status || 200, CORS);
+    res.end(JSON.stringify(data));
+}
+
+function parseQuery(reqUrl) {
+    try {
+        const u = new URL('http://x' + reqUrl);
+        const q = {};
+        u.searchParams.forEach((v, k) => { q[k] = v; });
+        return { pathname: u.pathname, query: q };
+    } catch(e) {
+        return { pathname: reqUrl.split('?')[0], query: {} };
+    }
+}
+
+function readBody(req) {
+    return new Promise(resolve => {
+        let body = '';
+        req.setEncoding('utf8');
+        req.on('data', c => { body += c; });
+        req.on('end', () => resolve(body));
+    });
+}
+
+function fetchRaw(reqUrl, headers) {
+    return new Promise((resolve, reject) => {
+        let u; try { u = new URL(reqUrl); } catch(e) { return reject(e); }
+        const mod = u.protocol === 'https:' ? https : http;
+        const req = mod.request({
+            hostname: u.hostname,
+            port: u.port || (u.protocol === 'https:' ? 443 : 80),
+            path: u.pathname + u.search,
+            method: 'GET',
+            headers: headers || {},
+        }, res => {
+            // Handle gzip/deflate encoding
+            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());
+            }
+            let data = '';
+            stream.setEncoding('utf8');
+            stream.on('data', c => { data += c; });
+            stream.on('end', () => resolve(data));
+            stream.on('error', reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(20000, () => { req.destroy(); reject(new Error('timeout')); });
+        req.end();
+    });
+}
+
+// ── Cinemar parser ────────────────────────────────────────────────────────────
+
+function findAllInBuf(buf, pattern) {
+    const positions = [];
+    let pos = 0;
+    while (pos < buf.length) {
+        const idx = buf.indexOf(pattern, pos);
+        if (idx < 0) break;
+        positions.push(idx);
+        pos = idx + 1;
+    }
+    return positions;
+}
+
+function readJsonStr(buf, pos) {
+    let str = '', i = pos;
+    while (i < buf.length) {
+        const b = buf[i];
+        if (b === 0x22) return { str, end: i };
+        if (b === 0x5C) {
+            i++;
+            if (i >= buf.length) break;
+            const esc = buf[i];
+            if (esc === 0x75 && i + 4 < buf.length) {
+                const hex = buf.slice(i + 1, i + 5).toString('ascii');
+                if (/^[0-9a-fA-F]{4}$/.test(hex)) { str += String.fromCharCode(parseInt(hex, 16)); i += 5; continue; }
+            }
+            str += String.fromCharCode(esc);
+        } else if (b >= 0x20 && b <= 0x7E) {
+            str += String.fromCharCode(b);
+        } else if ((b & 0xE0) === 0xC0 && i + 1 < buf.length && (buf[i+1] & 0xC0) === 0x80) {
+            str += String.fromCodePoint(((b & 0x1F) << 6) | (buf[i+1] & 0x3F)); i += 2; continue;
+        } else if ((b & 0xF0) === 0xE0 && i + 2 < buf.length && (buf[i+1] & 0xC0) === 0x80 && (buf[i+2] & 0xC0) === 0x80) {
+            str += String.fromCodePoint(((b & 0x0F) << 12) | ((buf[i+1] & 0x3F) << 6) | (buf[i+2] & 0x3F)); i += 3; continue;
+        } else break;
+        i++;
+    }
+    return { str, end: i };
+}
+
+function findBufVal(buf, key, fromPos, maxDist) {
+    const keyBuf = Buffer.from('"' + key + '":"');
+    const idx = buf.indexOf(keyBuf, fromPos);
+    if (idx < 0 || idx > fromPos + (maxDist || 400)) return null;
+    return readJsonStr(buf, idx + keyBuf.length);
+}
+
+const FOLDER_MARKER_BUF = Buffer.from('"folder":[');
+
+// Cinemar inserts garbage: 4 hex chars + '&' every ~4000 chars into the base64 string.
+// Must split on '&', strip the 4 trailing hex chars from each chunk, decode separately, concat.
+function decodeCinemarFile(fileValue) {
+    const w3sPos = fileValue.indexOf('W3s');
+    if (w3sPos < 0) return null;
+    const raw = fileValue.substring(w3sPos);
+    const chunks = raw.split('&');
+    const buffers = [];
+    for (let i = 0; i < chunks.length; i++) {
+        let chunk = chunks[i];
+        if (i < chunks.length - 1) chunk = chunk.slice(0, -4); // strip 4 hex garbage chars
+        const clean = chunk.replace(/[^A-Za-z0-9+/=]/g, '');
+        if (clean.length > 0) {
+            const padded = clean + '='.repeat((4 - clean.length % 4) % 4);
+            try { buffers.push(Buffer.from(padded, 'base64')); } catch(e) {}
+        }
+    }
+    if (!buffers.length) return null;
+    return Buffer.concat(buffers);
+}
+
+function normUrl(f) { return f ? (f.startsWith('//') ? 'https:' + f : f) : ''; }
+
+function parseSubs(subtitle) {
+    const subs = [];
+    if (!subtitle) return subs;
+    subtitle.split(',').forEach(part => {
+        const sm = part.match(/^\[([^\]]+)\](\/\/.+|https?:\/\/.+)/);
+        if (sm) subs.push({ label: sm[1], url: normUrl(sm[2]) });
+    });
+    return subs;
+}
+
+function parseCinemarBase64(html) {
+    const fileMatch = html.match(/"file":"([^"]+)"/);
+    if (!fileMatch) return null;
+    const buf = decodeCinemarFile(fileMatch[1]);
+    if (!buf || buf.length < 20) return null;
+
+    const isSerial = buf.indexOf(FOLDER_MARKER_BUF) >= 0;
+
+    if (!isSerial) {
+        const items = [];
+        findAllInBuf(buf, Buffer.from('"src_id"')).forEach(pos => {
+            const t = findBufVal(buf, 'title', pos, 300);
+            const f = findBufVal(buf, 'file', pos, 5000);  // dlink field can be very long
+            const s = findBufVal(buf, 'subtitle', pos, 6000);
+            if (!f) return;
+            const url = normUrl(f.str.replace(/\\\//g, '/'));
+            if (!url || !url.includes('cinemap')) return;  // must be a real stream URL
+            const title = t ? t.str : 'Unknown';
+            if (!items.find(i => i.title === title)) items.push({ title, file: url, subtitle: s ? s.str.replace(/\\\//g, '/') : '' });
+        });
+        return items.length ? items : null;
+    }
+
+    // Serial: find all episode IDs (sXXeYY) and group by season
+    const epIdPrefix = Buffer.from('"id":"s');
+    const allEpPositions = [];
+    findAllInBuf(buf, epIdPrefix).forEach(pos => {
+        let i = pos + epIdPrefix.length;
+        while (i < buf.length && buf[i] >= 0x30 && buf[i] <= 0x39) i++;
+        if (buf[i] !== 0x65) return;
+        i++;
+        while (i < buf.length && buf[i] >= 0x30 && buf[i] <= 0x39) i++;
+        if (buf[i] !== 0x22) return;
+        const fullId = buf.slice(pos + 6, i).toString('ascii');
+        const seasonMatch = fullId.match(/^(s\d+)e(\d+)$/);
+        if (!seasonMatch) return;
+        const folderIdx = buf.indexOf(FOLDER_MARKER_BUF, pos);
+        if (folderIdx < 0 || folderIdx > pos + 2000) return;
+        const t = findBufVal(buf, 'title', pos, 200);
+        allEpPositions.push({ id: fullId, seasonId: seasonMatch[1], epNum: parseInt(seasonMatch[2], 10), title: t ? t.str : ('Серия ' + seasonMatch[2]), pos });
+    });
+
+    const seasonMap = {};
+    allEpPositions.forEach(ep => {
+        if (!seasonMap[ep.seasonId]) seasonMap[ep.seasonId] = [];
+        if (!seasonMap[ep.seasonId].find(e => e.id === ep.id)) seasonMap[ep.seasonId].push(ep);
+    });
+    const seasonIds = Object.keys(seasonMap).sort((a, b) => parseInt(a.substring(1)) - parseInt(b.substring(1)));
+    if (!seasonIds.length) return null;
+
+    return seasonIds.map(seasonId => {
+        const eps = seasonMap[seasonId].sort((a, b) => a.epNum - b.epNum);
+        const episodesWithVoices = eps.map((ep, ei) => {
+            const nextEpPos = ei + 1 < eps.length ? eps[ei + 1].pos : buf.length;
+            const eBuf = buf.slice(ep.pos, nextEpPos);
+            const voices = [];
+            findAllInBuf(eBuf, Buffer.from('"src_id"')).forEach(vpos => {
+                const t = findBufVal(eBuf, 'title', vpos, 300);
+                const f = findBufVal(eBuf, 'file', vpos, 2000);
+                const s = findBufVal(eBuf, 'subtitle', vpos, 3000);
+                if (!f) return;
+                const url = normUrl(f.str.replace(/\\\//g, '/'));
+                if (!url || !url.includes('.m3u8')) return;
+                const title = t ? t.str : 'Unknown';
+                if (!voices.find(v => v.title === title)) voices.push({ title, file: url, subtitle: s ? s.str.replace(/\\\//g, '/') : '' });
+            });
+            return { id: ep.id, title: ep.title, folder: voices };
+        });
+        return { id: seasonId, title: 'Сезон ' + parseInt(seasonId.substring(1)), folder: episodesWithVoices };
+    });
+}
+
+// ── Multi-fetch helpers ───────────────────────────────────────────────────────
+
+function parseEpisodesFromHtml(html) {
+    const fileMatch = html.match(/"file":"([^"]+)"/);
+    if (!fileMatch) return {};
+    const buf = decodeCinemarFile(fileMatch[1]);
+    if (!buf || buf.length < 20) return {};
+    if (buf.indexOf(FOLDER_MARKER_BUF) < 0) return {};
+
+    const epIdPrefix = Buffer.from('"id":"s');
+    const episodes = {};
+    findAllInBuf(buf, epIdPrefix).forEach(pos => {
+        let i = pos + epIdPrefix.length;
+        let seasonNum = '';
+        while (i < buf.length && buf[i] >= 0x30 && buf[i] <= 0x39) { seasonNum += String.fromCharCode(buf[i]); i++; }
+        if (buf[i] !== 0x65) return;
+        i++;
+        let epNum = '';
+        while (i < buf.length && buf[i] >= 0x30 && buf[i] <= 0x39) { epNum += String.fromCharCode(buf[i]); i++; }
+        if (buf[i] !== 0x22) return;
+
+        const fullId = 's' + seasonNum + 'e' + epNum;
+        const seasonId = 's' + seasonNum;
+        const t = findBufVal(buf, 'title', pos, 200);
+        const title = t ? t.str : ('Серия ' + epNum);
+
+        const nextEpPos = buf.indexOf(epIdPrefix, pos + 1);
+        const endPos = nextEpPos > 0 ? Math.min(nextEpPos, pos + 5000) : pos + 5000;
+        const eBuf = buf.slice(pos, endPos);
+        const voices = [];
+        findAllInBuf(eBuf, Buffer.from('"src_id"')).forEach(vpos => {
+            const vt = findBufVal(eBuf, 'title', vpos, 300);
+            const f = findBufVal(eBuf, 'file', vpos, 2000);
+            const s = findBufVal(eBuf, 'subtitle', vpos, 3000);
+            if (!f) return;
+            const url = normUrl(f.str.replace(/\\\//g, '/'));
+            if (!url || !url.includes('.m3u8')) return;
+            const vtitle = vt ? vt.str : 'Unknown';
+            if (!voices.find(v => v.title === vtitle)) voices.push({ title: vtitle, file: url, subtitle: s ? s.str.replace(/\\\//g, '/') : '' });
+        });
+
+        if (!episodes[fullId] || voices.length > episodes[fullId].voices.length)
+            episodes[fullId] = { id: fullId, seasonId, seasonNum: parseInt(seasonNum), epNum: parseInt(epNum), title, voices };
+    });
+    return episodes;
+}
+
+function buildSerialDataFromMerged(mergedEpisodes) {
+    const seasonMap = {};
+    Object.values(mergedEpisodes).forEach(ep => {
+        if (!seasonMap[ep.seasonId]) seasonMap[ep.seasonId] = [];
+        seasonMap[ep.seasonId].push(ep);
+    });
+    const seasonIds = Object.keys(seasonMap).sort((a, b) => parseInt(a.substring(1)) - parseInt(b.substring(1)));
+    const seasons = [], episodes = {}, voicesMap = {};
+    seasonIds.forEach(sid => {
+        const eps = seasonMap[sid].sort((a, b) => a.epNum - b.epNum);
+        seasons.push({ id: sid, title: 'Сезон ' + parseInt(sid.substring(1)) });
+        episodes[sid] = [];
+        voicesMap[sid] = {};
+        eps.forEach(ep => {
+            episodes[sid].push({ id: ep.id, title: ep.title });
+            voicesMap[sid][ep.id] = ep.voices.map(v => ({ label: v.title, url: normUrl(v.file), subtitles: parseSubs(v.subtitle) }));
+        });
+    });
+    return { seasons, episodes, voices: voicesMap };
+}
+
+function parseCinemar(embedHtml) {
+    let voices = [], masterUrl = null, serialData = null, contentType = 'movie';
+    const rawItems = parseCinemarBase64(embedHtml);
+    if (rawItems && rawItems.length) {
+        const first = rawItems[0];
+        if (first.folder && first.folder.length && first.folder[0] && first.folder[0].folder) {
+            contentType = 'serial';
+            const seasons = [], episodes = {}, voicesMap = {};
+            rawItems.forEach((season, si) => {
+                const sid = season.id || String(si + 1);
+                seasons.push({ id: sid, title: season.title || ('Сезон ' + (si + 1)) });
+                episodes[sid] = [];
+                voicesMap[sid] = {};
+                (season.folder || []).forEach((ep, ei) => {
+                    const eid = ep.id || String(ei + 1);
+                    episodes[sid].push({ id: eid, title: ep.title || ('Серия ' + (ei + 1)) });
+                    voicesMap[sid][eid] = (ep.folder || []).map(v => ({ label: v.title || 'Unknown', url: normUrl(v.file || ''), subtitles: parseSubs(v.subtitle) })).filter(v => v.url);
+                });
+            });
+            serialData = { seasons, episodes, voices: voicesMap };
+            const fs = seasons[0];
+            if (fs && episodes[fs.id] && episodes[fs.id][0]) {
+                const fv = voicesMap[fs.id][episodes[fs.id][0].id];
+                if (fv && fv[0]) masterUrl = fv[0].url;
+            }
+        } else if (first.folder) {
+            contentType = 'serial';
+            const seasons = [], episodes = {}, voicesMap = {};
+            rawItems.forEach((season, si) => {
+                const sid = season.id || String(si + 1);
+                seasons.push({ id: sid, title: season.title || ('Сезон ' + (si + 1)) });
+                episodes[sid] = [];
+                voicesMap[sid] = {};
+                (season.folder || []).forEach((ep, ei) => {
+                    const eid = ep.id || String(ei + 1);
+                    episodes[sid].push({ id: eid, title: ep.title || ('Серия ' + (ei + 1)) });
+                    const u = normUrl(ep.file || '');
+                    voicesMap[sid][eid] = u ? [{ label: ep.title || 'Unknown', url: u, subtitles: parseSubs(ep.subtitle) }] : [];
+                });
+            });
+            serialData = { seasons, episodes, voices: voicesMap };
+            const fs = seasons[0];
+            if (fs && episodes[fs.id] && episodes[fs.id][0]) {
+                const fv = voicesMap[fs.id][episodes[fs.id][0].id];
+                if (fv && fv[0]) masterUrl = fv[0].url;
+            }
+        } else {
+            contentType = 'movie';
+            voices = rawItems.map(item => ({ label: item.title || 'Unknown', url: normUrl(item.file || ''), subtitles: parseSubs(item.subtitle) })).filter(v => v.url);
+            if (voices.length) masterUrl = voices[0].url;
+        }
+    }
+    if (!masterUrl) {
+        const fm = embedHtml.match(/["'](https?:\/\/[^"']*cinemap[^"']*\.m3u8[^"']*)['"]/);
+        if (fm) masterUrl = fm[1];
+    }
+    return { contentType, voices, masterUrl, serialData };
+}
+
+// ── HLS proxy ─────────────────────────────────────────────────────────────────
+
+function handleHls(req, res) {
+    const { query } = parseQuery(req.url);
+    const targetUrl = query.url;
+    if (!targetUrl) { res.writeHead(400, { 'Access-Control-Allow-Origin': '*' }); res.end('no url'); return; }
+
+    function doRequest(reqUrl, redirectCount) {
+        if (redirectCount > 5) { res.writeHead(500, { 'Access-Control-Allow-Origin': '*' }); res.end('too many redirects'); return; }
+        let pu;
+        try { pu = new URL(reqUrl); } catch(e) { res.writeHead(400); res.end('bad url'); return; }
+        const mod = pu.protocol === 'https:' ? https : http;
+        const isObrut = pu.hostname.includes('obrut') || pu.hostname.includes('superdupercdn');
+        const isCinemap = pu.hostname.includes('cinemap');
+        const isAlloha = pu.hostname.includes('stream-balancer') || pu.hostname.includes('streamalloha') || pu.hostname.includes('allo-');
+        const opts = {
+            hostname: pu.hostname,
+            port: pu.port || (pu.protocol === 'https:' ? 443 : 80),
+            path: pu.pathname + pu.search,
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36',
+                'accept': '*/*',
+                'origin':  isCinemap ? 'https://uakinogo.io' : isObrut ? 'https://kinojump.com' : isAlloha ? 'https://streamalloha.live' : 'https://streamalloha.live',
+                'referer': isCinemap ? 'https://uakinogo.io/' : isObrut ? 'https://kinojump.com/' : isAlloha ? 'https://streamalloha.live/' : 'https://streamalloha.live/',
+            },
+        };
+        if (req.headers['range']) opts.headers['range'] = req.headers['range'];
+        const pr = mod.request(opts, upstream => {
+            // Follow redirects
+            if (upstream.statusCode >= 300 && upstream.statusCode < 400 && upstream.headers.location) {
+                upstream.resume();
+                let loc = upstream.headers.location;
+                if (!loc.startsWith('http')) loc = pu.origin + loc;
+                return doRequest(loc, redirectCount + 1);
+            }
+            const ct = upstream.headers['content-type'] || '';
+            const isM3u8 = ct.includes('mpegurl') || (reqUrl.includes('.m3u8') || reqUrl.includes(':hls:manifest')) && !reqUrl.includes(':hls:seg-');
+            const rh = { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Headers': '*' };
+            if (isM3u8) {
+                rh['Content-Type'] = 'application/vnd.apple.mpegurl';
+                res.writeHead(upstream.statusCode, rh);
+                let body = '';
+                upstream.setEncoding('utf8');
+                upstream.on('data', c => { body += c; });
+                upstream.on('end', () => {
+                    const base = reqUrl.substring(0, reqUrl.lastIndexOf('/') + 1);
+                    const serverBase = 'https://' + (req.headers.host || 'localhost:' + PORT);
+                    function rewriteUrl(rel) {
+                        let a = rel.trim();
+                        if (!a) return a;
+                        if (a.startsWith('//')) a = 'https:' + a;
+                        else if (!a.startsWith('http')) a = base + a;
+                        return serverBase + '/hls?url=' + encodeURIComponent(a);
+                    }
+                    res.end(body.split('\n').map(line => {
+                        const tr = line.trim();
+                        if (!tr) return line;
+                        if (tr.startsWith('#')) return line.replace(/URI="([^"]+)"/g, (m, uri) => `URI="${rewriteUrl(uri)}"`);
+                        return rewriteUrl(tr);
+                    }).join('\n'));
+                });
+            } else {
+                rh['Content-Type'] = ct || 'video/mp2t';
+                if (upstream.headers['content-length']) rh['Content-Length'] = upstream.headers['content-length'];
+                if (upstream.headers['content-range']) rh['Content-Range'] = upstream.headers['content-range'];
+                res.writeHead(upstream.statusCode, rh);
+                upstream.pipe(res);
+            }
+        });
+        pr.on('error', e => { res.writeHead(500); res.end(e.message); });
+        pr.end();
+    }
+
+    doRequest(targetUrl, 0);
+}
+
+// ── Server ────────────────────────────────────────────────────────────────────
+
+const server = http.createServer(async (req, res) => {
+    const { pathname, query } = parseQuery(req.url);
+
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS', 'Access-Control-Allow-Headers': '*' });
+        res.end();
+        return;
+    }
+
+    if (pathname === '/health') { jsonResp(res, { ok: true, time: new Date().toISOString() }); return; }
+
+    // Show outbound IP of this server
+    if (pathname === '/debug/ip') {
+        fetchRaw('https://api.ipify.org?format=json', { 'user-agent': 'curl/7.0' })
+            .then(d => { jsonResp(res, { ok: true, ip: JSON.parse(d).ip }); })
+            .catch(e => { jsonResp(res, { ok: false, error: e.message }); });
+        return;
+    }
+
+    if (pathname === '/debug/platform') {
+        const fs = require('fs');
+        const chromiumPaths = [
+            process.env.PUPPETEER_EXECUTABLE_PATH,
+            '/usr/bin/chromium',
+            '/usr/bin/chromium-browser',
+            '/usr/bin/google-chrome'
+        ].filter(Boolean);
+        const available = chromiumPaths.filter(p => { try { return fs.existsSync(p); } catch(e) { return false; } });
+        jsonResp(res, {
+            platform: process.platform,
+            node: process.version,
+            puppeteer_path: process.env.PUPPETEER_EXECUTABLE_PATH || 'not set',
+            chromium_found: available,
+            alloha_available: typeof getStreams === 'function' && getStreams.toString().includes('getBrowser') ? 'yes' : 'fallback'
+        });
+        return;
+    }
+    if (pathname === '/hls') { handleHls(req, res); return; }
+
+    if (pathname === '/srt2vtt') {
+        const corsH = { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Headers': '*', 'Content-Type': 'text/vtt; charset=utf-8' };
+        const subUrl = query.url;
+        if (!subUrl) { res.writeHead(400, corsH); res.end('no url'); return; }
+        fetchRaw(subUrl, { 'user-agent': 'Mozilla/5.0 Chrome/120' }).then(body => {
+            const vtt = 'WEBVTT\n\n' + body.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/(\d{2}:\d{2}:\d{2}),(\d{3})/g, '$1.$2');
+            res.writeHead(200, corsH); res.end(vtt);
+        }).catch(e => { res.writeHead(500, corsH); res.end(e.message); });
+        return;
+    }
+
+    if (pathname === '/alloha/player-info' && req.method === 'POST') {
+        try {
+            const params = JSON.parse(await readBody(req));
+            const { token_movie, partner_token } = params;
+            if (!token_movie) { jsonResp(res, { ok: false, error: 'token_movie required' }, 400); return; }
+            const token = partner_token || ALLOHA_TOKEN;
+            const playerUrl = `https://${ALLOHA_HOST}/?token_movie=${token_movie}&token=${encodeURIComponent(token)}`;
+            console.log(`[server] /alloha/player-info token_movie=${token_movie}`);
+            const html = await fetchRaw(playerUrl, { 'user-agent': 'Mozilla/5.0 Chrome/120', 'referer': 'https://kinokrad.my/' });
+            const nkMatch = html.match(/name="viewporti"\s+content="([^"]+)"/);
+            const nk = nkMatch ? nkMatch[1] : null;
+            if (!nk) { jsonResp(res, { ok: false, error: 'nk_not_found' }); return; }
+            let fileId = null;
+            const flMatch = html.match(/"active"\s*:\s*\{[^}]*?"id"\s*:\s*(\d+)/);
+            if (flMatch) fileId = flMatch[1];
+            if (!fileId) { const m = html.match(/"id"\s*:\s*(\d+)/); if (m) fileId = m[1]; }
+            let fileList = null;
+            const flRaw = html.match(/fileList\s*=\s*JSON\.parse\('([\s\S]*?)'\)/);
+            if (flRaw) { try { fileList = JSON.parse(flRaw[1]); } catch(e) {} }
+            const appBundle = (html.match(/src="(\/build\/app\.[a-f0-9]+\.js)"/) || [])[1] || null;
+            const runtimeBundle = (html.match(/src="(\/build\/runtime\.[a-f0-9]+\.js)"/) || [])[1] || null;
+            const bundle539 = (html.match(/src="(\/build\/539\.[a-f0-9]+\.js)"/) || [])[1] || null;
+            jsonResp(res, {
+                ok: true, nk, file_id: fileId, player_url: playerUrl, file_list: fileList,
+                bundle_app: appBundle ? `https://${ALLOHA_HOST}${appBundle}` : null,
+                bundle_runtime: runtimeBundle ? `https://${ALLOHA_HOST}${runtimeBundle}` : null,
+                bundle_539: bundle539 ? `https://${ALLOHA_HOST}${bundle539}` : null,
+            });
+        } catch(e) {
+            console.log('[server] player-info ERROR:', e.message);
+            jsonResp(res, { ok: false, error: e.message }, 500);
+        }
+        return;
+    }
+
+    if (pathname === '/alloha/streams' && req.method === 'POST') {
+        try {
+            const params = JSON.parse(await readBody(req));
+            const { token_movie, partner_token, referer } = params;
+            if (!token_movie) { jsonResp(res, { ok: false, error: 'token_movie required' }, 400); return; }
+            console.log(`[server] /alloha/streams token_movie=${token_movie}`);
+            const result = await getStreams({ token_movie, partner_token, referer });
+            const serverBase = 'https://' + (req.headers.host || 'localhost:' + PORT);
+            if (result.hlsSource) {
+                result.hlsSource = result.hlsSource.map(src => {
+                    if (src.quality) {
+                        const newQ = {};
+                        for (const [q, u] of Object.entries(src.quality)) {
+                            newQ[q] = u.split(' or ').map(raw => {
+                                const t = raw.trim();
+                                const full = t.startsWith('//') ? 'https:' + t : t;
+                                return serverBase + '/hls?url=' + encodeURIComponent(full);
+                            }).join(' or ');
+                        }
+                        src.quality = newQ;
+                    }
+                    return src;
+                });
+            }
+            jsonResp(res, result);
+        } catch(e) {
+            console.log('[server] streams ERROR:', e.message);
+            jsonResp(res, { ok: false, error: e.message }, 500);
+        }
+        return;
+    }
+
+    if (pathname === '/uakinogo/search') {
+        const q = query.q || '';
+        if (!q) { jsonResp(res, { ok: false, error: 'no query' }, 400); return; }
+        const searchUrl = 'https://uakinogo.io/index.php?do=search&subaction=search&story=' + encodeURIComponent(q);
+        fetchRaw(searchUrl, { 'user-agent': 'Mozilla/5.0 Chrome/120', 'referer': 'https://uakinogo.io/' }).then(html => {
+            const results = [];
+            const re = /href="(https?:\/\/uakinogo\.io\/(?:filmy|serialy|multserialy|multfilmy|zarubezhnye-serialy|russkie-serialy|anime-serialy|anime|novinki)\/(\d+)-([^"]+)\.html)"/g;
+            let m;
+            while ((m = re.exec(html)) !== null) {
+                if (!results.find(r => r.id === m[2])) results.push({ url: m[1], id: m[2], slug: m[3] });
+            }
+            jsonResp(res, { ok: true, results: results.slice(0, 10) });
+        }).catch(e => jsonResp(res, { ok: false, error: e.message }, 500));
+        return;
+    }
+
+    if (pathname === '/uakinogo/embed') {
+        const pageUrl = query.url;
+        if (!pageUrl) { jsonResp(res, { ok: false, error: 'no url' }, 400); return; }
+        fetchRaw(pageUrl, { 'user-agent': 'Mozilla/5.0 Chrome/120', 'referer': 'https://uakinogo.io/' }).then(html => {
+            const m = html.match(/"embedUrl"\s*:\s*"(https:\/\/cinemar\.cc\/embed\/[^"]+)"/);
+            jsonResp(res, { ok: true, embed_url: m ? m[1] : null });
+        }).catch(e => jsonResp(res, { ok: false, error: e.message }, 500));
+        return;
+    }
+
+    // ── /turbo/search?q=TITLE ─────────────────────────────────────────────────
+    if (pathname === '/turbo/search') {
+        const q = query.q || '';
+        if (!q) { jsonResp(res, { ok: false, error: 'no query' }, 400); return; }
+        turboSearch(q)
+            .then(results => jsonResp(res, { ok: true, results }))
+            .catch(e => jsonResp(res, { ok: false, error: e.message }, 500));
+        return;
+    }
+
+    // ── /turbo/search-embed?q=TITLE ──────────────────────────────────────────
+    if (pathname === '/turbo/search-embed') {
+        const q = query.q || '';
+        if (!q) { jsonResp(res, { ok: false, error: 'no query' }, 400); return; }
+        const { parseObrutEmbed, buildSerialFromEntries, extractMovieVoices, getKinojumpHtml } = require('./turbo');
+        (async () => {
+            // Step 1: search kinojump
+            const results = await turboSearch(q);
+            if (!results.length) throw new Error('not found on kinojump');
+            const pageUrl = results[0].url;
+            console.log('[turbo/search-embed] page:', pageUrl);
+
+            // Step 2: get embed URL — plain HTTP first, Puppeteer fallback
+            const { getBrowser } = require('./alloha');
+            const browser = await getBrowser();
+            const pageHtml = await getKinojumpHtml(pageUrl, browser).catch(e => {
+                console.log('[turbo/search-embed] getKinojumpHtml error:', e.message);
+                return '';
+            });
+            const em = pageHtml.match(/(?:https?:\/\/)?(?:([a-z0-9]+)\.)?obrut\.show\/embed\/([A-Za-z0-9]+)\/content\/([A-Za-z0-9]+)/);
+            if (!em) throw new Error('obrut embed URL not found');
+            const subdomain = em[1] ? em[1] + '.obrut.show' : '49372504.obrut.show';
+            const embedUrl = 'https://' + subdomain + '/embed/' + em[2] + '/content/' + em[3];
+            console.log('[turbo/search-embed] embed URL:', embedUrl);
+            // Step 3: parse embed (retry until enough entries)
+            const result = await parseObrutEmbed(embedUrl);
+            if (!result) throw new Error('failed to parse obrut embed');
+
+            if (result.entries.length > 0) {
+                const serial = buildSerialFromEntries(result.entries);
+                jsonResp(res, { ok: true, embed_url: embedUrl, content_type: 'serial', serial });
+            } else if (result.movieVoices.length > 0) {
+                jsonResp(res, { ok: true, embed_url: embedUrl, content_type: 'movie', voices: result.movieVoices });
+            } else {
+                throw new Error('no data found in obrut embed');
+            }
+        })().catch(e => { console.log('[turbo/search-embed] error:', e.message); jsonResp(res, { ok: false, error: e.message }, 500); });
+        return;
+    }
+
+    // ── /turbo/stream?url=PAGE_URL ────────────────────────────────────────────
+    if (pathname === '/turbo/stream') {
+        const pageUrl = query.url;
+        if (!pageUrl) { jsonResp(res, { ok: false, error: 'no url' }, 400); return; }
+        getTurboStream(pageUrl)
+            .then(data => jsonResp(res, { ok: true, ...data }))
+            .catch(e => { console.log('[turbo] error:', e.message); jsonResp(res, { ok: false, error: e.message }, 500); });
+        return;
+    }
+
+    // ── /turbo/proxy-embed?url=OBRUT_EMBED_URL ───────────────────────────────
+    // Raw HTTP proxy for obrut embed — adds correct Referer header
+    // Used by browser clients that can't set Referer (file:/// origin)
+    if (pathname === '/turbo/proxy-embed') {
+        const embedUrl = query.url;
+        if (!embedUrl || !embedUrl.includes('obrut.show')) {
+            jsonResp(res, { ok: false, error: 'invalid url' }, 400); return;
+        }
+        (async () => {
+            const html = await fetchRaw(embedUrl, {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'referer': 'https://kinojump.com/',
+                'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'accept-language': 'ru-RU,ru;q=0.9,en;q=0.8',
+                'accept-encoding': 'identity',
+            });
+            console.log('[turbo/proxy-embed] len:', html.length, 'hasPlayer:', html.includes('new Player('));
+            res.writeHead(200, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Headers': '*',
+                'Content-Type': 'text/html; charset=utf-8',
+            });
+            res.end(html);
+        })().catch(e => {
+            console.log('[turbo/proxy-embed] error:', e.message);
+            res.writeHead(500, { 'Access-Control-Allow-Origin': '*' });
+            res.end('error: ' + e.message);
+        });
+        return;
+    }
+
+    // ── /turbo/embed?url=OBRUT_EMBED_URL ─────────────────────────────────────
+    // Parse obrut embed page directly (no Puppeteer needed)
+    if (pathname === '/turbo/embed') {
+        const embedUrl = query.url;
+        if (!embedUrl) { jsonResp(res, { ok: false, error: 'no url' }, 400); return; }
+        const { parseObrutEmbed, buildSerialFromEntries } = require('./turbo');
+        parseObrutEmbed(embedUrl)
+            .then(result => {
+                if (!result || (result.entries.length === 0 && result.movieVoices.length === 0)) {
+                    jsonResp(res, { ok: false, error: 'failed to parse embed' }); return;
+                }
+                if (result.entries.length > 0) {
+                    const serial = buildSerialFromEntries(result.entries);
+                    jsonResp(res, { ok: true, embed_url: embedUrl, content_type: 'serial', serial, entry_count: result.entries.length });
+                } else {
+                    jsonResp(res, { ok: true, embed_url: embedUrl, content_type: 'movie', voices: result.movieVoices });
+                }
+            })
+            .catch(e => { console.log('[turbo/embed] error:', e.message); jsonResp(res, { ok: false, error: e.message }, 500); });
+        return;
+    }
+
+    // ── /uakinogo/stream?url=PAGE_URL ─────────────────────────────────────────
+    if (pathname === '/uakinogo/stream') {
+        const pageUrl = query.url;
+        if (!pageUrl) { jsonResp(res, { ok: false, error: 'no url' }, 400); return; }
+        getCinemarStream(pageUrl)
+            .then(data => jsonResp(res, { ok: true, ...data }))
+            .catch(e => { console.log('[cinemar] error:', e.message); jsonResp(res, { ok: false, error: e.message }, 500); });
+        return;
+    }
+
+    // ── /puppeteer/fetch?url=URL — fetch URL via Puppeteer (bypasses Cloudflare JS challenge)
+    if (pathname === '/puppeteer/fetch') {
+        const targetUrl = query.url;
+        if (!targetUrl) { jsonResp(res, { ok: false, error: 'no url' }, 400); return; }
+        (async () => {
+            let browser;
+            try {
+                const { getBrowser } = require('./alloha');
+                browser = await getBrowser();
+                const page = await browser.newPage();
+                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' });
+                // Navigate and wait for JS challenge to complete
+                await page.goto(targetUrl, { waitUntil: 'networkidle2', timeout: 20000 });
+                // Extra wait for fingerprint redirect
+                await new Promise(r => setTimeout(r, 2500));
+                const html = await page.content();
+                const finalUrl = page.url();
+                await page.close();
+                jsonResp(res, { ok: true, html, url: finalUrl });
+            } catch(e) {
+                console.log('[puppeteer/fetch] error:', e.message);
+                jsonResp(res, { ok: false, error: e.message }, 500);
+            }
+        })();
+        return;
+    }
+
+    jsonResp(res, { ok: false, error: 'not found' }, 404);
+});
+
+server.listen(PORT, () => console.log(`[server] Alloha+Cinemar proxy on port ${PORT}`));
+
+process.on('SIGTERM', async () => { await closeBrowser(); server.close(); });
+process.on('SIGINT', async () => { await closeBrowser(); process.exit(0); });

turbo.js

@@ -0,0 +1,479 @@
+/**
+ * Turbo (obrut.show) stream extractor
+ * Flow: embed URL → fetch HTML → parse Player() base64 → extract entries via regex
+ */
+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); }
+        const mod = u.protocol === 'https:' ? https : http;
+        const req = mod.request({
+            hostname: u.hostname, path: u.pathname + u.search,
+            headers: headers || {}
+        }, res => {
+            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
+                loc = loc.replace('web.kinojump.com', 'kinojump.com');
+                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);
+        });
+        req.on('error', reject);
+        req.setTimeout(15000, () => { 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',
+        'referer': 'https://web.kinojump.com/'
+    });
+    const results = [];
+    const re = /href="(https?:\/\/(?:web\.)?kinojump\.com\/(\d+)-([^"]+)\.html)"/g;
+    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] });
+        }
+    }
+    return results.slice(0, 10);
+}
+
+// ── Get kinojump page HTML — try plain HTTP first, then Puppeteer ────────────
+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 {
+            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',
+                'cookie': 'PHPSESSID=a1b2c3d4e5f6; dle_user_id=0; dle_password=0'
+            });
+            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');
+            }
+            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;
+    }
+
+    // Fallback: Puppeteer — intercept network requests to catch obrut embed URL
+    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' });
+
+        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));
+            }
+            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 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;
+        }
+
+        const finalHtml = await page.content();
+        console.log('[turbo] Puppeteer final HTML len:', finalHtml.length, 'has embed:', finalHtml.includes('obrut.show/embed/'));
+        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.
+
+function getCleanText(raw) {
+    const eyJIdx = raw.indexOf('eyJ');
+    const b64 = eyJIdx > 0 ? raw.substring(eyJIdx) : raw;
+    const decoded = Buffer.from(b64, 'base64').toString('utf8');
+    for (let i = 0; i < decoded.length; i++) {
+        const code = decoded.charCodeAt(i);
+        if (code > 127 || (code < 32 && code !== 9 && code !== 10 && code !== 13)) {
+            return decoded.substring(0, i);
+        }
+    }
+    return decoded;
+}
+
+function parseFileStr(fileStr) {
+    const streams = [];
+    const re = /\[(\w+)\](https?:\/\/[^,\[]+)/g;
+    let m;
+    while ((m = re.exec(fileStr)) !== null) streams.push({ quality: m[1], url: m[2].trim() });
+    return streams;
+}
+
+function extractEntries(text) {
+    // Serial: t1 is non-empty like "S01E01 - Title"
+    const re = /"title":"([^"]+)","t1":"([^"]+)","poster":"[^"]*","file":"((?:\[\w+\]https?:\\\/\\\/[^"]+))"/g;
+    const entries = [];
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        if (!m[2]) continue;
+        const fileStr = m[3].replace(/\\\//g, '/');
+        const streams = parseFileStr(fileStr);
+        if (streams.length > 0) entries.push({ voice: m[1], episode: m[2], streams });
+    }
+    return entries;
+}
+
+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 streams = parseFileStr(fileStr);
+        if (streams.length > 0) voices.push({ label: m[1], url: streams[0].url, qualities: streams, subtitles: [] });
+    }
+    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');
+                }
+            }
+        } finally {
+            await page.close();
+        }
+    }
+
+    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'
+            }).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;
+                }
+                const text = getCleanText(pm[1]);
+                return { entries: extractEntries(text), movieVoices: extractMovieVoices(text) };
+            }).catch(() => null)
+        );
+
+        const results = await Promise.all(promises);
+        
+        for (const r of results) {
+            if (!r) continue;
+            for (const e of r.entries) {
+                const key = e.voice + '|' + e.episode;
+                if (!mergedEntries.has(key)) mergedEntries.set(key, e);
+            }
+            for (const v of r.movieVoices) {
+                if (!mergedVoices.has(v.label)) mergedVoices.set(v.label, v);
+            }
+        }
+
+        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
+        if (v >= 5) break;
+    }
+
+    const entries = Array.from(mergedEntries.values());
+    const movieVoices = Array.from(mergedVoices.values());
+    
+    if (entries.length === 0 && movieVoices.length === 0) return null;
+    return { entries, movieVoices };
+}
+
+// ── Build serial structure from entries ──────────────────────────────────────
+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);
+        const eNum = parseInt(seMatch[2], 10);
+        const sKey = 's' + String(sNum).padStart(2, '0');
+        const eKey = 'e' + String(eNum).padStart(2, '0');
+        if (!seasonMap[sKey]) seasonMap[sKey] = {};
+        if (!seasonMap[sKey][eKey]) seasonMap[sKey][eKey] = [];
+        seasonMap[sKey][eKey].push({ label: e.voice, streams: e.streams, url: e.streams[0] ? e.streams[0].url : '' });
+    }
+
+    const seasons = Object.keys(seasonMap).sort().map(sk => ({ id: sk, title: 'Season ' + parseInt(sk.slice(1), 10) }));
+    const episodes = {};
+    const voices = {};
+    for (const sk of Object.keys(seasonMap)) {
+        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: []
+            }));
+        }
+    }
+
+    return { seasons, episodes, voices };
+}
+
+// ── Main: get stream for a kinojump page URL ──────────────────────────────────
+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);
+    if (!result) throw new Error('failed to extract data from obrut embed');
+
+    const hasSerial = result.entries.length > 0;
+    const hasMovie = result.movieVoices.length > 0;
+
+    if (hasSerial) {
+        const serial = buildSerialFromEntries(result.entries);
+        console.log('[turbo] serial:', serial.seasons.length, 'seasons');
+        return { embed_url: embedUrl, content_type: 'serial', serial };
+    } else if (hasMovie) {
+        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');
+    }
+}
+
+module.exports = { turboSearch, getTurboStream, parseObrutEmbed, extractEntries, extractMovieVoices, buildSerialFromEntries, getKinojumpHtml };