Update index.js

index.js

@@ -1,670 +1,202 @@
-'use strict';
-
 const express = require('express');
-const fetch   = require('node-fetch');
-const AdmZip  = require('adm-zip');
-const app     = express();
-const PORT    = process.env.PORT || 7860;
+const fetch = require('node-fetch');
 
-const BASE_URL = process.env.SPACE_HOST
-  ? `https://${process.env.SPACE_HOST}`
-  : `http://localhost:${PORT}`;
+const app = express();
+const PORT = process.env.PORT || 7860;
 
 app.use((req, res, next) => {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  res.header('Access-Control-Allow-Origin', '*');
+  res.header('Access-Control-Allow-Headers', '*');
+  res.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
   if (req.method === 'OPTIONS') return res.sendStatus(200);
   next();
 });
 
-const SUBDL_KEY = process.env.SUBDL_KEY || 'subdl_TsxunQv1rWjwCiXQqDC_lpBPF5QtwoFH2Vbae0zvKqI';
-const TMDB_KEY  = process.env.TMDB_KEY  || '83d364331c40bfbe29858aeed82f45cc';
-
-app.get('/', (req, res) => res.send('Van Subs v19 ✅ Online'));
-
-app.get('/manifest.json', (req, res) => res.json({
-  id:          'org.van.humansubtitles',
-  name:        'VanSubs+',
-  description: 'Human-Verified Arabic & English Subtitles. Anti-AI. Format-first sync.',
-  version:     '19.0.0',
-  resources:   ['subtitles'],
-  types:       ['movie', 'series'],
-  idPrefixes:  ['tt'],
-  catalogs:    []
-}));
-
-app.get('/subtitles/:type/:id.json',        (req, res) => handleRequest(req, res));
-app.get('/subtitles/:type/:id/:extra.json', (req, res) => handleRequest(req, res));
-
-app.get('/health', (req, res) => res.json({
-  status:   'ok',
-  version:  '19.0.0',
-  cache:    cache.size,
-  zips:     subStore.size,
-  uptime:   Math.floor(process.uptime()) + 's',
-  base_url: BASE_URL
-}));
-
-// ─── Cache ────────────────────────────────────────────────────────────────────
-const cache = new Map();
-const TTL_MOVIE   = 7 * 24 * 60 * 60 * 1000;
-const TTL_EPISODE = 8 * 60 * 60 * 1000;
-
-function getTTL(type) { return type === 'series' ? TTL_EPISODE : TTL_MOVIE; }
-function cacheKey(imdbId, type, season, episode) {
-  return `${imdbId}|${type}|${season ?? 'x'}|${episode ?? 'x'}`;
-}
-
-setInterval(() => {
-  const now = Date.now(); let n = 0;
-  for (const [k, v] of cache.entries()) { if (now - v.ts > v.ttl) { cache.delete(k); n++; } }
-  if (n > 0) console.log(`[Cache] Evicted ${n} stale entries`);
-}, 15 * 60 * 1000);
-
-// ─── ZIP store ────────────────────────────────────────────────────────────────
-const subStore = new Map();
-let   subSeq   = 0;
+const UPSTREAM_URLS = [
+  'https://torrentio.strem.fun',
+  'https://torrentio.stremio.my.id'
+];
 
-setInterval(() => {
-  if (subStore.size > 500) {
-    const keys = [...subStore.keys()].slice(0, 250);
-    keys.forEach(k => subStore.delete(k));
-    console.log('[ZipStore] Flushed 250 old entries');
-  }
-}, 30 * 60 * 1000);
+const MIN_SEEDERS = 1;
+const ALLOWED_QUALITIES = ['480p', '576p', '720p', '1080p', 'webrip', 'webdl', 'bluray'];
+const MAX_SIZE_GB_MOVIE = 4;
+const MAX_SIZE_GB_SERIES = 1.5;
+
+const SOURCE_CONFIG = [
+  { name: 'yts', display: 'YTS', order: 1 },
+  { name: 'yify', display: 'YTS', order: 1 },
+  { name: 'eztv', display: 'EZTV', order: 2 },
+  { name: 'nyaasi', display: 'Nyaa', order: 3 },
+  { name: 'thepiratebay', display: 'TPB', order: 4 },
+  { name: 'piratebay', display: 'TPB', order: 4 },
+  { name: 'the piratebay', display: 'TPB', order: 4 },
+  { name: 'tpb', display: 'TPB', order: 4 },
+  { name: '1337x', display: '1337x', order: 5 },
+  { name: 'torrentgalaxy', display: 'TGx', order: 6 },
+  { name: 'rarbg', display: 'RARBG', order: 7 },
+  { name: 'rutor', display: 'Rutor', order: 8 },
+  { name: 'rutracker', display: 'Rutracker', order: 9 }
+];
 
-// ---------------------------------------------------------------------------
-// Extract episode number from a filename (SxxExx → number, else null)
-// ---------------------------------------------------------------------------
-function episodeFromFilename(filename) {
-  if (!filename) return null;
-  const n = filename.toLowerCase();
-  const m1 = n.match(/s\d{1,2}e(\d{1,3})/);
-  if (m1) return parseInt(m1[1], 10);
-  const m2 = n.match(/[._\-\s]e(\d{1,3})[._\-\s]/);
-  if (m2) return parseInt(m2[1], 10);
+const QUALITY_RANK = {
+  '1080p': 1,
+  '720p': 2,
+  'webdl': 3,
+  'webrip': 4,
+  '576p': 5,
+  '480p': 6,
+  'bluray': 7
+};
+
+const LINKS_PER_QUALITY = 5;
+
+function getQuality(title = '') {
+  const lower = title.toLowerCase();
+  if (lower.includes('1080p')) return '1080p';
+  if (lower.includes('720p')) return '720p';
+  if (lower.includes('480p')) return '480p';
+  if (lower.includes('576p')) return '576p';
+  if (lower.includes('webrip')) return 'webrip';
+  if (lower.includes('webdl') || lower.includes('web-dl')) return 'webdl';
+  if (lower.includes('bluray')) return 'bluray';
   return null;
 }
 
-// ---------------------------------------------------------------------------
-// Pick best file from ZIP — prefers exact episode match for series
-// ---------------------------------------------------------------------------
-function pickFileFromZip(zip, lang, season, episode) {
-  const entries = zip.getEntries()
-    .filter(e => !e.isDirectory)
-    .filter(e => /\.(srt|ass|ssa|vtt)$/i.test(e.entryName));
-  if (!entries.length) return null;
-
-  if (season != null && episode != null) {
-    const target = `s${String(season).padStart(2,'0')}e${String(episode).padStart(2,'0')}`;
-    const exact  = entries.find(e => e.entryName.toLowerCase().includes(target));
-    if (exact) return exact;
-    const loose = `s${season}e${episode}`;
-    if (loose !== target) {
-      const looseMatch = entries.find(e => e.entryName.toLowerCase().includes(loose));
-      if (looseMatch) return looseMatch;
-    }
-  }
-
-  const hints = lang === 'Arabic'
-    ? ['arabic', 'arab', '.ar.', '_ar_', '.ara.', '_ara_', 'ar.srt', 'ar.ass']
-    : ['english', 'eng', '.en.', '_en_', '.eng.', '_eng_', 'en.srt', 'en.ass'];
-
-  const hinted = entries.find(e => hints.some(h => e.entryName.toLowerCase().includes(h)));
-  if (hinted) return hinted;
-  if (entries.length === 1) return entries[0];
-
-  return [...entries].sort((a, b) =>
-    lang === 'Arabic' ? a.header.size - b.header.size : b.header.size - a.header.size
-  )[0];
+function getSeeders(stream) {
+  if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
+  const match = stream.title?.match(/👤\s*(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
 }
 
-// ---------------------------------------------------------------------------
-// Resolve a subdl URL (direct or ZIP). Retries once on AbortError.
-// Timeout raised to 12 s.
-// ---------------------------------------------------------------------------
-async function resolveUrl(rawUrl, lang, season, episode) {
-  if (/\.(srt|ass|ssa|vtt)(\?|$)/i.test(rawUrl)) {
-    return { url: rawUrl, extractedName: null };
-  }
-  for (let attempt = 1; attempt <= 2; attempt++) {
-    try {
-      const r = await timedFetch(rawUrl, {}, 12000);
-      if (!r.ok) { console.error(`[ZIP] HTTP ${r.status}`); return null; }
-      const zip  = new AdmZip(await r.buffer());
-      const best = pickFileFromZip(zip, lang, season, episode);
-      if (!best) return null;
-      const ext = best.entryName.split('.').pop().toLowerCase();
-      const id  = `s${++subSeq}`;
-      subStore.set(id, { buffer: best.getData(), ext });
-      const publicUrl = `${BASE_URL}/sub/${id}.${ext}`;
-      console.log(`[ZIP] "${best.entryName}" (${best.header.size}B) lang=${lang} → /sub/${id}`);
-      return { url: publicUrl, extractedName: best.entryName };
-    } catch (e) {
-      if (attempt < 2 && e.name === 'AbortError') {
-        console.log(`[ZIP] AbortError attempt ${attempt}, retrying in 500ms...`);
-        await new Promise(res => setTimeout(res, 500));
-      } else {
-        console.error(`[ZIP] error (attempt ${attempt}):`, e.message);
-        return null;
-      }
-    }
-  }
+function getSizeInGB(stream) {
+  const title = stream.title || '';
+  const sizeMatch = title.match(/💾\s*([\d.]+)\s*(GB|MB)/i) || 
+                    title.match(/([\d.]+)\s*(GB|MB)/i);
+  if (!sizeMatch) return null;
+  
+  const value = parseFloat(sizeMatch[1]);
+  const unit = sizeMatch[2].toUpperCase();
+  
+  if (unit === 'GB') return value;
+  if (unit === 'MB') return value / 1024;
   return null;
 }
 
-// ---------------------------------------------------------------------------
-// Concurrency-limited pool resolver — max `limit` parallel ZIP downloads.
-// Prevents the cascade of AbortErrors when many ZIPs fire simultaneously.
-// ---------------------------------------------------------------------------
-async function resolvePool(pool, limit, season, episode) {
-  const results = new Array(pool.length).fill(null);
-  let idx = 0;
-  async function worker() {
-    while (true) {
-      const i = idx++;
-      if (i >= pool.length) break;
-      const s      = pool[i];
-      const result = await resolveUrl(s.url, s.lang, season, episode);
-      if (result) {
-        results[i] = { ...s, url: result.url, filename: result.extractedName || s.filename };
-      }
-    }
+function detectSource(title = '') {
+  const lower = title.toLowerCase();
+  for (const src of SOURCE_CONFIG) {
+    if (lower.includes(src.name)) return src.name;
   }
-  await Promise.all(Array.from({ length: Math.min(limit, pool.length) }, () => worker()));
-  return results.filter(Boolean);
-}
-
-// ─── Subtitle serving ─────────────────────────────────────────────────────────
-app.get('/sub/:id', (req, res) => {
-  const id   = req.params.id.replace(/\.[^.]+$/, '');
-  const item = subStore.get(id);
-  if (!item) return res.status(404).send('Not found');
-  const mime = item.ext === 'vtt' ? 'text/vtt' : 'text/plain';
-  res.setHeader('Content-Type', `${mime}; charset=utf-8`);
-  res.setHeader('Content-Disposition', `inline; filename="sub.${item.ext}"`);
-  res.send(item.buffer);
-});
-
-// ─── Language resolution ──────────────────────────────────────────────────────
-const ARABIC_CODES  = new Set(['ar', 'ara', 'arabic']);
-const ENGLISH_CODES = new Set(['en', 'eng', 'english']);
-
-function resolveLanguage(code) {
-  const c = (code || '').toLowerCase().trim();
-  if (ARABIC_CODES.has(c))  return 'Arabic';
-  if (ENGLISH_CODES.has(c)) return 'English';
   return null;
 }
 
-// ─── Filters ──────────────────────────────────────────────────────────────────
-const FOREIGN_SIGNALS = [
-  'spanish','español','espanol','latino','castellano','.es.','_es_','.spa.','_spa_','.lat.','_lat_','[lat]','(lat)',
-  'french','français','francais','.fr.','_fr_','.fre.','_fre_',
-  'portuguese','português','brazil','brasil','.pt.','_pt.','.por.','_por.','.br.','_br_',
-  'german','deutsch','.de.','_de_','.ger.','_ger_',
-  'italian','italiano','.it.','_it_','.ita.','_ita_',
-  'dutch','nederlands','.nl.','_nl.','.dut.','_dut_','[nl]',
-  'turkish','türkçe','.tr.','_tr_','.tur.','_tur_',
-  'russian','.ru.','_ru_','.rus.','_rus_',
-  'chinese','.zh.','_zh_','korean','.ko.','_ko_','hindi','.hi.','_hi_',
-];
-
-function isForeignFilename(filename, lang) {
-  if (lang === 'Arabic') return false;
-  const n = (filename || '').toLowerCase();
-  return FOREIGN_SIGNALS.some(s => n.includes(s));
-}
-
-const AI_GARBAGE = [
-  'ai-translated','machine translation','chatgpt','translated from','auto-translated',
-  'google translate','deepl','whisper','ai generated','machine-translated','openai',
-  'gpt-4','gpt4','auto translate','ai.translated','aitranslated','autotranslated',
-  'machine.translation','subscene-ai','opensubtitles-bot','mtranslated','mt.translated',
-  'ai_translated','translated.by.ai','translated_by_ai',
-];
-
-function isHumanVerified(filename) {
-  const n = (filename || '').toLowerCase();
-  return !AI_GARBAGE.some(f => n.includes(f));
-}
-
-// Filters forced tracks, commentary, audio-description.
-// These are NOT regular subtitle tracks and should never appear in results.
-const USELESS_SIGNALS = [
-  '.forced.', '.forced_', '_forced.', '[forced]', '(forced)',
-  'en.forced', 'ar.forced', 'fr.forced', 'forced.srt', 'forced.ass',
-  'commentary',
-  'audio.description', 'audio description',
-];
-
-function isUsableSubtitle(filename) {
-  const n = (filename || '').toLowerCase();
-  return !USELESS_SIGNALS.some(f => n.includes(f));
-}
-
-// ─── Scoring tables ───────────────────────────────────────────────────────────
-
-// Release groups — low weight signal
-const SCENE_GROUPS = [
-  'qxr','psa','galaxyrg','ntb','deflate','epsilon','tigole','framestor',
-  'yts','yify','rarbg','fgt','amzn','flux','cm','tepes','heve','evo','ion10','glhf'
-];
-
-// Source format tiers for tier-match / tier-mismatch logic
-const SOURCE_TIERS = [
-  { tags: ['bluray','blu-ray','bdrip','bdremux','remux'], tier: 'bluray', pts: 80 },
-  { tags: ['webdl','web-dl','webrip','web-rip'],          tier: 'web',    pts: 70 },
-  { tags: ['hdtv','amzn','atvp','dsnp','nf','hulu'],      tier: 'hdtv',   pts: 50 },
-  { tags: ['dvdrip','hdrip','dvd'],                        tier: 'dvd',    pts: 25 },
-];
-
-const CODEC_TAGS   = ['x265','x264','hevc','h265','h264','10bit','10-bit','hdr','hdr10','dv','dolbyvision','2160p','4k','uhd','1080p','1080','720p'];
-const AUDIO_TAGS   = ['truehd.atmos','truehd','atmos','ddp5.1','ddp5','ddp','dts-hd','dts.hd','dts','ac3','aac','eac3'];
-
-// NOTE: 'remux' removed from SYNC_BOOST — it describes video container quality,
-// not subtitle sync quality. Its presence was unfairly boosting BluRay Remux subs.
-const SYNC_BOOST   = ['sync','synced','corrected','fixed','updated','proper','repack','retail','bd.sync','bluray.sync'];
-const SYNC_PENALTY = ['unsynced','unsync','rough','workprint','not.synced','not_synced','notsynced','raw.sub','raw_sub'];
-
-function normalizeRelease(name) {
-  if (!name) return [];
-  return name.toLowerCase()
-    .replace(/\[.*?\]/g, ' ').replace(/\(.*?\)/g, ' ')
-    .replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).filter(t => t.length > 1);
-}
-
-function detectTier(text) {
-  if (!text) return null;
-  const n = text.toLowerCase();
-  for (const entry of SOURCE_TIERS) {
-    if (entry.tags.some(t => n.includes(t))) return { tier: entry.tier, pts: entry.pts };
-  }
-  return null;
+function getSourceOrder(sourceName) {
+  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
+  return config ? config.order : 999;
+}
+
+function filterStream(stream, type = 'movie') {
+  const title = stream.title || '';
+  if (!stream.url && !stream.infoHash) return false;
+  
+  const quality = getQuality(title);
+  if (!ALLOWED_QUALITIES.includes(quality)) return false;
+  
+  if (getSeeders(stream) < MIN_SEEDERS) return false;
+  
+  if (!detectSource(title)) return false;
+  
+  const maxSize = type === 'series' ? MAX_SIZE_GB_SERIES : MAX_SIZE_GB_MOVIE;
+  const sizeGB = getSizeInGB(stream);
+  if (sizeGB !== null && sizeGB > maxSize) return false;
+  
+  return true;
 }
 
-// ---------------------------------------------------------------------------
-// scoreTrack — V19
-//
-// SubDL does NOT return a `rating` field so ratings are permanently 0.
-// All scoring is based on filename signals.
-//
-// Scoring priority (highest → lowest):
-//   1.  Episode exact match          +500   hard requirement for series
-//   2.  Downloads popularity         0–60   if SubDL returns the field
-//   3.  Source format tier                  match/mismatch vs stream hint
-//        hasHint + same tier         +pts×2
-//        hasHint + different tier    -200   overwhelms codec tag bias
-//        no hint + web tier          +pts+40
-//        no hint + other tier        +pts
-//   4.  Codec / resolution tags             small additive (mult halved when no hint)
-//   5.  Audio tags                          small additive
-//   6.  Sync quality signals               ±30 / ±60
-//   7.  Release group                       very low weight
-//   8.  No-hint popularity boosts:
-//         YTS/YIFY                   +100   dominant torrent source
-//         RARBG                      +40
-//         WEBRip                     +20
-//         1080p                      +40    most common stream resolution
-//         UHD/4K/2160p               -80    rarely syncs with 1080p streams
-//         Streaming services         +25    WAVO/OSN/Shahid/AMZN/NFLX/HMAX
-//         MAX/HBO Max (word-safe)    +25
-//   9.  SDH                          -30    mild penalty
-// ---------------------------------------------------------------------------
-function scoreTrack(subFilename, streamTitle, rating = 0, season = null, episode = null, downloads = 0) {
-  if (!subFilename) return 0;
-  const n          = subFilename.toLowerCase();
-  const subTokens  = normalizeRelease(subFilename);
-  const strmTokens = normalizeRelease(streamTitle || '');
-
-  // hasHint = true only if the stream title contains a recognisable quality tier.
-  // Empty titles and plain episode filenames ("Shingeki.S02E09.mkv") have no tier.
-  const strmTier = detectTier(streamTitle || '');
-  const hasHint  = !!strmTier;
-
-  let s = 0;
-
-  // Hard-drop safety net (belt-and-suspenders; filter already removes these)
-  if (n.includes('.forced.') || n.includes('commentary')) return -9999;
-
-  // 1. Episode exact match
-  if (season != null && episode != null) {
-    const pat = `s${String(season).padStart(2,'0')}e${String(episode).padStart(2,'0')}`;
-    if (n.includes(pat)) s += 500;
-    else {
-      const loose = `s${season}e${episode}`;
-      if (loose !== pat && n.includes(loose)) s += 500;
-    }
-  }
-
-  // 2. Rating (SubDL currently returns 0, kept for future API changes)
-  if (rating > 0) s += Math.round(rating * 18);
-
-  // 2b. Downloads — popularity signal capped at +60 to avoid dominance
-  //     Formula: min(downloads, 1000) × 0.06 → max 60pts at 1000 downloads
-  if (downloads > 0) s += Math.min(Math.round(downloads * 0.06), 60);
-
-  // 3. Source format tier — match/mismatch vs stream hint
-  const subTier = detectTier(n);
-  if (subTier) {
-    if (hasHint) {
-      // We know stream quality: reward exact match, penalise mismatch.
-      // Penalty -200 is large enough to overcome codec tag accumulation.
-      if (subTier.tier === strmTier.tier) s += subTier.pts * 2;
-      else                                s -= 200;
-    } else {
-      // No stream quality hint: WEB is the safest universal default.
-      if (subTier.tier === 'web') s += subTier.pts + 40;
-      else                        s += subTier.pts;
-    }
-  }
-
-  // 4. Codec / resolution tags
-  // No-hint multiplier is 2 (was 6) — prevents UHD titles monopolising via tag count.
-  const codecMult = hasHint ? 6 : 2;
-  CODEC_TAGS.forEach((t, i) => { if (n.includes(t)) s += (CODEC_TAGS.length - i) * codecMult; });
-
-  // 5. Audio tags
-  const audioMult = hasHint ? 5 : 2;
-  AUDIO_TAGS.forEach((t, i) => { if (n.includes(t)) s += (AUDIO_TAGS.length - i) * audioMult; });
-
-  // 6. Sync quality signals
-  SYNC_BOOST.forEach(  b => { if (n.includes(b)) s += 30; });
-  SYNC_PENALTY.forEach(p => { if (n.includes(p)) s -= 60; });
-
-  // 7. Release group — lowest weight
-  for (const g of SCENE_GROUPS) {
-    const inSub  = subTokens.includes(g);
-    const inStrm = strmTokens.includes(g);
-    if (inSub && inStrm) s += 15;
-    else if (inSub)      s += 5;
-  }
-
-  // 8. No-hint popularity & resolution adjustments
-  //    Only applied when we cannot detect what the user is actually streaming.
-  if (!hasHint) {
-    // YTS/YIFY: the single most common torrent stream source — most universally compatible
-    if (['yts', 'yify'].some(g => subTokens.includes(g))) {
-      s += 100;
-    } else if (subTokens.includes('rarbg')) {
-      s += 40;
-    }
-
-    // WEBRip: very common stream format, extra nudge on top of web tier
-    if (n.includes('webrip') || n.includes('web-rip')) s += 20;
-
-    // 1080p: most common streaming resolution — preferred over 4K or 720p
-    if (n.includes('1080p')) s += 40;
-
-    // UHD/4K penalty: a 4K subtitle will almost never sync with a 1080p stream.
-    // When there is no hint we must assume the common case (1080p WEB/YTS).
-    if (n.includes('2160p') ||
-        /[.\s\-_]uhd[.\s\-_]/.test(n) ||
-        /[.\s\-_]4k[.\s\-_]/.test(n)) {
-      s -= 80;
-    }
-
-    // Streaming-service subs (WAVO, OSN, Shahid, AMZN, NF, HMAX) tend to sync
-    // well against whatever version most people stream online.
-    const STREAM_SVCS = ['wavo', 'osn', 'shahid', 'amzn', 'nflx', 'hmax', 'amazon'];
-    if (STREAM_SVCS.some(sv => n.includes(sv))) s += 25;
-
-    // MAX / HBO Max — word-boundary safe (avoids matching "maximum", "climax", etc.)
-    if (/[.\-_]max[.\-_]/.test(n) || n.endsWith('.max')) s += 25;
+async function fetchUpstream(type, id) {
+  for (const baseUrl of UPSTREAM_URLS) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 8000);
+      const res = await fetch(`${baseUrl}/stream/${type}/${id}.json`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (res.ok) {
+        const data = await res.json();
+        if (data.streams?.length) return data.streams;
+      }
+    } catch (e) {}
   }
-
-  // 9. SDH mild penalty — sound-effect descriptions are noise for most viewers
-  if (n.includes('sdh') || n.includes('hearing.impaired')) s -= 30;
-
-  return s;
+  return [];
 }
 
-async function timedFetch(url, opts = {}, ms = 6000) {
-  const ctrl  = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), ms);
-  try   { return await fetch(url, { ...opts, signal: ctrl.signal }); }
-  finally { clearTimeout(timer); }
-}
-
-async function safeJson(r, tag) {
-  const text = await r.text();
-  try   { return JSON.parse(text); }
-  catch { console.error(`[${tag}] bad JSON:`, text.slice(0, 200)); return null; }
-}
-
-async function handleRequest(req, res) {
-  const { type } = req.params;
-  const rawId    = req.params.id.replace('.json', '');
-  const extra    = req.params.extra ? decodeURIComponent(req.params.extra.replace('.json','')) : '';
-  const parts    = rawId.split(':');
-  const imdbId   = parts[0];
-  const season   = parts[1] ? parseInt(parts[1]) : null;
-  const episode  = parts[2] ? parseInt(parts[2]) : null;
-
-  const filenameMatch = extra.match(/filename=([^&]+)/i);
-  const streamTitle   = filenameMatch ? decodeURIComponent(filenameMatch[1]) : '';
-
-  const hintTier = detectTier(streamTitle);
-
-  console.log(`\n╔═ [VanSubs v19] ${type.toUpperCase()} ${imdbId}` +
-    (season !== null ? ` S${String(season).padStart(2,'0')}E${String(episode??0).padStart(2,'0')}` : '') +
-    (streamTitle ? `\n║  hint: "${streamTitle}"` : '') +
-    (hintTier    ? ` [${hintTier.tier.toUpperCase()}]` : streamTitle ? ' [no-tier]' : ' [no-hint]'));
-
-  const ck  = cacheKey(imdbId, type, season, episode);
-  const hit = cache.get(ck);
-  if (hit && (Date.now() - hit.ts) < hit.ttl) {
-    console.log(`╚═ ✅ Cache hit — ${hit.subtitles.length} tracks`);
-    return res.json({ subtitles: hit.subtitles });
-  }
-
-  let rawTracks = [];
-  try { rawTracks = await fetchSubDL(imdbId, type, season, episode); }
-  catch (e) { console.error('║  [SubDL] FAILED:', e.message); }
-  console.log(`║  [SubDL] ${rawTracks.length} raw tracks`);
-
-  const seen    = new Set();
-  const deduped = rawTracks.filter(s => {
-    const key = (s.filename || '').toLowerCase().replace(/[\s.\-_]+/g, '.').replace(/\.(srt|ass|zip)$/, '');
-    if (seen.has(key)) return false;
-    seen.add(key); return true;
+function sortAndGroup(streams, type = 'movie') {
+  const filtered = streams.filter(s => filterStream(s, type));
+  
+  const byQuality = {};
+  filtered.forEach(stream => {
+    const quality = getQuality(stream.title);
+    if (!byQuality[quality]) byQuality[quality] = [];
+    byQuality[quality].push(stream);
   });
-
-  const clean = deduped.filter(s => {
-    if (!s.url) return false;
-    if (!isUsableSubtitle(s.filename)) { console.log(`║  [FORCED-DROP] "${s.filename}"`); return false; }
-    if (!isHumanVerified(s.filename))  { console.log(`║  [AI-DROP] "${s.filename}"`);     return false; }
-    if (isForeignFilename(s.filename, s.lang)) { console.log(`║  [FOREIGN-DROP] "${s.filename}"`); return false; }
-    return true;
+  
+  for (const quality in byQuality) {
+    byQuality[quality].sort((a, b) => {
+      const sourceA = detectSource(a.title);
+      const sourceB = detectSource(b.title);
+      const orderA = getSourceOrder(sourceA);
+      const orderB = getSourceOrder(sourceB);
+      if (orderA !== orderB) return orderA - orderB;
+      return getSeeders(b) - getSeeders(a);
+    });
+  }
+  
+  const result = [];
+  const sortedQualities = Object.keys(byQuality).sort((a, b) => {
+    const rankA = QUALITY_RANK[a] || 999;
+    const rankB = QUALITY_RANK[b] || 999;
+    return rankA - rankB;
   });
+  
+  sortedQualities.forEach(quality => {
+    const topLinks = byQuality[quality].slice(0, LINKS_PER_QUALITY);
+    result.push(...topLinks);
+  });
+  
+  return result;
+}
+
+app.get('/manifest.json', (req, res) => {
+  res.json({
+    id: 'org.ghostream.platinum',
+    name: 'Ghostream 🚀',
+    description: 'Stream Everything You Want\nMade With 🤍 By Van',
+    version: '7.3.0',
+    resources: ['stream'],
+    types: ['movie', 'series'],
+    idPrefixes: ['tt'],
+    catalogs: []
+  });
+});
 
-  // Phase 1 — pre-sort on release_name with V19 scoring
-  const scored = clean
-    .map(s => ({ ...s, score: scoreTrack(s.filename, streamTitle, s.rating, null, null, s.downloads) }))
-    .sort((a, b) => b.score - a.score);
-
-  // Take top 8 per language (up from 6) — wider candidate pool for ZIP extraction.
-  // The real filename inside a ZIP often has better tags than the SubDL release_name,
-  // so Phase 3 re-score can reorder them properly.
-  const arabic  = scored.filter(s => s.lang === 'Arabic').slice(0, 8);
-  const english = scored.filter(s => s.lang === 'English').slice(0, 8);
-  const pool    = [...arabic, ...english];
-
-  // Phase 2 — resolve URLs with concurrency limit (4 parallel max)
-  const resolved = await resolvePool(pool, 4, season, episode);
-
-  // Phase 3 — re-score on actual extracted filename + episode boost
-  const rescored = resolved
-    .map(s => ({
-      ...s,
-      finalScore: scoreTrack(s.filename, streamTitle, s.rating, season, episode, s.downloads)
-    }))
-    .sort((a, b) => b.finalScore - a.finalScore);
-
-  // Trim to top 4 per language after the decisive re-score
-  const arFinal = rescored.filter(s => s.lang === 'Arabic').slice(0, 4);
-  const enFinal = rescored.filter(s => s.lang === 'English').slice(0, 4);
-  const finalSorted = [...arFinal, ...enFinal];
-
-  const subtitles = finalSorted.map((s, i) => ({
-    id:   `van_${s.lang === 'Arabic' ? 'ar' : 'en'}_${imdbId}_${i}`,
-    url:  s.url,
-    lang: s.lang
-  }));
-
-  cache.set(ck, { subtitles, ts: Date.now(), ttl: getTTL(type) });
-
-  const ar = finalSorted.filter(s => s.lang === 'Arabic');
-  const en = finalSorted.filter(s => s.lang === 'English');
-  console.log(`║  ✅ ${subtitles.length} tracks (AR:${ar.length} EN:${en.length})`);
-  ar.forEach((s, i) => console.log(`║    AR[${i}] ${String(s.finalScore).padStart(4)}pt  dl=${s.downloads}  "${s.filename}"`));
-  en.forEach((s, i) => console.log(`║    EN[${i}] ${String(s.finalScore).padStart(4)}pt  dl=${s.downloads}  "${s.filename}"`));
-  console.log(`╚═ done`);
-
-  res.json({ subtitles });
-}
-
-// ─── SubDL API helpers ────────────────────────────────────────────────────────
-async function subDLRequestWithFallback(baseParams) {
-  let data = await subDLRequest(baseParams + '&type=tv');
-  if (data && data.length > 0) return data;
-  return await subDLRequest(baseParams);
-}
-
-async function subDLRequest(params) {
-  // subs_per_page raised to 50 (was 30) — wider candidate pool
-  const base = `https://api.subdl.com/api/v1/subtitles?api_key=${SUBDL_KEY}&languages=AR,EN&subs_per_page=50&releases=1`;
-  const url  = base + params;
-  const r    = await timedFetch(url, {}, 6000);
-  const data = await safeJson(r, 'SubDL');
-  if (!data?.status) { console.error('║  [SubDL] error:', data?.error); return []; }
-  return data.subtitles || [];
-}
-
-function parseSubDLResults(subs) {
-  // One-time field audit — helps diagnose future SubDL API changes.
-  // Will print once per request batch the first time results arrive.
-  if (subs.length > 0) {
-    const keys      = Object.keys(subs[0]);
-    const hasRating = keys.includes('rating') || keys.includes('rate');
-    const hasDl     = keys.includes('downloads') || keys.includes('download_count') || keys.includes('hits');
-    if (!hasRating) console.log(`║  [SubDL-fields] no rating field. available: ${keys.join(', ')}`);
-    if (hasDl)      console.log(`║  [SubDL-fields] download count field found`);
-  }
-
-  return subs.map(sub => {
-    const lang = resolveLanguage(sub.language);
-    if (!lang) return null;
-    let dlUrl = (sub.url || '').trim();
-    if (dlUrl && !dlUrl.startsWith('http')) dlUrl = 'https://dl.subdl.com' + dlUrl;
-    if (!dlUrl) return null;
-    return {
-      filename:    sub.release_name || sub.full_name || sub.name || 'SubDL Track',
-      url:         dlUrl,
-      lang,
-      rating:      parseFloat(sub.rating || sub.rate || 0) || 0,
-      downloads:   parseInt(sub.downloads || sub.download_count || sub.hits || 0, 10) || 0,
-      source:      'subdl',
-      season:      sub.season       ?? null,
-      episode:     sub.episode      ?? null,
-      episodeFrom: sub.episode_from ?? null,
-      episodeTo:   sub.episode_end  ?? null,
-      fullSeason:  sub.full_season  ?? false,
-    };
-  }).filter(Boolean);
-}
-
-function episodeFilter(s, targetSeason, targetEp, callSite) {
-  const seasonOk = !s.season || s.season === 0 || s.season === targetSeason;
-  if (!seasonOk) {
-    console.log(`║  [EP-FILTER] dropped wrong-season from ${callSite}: "${s.filename}"`);
-    return false;
-  }
-
-  if (s.episodeFrom > 0 && s.episodeTo > 0) {
-    const inRange = targetEp >= s.episodeFrom && targetEp <= s.episodeTo;
-    if (!inRange) console.log(`║  [EP-FILTER] dropped out-of-range from ${callSite}: "${s.filename}"`);
-    return inRange;
-  }
-
-  if (s.fullSeason) {
-    const fnEp = episodeFromFilename(s.filename);
-    if (fnEp !== null && fnEp !== targetEp) {
-      console.log(`║  [EP-FILTER] dropped wrong-episode (fullSeason, filename) from ${callSite}: "${s.filename}"`);
-      return false;
-    }
-    return true;
-  }
-
-  if (s.episode !== null && s.episode !== 0) {
-    const match = s.episode === targetEp;
-    if (!match) console.log(`║  [EP-FILTER] dropped wrong-episode from ${callSite}: "${s.filename}"`);
-    return match;
-  }
-
-  const fnEp = episodeFromFilename(s.filename);
-  if (fnEp !== null && fnEp !== targetEp) {
-    console.log(`║  [EP-FILTER] dropped wrong-episode (filename) from ${callSite}: "${s.filename}"`);
-    return false;
+app.get('/stream/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
+  try {
+    const streams = await fetchUpstream(type, id);
+    const sorted = sortAndGroup(streams, type);
+    res.json({ streams: sorted });
+  } catch (e) {
+    res.json({ streams: [] });
   }
+});
 
-  return true;
-}
-
-async function tmdbLookup(imdbId) {
+app.get('/debug/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
   try {
-    const r = await timedFetch(
-      `https://api.themoviedb.org/3/find/${imdbId}?api_key=${TMDB_KEY}&external_source=imdb_id&language=en`,
-      {}, 6000
-    );
-    if (!r || !r.ok) return null;
-    const data = await r.json();
-    const movie = data.movie_results?.[0];
-    const tv    = data.tv_results?.[0];
-    if (movie) return { title: movie.title || movie.original_title, year: (movie.release_date || '').slice(0, 4) };
-    if (tv)    return { title: tv.name     || tv.original_name,     year: (tv.first_air_date  || '').slice(0, 4) };
-    return null;
-  } catch (e) { console.error('[TMDB]', e.message); return null; }
-}
-
-async function fetchSubDL(imdbId, type, season, episode) {
-  if (type !== 'series' || season === null || episode === null) {
-    let subs = await subDLRequest(`&imdb_id=${imdbId}`);
-    if (subs.length === 0) {
-      const meta = await tmdbLookup(imdbId);
-      if (meta && meta.title) {
-        console.log(`║  [SubDL] IMDb failed, trying film_name="${meta.title}"...`);
-        subs = await subDLRequest(`&film_name=${encodeURIComponent(meta.title)}&type=movie`);
-      }
-    }
-    return parseSubDLResults(subs);
+    const streams = await fetchUpstream(type, id);
+    res.json({ streams });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
   }
+});
 
-  const [episodeSubs, seasonSubs] = await Promise.all([
-    subDLRequestWithFallback(`&imdb_id=${imdbId}&season_number=${season}&episode_number=${episode}`),
-    subDLRequestWithFallback(`&imdb_id=${imdbId}&season_number=${season}&full_season=1`)
-  ]);
-
-  const episodeParsed = parseSubDLResults(episodeSubs)
-    .filter(s => episodeFilter(s, season, episode, 'episodeCall'));
-
-  const seasonParsed = parseSubDLResults(seasonSubs)
-    .filter(s => episodeFilter(s, season, episode, 'seasonCall'));
-
-  console.log(`║  [SubDL] episode=${episodeParsed.length} season_pack=${seasonParsed.length}`);
-
-  const combined = [...episodeParsed, ...seasonParsed];
-  const seen     = new Set();
-  return combined.filter(s => {
-    const key = (s.filename || '').toLowerCase().replace(/[\s.\-_]+/g, '.');
-    if (seen.has(key)) return false;
-    seen.add(key); return true;
-  });
-}
-
-app.listen(PORT, '0.0.0.0', () => {
-  console.log(`\nVan Subs v19 — port ${PORT}`);
-  console.log(`BASE_URL: ${BASE_URL}`);
-  console.log(`SPACE_HOST env: ${process.env.SPACE_HOST || '(not set — using localhost)'}\n`);
-});
+app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));