nekostream 2026.0.1

package/dist/scrapers/base.js

@@ -0,0 +1,41 @@
+"use strict";
+// Base scraper interface for all anime sources
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseScraper = void 0;
+class BaseScraper {
+    async getHomeCards(_section = 'trending') {
+        return [];
+    }
+    async getSchedule() {
+        return [];
+    }
+    // Helper to build full URL
+    buildUrl(path) {
+        if (path.startsWith('http'))
+            return path;
+        return `${this.baseUrl}${path.startsWith('/') ? '' : '/'}${path}`;
+    }
+    // Helper to sleep (for rate limiting)
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // Parse generic ID from URL
+    parseIdFromUrl(url) {
+        // Handle various URL formats:
+        // /phim/anime-name-a123/ -> anime-name-a123
+        // /phim/anime-name-r2-a123/tap-001-10032.html -> anime-name-r2-a123
+        // /xem-phim/anime-name.html -> anime-name
+        // Remove trailing slash and .html
+        let cleanUrl = url.replace(/\.html$/, '').replace(/\/$/, '');
+        // Extract the path component
+        const pathMatch = cleanUrl.match(/\/phim\/([^/]+)/);
+        if (pathMatch)
+            return pathMatch[1];
+        const watchMatch = cleanUrl.match(/\/xem-phim\/([^/]+)/);
+        if (watchMatch)
+            return watchMatch[1];
+        const lastSegment = cleanUrl.match(/\/([^/]+)$/);
+        return lastSegment ? lastSegment[1] : url;
+    }
+}
+exports.BaseScraper = BaseScraper;

package/dist/scrapers/crawler.js

@@ -0,0 +1,301 @@
+"use strict";
+// Playwright-based scraper engine with stealth capabilities
+// Handles JavaScript rendering, anti-bot bypass, and video stream interception
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightCrawler = void 0;
+exports.getCrawler = getCrawler;
+exports.closeCrawler = closeCrawler;
+const playwright_1 = require("playwright");
+const events_1 = require("events");
+const DEFAULT_USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0'
+];
+class PlaywrightCrawler extends events_1.EventEmitter {
+    browser = null;
+    context = null;
+    options;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            headless: true,
+            timeout: 30000,
+            ...options
+        };
+    }
+    getRandomUserAgent() {
+        return this.options.userAgent ||
+            DEFAULT_USER_AGENTS[Math.floor(Math.random() * DEFAULT_USER_AGENTS.length)];
+    }
+    async init() {
+        if (this.browser)
+            return;
+        this.browser = await playwright_1.chromium.launch({
+            headless: this.options.headless,
+            args: [
+                '--disable-blink-features=AutomationControlled',
+                '--disable-dev-shm-usage',
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-web-security',
+                '--disable-features=IsolateOrigins,site-per-process'
+            ]
+        });
+        this.context = await this.browser.newContext({
+            userAgent: this.getRandomUserAgent(),
+            viewport: { width: 1920, height: 1080 },
+            locale: 'vi-VN',
+            timezoneId: 'Asia/Ho_Chi_Minh',
+            // Stealth settings
+            javaScriptEnabled: true,
+            ignoreHTTPSErrors: true,
+            bypassCSP: true
+        });
+        // Add stealth scripts to evade detection
+        await this.context.addInitScript(() => {
+            // Override webdriver property
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined
+            });
+            // Override plugins
+            Object.defineProperty(navigator, 'plugins', {
+                get: () => [1, 2, 3, 4, 5]
+            });
+            // Override languages
+            Object.defineProperty(navigator, 'languages', {
+                get: () => ['vi-VN', 'vi', 'en-US', 'en']
+            });
+            // Override chrome
+            window.chrome = {
+                runtime: {}
+            };
+            // Override permissions
+            const originalQuery = window.navigator.permissions.query;
+            window.navigator.permissions.query = (parameters) => (parameters.name === 'notifications'
+                ? Promise.resolve({ state: 'denied' })
+                : originalQuery(parameters));
+        });
+        console.log('✅ Playwright crawler initialized');
+    }
+    async close() {
+        if (this.context) {
+            await this.context.close();
+            this.context = null;
+        }
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+    async newPage() {
+        if (!this.context) {
+            await this.init();
+        }
+        return await this.context.newPage();
+    }
+    /**
+     * Lightweight ad/tracker blocking for noisy providers (e.g. Animet/HRX).
+     * We block known ad networks and popup flows while keeping media requests intact.
+     */
+    async enableAdBlocking(page) {
+        const blockedHosts = [
+            'doubleclick.net',
+            'googlesyndication.com',
+            'googleadservices.com',
+            'adservice.google.com',
+            'adnxs.com',
+            'taboola.com',
+            'outbrain.com',
+            'popads.net',
+            'propellerads.com',
+            'adsterra.com',
+            'exoclick.com',
+            'hilltopads.net',
+            'trafficjunky.net',
+            'juicyads.com',
+            'analytics.ahrefs.com'
+        ];
+        page.on('popup', async (popup) => {
+            await popup.close().catch(() => { });
+        });
+        await page.route('**/*', async (route) => {
+            const request = route.request();
+            const url = request.url().toLowerCase();
+            const type = request.resourceType();
+            const matchedHost = blockedHosts.some((host) => url.includes(host));
+            if (matchedHost) {
+                await route.abort().catch(() => { });
+                return;
+            }
+            if (type === 'script' &&
+                /(popunder|popup|onclickads|adsystem|adnetwork|adserver|bannerads)/i.test(url)) {
+                await route.abort().catch(() => { });
+                return;
+            }
+            await route.continue().catch(async () => {
+                await route.abort().catch(() => { });
+            });
+        });
+    }
+    /**
+     * Navigate to URL and wait for content to load
+     */
+    async goto(page, url, options = {}) {
+        await page.goto(url, {
+            waitUntil: 'domcontentloaded',
+            timeout: this.options.timeout
+        });
+        // Wait for specific selector if provided
+        if (options.waitFor) {
+            await page.waitForSelector(options.waitFor, { timeout: this.options.timeout });
+        }
+        // Wait a bit for dynamic content
+        await page.waitForTimeout(1000);
+    }
+    /**
+     * Intercept network requests to capture video streams
+     */
+    async interceptStreams(page, navigateUrl) {
+        const streams = [];
+        const seenUrls = new Set();
+        // Listen for responses
+        page.on('response', async (response) => {
+            const url = response.url();
+            // Skip if already seen
+            if (seenUrls.has(url))
+                return;
+            // Check for video streams
+            const contentType = response.headers()['content-type'] || '';
+            const isStream = url.includes('.m3u8') ||
+                url.includes('.mpd') ||
+                url.includes('.mp4') ||
+                url.includes('/hls/') ||
+                url.includes('/video/') ||
+                contentType.includes('mpegurl') ||
+                contentType.includes('dash+xml') ||
+                contentType.includes('video/');
+            if (isStream) {
+                seenUrls.add(url);
+                let type = 'unknown';
+                if (url.includes('.m3u8') || contentType.includes('mpegurl')) {
+                    type = 'hls';
+                }
+                else if (url.includes('.mpd') || contentType.includes('dash')) {
+                    type = 'dash';
+                }
+                else if (url.includes('.mp4') || contentType.includes('video/mp4')) {
+                    type = 'mp4';
+                }
+                // Determine quality from URL
+                let quality = 'unknown';
+                const qualityMatch = url.match(/(\d{3,4})p|(\d{3,4})\.m3u8|quality[=_](\d+)/i);
+                if (qualityMatch) {
+                    quality = (qualityMatch[1] || qualityMatch[2] || qualityMatch[3]) + 'p';
+                }
+                else if (url.includes('1080')) {
+                    quality = '1080p';
+                }
+                else if (url.includes('720')) {
+                    quality = '720p';
+                }
+                else if (url.includes('480')) {
+                    quality = '480p';
+                }
+                streams.push({
+                    url,
+                    type,
+                    quality,
+                    headers: {
+                        'Referer': page.url(),
+                        'Origin': new URL(page.url()).origin
+                    }
+                });
+                this.emit('stream', streams[streams.length - 1]);
+            }
+        });
+        // Navigate to the page
+        await page.goto(navigateUrl, {
+            waitUntil: 'domcontentloaded',
+            timeout: this.options.timeout
+        });
+        // Wait for video player to initialize and start loading
+        await page.waitForTimeout(5000);
+        // Try to trigger video load by clicking play buttons
+        try {
+            const playButtons = await page.$$('button[class*="play"], .play-button, [aria-label*="play"], .art-icon-play');
+            for (const btn of playButtons) {
+                await btn.click().catch(() => { });
+                await page.waitForTimeout(1000);
+            }
+        }
+        catch (e) {
+            // Ignore click errors
+        }
+        // Wait a bit more for streams to be captured
+        await page.waitForTimeout(3000);
+        return streams;
+    }
+    /**
+     * Extract content from iframe
+     */
+    async extractFromIframe(page, iframeSelector) {
+        try {
+            const iframe = await page.$(iframeSelector);
+            if (!iframe)
+                return null;
+            const src = await iframe.getAttribute('src');
+            if (!src)
+                return null;
+            // Get full URL
+            const baseUrl = new URL(page.url());
+            const iframeUrl = src.startsWith('//')
+                ? `${baseUrl.protocol}${src}`
+                : src.startsWith('http')
+                    ? src
+                    : new URL(src, baseUrl).href;
+            return iframeUrl;
+        }
+        catch (error) {
+            console.error('Error extracting iframe:', error);
+            return null;
+        }
+    }
+    /**
+     * Solve Cloudflare challenge (wait for it to pass)
+     */
+    async waitForCloudflare(page, maxWait = 30000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            const title = await page.title();
+            const content = await page.content();
+            // Check if still on Cloudflare challenge
+            if (title.includes('Just a moment') ||
+                content.includes('Checking your browser') ||
+                content.includes('cf-browser-verification')) {
+                await page.waitForTimeout(1000);
+                continue;
+            }
+            // Challenge passed
+            return true;
+        }
+        return false;
+    }
+}
+exports.PlaywrightCrawler = PlaywrightCrawler;
+// Singleton instance
+let crawlerInstance = null;
+async function getCrawler(options) {
+    if (!crawlerInstance) {
+        crawlerInstance = new PlaywrightCrawler(options);
+        await crawlerInstance.init();
+    }
+    return crawlerInstance;
+}
+async function closeCrawler() {
+    if (crawlerInstance) {
+        await crawlerInstance.close();
+        crawlerInstance = null;
+    }
+}

package/dist/scrapers/external-api.js

@@ -0,0 +1,68 @@
+"use strict";
+// External API service for fetching anime metadata
+// Consolidates AniList and Jikan metadata wrappers
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.externalApi = exports.ExternalApiService = void 0;
+const anilist_api_1 = require("./anilist-api");
+const jikan_api_1 = require("./jikan-api");
+class ExternalApiService {
+    /**
+     * Get high-quality cover image — AniList only (extraLarge: 500x710)
+     */
+    async getCoverImage(title, titleAlt) {
+        try {
+            console.log('[ExternalAPI] Fetching cover for:', titleAlt?.split(',')[0] || title);
+            const meta = await anilist_api_1.anilistApi.getEnhancedMetadata(title, titleAlt);
+            if (meta?.cover) {
+                console.log('[ExternalAPI] ✅ Got AniList cover:', meta.cover.substring(0, 70) + '...');
+                return meta.cover;
+            }
+            console.log('[ExternalAPI] ⚠️ No cover found for:', titleAlt?.split(',')[0] || title);
+            return null;
+        }
+        catch (error) {
+            console.error('getCoverImage error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get Discord Presence Banner (Cover) Image — MAL Jikan
+     */
+    async getJikanCover(title, titleAlt) {
+        try {
+            return await jikan_api_1.jikanApi.getAnimeCover(title, titleAlt);
+        }
+        catch (error) {
+            console.error('getJikanCover error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get banner/background image — AniList bannerImage (1900x400)
+     */
+    async getBannerImage(title, titleAlt) {
+        try {
+            return await anilist_api_1.anilistApi.getBannerImage(title, titleAlt);
+        }
+        catch (error) {
+            console.error('getBannerImage error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get full metadata — AniList only (cover + banner + synopsis + score + genres + studios)
+     * Session-cached: free if getCoverImage was already called for the same title.
+     */
+    async getEnhancedMetadata(title, titleAlt) {
+        try {
+            return await anilist_api_1.anilistApi.getEnhancedMetadata(title, titleAlt);
+        }
+        catch (error) {
+            console.error('getEnhancedMetadata error:', error);
+            return null;
+        }
+    }
+}
+exports.ExternalApiService = ExternalApiService;
+// Singleton instance
+exports.externalApi = new ExternalApiService();

package/dist/scrapers/fingerprint.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * Browser Fingerprint Profiles
+ *
+ * Also contains:
+ *   - SiteDownError: typed error for origin-server outages
+ *   - isOriginServerDownPage: detects custom 5xx error pages from known providers
+ *
+ * Ported from botasaurus browser_decorator.py + request_decorator.py patterns:
+ * - user_agent evaluated per run_task (rotation per attempt)
+ * - Coherent UA + Accept-Language + sec-ch-ua profile (not just UA string)
+ * - evaluate_proxy: random.choice(proxy_list) → pickRandomProfile()
+ *
+ * Each profile mimics a real browser session: UA, sec-ch-ua hints, platform,
+ * and Accept-Language are kept consistent (botasaurus: "keep Referer/Accept-Language
+ * coherent with UA profile").
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostThrottle = exports.SiteDownError = void 0;
+exports.pickRandomProfile = pickRandomProfile;
+exports.buildProfileHeaders = buildProfileHeaders;
+exports.isBlockedStatus = isBlockedStatus;
+exports.isBlockedError = isBlockedError;
+exports.isCloudflareChallengePage = isCloudflareChallengePage;
+exports.isOriginServerDownPage = isOriginServerDownPage;
+/** Botasaurus pattern: full browser profile pool (not just UA strings) */
+const BROWSER_PROFILES = [
+    // Chrome 124 Windows
+    {
+        ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+        secChUa: '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+        secChUaMobile: '?0',
+        secChUaPlatform: '"Windows"',
+        acceptLanguage: 'vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7',
+    },
+    // Chrome 122 Windows
+    {
+        ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+        secChUa: '"Chromium";v="122", "Not(A:Brand";v="24", "Google Chrome";v="122"',
+        secChUaMobile: '?0',
+        secChUaPlatform: '"Windows"',
+        acceptLanguage: 'vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7',
+    },
+    // Chrome 120 Windows
+    {
+        ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        secChUa: '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+        secChUaMobile: '?0',
+        secChUaPlatform: '"Windows"',
+        acceptLanguage: 'en-US,en;q=0.9,vi;q=0.8',
+    },
+    // Chrome 124 macOS
+    {
+        ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+        secChUa: '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+        secChUaMobile: '?0',
+        secChUaPlatform: '"macOS"',
+        acceptLanguage: 'vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7',
+    },
+    // Chrome 122 macOS
+    {
+        ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+        secChUa: '"Chromium";v="122", "Not(A:Brand";v="24", "Google Chrome";v="122"',
+        secChUaMobile: '?0',
+        secChUaPlatform: '"macOS"',
+        acceptLanguage: 'en-US,en;q=0.9,vi-VN;q=0.8,vi;q=0.7',
+    },
+    // Firefox 125 Windows
+    {
+        ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0',
+        secChUa: '', // Firefox does not send sec-ch-ua
+        secChUaMobile: '',
+        secChUaPlatform: '',
+        acceptLanguage: 'vi-VN,vi;q=0.8,en-US;q=0.5,en;q=0.3',
+    },
+    // Firefox 123 Windows
+    {
+        ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0',
+        secChUa: '',
+        secChUaMobile: '',
+        secChUaPlatform: '',
+        acceptLanguage: 'vi-VN,vi;q=0.8,en-US;q=0.5,en;q=0.3',
+    },
+    // Chrome 123 Linux
+    {
+        ua: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
+        secChUa: '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
+        secChUaMobile: '?0',
+        secChUaPlatform: '"Linux"',
+        acceptLanguage: 'en-US,en;q=0.9',
+    },
+];
+/**
+ * Botasaurus pattern: evaluate_proxy (random.choice) → pick random full profile.
+ * Ensures UA + sec-ch-ua + platform are always coherent.
+ */
+function pickRandomProfile() {
+    return BROWSER_PROFILES[Math.floor(Math.random() * BROWSER_PROFILES.length)];
+}
+/**
+ * Build fetch headers from a coherent browser profile.
+ * Botasaurus: "keep Referer/Accept-Language coherent with UA profile"
+ */
+function buildProfileHeaders(profile, referer, extraHeaders = {}) {
+    const headers = {
+        'User-Agent': profile.ua,
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+        'Accept-Language': profile.acceptLanguage,
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Referer': referer,
+        'Cache-Control': 'no-cache',
+        'Pragma': 'no-cache',
+        'Upgrade-Insecure-Requests': '1',
+    };
+    // Add Chromium client hints only for Chrome/Chromium profiles
+    if (profile.secChUa) {
+        headers['sec-ch-ua'] = profile.secChUa;
+        headers['sec-ch-ua-mobile'] = profile.secChUaMobile;
+        headers['sec-ch-ua-platform'] = profile.secChUaPlatform;
+        headers['Sec-Fetch-Dest'] = 'document';
+        headers['Sec-Fetch-Mode'] = 'navigate';
+        headers['Sec-Fetch-Site'] = 'same-origin';
+        headers['Sec-Fetch-User'] = '?1';
+    }
+    return { ...headers, ...extraHeaders };
+}
+/**
+ * Botasaurus pattern: isBlockedError — expanded from 403-only to cover full
+ * Cloudflare error range and rate-limit responses.
+ *
+ * Cloudflare error codes:
+ *   520 Unknown error, 521 Web server is down, 522 Connection timed out
+ *   523 Origin unreachable, 524 Timeout, 525 SSL handshake failed
+ *   526 Invalid SSL cert, 527 Railgun error, 530 Origin DNS error
+ *   429 Too Many Requests (rate limiting)
+ *   403 Forbidden (explicit block)
+ */
+function isBlockedStatus(status) {
+    return status === 403 || status === 429 || (status >= 520 && status <= 530);
+}
+function isBlockedError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const msg = error.message;
+    // Match "HTTP 403", "HTTP 429", "HTTP 520" ... "HTTP 530"
+    const statusMatch = msg.match(/HTTP (\d{3})/);
+    if (statusMatch) {
+        return isBlockedStatus(parseInt(statusMatch[1], 10));
+    }
+    return msg.includes('Forbidden');
+}
+/**
+ * Botasaurus pattern: Cloudflare challenge detection.
+ * Detects when a 200 response body is actually a CF challenge/CAPTCHA page.
+ * (botasaurus: wait_for_cf, CloudflareDetectionException)
+ */
+function isCloudflareChallengePage(html) {
+    if (html.length > 50000)
+        return false; // Real pages are usually longer
+    const lower = html.toLowerCase();
+    return (lower.includes('just a moment') ||
+        lower.includes('cf-browser-verification') ||
+        lower.includes('checking your browser') ||
+        lower.includes('enable javascript and cookies') ||
+        lower.includes('cloudflare') && lower.includes('challenge') ||
+        lower.includes('ray id') && html.length < 15000 ||
+        lower.includes('_cf_chl_opt') ||
+        lower.includes('turnstile'));
+}
+/**
+ * Typed error for when the origin server (not Cloudflare) is returning a 5xx
+ * error page. Thrown when fetchHtmlWithPlaywright detects a known error page.
+ */
+class SiteDownError extends Error {
+    providerName;
+    constructor(providerName) {
+        super(`${providerName}: Máy chủ đang bảo trì hoặc gặp sự cố tạm thời. Vui lòng thử lại sau.`);
+        this.providerName = providerName;
+        this.name = 'SiteDownError';
+    }
+}
+exports.SiteDownError = SiteDownError;
+/**
+ * Detects a custom origin-server 5xx error page returned by known providers.
+ *
+ * AnimeVietsub returns an 888k HTML page when its origin is down that:
+ *   - Has title "Lỗi Server 5xx"
+ *   - Has class="feature-list" in body (their custom error UI)
+ *   - Contains zero /phim/ links
+ *
+ * Unlike isCloudflareChallengePage (which catches CF-generated pages),
+ * this catches the provider's own error HTML.
+ */
+function isOriginServerDownPage(html) {
+    const lower = html.toLowerCase();
+    // AnimeVietsub custom 5xx page markers
+    const isAVS5xx = lower.includes('lỗi server 5xx') ||
+        lower.includes('loi server 5xx') ||
+        (lower.includes('feature-list') &&
+            lower.includes('web server is returning an unknown error') &&
+            !lower.includes('/phim/'));
+    if (isAVS5xx)
+        return true;
+    // Generic origin-down signals when page has no real content
+    const hasNoLinks = !lower.includes('/phim/') && !lower.includes('/anime/');
+    const isErrorPage = (lower.includes('500') || lower.includes('503') || lower.includes('502')) &&
+        lower.includes('server') &&
+        html.length > 200000 && // Big page = full CSS bundle injected
+        hasNoLinks;
+    return isErrorPage;
+}
+/**
+ * Botasaurus pattern: per-host request throttle.
+ * "Enforce request spacing to reduce ban probability" (Phase 2, Task 2.3).
+ * Maintains last-request timestamp per hostname and enforces minimum gap.
+ */
+class HostThrottle {
+    lastRequestAt = new Map();
+    minGapMs;
+    constructor(minGapMs = 800) {
+        this.minGapMs = minGapMs;
+    }
+    async wait(url) {
+        let hostname;
+        try {
+            hostname = new URL(url).hostname;
+        }
+        catch {
+            return;
+        }
+        const last = this.lastRequestAt.get(hostname) ?? 0;
+        const elapsed = Date.now() - last;
+        const remaining = this.minGapMs - elapsed;
+        if (remaining > 0) {
+            await new Promise((resolve) => setTimeout(resolve, remaining));
+        }
+        this.lastRequestAt.set(hostname, Date.now());
+    }
+}
+exports.HostThrottle = HostThrottle;