Update index.js

index.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const express = require('express');
 const cheerio = require('cheerio');
 const AdmZip  = require('adm-zip');
@@ -12,98 +10,140 @@ const app  = express();
 const PORT = process.env.PORT || 7860;
 
 app.use((req, res, next) => {
-  res.header('Access-Control-Allow-Origin', '*');
+  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();
 });
 
-/* ===================================================================
-   CONFIG
-   =================================================================== */
+// ── CONFIG ──────────────────────────────────────────────────────────────────
 const BASE         = 'https://subf2m.co';
-const TMDB_KEY     = '30166e2db6b420d3f230808cd1bb2c90';   // you can replace with your own
+const TMDB_KEY     = '30166e2db6b420d3f230808cd1bb2c90';
 const TMDB_BASE    = 'https://api.themoviedb.org/3';
 const MAX_PER_LANG = 4;
 const CACHE_TTL    = 6 * 60 * 60 * 1000;
 const REQ_TIMEOUT  = 15_000;
 const DL_TIMEOUT   = 25_000;
-const MAX_DETAIL   = 50;
+const MAX_ENRICH   = 30;
+
+const ORDINALS = [
+  '', 'first', 'second', 'third', 'fourth', 'fifth',
+  'sixth', 'seventh', 'eighth', 'ninth', 'tenth',
+  'eleventh', 'twelfth', 'thirteenth', 'fourteenth', 'fifteenth'
+];
 
+// Languages we ALLOW (everything else is silently skipped)
 const ALLOWED_LANGS = new Set(['english', 'arabic']);
 
-/* ===================================================================
-   AI FILTERS (unchanged)
-   =================================================================== */
-const AI_PATTERNS = [
-  /\ba\.i\.\b/i, /\bai[\s\-_]sub(title)?s?\b/i, /\bai[\s\-_](translat|generat|correct|made|creat)/i,
-  /(translat|generat|creat|made|sub(title)?s?)\s+(by\s+)?ai\b/i, /machine[\s\-_]translat/i, /auto[\s\-_]?translat/i,
-  /auto[\s\-_]?generat/i, /auto[\s\-_]?sub(title)?s?\b/i, /\bautosub\b/i, /\bchatgpt\b/i, /\bgpt[\s\-_]?[34o]?\b/i,
-  /\bdeep[\s\-_]?l\b/i, /google[\s\-_]translat/i, /yandex[\s\-_]translat/i, /amazon[\s\-_]translat/i,
-  /microsoft[\s\-_]translat/i, /bing[\s\-_]translat/i, /\bopenai\b/i, /\bwhisper\b/i, /\bgemini\b/i, /\bclaude\b/i,
-  /\bllama\b/i, /neural[\s\-_](translat|sub|net|machine)/i, /\bnmt\b/i, /artificial[\s\-_]intelligence/i,
-  /computer[\s\-_](translat|generat)/i,
+// Other-language path fragments — used to drop mis-classified links
+const OTHER_LANGS = [
+  'french','spanish','portuguese','german','italian','turkish','persian','farsi',
+  'hindi','russian','polish','dutch','swedish','norwegian','danish','finnish',
+  'korean','japanese','chinese','malay','indonesian','vietnamese','thai','greek',
+  'hungarian','czech','romanian','bulgarian','hebrew','ukrainian','serbian',
+  'croatian','slovak','slovenian','latvian','estonian','lithuanian','albanian',
+  'azerbaijani','bosnian','catalan','georgian','icelandic','macedonian','mongolian',
+  'punjabi','sinhala','tamil','bengali','urdu','nepali','khmer','burmese',
+  'afrikaans','swahili'
 ];
-const isAISub = (text) => AI_PATTERNS.some(rx => rx.test(text || ''));
-
-/* ===================================================================
-   GLOBALS & CACHE
-   =================================================================== */
-const cache    = new Map();
-const subStore = new Map();
-let   subSeq   = 0;
-
-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);
-
-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 sleep = ms => new Promise(r => setTimeout(r, ms));
 
-/* ===================================================================
-   HTTP HELPERS
-   =================================================================== */
+// ── STREAMING PLATFORM PRIORITY ──────────────────────────────────────────────
+// Streaming-ripped subs are almost always perfectly synced retail encodes.
+// Prioritise them over scene / BluRay rips which can be off by seconds.
+const STREAMING_TIERS = [
+  { pts: 40, rx: [/\bnflx\b/i, /\bnetflix\b/i] },
+  { pts: 38, rx: [/\bamzn\b/i, /\bamazon\b/i, /\bprime\b/i] },
+  { pts: 36, rx: [/\bdsnp\b/i, /\bdisney\+?/i] },
+  { pts: 35, rx: [/\batvp\b/i, /\bappletv\b/i] },
+  { pts: 34, rx: [/\bhbo\b/i, /\bhbomax\b/i] },
+  { pts: 33, rx: [/\bpcok\b/i, /\bpeacock\b/i] },
+  { pts: 32, rx: [/\bhulu\b/i] },
+  { pts: 31, rx: [/\bpmtp\b/i, /\bparamount/i] },
+  { pts: 28, rx: [/\bwavve\b/i, /\btving\b/i, /\bwatcha\b/i, /\bviafree\b/i] },
+  { pts: 20, rx: [/\bweb[- ]?dl\b/i, /\bwebrip\b/i] },
+  { pts: 14, rx: [/\bbluray\b/i, /\bblu[- ]ray\b/i, /\bbdrip\b/i, /\b1080p\b/i, /\b4k\b/i] },
+  { pts: 12, rx: [/\bhdtv\b/i, /\b720p\b/i] },
+  { pts:  8, rx: [/\bproper\b/i, /\brepack\b/i, /\bsynced\b/i, /\bsync\b/i, /\bfixed\b/i] },
+];
+
+function streamScore(text) {
+  if (!text) return 0;
+  let best = 0;
+  for (const t of STREAMING_TIERS)
+    if (t.rx.some(r => r.test(text))) best = Math.max(best, t.pts);
+  return best;
+}
+
+// ── AI SUBTITLE DETECTION ────────────────────────────────────────────────────
+const AI_QUICK = [
+  'a.i','chatgpt','deepl','whisper','openai','gemini','claude','llama',
+  'machine translat','auto translat','auto-translat','auto generat','autosub',
+  'neural','yandex','bing translat','google translat','amazon translat',
+  'microsoft translat','nmt','artificial intel',' ai sub','ai-sub',
+  'ai translat','translated by ai','generated by ai',
+];
+const AI_RX = [
+  /\ba\.i\.\b/i, /\bartificial[\s\-_]intelligence/i,
+  /\b(ai|a\.i)[\s\-_](sub(title)?s?|translat|generat|correct|made|creat|caption|dub|edit|sync|fix)/i,
+  /(sub(title)?s?|translat|generat|creat|made|dub|caption|correct)\s+(by\s+)?(ai|a\.i)\b/i,
+  /\b(ai|a\.i)[- _]?(powered|assisted|based|driven|enabled)\b/i,
+  /machine[\s\-_]?translat/i, /auto[\s\-_]?translat/i, /auto[\s\-_]?sub(title)?s?\b/i,
+  /\bautosub\b/i, /\bnmt\b/, /neural[\s\-_]?(machine[\s\-_]?)?translat/i,
+  /\bwhisper[\s\-_]?(cpp|x|large|medium|small|tiny|base|v[123])?\b/i,
+  /\bfaster[\s\-_]?whisper\b/i, /\bwhisperx\b/i,
+  /\bopenai\b/i, /\bchatgpt\b/i,
+  /\bgpt[\s\-_]?[1-9o]?[\s\-_]?(turbo|mini|nano|ultra|pro|plus|omni|preview|vision)?\b/i,
+  /\banthropic\b/i, /\bclaude[\s\-_]?(2|3|4|sonnet|haiku|opus|instant|v\d)?\b/i,
+  /\bgemini[\s\-_]?(pro|ultra|flash|nano|advanced|1\.5|2\.0)?\b/i,
+  /\bgoogle[\s\-_]?(bard|translat|speech|asr)\b/i, /\bbard\b/i,
+  /\bllama[\s\-_]?[23]?\b/i, /\bmeta[\s\-_]?ai\b/i,
+  /\bdeepseek[\s\-_]?(v[123]|r1)?\b/i, /\bdeep[\s\-_]?l\b/i,
+  /\bmistral\b/i, /\bmixtral\b/i, /\bgrok[\s\-_]?[12]?\b/i,
+  /\bbing[\s\-_]?translat\b/i, /\bcopilot\b/i,
+  /\byandex[\s\-_]?(translat|gpt)\b/i, /\bamazon[\s\-_]?(translat|titan)\b/i,
+  /\bvosk\b/i, /\bassemblyai\b/i, /\bspeech[\s\-_]?(recogni|to[\s\-_]text)/i,
+  /\bsubtitlebee\b/i, /\bmaestra\b/i, /\bzubtitle\b/i, /\bsubmagic\b/i,
+  /\bhappy[\s\-_]?scribe\b/i, /\bdescript\b/i, /\bkapwing\b/i,
+  /\bveed[\s\-_]?io\b/i, /\bsubanana\b/i,
+];
+function isAI(text) {
+  if (!text) return false;
+  const lo = text.toLowerCase();
+  if (!AI_QUICK.some(q => lo.includes(q)) && !lo.includes(' ai') && !lo.includes('ai ') && !lo.includes('ai-')) return false;
+  return AI_RX.some(r => r.test(text));
+}
+
+// ── HTTP CORE ────────────────────────────────────────────────────────────────
 const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
 
-function _request(urlStr, opts = {}) {
+function _req(urlStr, opts = {}) {
   return new Promise((resolve, reject) => {
-    const parsed  = new URL(urlStr);
-    const lib     = parsed.protocol === 'https:' ? https : http;
-    const timeout = opts.timeout || REQ_TIMEOUT;
-    const reqOpts = {
+    const parsed = new URL(urlStr);
+    const lib    = parsed.protocol === 'https:' ? https : http;
+    const ro = {
       hostname: parsed.hostname,
       port    : parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
       path    : parsed.pathname + parsed.search,
       method  : 'GET',
       headers : {
-        'User-Agent'               : UA,
-        'Accept'                   : opts.binary ? 'application/zip,application/octet-stream,*/*' : 'text/html,application/xhtml+xml,*/*;q=0.8',
-        'Accept-Language'          : 'en-US,en;q=0.9',
-        'Accept-Encoding'          : 'gzip, deflate',
-        'Referer'                  : BASE + '/',
-        'Connection'               : 'keep-alive',
-        'Cache-Control'            : 'no-cache',
+        'User-Agent'      : UA,
+        'Accept'          : opts.binary ? 'application/zip,*/*' : 'text/html,*/*;q=0.8',
+        'Accept-Language' : 'en-US,en;q=0.9',
+        'Accept-Encoding' : 'gzip, deflate',
+        'Referer'         : BASE + '/',
+        'Connection'      : 'keep-alive',
         ...(opts.headers || {})
       }
     };
-    const req = lib.request(reqOpts, res => {
+    const req = lib.request(ro, res => {
       if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        const next = new URL(res.headers.location, urlStr).toString();
-        return _request(next, opts).then(resolve).catch(reject);
+        return _req(new URL(res.headers.location, urlStr).toString(), opts).then(resolve).catch(reject);
       }
       if (res.statusCode === 404) return resolve(null);
       if (res.statusCode !== 200) return resolve(null);
       const chunks = [];
-      let stream   = res;
+      let stream = res;
       const enc = res.headers['content-encoding'] || '';
       if (enc.includes('gzip'))         stream = res.pipe(zlib.createGunzip());
       else if (enc.includes('br'))      stream = res.pipe(zlib.createBrotliDecompress());
@@ -112,249 +152,198 @@ function _request(urlStr, opts = {}) {
       stream.on('end',  () => resolve(opts.binary ? Buffer.concat(chunks) : Buffer.concat(chunks).toString('utf8')));
       stream.on('error', reject);
     });
-    req.setTimeout(timeout, () => { req.destroy(); reject(new Error('Timeout')); });
+    req.setTimeout(opts.timeout || REQ_TIMEOUT, () => { req.destroy(); reject(new Error('timeout')); });
     req.on('error', reject);
     req.end();
   });
 }
-
 async function getHTML(url, tries = 3) {
   for (let i = 0; i < tries; i++) {
-    try { const r = await _request(url, { timeout: REQ_TIMEOUT }); if (r !== null) return r; } catch {}
-    if (i < tries - 1) await sleep(1200 * (i + 1));
+    try { const r = await _req(url); if (r !== null) return r; }
+    catch (e) { if (i < tries - 1) await sleep(1200 * (i + 1)); }
   }
   return null;
 }
-
-async function getBinary(url, tries = 3) {
+async function getBin(url, tries = 3) {
   for (let i = 0; i < tries; i++) {
-    try { const r = await _request(url, { binary: true, timeout: DL_TIMEOUT }); if (r !== null) return r; } catch {}
-    if (i < tries - 1) await sleep(1200 * (i + 1));
+    try { const r = await _req(url, { binary: true, timeout: DL_TIMEOUT }); if (r !== null) return r; }
+    catch (e) { if (i < tries - 1) await sleep(1200 * (i + 1)); }
   }
   return null;
 }
 
-/* ===================================================================
-   CACHE HELPERS
-   =================================================================== */
-function cacheGet(key) {
-  const item = cache.get(key);
+// ── CACHE ────────────────────────────────────────────────────────────────────
+const _cache = new Map();
+function cacheGet(k) {
+  const item = _cache.get(k);
   if (!item) return null;
-  if (Date.now() - item.ts > CACHE_TTL) { cache.delete(key); return null; }
+  if (Date.now() - item.ts > CACHE_TTL) { _cache.delete(k); return null; }
   return item.val;
 }
-function cacheSet(key, val) {
-  if (cache.size >= 900) { let n = 0; for (const k of cache.keys()) { cache.delete(k); if (++n >= 90) break; } }
-  cache.set(key, { val, ts: Date.now() });
+function cacheSet(k, v) {
+  if (_cache.size >= 800) { let n = 0; for (const key of _cache.keys()) { _cache.delete(key); if (++n >= 80) break; } }
+  _cache.set(k, { val: v, ts: Date.now() });
 }
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+const _clean = t => (t || '').replace(/\s+/g, ' ').trim();
 
-/* ===================================================================
-   TMDB (for title / year metadata needed for candidate scoring)
-   =================================================================== */
+// ── TMDB ─────────────────────────────────────────────────────────────────────
 async function getTMDB(imdbId) {
-  const ck = `tmdb:${imdbId}`;
-  const hit = cacheGet(ck);
+  const ck = `tmdb:${imdbId}`, hit = cacheGet(ck);
   if (hit !== null) return hit;
   try {
-    const raw = await _request(`${TMDB_BASE}/find/${imdbId}?external_source=imdb_id&api_key=${TMDB_KEY}`, { timeout: 8000 });
+    const raw = await _req(`${TMDB_BASE}/find/${imdbId}?external_source=imdb_id&api_key=${TMDB_KEY}`, { timeout: 8000 });
     if (!raw) { cacheSet(ck, null); return null; }
     const d = JSON.parse(raw);
     let info = null;
     if (d.movie_results?.length) {
       const m = d.movie_results[0];
-      info = { title: m.title || m.original_title, year: m.release_date?.substring(0,4) || null, type: 'movie' };
+      info = { title: m.title || m.original_title, year: m.release_date?.slice(0,4) || null, tmdbId: m.id, type: 'movie' };
     } else if (d.tv_results?.length) {
       const t = d.tv_results[0];
-      info = { title: t.name || t.original_name, year: t.first_air_date?.substring(0,4) || null, type: 'series' };
+      info = { title: t.name || t.original_name, year: t.first_air_date?.slice(0,4) || null, tmdbId: t.id, type: 'series' };
     }
-    cacheSet(ck, info);
-    return info;
+    cacheSet(ck, info); return info;
   } catch { cacheSet(ck, null); return null; }
 }
 
-/* ===================================================================
-   CANDIDATE SCORING & SLUG SELECTION
-   =================================================================== */
-function slugCandidateScore(slugText, expectedTitle, expectedYear) {
-  // text is the cleaned title string from the search result (e.g. "My Name (2021)")
-  const text = (slugText || '').trim().toLowerCase();
-  const clean = text.replace(/\s*\(\d{4}\)\s*$/, '').trim(); // remove year part
-  const yearMatch = text.match(/\((\d{4})\)/);
-  const year = yearMatch ? yearMatch[1] : null;
-
-  let score = 0;
-
-  // Title similarity (simple token overlap)
-  const expectedClean = (expectedTitle || '').toLowerCase().trim();
-  const tokensA = new Set(clean.split(' ').filter(Boolean));
-  const tokensB = new Set(expectedClean.split(' ').filter(Boolean));
-  const common = [...tokensA].filter(t => tokensB.has(t)).length;
-  const similarity = common / Math.max(tokensA.size, tokensB.size, 1);
-  score += similarity * 100;
-
-  // Year match (strong bonus)
-  if (year && expectedYear && year === String(expectedYear)) score += 100;
-  else if (year && expectedYear && Math.abs(+year - +expectedYear) <= 1) score += 40; // adjacent year
-
-  // Prefer non-collection / non-complete-series titles (less junk)
-  if (clean.includes('complete series') || clean.includes('collection')) score -= 30;
-
-  return score;
-}
-
-async function resolveBestSlug(imdbId, season, tmdbTitle, tmdbYear) {
-  const ck = `best:${imdbId}:${season ?? 'movie'}`;
+// ── SLUG RESOLUTION: IMDb ID → subf2m collection slug ────────────────────────
+// Flow confirmed by Bazarr/community research:
+//   subf2m.co/subtitles/searchbytitle?query=tt{id}&l=
+//   returns results whose <a> text is "Show Name - First Season (2017)"
+//   We pick the entry whose text matches the target season (or movie year).
+async function resolveSlug(imdbId, type, season, tmdb) {
+  const ck = `f2mslug:${imdbId}:${season || 0}`;
   const hit = cacheGet(ck);
   if (hit !== null) return hit;
 
-  const url = `${BASE}/subtitles/searchbytitle?query=${imdbId}&l=`;
-  console.log(`[IMDb] Fetching candidate list: ${url}`);
+  // Pass 1: search by IMDb ID (most reliable — works for all content globally)
+  let slug = await _f2mSearch(imdbId, type, season, tmdb);
+  // Pass 2: search by English title (fallback for obscure content)
+  if (!slug && tmdb?.title) slug = await _f2mSearch(tmdb.title, type, season, tmdb);
+
+  cacheSet(ck, slug);
+  return slug;
+}
+
+async function _f2mSearch(query, type, season, tmdb) {
+  const url  = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
   const html = await getHTML(url);
-  if (!html) { cacheSet(ck, null); return null; }
+  if (!html) return null;
 
   const $ = cheerio.load(html);
-  const candidates = [];
+  const results = [];
+  const seen    = new Set();
 
-  $('li div.title a').each((_, a) => {
-    const href = $(a).attr('href') || '';
-    if (!href.startsWith('/subtitles/')) return;
+  $('a[href]').each((_, el) => {
+    const href = ($(el).attr('href') || '').trim();
+    if (!href.startsWith('/subtitles/') || href.includes('searchbytitle')) return;
     const parts = href.split('/').filter(Boolean);
     if (parts.length < 2) return;
     const slug = parts[1];
-    const rawText = $(a).text() || '';
-    const text = rawText.trim();                    // ← handle trailing spaces
-    candidates.push({ slug, text });
+    if (!slug || seen.has(slug)) return;
+    seen.add(slug);
+    const text = ($(el).text() || '').replace(/\s+/g, ' ').trim().toLowerCase();
+    if (!text) return;
+    results.push({ slug, text });
   });
 
-  if (!candidates.length) {
-    console.log(`[IMDb] No candidates found`);
-    cacheSet(ck, null);
-    return null;
-  }
-  console.log(`[IMDb] Found ${candidates.length} candidates`);
-
-  // Score candidates
-  const scored = candidates.map(c => ({
-    ...c,
-    score: slugCandidateScore(c.text, tmdbTitle, tmdbYear)
-  }));
-  scored.sort((a, b) => b.score - a.score);
-
-  // If season is requested, try to find a candidate containing the season word
-  const SEASON_WORDS = [
-    'first season', 'second season', 'third season', 'fourth season', 'fifth season',
-    'sixth season', 'seventh season', 'eighth season', 'ninth season', 'tenth season',
-    'eleventh season', 'twelfth season', 'thirteenth season', 'fourteenth season',
-    'fifteenth season', 'sixteenth season', '1st season', '2nd season', '3rd season'
-  ];
-  let selectedSlug = scored[0].slug;
-  if (season && season <= SEASON_WORDS.length) {
-    const seasonWord = SEASON_WORDS[season - 1];
-    if (seasonWord) {
-      const match = scored.find(c => c.text.toLowerCase().includes(seasonWord));
-      if (match) {
-        selectedSlug = match.slug;
-        console.log(`[IMDb] Season match (${seasonWord}): ${selectedSlug}`);
-      } else {
-        console.log(`[IMDb] No season match, using best scored slug: ${selectedSlug}`);
-      }
+  if (!results.length) return null;
+  return type === 'series' && season
+    ? _pickSeries(results, tmdb, season)
+    : _pickMovie(results, tmdb);
+}
+
+function _pickSeries(results, tmdb, season) {
+  const ord  = (ORDINALS[season] || '').toLowerCase();
+  const s2   = String(season).padStart(2, '0');
+  const year = tmdb?.year || '';
+  // First word of the show's slug — used as a guard against unrelated results
+  const guard = tmdb?.title
+    ? tmdb.title.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g,'')
+        .replace(/[^a-z0-9]/g, ' ').trim().split(' ')[0]
+    : '';
+
+  let best = null, bestScore = -1;
+
+  for (const r of results) {
+    const t = r.text;
+    const s = r.slug.toLowerCase();
+    let score = 0;
+
+    // Guard: result must at least start with the show's first word
+    if (guard && !s.startsWith(guard) && !t.startsWith(guard)) continue;
+
+    // Ordinal word match (strongest: "first season", "second season")
+    if (ord) {
+      if (t.includes(`${ord} season`) || t.includes(`${ord} series`)) score += 100;
+      if (s.includes(`-${ord}-season`) || s.includes(`${ord}-season`))  score += 90;
     }
+    // Numeric season
+    if (t.includes(`season ${season}`) || s.includes(`season-${season}`)) score += 80;
+    if (s.includes(`-s${s2}`))                                             score += 75;
+    // Year
+    if (year && (t.includes(`(${year})`) || s.includes(year)))            score += 20;
+    // Has "season" keyword at all
+    if (t.includes('season') || s.includes('season'))                      score += 5;
+
+    if (score > bestScore) { bestScore = score; best = r; }
   }
 
-  cacheSet(ck, selectedSlug);
-  return selectedSlug;
-}
-
-/* ===================================================================
-   EPISODE PARSING (token-level, handles SxxExx and XxYY formats)
-   =================================================================== */
-function parseEpisode(text) {
-  if (!text) return { season: null, episode: null };
-  const t = text.toLowerCase();
-  // SxxExx
-  let m = t.match(/s(\d{1,2})[\.\-_\s]?e(\d{1,3})/);
-  if (m) return { season: parseInt(m[1],10), episode: parseInt(m[2],10) };
-  // XxYY (e.g. 1x05)
-  m = t.match(/\b(\d{1,2})x(\d{2,3})\b/);
-  if (m) return { season: parseInt(m[1],10), episode: parseInt(m[2],10) };
-  // "Season X Episode Y"
-  m = t.match(/season\s*(\d{1,2})\s*episode\s*(\d{1,3})/i);
-  if (m) return { season: parseInt(m[1],10), episode: parseInt(m[2],10) };
-  return { season: null, episode: null };
+  // Must have at least a "season" keyword — avoids picking unrelated movie entries
+  if (best && bestScore >= 5) {
+    console.log(`[f2m-slug] S${season} → "${best.slug}" (score ${bestScore})`);
+    return best.slug;
+  }
+  // Absolute fallback: first result whose slug starts with guard word
+  const fb = guard ? results.find(r => r.slug.toLowerCase().startsWith(guard)) : null;
+  if (fb) console.log(`[f2m-slug] S${season} fallback → "${fb.slug}"`);
+  return fb ? fb.slug : null;
 }
 
-/* ===================================================================
-   SUBTITLE SCRAPING & ENRICHMENT
-   =================================================================== */
-function _clean(t) { return (t || '').replace(/\s+/g, ' ').trim(); }
-
-async function _enrichSub(sub) {
-  const ck = `det:${sub.subId}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit.__aiBlocked ? null : { ...sub, ...hit };
-
-  const html = await getHTML(sub.detailUrl);
-  if (!html) return sub;
-  const $ = cheerio.load(html);
-  const txt = $.root().text();
-
-  const goodVotes = +(txt.match(/voted\s+as\s+good\s+by[:\s]*(\d+)/i)?.[1] ?? 0);
-  const badVotes  = +(txt.match(/voted\s+as\s+bad\s+by[:\s]*(\d+)/i)?.[1]  ?? 0);
-  const downloads = +(txt.match(/downloads?[:\s]*(\d+)/i)?.[1]              ?? 0);
-  const total = goodVotes + badVotes;
-  const ratio = total >= 3 ? goodVotes / total : null;
-  const isGood = sub.isGood || (ratio !== null && ratio >= 0.70 && goodVotes >= 2);
-
-  const authorNote = _clean($('p.comment, .comment, .notes, .author-comment').first().text());
-  const fullCheck = `${authorNote} ${sub.releaseInfo} ${sub.comment}`;
-  if (isAISub(fullCheck)) { cacheSet(ck, { __aiBlocked: true }); return null; }
-
-  const relLines = $('ul.release li, .release-names li, ul.scrolllist li')
-    .map((_, e) => $(e).text().trim()).get();
-  const releaseInfo = relLines.length ? relLines.join(' | ').substring(0, 130) : sub.releaseInfo;
-
-  return { ...sub, releaseInfo, goodVotes, badVotes, downloads, isGood, authorNote };
+function _pickMovie(results, tmdb) {
+  if (!results.length) return null;
+  const year  = tmdb?.year || '';
+  const guard = tmdb?.title
+    ? tmdb.title.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g,'')
+        .replace(/[^a-z0-9]/g, ' ').trim().split(' ')[0]
+    : '';
+
+  let best = null, bestScore = -1;
+  for (const r of results) {
+    const t = r.text;
+    const s = r.slug.toLowerCase();
+    let score = 0;
+
+    // Penalise series entries hard
+    if (t.includes('season') || s.includes('season')) { score -= 100; }
+    if (guard && s.startsWith(guard))             score += 40;
+    if (year && (t.includes(`(${year})`) || s.includes(year))) score += 50;
+
+    if (score > bestScore) { bestScore = score; best = r; }
+  }
+  if (best) {
+    console.log(`[f2m-slug] movie → "${best.slug}" (score ${bestScore})`);
+    return best.slug;
+  }
+  return results[0].slug;
 }
 
+// ── SUBTITLE LIST ─────────────────────────────────────────────────────────────
 async function getSubsList(slug, lang, season, episode) {
   if (!ALLOWED_LANGS.has(lang)) return [];
-
-  const ck = `list:${slug}:${lang}:${episode || 0}`;
+  const ck = `f2mlist:${slug}:${lang}:${episode || 0}`;
   const hit = cacheGet(ck);
   if (hit) return hit;
 
-  const url = `${BASE}/subtitles/${slug}/${lang}`;
-  const html = await getHTML(url);
+  const html = await getHTML(`${BASE}/subtitles/${slug}/${lang}`);
   if (!html) { cacheSet(ck, []); return []; }
 
   const $ = cheerio.load(html);
   let raw = [];
+  $('li.item').each((_, el) => _extractItem($, el, lang, raw));
 
-  $('li.item').each((_, el) => {
-    const $el = $(el);
-    const rawText = _clean($el.text());
-    let detailHref = null;
-    $el.find('a').each((_, a) => {
-      const h = $(a).attr('href') || '';
-      if (h.includes(`/${lang}/`) && /\/\d+$/.test(h)) detailHref = h;
-    });
-    if (!detailHref) return;
-    const parts = detailHref.split('/');
-    const subId = parts[parts.length - 1];
-    if (!subId || !/^\d+$/.test(subId)) return;
-
-    const isGood = $el.find('.green-icon, .positive-icon').length > 0 ||
-                   $el.hasClass('good') || ($el.attr('class') || '').toLowerCase().includes('good');
-    const comment = _clean($el.find('p.comment, .comment').first().text());
-    const releaseLines = $el.find('.r li, ul.release li, ul.scrolllist li, ul li')
-                            .map((_, li) => $(li).text().trim()).get().filter(Boolean);
-    const releaseInfo = releaseLines.join(' | ').substring(0, 130) || _clean($el.text()).substring(0, 130);
-    if (isAISub(`${comment} ${releaseInfo}`)) return;
-    raw.push({ subId, detailUrl: detailHref.startsWith('http') ? detailHref : `${BASE}${detailHref}`,
-               isGood, releaseInfo, comment, authorNote: '', lang, goodVotes: 0, badVotes: 0, downloads: 0,
-               _rawText: rawText });
-  });
-
+  // Fallback scraper for when li.item isn't populated
   if (!raw.length) {
     $('a[href]').each((_, a) => {
       const href = $(a).attr('href') || '';
@@ -362,128 +351,143 @@ async function getSubsList(slug, lang, season, episode) {
       const parts = href.split('/');
       const subId = parts[parts.length - 1];
       if (!subId || !/^\d+$/.test(subId)) return;
-      raw.push({ subId, detailUrl: href.startsWith('http') ? href : `${BASE}${href}`,
-                 isGood: false, releaseInfo: '', comment: '', authorNote: '', lang,
-                 goodVotes: 0, badVotes: 0, downloads: 0, _rawText: '' });
+      raw.push({ subId, lang, detailUrl: href.startsWith('http') ? href : `${BASE}${href}`,
+        isGood: false, releaseInfo: '', comment: '', authorNote: '', goodVotes: 0, badVotes: 0, _rawText: '' });
     });
   }
 
-  // Episode filter – token‑level matching
-  if (season && episode) {
-    const exact = raw.filter(item => {
-      const parsed = parseEpisode(item._rawText || item.releaseInfo);
-      return parsed.season === season && parsed.episode === episode;
+  // Episode filter for series
+  if (season != null && episode != null) {
+    const s2  = String(season).padStart(2, '0');
+    const ep2 = String(episode).padStart(2, '0');
+    const pats = [`s${s2}e${ep2}`, `${season}x${ep2}`, ` e${ep2}`, `ep${ep2}`, `episode ${episode}`, `- ${episode} -`];
+    const filtered = raw.filter(it => {
+      const txt = (it._rawText || it.releaseInfo || '').toLowerCase();
+      return pats.some(p => txt.includes(p));
     });
-    if (exact.length > 0) raw = exact;
-    else console.log(`[ep-filter] No exact S${season}E${episode} match in ${lang}, falling back to all on page.`);
+    if (filtered.length) {
+      raw = filtered;
+      console.log(`[f2m-ep] S${season}E${episode}: filtered to ${raw.length}`);
+    } else {
+      console.log(`[f2m-ep] S${season}E${episode}: no exact match, keeping all ${raw.length}`);
+    }
   }
 
-  const seen = new Set();
-  const unique = raw.filter(s => { if (seen.has(s.subId)) return false; seen.add(s.subId); return true; });
+  const seen    = new Set();
+  const unique  = raw.filter(s => { if (seen.has(s.subId)) return false; seen.add(s.subId); return true; });
 
-  const toEnrich = unique.slice(0, MAX_DETAIL);
-  const enriched = (await Promise.all(toEnrich.map(s => _enrichSub(s)))).filter(Boolean);
+  // Enrich detail pages in parallel (batched to avoid hammering the server)
+  const toEnrich = unique.slice(0, MAX_ENRICH);
+  const enriched = (await Promise.all(toEnrich.map(s => _enrich(s)))).filter(Boolean);
+  const human    = enriched.filter(s => !isAI(`${s.releaseInfo} ${s.comment} ${s.authorNote}`));
 
-  cacheSet(ck, enriched);
-  return enriched;
-}
-
-/* ===================================================================
-   SCORING (streaming source priority, sync keywords, etc.)
-   =================================================================== */
-const OFFICIAL_SOURCES = ['netflix','nf','amzn','amazon','osn','shahid','wavo','hbo','hulu','disney','dsnp','appletv','atvp'];
-
-function scoreTrack(sub, streamTitle) {
-  const text = (sub.releaseInfo || '').toLowerCase();
-  let s = 0;
-
-  if (OFFICIAL_SOURCES.some(src => text.includes(src))) s += 150;
-  if (/\b(synced|resync|corrected|fixed|proper|repack|retail|sync\.fix)\b/i.test(text)) s += 80;
-  if (/\b(sdh|hi\.|hi_|hearing.impaired)\b/i.test(text) || sub.hearingImpaired) s -= 40;
-  if (sub.rating) s += Math.round((sub.rating || 0) * 4);
-  if (/\.(ass|ssa)$/i.test(sub.releaseInfo || '')) s += 5;
-
-  // Release group match between subtitle and stream filename
-  const strmTitle = (streamTitle || '').toLowerCase();
-  const subGroups = text.match(/\b(?:-([a-z0-9]{2,20}))\b/g) || [];
-  for (const g of subGroups) {
-    const group = g.replace(/^-/, '');
-    if (group && strmTitle.includes(group)) { s += 100; break; }
-  }
+  // Sort: streaming platform first, then isGood, then raw quality
+  human.sort((a, b) => {
+    const sa = streamScore(a.releaseInfo), sb = streamScore(b.releaseInfo);
+    if (sa !== sb) return sb - sa;
+    const ga = a.isGood ? 1 : 0, gb = b.isGood ? 1 : 0;
+    return gb - ga;
+  });
 
-  return s;
+  cacheSet(ck, human);
+  return human;
 }
 
-/* ===================================================================
-   ZIP HANDLING (parallel downloads)
-   =================================================================== */
-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;
-  }
+function _extractItem($, el, lang, out) {
+  const $el     = $(el);
+  const rawText = _clean($el.text());
+  let   detailHref = null;
+  $el.find('a').each((_, a) => {
+    const h = $(a).attr('href') || '';
+    if (h.includes(`/${lang}/`) && /\/\d+$/.test(h)) detailHref = h;
+  });
+  if (!detailHref) return;
+  if (OTHER_LANGS.some(ol => detailHref.toLowerCase().includes(`/${ol}/`))) return;
+  const parts = detailHref.split('/');
+  const subId = parts[parts.length - 1];
+  if (!subId || !/^\d+$/.test(subId)) return;
+  const isGood = $el.find('.green-icon,.positive-icon').length > 0 ||
+    $el.find('img[alt="good"],img[alt="Positive"],img[alt="positive"]').length > 0 ||
+    ($el.attr('class') || '').toLowerCase().includes('good');
+  const comment  = _clean($el.find('p.comment,.comment').first().text());
+  const relLines = $el.find('.r li,ul.release li,ul.scrolllist li,ul li')
+                     .map((_, li) => $(li).text().trim()).get().filter(Boolean);
+  const releaseInfo = (relLines.join(' | ') || _clean($el.text())).substring(0, 130);
+  if (isAI(`${comment} ${releaseInfo}`)) return;
+  out.push({ subId, lang, isGood, releaseInfo, comment, authorNote: '', goodVotes: 0, badVotes: 0,
+    detailUrl: detailHref.startsWith('http') ? detailHref : `${BASE}${detailHref}`, _rawText: rawText });
+}
 
-  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];
+async function _enrich(sub) {
+  const ck = `f2mdet:${sub.subId}`, hit = cacheGet(ck);
+  if (hit !== null) { if (hit.__blocked) return null; return { ...sub, ...hit }; }
+  const html = await getHTML(sub.detailUrl);
+  if (!html) return sub;
+  const $   = cheerio.load(html);
+  const txt = $.root().text();
+  const goodVotes = +(txt.match(/voted\s+as\s+good\s+by[:\s]*(\d+)/i)?.[1] ?? 0);
+  const badVotes  = +(txt.match(/voted\s+as\s+bad\s+by[:\s]*(\d+)/i)?.[1]  ?? 0);
+  const total     = goodVotes + badVotes;
+  const ratio     = total >= 3 ? goodVotes / total : null;
+  const isGood    = sub.isGood || (ratio !== null && ratio >= 0.70 && goodVotes >= 2);
+  const authorNote = _clean($('p.comment,.comment,.notes,.author-comment').first().text());
+  if (isAI(`${authorNote} ${sub.releaseInfo} ${sub.comment}`)) { cacheSet(ck, { __blocked: true }); return null; }
+  const relLines   = $('ul.release li,.release-names li,ul.scrolllist li').map((_, e) => $(e).text().trim()).get();
+  const releaseInfo = relLines.length ? relLines.join(' | ').substring(0, 130) : sub.releaseInfo;
+  const result = { releaseInfo, goodVotes, badVotes, isGood, authorNote };
+  cacheSet(ck, result);
+  return { ...sub, ...result };
 }
 
-async function resolveUrl(downloadUrl, lang, season, episode) {
-  if (/\.(srt|ass|ssa|vtt)$/i.test(downloadUrl)) return { url: downloadUrl, extractedName: null };
-  for (let attempt = 1; attempt <= 2; attempt++) {
-    try {
-      const buf = await getBinary(downloadUrl);
-      if (!buf) continue;
-      const zip = new AdmZip(buf);
-      const best = pickFileFromZip(zip, lang, season, episode);
-      if (!best) continue;
-      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}" → /sub/${id}`);
-      return { url: publicUrl, extractedName: best.entryName };
-    } catch (e) { console.error('[ZIP] error:', e.message); }
-  }
+// ── SRT EXTRACTION ───────────────────────────────────────────────────────────
+async function fetchSRT(dlUrl) {
+  const ck = `f2msrt:${dlUrl}`, hit = cacheGet(ck);
+  if (hit !== null) return hit;
+  try {
+    const buf     = await getBin(dlUrl);
+    if (!buf) return null;
+    const content = _fromZip(buf) ?? _direct(buf);
+    if (!content) return null;
+    cacheSet(ck, content); return content;
+  } catch { return null; }
+}
+function _fromZip(buf) {
+  try {
+    const RANK = { '.srt': 0, '.vtt': 1, '.ass': 2, '.ssa': 3 };
+    const zip  = new AdmZip(buf);
+    const files = zip.getEntries()
+      .filter(e => { const n = e.entryName.toLowerCase(); return !e.isDirectory && !n.startsWith('__macosx') && Object.keys(RANK).some(x => n.endsWith(x)); })
+      .sort((a, b) => (RANK[_ext(a.entryName)] ?? 9) - (RANK[_ext(b.entryName)] ?? 9));
+    for (const f of files) { const t = _decode(zip.readFile(f)); if (_isSub(t)) return t; }
+  } catch {}
   return null;
 }
+function _direct(buf) { const t = _decode(buf); return _isSub(t) ? t : null; }
+const _ext   = n => (n.match(/(\.[^.]+)$/)?.[1]?.toLowerCase() ?? '');
+const _isSub = t => typeof t === 'string' && t.includes('-->') && t.length > 50;
+function _decode(buf) {
+  if (!buf) return '';
+  const hasBOM = buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF;
+  const u8 = buf.slice(hasBOM ? 3 : 0).toString('utf8');
+  return _isSub(u8) ? u8 : buf.toString('latin1');
+}
 
-/* ===================================================================
-   EXPRESS ROUTES
-   =================================================================== */
-const BASE_URL = process.env.SPACE_HOST ? `https://${process.env.SPACE_HOST}` : `http://localhost:${PORT}`;
-
-app.get('/manifest.json', (req, res) => res.json({
-  id: 'org.van.vansubs.v4',
-  name: 'VanSubs+ (Subf2m) – Smart Slug',
-  description: 'Human-verified Arabic & English. AI-free. Candidate scoring for correct page.',
-  version: '4.0.0',
-  resources: ['subtitles'],
-  types: ['movie', 'series'],
-  idPrefixes: ['tt'],
-  catalogs: []
+// ── ROUTES ───────────────────────────────────────────────────────────────────
+app.get('/manifest.json', (_, res) => res.json({
+  id: 'org.van.vanstreams.plus.primary', name: 'VanStreams+',
+  description: 'Human-Verified Arabic & English subtitles. Anti-AI.',
+  version: '2.0.0', resources: ['subtitles'], types: ['movie','series'], idPrefixes: ['tt'], catalogs: []
 }));
 
-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);
+app.get('/sub/:enc.srt', async (req, res) => {
+  let dlUrl = '';
+  try { dlUrl = Buffer.from(req.params.enc, 'base64url').toString('utf8'); } catch { return res.status(400).end(); }
+  if (!dlUrl.startsWith('https://subf2m.co/') || !dlUrl.endsWith('/download')) return res.status(403).end();
+  const content = await fetchSRT(dlUrl);
+  if (!content) return res.status(404).end();
+  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+  res.setHeader('Cache-Control', 'public, max-age=86400');
+  res.end(content);
 });
 
 app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
@@ -491,73 +495,86 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
   const { type, id } = req.params;
   if (!id?.startsWith('tt')) return res.json({ subtitles: [] });
 
-  const ck = `result:${id}`;
-  const hit = cacheGet(ck);
+  const ck = `f2mresult:${id}`, hit = cacheGet(ck);
   if (hit) return res.json({ subtitles: hit });
 
   try {
     let imdbId = id, season = null, episode = null;
     if (id.includes(':')) {
-      const parts = id.split(':');
-      imdbId = parts[0]; season = parts[1] ? +parts[1] : null; episode = parts[2] ? +parts[2] : null;
+      const p = id.split(':');
+      imdbId = p[0]; season = p[1] ? +p[1] : null; episode = p[2] ? +p[2] : null;
     }
     if (!/^tt\d+$/.test(imdbId)) return res.json({ subtitles: [] });
 
-    const extra = req.params.extra ? decodeURIComponent(req.params.extra.replace('.json','')) : '';
-    const streamTitle = (extra.match(/filename=([^&]+)/i) || [])[1] || '';
-
-    console.log(`\n╔═ [Subf2m v4] ${type.toUpperCase()} ${imdbId}` +
-      (season ? ` S${String(season).padStart(2,'0')}E${String(episode??0).padStart(2,'0')}` : '') +
-      (streamTitle ? `\n║  hint: "${streamTitle}"` : ''));
-
-    // TMDB metadata for candidate scoring
     const tmdb = await getTMDB(imdbId);
-    const slug = await resolveBestSlug(imdbId, season, tmdb?.title, tmdb?.year);
-    if (!slug) return res.json({ subtitles: [] });
+    const slug = await resolveSlug(imdbId, type, season, tmdb);
+    if (!slug) { console.log(`[f2m] no slug for ${imdbId}`); return res.json({ subtitles: [] }); }
+    console.log(`[f2m] ${type} ${imdbId} S${season}E${episode} → ${slug}`);
 
-    const [engSubs, araSubs] = await Promise.all([
+    const [engRes, araRes] = await Promise.allSettled([
       getSubsList(slug, 'english', season, episode),
-      getSubsList(slug, 'arabic', season, episode)
+      getSubsList(slug, 'arabic',  season, episode)
     ]);
 
-    const process = (list) => list
-      .map(s => ({ ...s, score: scoreTrack(s, streamTitle) }))
-      .sort((a, b) => b.score - a.score)
-      .slice(0, MAX_PER_LANG);
-
-    const engTop = process(engSubs);
-    const araTop = process(araSubs);
-
-    // Parallel ZIP resolution
-    const resolveAll = async (arr) => {
-      const results = await Promise.all(arr.map(async (s) => {
-        const dl = `${s.detailUrl}/download`;
-        const resolved = await resolveUrl(dl, s.lang, season, episode);
-        if (!resolved) return null;
-        return { ...s, url: resolved.url, filename: resolved.extractedName || s.releaseInfo };
-      }));
-      return results.filter(Boolean);
-    };
-
-    const engFinal = await resolveAll(engTop);
-    const araFinal = await resolveAll(araTop);
+    const engSubs = (engRes.status === 'fulfilled' ? engRes.value : []).slice(0, MAX_PER_LANG);
+    const araSubs = (araRes.status === 'fulfilled' ? araRes.value : []).slice(0, MAX_PER_LANG);
 
-    const proto = req.headers['x-forwarded-proto'] || (req.socket?.encrypted ? 'https' : 'http');
-    const host  = req.headers['x-forwarded-host'] || req.headers.host;
-    const origin = `${proto}://${host}`;
+    const proto  = req.headers['x-forwarded-proto'] || (req.socket?.encrypted ? 'https' : 'http');
+    const origin = `${proto}://${req.headers['x-forwarded-host'] || req.headers.host}`;
 
-    const subtitles = [
-      ...engFinal.map(s => ({ id: `vsub-eng-${s.subId}`, url: s.url, lang: 'eng', name: `🇺🇸 English ${s.isGood?'⭐':''} ${s.filename}`.substring(0,100) })),
-      ...araFinal.map(s => ({ id: `vsub-ara-${s.subId}`, url: s.url, lang: 'ara', name: `🇸🇦 Arabic ${s.isGood?'⭐':''} ${s.filename}`.substring(0,100) }))
-    ];
+    const build = (subs, code, flag) => subs.map(s => {
+      const enc  = Buffer.from(`${s.detailUrl}/download`).toString('base64url');
+      const star = s.isGood ? ' ⭐' : '';
+      const name = `${flag}${star} ${s.releaseInfo}`.trim().substring(0, 100);
+      return { id: `vsub-${code}-${s.subId}`, url: `${origin}/sub/${enc}.srt`, lang: code, name };
+    });
 
+    // Arabic first → Stremio auto-selects [0] as default
+    const subtitles = [...build(araSubs, 'ara', '🇸🇦 Arabic'), ...build(engSubs, 'eng', '🇺🇸 English')];
     cacheSet(ck, subtitles);
-    console.log(`║  ✅ ${subtitles.length} tracks (EN:${engFinal.length} AR:${araFinal.length})`);
     res.json({ subtitles });
-  } catch (e) {
-    console.error(e);
-    res.json({ subtitles: [] });
-  }
+  } catch (e) { console.error('[f2m route]', e); res.json({ subtitles: [] }); }
+});
+
+app.get('/', (req, res) => {
+  const manifestUrl = `${req.protocol}://${req.get('host')}/manifest.json`;
+  res.type('html').send(`<!DOCTYPE html>
+<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>VanStreams+ SubF2M</title>
+<style>*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+body{font-family:-apple-system,'Segoe UI',system-ui,sans-serif;background:#050810;color:#dde6f0;min-height:100vh;display:flex;align-items:center;justify-content:center;padding:28px 20px;background-image:radial-gradient(ellipse 70% 40% at 50% 0%,rgba(0,180,255,.07) 0%,transparent 70%)}
+.wrap{width:100%;max-width:560px;display:flex;flex-direction:column;gap:20px}
+.logo{font-size:2.6rem;font-weight:800;letter-spacing:-1px}.logo .van{color:#00c6ff}.logo .subs{color:#fff}
+.badge-row{display:flex;gap:8px;flex-wrap:wrap}
+.badge{display:inline-flex;align-items:center;gap:5px;background:rgba(0,198,255,.08);border:1px solid rgba(0,198,255,.18);color:#fff;padding:4px 11px;border-radius:100px;font-size:.72rem;font-weight:700;letter-spacing:.4px;text-transform:uppercase}
+.badge.green{background:rgba(0,220,130,.08);border-color:rgba(0,220,130,.18);color:#00dc82}
+.desc{color:#fff;font-size:.9rem;line-height:1.6;margin-top:2px}
+.card{background:rgba(255,255,255,.03);border:1px solid rgba(255,255,255,.07);border-radius:16px;padding:20px 22px}
+.card-label{font-size:.68rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;color:#3a5060;margin-bottom:10px}
+.url-box{font-family:'SF Mono','Fira Code',monospace;font-size:.8rem;color:#fff;background:rgba(0,0,0,.25);border:1px solid rgba(0,198,255,.12);border-radius:10px;padding:11px 14px;word-break:break-all;line-height:1.5}
+.actions{display:flex;gap:10px;margin-top:14px}
+.btn{padding:10px 22px;border-radius:10px;font-size:.84rem;font-weight:600;text-decoration:none;border:none;cursor:pointer;transition:all .15s;font-family:inherit}
+.btn-primary{background:#00c6ff;color:#050810}.btn-primary:hover{background:#00b0e8}
+.btn-ghost{background:rgba(255,255,255,.05);color:#7a8fa3;border:1px solid rgba(255,255,255,.09)}.btn-ghost:hover{background:rgba(255,255,255,.09);color:#aabdcc}
+.stats{display:grid;grid-template-columns:repeat(3,1fr);gap:10px}
+.stat{background:rgba(255,255,255,.02);border:1px solid rgba(255,255,255,.06);border-radius:12px;padding:16px 12px;text-align:center}
+.stat-val{font-size:1.5rem;font-weight:800;color:#fff;line-height:1;margin-bottom:5px}
+.stat-lbl{font-size:.68rem;color:#3a5060;font-weight:600;text-transform:uppercase;letter-spacing:.5px}</style></head>
+<body><div class="wrap">
+<div><div class="logo"><span class="van">Van</span> <span class="subs">Subs+</span></div>
+<div class="badge-row" style="margin-top:12px"><span class="badge">🛡 Anti-AI</span><span class="badge green">✔ Human-Verified</span><span class="badge">📡 SubF2M</span></div>
+<p class="desc" style="margin-top:12px">Human-Verified Arabic &amp; English Subtitles. Anti-AI.<br>IMDb-native search · streaming platform priority · Arabic first.</p></div>
+<div class="card"><div class="card-label">Stremio Install URL</div>
+<div class="url-box">${manifestUrl}</div>
+<div class="actions">
+<a href="/manifest.json" class="btn btn-primary">View Manifest</a>
+<button class="btn btn-ghost" onclick="navigator.clipboard.writeText('${manifestUrl}').then(()=>{this.textContent='✔ Copied';setTimeout(()=>this.textContent='Copy URL',2000)})">Copy URL</button>
+</div></div>
+<div class="stats">
+<div class="stat"><div class="stat-val">2</div><div class="stat-lbl">Languages</div></div>
+<div class="stat"><div class="stat-val">4</div><div class="stat-lbl">Max per lang</div></div>
+<div class="stat"><div class="stat-val">0</div><div class="stat-lbl">AI subs</div></div>
+</div></div></body></html>`);
 });
 
-app.listen(PORT, '0.0.0.0', () => console.log(`\n✅ Subf2m v4 – candidate scoring + episode parsing → http://0.0.0.0:${PORT}`));
+app.listen(PORT, '0.0.0.0', () => console.log(`✅ VanStreams+ SubF2M v2.0.0 → http://0.0.0.0:${PORT}`));