Update index.js

index.js

@@ -1,203 +1,468 @@
+'use strict';
 
 const express = require('express');
-const fetch = require('node-fetch');
+const fetch   = require('node-fetch');
+const AdmZip  = require('adm-zip');
+const app     = express();
+const PORT    = process.env.PORT || 7860;
 
-const app = express();
-const PORT = process.env.PORT || 7860;
+const BASE_URL = process.env.SPACE_HOST
+  ? `https://${process.env.SPACE_HOST}`
+  : `http://localhost:${PORT}`;
 
 app.use((req, res, next) => {
-  res.header('Access-Control-Allow-Origin', '*');
-  res.header('Access-Control-Allow-Headers', '*');
-  res.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
   if (req.method === 'OPTIONS') return res.sendStatus(200);
   next();
 });
 
-const UPSTREAM_URLS = [
-  'https://torrentio.strem.fun',
-  'https://torrentio.stremio.my.id'
-];
+const SUBDL_KEY = process.env.SUBDL_KEY || 'subdl_TlE9rP7MTKE7PamqR6Ha7hlBjQZ3ET5zCZAYJCOIjG8';
 
-const MIN_SEEDERS = 1;
-const ALLOWED_QUALITIES = ['480p', '576p', '720p', '1080p', 'webrip', 'webdl', 'bluray'];
-const MAX_SIZE_GB_MOVIE = 4;
-const MAX_SIZE_GB_SERIES = 1.5;
-
-const SOURCE_CONFIG = [
-  { name: 'yts', display: 'YTS', order: 1 },
-  { name: 'yify', display: 'YTS', order: 1 },
-  { name: 'eztv', display: 'EZTV', order: 2 },
-  { name: 'nyaasi', display: 'Nyaa', order: 3 },
-  { name: 'thepiratebay', display: 'TPB', order: 4 },
-  { name: 'piratebay', display: 'TPB', order: 4 },
-  { name: 'the piratebay', display: 'TPB', order: 4 },
-  { name: 'tpb', display: 'TPB', order: 4 },
-  { name: '1337x', display: '1337x', order: 5 },
-  { name: 'torrentgalaxy', display: 'TGx', order: 6 },
-  { name: 'rarbg', display: 'RARBG', order: 7 },
-  { name: 'rutor', display: 'Rutor', order: 8 },
-  { name: 'rutracker', display: 'Rutracker', order: 9 }
-];
+app.get('/', (req, res) => res.send('Van Subs v15 ✅ Online'));
 
-const QUALITY_RANK = {
-  '1080p': 1,
-  '720p': 2,
-  'webdl': 3,
-  'webrip': 4,
-  '576p': 5,
-  '480p': 6,
-  'bluray': 7
-};
-
-const LINKS_PER_QUALITY = 5;
-
-function getQuality(title = '') {
-  const lower = title.toLowerCase();
-  if (lower.includes('1080p')) return '1080p';
-  if (lower.includes('720p')) return '720p';
-  if (lower.includes('480p')) return '480p';
-  if (lower.includes('576p')) return '576p';
-  if (lower.includes('webrip')) return 'webrip';
-  if (lower.includes('webdl') || lower.includes('web-dl')) return 'webdl';
-  if (lower.includes('bluray')) return 'bluray';
-  return null;
-}
+app.get('/manifest.json', (req, res) => res.json({
+  id:          'org.van.humansubtitles',
+  name:        'VanSubs+',
+  description: 'Human-Verified Arabic & English Subtitles.',
+  version:     '15.0.0',
+  resources:   ['subtitles'],
+  types:       ['movie', 'series'],
+  idPrefixes:  ['tt'],
+  catalogs:    []
+}));
+
+app.get('/subtitles/:type/:id.json',        (req, res) => handleRequest(req, res));
+app.get('/subtitles/:type/:id/:extra.json', (req, res) => handleRequest(req, res));
+
+app.get('/health', (req, res) => res.json({
+  status:   'ok',
+  version:  '15.0.0',
+  cache:    cache.size,
+  zips:     subStore.size,
+  uptime:   Math.floor(process.uptime()) + 's',
+  base_url: BASE_URL
+}));
 
-function getSeeders(stream) {
-  if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
-  const match = stream.title?.match(/👤\s*(\d+)/);
-  return match ? parseInt(match[1], 10) : 0;
+const cache = new Map();
+const TTL_MOVIE   = 7 * 24 * 60 * 60 * 1000;
+const TTL_EPISODE = 8 * 60 * 60 * 1000;
+
+function getTTL(type) { return type === 'series' ? TTL_EPISODE : TTL_MOVIE; }
+function cacheKey(imdbId, type, season, episode) {
+  return `${imdbId}|${type}|${season ?? 'x'}|${episode ?? 'x'}`;
 }
 
-function getSizeInGB(stream) {
-  const title = stream.title || '';
-  const sizeMatch = title.match(/💾\s*([\d.]+)\s*(GB|MB)/i) || 
-                    title.match(/([\d.]+)\s*(GB|MB)/i);
-  if (!sizeMatch) return null;
-  
-  const value = parseFloat(sizeMatch[1]);
-  const unit = sizeMatch[2].toUpperCase();
-  
-  if (unit === 'GB') return value;
-  if (unit === 'MB') return value / 1024;
+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);
+
+const subStore = new Map();
+let   subSeq   = 0;
+
+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);
+
+// ---------------------------------------------------------------------------
+// Extract episode number from a filename (SxxExx → number, else null)
+// ---------------------------------------------------------------------------
+function episodeFromFilename(filename) {
+  if (!filename) return null;
+  const n = filename.toLowerCase();
+  const m1 = n.match(/s\d{1,2}e(\d{1,3})/);
+  if (m1) return parseInt(m1[1], 10);
+  const m2 = n.match(/[._\-\s]e(\d{1,3})[._\-\s]/);
+  if (m2) return parseInt(m2[1], 10);
   return null;
 }
 
-function detectSource(title = '') {
-  const lower = title.toLowerCase();
-  for (const src of SOURCE_CONFIG) {
-    if (lower.includes(src.name)) return src.name;
+// ---------------------------------------------------------------------------
+// Pick file from ZIP – prefers exact episode match for series
+// ---------------------------------------------------------------------------
+function pickFileFromZip(zip, lang, season, episode) {
+  const entries = zip.getEntries()
+    .filter(e => !e.isDirectory)
+    .filter(e => /\.(srt|ass|ssa|vtt)$/i.test(e.entryName));
+  if (!entries.length) return null;
+
+  if (season != null && episode != null) {
+    const target = `s${String(season).padStart(2,'0')}e${String(episode).padStart(2,'0')}`;
+    const exact = entries.find(e => e.entryName.toLowerCase().includes(target));
+    if (exact) return exact;
+    const loose = `s${season}e${episode}`;
+    if (loose !== target) {
+      const looseMatch = entries.find(e => e.entryName.toLowerCase().includes(loose));
+      if (looseMatch) return looseMatch;
+    }
   }
+
+  const hints = lang === 'Arabic'
+    ? ['arabic', 'arab', '.ar.', '_ar_', '.ara.', '_ara_', 'ar.srt', 'ar.ass']
+    : ['english', 'eng', '.en.', '_en_', '.eng.', '_eng_', 'en.srt', 'en.ass'];
+
+  const hinted = entries.find(e => hints.some(h => e.entryName.toLowerCase().includes(h)));
+  if (hinted) return hinted;
+  if (entries.length === 1) return entries[0];
+
+  return [...entries].sort((a, b) =>
+    lang === 'Arabic' ? a.header.size - b.header.size : b.header.size - a.header.size
+  )[0];
+}
+
+// ---------------------------------------------------------------------------
+// Resolve a subdl URL (direct or ZIP).  Returns { url, extractedName }
+// ---------------------------------------------------------------------------
+async function resolveUrl(rawUrl, lang, season, episode) {
+  if (/\.(srt|ass|ssa|vtt)(\?|$)/i.test(rawUrl)) {
+    return { url: rawUrl, extractedName: null };
+  }
+  try {
+    const r = await timedFetch(rawUrl, {}, 8000);
+    if (!r.ok) { console.error(`[ZIP] ${r.status}`); return null; }
+    const zip  = new AdmZip(await r.buffer());
+    const best = pickFileFromZip(zip, lang, season, episode);
+    if (!best) return null;
+    const ext = best.entryName.split('.').pop().toLowerCase();
+    const id  = `s${++subSeq}`;
+    subStore.set(id, { buffer: best.getData(), ext });
+    const publicUrl = `${BASE_URL}/sub/${id}.${ext}`;
+    console.log(`[ZIP] "${best.entryName}" (${best.header.size}B) lang=${lang} → /sub/${id}`);
+    return { url: publicUrl, extractedName: best.entryName };
+  } catch (e) { console.error('[ZIP] error:', e.message); return null; }
+}
+
+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);
+});
+
+const ARABIC_CODES  = new Set(['ar', 'ara', 'arabic']);
+const ENGLISH_CODES = new Set(['en', 'eng', 'english']);
+
+function resolveLanguage(code) {
+  const c = (code || '').toLowerCase().trim();
+  if (ARABIC_CODES.has(c))  return 'Arabic';
+  if (ENGLISH_CODES.has(c)) return 'English';
   return null;
 }
 
-function getSourceOrder(sourceName) {
-  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
-  return config ? config.order : 999;
-}
-
-function filterStream(stream, type = 'movie') {
-  const title = stream.title || '';
-  if (!stream.url && !stream.infoHash) return false;
-  
-  const quality = getQuality(title);
-  if (!ALLOWED_QUALITIES.includes(quality)) return false;
-  
-  if (getSeeders(stream) < MIN_SEEDERS) return false;
-  
-  if (!detectSource(title)) return false;
-  
-  const maxSize = type === 'series' ? MAX_SIZE_GB_SERIES : MAX_SIZE_GB_MOVIE;
-  const sizeGB = getSizeInGB(stream);
-  if (sizeGB !== null && sizeGB > maxSize) return false;
-  
-  return true;
+const FOREIGN_SIGNALS = [
+  'spanish','español','espanol','latino','castellano','.es.','_es_','.spa.','_spa_','.lat.','_lat_','[lat]','(lat)',
+  'french','français','francais','.fr.','_fr_','.fre.','_fre_',
+  'portuguese','português','brazil','brasil','.pt.','_pt.','.por.','_por_','.br.','_br_',
+  'german','deutsch','.de.','_de_','.ger.','_ger_',
+  'italian','italiano','.it.','_it_','.ita.','_ita_',
+  'dutch','nederlands','.nl.','_nl_','.dut.','_dut_','[nl]',
+  'turkish','türkçe','.tr.','_tr_','.tur.','_tur_',
+  'russian','.ru.','_ru_','.rus.','_rus_',
+  'chinese','.zh.','_zh_','korean','.ko.','_ko_','hindi','.hi.','_hi_',
+];
+
+function isForeignFilename(filename, lang) {
+  if (lang === 'Arabic') return false;
+  const n = (filename || '').toLowerCase();
+  return FOREIGN_SIGNALS.some(s => n.includes(s));
+}
+
+const AI_GARBAGE = [
+  'ai-translated','machine translation','chatgpt','translated from','auto-translated',
+  'google translate','deepl','whisper','ai generated','machine-translated','openai',
+  'gpt-4','gpt4','auto translate','ai.translated','aitranslated','autotranslated',
+  'machine.translation','subscene-ai','opensubtitles-bot','mtranslated','mt.translated',
+  'ai_translated','translated.by.ai','translated_by_ai',
+];
+
+function isHumanVerified(filename) {
+  const n = (filename || '').toLowerCase();
+  return !AI_GARBAGE.some(f => n.includes(f));
+}
+
+const SCENE_GROUPS = [
+  'qxr','psa','galaxyrg','ntb','deflate','epsilon','tigole','framestor',
+  'yts','yify','rarbg','fgt','amzn','flux','cm','tepes','heve','evo','ion10','glhf'
+];
+const SOURCE_TAGS  = ['bluray','blu-ray','webdl','web-dl','webrip','web-rip','dvdrip','hdrip','remux','bdremux','bdrip'];
+const CODEC_TAGS   = ['x265','x264','hevc','h265','h264','10bit','10-bit','hdr','hdr10','dv','dolbyvision','2160p','4k','uhd','1080p','1080','720p'];
+const AUDIO_TAGS   = ['truehd.atmos','truehd','atmos','ddp5.1','ddp5','ddp','dts-hd','dts.hd','dts','ac3','aac','eac3'];
+const SYNC_BOOST   = ['sync','synced','corrected','fixed','updated','proper','repack','retail','remux','bd.sync','bluray.sync'];
+const SYNC_PENALTY = ['unsynced','unsync','rough','workprint','not.synced','not_synced','notsynced','raw.sub','raw_sub'];
+
+function normalizeRelease(name) {
+  if (!name) return [];
+  return name.toLowerCase()
+    .replace(/\[.*?\]/g, ' ').replace(/\(.*?\)/g, ' ')
+    .replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).filter(t => t.length > 1);
 }
 
-async function fetchUpstream(type, id) {
-  for (const baseUrl of UPSTREAM_URLS) {
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 8000);
-      const res = await fetch(`${baseUrl}/stream/${type}/${id}.json`, { signal: controller.signal });
-      clearTimeout(timeout);
-      if (res.ok) {
-        const data = await res.json();
-        if (data.streams?.length) return data.streams;
-      }
-    } catch (e) {}
+// ---------------------------------------------------------------------------
+// Score a subtitle release.  If season/episode are given, a 500‑point bonus
+// is added when the filename contains the exact SxxExx pattern.
+// ---------------------------------------------------------------------------
+function scoreTrack(subFilename, streamTitle, rating = 0, season = null, episode = null) {
+  if (!subFilename) return 0;
+  const n          = subFilename.toLowerCase();
+  const subTokens  = normalizeRelease(subFilename);
+  const strmTokens = normalizeRelease(streamTitle || '');
+  let s = 0;
+
+  // Episode exact match boost
+  if (season != null && episode != null) {
+    const pat = `s${String(season).padStart(2,'0')}e${String(episode).padStart(2,'0')}`;
+    if (n.includes(pat)) s += 500;
+    else {
+      const loose = `s${season}e${episode}`;
+      if (loose !== pat && n.includes(loose)) s += 500;
+    }
+  }
+
+  for (const g of SCENE_GROUPS) {
+    const inSub  = subTokens.includes(g);
+    const inStrm = strmTokens.includes(g);
+    if (inSub && inStrm) s += 200;
+    else if (inSub)      s += 60;
   }
-  return [];
+
+  SOURCE_TAGS.forEach((t, i) => { if (n.includes(t)) s += (SOURCE_TAGS.length - i) * 8; });
+  CODEC_TAGS.forEach( (t, i) => { if (n.includes(t)) s += (CODEC_TAGS.length  - i) * 6; });
+  AUDIO_TAGS.forEach( (t, i) => { if (n.includes(t)) s += (AUDIO_TAGS.length  - i) * 5; });
+  SYNC_BOOST.forEach(  b     => { if (n.includes(b)) s += 35; });
+  SYNC_PENALTY.forEach(p     => { if (n.includes(p)) s -= 50; });
+  if (rating > 0) s += Math.round(rating * 2);
+
+  return s;
 }
 
-function sortAndGroup(streams, type = 'movie') {
-  const filtered = streams.filter(s => filterStream(s, type));
-  
-  const byQuality = {};
-  filtered.forEach(stream => {
-    const quality = getQuality(stream.title);
-    if (!byQuality[quality]) byQuality[quality] = [];
-    byQuality[quality].push(stream);
-  });
-  
-  for (const quality in byQuality) {
-    byQuality[quality].sort((a, b) => {
-      const sourceA = detectSource(a.title);
-      const sourceB = detectSource(b.title);
-      const orderA = getSourceOrder(sourceA);
-      const orderB = getSourceOrder(sourceB);
-      if (orderA !== orderB) return orderA - orderB;
-      return getSeeders(b) - getSeeders(a);
-    });
+async function timedFetch(url, opts = {}, ms = 6000) {
+  const ctrl  = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), ms);
+  try   { return await fetch(url, { ...opts, signal: ctrl.signal }); }
+  finally { clearTimeout(timer); }
+}
+
+async function safeJson(r, tag) {
+  const text = await r.text();
+  try   { return JSON.parse(text); }
+  catch { console.error(`[${tag}] bad JSON:`, text.slice(0, 200)); return null; }
+}
+
+async function handleRequest(req, res) {
+  const { type } = req.params;
+  const rawId    = req.params.id.replace('.json', '');
+  const extra    = req.params.extra ? decodeURIComponent(req.params.extra.replace('.json','')) : '';
+  const parts    = rawId.split(':');
+  const imdbId   = parts[0];
+  const season   = parts[1] ? parseInt(parts[1]) : null;
+  const episode  = parts[2] ? parseInt(parts[2]) : null;
+
+  const filenameMatch = extra.match(/filename=([^&]+)/i);
+  const streamTitle   = filenameMatch ? decodeURIComponent(filenameMatch[1]) : '';
+
+  console.log(`\n╔═ [VanSubs v15] ${type.toUpperCase()} ${imdbId}` +
+    (season !== null ? ` S${String(season).padStart(2,'0')}E${String(episode??0).padStart(2,'0')}` : '') +
+    (streamTitle ? `\n║  hint: "${streamTitle}"` : ''));
+
+  const ck  = cacheKey(imdbId, type, season, episode);
+  const hit = cache.get(ck);
+  if (hit && (Date.now() - hit.ts) < hit.ttl) {
+    console.log(`╚═ ✅ Cache hit — ${hit.subtitles.length} tracks`);
+    return res.json({ subtitles: hit.subtitles });
   }
-  
-  const result = [];
-  const sortedQualities = Object.keys(byQuality).sort((a, b) => {
-    const rankA = QUALITY_RANK[a] || 999;
-    const rankB = QUALITY_RANK[b] || 999;
-    return rankA - rankB;
-  });
-  
-  sortedQualities.forEach(quality => {
-    const topLinks = byQuality[quality].slice(0, LINKS_PER_QUALITY);
-    result.push(...topLinks);
+
+  let rawTracks = [];
+  try { rawTracks = await fetchSubDL(imdbId, type, season, episode); }
+  catch (e) { console.error('║  [SubDL] FAILED:', e.message); }
+  console.log(`║  [SubDL] ${rawTracks.length} raw tracks`);
+
+  const seen    = new Set();
+  const deduped = rawTracks.filter(s => {
+    const key = (s.filename || '').toLowerCase().replace(/[\s.\-_]+/g, '.').replace(/\.(srt|ass|zip)$/, '');
+    if (seen.has(key)) return false;
+    seen.add(key); return true;
   });
-  
-  return result;
-}
-
-app.get('/manifest.json', (req, res) => {
-  res.json({
-    id: 'org.ghostream.platinum',
-    name: 'Ghostream 🚀',
-    description: 'Stream Everything You Want\nMade With 🤍 By Van',
-    version: '7.3.0',
-    resources: ['stream'],
-    types: ['movie', 'series'],
-    idPrefixes: ['tt'],
-    catalogs: []
+
+  const clean = deduped.filter(s => {
+    if (!s.url) return false;
+    if (!isHumanVerified(s.filename)) { console.log(`║  [AI-DROP] "${s.filename}"`); return false; }
+    if (isForeignFilename(s.filename, s.lang)) { console.log(`║  [FOREIGN-DROP] "${s.filename}"`); return false; }
+    return true;
   });
-});
 
-app.get('/stream/:type/:id.json', async (req, res) => {
-  const { type, id } = req.params;
-  try {
-    const streams = await fetchUpstream(type, id);
-    const sorted = sortAndGroup(streams, type);
-    res.json({ streams: sorted });
-  } catch (e) {
-    res.json({ streams: [] });
+  // Phase 1: order by release quality only (no episode boost)
+  const scored = clean
+    .map(s => ({ ...s, score: scoreTrack(s.filename, streamTitle, s.rating) }))
+    .sort((a, b) => b.score - a.score);
+
+  const arabic  = scored.filter(s => s.lang === 'Arabic').slice(0, 4);
+  const english = scored.filter(s => s.lang === 'English').slice(0, 4);
+  const final   = [...arabic, ...english];
+
+  // Phase 2: resolve URLs, replace filename with extracted name, re‑score
+  const resolved = (await Promise.all(
+    final.map(async s => {
+      const result = await resolveUrl(s.url, s.lang, season, episode);
+      if (!result) return null;
+      // Replace the release filename with the actual file we serve
+      const displayName = result.extractedName || s.filename;
+      return {
+        ...s,
+        url: result.url,
+        filename: displayName,
+      };
+    })
+  )).filter(Boolean);
+
+  // Phase 3: re‑score with the correct (possibly extracted) filename, now with episode boost
+  const finalSorted = resolved
+    .map(s => ({
+      ...s,
+      finalScore: scoreTrack(s.filename, streamTitle, s.rating, season, episode)
+    }))
+    .sort((a, b) => b.finalScore - a.finalScore);
+
+  const subtitles = finalSorted.map((s, i) => ({
+    id:   `van_${s.lang === 'Arabic' ? 'ar' : 'en'}_${imdbId}_${i}`,
+    url:  s.url,
+    lang: s.lang
+  }));
+
+  cache.set(ck, { subtitles, ts: Date.now(), ttl: getTTL(type) });
+
+  const ar = finalSorted.filter(s => s.lang === 'Arabic');
+  const en = finalSorted.filter(s => s.lang === 'English');
+  console.log(`║  ✅ ${subtitles.length} tracks (AR:${ar.length} EN:${en.length})`);
+  ar.forEach((s, i) => console.log(`║    AR[${i}] ${String(s.finalScore).padStart(4)}pt  "${s.filename}"`));
+  en.forEach((s, i) => console.log(`║    EN[${i}] ${String(s.finalScore).padStart(4)}pt  "${s.filename}"`));
+  console.log(`╚═ done`);
+
+  res.json({ subtitles });
+}
+
+// ---------------------------------------------------------------------------
+// SubDL API helper with fallback: if a request with type=tv returns 0
+// results, retry without it (the API sometimes fails with type=tv).
+// ---------------------------------------------------------------------------
+async function subDLRequestWithFallback(baseParams) {
+  // Try with type=tv first
+  let data = await subDLRequest(baseParams + '&type=tv');
+  if (data && data.length > 0) return data;
+  // Fallback without type=tv
+  return await subDLRequest(baseParams);
+}
+
+async function subDLRequest(params) {
+  const base = `https://api.subdl.com/api/v1/subtitles?api_key=${SUBDL_KEY}&languages=AR,EN&subs_per_page=30&releases=1`;
+  const url  = base + params;
+  const r    = await timedFetch(url, {}, 6000);
+  const data = await safeJson(r, 'SubDL');
+  if (!data?.status) { console.error('║  [SubDL] error:', data?.error); return []; }
+  return data.subtitles || [];
+}
+
+function parseSubDLResults(subs) {
+  return subs.map(sub => {
+    const lang = resolveLanguage(sub.language);
+    if (!lang) return null;
+    let dlUrl = (sub.url || '').trim();
+    if (dlUrl && !dlUrl.startsWith('http')) dlUrl = 'https://dl.subdl.com' + dlUrl;
+    if (!dlUrl) return null;
+    return {
+      filename:    sub.release_name || sub.full_name || sub.name || 'SubDL Track',
+      url:         dlUrl,
+      lang,
+      rating:      parseFloat(sub.rating) || 0,
+      source:      'subdl',
+      season:      sub.season       ?? null,
+      episode:     sub.episode      ?? null,
+      episodeFrom: sub.episode_from ?? null,
+      episodeTo:   sub.episode_end  ?? null,
+      fullSeason:  sub.full_season  ?? false,
+    };
+  }).filter(Boolean);
+}
+
+// ---------------------------------------------------------------------------
+// Client‑side episode filter
+// ---------------------------------------------------------------------------
+function episodeFilter(s, targetSeason, targetEp, callSite) {
+  const seasonOk = !s.season || s.season === 0 || s.season === targetSeason;
+  if (!seasonOk) {
+    console.log(`║  [EP-FILTER] dropped wrong-season from ${callSite}: "${s.filename}"`);
+    return false;
   }
-});
 
-app.get('/debug/:type/:id.json', async (req, res) => {
-  const { type, id } = req.params;
-  try {
-    const streams = await fetchUpstream(type, id);
-    res.json({ streams });
-  } catch (e) {
-    res.status(500).json({ error: e.message });
+  if (s.episodeFrom > 0 && s.episodeTo > 0) {
+    const inRange = targetEp >= s.episodeFrom && targetEp <= s.episodeTo;
+    if (!inRange) console.log(`║  [EP-FILTER] dropped out-of-range from ${callSite}: "${s.filename}"`);
+    return inRange;
   }
-});
 
-app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));
+  if (s.fullSeason) {
+    const fnEp = episodeFromFilename(s.filename);
+    if (fnEp !== null && fnEp !== targetEp) {
+      console.log(`║  [EP-FILTER] dropped wrong-episode (fullSeason, filename) from ${callSite}: "${s.filename}"`);
+      return false;
+    }
+    return true;
+  }
+
+  if (s.episode !== null && s.episode !== 0) {
+    const match = s.episode === targetEp;
+    if (!match) console.log(`║  [EP-FILTER] dropped wrong-episode from ${callSite}: "${s.filename}"`);
+    return match;
+  }
+
+  const fnEp = episodeFromFilename(s.filename);
+  if (fnEp !== null && fnEp !== targetEp) {
+    console.log(`║  [EP-FILTER] dropped wrong-episode (filename) from ${callSite}: "${s.filename}"`);
+    return false;
+  }
+
+  return true;
+}
+
+async function fetchSubDL(imdbId, type, season, episode) {
+  if (type !== 'series' || season === null || episode === null) {
+    const subs = await subDLRequest(`&imdb_id=${imdbId}`);
+    return parseSubDLResults(subs);
+  }
+
+  const [episodeSubs, seasonSubs] = await Promise.all([
+    subDLRequestWithFallback(`&imdb_id=${imdbId}&season_number=${season}&episode_number=${episode}`),
+    subDLRequestWithFallback(`&imdb_id=${imdbId}&season_number=${season}&full_season=1`)
+  ]);
+
+  const episodeParsed = parseSubDLResults(episodeSubs)
+    .filter(s => episodeFilter(s, season, episode, 'episodeCall'));
+
+  const seasonParsed = parseSubDLResults(seasonSubs)
+    .filter(s => episodeFilter(s, season, episode, 'seasonCall'));
+
+  console.log(`║  [SubDL] episode=${episodeParsed.length} season_pack=${seasonParsed.length}`);
+
+  const combined = [...episodeParsed, ...seasonParsed];
+  const seen     = new Set();
+  return combined.filter(s => {
+    const key = (s.filename || '').toLowerCase().replace(/[\s.\-_]+/g, '.');
+    if (seen.has(key)) return false;
+    seen.add(key); return true;
+  });
+}
+
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`\nVan Subs v15 — port ${PORT}`);
+  console.log(`BASE_URL: ${BASE_URL}`);
+  console.log(`SPACE_HOST env: ${process.env.SPACE_HOST || '(not set — using localhost)'}\n`);
+});