nekostream 2026.3.1 → 2026.4.1

package/dist/scrapers/providers/anime47.js

@@ -42,6 +42,7 @@ const anilist_1 = require("../anilist");
 const external_api_1 = require("../external-api");
 const storage_1 = require("../../storage");
 const auth_service_1 = require("../auth-service");
+const search_utils_1 = require("../search-utils");
 let cacheHooks = {};
 function configureAnime47CacheHooks(hooks) {
     cacheHooks = {
@@ -117,7 +118,7 @@ class Anime47Provider extends base_1.BaseScraper {
      */
     async fetchHtml(url, options = {}) {
         const token = (0, storage_1.getProviderToken)('anime47');
-        if (token) {
+        if (token && options.useBrowserFallback !== false) {
             const html = await (0, auth_service_1.fetchA47Page)(url);
             if (html)
                 return html;
@@ -315,9 +316,9 @@ class Anime47Provider extends base_1.BaseScraper {
     mapStateAnime(item) {
         if (!item || typeof item !== 'object')
             return null;
-        const link = String(item.link || item.canonical_url || '');
+        const link = String(item.link || item.canonical_url || item.url || '');
         const id = this.normalizeAnimeIdFromLink(link);
-        const title = String(item.title || '').trim();
+        const title = String(item.title || item.name || '').trim();
         if (!id || !title)
             return null;
         const rawPoster = String(item.poster || item.thumbnail || item.image || item.images?.poster || '');
@@ -474,66 +475,68 @@ class Anime47Provider extends base_1.BaseScraper {
         }
     }
     async search(query) {
-        const q = query.trim();
+        const q = (0, search_utils_1.cleanSearchQuery)(query);
         if (!q)
             return [];
         const merged = [];
-        const seen = new Set();
-        const addResult = (item) => {
-            if (!item || !item.id || seen.has(item.id))
-                return;
-            seen.add(item.id);
-            merged.push(item);
-        };
-        // Primary path: real Anime47 API used by site frontend
+        const addResults = (items) => merged.push(...items);
+        const hasRelevant = () => (0, search_utils_1.rankSearchResults)(merged, q, 48).length >= 12;
+        // Primary path: real Anime47 API used by site frontend. Keep pages serial
+        // to avoid multiplying load on provider while stopping as soon as useful.
         try {
             for (let page = 1; page <= 3; page++) {
                 const apiUrl = `${this.apiBase}/search/full/?lang=vi&keyword=${encodeURIComponent(q)}&page=${page}`;
-                const response = await this.fetchJson(apiUrl, { retries: 1 });
-                const rows = Array.isArray(response?.results) ? response.results : [];
+                const response = await this.fetchJson(apiUrl, {
+                    timeoutMs: 8000,
+                    retries: 0
+                });
+                const rows = Array.isArray(response)
+                    ? response
+                    : Array.isArray(response?.results)
+                        ? response.results
+                        : Array.isArray(response?.data)
+                            ? response.data
+                            : Array.isArray(response?.items)
+                                ? response.items
+                                : [];
                 if (rows.length === 0)
                     break;
-                for (const row of rows)
-                    addResult(this.mapStateAnime(row));
+                addResults(rows.map((row) => this.mapStateAnime(row)).filter((item) => Boolean(item)));
+                if (hasRelevant())
+                    break;
             }
         }
         catch (error) {
             console.warn('[Anime47] search api failed:', error);
         }
-        // Secondary fallback: parse page HTML (only when API returned no results)
-        if (merged.length === 0) {
+        // Secondary fallback: parse page HTML only when API has no relevant hit.
+        if ((0, search_utils_1.rankSearchResults)(merged, q, 48).length === 0) {
             const urls = [
                 `${this.baseUrl}/tim-kiem/${encodeURIComponent(q)}`,
                 `${this.baseUrl}/filter?keyword=${encodeURIComponent(q)}`
             ];
             for (const url of urls) {
                 try {
-                    const html = await this.fetchHtml(url, { retries: 1 });
+                    const html = await this.fetchHtml(url, {
+                        timeoutMs: 8000,
+                        retries: 0,
+                        useBrowserFallback: false
+                    });
                     const state = this.extractInitialState(html);
                     const stateResults = this.extractListsFromState(state)
                         .flat()
                         .map((item) => this.mapStateAnime(item))
                         .filter((v) => Boolean(v));
-                    const htmlResults = this.parseAnimeCardsFromHtml(html);
-                    for (const item of [...stateResults, ...htmlResults])
-                        addResult(item);
-                    if (merged.length > 0)
-                        break; // stop after first URL that yields results
+                    addResults([...stateResults, ...this.parseAnimeCardsFromHtml(html)]);
+                    if ((0, search_utils_1.rankSearchResults)(merged, q, 48).length > 0)
+                        break;
                 }
                 catch (error) {
                     console.warn('[Anime47] search url failed:', url, error);
                 }
             }
         }
-        const lowered = q.toLowerCase();
-        const ranked = merged
-            .sort((a, b) => {
-            const aHit = a.title.toLowerCase().includes(lowered) ? 1 : 0;
-            const bHit = b.title.toLowerCase().includes(lowered) ? 1 : 0;
-            return bHit - aHit;
-        })
-            .slice(0, 48);
-        return ranked;
+        return (0, search_utils_1.rankSearchResults)(merged, q, 48);
     }
     async getAnimeDetail(id) {
         try {

package/dist/scrapers/providers/animevietsub.js

@@ -46,6 +46,7 @@ const anilist_1 = require("../anilist");
 const auth_service_1 = require("../auth-service");
 const storage_1 = require("../../storage");
 const logger_1 = require("../../logger");
+const search_utils_1 = require("../search-utils");
 class AnimeVietsubProvider extends base_1.BaseScraper {
     name = 'AnimeVietsub';
     baseUrl = 'https://animevietsub.site';
@@ -226,7 +227,7 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
         if (hostname && AnimeVietsubProvider.blockedHostCache.has(hostname)) {
             if (!useBrowserFallback)
                 throw new Error(`Lỗi kết nối: host bị chặn (${hostname})`);
-            return await this.fetchHtmlWithPlaywright(url);
+            return await this.fetchHtmlWithPlaywright(url, options.browserTimeoutMs);
         }
         let lastError;
         let consecutiveBlocks = 0;
@@ -257,7 +258,7 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
                     }
                     if (useBrowserFallback) {
                         (0, logger_1.debugWarn)(`[Scraper] Blocked (${response.status}) after ${consecutiveBlocks} attempt(s), escalating to Playwright for ${url}`);
-                        return await this.fetchHtmlWithPlaywright(url);
+                        return await this.fetchHtmlWithPlaywright(url, options.browserTimeoutMs);
                     }
                     throw new Error(`Lỗi kết nối: HTTP ${response.status}`);
                 }
@@ -276,7 +277,7 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
                     }
                     if (useBrowserFallback) {
                         (0, logger_1.debugWarn)(`[Scraper] CF challenge persists, escalating to Playwright for ${url}`);
-                        return await this.fetchHtmlWithPlaywright(url);
+                        return await this.fetchHtmlWithPlaywright(url, options.browserTimeoutMs);
                     }
                     throw new Error('Lỗi kết nối: Cloudflare challenge không thể vượt qua');
                 }
@@ -297,7 +298,7 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
                     }
                     if (useBrowserFallback) {
                         (0, logger_1.debugWarn)(`[Scraper] Block error exhausted retries, escalating to Playwright for ${url}`);
-                        return await this.fetchHtmlWithPlaywright(url);
+                        return await this.fetchHtmlWithPlaywright(url, options.browserTimeoutMs);
                     }
                     throw new Error(`Lỗi kết nối: ${error.message}`);
                 }
@@ -353,8 +354,10 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
      * With it (set by the user's normal Electron browser visit), CF treats the
      * Playwright session as a recognized client.
      */
-    async fetchHtmlWithPlaywright(url) {
+    async fetchHtmlWithPlaywright(url, timeoutMs = 35000) {
         const { chromium } = await Promise.resolve().then(() => __importStar(require('playwright')));
+        const deadline = Date.now() + timeoutMs;
+        const remainingTime = (ceiling) => Math.max(1, Math.min(ceiling, deadline - Date.now()));
         // --- Step 1: Pull CF + session cookies from stored session ---
         let playwrightCookies = [];
         try {
@@ -425,32 +428,35 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
         }
         const page = await context.newPage();
         try {
-            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 35000 });
+            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: remainingTime(35000) });
             // Wait for CF challenge to pass (if cookies didn't help, it may still loop)
             let cfWaitMs = 0;
-            while (cfWaitMs < 20000) {
+            while (cfWaitMs < 20000 && Date.now() < deadline) {
                 const title = await page.title().catch(() => '');
                 const snippet = await page.content().catch(() => '').then(h => h.slice(0, 2000).toLowerCase());
                 if (title.includes('Just a moment') ||
                     snippet.includes('_cf_chl_opt') ||
                     snippet.includes('cf-browser-verification')) {
-                    await page.waitForTimeout(1500);
-                    cfWaitMs += 1500;
+                    const waitMs = remainingTime(1500);
+                    await page.waitForTimeout(waitMs);
+                    cfWaitMs += waitMs;
                     continue;
                 }
                 break;
             }
             // Wait for SPA card content to render via AJAX
             try {
-                await page.waitForSelector('a[href*="/phim/"]', { timeout: 12000 });
+                await page.waitForSelector('a[href*="/phim/"]', { timeout: remainingTime(12000) });
             }
             catch {
                 // Scroll to trigger lazy content
                 await page.evaluate(() => globalThis.scrollTo(0, globalThis.document.body.scrollHeight / 2));
-                await page.waitForTimeout(2000);
+                if (Date.now() < deadline)
+                    await page.waitForTimeout(remainingTime(2000));
             }
             // Extra settle time
-            await page.waitForTimeout(1000);
+            if (Date.now() < deadline)
+                await page.waitForTimeout(remainingTime(1000));
             this.rememberWorkingDomain(page.url(), url);
             const html = await page.content();
             if (!html || html.length < 100) {
@@ -728,7 +734,7 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
                 return results.slice(0, 48);
             // Only fallback to search when HTML parsed OK but yielded 0 cards (not a 403/down scenario)
             (0, logger_1.debugWarn)('[Scraper] getHomeCards: HTML loaded but 0 cards parsed, trying search fallback');
-            return this.search('anime');
+            return this.searchInternal('anime', true);
         }
         catch (error) {
             // Site is temporarily down — propagate as a typed error so UI can show proper message
@@ -747,44 +753,68 @@ class AnimeVietsubProvider extends base_1.BaseScraper {
             return [];
         }
     }
-    async search(query) {
-        if (!query || query.trim().length === 0) {
+    parseSearchCards(html) {
+        if (html.length < 100)
+            return [];
+        const $ = this.parseHtml(html);
+        const results = [];
+        const seenIds = new Set();
+        this.selectCardElements($).each((_, el) => {
+            const card = this.extractCardData($(el), $);
+            if (!card || seenIds.has(card.id))
+                return;
+            seenIds.add(card.id);
+            results.push(card);
+        });
+        return results;
+    }
+    async searchInternal(query, allowUnmatched = false) {
+        const normalizedQuery = (0, search_utils_1.cleanSearchQuery)(query);
+        if (!normalizedQuery)
             return [];
-        }
-        // Search URL candidates — try each in order until one returns cards
         const searchUrls = [
-            `${this.baseUrl}/tim-kiem/${encodeURIComponent(query)}/`,
-            `${this.baseUrl}/?s=${encodeURIComponent(query)}`,
+            `${this.baseUrl}/tim-kiem/${encodeURIComponent(normalizedQuery)}/`,
+            `${this.baseUrl}/?s=${encodeURIComponent(normalizedQuery)}`,
         ];
+        const candidates = [];
+        const rawOptions = {
+            timeoutMs: 8000,
+            retries: 0,
+            useBrowserFallback: false,
+            allowDomainFallback: false,
+        };
         for (const searchUrl of searchUrls) {
             try {
-                // useBrowserFallback: true → 403 after retries auto-escalates to Playwright
-                const html = await this.fetchHtml(searchUrl, { retries: 2, useBrowserFallback: true });
-                if (html.length < 100) {
-                    continue;
-                }
-                const $ = this.parseHtml(html);
-                const results = [];
-                const seenIds = new Set();
-                this.selectCardElements($).each((_, el) => {
-                    const card = this.extractCardData($(el), $);
-                    if (!card || seenIds.has(card.id))
-                        return;
-                    seenIds.add(card.id);
-                    results.push(card);
-                });
-                if (results.length > 0) {
-                    return results.slice(0, 24);
-                }
+                const html = await this.fetchHtml(searchUrl, rawOptions);
+                candidates.push(...this.parseSearchCards(html));
+                const ranked = (0, search_utils_1.rankSearchResults)(candidates, normalizedQuery, 24);
+                if (ranked.length >= 12)
+                    return ranked;
             }
             catch (error) {
-                // Site down — re-throw immediately, don't try other URLs
                 if (error instanceof fingerprint_1.SiteDownError)
                     throw error;
                 (0, logger_1.debugWarn)('[Scraper] Search attempt failed for', searchUrl, error);
             }
         }
-        return [];
+        // One direct browser attempt handles pages that require rendering, without
+        // another native request or alternate-domain fan-out.
+        if ((0, search_utils_1.rankSearchResults)(candidates, normalizedQuery, 24).length === 0) {
+            try {
+                const html = await this.fetchHtmlWithPlaywright(searchUrls[0], 20000);
+                candidates.push(...this.parseSearchCards(html));
+            }
+            catch (error) {
+                if (error instanceof fingerprint_1.SiteDownError)
+                    throw error;
+                (0, logger_1.debugWarn)('[Scraper] Search browser fallback failed for', searchUrls[0], error);
+            }
+        }
+        const ranked = (0, search_utils_1.rankSearchResults)(candidates, normalizedQuery, 24);
+        return ranked.length > 0 || !allowUnmatched ? ranked : candidates.slice(0, 24);
+    }
+    async search(query) {
+        return this.searchInternal(query);
     }
     async getAnimeDetail(id) {
         try {

package/dist/scrapers/search-utils.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanSearchQuery = cleanSearchQuery;
+exports.rankSearchResults = rankSearchResults;
+const DISPLAY_LABEL = '(?:vietsub|thuyết minh|lồng tiếng|fhd|hd|full|tập\\s+\\d+)';
+const BRACKETED_LABEL = new RegExp(`\\s*[\\[(]\\s*${DISPLAY_LABEL}\\s*[\\])]\\s*$`, 'iu');
+const TRAILING_LABEL = new RegExp(`(?:\\s*[-–—|:]\\s*|\\s+)${DISPLAY_LABEL}\\s*$`, 'iu');
+function cleanSearchQuery(input) {
+    return String(input || '')
+        .normalize('NFKC')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function stripDisplayLabels(input) {
+    let value = input;
+    let previous = '';
+    while (value !== previous) {
+        previous = value;
+        value = value.replace(BRACKETED_LABEL, '').replace(TRAILING_LABEL, '').trim();
+    }
+    return value;
+}
+function normalizeText(input) {
+    const accented = stripDisplayLabels(cleanSearchQuery(input))
+        .toLocaleLowerCase('vi-VN')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const folded = accented
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .replace(/đ/g, 'd');
+    const tokens = folded
+        .split(' ')
+        .filter((token) => token.length >= 3 || /^\d+$/.test(token));
+    return { accented, folded, tokens };
+}
+function hasVietnameseMarks(text) {
+    return text.accented !== text.folded;
+}
+function containsWholePhrase(text, query) {
+    return Boolean(query) && ` ${text} `.includes(` ${query} `);
+}
+function startsWithWholePhrase(text, query) {
+    return Boolean(query) && (text === query || text.startsWith(`${query} `));
+}
+function scoreTitle(title, query, isAlt) {
+    if (!title)
+        return 0;
+    const candidate = normalizeText(title);
+    if (!candidate.folded || !query.folded)
+        return 0;
+    const offset = isAlt ? 30 : 0;
+    const queryHasMarks = hasVietnameseMarks(query);
+    const canUseBroadMatch = query.folded.length >= 3 || /^\d+$/.test(query.folded);
+    if (queryHasMarks && candidate.accented === query.accented)
+        return 1000 - offset;
+    if (candidate.folded === query.folded)
+        return 940 - offset;
+    if (canUseBroadMatch) {
+        if (queryHasMarks && startsWithWholePhrase(candidate.accented, query.accented))
+            return 850 - offset;
+        if (startsWithWholePhrase(candidate.folded, query.folded))
+            return 800 - offset;
+        if (queryHasMarks && containsWholePhrase(candidate.accented, query.accented))
+            return 700 - offset;
+        if (containsWholePhrase(candidate.folded, query.folded))
+            return 650 - offset;
+    }
+    if (query.tokens.length === 0)
+        return 0;
+    const candidateTokens = new Set(candidate.tokens);
+    const matchedTokens = query.tokens.filter((token) => candidateTokens.has(token)).length;
+    const coverage = matchedTokens / query.tokens.length;
+    if (coverage < 0.6)
+        return 0;
+    return Math.round(400 + coverage * 100) - (isAlt ? 20 : 0);
+}
+function rankSearchResults(items, query, limit) {
+    const normalizedQuery = normalizeText(query);
+    if (!normalizedQuery.folded || limit <= 0)
+        return [];
+    const byId = new Map();
+    items.forEach((item, index) => {
+        const score = Math.max(scoreTitle(item.title, normalizedQuery, false), scoreTitle(item.titleAlt, normalizedQuery, true));
+        if (score === 0)
+            return;
+        const id = cleanSearchQuery(item.id).toLocaleLowerCase('vi-VN');
+        if (!id)
+            return;
+        const current = byId.get(id);
+        if (!current || score > current.score) {
+            byId.set(id, { item, score, index });
+        }
+    });
+    return [...byId.values()]
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .slice(0, limit)
+        .map(({ item }) => item);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nekostream",
-  "version": "2026.3.1",
+  "version": "2026.4.1",
   "description": "Bettter version of NekoStream ",
   "keywords": [
     "anime",