Update app.py

app.py

@@ -1,33 +1,22 @@
-"""
-HackTrack Scraper v5.0 - Structured extraction, no LLM
-- Devfolio : reads __NEXT_DATA__ JSON blob (Next.js SSR, 100% accurate dates)
-- Unstop   : calls api.unstop.com REST API directly (structured JSON)
-- Devpost  : reads <time datetime> tags + structured sidebar
-- Others   : regex fallback on bodyText
-"""
-
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 import asyncio
 import re
 import sys
-import json
-import httpx
 from urllib.parse import urlparse
-from typing import List, Optional
-from datetime import datetime, timezone
+from typing import List
+from datetime import datetime
 
 if sys.platform == "win32":
+    # Playwright launches a driver subprocess; Proactor loop supports subprocess APIs on Windows.
     asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
 
-app = FastAPI(title="HackTrack Scraper", version="5.0.0")
-playwright = None
-browser    = None
+app = FastAPI(title="HackTrack Scraper", version="3.0.0")
 
-# Semaphore: only 1 Playwright scrape at a time on HuggingFace free tier.
-# Prevents two concurrent requests from doubling RAM usage (~1.2GB peak).
-_scrape_sem = asyncio.Semaphore(1)
+# Global Playwright runtime objects reused across requests.
+playwright = None
+browser = None
 
 app.add_middleware(
     CORSMiddleware,
@@ -37,13 +26,10 @@ app.add_middleware(
 )
 
 
-# ============================================================
-# MODELS
-# ============================================================
-
 class ScrapeRequest(BaseModel):
     url: str
 
+
 class ScrapeResponse(BaseModel):
     name: str = ""
     platform: str = ""
@@ -62,807 +48,473 @@ class ScrapeResponse(BaseModel):
     url: str = ""
 
 
-# ============================================================
-# PLATFORM DETECTION
-# ============================================================
-
 def detect_platform(url: str) -> str:
     domain = urlparse(url).netloc.lower()
-    if "devfolio"    in domain: return "Devfolio"
-    if "unstop"      in domain: return "Unstop"
-    if "devpost"     in domain: return "Devpost"
-    if "dorahacks"   in domain: return "DoraHacks"
-    if "mlh.io"      in domain: return "MLH"
-    if "hackerearth" in domain: return "HackerEarth"
+    if "devfolio" in domain:
+        return "Devfolio"
+    elif "unstop" in domain:
+        return "Unstop"
+    elif "devpost" in domain:
+        return "Devpost"
+    elif "dorahacks" in domain:
+        return "DoraHacks"
     return "Other"
 
 
 # ============================================================
-# DATE HELPERS
+# DATE PARSING — robust multi-format
 # ============================================================
-
-def iso_to_date(val: Optional[str]) -> str:
-    """Convert ISO-8601 / Unix timestamp -> YYYY-MM-DD."""
-    if not val:
-        return ""
-    val = str(val).strip()
-    if re.fullmatch(r"\d{10}", val):
-        try:
-            return datetime.fromtimestamp(int(val), tz=timezone.utc).strftime("%Y-%m-%d")
-        except Exception:
-            return ""
-    if re.fullmatch(r"\d{13}", val):
-        try:
-            return datetime.fromtimestamp(int(val) / 1000, tz=timezone.utc).strftime("%Y-%m-%d")
-        except Exception:
-            return ""
-    m = re.match(r"(\d{4}-\d{2}-\d{2})", val)
-    if m:
-        return m.group(1)
-    return ""
+MONTH_MAP = {
+    "jan": 1, "january": 1, "feb": 2, "february": 2, "mar": 3, "march": 3,
+    "apr": 4, "april": 4, "may": 5, "jun": 6, "june": 6,
+    "jul": 7, "july": 7, "aug": 8, "august": 8, "sep": 9, "sept": 9, "september": 9,
+    "oct": 10, "october": 10, "nov": 11, "november": 11, "dec": 12, "december": 12,
+}
 
 DATE_FORMATS = [
     "%Y-%m-%d", "%Y/%m/%d",
     "%d %B %Y", "%d %b %Y", "%d %B, %Y", "%d %b, %Y",
     "%B %d, %Y", "%b %d, %Y", "%B %d %Y", "%b %d %Y",
     "%m/%d/%Y", "%d/%m/%Y",
+    "%B %d", "%b %d",
 ]
 
-def parse_any_date(text: str) -> str:
-    if not text: return ""
-    text = re.sub(r"(\d+)(st|nd|rd|th)", r"\1", text.strip())
+
+def parse_any_date(text: str, fallback_year: int = None) -> str:
+    """Parse many date formats to YYYY-MM-DD. Handles partial dates."""
+    if not text:
+        return ""
+    text = text.strip()
+    text = re.sub(r"(\d+)(st|nd|rd|th)", r"\1", text)
     text = re.sub(r"\s+", " ", text)
+
+    if not fallback_year:
+        fallback_year = datetime.now().year
+
     for fmt in DATE_FORMATS:
         try:
             dt = datetime.strptime(text, fmt)
-            if dt.year == 1900:
-                dt = dt.replace(year=datetime.now().year)
+            if dt.year == 1900:  # no year in format
+                dt = dt.replace(year=fallback_year)
+                if dt < datetime.now():
+                    dt = dt.replace(year=fallback_year + 1)
             return dt.strftime("%Y-%m-%d")
         except ValueError:
             continue
     return ""
 
+
 def find_dates_near(text: str, keywords: List[str], window: int = 400) -> str:
+    """Find dates within `window` chars after any keyword."""
     lower = text.lower()
-    patterns = [
+    all_date_patterns = [
         r"(\d{4}[-/]\d{1,2}[-/]\d{1,2})",
-        r"(\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?"
-        r"|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)"
-        r"[,]?\s+\d{4})",
-        r"((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?"
-        r"|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)"
-        r"\s+\d{1,2}(?:st|nd|rd|th)?[,]?\s*\d{0,4})",
+        r"(\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)[,]?\s+\d{4})",
+        r"((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2}(?:st|nd|rd|th)?[,]?\s*\d{0,4})",
         r"(\d{1,2}/\d{1,2}/\d{4})",
     ]
     for kw in keywords:
         idx = lower.find(kw.lower())
-        if idx == -1: continue
-        chunk = text[idx: idx + window]
-        for pat in patterns:
-            m = re.search(pat, chunk, re.IGNORECASE)
-            if m:
-                parsed = parse_any_date(m.group(1))
-                if parsed: return parsed
+        if idx == -1:
+            continue
+        chunk = text[idx:idx + window]
+        for pat in all_date_patterns:
+            match = re.search(pat, chunk, re.IGNORECASE)
+            if match:
+                parsed = parse_any_date(match.group(1))
+                if parsed:
+                    return parsed
     return ""
 
 
 # ============================================================
-# DEVFOLIO - __NEXT_DATA__ extraction script
+# EXTRACT from full page innerText (the reliable approach)
 # ============================================================
 
-DEVFOLIO_SCRIPT = """() => {
-    const nextEl = document.getElementById('__NEXT_DATA__');
-    let nextData = null;
-    if (nextEl) { try { nextData = JSON.parse(nextEl.textContent); } catch(e) {} }
-
-    function findHackathon(obj, depth) {
-        if (!obj || typeof obj !== 'object' || depth > 8) return null;
-        if (obj.starts_at || obj.registration_deadline || obj.ends_at || obj.slug) return obj;
-        for (const k of Object.keys(obj)) {
-            const child = obj[k];
-            if (child && typeof child === 'object') {
-                const found = findHackathon(child, depth + 1);
-                if (found) return found;
-            }
-        }
-        return null;
-    }
-
-    let hackathon = nextData ? findHackathon(nextData, 0) : null;
-
-    const getMeta = (n) => {
-        const el = document.querySelector('meta[property="' + n + '"], meta[name="' + n + '"]');
-        return el ? el.getAttribute('content') || '' : '';
-    };
-
-    let name = '';
-    if (hackathon) name = hackathon.name || hackathon.title || '';
-    if (!name) {
-        const el = document.querySelector('h1');
-        if (el && el.textContent.trim().length > 2) name = el.textContent.trim();
-    }
-    name = name || getMeta('og:title') || document.title.split('|')[0].trim();
-
-    const banner      = (hackathon && (hackathon.cover_image || hackathon.banner_image)) || getMeta('og:image') || '';
-    const description = (hackathon && (hackathon.tagline || hackathon.description)) || getMeta('og:description') || '';
-    const starts_at   = (hackathon && (hackathon.starts_at || hackathon.start_date)) || '';
-    const ends_at     = (hackathon && (hackathon.ends_at   || hackathon.end_date))   || '';
-    const reg_dl      = (hackathon && (hackathon.registration_deadline || hackathon.registration_ends_at)) || '';
-    const sub_dl      = (hackathon && (hackathon.submission_deadline   || hackathon.submission_ends_at))   || '';
-    const result_date = (hackathon && (hackathon.result_date           || hackathon.results_at))           || '';
-
-    let prize_pool = '';
-    if (hackathon) {
-        if (hackathon.prize_pool != null) prize_pool = String(hackathon.prize_pool);
-        else if (hackathon.prize)         prize_pool = String(hackathon.prize);
-    }
-
-    let team_min = 1, team_max = 4;
-    if (hackathon) {
-        if (hackathon.min_team_size) team_min = hackathon.min_team_size;
-        if (hackathon.max_team_size) team_max = hackathon.max_team_size;
-    }
-
-    const ps = [];
-    const seenPs = new Set();
-    const tracks = hackathon ? (hackathon.tracks || hackathon.themes || hackathon.problem_statements || []) : [];
-    if (Array.isArray(tracks)) {
-        for (const t of tracks) {
-            const title = t.title || t.name || t.track || (typeof t === 'string' ? t : '');
-            const desc  = t.description || t.desc || '';
-            if (title && !seenPs.has(title.toLowerCase())) {
-                seenPs.add(title.toLowerCase());
-                ps.push({ track: t.track || '', title: title, description: desc });
-            }
-        }
+def extract_all_from_text(body_text: str, platform: str) -> dict:
+    """Extract hackathon details from page innerText using text patterns."""
+    result = {
+        "registration_deadline": "",
+        "submission_deadline": "",
+        "result_date": "",
+        "start_date": "",
+        "end_date": "",
+        "prize_pool": "",
+        "team_size": {"min": 1, "max": 4},
+        "problem_statements": [],
     }
 
-    const resourceLinks = [];
-    const seenHrefs = new Set();
-    const kws = ['problem','statement','pdf','rule','guideline','brochure','document','brief','challenge','track','theme','schedule','timeline'];
-    document.querySelectorAll('a[href]').forEach(function(a) {
-        const href = a.href || '';
-        const text = a.textContent.trim();
-        const hl = href.toLowerCase(), tl = text.toLowerCase();
-        if (seenHrefs.has(href) || !href || href === '#') return;
-        const isPdf   = hl.endsWith('.pdf') || hl.includes('/pdf');
-        const isDrive = hl.includes('drive.google.com') || hl.includes('docs.google.com');
-        const isRel   = kws.some(function(kw) { return tl.includes(kw) || hl.includes(kw); });
-        if (isPdf || isDrive || isRel) {
-            seenHrefs.add(href);
-            resourceLinks.push({ text: text.substring(0, 150) || 'Document', url: href, type: isPdf ? 'pdf' : isDrive ? 'google_drive' : 'link' });
-        }
-    });
-
-    return {
-        name: name.substring(0, 200),
-        description: description.substring(0, 2000),
-        banner_url: banner,
-        starts_at: starts_at,
-        ends_at: ends_at,
-        registration_deadline: reg_dl,
-        submission_deadline: sub_dl,
-        result_date: result_date,
-        prize_pool: prize_pool,
-        team_min: team_min,
-        team_max: team_max,
-        problem_statements: ps.slice(0, 20),
-        resource_links: resourceLinks.slice(0, 30),
-        bodyText: document.body.innerText.substring(0, 15000),
-        found_next_data: hackathon !== null,
-        hackathon_keys: hackathon ? Object.keys(hackathon).join(',') : ''
-    };
-}"""
+    # ---- DATES ----
+    # Registration deadline
+    result["registration_deadline"] = find_dates_near(body_text, [
+        "registration close", "registrations close", "register by",
+        "last date to register", "registration deadline", "applications close",
+        "apply by", "registration ends", "sign up deadline",
+    ])
 
+    # Submission deadline
+    result["submission_deadline"] = find_dates_near(body_text, [
+        "submission deadline", "submission closes", "submissions close",
+        "submit by", "last date to submit", "submission end",
+        "final submission", "project submission",
+        "deadline",  # generic fallback last
+    ])
 
-def parse_devfolio(data: dict) -> dict:
-    return {
-        "name":                  data.get("name", ""),
-        "description":           data.get("description", ""),
-        "banner_url":            data.get("banner_url", ""),
-        "start_date":            iso_to_date(data.get("starts_at")),
-        "end_date":              iso_to_date(data.get("ends_at")),
-        "registration_deadline": iso_to_date(data.get("registration_deadline")),
-        "submission_deadline":   iso_to_date(data.get("submission_deadline")),
-        "result_date":           iso_to_date(data.get("result_date")),
-        "prize_pool":            data.get("prize_pool", ""),
-        "team_size":             {"min": data.get("team_min", 1), "max": data.get("team_max", 4)},
-        "problem_statements":    data.get("problem_statements", []),
-        "resource_links":        data.get("resource_links", []),
-        "body_text":             data.get("bodyText", ""),
-        "found_structured":      data.get("found_next_data", False),
-    }
+    # Start date — Devfolio uses "Runs from Mar 25 - 26, 2026"
+    runs_from = re.search(
+        r"(?:runs?\s+from|starts?\s+(?:on|from)?|begins?\s+(?:on)?|commences?\s+(?:on)?)\s*[:\-]?\s*"
+        r"((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2})"
+        r"(?:\s*[-–]\s*(\d{1,2}))?"
+        r"(?:[,\s]+(\d{4}))?",
+        body_text, re.IGNORECASE
+    )
+    if runs_from:
+        start_text = runs_from.group(1)
+        year = runs_from.group(3) or str(datetime.now().year)
+        result["start_date"] = parse_any_date(f"{start_text} {year}")
+        if runs_from.group(2) and runs_from.group(1):
+            month = runs_from.group(1).split()[0]
+            result["end_date"] = parse_any_date(f"{month} {runs_from.group(2)} {year}")
 
+    if not result["start_date"]:
+        result["start_date"] = find_dates_near(body_text, [
+            "start date", "starts on", "begins on", "hackathon starts",
+            "event starts", "event date", "dates:",
+        ])
 
-# ============================================================
-# UNSTOP - Direct REST API
-# ============================================================
+    if not result["end_date"]:
+        result["end_date"] = find_dates_near(body_text, [
+            "end date", "ends on", "hackathon ends", "event ends",
+        ])
+
+    # Result date
+    result["result_date"] = find_dates_near(body_text, [
+        "result", "winners announced", "announcement", "winner announcement",
+        "results declared", "shortlist",
+    ])
 
-def extract_unstop_id(url: str) -> Optional[str]:
-    m = re.search(r"-(\d{5,8})(?:/|$|\?)", url)
-    if m: return m.group(1)
-    m = re.search(r"/(\d{5,8})(?:/|$|\?)", url)
-    return m.group(1) if m else None
+    # ---- PRIZE POOL ----
+    prize_patterns = [
+        r"(₹\s*[\d,]+(?:\.\d+)?(?:\s*(?:Lakhs?|Lacs?|Crores?|Cr|K|k|L))?)",
+        r"(\$\s*[\d,]+(?:\.\d+)?(?:\s*(?:K|k|M|million|thousand))?)",
+        r"(€\s*[\d,]+(?:\.\d+)?)",
+        r"(£\s*[\d,]+(?:\.\d+)?)",
+        r"(INR\s*[\d,]+(?:\.\d+)?(?:\s*(?:Lakhs?|Lacs?|Crores?|Cr|K|k|L))?)",
+        r"(Rs\.?\s*[\d,]+(?:\.\d+)?(?:\s*(?:Lakhs?|Lacs?|Crores?|Cr|K|k|L))?)",
+    ]
 
+    # Find prize amounts near keywords like "prize", "reward", "worth", "win"
+    prize_lower = body_text.lower()
+    for kw in ["prize", "reward", "worth", "winning", "bounty", "in cash", "in prizes"]:
+        idx = prize_lower.find(kw)
+        if idx == -1:
+            continue
+        # Search ±200 chars around keyword
+        start = max(0, idx - 200)
+        chunk = body_text[start:idx + 200]
+        for pat in prize_patterns:
+            match = re.search(pat, chunk, re.IGNORECASE)
+            if match:
+                result["prize_pool"] = match.group(1).strip()
+                break
+        if result["prize_pool"]:
+            break
 
-async def fetch_unstop_api(opportunity_id: str) -> Optional[dict]:
-    headers = {
-        "User-Agent": "Mozilla/5.0 (compatible; HackTrackBot/1.0)",
-        "Accept": "application/json",
-        "Referer": "https://unstop.com/hackathons",
-    }
-    endpoints = [
-        f"https://unstop.com/api/public/opportunity/get-applied-detail?id={opportunity_id}",
-        f"https://unstop.com/api/public/opportunity/{opportunity_id}",
-        f"https://unstop.com/api/public/hackathon/{opportunity_id}",
+    # Fallback: any large currency amount
+    if not result["prize_pool"]:
+        for pat in prize_patterns:
+            match = re.search(pat, body_text)
+            if match:
+                result["prize_pool"] = match.group(1).strip()
+                break
+
+    # ---- TEAM SIZE ----
+    team_patterns = [
+        r"team\s*size[:\s]*(\d+)\s*[-–to]+\s*(\d+)",
+        r"(\d+)\s*[-–to]+\s*(\d+)\s*(?:members?|people|participants?|per team)",
+        r"teams?\s+of\s+(?:up\s+to\s+)?(\d+)",
+        r"max(?:imum)?\s*(?:team)?\s*(?:size)?\s*[:\s]*(\d+)",
+        r"(\d+)\s*[-–]\s*(\d+)\s*$",  # in FAQ: "2 - 4"
     ]
-    for api_url in endpoints:
-        try:
-            async with httpx.AsyncClient(timeout=15) as client:
-                resp = await client.get(api_url, headers=headers)
-                if resp.status_code != 200:
-                    continue
-                data = resp.json()
-                opp = data.get("data") or data
-                if isinstance(opp, dict) and "opportunity" in opp:
-                    opp = opp["opportunity"]
-                if isinstance(opp, dict) and (opp.get("id") or opp.get("title")):
-                    print(f"[Unstop] API success from {api_url}")
-                    print(f"[Unstop] Keys: {list(opp.keys())[:15]}")
-                    return opp
-        except Exception as e:
-            print(f"[Unstop] {api_url} failed: {e}")
-    return None
-
-
-def parse_unstop_api(opp: dict) -> dict:
-    start_date   = iso_to_date(opp.get("start_date")  or opp.get("starts_at"))
-    end_date     = iso_to_date(opp.get("end_date")    or opp.get("ends_at"))
-    reg_deadline = iso_to_date(
-        opp.get("registrations_end_date") or
-        opp.get("registration_deadline")  or
-        opp.get("registration_end_date")
-    )
-    sub_deadline = iso_to_date(
-        opp.get("submission_end_date")  or
-        opp.get("submission_deadline")  or
-        opp.get("last_submission_date")
-    )
-    result_date = iso_to_date(opp.get("result_date") or opp.get("results_at"))
-
-    prize_pool = ""
-    if opp.get("prize_amount"):
-        prize_pool = str(opp["prize_amount"])
-    elif opp.get("prizes") and isinstance(opp["prizes"], list):
-        total = 0
-        for p in opp["prizes"]:
-            try: total += float(str(p.get("amount") or 0).replace(",", ""))
-            except: pass
-        if total:
-            prize_pool = "Rs. {:,}".format(int(total))
-    elif opp.get("total_prize"):
-        prize_pool = str(opp["total_prize"])
-
-    team_min = int(opp.get("min_team_size") or opp.get("min_team") or 1)
-    team_max = int(opp.get("max_team_size") or opp.get("max_team") or 4)
+    for pat in team_patterns:
+        match = re.search(pat, body_text, re.IGNORECASE)
+        if match:
+            groups = [g for g in match.groups() if g]
+            if len(groups) == 2:
+                result["team_size"] = {"min": int(groups[0]), "max": int(groups[1])}
+            elif len(groups) == 1:
+                result["team_size"] = {"min": 1, "max": int(groups[0])}
+            break
 
+    # ---- PROBLEM STATEMENTS / TRACKS / DOMAINS ----
     ps = []
     seen_ps = set()
-    for r in (opp.get("rounds") or opp.get("problem_statements") or []):
-        if not isinstance(r, dict): continue
-        title = r.get("title") or r.get("name") or r.get("round_name") or ""
-        desc  = r.get("description") or r.get("details") or ""
-        if title and title.lower() not in seen_ps:
-            seen_ps.add(title.lower())
-            ps.append({"track": "", "title": title, "description": desc[:300]})
 
-    tags = opp.get("tags") or opp.get("categories") or []
-    if isinstance(tags, list) and not ps:
-        for t in tags:
-            label = t.get("name") or t.get("label") or (t if isinstance(t, str) else "")
-            if label and label.lower() not in seen_ps:
-                seen_ps.add(label.lower())
-                ps.append({"track": "Theme", "title": label, "description": ""})
+    # Pattern 1: "Domains: AI, ML, Web App" (Devfolio style)
+    domain_match = re.search(
+        r"(?:domains?|themes?|tracks?|categories|verticals|areas?)[:\s]+([^\n💡🏆🎁🎟️📍📅⏳📞🌮]+)",
+        body_text, re.IGNORECASE
+    )
+    if domain_match:
+        items = re.split(r"[,•|/]", domain_match.group(1))
+        for item in items:
+            item = item.strip().rstrip(".")
+            if 3 < len(item) < 150 and item.lower() not in seen_ps:
+                seen_ps.add(item.lower())
+                ps.append({"track": "", "title": item})
+
+    # Pattern 2: Numbered problem statements: "PS1: ...", "Problem Statement 1 - ..."
+    for match in re.finditer(
+        r"(?:PS|Problem\s*Statement|Theme|Track|Challenge)\s*#?(\d+)\s*[:\-–]\s*(.{5,200})",
+        body_text, re.IGNORECASE
+    ):
+        num = match.group(1)
+        title = match.group(2).strip().split("\n")[0]
+        if title.lower() not in seen_ps and len(title) > 4:
+            seen_ps.add(title.lower())
+            ps.append({"track": f"Track {num}", "title": title})
+
+    # Pattern 3: Devpost-style theme tags (already in themes list from JS)
+    # Pattern 4: Bulleted lists after "Themes" or "Tracks" heading
+    for match in re.finditer(
+        r"(?:themes?|tracks?|problem\s*statements?|challenges?|domains?)\s*[:\n]"
+        r"((?:\s*[-•●▸]\s*.{5,200}\n?)+)",
+        body_text, re.IGNORECASE
+    ):
+        items = re.findall(r"[-•●▸]\s*(.{5,200})", match.group(1))
+        for item in items:
+            item = item.strip().split("\n")[0]
+            if item.lower() not in seen_ps and 4 < len(item) < 200:
+                seen_ps.add(item.lower())
+                ps.append({"track": "", "title": item})
 
-    return {
-        "name":                  opp.get("title") or opp.get("name", ""),
-        "description":           (opp.get("short_description") or opp.get("description") or "")[:500],
-        "banner_url":            opp.get("banner_image") or opp.get("cover_image") or opp.get("image") or "",
-        "start_date":            start_date,
-        "end_date":              end_date,
-        "registration_deadline": reg_deadline,
-        "submission_deadline":   sub_deadline,
-        "result_date":           result_date,
-        "prize_pool":            prize_pool,
-        "team_size":             {"min": team_min, "max": team_max},
-        "problem_statements":    ps[:20],
-        "resource_links":        [],
-    }
+    result["problem_statements"] = ps[:20]
+    return result
 
 
 # ============================================================
-# DEVPOST - <time datetime> tags + sidebar
+# PLAYWRIGHT SCRAPER — gets innerText + meta from rendered page
 # ============================================================
 
-DEVPOST_SCRIPT = """() => {
-    const getMeta = function(n) {
-        const el = document.querySelector('meta[property="' + n + '"], meta[name="' + n + '"]');
+EXTRACT_SCRIPT = """() => {
+    const getMeta = (name) => {
+        const el = document.querySelector(`meta[property="${name}"], meta[name="${name}"]`);
         return el ? el.getAttribute('content') || '' : '';
     };
 
-    let name = getMeta('og:title') || document.title.split('|')[0].trim();
-    const h1 = document.querySelector('#challenge-title, h1.title, h1');
-    if (h1 && h1.textContent.trim().length > 2) name = h1.textContent.trim();
-
-    const banner      = getMeta('og:image') || '';
-    const description = getMeta('og:description') || '';
-
-    const timeMap = {};
-    document.querySelectorAll('time[datetime]').forEach(function(el) {
-        const dt  = el.getAttribute('datetime') || '';
-        const parent = el.closest('.deadline, .date, li, div');
-        const lbl = (parent ? parent.textContent : '').toLowerCase();
-        if      (lbl.includes('submission') || lbl.includes('submit'))  { if (!timeMap.submission)   timeMap.submission   = dt; }
-        else if (lbl.includes('registr')    || lbl.includes('apply'))   { if (!timeMap.registration) timeMap.registration = dt; }
-        else if (lbl.includes('result')     || lbl.includes('winner'))  { if (!timeMap.result)       timeMap.result       = dt; }
-        else if (lbl.includes('start')      || lbl.includes('begin'))   { if (!timeMap.start)        timeMap.start        = dt; }
-        else if (lbl.includes('end')        || lbl.includes('close'))   { if (!timeMap.end)          timeMap.end          = dt; }
-        else if (!timeMap.first)                                         { timeMap.first              = dt; }
-    });
-
-    let prize_pool = '';
-    const prizeSection = document.querySelector('#prizes, .prize-amount, [id*="prize"]');
-    if (prizeSection) {
-        const txt = prizeSection.textContent;
-        const m = txt.match(/([\\u20b9][\\d,]+|[$][\\d,]+(?:K|k|M)?)/);
-        if (m) prize_pool = m[1];
-        else prize_pool = txt.trim().substring(0, 80);
+    // Name: try multiple selectors
+    const nameSelectors = [
+        'h1',
+        '.hackathon-name', '.event-name', '.challenge-title',
+        '#challenge-title', '.opp-title',
+    ];
+    let name = '';
+    for (const sel of nameSelectors) {
+        const el = document.querySelector(sel);
+        if (el && el.textContent.trim().length > 2) {
+            name = el.textContent.trim();
+            break;
+        }
     }
+    name = name || getMeta('og:title') || document.title.split('|')[0].trim();
+
+    // Banner
+    const banner = getMeta('og:image') || '';
+
+    // Description
+    let description = getMeta('og:description') || getMeta('description') || '';
+
+    // Full page text for parsing
+    const bodyText = document.body.innerText;
 
+    // For Devpost: extract themes from tag links
     const themes = [];
-    const seenT = new Set();
-    document.querySelectorAll('a[href*="themes"], .software-list a').forEach(function(a) {
+    document.querySelectorAll('a[href*="themes"]').forEach(a => {
         const t = a.textContent.trim();
-        if (t && t.length > 1 && t.length < 80 && !seenT.has(t)) { seenT.add(t); themes.push(t); }
+        if (t && t.length > 2 && t.length < 100) themes.push(t);
     });
 
-    const resourceLinks = [];
-    const seenHrefs = new Set();
-    const kws = ['problem','statement','pdf','rule','guideline','document','challenge','track','theme','schedule'];
-    document.querySelectorAll('a[href]').forEach(function(a) {
-        const href = a.href || '';
-        const text = a.textContent.trim();
-        const hl = href.toLowerCase(), tl = text.toLowerCase();
-        if (seenHrefs.has(href) || !href || href === '#') return;
-        const isPdf   = hl.endsWith('.pdf') || hl.includes('/pdf');
-        const isDrive = hl.includes('drive.google.com') || hl.includes('docs.google.com');
-        const isRel   = kws.some(function(kw) { return tl.includes(kw) || hl.includes(kw); });
-        if (isPdf || isDrive || isRel) {
-            seenHrefs.add(href);
-            resourceLinks.push({ text: text.substring(0, 150) || 'Document', url: href, type: isPdf ? 'pdf' : isDrive ? 'google_drive' : 'link' });
-        }
+    // Devpost sidebar prize text
+    let sidebarPrize = '';
+    document.querySelectorAll('a[href*="prizes"], .prize, [class*="prize"]').forEach(el => {
+        const t = el.textContent.trim();
+        if (t && t.length > 2) sidebarPrize += t + ' ';
     });
 
-    return {
-        name: name.substring(0, 200),
-        description: description.substring(0, 2000),
-        banner_url: banner,
-        time_map: timeMap,
-        prize_pool: prize_pool,
-        themes: themes,
-        resource_links: resourceLinks.slice(0, 30),
-        bodyText: document.body.innerText.substring(0, 15000)
-    };
-}"""
-
-
-def parse_devpost(data: dict) -> dict:
-    tm = data.get("time_map", {})
-    ps = [{"track": "Theme", "title": t, "description": ""} for t in data.get("themes", [])]
-    return {
-        "name":                  data.get("name", ""),
-        "description":           data.get("description", ""),
-        "banner_url":            data.get("banner_url", ""),
-        "start_date":            iso_to_date(tm.get("start") or tm.get("first")),
-        "end_date":              iso_to_date(tm.get("end")),
-        "registration_deadline": iso_to_date(tm.get("registration")),
-        "submission_deadline":   iso_to_date(tm.get("submission")),
-        "result_date":           iso_to_date(tm.get("result")),
-        "prize_pool":            data.get("prize_pool", ""),
-        "team_size":             {"min": 1, "max": 4},
-        "problem_statements":    ps,
-        "resource_links":        data.get("resource_links", []),
-        "body_text":             data.get("bodyText", ""),
-    }
-
-
-# ============================================================
-# GENERIC SCRIPT + REGEX FALLBACK
-# ============================================================
-
-GENERIC_SCRIPT = """() => {
-    const getMeta = function(n) {
-        const el = document.querySelector('meta[property="' + n + '"], meta[name="' + n + '"]');
-        return el ? el.getAttribute('content') || '' : '';
-    };
-    let name = '';
-    const sels = ['h1','.hackathon-name','.event-name','#challenge-title','.opp-title'];
-    for (let i = 0; i < sels.length; i++) {
-        const el = document.querySelector(sels[i]);
-        if (el && el.textContent.trim().length > 2) { name = el.textContent.trim(); break; }
-    }
-    name = name || getMeta('og:title') || document.title.split('|')[0].trim();
-    const banner      = getMeta('og:image') || '';
-    const description = getMeta('og:description') || getMeta('description') || '';
+    // Resource links: PDFs, Google Drive, problem statements, rules, guidelines
     const resourceLinks = [];
     const seenHrefs = new Set();
-    const kws = ['problem','statement','pdf','rule','guideline','document','challenge','track','theme','schedule'];
-    document.querySelectorAll('a[href]').forEach(function(a) {
+    const linkKeywords = ['problem', 'statement', 'pdf', 'rule', 'guideline', 'brochure', 'document', 'brief', 'challenge', 'track', 'theme', 'schedule', 'timeline'];
+    document.querySelectorAll('a[href]').forEach(a => {
         const href = a.href || '';
         const text = a.textContent.trim();
-        const hl = href.toLowerCase(), tl = text.toLowerCase();
+        const hrefLower = href.toLowerCase();
+        const textLower = text.toLowerCase();
         if (seenHrefs.has(href) || !href || href === '#') return;
-        const isPdf   = hl.endsWith('.pdf') || hl.includes('/pdf');
-        const isDrive = hl.includes('drive.google.com') || hl.includes('docs.google.com');
-        const isRel   = kws.some(function(kw) { return tl.includes(kw) || hl.includes(kw); });
-        if (isPdf || isDrive || isRel) {
+
+        const isPdf = hrefLower.endsWith('.pdf') || hrefLower.includes('/pdf');
+        const isDrive = hrefLower.includes('drive.google.com') || hrefLower.includes('docs.google.com');
+        const isDropbox = hrefLower.includes('dropbox.com');
+        const isRelevant = linkKeywords.some(kw => textLower.includes(kw) || hrefLower.includes(kw));
+
+        if (isPdf || isDrive || isDropbox || isRelevant) {
             seenHrefs.add(href);
-            resourceLinks.push({ text: text.substring(0, 150) || 'Document', url: href, type: isPdf ? 'pdf' : isDrive ? 'google_drive' : 'link' });
+            resourceLinks.push({
+                text: text.substring(0, 150) || 'Document',
+                url: href,
+                type: isPdf ? 'pdf' : isDrive ? 'google_drive' : isDropbox ? 'dropbox' : 'link',
+            });
         }
     });
+
     return {
         name: name.substring(0, 200),
         description: description.substring(0, 2000),
         banner_url: banner,
-        bodyText: document.body.innerText.substring(0, 20000),
-        resource_links: resourceLinks.slice(0, 30)
+        bodyText: bodyText.substring(0, 30000),
+        themes: themes,
+        sidebarPrize: sidebarPrize.trim(),
+        resourceLinks: resourceLinks.slice(0, 30),
     };
 }"""
 
 
-def regex_extract(body_text: str) -> dict:
-    result = {
-        "registration_deadline": "", "submission_deadline": "",
-        "result_date": "", "start_date": "", "end_date": "",
-        "prize_pool": "", "team_size": {"min": 1, "max": 4},
-        "problem_statements": [],
-    }
-    result["registration_deadline"] = find_dates_near(body_text, [
-        "registration close", "register by", "registration deadline",
-        "applications close", "apply by", "registration ends",
-    ])
-    result["submission_deadline"] = find_dates_near(body_text, [
-        "submission deadline", "submissions close", "submit by",
-        "final submission", "project submission", "deadline",
-    ])
-    runs = re.search(
-        r"(?:runs?\s+from|starts?\s+(?:on|from)?)\s*"
-        r"((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2})"
-        r"(?:\s*[-\u2013]\s*(\d{1,2}))?(?:[,\s]+(\d{4}))?",
-        body_text, re.IGNORECASE,
-    )
-    if runs:
-        year = runs.group(3) or str(datetime.now().year)
-        result["start_date"] = parse_any_date(f"{runs.group(1)} {year}")
-        if runs.group(2):
-            month = runs.group(1).split()[0]
-            result["end_date"] = parse_any_date(f"{month} {runs.group(2)} {year}")
-    if not result["start_date"]:
-        result["start_date"] = find_dates_near(body_text, ["start date","starts on","begins on"])
-    if not result["end_date"]:
-        result["end_date"]   = find_dates_near(body_text, ["end date","ends on","hackathon ends"])
-    result["result_date"]    = find_dates_near(body_text, ["result","winners announced","results declared"])
-
-    prize_patterns = [
-        r"(Rs\.?\s*[\d,]+(?:\s*(?:Lakhs?|Crores?|K|k|L))?)",
-        r"(INR\s*[\d,]+(?:\s*(?:Lakhs?|Crores?|K|k|L))?)",
-        r"(\$\s*[\d,]+(?:\s*(?:K|k|M))?)",
-        r"(\u20b9\s*[\d,]+(?:\s*(?:Lakhs?|Crores?|K|k|L))?)",
-    ]
-    lower = body_text.lower()
-    for kw in ["prize","reward","worth","winning","bounty","in cash","in prizes"]:
-        idx = lower.find(kw)
-        if idx == -1: continue
-        chunk = body_text[max(0, idx-200): idx+200]
-        for pat in prize_patterns:
-            m = re.search(pat, chunk, re.IGNORECASE)
-            if m: result["prize_pool"] = m.group(1).strip(); break
-        if result["prize_pool"]: break
-    if not result["prize_pool"]:
-        for pat in prize_patterns:
-            m = re.search(pat, body_text)
-            if m: result["prize_pool"] = m.group(1).strip(); break
-
-    for pat in [
-        r"team\s*size[:\s]*(\d+)\s*[-\u2013to]+\s*(\d+)",
-        r"(\d+)\s*[-\u2013to]+\s*(\d+)\s*(?:members?|people|per team)",
-        r"teams?\s+of\s+(?:up\s+to\s+)?(\d+)",
-        r"max(?:imum)?\s*(?:team)?\s*size\s*[:\s]*(\d+)",
-    ]:
-        m = re.search(pat, body_text, re.IGNORECASE)
-        if m:
-            g = [x for x in m.groups() if x]
-            result["team_size"] = (
-                {"min": int(g[0]), "max": int(g[1])} if len(g) == 2
-                else {"min": 1, "max": int(g[0])}
-            )
-            break
+@app.on_event("startup")
+async def startup() -> None:
+    global playwright, browser
+    from playwright.async_api import async_playwright
 
-    ps, seen = [], set()
-    dm = re.search(
-        r"(?:domains?|themes?|tracks?|categories|verticals)[:\s]+([^\n]+)",
-        body_text, re.IGNORECASE,
+    playwright = await async_playwright().start()
+    browser = await playwright.chromium.launch(
+        headless=True,
+        args=["--no-sandbox", "--disable-setuid-sandbox"],
     )
-    if dm:
-        for item in re.split(r"[,|/]", dm.group(1)):
-            item = item.strip().rstrip(".")
-            if 3 < len(item) < 150 and item.lower() not in seen:
-                seen.add(item.lower())
-                ps.append({"track": "", "title": item, "description": ""})
-    for m in re.finditer(
-        r"(?:PS|Problem\s*Statement|Theme|Track|Challenge)\s*#?(\d+)\s*[:\-]\s*(.{5,200})",
-        body_text, re.IGNORECASE,
-    ):
-        title = m.group(2).strip().split("\n")[0]
-        if title.lower() not in seen and len(title) > 4:
-            seen.add(title.lower())
-            ps.append({"track": f"Track {m.group(1)}", "title": title, "description": ""})
-    result["problem_statements"] = ps[:20]
-    return result
+    print("[Scraper] Playwright browser initialized")
 
 
-# ============================================================
-# SAFE EVALUATE
-# ============================================================
-
-EMPTY_DATA = {"name": "", "description": "", "banner_url": "", "bodyText": "", "resource_links": []}
-
-async def safe_evaluate(page, script: str, fallback=None) -> dict:
-    for attempt in range(3):
-        try:
-            try:
-                await page.wait_for_load_state("networkidle", timeout=8000)
-            except Exception:
-                pass
-            return await page.evaluate(script)
-        except Exception as e:
-            err = str(e)
-            print(f"[Scraper] evaluate attempt {attempt+1} failed: {err[:120]}")
-            if "Execution context was destroyed" in err or "Frame was detached" in err:
-                print("[Scraper] Redirect detected, waiting to settle...")
-                try:
-                    await page.wait_for_load_state("domcontentloaded", timeout=12000)
-                    await asyncio.sleep(2)
-                except Exception:
-                    await asyncio.sleep(3)
-                continue
-            if fallback and attempt == 1:
-                script = fallback
-                continue
-            break
-    return EMPTY_DATA
+@app.on_event("shutdown")
+async def shutdown() -> None:
+    global playwright, browser
 
+    try:
+        if browser is not None:
+            await browser.close()
+            print("[Scraper] Browser closed")
+    finally:
+        browser = None
 
-# ============================================================
-# MAIN SCRAPER
-# ============================================================
+    try:
+        if playwright is not None:
+            await playwright.stop()
+            print("[Scraper] Playwright stopped")
+    finally:
+        playwright = None
 
 async def scrape_with_playwright(url: str, platform: str) -> dict:
+    """Scrape using Playwright — renders JS, grabs full innerText for parsing."""
     global browser
-    if browser is None:
-        return {"scrape_success": False, "error": "Browser not initialized"}
-
-    # Unstop: try API first — no Playwright needed, saves all memory for this call
-    if platform == "Unstop":
-        opp_id = extract_unstop_id(url)
-        print(f"[Unstop] Extracted ID: {opp_id}")
-        if opp_id:
-            opp = await fetch_unstop_api(opp_id)
-            if opp:
-                result = parse_unstop_api(opp)
-                result["scrape_success"] = bool(result.get("name"))
-                print(f"[Unstop] API: name='{result['name']}' reg={result['registration_deadline']} sub={result['submission_deadline']} ps={len(result['problem_statements'])}")
-                return result
-        print("[Unstop] API failed, falling back to Playwright")
-
-    async with _scrape_sem:
-        # Only one Playwright scrape runs at a time to stay within HuggingFace RAM limits.
-        # Concurrent requests queue here and are processed sequentially.
-        print(f"[Scraper] Semaphore acquired for {platform}")
-        return await _do_playwright_scrape(url, platform)
-
-
-async def _do_playwright_scrape(url: str, platform: str) -> dict:
-    """Inner function — runs inside the semaphore."""
-    global browser
-
-    context = await browser.new_context(
-        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-        # Smaller viewport = less GPU memory for compositing
-        viewport={"width": 1280, "height": 800},
-        # Block credentials/service workers to reduce overhead
-        java_script_enabled=True,
-        bypass_csp=False,
-    )
     try:
-        page = await context.new_page()
-
-        # Block images, fonts, media, and tracking — saves 30-60% of page RAM
-        # We only need DOM text and __NEXT_DATA__, not rendered assets
-        async def block_resources(route, request):
-            BLOCK_TYPES = {"image", "media", "font", "stylesheet", "other",
-                           "ping", "websocket"}
-            BLOCK_DOMAINS = {"google-analytics", "googletagmanager", "facebook",
-                             "hotjar", "intercom", "amplitude", "segment",
-                             "cloudflare.com/beacon", "sentry.io"}
-            if request.resource_type in BLOCK_TYPES:
-                await route.abort()
-                return
-            url_lower = request.url.lower()
-            if any(d in url_lower for d in BLOCK_DOMAINS):
-                await route.abort()
-                return
-            await route.continue_()
-
-        await page.route("**/*", block_resources)
-
-        print(f"[Scraper] => {url}  platform={platform}")
-        wait_until = "load" if platform in ("Devfolio", "MLH") else "domcontentloaded"
-        try:
-            await page.goto(url, wait_until=wait_until, timeout=30000)
-        except Exception as e:
-            if "Timeout" not in str(e): raise
-            print("[Scraper] goto timeout, proceeding anyway")
-
-        # Reduced wait times — blocking assets means pages settle faster
-        wait_map = {"Unstop": 6, "DoraHacks": 6, "Devfolio": 5, "MLH": 3}
-        wait_sec = wait_map.get(platform, 4)
-        print(f"[Scraper] Waiting {wait_sec}s for JS...")
-        await page.wait_for_timeout(wait_sec * 1000)
-
-        # Light scroll only — no heavy scroll since images are blocked anyway
-        for frac in [0.5, 1.0, 0.0]:
-            try:
-                await page.evaluate(f"window.scrollTo(0, document.body.scrollHeight * {frac})")
-            except Exception:
-                pass
-            await asyncio.sleep(0.4)
-        await asyncio.sleep(0.5)
-
-        if platform == "Devfolio":
-            raw = await safe_evaluate(page, DEVFOLIO_SCRIPT, GENERIC_SCRIPT)
-            print(f"[Devfolio] found_next_data={raw.get('found_next_data')} keys={raw.get('hackathon_keys','')[:80]}")
-            result = parse_devfolio(raw)
-            # Regex fill for any empty structured fields
-            if not result.get("registration_deadline") or not result.get("start_date"):
-                print("[Devfolio] Filling gaps with regex")
-                regex = regex_extract(raw.get("bodyText", ""))
-                for f in ("start_date","end_date","registration_deadline","submission_deadline","result_date","prize_pool"):
-                    if not result.get(f) and regex.get(f):
-                        result[f] = regex[f]
-                if not result["problem_statements"]:
-                    result["problem_statements"] = regex.get("problem_statements", [])
-                if result["team_size"] == {"min": 1, "max": 4}:
-                    result["team_size"] = regex.get("team_size", {"min": 1, "max": 4})
-
-        elif platform == "Devpost":
-            raw = await safe_evaluate(page, DEVPOST_SCRIPT, GENERIC_SCRIPT)
-            result = parse_devpost(raw)
-            if not result.get("submission_deadline") or not result.get("start_date"):
-                regex = regex_extract(raw.get("bodyText", ""))
-                for f in ("start_date","end_date","registration_deadline","submission_deadline","result_date"):
-                    if not result.get(f) and regex.get(f):
-                        result[f] = regex[f]
-
-        else:
-            raw = await safe_evaluate(page, GENERIC_SCRIPT)
-            regex = regex_extract(raw.get("bodyText", ""))
-            result = {
-                "name":        raw.get("name", ""),
-                "description": raw.get("description", ""),
-                "banner_url":  raw.get("banner_url", ""),
-                "resource_links": raw.get("resource_links", []),
-                **regex,
+        if browser is None:
+            return {
+                "scrape_success": False,
+                "error": "Browser is not initialized. Service startup failed.",
             }
 
-        result["scrape_success"] = bool(result.get("name") and len(result.get("name","")) > 2)
-        print(f"[Scraper] Done: name='{result.get('name','')}' reg={result.get('registration_deadline','')} sub={result.get('submission_deadline','')} start={result.get('start_date','')} prize='{result.get('prize_pool','')}' ps={len(result.get('problem_statements',[]))}")
-        return result
+        context = await browser.new_context(
+            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+            viewport={"width": 1920, "height": 1080},
+        )
+
+        try:
+            page = await context.new_page()
+
+            print(f"[Scraper] Navigating to {url} (platform: {platform})")
+            await page.goto(url, wait_until="domcontentloaded", timeout=20000)
+
+            # Wait for JS rendering — longer for SPAs
+            wait_time = 8 if platform in ("Unstop",) else 5
+            print(f"[Scraper] Waiting {wait_time}s for JS rendering...")
+            await page.wait_for_timeout(wait_time * 1000)
+
+            # Scroll to trigger lazy content
+            await page.evaluate("window.scrollTo(0, document.body.scrollHeight / 3)")
+            await asyncio.sleep(1)
+            await page.evaluate("window.scrollTo(0, document.body.scrollHeight * 2 / 3)")
+            await asyncio.sleep(1)
+            await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+            await asyncio.sleep(1)
+            await page.evaluate("window.scrollTo(0, 0)")
+            await asyncio.sleep(0.5)
+
+            # Extract structured + raw text data
+            data = await page.evaluate(EXTRACT_SCRIPT)
+
+            body_text = data.get("bodyText", "")
+            name = data.get("name", "")
+            description = data.get("description", "")
+
+            print(f"[Scraper] Extracted name: '{name}', bodyText length: {len(body_text)}")
+
+            # Parse all fields from full innerText
+            extracted = extract_all_from_text(body_text, platform)
+
+            # Devpost themes from sidebar tags
+            themes = data.get("themes", [])
+            if themes and not extracted["problem_statements"]:
+                seen = set()
+                for t in themes:
+                    if t.lower() not in seen:
+                        seen.add(t.lower())
+                        extracted["problem_statements"].append({"track": "Theme", "title": t})
+
+            # Sidebar prize fallback (Devpost)
+            if not extracted["prize_pool"] and data.get("sidebarPrize"):
+                prize_text = data["sidebarPrize"]
+                for pat in [r"(\$[\d,]+(?:\.\d+)?(?:\s*(?:K|k|M))?)", r"(₹[\d,]+)"]:
+                    m = re.search(pat, prize_text)
+                    if m:
+                        extracted["prize_pool"] = m.group(1)
+                        break
+                if not extracted["prize_pool"]:
+                    extracted["prize_pool"] = prize_text[:100]
+
+            return {
+                "name": name,
+                "description": description,
+                "banner_url": data.get("banner_url", ""),
+                "scrape_success": bool(name and len(name) > 2),
+                "resource_links": data.get("resourceLinks", []),
+                **extracted,
+            }
+        finally:
+            await context.close()
 
     except Exception as e:
+        print(f"[Scraper] Error: {e}")
         import traceback
         traceback.print_exc()
         return {"scrape_success": False, "error": str(e)}
-    finally:
-        await context.close()
 
 
 # ============================================================
-# APP LIFECYCLE & ROUTES
+# API ROUTES
 # ============================================================
 
-@app.on_event("startup")
-async def startup() -> None:
-    global playwright, browser
-    from playwright.async_api import async_playwright
-    playwright = await async_playwright().start()
-    browser = await playwright.chromium.launch(
-        headless=True,
-        args=[
-            # ── Security (required for containers) ──────────────────────────
-            "--no-sandbox",
-            "--disable-setuid-sandbox",
-            # ── Memory reduction ─────────────────────────────────────────────
-            "--disable-dev-shm-usage",       # use /tmp instead of /dev/shm
-            "--disable-gpu",                 # no GPU process (~50MB saved)
-            "--no-zygote",                   # skip zygote process fork
-            "--single-process",              # single process mode (~150MB saved)
-            "--disable-extensions",          # no extension processes
-            "--disable-background-networking",
-            "--disable-background-timer-throttling",
-            "--disable-backgrounding-occluded-windows",
-            "--disable-breakpad",            # no crash reporter
-            "--disable-client-side-phishing-detection",
-            "--disable-component-update",
-            "--disable-default-apps",
-            "--disable-domain-reliability",
-            "--disable-features=AudioServiceOutOfProcess,IsolateOrigins,site-per-process",
-            "--disable-hang-monitor",
-            "--disable-ipc-flooding-protection",
-            "--disable-popup-blocking",
-            "--disable-prompt-on-repost",
-            "--disable-renderer-backgrounding",
-            "--disable-sync",
-            "--disable-translate",
-            "--metrics-recording-only",
-            "--mute-audio",
-            "--no-first-run",
-            "--safebrowsing-disable-auto-update",
-            "--password-store=basic",
-            "--use-mock-keychain",
-            # ── Reduce per-page memory ────────────────────────────────────────
-            "--js-flags=--max-old-space-size=256",  # cap JS heap to 256MB
-            "--renderer-process-limit=2",
-        ],
-    )
-    print("[Scraper] v5.0 ready - memory-optimised Chromium on HuggingFace")
-
-
-@app.on_event("shutdown")
-async def shutdown() -> None:
-    global playwright, browser
-    try:
-        if browser: await browser.close()
-    finally:
-        browser = None
-    try:
-        if playwright: await playwright.stop()
-    finally:
-        playwright = None
-
-
 @app.get("/")
 async def root():
-    return {
-        "status": "ok",
-        "service": "HackTrack Scraper v5",
-        "strategy": "__NEXT_DATA__ + REST API + time-tags + regex",
-        "platforms": ["Devfolio", "Devpost", "Unstop", "DoraHacks", "MLH"],
-    }
-
-@app.get("/health")
-async def health():
-    return {"status": "ok", "timestamp": datetime.utcnow().isoformat()}
+    return {"status": "ok", "service": "HackTrack Scraper v3"}
 
 
 @app.post("/scrape", response_model=ScrapeResponse)
 async def scrape(request: ScrapeRequest):
     url = request.url.strip()
     platform = detect_platform(url)
-    print(f"\n[Scraper] === {url}  platform={platform} ===")
+    print(f"\n[Scraper] === New scrape request: {url} (platform={platform}) ===")
+
     try:
         data = await scrape_with_playwright(url, platform)
-        return ScrapeResponse(
+
+        response = ScrapeResponse(
             name=data.get("name", ""),
             platform=platform,
             banner_url=data.get("banner_url", ""),
@@ -879,6 +531,10 @@ async def scrape(request: ScrapeRequest):
             scrape_success=data.get("scrape_success", False),
             url=url,
         )
+
+        print(f"[Scraper] Result: name='{response.name}', dates=({response.start_date}, {response.end_date}, reg={response.registration_deadline}, sub={response.submission_deadline}), prize='{response.prize_pool}', team={response.team_size}, ps={len(response.problem_statements)}")
+        return response
+
     except Exception as e:
         print(f"[Scraper] Endpoint error: {e}")
-        return ScrapeResponse(platform=platform, url=url, scrape_success=False)
+        return ScrapeResponse(platform=platform, url=url, scrape_success=False)