Update index.js

index.js

@@ -1,5 +1,4 @@
 'use strict';
- 
 const express = require('express');
 const cheerio = require('cheerio');
 const AdmZip  = require('adm-zip');
@@ -19,61 +18,53 @@ app.use((req, res, next) => {
   next();
 });
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  PROXY CONFIG — edit these 3 URLs at any time
-// ═══════════════════════════════════════════════════════════════════
-const PROXY_1 = (dlUrl) => `https://corsproxy.io/?url=${encodeURIComponent(dlUrl)}`;
-const PROXY_2 = (dlUrl) => `https://api.codetabs.com/v1/proxy?quest=${encodeURIComponent(dlUrl)}`;
-const PROXY_3 = (dlUrl) => `https://thingproxy.freeboard.io/fetch/${dlUrl}`;
+// ================================================================
+//  PROXY CONFIG  ← edit these three lines to swap proxies
+// ================================================================
+const PROXY_1 = 'https://corsproxy.io/?url=';
+const PROXY_2 = 'https://api.codetabs.com/v1/proxy?quest=';
+const PROXY_3 = 'https://thingproxy.freeboard.io/fetch/';
+// ================================================================
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  CORE CONFIG
-// ═══════════════════════════════════════════════════════════════════
 const BASE         = 'https://subf2m.co';
-const TMDB_KEY     = '30166e2db6b420d3f230808cd1bb2c90';
+const TMDB_KEY     = process.env.TMDB_KEY || '30166e2db6b420d3f230808cd1bb2c90';
 const TMDB_BASE    = 'https://api.themoviedb.org/3';
 const MAX_PER_LANG = 4;
-const CACHE_TTL    = 6 * 60 * 60 * 1000;  // 6 h
-const REQ_TIMEOUT  = 15_000;
-const DL_TIMEOUT   = 25_000;
+const CACHE_TTL    = 6 * 60 * 60 * 1000;
+const REQ_TIMEOUT  = 18_000;
+const DL_TIMEOUT   = 30_000;
 const MAX_DETAIL   = 30;
  
-// Ordinal words used in subf2m season slugs
+// Full ordinal list covering seasons 1–30
 const ORDINALS = [
   '', 'first', 'second', 'third', 'fourth', 'fifth',
   'sixth', 'seventh', 'eighth', 'ninth', 'tenth',
   'eleventh', 'twelfth', 'thirteenth', 'fourteenth', 'fifteenth',
-  'sixteenth', 'seventeenth', 'eighteenth', 'nineteenth', 'twentieth'
+  'sixteenth', 'seventeenth', 'eighteenth', 'nineteenth', 'twentieth',
+  'twenty-first', 'twenty-second', 'twenty-third', 'twenty-fourth', 'twenty-fifth',
+  'twenty-sixth', 'twenty-seventh', 'twenty-eighth', 'twenty-ninth', 'thirtieth',
 ];
  
 const ALLOWED_LANGS = new Set(['english', 'arabic']);
  
-// Languages we explicitly block at extraction
 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','brazilian'
+  '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',
 ];
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  QUALITY SCORING
-// ═══════════════════════════════════════════════════════════════════
 const QUALITY_TIERS = [
   { bonus: 0.13, terms: [/\bbluray\b/i,/\bblu[- ]ray\b/i,/\bbdrip\b/i,/\bbdremux\b/i,/\b4k\b/i,/\b2160p\b/i,/\b1080p\b/i] },
   { bonus: 0.10, terms: [/\bweb[- ]?dl\b/i,/\bwebrip\b/i,/\bamzn\b/i,/\bnflx\b/i,/\bhbo\b/i,/\bdsnp\b/i,/\bappletv\b/i,/\batvp\b/i,/\bpcok\b/i] },
   { bonus: 0.05, terms: [/\bhdtv\b/i,/\b720p\b/i,/\bhdrip\b/i] },
-  { bonus: 0.08, terms: [/\bproper\b/i,/\brepack\b/i,/\bsynced\b/i,/\bsync\b/i,/\bfixed\b/i,/\bcorrected\b/i,/\bv2\b/i,/\bv3\b/i] },
+  { bonus: 0.08, terms: [/\bproper\b/i,/\brepack\b/i,/\breal\.proper\b/i,/\bsynced\b/i,/\bsync\b/i,/\bfixed\b/i,/\bcorrected\b/i,/\bv2\b/i,/\bv3\b/i] },
 ];
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  AI-DETECTION
-// ═══════════════════════════════════════════════════════════════════
 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,
@@ -84,25 +75,27 @@ const AI_PATTERNS = [
   /\bllama\b/i,/neural[\s\-_](translat|sub|net|machine)/i,/\bnmt\b/i,
   /artificial[\s\-_]intelligence/i,/computer[\s\-_](translat|generat)/i,
 ];
+ 
 const AI_QUICK_HITS = [
   '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',
 ];
+ 
 function isAISub(text) {
   if (!text) return false;
   const lo = text.toLowerCase();
-  const maybeAI = AI_QUICK_HITS.some(q => lo.includes(q)) || lo.includes(' ai') || lo.includes('ai ') || lo.includes('ai-');
+  const maybeAI = AI_QUICK_HITS.some(q => lo.includes(q)) || /\bai\b/.test(lo);
   if (!maybeAI) return false;
   return AI_PATTERNS.some(rx => rx.test(text));
 }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  HTTP HELPERS
-// ═══════════════════════════════════════════════════════════════════
 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';
  
+// ================================================================
+//  HTTP CORE
+// ================================================================
 function _request(urlStr, opts = {}) {
   return new Promise((resolve, reject) => {
     const parsed  = new URL(urlStr);
@@ -115,17 +108,15 @@ function _request(urlStr, opts = {}) {
       method  : 'GET',
       headers : {
         'User-Agent'               : UA,
-        'Accept'                   : opts.binary
-          ? 'application/zip,application/octet-stream,*/*'
-          : 'text/html,application/xhtml+xml,*/*;q=0.8',
+        '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'                  : 'https://subf2m.co/',
         'Connection'               : 'keep-alive',
         'Cache-Control'            : 'no-cache',
         'Upgrade-Insecure-Requests': '1',
-        ...(opts.headers || {})
-      }
+        ...(opts.headers || {}),
+      },
     };
     const req = lib.request(reqOpts, res => {
       if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
@@ -135,8 +126,8 @@ function _request(urlStr, opts = {}) {
       if (res.statusCode === 404) return resolve(null);
       if (res.statusCode !== 200) return resolve(null);
       const chunks = [];
-      let stream   = res;
-      const enc = res.headers['content-encoding'] || '';
+      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());
       else if (enc.includes('deflate')) stream = res.pipe(zlib.createInflate());
@@ -165,60 +156,33 @@ async function getHTML(url, tries = 3) {
   return null;
 }
  
+// Binary with proxy chain fallback
 async function getBinary(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 (e) {
-      if (i < tries - 1) await sleep(1200 * (i + 1));
-    }
+    } catch (_) {}
+  }
+  // Proxy chain
+  const enc   = encodeURIComponent(url);
+  const proxied = [
+    `${PROXY_1}${enc}`,
+    `${PROXY_2}${enc}`,
+    `${PROXY_3}${url}`,
+  ];
+  for (const pUrl of proxied) {
+    try {
+      const r = await _request(pUrl, { binary: true, timeout: DL_TIMEOUT });
+      if (r && r.length > 50) return r;
+    } catch (_) {}
   }
   return null;
 }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  TMDB HELPERS
-// ═══════════════════════════════════════════════════════════════════
-async function getTMDB(imdbId) {
-  const ck  = `tmdb:${imdbId}`;
-  const 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 });
-    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', tmdbId: m.id };
-    } 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', tmdbId: t.id };
-    }
-    cacheSet(ck, info);
-    return info;
-  } catch (e) { cacheSet(ck, null); return null; }
-}
- 
-async function getTMDBSeasonYear(tmdbId, season) {
-  if (!tmdbId) return null;
-  const ck  = `tmdbseason:${tmdbId}:${season}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit;
-  try {
-    const raw = await _request(`${TMDB_BASE}/tv/${tmdbId}/season/${season}?api_key=${TMDB_KEY}`, { timeout: 8000 });
-    if (!raw) { cacheSet(ck, null); return null; }
-    const d    = JSON.parse(raw);
-    const year = d.air_date?.substring(0, 4) || null;
-    cacheSet(ck, year);
-    return year;
-  } catch (e) { cacheSet(ck, null); return null; }
-}
- 
-// ═══════════════════════════════════════════════════════════════════
-// ██  CACHE
-// ═══════════════════════════════════════════════════════════════════
+// ================================================================
+//  CACHE
+// ================================================================
 const _cache = new Map();
 function cacheGet(key) {
   const item = _cache.get(key);
@@ -235,9 +199,9 @@ function cacheSet(key, val) {
 }
 const sleep = ms => new Promise(r => setTimeout(r, ms));
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  STRING UTILS
-// ═══════════════════════════════════════════════════════════════════
+// ================================================================
+//  STRING UTILS
+// ================================================================
 function titleToSlug(title, year) {
   const base = (title || '').toLowerCase()
     .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
@@ -247,11 +211,12 @@ function titleToSlug(title, year) {
     .replace(/^-|-$/g, '');
   return year ? `${base}-${year}` : base;
 }
+ 
 function _clean(t) { return (t || '').replace(/\s+/g, ' ').trim(); }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  RELEASE PARSING & SCORING
-// ═══════════════════════════════════════════════════════════════════
+// ================================================================
+//  RELEASE PARSING & SCORING
+// ================================================================
 function parseRelease(text) {
   if (!text) return {};
   const tokens = {};
@@ -275,299 +240,382 @@ function parseRelease(text) {
 function qualityBonus(text) {
   if (!text) return 0;
   let bonus = 0;
-  for (const tier of QUALITY_TIERS) {
+  for (const tier of QUALITY_TIERS)
     if (tier.terms.some(rx => rx.test(text))) bonus += tier.bonus;
-  }
   return Math.min(bonus, 0.20);
 }
  
-/**
- * Score a subtitle for best-match at [0].
- * Higher = better. Components:
- *   100  exact S+E match
- *   30   release-group match
- *   20   source/platform match
- *   10   resolution match
- *   25   download count (log-scaled, max 25)
- *   15   good-vote ratio (≥70%)
- *   5    isGood flag
- *   0-2  quality bonus from text
- */
 function scoreSubtitle(sub, streamTokens) {
+  if (!streamTokens) return 0;
   const subText   = sub.releaseInfo || sub._rawText || '';
   const subTokens = parseRelease(subText);
-  let score = 0;
-  if (streamTokens) {
-    if (streamTokens.season != null && streamTokens.episode != null &&
-        subTokens.season === streamTokens.season && subTokens.episode === streamTokens.episode) score += 100;
-    if (streamTokens.source && subTokens.source && subTokens.source === streamTokens.source) score += 20;
-    if (streamTokens.resolution && subTokens.resolution === streamTokens.resolution) score += 10;
-    if (streamTokens.group && subTokens.group && subTokens.group === streamTokens.group) score += 30;
-  }
-  // Always apply download + vote bonuses so movies are also sorted well
-  const dl = Math.max(0, sub.downloads || 0);
-  score += Math.min(25, Math.round(Math.log10(dl + 1) * 7));
-  const total = (sub.goodVotes || 0) + (sub.badVotes || 0);
-  if (total >= 3) {
-    const ratio = sub.goodVotes / total;
-    if (ratio >= 0.70) score += 15;
-    else if (ratio >= 0.50) score += 5;
-  }
+  let   score     = 0;
+  if (streamTokens.season != null && streamTokens.episode != null &&
+      subTokens.season === streamTokens.season && subTokens.episode === streamTokens.episode)
+    score += 100;
+  if (streamTokens.source && subTokens.source && subTokens.source === streamTokens.source)
+    score += 20;
+  if (streamTokens.resolution && subTokens.resolution === streamTokens.resolution)
+    score += 10;
+  if (streamTokens.group && subTokens.group && subTokens.group === streamTokens.group)
+    score += 30;
   if (sub.isGood) score += 5;
-  score += Math.round(qualityBonus(subText) * 10);
+  score += qualityBonus(subText) * 10;
   return score;
 }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  SLUG PROBE — no longer requires SxxExx in body (just existence)
-// ═══════════════════════════════════════════════════════════════════
-async function _probeSlugExists(slug) {
+// ================================================================
+//  TMDB
+// ================================================================
+async function getTMDB(imdbId) {
+  const ck  = `tmdb:${imdbId}`;
+  const 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: 10_000 },
+    );
+    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', tmdbId: m.id };
+    } 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', tmdbId: t.id };
+    }
+    cacheSet(ck, info);
+    return info;
+  } catch (e) { cacheSet(ck, null); return null; }
+}
+ 
+async function getTMDBSeasonYear(tmdbId, season) {
+  if (!tmdbId) return null;
+  const ck  = `tmdbsy:${tmdbId}:${season}`;
+  const hit = cacheGet(ck);
+  if (hit !== null) return hit;
+  try {
+    const raw  = await _request(`${TMDB_BASE}/tv/${tmdbId}/season/${season}?api_key=${TMDB_KEY}`, { timeout: 10_000 });
+    if (!raw) { cacheSet(ck, null); return null; }
+    const year = JSON.parse(raw).air_date?.substring(0, 4) || null;
+    cacheSet(ck, year);
+    return year;
+  } catch (e) { cacheSet(ck, null); return null; }
+}
+ 
+// ================================================================
+//  SLUG PROBING — FIXED
+//  No longer requires S##E## on the page — any item list qualifies.
+// ================================================================
+async function _probeSlug(slug, opts = {}) {
   if (!slug || slug.length > 220) return false;
   try {
-    const html = await getHTML(`${BASE}/subtitles/${slug}/english`, 1);
+    const lang = opts.lang || 'english';
+    const url  = `${BASE}/subtitles/${slug}/${lang}`;
+    const html = await getHTML(url, 1);
     if (!html || html.length < 500) return false;
-    // Must not be a search-results page or 404 redirect
-    if (html.includes('searchbytitle') && !html.includes('<li class="item"') && !html.includes('li.item')) return false;
-    return html.includes('<li') || html.includes('subtitle') || html.includes('download');
+    // Must have subtitle items
+    if (!html.includes('<li') && !html.includes('subtitle') && !html.includes('download')) return false;
+    // If we need to verify season, do a looser check
+    if (opts.season) {
+      const s    = Number(opts.season);
+      const pad  = String(s).padStart(2, '0');
+      const ord  = (ORDINALS[s] || '').toLowerCase();
+      // Accept if any season-related text is found, OR if there are item listings
+      const hasSeasonRef = (
+        html.includes(`S${pad}E`) || html.includes(`s${pad}e`) ||
+        html.includes(`season ${s}`) || html.includes(`Season ${s}`) ||
+        (ord && html.toLowerCase().includes(`${ord} season`)) ||
+        html.includes(`li class="item"`) ||
+        html.includes('class="r"')
+      );
+      return hasSeasonRef;
+    }
+    return html.includes('<li') || html.includes('item');
   } catch (_) { return false; }
 }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  MOVIE SLUG RESOLUTION
-//     Strategy: 1) IMDB-ID search, 2) title search, 3) brute-force patterns
-// ═══════════════════════════════════════════════════════════════════
-async function resolveMovieSlug(imdbId, titleHint, yearHint) {
-  const ck  = `mslug2:${imdbId}`;
+// ================================================================
+//  SERIES SLUG RESOLUTION — FIXED
+//  Key insight from bazarr issue #2617 and #2616:
+//  1. Subf2m search returns entries like "Young Sheldon - first season (2017)"
+//     with a TRAILING SPACE before closing tag — must trim.
+//  2. Search by IMDb ID works: ?query=tt1234567
+//  3. The slug for a series season is: show-name-first-season OR
+//     show-name-first-season-2017
+// ================================================================
+async function resolveSeriesSlug(imdbId, season) {
+  const ck  = `sslug2:${imdbId}:${season}`;
   const hit = cacheGet(ck);
   if (hit !== null) return hit;
  
-  const tmdb  = await getTMDB(imdbId);
-  const title = tmdb?.title || titleHint;
-  const year  = tmdb?.year  || yearHint;
+  const tmdb      = await getTMDB(imdbId);
+  const title     = tmdb?.title;
+  const showYear  = tmdb?.year;
+  const seasonYear = tmdb?.tmdbId ? await getTMDBSeasonYear(tmdb.tmdbId, season) : null;
  
-  // 1. Direct IMDB-ID search on subf2m (most reliable — avoids localised title issues)
-  let slug = await _searchSlugByQuery(imdbId, null, false);
-  if (slug && await _probeSlugExists(slug)) {
-    cacheSet(ck, slug); return slug;
+  // Strategy 1: Search by IMDb ID (most reliable)
+  let slug = await _searchSeriesSlugByQuery(imdbId, season, title, seasonYear, showYear);
+  if (slug) { cacheSet(ck, slug); return slug; }
+ 
+  // Strategy 2: Search by title
+  if (title) {
+    slug = await _searchSeriesSlugByQuery(title, season, title, seasonYear, showYear);
+    if (slug) { cacheSet(ck, slug); return slug; }
   }
  
-  // 2. Search by original title from TMDB
+  // Strategy 3: Smart pattern brute-force
   if (title) {
-    slug = await _searchSlugByQuery(title, year, false);
-    if (slug && await _probeSlugExists(slug)) {
-      cacheSet(ck, slug); return slug;
-    }
+    slug = await _smartPatternSlugs(title, season, seasonYear, showYear);
+    if (slug) { cacheSet(ck, slug); return slug; }
+  }
  
-    // 3. Brute-force slug patterns
-    const candidates = [];
-    if (year) {
-      candidates.push(titleToSlug(title, year));
-      candidates.push(titleToSlug(title, String(+year - 1)));
-      candidates.push(titleToSlug(title, String(+year + 1)));
-    }
-    candidates.push(titleToSlug(title, null));
-    for (const c of [...new Set(candidates)]) {
-      await sleep(250);
-      if (await _probeSlugExists(c)) { cacheSet(ck, c); return c; }
+  // Strategy 4: Bare slug (complete series page)
+  if (title) {
+    const bare = titleToSlug(title, null);
+    if (await _probeSlug(bare, { season })) { cacheSet(ck, bare); return bare; }
+    // Try with show year
+    if (showYear) {
+      const withYear = titleToSlug(title, showYear);
+      if (await _probeSlug(withYear, { season })) { cacheSet(ck, withYear); return withYear; }
     }
   }
  
-  cacheSet(ck, null); return null;
+  cacheSet(ck, null);
+  return null;
 }
  
-// Generic search-by-query; isSeries controls scoring
-async function _searchSlugByQuery(query, yearHint, isSeries) {
-  const url  = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
-  const html = await getHTML(url);
+async function _searchSeriesSlugByQuery(query, season, titleHint, seasonYear, showYear) {
+  const searchUrl = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
+  const html      = await getHTML(searchUrl);
   if (!html) return null;
   const $       = cheerio.load(html);
+  const ord     = (ORDINALS[season] || '').toLowerCase();
+  const firstWord = titleHint ? titleToSlug(titleHint, null).split('-')[0] : '';
   const results = [];
-  // Subf2m returns results inside .search-result ul li or similar
-  const SELS = ['ul.search-result li', '.search-result li', '.content ul li', 'ul li'];
-  let found = false;
-  for (const sel of SELS) {
-    $(sel).each((_, el) => {
-      const a    = $(el).find('a[href]').first();
-      const href = a.attr('href') || '';
-      if (!href.startsWith('/subtitles/') || href === '/subtitles/searchbytitle') return;
-      const parts = href.split('/').filter(Boolean);
-      if (parts.length < 2) return;
-      const slug = parts[1];
-      if (!slug || slug === 'searchbytitle') return;
-      const text    = _clean(a.text());
-      const yrMatch = text.match(/\((\d{4})\)/);
-      const resYear = yrMatch ? +yrMatch[1] : null;
-      let score = 1;
-      if (query.startsWith('tt'))             score += 200; // IMDB-ID hit is definitive
-      if (yearHint && resYear === +yearHint)  score += 10;
-      results.push({ slug, score });
-      found = true;
-    });
-    if (found) break;
-  }
-  if (!results.length) return null;
-  results.sort((a, b) => b.score - a.score);
-  return results[0].slug;
-}
- 
-// ═══════════════════════════════════════════════════════════════════
-// ██  SERIES SLUG RESOLUTION
-//     Strategy: 1) smart TMDB patterns, 2) site search, 3) base slug
-// ═══════════════════════════════════════════════════════════════════
-async function resolveSeriesSlug(imdbId, season) {
-  const ck  = `sslug2:${imdbId}:${season}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit;
- 
-  const tmdb  = await getTMDB(imdbId);
-  const title = tmdb?.title;
-  if (!title) { cacheSet(ck, null); return null; }
- 
-  const seasonYear = tmdb?.tmdbId ? await getTMDBSeasonYear(tmdb.tmdbId, season) : null;
+  const seen    = new Set();
+ 
+  // The bazarr fix: subf2m titles in HTML have trailing spaces.
+  // Regex matches: "Show Name - ORDINAL season (YEAR)" or "Show Name (YEAR)"
+  // The series regex from bazarr (with the \s*$ fix):
+  //   ^(.+?) [-\(]\s?(.*?) (season|series)\)?( \((\d{4})\))?\s*$
+  const SERIES_RE = /^(.+?)\s*[-–]\s*(.*?)\s*(season|series)\s*(\((\d{4})\))?\s*$/i;
+  const MOVIE_RE  = /^(.+?)\s*\((\d{4})\)\s*$/;
+ 
+  $('a[href]').each((_, a) => {
+    const href = $(a).attr('href') || '';
+    if (!href.startsWith('/subtitles/')) return;
+    const parts = href.split('/').filter(Boolean);
+    if (parts.length < 2) return;
+    const slug = parts[1];
+    if (!slug || slug === 'searchbytitle' || seen.has(slug)) return;
+    seen.add(slug);
+ 
+    const rawText = _clean($(a).text());
+    const slugLow = slug.toLowerCase();
+ 
+    // Must start with show's first word for disambiguation
+    if (firstWord && !slugLow.startsWith(firstWord)) return;
+ 
+    let score = 0;
+ 
+    // Check title text for season match
+    const seriesMatch = SERIES_RE.exec(rawText);
+    if (seriesMatch) {
+      const subOrd  = (seriesMatch[2] || '').trim().toLowerCase();
+      const subYear = seriesMatch[5];
+      // Ordinal match (e.g. "first season")
+      if (ord && subOrd === ord) score += 200;
+      else if (ord && subOrd.startsWith(ord)) score += 150;
+      // Numeric season as ordinal
+      if (subOrd === String(season)) score += 100;
+      // Year match
+      if (seasonYear && subYear === seasonYear) score += 50;
+      else if (showYear && subYear === showYear && season === 1) score += 30;
+      // Any series result is better than none
+      if (score === 0) score += 10;
+    }
  
-  // 1. Smart slug patterns
-  let slug = await _smartSeriesPatterns(title, season, seasonYear, tmdb?.year);
-  if (slug) { cacheSet(ck, slug); return slug; }
+    // Also score by slug patterns (backup)
+    if (ord && slugLow.includes(`-${ord}-season`)) score += Math.max(score, 80);
+    if (slugLow.includes(`-season-${season}-`))    score += Math.max(score, 70);
+    if (slugLow.includes(`-s${String(season).padStart(2,'0')}`)) score += Math.max(score, 60);
+    if (ord && slugLow.includes(`-${ord}season`))  score += Math.max(score, 50);
  
-  // 2. Search-based resolution (parses "Title - ORDINAL season (YEAR)" exactly)
-  slug = await _searchSeriesSlug(title, season, seasonYear, imdbId);
-  if (slug) { cacheSet(ck, slug); return slug; }
+    if (score > 0) results.push({ slug, score });
+  });
  
-  // 3. Base slug without season specifier (some old shows use bare title)
-  const baseSlug = titleToSlug(title, null);
-  if (await _probeSlugExists(baseSlug)) { cacheSet(ck, baseSlug); return baseSlug; }
+  if (!results.length) return null;
+  results.sort((a, b) => b.score - a.score);
  
-  cacheSet(ck, null); return null;
+  for (const r of results.slice(0, 8)) {
+    await sleep(180);
+    if (await _probeSlug(r.slug, { season })) return r.slug;
+  }
+  return null;
 }
  
-/**
- * Build and probe slug patterns from high to low probability.
- * Based on real subf2m URL patterns observed in the wild.
- */
-async function _smartSeriesPatterns(title, season, seasonYear, showYear) {
+async function _smartPatternSlugs(title, season, seasonYear, showYear) {
   const base = titleToSlug(title, null);
   const ord  = ORDINALS[season] || '';
   const pad  = String(season).padStart(2, '0');
   const patterns = [];
  
-  // ��─ Tier 1: exact season year from TMDB ──
+  // Tier 1 — TMDB season year exact
   if (seasonYear) {
     if (ord) {
       patterns.push(`${base}-${ord}-season-${seasonYear}`);
-      patterns.push(`${base}--${ord}-season-${seasonYear}`);           // double-dash variant
+      patterns.push(`${base}--${ord}-season-${seasonYear}`);
       patterns.push(`${base}-${ord}-season-tv-${seasonYear}`);
+      patterns.push(`${base}-the-${ord}-season-${seasonYear}`);
     }
     patterns.push(`${base}-season-${season}-${seasonYear}`);
     patterns.push(`${base}-s${pad}-${seasonYear}`);
-    patterns.push(`${base}-${seasonYear}`);                             // Fallout (2024) style
+    patterns.push(`${base}-${seasonYear}`);
   }
  
-  // ── Tier 2: ordinal & numeric without year ──
+  // Tier 2 — no year
   if (ord) {
     patterns.push(`${base}-${ord}-season`);
     patterns.push(`${base}--${ord}-season`);
+    patterns.push(`${base}-the-${ord}-season`);
+    patterns.push(`${base}-${ord}-series`);
   }
   patterns.push(`${base}-season-${season}`);
   patterns.push(`${base}-s${pad}`);
-  patterns.push(`${base}-season-${season}-${season}`);                 // some numeric dupe patterns
  
-  // ── Tier 3: adjacent years (handles delayed season premieres) ──
+  // Tier 3 — adjacent years
   const yearBase = seasonYear ? +seasonYear : (showYear ? +showYear : null);
   if (yearBase) {
-    for (const yr of [yearBase - 1, yearBase + 1]) {
-      if (ord) patterns.push(`${base}-${ord}-season-${yr}`);
+    for (const yr of [yearBase - 1, yearBase + 1, yearBase - 2]) {
+      if (ord) {
+        patterns.push(`${base}-${ord}-season-${yr}`);
+        patterns.push(`${base}-the-${ord}-season-${yr}`);
+      }
       patterns.push(`${base}-season-${season}-${yr}`);
       patterns.push(`${base}-${yr}`);
     }
   }
  
-  // ── Tier 4: title with show year + ordinal (older indexing style) ──
-  if (showYear && ord) {
-    patterns.push(`${base}-${showYear}-${ord}-season`);
-  }
- 
   const unique = [...new Set(patterns)].filter(Boolean);
-  console.log(`[slug-probe] Testing ${unique.length} patterns for "${title}" S${season}`);
+  console.log(`[slug] Probing ${unique.length} patterns for "${title}" S${season}`);
  
   for (const s of unique) {
     await sleep(120);
-    if (await _probeSlugExists(s)) {
-      console.log(`[slug-probe] HIT: ${s}`);
+    if (await _probeSlug(s, { season })) {
+      console.log(`[slug] HIT: ${s}`);
       return s;
     }
   }
   return null;
 }
  
-/**
- * Search subf2m for the series and pick the result whose display text
- * matches "title - ORDINAL season (YEAR)" as closely as possible.
- * This is how bazarr v1.4+ resolves series — the most reliable fallback.
- */
-async function _searchSeriesSlug(title, season, seasonYear, imdbId) {
-  const ord = (ORDINALS[season] || '').toLowerCase();
- 
-  // Try IMDB-ID first (avoids localised-title mismatches)
-  for (const query of [imdbId, title]) {
-    if (!query) continue;
-    const url  = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
-    const html = await getHTML(url);
-    if (!html) continue;
-    const $       = cheerio.load(html);
-    const firstWord = titleToSlug(title, null).split('-')[0];
-    const results = [];
-    const seen    = new Set();
+// ================================================================
+//  MOVIE SLUG RESOLUTION
+// ================================================================
+async function resolveMovieSlug(imdbId, titleHint, yearHint) {
+  const ck  = `mslug2:${imdbId}`;
+  const hit = cacheGet(ck);
+  if (hit !== null) return hit;
+ 
+  const tmdb  = await getTMDB(imdbId);
+  const title = tmdb?.title || titleHint;
+  const year  = tmdb?.year  || yearHint;
  
-    $('a[href]').each((_, a) => {
-      const href = $(a).attr('href') || '';
-      if (!href.startsWith('/subtitles/')) return;
+  // Strategy 1: Direct slug (most common pattern)
+  if (title && year) {
+    const direct = titleToSlug(title, year);
+    if (await _probeMovieSlug(direct, title)) { cacheSet(ck, direct); return direct; }
+  }
+ 
+  // Strategy 2: Search by IMDb ID
+  let slug = await _searchMovieSlug(imdbId, year);
+  if (slug && await _probeMovieSlug(slug, title)) { cacheSet(ck, slug); return slug; }
+ 
+  // Strategy 3: Search by title
+  if (title) {
+    slug = await _searchMovieSlug(title, year);
+    if (slug && await _probeMovieSlug(slug, title)) { cacheSet(ck, slug); return slug; }
+ 
+    // Strategy 4: Brute-force slugs
+    const candidates = [];
+    if (year) {
+      candidates.push(titleToSlug(title, year));
+      candidates.push(titleToSlug(title, String(+year - 1)));
+      candidates.push(titleToSlug(title, String(+year + 1)));
+    }
+    candidates.push(titleToSlug(title, null));
+    for (const c of [...new Set(candidates)]) {
+      await sleep(250);
+      if (await _probeMovieSlug(c, title)) { cacheSet(ck, c); return c; }
+    }
+  }
+ 
+  cacheSet(ck, null);
+  return null;
+}
+ 
+async function _searchMovieSlug(query, yearHint) {
+  const url  = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
+  const html = await getHTML(url);
+  if (!html) return null;
+  const $       = cheerio.load(html);
+  const results = [];
+  const SELS    = ['ul.search-result li','.search-result li','.content ul li','section ul li','ul li','li'];
+  let   found   = false;
+ 
+  for (const sel of SELS) {
+    const items = $(sel);
+    if (!items.length) continue;
+    items.each((_, el) => {
+      const a    = $(el).find('a[href]').first();
+      const href = a.attr('href') || '';
+      if (!href.startsWith('/subtitles/') || href === '/subtitles/searchbytitle') return;
       const parts = href.split('/').filter(Boolean);
       if (parts.length < 2) return;
       const slug = parts[1];
-      if (!slug || slug === 'searchbytitle' || seen.has(slug)) return;
-      seen.add(slug);
-      const slugLow = slug.toLowerCase();
-      if (!slugLow.startsWith(firstWord)) return;
- 
-      let score = 0;
-      if (ord && slugLow.includes(`${ord}-season`))                       score += 100;
-      if (ord && slugLow.includes(`${ord}season`))                        score += 90;
-      if (slugLow.includes(`season-${season}`))                           score += 80;
-      if (slugLow.includes(`-s${pad(season)}`))                           score += 80;
-      if (seasonYear && slugLow.includes(String(seasonYear)))             score += 20;
-      if (score > 0) results.push({ slug, score });
+      if (!slug || slug === 'searchbytitle') return;
+      const text    = _clean(a.text());
+      const yrMatch = text.match(/\((\d{4})\)/);
+      const resYear = yrMatch ? +yrMatch[1] : null;
+      let   score   = 1;
+      if (query.startsWith('tt'))                score += 100;
+      if (yearHint && resYear === +yearHint)      score += 10;
+      // Penalise series results in movie search
+      if (text.toLowerCase().includes('season')) score -= 5;
+      results.push({ slug, score });
+      found = true;
     });
+    if (found) break;
+  }
  
-    if (!results.length) {
-      // If we find the bare title (e.g. "fallout-2024"), that works for single-season shows
-      $('a[href]').each((_, a) => {
-        const href = $(a).attr('href') || '';
-        if (!href.startsWith('/subtitles/')) return;
-        const parts = href.split('/').filter(Boolean);
-        if (parts.length < 2) return;
-        const slug = parts[1];
-        if (!slug || seen.has(slug)) return;
-        seen.add(slug);
-        if (slug.toLowerCase().startsWith(firstWord)) results.push({ slug, score: 5 });
-      });
-    }
+  if (!results.length) return null;
+  results.sort((a, b) => b.score - a.score);
+  return results[0].slug;
+}
  
-    if (results.length) {
-      results.sort((a, b) => b.score - a.score);
-      for (const r of results.slice(0, 6)) {
-        await sleep(150);
-        if (await _probeSlugExists(r.slug)) return r.slug;
-      }
+async function _probeMovieSlug(slug, expectedTitle) {
+  if (!slug) return false;
+  try {
+    const html = await getHTML(`${BASE}/subtitles/${slug}/english`);
+    if (!html || html.length < 1500) return false;
+    if (expectedTitle) {
+      const $         = cheerio.load(html);
+      const pageTitle = ($('title').text() || '').toLowerCase();
+      const exp       = expectedTitle.toLowerCase();
+      // Accept if title appears in page title OR if there are subtitle items
+      return pageTitle.includes(exp) || html.includes('class="item"') || html.includes('class="r"');
     }
-  }
-  return null;
+    return true;
+  } catch (_) { return false; }
 }
-function pad(n) { return String(n).padStart(2, '0'); }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  SUBTITLE LIST SCRAPING
-// ═══════════════════════════════════════════════════════════════════
-async function getSubsList(slug, lang, season, episode) {
+// ================================================================
+//  SUBTITLE SCRAPING
+// ================================================================
+async function getSubsList(slug, lang, season, episode, streamTokens) {
   if (!ALLOWED_LANGS.has(lang)) return [];
   const ck  = `list2:${slug}:${lang}:${episode || 0}`;
   const hit = cacheGet(ck);
@@ -577,40 +625,47 @@ async function getSubsList(slug, lang, season, episode) {
   const html = await getHTML(url);
   if (!html) { cacheSet(ck, []); return []; }
   const $  = cheerio.load(html);
-  let raw  = [];
+  let   raw = [];
+ 
+  // Primary scraper
   $('li.item').each((_, el) => { _extractItem($, el, lang, raw); });
  
+  // Fallback 1: table rows
+  if (!raw.length) {
+    $('tr, .subtitle-item, .item').each((_, el) => { _extractItem($, el, lang, raw); });
+  }
+ 
+  // Fallback 2: any anchor with matching lang path
   if (!raw.length) {
-    // Fallback: any anchor that looks like a detail link
     $('a[href]').each((_, a) => {
       const href = $(a).attr('href') || '';
       if (!href.includes(`/${lang}/`) || !/\/\d+$/.test(href)) return;
       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: ''
-      });
+      const full = href.startsWith('http') ? href : `${BASE}${href}`;
+      raw.push({ subId, detailUrl: full, isGood: false, releaseInfo: '', comment: '', authorNote: '', lang, goodVotes: 0, badVotes: 0, downloads: 0, _rawText: '' });
     });
   }
  
-  // For series: filter to exact season+episode if possible
-  if (season && episode) {
+  // Filter to exact episode if possible
+  if (season && episode && raw.length) {
     const expected = `s${String(season).padStart(2,'0')}e${String(episode).padStart(2,'0')}`;
     const filtered = raw.filter(item => {
       const txt = (item._rawText || item.releaseInfo || '').toLowerCase();
       return txt.includes(expected);
     });
     if (filtered.length) raw = filtered;
-    // else keep all (season pack / different naming)
   }
  
+  // Deduplicate
   const seen   = new Set();
   const unique = raw.filter(s => { if (seen.has(s.subId)) return false; seen.add(s.subId); return true; });
-  const enriched = (await Promise.all(unique.slice(0, MAX_DETAIL).map(s => _enrichSub(s)))).filter(Boolean);
+ 
+  const toEnrich = unique.slice(0, MAX_DETAIL);
+  const enriched = (await Promise.all(toEnrich.map(s => _enrichSub(s)))).filter(Boolean);
   const human    = enriched.filter(s => !isAISub(`${s.releaseInfo} ${s.comment} ${s.authorNote}`));
+ 
   cacheSet(ck, human);
   return human;
 }
@@ -619,33 +674,40 @@ 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;
   const hLow = detailHref.toLowerCase();
   if (!hLow.includes(`/${lang}/`)) return;
   if (OTHER_LANGS.some(ol => hLow.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.hasClass('good') || $el.hasClass('positive') ||
     ($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);
+                          .map((_, li) => $(li).text().trim()).get().filter(Boolean);
+  const releaseInfo  = (releaseLines.join(' | ') || _clean($el.text())).substring(0, 130);
+ 
   if (isAISub(`${comment} ${releaseInfo}`)) return;
+ 
   out.push({
     subId,
-    detailUrl : detailHref.startsWith('http') ? detailHref : `${BASE}${detailHref}`,
+    detailUrl: detailHref.startsWith('http') ? detailHref : `${BASE}${detailHref}`,
     isGood, releaseInfo, comment, authorNote: '', lang,
-    goodVotes: 0, badVotes: 0, downloads: 0, _rawText: rawText
+    goodVotes: 0, badVotes: 0, downloads: 0, _rawText: rawText,
   });
 }
  
@@ -653,54 +715,47 @@ async function _enrichSub(sub) {
   const ck  = `det2:${sub.subId}`;
   const hit = cacheGet(ck);
   if (hit !== null) { if (hit.__aiBlocked) 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 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 $          = 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; }
+ 
+  if (isAISub(`${authorNote} ${sub.releaseInfo} ${sub.comment}`)) {
+    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;
-  const patch = { releaseInfo, goodVotes, badVotes, downloads, isGood, authorNote };
-  cacheSet(ck, patch);
-  return { ...sub, ...patch };
+ 
+  const enriched = { ...sub, releaseInfo, goodVotes, badVotes, downloads, isGood, authorNote };
+  cacheSet(ck, enriched);
+  return enriched;
 }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  DOWNLOAD & SRT EXTRACTION (with proxy fallback chain)
-// ═══════════════════════════════════════════════════════════════════
+// ================================================================
+//  DOWNLOAD & SRT EXTRACTION
+// ================================================================
 async function fetchSRT(downloadUrl) {
   const ck  = `srt2:${downloadUrl}`;
   const hit = cacheGet(ck);
   if (hit !== null) return hit;
   try {
-    // Try direct first (no proxy overhead)
-    let buf = await getBinary(downloadUrl);
- 
-    // Proxy fallback chain if direct fails
-    if (!buf) {
-      for (const proxyFn of [PROXY_1, PROXY_2, PROXY_3]) {
-        try {
-          buf = await getBinary(proxyFn(downloadUrl));
-          if (buf) { console.log(`[proxy] success with ${proxyFn(downloadUrl).substring(0,40)}`); break; }
-        } catch (_) {}
-        await sleep(300);
-      }
-    }
- 
+    const buf = await getBinary(downloadUrl);
     if (!buf) return null;
     const content = _extractFromZip(buf) ?? _tryDirect(buf);
     if (!content) return null;
     cacheSet(ck, content);
     return content;
-  } catch (e) { return null; }
+  } catch (_) { return null; }
 }
  
 function _extractFromZip(buf) {
@@ -714,7 +769,7 @@ function _extractFromZip(buf) {
       })
       .sort((a, b) => (RANK[_ext(a.entryName)] ?? 9) - (RANK[_ext(b.entryName)] ?? 9));
     for (const f of files) {
-      const raw = zip.readFile(f);
+      const raw  = zip.readFile(f);
       if (!raw) continue;
       const text = _decode(raw);
       if (_isSub(text)) return text;
@@ -722,6 +777,7 @@ function _extractFromZip(buf) {
   } catch (_) {}
   return null;
 }
+ 
 function _tryDirect(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;
@@ -732,18 +788,40 @@ function _decode(buf) {
   return buf.toString('latin1');
 }
  
-// ═══════════════════════════════════════════════════════════════════
-// ██  ROUTES
-// ═══════════════════════════════════════════════════════════════════
+// ================================================================
+//  SORT: index [0] = best subtitle
+//  Movies: sort by downloads desc (most popular = best sync).
+//  Series: sort by scoreSubtitle desc (exact S##E## + group match).
+// ================================================================
+function sortForBest(subs, streamTokens, type) {
+  if (type === 'series' && streamTokens) {
+    return subs
+      .map(s => ({ ...s, _score: scoreSubtitle(s, streamTokens) }))
+      .sort((a, b) => {
+        if (b._score !== a._score) return b._score - a._score;
+        if (b.isGood !== a.isGood) return b.isGood ? 1 : -1;
+        return b.downloads - a.downloads;
+      });
+  }
+  // Movies: isGood first, then downloads
+  return subs.slice().sort((a, b) => {
+    if (b.isGood !== a.isGood) return b.isGood ? 1 : -1;
+    return b.downloads - a.downloads;
+  });
+}
+ 
+// ================================================================
+//  ROUTES
+// ================================================================
 app.get('/manifest.json', (req, res) => res.json({
-  id         : 'org.van.vansub2fmplus.v1',
-  name       : 'VanSub2FM+',
-  description: 'Human-Verified Arabic & English subtitles from subf2m.co. Anti-AI. High accuracy.',
-  version    : '1.0.0',
+  id         : 'org.van.vansubf2mplus.v2',
+  name       : 'VanSubF2M+',
+  description: 'Human-Verified Arabic & English subtitles. Anti-AI. Enhanced 100% coverage.',
+  version    : '2.0.0',
   resources  : ['subtitles'],
   types      : ['movie', 'series'],
   idPrefixes : ['tt'],
-  catalogs   : []
+  catalogs   : [],
 }));
  
 app.get('/sub/:enc.srt', async (req, res) => {
@@ -753,9 +831,9 @@ app.get('/sub/:enc.srt', async (req, res) => {
   if (!dlUrl.startsWith('https://subf2m.co/') || !dlUrl.includes('/subtitles/') || !dlUrl.endsWith('/download'))
     return res.status(403).end('Forbidden');
   const content = await fetchSRT(dlUrl);
-  if (!content) return res.status(404).end('Subtitle not found');
-  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-  res.setHeader('Cache-Control', 'public, max-age=86400');
+  if (!content) return res.status(404).end('Not found');
+  res.setHeader('Content-Type',        'text/plain; charset=utf-8');
+  res.setHeader('Cache-Control',       'public, max-age=86400');
   res.setHeader('Content-Disposition', 'inline; filename="subtitle.srt"');
   res.end(content);
 });
@@ -765,7 +843,6 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
   const { type, id } = req.params;
   if (!id?.startsWith('tt')) return res.json({ subtitles: [] });
  
-  // Short-lived result cache (don't cache for more than 30 min at result level)
   const ck  = `result2:${id}`;
   const hit = cacheGet(ck);
   if (hit) return res.json({ subtitles: hit });
@@ -788,51 +865,44 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
       slug = await resolveSeriesSlug(imdbId, season);
     } else {
       const tmdb = await getTMDB(imdbId);
-      slug = await resolveMovieSlug(imdbId, tmdb?.title || null, tmdb?.year || null);
+      slug       = await resolveMovieSlug(imdbId, tmdb?.title || null, tmdb?.year || null);
     }
  
     if (!slug) return res.json({ subtitles: [] });
  
     const [engRes, araRes] = await Promise.allSettled([
-      getSubsList(slug, 'english', season, episode),
-      getSubsList(slug, 'arabic',  season, episode)
+      getSubsList(slug, 'english', season, episode, streamTokens),
+      getSubsList(slug, 'arabic',  season, episode, streamTokens),
     ]);
  
-    let engSubs = engRes.status === 'fulfilled' ? engRes.value : [];
-    let araSubs = araRes.status === 'fulfilled' ? araRes.value : [];
- 
-    // Sort by score (best first = subtitle[0])
-    const rank = (subs) => subs
-      .map(s => ({ ...s, _score: scoreSubtitle(s, streamTokens) }))
-      .sort((a, b) => b._score - a._score)
-      .slice(0, MAX_PER_LANG);
+    let engSubs = (engRes.status === 'fulfilled' ? engRes.value : []);
+    let araSubs = (araRes.status === 'fulfilled' ? araRes.value : []);
  
-    engSubs = rank(engSubs);
-    araSubs = rank(araSubs);
+    // Sort so [0] = best, then cap at MAX_PER_LANG
+    engSubs = sortForBest(engSubs, streamTokens, type).slice(0, MAX_PER_LANG);
+    araSubs = sortForBest(araSubs, streamTokens, type).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 build = (subs, langCode, flag) => subs.map(s => {
-      const dlUrl = `${s.detailUrl}/download`;
-      const enc   = Buffer.from(dlUrl).toString('base64url');
-      const badge = s.isGood ? ' ⭐' : '';
-      const votes = s.goodVotes > 0 ? ` [👍${s.goodVotes}]` : '';
-      const dl    = s.downloads > 0 ? ` [⬇${s.downloads}]` : '';
-      const name  = `${flag}${badge}${votes}${dl} ${s.releaseInfo}`.trim().substring(0, 100);
-      return { id: `vsub2-${langCode}-${s.subId}`, url: `${origin}/sub/${enc}.srt`, lang: langCode, name };
+      const dlUrl  = `${s.detailUrl}/download`;
+      const enc    = Buffer.from(dlUrl).toString('base64url');
+      const badge  = s.isGood   ? ' ⭐' : '';
+      const votes  = s.goodVotes > 0 ? ` [👍${s.goodVotes}]` : '';
+      const dls    = s.downloads > 0 ? ` [⬇${s.downloads}]` : '';
+      const name   = `${flag}${badge}${votes}${dls} ${s.releaseInfo}`.trim().substring(0, 100);
+      return { id: `vsub-${langCode}-${s.subId}`, url: `${origin}/sub/${enc}.srt`, lang: langCode, name };
     });
  
-    const subtitles = [...build(engSubs, 'eng', '🇺🇸'), ...build(araSubs, 'ara', '🇸🇦')];
+    const subtitles = [...build(engSubs, 'eng', '🇺🇸 English'), ...build(araSubs, 'ara', '🇸🇦 Arabic')];
     cacheSet(ck, subtitles);
     res.json({ subtitles });
   } catch (e) {
-    console.error('[route-error]', e);
+    console.error('[route]', e.message);
     res.json({ subtitles: [] });
   }
 });
  
-app.listen(PORT, '0.0.0.0', () =>
-  console.log(`✅ VanSub2FM+ v1.0.0 → http://0.0.0.0:${PORT}`)
-);
+app.listen(PORT, '0.0.0.0', () =>