Update index.js

index.js

@@ -35,6 +35,7 @@ const REQ_TIMEOUT  = 18_000;
 const DL_TIMEOUT   = 30_000;
 const MAX_DETAIL   = 30;
  
+// Full ordinal list covering seasons 1–30
 const ORDINALS = [
   '', 'first', 'second', 'third', 'fourth', 'fifth',
   'sixth', 'seventh', 'eighth', 'ninth', 'tenth',
@@ -155,6 +156,7 @@ 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 {
@@ -162,6 +164,7 @@ async function getBinary(url, tries = 3) {
       if (r !== null) return r;
     } catch (_) {}
   }
+  // Proxy chain
   const enc   = encodeURIComponent(url);
   const proxied = [
     `${PROXY_1}${enc}`,
@@ -199,25 +202,16 @@ const sleep = ms => new Promise(r => setTimeout(r, ms));
 // ================================================================
 //  STRING UTILS
 // ================================================================
-
-// Standard slug: lowercases, strips accents, keeps only a-z0-9 and spaces→dashes
-// IMPORTANT: does NOT collapse multiple dashes — subf2m uses double-dash for some titles (e.g. friends--first-season)
 function titleToSlug(title, year) {
   const base = (title || '').toLowerCase()
     .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
-    .replace(/[^a-z0-9\s-]/g, '')   // keep existing dashes too
+    .replace(/[^a-z0-9\s]/g, '')
     .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
     .replace(/^-|-$/g, '');
   return year ? `${base}-${year}` : base;
 }
-
-// Slug builder that PRESERVES double-dashes coming from search result hrefs
-// (subf2m itself outputs these — we must not sanitise them away)
-function hrefToSlug(href) {
-  const parts = href.split('/').filter(Boolean);
-  return parts.length >= 2 ? parts[1] : '';
-}
-
+ 
 function _clean(t) { return (t || '').replace(/\s+/g, ' ').trim(); }
  
 // ================================================================
@@ -271,7 +265,7 @@ function scoreSubtitle(sub, streamTokens) {
 }
  
 // ================================================================
-//  TMDB  —  now also returns originalName + originalLanguage
+//  TMDB
 // ================================================================
 async function getTMDB(imdbId) {
   const ck  = `tmdb:${imdbId}`;
@@ -287,24 +281,10 @@ async function getTMDB(imdbId) {
     let   info = null;
     if (d.movie_results?.length) {
       const m = d.movie_results[0];
-      info = {
-        title          : m.title || m.original_title,
-        originalTitle  : m.original_title || m.title,
-        originalLanguage: m.original_language || 'en',
-        year           : m.release_date?.substring(0,4) || null,
-        type           : 'movie',
-        tmdbId         : m.id,
-      };
+      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,
-        originalTitle  : t.original_name || t.name,
-        originalLanguage: t.original_language || 'en',
-        year           : t.first_air_date?.substring(0,4) || null,
-        type           : 'series',
-        tmdbId         : t.id,
-      };
+      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;
@@ -326,20 +306,24 @@ async function getTMDBSeasonYear(tmdbId, season) {
 }
  
 // ================================================================
-//  SLUG PROBING
+//  SLUG PROBING — FIXED
+//  No longer requires S##E## on the page — any item list qualifies.
 // ================================================================
 async function _probeSlug(slug, opts = {}) {
-  if (!slug || slug.length > 280) return false;
+  if (!slug || slug.length > 220) return false;
   try {
     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 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}`) ||
@@ -354,125 +338,111 @@ async function _probeSlug(slug, opts = {}) {
 }
  
 // ================================================================
-//  SERIES SLUG RESOLUTION
-//  New: handles anime (original_language != en → search by original title too)
-//       handles double-dash slugs (friends--first-season)
+//  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  = `sslug3:${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;
-  const origTitle   = tmdb?.originalTitle;
-  const origLang    = tmdb?.originalLanguage || 'en';
-  const showYear    = tmdb?.year;
-  const seasonYear  = tmdb?.tmdbId ? await getTMDBSeasonYear(tmdb.tmdbId, season) : null;
-  const isAnime     = origLang !== 'en' && origTitle && origTitle !== title;
-
-  // Build ordered list of queries to try
-  const queries = [];
-
-  // 1. IMDb ID — most reliable, always first
-  queries.push(imdbId);
-
-  // 2. Original (non-English) title — critical for anime like Attack on Titan → shingeki-no-kyojin
-  if (isAnime) queries.push(origTitle);
-
-  // 3. English title
-  if (title) queries.push(title);
-
-  for (const q of queries) {
-    const slug = await _searchSeriesSlugByQuery(q, season, title, origTitle, seasonYear, showYear, isAnime);
+  const tmdb      = await getTMDB(imdbId);
+  const title     = tmdb?.title;
+  const showYear  = tmdb?.year;
+  const seasonYear = tmdb?.tmdbId ? await getTMDBSeasonYear(tmdb.tmdbId, season) : null;
+ 
+  // 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; }
   }
-
-  // 4. Smart pattern brute-force using both title forms
+ 
+  // Strategy 3: Smart pattern brute-force
   if (title) {
-    let slug = await _smartPatternSlugs(title, origTitle, season, seasonYear, showYear, isAnime);
+    slug = await _smartPatternSlugs(title, season, seasonYear, showYear);
     if (slug) { cacheSet(ck, slug); return slug; }
   }
-
-  // 5. Bare slug fallback
+ 
+  // 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; }
     }
   }
-  if (isAnime && origTitle) {
-    const bareOrig = titleToSlug(origTitle, null);
-    if (await _probeSlug(bareOrig, { season })) { cacheSet(ck, bareOrig); return bareOrig; }
-  }
-
+ 
   cacheSet(ck, null);
   return null;
 }
  
-async function _searchSeriesSlugByQuery(query, season, titleHint, origTitleHint, seasonYear, showYear, isAnime) {
+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();
-
-  // First word of the English title slug (for filtering unrelated results)
-  const engFirstWord  = titleHint  ? titleToSlug(titleHint,  null).split('-')[0] : '';
-  // First word of the original title slug (for anime)
-  const origFirstWord = origTitleHint ? titleToSlug(origTitleHint, null).split('-')[0] : '';
-
+  const firstWord = titleHint ? titleToSlug(titleHint, null).split('-')[0] : '';
   const results = [];
   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;
-    // Use raw href segment — PRESERVES double-dash (friends--first-season)
     const slug = parts[1];
     if (!slug || slug === 'searchbytitle' || seen.has(slug)) return;
     seen.add(slug);
  
     const rawText = _clean($(a).text());
     const slugLow = slug.toLowerCase();
-
-    // Filter: slug must start with a known first-word (eng or orig)
-    const matchesEng  = engFirstWord  && slugLow.startsWith(engFirstWord);
-    const matchesOrig = origFirstWord && slugLow.startsWith(origFirstWord);
-    if (engFirstWord && origFirstWord) {
-      if (!matchesEng && !matchesOrig) return;
-    } else if (engFirstWord && !matchesEng) return;
-    else if (origFirstWord && !matchesOrig) return;
+ 
+    // 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;
     }
  
-    // Slug pattern scoring (works with double-dash too)
-    if (ord && slugLow.includes(`-${ord}-season`)) score = Math.max(score, 80);
-    if (ord && slugLow.includes(`--${ord}-season`)) score = Math.max(score, 85); // double-dash bonus
-    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);
-
-    // Anime-specific: bonus when slug contains the original-language romanization
-    if (isAnime && origFirstWord && slugLow.startsWith(origFirstWord)) score += 30;
+    // 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);
  
     if (score > 0) results.push({ slug, score });
   });
@@ -487,80 +457,50 @@ async function _searchSeriesSlugByQuery(query, season, titleHint, origTitleHint,
   return null;
 }
  
-async function _smartPatternSlugs(title, origTitle, season, seasonYear, showYear, isAnime) {
-  const base     = titleToSlug(title, null);
-  const origBase = origTitle ? titleToSlug(origTitle, null) : null;
-  const ord      = ORDINALS[season] || '';
-  const pad      = String(season).padStart(2, '0');
+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 = [];
-
-  // ── Anime-first patterns (original title base) ──────────────────
-  if (isAnime && origBase) {
-    if (seasonYear) {
-      if (ord) {
-        patterns.push(`${origBase}-${ord}-season-${seasonYear}`);
-        patterns.push(`${origBase}-${ord}-season`);
-      }
-      patterns.push(`${origBase}-${seasonYear}`);
-      patterns.push(`${origBase}-season-${season}-${seasonYear}`);
-    }
-    if (ord) {
-      patterns.push(`${origBase}-${ord}-season`);
-      patterns.push(`${origBase}-${ord}-series`);
-    }
-    patterns.push(`${origBase}-season-${season}`);
-    patterns.push(`${origBase}`);
-    // Compound slug e.g. shingeki-no-kyojin-attack-on-titan (S1 of AoT)
-    patterns.push(`${origBase}-${base}`);
-    if (ord) {
-      patterns.push(`${origBase}-${ord}-season-${base}`);
-      patterns.push(`${origBase}-${ord}-season-${base}-${season}`);
-      // e.g. shingeki-no-kyojin-second-season-attack-on-titan-2
-      patterns.push(`${origBase}-${ord}-season-${base}-${season}`);
-    }
-    // e.g. shingeki-no-kyojin-attack-on-titan-fourth-season
-    if (ord) patterns.push(`${origBase}-${base}-${ord}-season`);
-    if (ord && seasonYear) patterns.push(`${origBase}-${base}-${ord}-season-${seasonYear}`);
-  }
-
-  // ── Standard English title patterns ─────────────────────────────
+ 
+  // Tier 1 — TMDB season year exact
   if (seasonYear) {
     if (ord) {
       patterns.push(`${base}-${ord}-season-${seasonYear}`);
-      // Double-dash variant: friends--first-season-1994
       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}`);
   }
-
+ 
+  // Tier 2 — no year
   if (ord) {
     patterns.push(`${base}-${ord}-season`);
-    // Double-dash variant: friends--first-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}`);
-
-  // Adjacent years
+ 
+  // Tier 3 — adjacent years
   const yearBase = seasonYear ? +seasonYear : (showYear ? +showYear : null);
   if (yearBase) {
     for (const yr of [yearBase - 1, yearBase + 1, yearBase - 2]) {
       if (ord) {
         patterns.push(`${base}-${ord}-season-${yr}`);
-        patterns.push(`${base}--${ord}-season-${yr}`);
+        patterns.push(`${base}-the-${ord}-season-${yr}`);
       }
       patterns.push(`${base}-season-${season}-${yr}`);
       patterns.push(`${base}-${yr}`);
     }
   }
-
+ 
   const unique = [...new Set(patterns)].filter(Boolean);
-  console.log(`[slug] Probing ${unique.length} patterns for "${title}"${isAnime ? ` / "${origTitle}"` : ''} S${season}`);
+  console.log(`[slug] Probing ${unique.length} patterns for "${title}" S${season}`);
  
   for (const s of unique) {
     await sleep(120);
@@ -576,57 +516,36 @@ async function _smartPatternSlugs(title, origTitle, season, seasonYear, showYear
 //  MOVIE SLUG RESOLUTION
 // ================================================================
 async function resolveMovieSlug(imdbId, titleHint, yearHint) {
-  const ck  = `mslug3:${imdbId}`;
+  const ck  = `mslug2:${imdbId}`;
   const hit = cacheGet(ck);
   if (hit !== null) return hit;
  
-  const tmdb       = await getTMDB(imdbId);
-  const title      = tmdb?.title      || titleHint;
-  const origTitle  = tmdb?.originalTitle;
-  const origLang   = tmdb?.originalLanguage || 'en';
-  const year       = tmdb?.year       || yearHint;
-  const isAnime    = origLang !== 'en' && origTitle && origTitle !== title;
-
-  // Direct slug attempt (English)
+  const tmdb  = await getTMDB(imdbId);
+  const title = tmdb?.title || titleHint;
+  const year  = tmdb?.year  || yearHint;
+ 
+  // 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; }
   }
-  // Direct slug attempt (original title for anime)
-  if (isAnime && origTitle && year) {
-    const directOrig = titleToSlug(origTitle, year);
-    if (await _probeMovieSlug(directOrig, title)) { cacheSet(ck, directOrig); return directOrig; }
-  }
-
-  // Search by IMDb ID
-  let slug = await _searchMovieSlug(imdbId, year, title, origTitle);
+ 
+  // Strategy 2: Search by IMDb ID
+  let slug = await _searchMovieSlug(imdbId, year);
   if (slug && await _probeMovieSlug(slug, title)) { cacheSet(ck, slug); return slug; }
-
-  // Search by original title (anime)
-  if (isAnime && origTitle) {
-    slug = await _searchMovieSlug(origTitle, year, title, origTitle);
-    if (slug && await _probeMovieSlug(slug, title)) { cacheSet(ck, slug); return slug; }
-  }
-
-  // Search by English title
+ 
+  // Strategy 3: Search by title
   if (title) {
-    slug = await _searchMovieSlug(title, year, title, origTitle);
+    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)));
     }
-    if (isAnime && origTitle) {
-      if (year) {
-        candidates.push(titleToSlug(origTitle, year));
-        candidates.push(titleToSlug(origTitle, String(+year - 1)));
-        candidates.push(titleToSlug(origTitle, String(+year + 1)));
-      }
-      candidates.push(titleToSlug(origTitle, null));
-    }
     candidates.push(titleToSlug(title, null));
     for (const c of [...new Set(candidates)]) {
       await sleep(250);
@@ -638,7 +557,7 @@ async function resolveMovieSlug(imdbId, titleHint, yearHint) {
   return null;
 }
  
-async function _searchMovieSlug(query, yearHint, titleHint, origTitleHint) {
+async function _searchMovieSlug(query, yearHint) {
   const url  = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
   const html = await getHTML(url);
   if (!html) return null;
@@ -656,7 +575,7 @@ async function _searchMovieSlug(query, yearHint, titleHint, origTitleHint) {
       if (!href.startsWith('/subtitles/') || href === '/subtitles/searchbytitle') return;
       const parts = href.split('/').filter(Boolean);
       if (parts.length < 2) return;
-      const slug = parts[1];  // raw — preserves double-dash
+      const slug = parts[1];
       if (!slug || slug === 'searchbytitle') return;
       const text    = _clean(a.text());
       const yrMatch = text.match(/\((\d{4})\)/);
@@ -664,6 +583,7 @@ async function _searchMovieSlug(query, yearHint, titleHint, origTitleHint) {
       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;
@@ -685,6 +605,7 @@ async function _probeMovieSlug(slug, 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 true;
@@ -696,7 +617,7 @@ async function _probeMovieSlug(slug, expectedTitle) {
 // ================================================================
 async function getSubsList(slug, lang, season, episode, streamTokens) {
   if (!ALLOWED_LANGS.has(lang)) return [];
-  const ck  = `list3:${slug}:${lang}:${episode || 0}`;
+  const ck  = `list2:${slug}:${lang}:${episode || 0}`;
   const hit = cacheGet(ck);
   if (hit) return hit;
  
@@ -706,12 +627,15 @@ async function getSubsList(slug, lang, season, episode, streamTokens) {
   const $  = cheerio.load(html);
   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) {
     $('a[href]').each((_, a) => {
       const href = $(a).attr('href') || '';
@@ -724,6 +648,7 @@ async function getSubsList(slug, lang, season, episode, streamTokens) {
     });
   }
  
+  // 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 => {
@@ -733,6 +658,7 @@ async function getSubsList(slug, lang, season, episode, streamTokens) {
     if (filtered.length) raw = filtered;
   }
  
+  // Deduplicate
   const seen   = new Set();
   const unique = raw.filter(s => { if (seen.has(s.subId)) return false; seen.add(s.subId); return true; });
  
@@ -786,7 +712,7 @@ function _extractItem($, el, lang, out) {
 }
  
 async function _enrichSub(sub) {
-  const ck  = `det3:${sub.subId}`;
+  const ck  = `det2:${sub.subId}`;
   const hit = cacheGet(ck);
   if (hit !== null) { if (hit.__aiBlocked) return null; return { ...sub, ...hit }; }
  
@@ -816,7 +742,56 @@ async function _enrichSub(sub) {
 }
  
 // ================================================================
-//  SORT
+//  DOWNLOAD & SRT EXTRACTION
+// ================================================================
+async function fetchSRT(downloadUrl) {
+  const ck  = `srt2:${downloadUrl}`;
+  const hit = cacheGet(ck);
+  if (hit !== null) return hit;
+  try {
+    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 (_) { return null; }
+}
+ 
+function _extractFromZip(buf) {
+  try {
+    const zip  = new AdmZip(buf);
+    const RANK = { '.srt': 0, '.vtt': 1, '.ass': 2, '.ssa': 3 };
+    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 raw  = zip.readFile(f);
+      if (!raw) continue;
+      const text = _decode(raw);
+      if (_isSub(text)) return text;
+    }
+  } 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;
+function _decode(buf) {
+  const hasBOM = buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF;
+  const u8     = buf.slice(hasBOM ? 3 : 0).toString('utf8');
+  if (_isSub(u8)) return u8;
+  return buf.toString('latin1');
+}
+ 
+// ================================================================
+//  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) {
@@ -828,6 +803,7 @@ function sortForBest(subs, streamTokens, type) {
         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;
@@ -838,10 +814,10 @@ function sortForBest(subs, streamTokens, type) {
 //  ROUTES
 // ================================================================
 app.get('/manifest.json', (req, res) => res.json({
-  id         : 'org.van.vansubf2mplus.v3',
+  id         : 'org.van.vansubf2mplus.v2',
   name       : 'VanSubF2M+',
   description: 'Human-Verified Arabic & English subtitles. Anti-AI. Enhanced 100% coverage.',
-  version    : '3.0.0',
+  version    : '2.0.0',
   resources  : ['subtitles'],
   types      : ['movie', 'series'],
   idPrefixes : ['tt'],
@@ -867,7 +843,7 @@ 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  = `result3:${id}`;
+  const ck  = `result2:${id}`;
   const hit = cacheGet(ck);
   if (hit) return res.json({ subtitles: hit });
  
@@ -902,6 +878,7 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
     let engSubs = (engRes.status === 'fulfilled' ? engRes.value : []);
     let araSubs = (araRes.status === 'fulfilled' ? araRes.value : []);
  
+    // 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);
  
@@ -928,53 +905,6 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
   }
 });
  
-// ================================================================
-//  DOWNLOAD & SRT EXTRACTION
-// ================================================================
-async function fetchSRT(downloadUrl) {
-  const ck  = `srt3:${downloadUrl}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit;
-  try {
-    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 (_) { return null; }
-}
- 
-function _extractFromZip(buf) {
-  try {
-    const zip  = new AdmZip(buf);
-    const RANK = { '.srt': 0, '.vtt': 1, '.ass': 2, '.ssa': 3 };
-    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 raw  = zip.readFile(f);
-      if (!raw) continue;
-      const text = _decode(raw);
-      if (_isSub(text)) return text;
-    }
-  } 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;
-function _decode(buf) {
-  const hasBOM = buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF;
-  const u8     = buf.slice(hasBOM ? 3 : 0).toString('utf8');
-  if (_isSub(u8)) return u8;
-  return buf.toString('latin1');
-}
- 
 app.listen(PORT, '0.0.0.0', () => {
   console.log(`Server running on port ${PORT}`);
 });