kiku-agent 1.2.0 → 1.3.1

package/server/agent/webSearch.js

@@ -3,75 +3,281 @@ import { execFile } from 'node:child_process';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { assertSafeUrlHostname, sanitizeUrl } from './sanitizer.js';
+import http from 'node:http';
+import https from 'node:https';
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { assertSafeUrlHostname, sanitizeUrl, isPrivateIPv4, isPrivateIPv6, isIpAddress } from './sanitizer.js';
+import { getContextualizedSearchQuery } from './catalogEntityResolver.js';
+import { galleryData } from '../../src/data/galleryData.js';
+import { discographyData } from '../../src/data/discographyData.js';
+import { musicVideoData } from '../../src/data/musicVideoData.js';
+import { profileData } from '../../src/data/profileData.js';
+import { defaultMetaSearch, hybridWebSearch } from './websearch/index.js';
+import { computeSearchCacheKey, TTL_GENERAL_MS } from './websearch/resilience/cache.js';
+import {
+  decodeHtmlBytes,
+  decodeEntities,
+  normalizeText,
+  loadCheerio,
+  extractMainContent,
+  splitIntoPassages,
+  selectPassages,
+  filterUniquePassages,
+  truncateByWords,
+} from './websearch/extract.js';
+
+export { defaultMetaSearch, hybridWebSearch };
+
+export class BoundedLruCache {
+  constructor(maxSize = 500) {
+    this.maxSize = Math.max(10, maxSize);
+    this.cache = new Map();
+  }
 
-let _cheerioLoad = null;
-async function loadCheerio() {
-  if (_cheerioLoad) return _cheerioLoad;
-  try {
-    const mod = await import('cheerio');
-    _cheerioLoad = mod.load;
-    return _cheerioLoad;
-  } catch {
-    return null;
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return undefined;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry.value;
+  }
+
+  set(key, value, ttlMs = 0) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) this.cache.delete(oldestKey);
+    }
+    const expiresAt = ttlMs > 0 ? Date.now() + ttlMs : 0;
+    this.cache.set(key, { value, expiresAt });
+    return value;
+  }
+
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+
+  delete(key) {
+    return this.cache.delete(key);
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+
+  get size() {
+    return this.cache.size;
+  }
+}
+
+let _chromeConcurrency = 0;
+const _chromeWaiters = [];
+const MAX_CHROME_CONCURRENCY = 2;
+
+async function acquireChromeLock(timeoutMs = 20000) {
+  if (_chromeConcurrency < MAX_CHROME_CONCURRENCY) {
+    _chromeConcurrency++;
+    return () => releaseChromeLock();
+  }
+  return new Promise((resolve, reject) => {
+    let entry = null;
+    const timer = setTimeout(() => {
+      const idx = _chromeWaiters.indexOf(entry);
+      if (idx !== -1) _chromeWaiters.splice(idx, 1);
+      reject(new Error('Chrome screenshot queue timed out waiting for an available browser process'));
+    }, timeoutMs);
+    entry = () => {
+      clearTimeout(timer);
+      _chromeConcurrency++;
+      resolve(() => releaseChromeLock());
+    };
+    _chromeWaiters.push(entry);
+  });
+}
+
+function releaseChromeLock() {
+  _chromeConcurrency = Math.max(0, _chromeConcurrency - 1);
+  if (_chromeWaiters.length > 0) {
+    const next = _chromeWaiters.shift();
+    next();
   }
 }
 
 function cleanHtml(html) {
   if (!html) return '';
-  return html
-    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, ' ')
-    .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, ' ')
-    .replace(/<nav\b[^<]*(?:(?!<\/nav>)<[^<]*)*<\/nav>/gi, ' ')
-    .replace(/<footer\b[^<]*(?:(?!<\/footer>)<[^<]*)*<\/footer>/gi, ' ')
-    .replace(/<header\b[^<]*(?:(?!<\/header>)<[^<]*)*<\/header>/gi, ' ')
-    .replace(/<aside\b[^<]*(?:(?!<\/aside>)<[^<]*)*<\/aside>/gi, ' ')
-    .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, ' ')
-    .replace(/<noscript\b[^<]*(?:(?!<\/noscript>)<[^<]*)*<\/noscript>/gi, ' ')
-    .replace(/<[^>]+>/g, ' ')
-    .replace(/&nbsp;/g, ' ')
-    .replace(/&amp;/g, '&')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&mdash;/g, '—')
-    .replace(/&ndash;/g, '–')
-    .replace(/&hellip;/g, '...')
-    .replace(/\s+/g, ' ')
-    .trim();
+  return normalizeText(decodeEntities(
+    String(html)
+      .replace(/<script\b[\s\S]*?<\/script>/gi, ' ')
+      .replace(/<style\b[\s\S]*?<\/style>/gi, ' ')
+      .replace(/<[^>]+>/g, ' ')
+  ));
 }
 
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 
+const SAFE_FETCH_DNS_CACHE = new Map();
+const SAFE_FETCH_DNS_SUCCESS_TTL_MS = 60_000;
+const SAFE_FETCH_DNS_FAIL_TTL_MS = 10_000;
+const SAFE_FETCH_DNS_CACHE_MAX = 500;
+
+function setSafeFetchDnsEntry(hostname, entry) {
+  if (!SAFE_FETCH_DNS_CACHE.has(hostname) && SAFE_FETCH_DNS_CACHE.size >= SAFE_FETCH_DNS_CACHE_MAX) {
+    const oldestKey = SAFE_FETCH_DNS_CACHE.keys().next().value;
+    if (oldestKey !== undefined) SAFE_FETCH_DNS_CACHE.delete(oldestKey);
+  }
+  SAFE_FETCH_DNS_CACHE.set(hostname, entry);
+}
+
+async function safeFetchDnsLookup(hostname) {
+  const cached = SAFE_FETCH_DNS_CACHE.get(hostname);
+  if (cached && cached.expires > Date.now()) {
+    if (cached.error) throw new Error(cached.error);
+    return cached.addresses;
+  }
+  if (cached) SAFE_FETCH_DNS_CACHE.delete(hostname);
+  try {
+    const addresses = await dnsLookup(hostname, { all: true });
+    setSafeFetchDnsEntry(hostname, { expires: Date.now() + SAFE_FETCH_DNS_SUCCESS_TTL_MS, addresses });
+    return addresses;
+  } catch (dnsErr) {
+    const message = `Unable to resolve hostname ${hostname}: ${dnsErr.message}`;
+    setSafeFetchDnsEntry(hostname, { expires: Date.now() + SAFE_FETCH_DNS_FAIL_TTL_MS, error: message });
+    throw new Error(message);
+  }
+}
+
 export async function safeFetch(inputUrl, options = {}, maxRedirects = 5) {
   let currentUrl = String(inputUrl || '');
-  let currentOptions = { ...options, redirect: 'manual' };
+  let currentOptions = { ...options };
 
   for (let redirects = 0; redirects <= maxRedirects; redirects++) {
     const sanitized = sanitizeUrl(currentUrl);
     if (!sanitized.safe) throw new Error(`URL rejected by SSRF guard: ${sanitized.reason}`);
-    const dnsCheck = await assertSafeUrlHostname(sanitized.hostname);
-    if (!dnsCheck.safe) throw new Error(`URL rejected by SSRF guard: ${dnsCheck.reason}`);
 
-    const response = await fetch(sanitized.url.href, currentOptions);
+    const parsedUrl = sanitized.url;
+    const hostname = sanitized.hostname;
+
+    let targetIp = hostname;
+    if (!isIpAddress(hostname)) {
+      const addresses = await safeFetchDnsLookup(hostname);
+      if (!addresses || addresses.length === 0) {
+        throw new Error(`Unable to resolve hostname ${hostname}`);
+      }
+      for (const { address } of addresses) {
+        if (isPrivateIPv4(address) || isPrivateIPv6(address)) {
+          throw new Error(`Host resolved to private/internal IP: ${address}`);
+        }
+      }
+      targetIp = addresses[0].address;
+    } else {
+      if (isPrivateIPv4(hostname) || isPrivateIPv6(hostname)) {
+        throw new Error(`Host is private/internal IP: ${hostname}`);
+      }
+    }
+
+    const isHttps = parsedUrl.protocol === 'https:';
+    const client = isHttps ? https : http;
+    const port = parsedUrl.port ? Number(parsedUrl.port) : (isHttps ? 443 : 80);
+    const method = String(currentOptions.method || 'GET').toUpperCase();
+
+    const headers = { ...(currentOptions.headers || {}) };
+    if (!headers.host && !headers.Host) {
+      headers.Host = parsedUrl.host;
+    }
+
+    const response = await new Promise((resolve, reject) => {
+      let req = null;
+      try {
+        req = client.request({
+          host: targetIp,
+          port,
+          path: parsedUrl.pathname + parsedUrl.search,
+          method,
+          headers,
+          servername: isHttps ? hostname : undefined,
+          signal: currentOptions.signal,
+          timeout: currentOptions.timeout || 15000
+        }, res => {
+          const chunks = [];
+          let bytesReceived = 0;
+          let aborted = false;
+          const maxBytes = currentOptions.maxBytes || 5_000_000;
+
+          const finish = () => {
+            if (aborted) return;
+            aborted = true;
+            const bodyBuffer = Buffer.concat(chunks);
+            const responseHeaders = new Headers();
+            for (const [k, v] of Object.entries(res.headers)) {
+              if (Array.isArray(v)) {
+                v.forEach(val => responseHeaders.append(k, val));
+              } else if (v !== undefined) {
+                responseHeaders.set(k, v);
+              }
+            }
+
+            resolve({
+              status: res.statusCode || 200,
+              statusText: res.statusMessage || '',
+              ok: res.statusCode >= 200 && res.statusCode < 300,
+              headers: responseHeaders,
+              url: parsedUrl.href,
+              text: async () => bodyBuffer.toString('utf8'),
+              json: async () => JSON.parse(bodyBuffer.toString('utf8')),
+              buffer: async () => bodyBuffer
+            });
+          };
+
+          res.on('data', chunk => {
+            bytesReceived += chunk.length;
+            if (bytesReceived > maxBytes) {
+              finish();
+              req.destroy();
+              return;
+            }
+            chunks.push(chunk);
+          });
+
+          res.on('end', finish);
+          res.on('error', () => finish());
+        });
+
+        req.on('error', reject);
+        req.on('timeout', () => {
+          req.destroy(new Error(`Request to ${hostname} timed out`));
+        });
+
+        if (currentOptions.body) {
+          req.write(currentOptions.body);
+        }
+        req.end();
+      } catch (err) {
+        reject(err);
+      }
+    });
+
     if (!REDIRECT_STATUSES.has(response.status)) return response;
 
     const location = response.headers.get('location');
     if (!location) return response;
     if (redirects === maxRedirects) throw new Error('Too many redirects');
 
-    const nextUrl = new URL(location, sanitized.url).href;
+    const nextUrl = new URL(location, parsedUrl).href;
     const nextOrigin = new URL(nextUrl).origin;
-    const headers = new Headers(currentOptions.headers || {});
-    if (nextOrigin !== sanitized.url.origin) {
-      headers.delete('authorization');
-      headers.delete('cookie');
-      headers.delete('proxy-authorization');
+    delete headers.host;
+    delete headers.Host;
+    if (nextOrigin !== parsedUrl.origin) {
+      delete headers.authorization;
+      delete headers.cookie;
+      delete headers['proxy-authorization'];
     }
-    const method = String(currentOptions.method || 'GET').toUpperCase();
     if (response.status === 303 || ((response.status === 301 || response.status === 302) && method === 'POST')) {
-      headers.delete('content-type');
+      delete headers['content-type'];
       currentOptions = { ...currentOptions, method: 'GET', body: undefined, headers };
     } else {
       currentOptions = { ...currentOptions, headers };
@@ -81,32 +287,106 @@ export async function safeFetch(inputUrl, options = {}, maxRedirects = 5) {
   throw new Error('Too many redirects');
 }
 
-async function readResponseTextLimited(response, maxBytes) {
-  const limit = Math.max(1024, Math.min(Number(maxBytes) || 1024, 2_000_000));
-  const declared = Number(response.headers.get('content-length') || 0);
-  if (declared > limit) throw new Error(`Response exceeds ${limit} byte limit`);
-  if (!response.body?.getReader) {
-    const text = await response.text();
-    if (Buffer.byteLength(text, 'utf8') > limit) throw new Error(`Response exceeds ${limit} byte limit`);
-    return text;
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let bytes = 0;
-  let text = '';
+export async function checkUrlLiveness(inputUrl, { timeoutMs = 2500 } = {}) {
+  if (!inputUrl || typeof inputUrl !== 'string' || !/^https?:\/\//i.test(inputUrl)) {
+    return { alive: false, reason: 'invalid_url' };
+  }
+
+  if (inputUrl.includes('youtube.com/results') || inputUrl.includes('google.com/search') || inputUrl.includes('wikipedia.org') || inputUrl.includes('example.com') || inputUrl.includes('example.org') || inputUrl.includes('example.net')) {
+    return { alive: true };
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
   try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      bytes += value.byteLength;
-      if (bytes > limit) throw new Error(`Response exceeds ${limit} byte limit`);
-      text += decoder.decode(value, { stream: true });
-    }
-    text += decoder.decode();
-    return text;
-  } finally {
-    if (bytes > limit) await reader.cancel().catch(() => {});
+    let res = await safeFetch(inputUrl, {
+      method: 'HEAD',
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
+      },
+      signal: controller.signal
+    });
+
+    if (res.status === 405 || res.status === 404 || res.status === 403 || res.status === 501) {
+      try {
+        const getRes = await safeFetch(inputUrl, {
+          method: 'GET',
+          headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+            'Range': 'bytes=0-512'
+          },
+          signal: controller.signal
+        });
+        if (getRes.status >= 200 && getRes.status < 400) {
+          res = getRes;
+        }
+      } catch {
+      
+      }
+    }
+
+    clearTimeout(timer);
+
+    if (res.status === 404 || res.status === 410) {
+      return { alive: false, status: res.status, reason: 'not_found' };
+    }
+
+    return { alive: true, status: res.status };
+  } catch (err) {
+    clearTimeout(timer);
+    const msg = String(err?.message || '');
+    if (
+      err?.code === 'ENOTFOUND' ||
+      err?.code === 'ECONNREFUSED' ||
+      msg.includes('getaddrinfo') ||
+      msg.includes('Unable to resolve hostname') ||
+      msg.includes('ENOTFOUND')
+    ) {
+      return { alive: false, reason: err?.code || 'dns_failed' };
+    }
+    return { alive: true, unverified: true, reason: msg };
+  }
+}
+
+async function readResponseBytesLimited(response, maxBytes) {
+  const limit = Math.max(1024, Math.min(Number(maxBytes) || 1024, 5_000_000));
+  let bytes;
+  if (response.body?.getReader) {
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+        total += value.byteLength;
+        if (total >= limit) break;
+      }
+    } finally {
+      try { reader.releaseLock(); } catch {}
+    }
+    bytes = Buffer.concat(chunks);
+    if (bytes.length > limit) bytes = bytes.subarray(0, limit);
+  } else if (typeof response.buffer === 'function') {
+    bytes = await response.buffer();
+    if (bytes.length > limit) bytes = bytes.subarray(0, limit);
+  } else if (typeof response.arrayBuffer === 'function') {
+    bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > limit) bytes = bytes.subarray(0, limit);
+  } else {
+    bytes = Buffer.from(await response.text(), 'utf8');
+    if (bytes.length > limit) bytes = bytes.subarray(0, limit);
   }
+  return bytes;
+}
+
+async function readResponseTextLimited(response, maxBytes) {
+  const bytes = await readResponseBytesLimited(response, maxBytes);
+  const contentType = response.headers?.get?.('content-type') || '';
+  return decodeHtmlBytes(bytes, contentType).text;
 }
 
 function detectLanguage(query) {
@@ -143,6 +423,7 @@ function expandQuery(query, lang) {
 
 async function searchDuckDuckGo(query, maxResults) {
   const results = [];
+  const seenLinks = new Set();
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 8000);
@@ -161,28 +442,60 @@ async function searchDuckDuckGo(query, maxResults) {
 
     if (res.ok) {
       const html = await res.text();
-      
-      const resultRegex = /<div[^>]*class="[^"]*result[^"]*"[^>]*>[\s\S]*?<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
-      let match;
-      while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
-        let rawLink = match[1];
-        if (rawLink.includes('uddg=')) {
-          try {
-            const decoded = new URL('https://duckduckgo.com' + rawLink).searchParams.get('uddg');
-            if (decoded) rawLink = decoded;
-          } catch {}
-        }
+      const cheerioLoad = await loadCheerio();
+
+      if (cheerioLoad) {
+        const $ = cheerioLoad(html);
+        $('div.result, div.web-result').each((_, el) => {
+          if (results.length >= maxResults) return;
+          const $el = $(el);
+          const anchor = $el.find('a.result__a').first();
+          let rawLink = anchor.attr('href') || '';
+          if (rawLink.includes('uddg=')) {
+            try {
+              const decoded = new URL('https://duckduckgo.com' + rawLink).searchParams.get('uddg');
+              if (decoded) rawLink = decoded;
+            } catch {}
+          }
+          const title = normalizeText(decodeEntities(anchor.text()));
+          const snippet = normalizeText(decodeEntities($el.find('.result__snippet').first().text()));
+
+          if (rawLink && title && !seenLinks.has(rawLink)) {
+            seenLinks.add(rawLink);
+            results.push({
+              title,
+              url: rawLink,
+              snippet,
+              source: 'DuckDuckGo'
+            });
+          }
+        });
+      }
 
-        const title = cleanHtml(match[2]);
-        const snippet = cleanHtml(match[3]);
+      if (results.length === 0) {
+        const resultRegex = /<div[^>]*class="[^"]*result[^"]*"[^>]*>[\s\S]*?<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
+        let match;
+        while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+          let rawLink = match[1];
+          if (rawLink.includes('uddg=')) {
+            try {
+              const decoded = new URL('https://duckduckgo.com' + rawLink).searchParams.get('uddg');
+              if (decoded) rawLink = decoded;
+            } catch {}
+          }
 
-        if (title && snippet && !results.some(r => r.url === rawLink)) {
-          results.push({
-            title,
-            url: rawLink,
-            snippet,
-            source: 'DuckDuckGo'
-          });
+          const title = cleanHtml(match[2]);
+          const snippet = cleanHtml(match[3]);
+
+          if (title && snippet && !seenLinks.has(rawLink)) {
+            seenLinks.add(rawLink);
+            results.push({
+              title,
+              url: rawLink,
+              snippet,
+              source: 'DuckDuckGo'
+            });
+          }
         }
       }
     }
@@ -226,18 +539,21 @@ async function searchWikipedia(query, maxResults, lang) {
   return results;
 }
 
-async function searchBing(query, maxResults) {
+async function searchBing(query, maxResults, { language } = {}) {
   const results = [];
+  const seenLinks = new Set();
   try {
+    const lang = language || detectLanguage(query);
+    const setlang = lang === 'th' ? 'th' : lang === 'zh' ? 'zh-cn' : 'en-us';
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 8000);
 
-    const searchUrl = `https://www.bing.com/search?q=${encodeURIComponent(query)}&setlang=${detectLanguage(query) === 'th' ? 'th' : detectLanguage(query) === 'zh' ? 'zh-cn' : 'en-us'}`;
+    const searchUrl = `https://www.bing.com/search?q=${encodeURIComponent(query)}&setlang=${setlang}`;
     const res = await fetch(searchUrl, {
       headers: {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
         'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-        'Accept-Language': 'th,en-US;q=0.9,en;q=0.8,zh-CN;q=0.7,zh;q=0.6'
+        'Accept-Language': 'zh-CN,zh;q=0.9,th;q=0.8,en;q=0.7'
       },
       signal: controller.signal
     });
@@ -245,101 +561,278 @@ async function searchBing(query, maxResults) {
     clearTimeout(timeoutId);
 
     if (res.ok) {
-      const html = await res.text();
-      
-      const linkRegex = /<h2><a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<p[^>]*class="b_lineclamp2 b_algoSlug"[^>]*>([\s\S]*?)<\/p>/gi;
-      let match;
-      while ((match = linkRegex.exec(html)) !== null && results.length < maxResults) {
-        const rawLink = match[1];
-        const title = cleanHtml(match[2]);
-        const snippet = cleanHtml(match[3]);
-
-        if (title && snippet && !results.some(r => r.url === rawLink)) {
-          results.push({
-            title,
-            url: rawLink,
-            snippet,
-            source: 'Bing'
-          });
+      const html = await readResponseTextLimited(res, 2_000_000);
+      const algoRegex = /<li[^>]*class="[^"]*b_algo[^"]*"[^>]*>([\s\S]*?)<\/li>/gi;
+      let blockMatch;
+      while ((blockMatch = algoRegex.exec(html)) !== null && results.length < maxResults) {
+        const block = blockMatch[1];
+        const aMatch = block.match(/<h2[^>]*>\s*<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>\s*<\/h2>/i);
+        if (!aMatch) continue;
+        const link = aMatch[1];
+        const title = cleanHtml(aMatch[2]);
+        if (!link || !title || seenLinks.has(link)) continue;
+
+        let snippet = '';
+        const pMatch = block.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+        if (pMatch) {
+          snippet = cleanHtml(pMatch[1]).slice(0, 320);
+        } else {
+          const capMatch = block.match(/<div[^>]*class="[^"]*b_caption[^"]*"[^>]*>([\s\S]*?)<\/div>/i);
+          if (capMatch) snippet = cleanHtml(capMatch[1]).slice(0, 320);
+        }
+        seenLinks.add(link);
+        results.push({ title, url: link, snippet, source: 'Bing' });
+      }
+
+      if (results.length === 0) {
+        const linkRegex = /<h2><a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<p[^>]*class="b_lineclamp2 b_algoSlug"[^>]*>([\s\S]*?)<\/p>/gi;
+        let match;
+        while ((match = linkRegex.exec(html)) !== null && results.length < maxResults) {
+          const rawLink = match[1];
+          const title = cleanHtml(match[2]);
+          const snippet = cleanHtml(match[3]);
+          if (title && snippet && !seenLinks.has(rawLink)) {
+            seenLinks.add(rawLink);
+            results.push({ title, url: rawLink, snippet, source: 'Bing' });
+          }
         }
       }
     }
-  } catch (err) {
-  }
-  
+  } catch {}
+
   return results;
 }
 
-export async function searchWeb(query, maxResults = 8) {
+export async function searchWeb(query, maxResults = 8, options = {}) {
   if (!query || typeof query !== 'string') {
     return { status: 'error', message: 'Query string is required for web search.' };
   }
 
   const lang = detectLanguage(query);
-  const results = [];
-  const sources = [];
+  const capped = Math.min(Math.max(maxResults, 1), 25);
+  const cacheKey = computeSearchCacheKey('searchWeb', query, capped);
+
+  if (!options.noCache) {
+    const cached = defaultMetaSearch.cache.get(cacheKey);
+    if (cached) {
+      return { ...cached, fromCache: true };
+    }
+  }
 
   try {
-    const ddgResults = await searchDuckDuckGo(query, maxResults);
-    ddgResults.forEach(r => {
-      if (!results.some(existing => existing.url === r.url)) {
-        results.push(r);
-        sources.push('DuckDuckGo');
+    const [metaResSettled, imgResSettled] = await Promise.allSettled([
+      defaultMetaSearch.executeSearch(query, {
+        limit: capped,
+        language: lang,
+        ...options
+      }),
+      searchWebImages(query, 6).catch(() => null)
+    ]);
+
+    const metaRes = metaResSettled.status === 'fulfilled' ? metaResSettled.value : null;
+    const imgRes = imgResSettled.status === 'fulfilled' ? imgResSettled.value : null;
+    const images = Array.isArray(imgRes?.results) ? imgRes.results.slice(0, 6) : [];
+
+    if (metaRes && metaRes.results && metaRes.results.length > 0) {
+      const sources = [...new Set(metaRes.results.map(r => r.engine || metaRes.engine || 'web'))];
+      const resultObj = {
+        status: 'success',
+        query,
+        language: lang,
+        count: metaRes.results.length,
+        sources,
+        results: metaRes.results.map(r => ({
+          title: r.title,
+          url: r.link,
+          snippet: r.snippet,
+          source: r.engine || 'web'
+        })),
+        ...(images.length > 0 ? { images } : {}),
+        ...(metaRes.mode === 'deep_scrape' ? {
+          scrapedPages: metaRes.scrapedPages,
+          combinedContent: metaRes.combinedContent
+        } : {})
+      };
+      if (!options.noCache) {
+        defaultMetaSearch.cache.set(cacheKey, resultObj, TTL_GENERAL_MS);
       }
-    });
+      return resultObj;
+    }
+  } catch {}
+
+  try {
+    const wikiItems = await searchWikipedia(query, Math.min(capped, 3), lang);
+    if (wikiItems.length > 0) {
+      const wikiResponse = {
+        status: 'success',
+        query,
+        language: lang,
+        count: wikiItems.length,
+        sources: ['Wikipedia'],
+        results: wikiItems
+      };
+      if (!options.noCache) {
+        defaultMetaSearch.cache.set(cacheKey, wikiResponse, TTL_GENERAL_MS);
+      }
+      return wikiResponse;
+    }
   } catch {}
 
-  if (results.length < maxResults) {
+  return {
+    status: 'no_results',
+    query,
+    language: lang,
+    count: 0,
+    sources: [],
+    results: []
+  };
+}
+
+const PAGE_CACHE_TTL_MS = 10 * 60 * 1000;
+const pageContentCache = new BoundedLruCache(40);
+
+function buildPageResult(pageData, { finalUrl, maxLength, query, cached }) {
+  const markdown = pageData.markdown || '';
+  let content = markdown;
+  let contentMode = 'full';
+  const totalChars = markdown.length;
+
+  if (query) {
+    const passages = splitIntoPassages(markdown);
+    if (passages.length > 1 && totalChars > maxLength) {
+      const selection = selectPassages(passages, query, { budgetChars: maxLength });
+      if (selection.text && selection.selected < selection.total) {
+        content = `[Excerpt: ${selection.selected}/${selection.total} most relevant sections]\n\n${selection.text}`;
+        contentMode = 'query-passages';
+      }
+    }
+  }
+  if (contentMode === 'full' && totalChars > maxLength) {
+    content = truncateByWords(markdown, maxLength) + '\n\n... [Content truncated for brevity]';
+    contentMode = 'truncated';
+  }
+
+  const result = {
+    status: 'success',
+    url: finalUrl,
+    contentType: 'html',
+    contentLength: content.length,
+    totalPageChars: totalChars,
+    content: content || 'Unable to retrieve text content from this webpage.',
+    meta: pageData.meta || {},
+    extraction: {
+      engine: pageData.engine || 'cheerio-readability',
+      mode: contentMode,
+      cached: Boolean(cached),
+      charset: pageData.charset || 'utf-8',
+      quality: pageData.quality || null
+    }
+  };
+
+  if (pageData.headings?.length > 0) result.headings = pageData.headings;
+  if (pageData.paragraphs?.length > 0) result.paragraphs = pageData.paragraphs;
+  if (pageData.links?.length > 0) result.links = pageData.links;
+  if (pageData.images?.length > 0) result.images = pageData.images;
+  if (pageData.jsonLd) result.jsonLd = pageData.jsonLd;
+
+  return result;
+}
+
+async function rescueThinPage({ url, markdown, jsonLd }) {
+  const candidates = [];
+  if (jsonLd?.body && jsonLd.body.length > markdown.length && jsonLd.body.length > 400) {
+    candidates.push({ engine: 'jsonld-articlebody', markdown: jsonLd.body });
+  }
+  if (markdown.length < 400) {
     try {
-      const wikiResults = await searchWikipedia(query, maxResults - results.length, lang);
-      wikiResults.forEach(r => {
-        if (!results.some(existing => existing.url === r.url)) {
-          results.push(r);
-          sources.push('Wikipedia');
-        }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 12000);
+      const res = await safeFetch(`https://r.jina.ai/${url}`, {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+          'Accept': 'text/plain',
+          'X-No-Cache': 'false'
+        },
+        signal: controller.signal
       });
+      clearTimeout(timeoutId);
+      if (res.ok) {
+        const text = (await readResponseTextLimited(res, 300_000)).trim();
+        if (text.length > 400) candidates.push({ engine: 'jina-reader', markdown: text });
+      }
     } catch {}
-  }
-
-  if (results.length < maxResults / 2) {
     try {
-      const expandedQueries = expandQuery(query, lang);
-      for (const expandedQuery of expandedQueries) {
-        if (results.length >= maxResults) break;
-        const ddgResults = await searchDuckDuckGo(expandedQuery, Math.ceil(maxResults / 2));
-        ddgResults.forEach(r => {
-          if (!results.some(existing => existing.url === r.url)) {
-            results.push(r);
-            sources.push('DuckDuckGo (expanded)');
-          }
-        });
+      const renderedDom = await chromeDumpDom(url);
+      if (renderedDom) {
+        const rendered = await extractMainContent(renderedDom, { url });
+        if (rendered.markdown && rendered.markdown.length > 400 && !rendered.quality?.isThin) {
+          candidates.push({ engine: 'chrome-render', markdown: rendered.markdown });
+        }
       }
     } catch {}
   }
+  candidates.sort((a, b) => b.markdown.length - a.markdown.length);
+  return candidates[0] || null;
+}
+
+async function chromeDumpDom(url, timeoutMs = 20000) {
+  if (process.env.KIKU_DISABLE_CHROME_EXTRACT === 'true') return null;
+  const chromePath = findChromePath();
+  if (!chromePath) return null;
+
+  let releaseLock = null;
+  let tmpDir = null;
+  try {
+    releaseLock = await acquireChromeLock(timeoutMs);
+  } catch {
+    return null;
+  }
 
-  if (results.length < maxResults) {
+  try {
+    let targetUrl = url;
     try {
-      const bingResults = await searchBing(query, maxResults - results.length);
-      bingResults.forEach(r => {
-        if (!results.some(existing => existing.url === r.url)) {
-          results.push(r);
-          sources.push('Bing');
-        }
-      });
+      const preflight = await safeFetch(url, { method: 'HEAD', timeout: 5000 });
+      if (preflight?.url) targetUrl = preflight.url;
     } catch {}
-  }
 
-  return {
-    status: results.length > 0 ? 'success' : 'no_results',
-    query,
-    language: lang,
-    count: results.length,
-    sources: [...new Set(sources)],
-    results: results.slice(0, maxResults)
-  };
+    const targetHostname = new URL(targetUrl).hostname;
+    tmpDir = await mkdtemp(join(tmpdir(), 'kiku-dom-'));
+    const args = [
+      '--headless=new',
+      '--disable-gpu',
+      '--disable-dev-shm-usage',
+      '--disable-software-rasterizer',
+      '--disable-background-networking',
+      '--disable-sync',
+      '--no-first-run',
+      '--no-default-browser-check',
+      `--host-resolver-rules=MAP * ~NOTFOUND , EXCLUDE ${targetHostname}`,
+      `--user-data-dir=${join(tmpDir, 'chrome-profile')}`,
+      '--virtual-time-budget=8000',
+      '--dump-dom',
+      targetUrl
+    ];
+
+    const stdout = await new Promise((resolve, reject) => {
+      const child = execFile(chromePath, args, { timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024 }, (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout || '');
+      });
+      child.on('error', reject);
+    });
+
+    return stdout.length > 500 ? stdout : null;
+  } catch {
+    return null;
+  } finally {
+    if (tmpDir) {
+      try { await rm(tmpDir, { recursive: true, force: true }); } catch {}
+    }
+    if (releaseLock) releaseLock();
+  }
 }
 
-export async function fetchWebpage(url, maxLength = 8000) {
+export async function fetchWebpage(url, maxLength = 8000, options = {}) {
   if (!url || typeof url !== 'string' || !url.startsWith('http')) {
     return { status: 'error', message: 'Valid HTTP/HTTPS URL is required.' };
   }
@@ -355,22 +848,40 @@ export async function fetchWebpage(url, maxLength = 8000) {
     return { status: 'error', message: `URL rejected by SSRF guard: ${ssrf.reason}` };
   }
 
+  const query = typeof options.query === 'string' ? options.query : '';
+  const cacheKey = `${parsedUrl.origin}${parsedUrl.pathname}${parsedUrl.search}`;
+  const cached = pageContentCache.get(cacheKey);
+
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 15000);
 
+    const headers = {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Language': 'en-US,en;q=0.9,th;q=0.8,zh-CN;q=0.7'
+    };
+    if (cached) {
+      if (cached.etag) headers['If-None-Match'] = cached.etag;
+      if (cached.lastModified) headers['If-Modified-Since'] = cached.lastModified;
+    }
+
     const res = await safeFetch(url, {
-      headers: {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
-        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-        'Accept-Language': 'en-US,en;q=0.9,th;q=0.8,zh-CN;q=0.7'
-      },
+      headers,
       signal: controller.signal
     });
 
     clearTimeout(timeoutId);
 
+    if (cached && res.status === 304) {
+      pageContentCache.set(cacheKey, { ...cached, cachedAt: Date.now() }, PAGE_CACHE_TTL_MS);
+      return buildPageResult(cached, { finalUrl: cached.finalUrl || url, maxLength, query, cached: true });
+    }
+
     if (!res.ok) {
+      if (cached) {
+        return buildPageResult(cached, { finalUrl: cached.finalUrl || url, maxLength, query, cached: true });
+      }
       return { status: 'error', message: `HTTP ${res.status}: Failed to load webpage` };
     }
 
@@ -390,111 +901,50 @@ export async function fetchWebpage(url, maxLength = 8000) {
       };
     }
 
-    const html = await readResponseTextLimited(res, Math.max(256_000, maxLength * 16));
-    const cheerioLoad = await loadCheerio();
-
-    if (cheerioLoad) {
-      const $ = cheerioLoad(html);
-
-      $('script, style, noscript, iframe, svg, nav, footer, aside, form, button').remove();
-
-      const meta = {};
-      meta.title = $('title').first().text().trim() || '';
-      meta.description = $('meta[name="description"]').attr('content') || $('meta[property="og:description"]').attr('content') || '';
-      meta.author = $('meta[name="author"]').attr('content') || '';
-      meta.keywords = $('meta[name="keywords"]').attr('content') || '';
-      meta.ogTitle = $('meta[property="og:title"]').attr('content') || '';
-      meta.ogImage = $('meta[property="og:image"]').attr('content') || '';
-      meta.ogType = $('meta[property="og:type"]').attr('content') || '';
-      meta.canonical = $('link[rel="canonical"]').attr('href') || '';
-      meta.favicon = $('link[rel="icon"], link[rel="shortcut icon"]').attr('href') || '';
-      meta.lang = $('html').attr('lang') || '';
-
-      const headings = [];
-      $('h1, h2, h3').each((i, el) => {
-        if (i < 10) {
-          const txt = $(el).text().trim();
-          if (txt) headings.push({ level: el.tagName, text: txt });
-        }
-      });
-
-      const paragraphs = [];
-      $('article p, main p, .content p, .post-content p, .entry-content p, .article-body p, .wiki-content p').each((i, el) => {
-        if (i < 20) {
-          const txt = $(el).text().trim();
-          if (txt && txt.length > 20) paragraphs.push(txt);
-        }
-      });
-      if (paragraphs.length === 0) {
-        $('p').each((i, el) => {
-          if (i < 15) {
-            const txt = $(el).text().trim();
-            if (txt && txt.length > 30) paragraphs.push(txt);
-          }
-        });
-      }
-
-      const links = [];
-      $('article a, main a, .content a').each((i, el) => {
-        if (i < 15) {
-          const href = $(el).attr('href');
-          const text = $(el).text().trim();
-          if (href && text && text.length > 2) {
-            let absoluteUrl = href;
-            try { absoluteUrl = new URL(href, finalUrl).href; } catch {}
-            links.push({ text: text.slice(0, 80), url: absoluteUrl });
-          }
-        }
-      });
-
-      const images = [];
-      $('article img, main img, .content img').each((i, el) => {
-        if (i < 8) {
-          const src = $(el).attr('src');
-          const alt = $(el).attr('alt') || '';
-          if (src) {
-            let absoluteUrl = src;
-            try { absoluteUrl = new URL(src, finalUrl).href; } catch {}
-            images.push({ src: absoluteUrl, alt: alt.slice(0, 100) });
-          }
-        }
-      });
-
-      let bodyText = $('body').text().replace(/\s+/g, ' ').trim();
-      if (bodyText.length > maxLength) {
-        bodyText = bodyText.slice(0, maxLength) + '... [Content truncated for brevity]';
-      }
-
-      const result = {
-        status: 'success',
-        url: finalUrl,
-        contentType: 'html',
-        contentLength: bodyText.length,
-        content: bodyText || 'Unable to retrieve text content.',
-        meta: Object.fromEntries(Object.entries(meta).filter(([, v]) => v))
-      };
-
-      if (headings.length > 0) result.headings = headings;
-      if (paragraphs.length > 0) result.paragraphs = paragraphs;
-      if (links.length > 0) result.links = links;
-      if (images.length > 0) result.images = images;
-
-      return result;
+    if (/^(image|audio|video)\//.test(contentType) || contentType.includes('application/pdf')) {
+      return { status: 'error', url: finalUrl, message: `Unsupported content type: ${contentType}` };
     }
 
-    let text = cleanHtml(html);
-    if (text.length > maxLength) {
-      text = text.slice(0, maxLength) + '... [Content truncated for brevity]';
+    const htmlBytes = await readResponseBytesLimited(res, Math.max(256_000, maxLength * 16));
+    const decoded = decodeHtmlBytes(htmlBytes, contentType);
+    const extraction = await extractMainContent(decoded.text, { url: finalUrl });
+
+    let engine = 'cheerio-readability';
+    let markdown = extraction.markdown;
+    if (extraction.quality?.isThin) {
+      const rescue = await rescueThinPage({ url: finalUrl, markdown, jsonLd: extraction.jsonLd });
+      if (rescue && rescue.markdown.length > markdown.length * 1.3) {
+        markdown = rescue.markdown;
+        engine = rescue.engine;
+      }
     }
 
-    return {
-      status: 'success',
-      url: finalUrl,
-      contentType: 'html',
-      contentLength: text.length,
-      content: text || 'Unable to retrieve text content from this webpage.'
+    const pageData = {
+      markdown,
+      meta: extraction.meta,
+      headings: extraction.headings,
+      paragraphs: extraction.paragraphs,
+      links: extraction.links,
+      images: extraction.images,
+      jsonLd: extraction.jsonLd,
+      quality: extraction.quality,
+      engine,
+      charset: decoded.charset,
+      finalUrl
     };
+
+    pageContentCache.set(cacheKey, {
+      ...pageData,
+      etag: res.headers.get('etag') || '',
+      lastModified: res.headers.get('last-modified') || '',
+      cachedAt: Date.now()
+    }, PAGE_CACHE_TTL_MS);
+
+    return buildPageResult(pageData, { finalUrl, maxLength, query, cached: false });
   } catch (err) {
+    if (cached) {
+      return buildPageResult(cached, { finalUrl: cached.finalUrl || url, maxLength, query, cached: true });
+    }
     return {
       status: 'error',
       url,
@@ -650,17 +1100,38 @@ export async function screenshotWebpage(url, options = {}) {
     return { status: 'error', message: 'Google Chrome not found. Install Chrome to enable screenshot feature.' };
   }
 
-  const tmpDir = await mkdtemp(join(tmpdir(), 'kiku-screenshot-'));
-  const profileDir = join(tmpDir, 'chrome-profile');
+  let releaseLock = null;
+  try {
+    releaseLock = await acquireChromeLock(timeoutMs);
+  } catch (lockErr) {
+    return { status: 'error', message: lockErr.message };
+  }
 
+  let tmpDir = null;
   try {
+ 
+    let targetUrl = url;
+    try {
+      const preflight = await safeFetch(url, { method: 'HEAD', timeout: 5000 });
+      if (preflight?.url) targetUrl = preflight.url;
+    } catch {}
+
+    const targetHostname = new URL(targetUrl).hostname;
+    tmpDir = await mkdtemp(join(tmpdir(), 'kiku-screenshot-'));
+    const profileDir = join(tmpDir, 'chrome-profile');
     const screenshotFile = 'kiku_screenshot.png';
     const screenshotPath = join(tmpDir, screenshotFile);
+
     const args = [
       '--headless=new',
       '--disable-gpu',
       '--disable-dev-shm-usage',
       '--disable-software-rasterizer',
+      '--disable-background-networking',
+      '--disable-sync',
+      '--no-first-run',
+      '--no-default-browser-check',
+      `--host-resolver-rules=MAP * ~NOTFOUND , EXCLUDE ${targetHostname}`,
       `--user-data-dir=${profileDir}`,
       `--window-size=${width},${height}`,
       `--screenshot=${screenshotPath}`,
@@ -668,7 +1139,7 @@ export async function screenshotWebpage(url, options = {}) {
       '--virtual-time-budget=8000'
     ];
 
-    args.push(url);
+    args.push(targetUrl);
 
     await new Promise((resolve, reject) => {
       const child = execFile(chromePath, args, {
@@ -690,7 +1161,7 @@ export async function screenshotWebpage(url, options = {}) {
 
     return {
       status: 'success',
-      url,
+      url: targetUrl,
       width,
       height,
       format: 'png',
@@ -705,12 +1176,1538 @@ export async function screenshotWebpage(url, options = {}) {
       message: `Screenshot failed: ${err.message}`
     };
   } finally {
-    try { await rm(tmpDir, { recursive: true, force: true }); } catch {}
+    if (tmpDir) {
+      try { await rm(tmpDir, { recursive: true, force: true }); } catch {}
+    }
+    if (releaseLock) {
+      releaseLock();
+    }
   }
 }
 
-export async function webExtract(query, opts = {}) {
-  if (!query || typeof query !== 'string') {
+export { detectLanguage };
+
+async function fetchWithTimeout(url, options = {}, timeoutMs = 10000) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await safeFetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+function stripCdata(value) {
+  return String(value || '')
+    .replace(/^\s*<!\[CDATA\[/, '')
+    .replace(/\]\]>\s*$/, '')
+    .trim();
+}
+
+export function parseRssFeed(xml) {
+  const text = String(xml || '');
+  const items = [];
+  const blocks = text.match(/<(?:item|entry)[\s\S]*?<\/(?:item|entry)>/gi) || [];
+
+  for (const block of blocks) {
+    const pick = (tags) => {
+      for (const tag of tags) {
+        const m = block.match(new RegExp(`<${tag}(?:\\s[^>]*)?>([\\s\\S]*?)</${tag}>`, 'i'));
+        if (m) return stripCdata(m[1]);
+      }
+      return '';
+    };
+
+    let link = '';
+    const hrefMatch = block.match(/<link[^>]*\shref="([^"]+)"/i);
+    if (hrefMatch) {
+      link = stripCdata(hrefMatch[1]);
+    } else {
+      link = pick(['link']);
+    }
+
+    const title = cleanHtml(pick(['title']));
+    const snippet = cleanHtml(pick(['description', 'summary', 'content'])).slice(0, 400);
+    const publishedAt = pick(['pubDate', 'published', 'updated', 'dc:date']);
+    const sourceName = cleanHtml(pick(['source'])).slice(0, 80);
+
+    if (title && link) {
+      items.push({ title, url: link, snippet, publishedAt, source: sourceName || '' });
+    }
+  }
+
+  return items;
+}
+
+const NEWS_EDITIONS = {
+  zh: { hl: 'zh-CN', gl: 'CN', ceid: 'CN:zh-Hans', mkt: 'zh-CN' },
+  th: { hl: 'th', gl: 'TH', ceid: 'TH:th', mkt: 'th-TH' },
+  en: { hl: 'en-US', gl: 'US', ceid: 'US:en', mkt: 'en-US' }
+};
+
+const BROWSER_HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+  'Accept': 'text/html,application/xhtml+xml,application/xml,application/rss+xml;q=0.9,*/*;q=0.8',
+  'Accept-Language': 'th,en-US;q=0.9,en;q=0.8,zh-CN;q=0.7,zh;q=0.6'
+};
+
+async function fetchGoogleNewsRss(query, maxResults, lang) {
+  const edition = NEWS_EDITIONS[lang] || NEWS_EDITIONS.en;
+  const url = `https://news.google.com/rss/search?q=${encodeURIComponent(query)}&hl=${edition.hl}&gl=${edition.gl}&ceid=${encodeURIComponent(edition.ceid)}`;
+  const res = await fetchWithTimeout(url, { headers: BROWSER_HEADERS }, 9000);
+  if (!res.ok) throw new Error(`Google News RSS HTTP ${res.status}`);
+  const xml = await readResponseTextLimited(res, 512_000);
+  return parseRssFeed(xml)
+    .slice(0, maxResults)
+    .map(item => ({
+      title: item.title,
+      url: item.url,
+      snippet: item.snippet,
+      publishedAt: item.publishedAt,
+      source: item.source || 'Google News'
+    }));
+}
+
+async function fetchBingNewsRss(query, maxResults, lang) {
+  const edition = NEWS_EDITIONS[lang] || NEWS_EDITIONS.en;
+  const url = `https://www.bing.com/news/search?q=${encodeURIComponent(query)}&format=RSS&setmkt=${edition.mkt}`;
+  const res = await fetchWithTimeout(url, { headers: BROWSER_HEADERS }, 9000);
+  if (!res.ok) throw new Error(`Bing News RSS HTTP ${res.status}`);
+  const xml = await readResponseTextLimited(res, 512_000);
+  return parseRssFeed(xml)
+    .slice(0, maxResults)
+    .map(item => ({
+      title: item.title,
+      url: item.url,
+      snippet: item.snippet,
+      publishedAt: item.publishedAt,
+      source: item.source || 'Bing News'
+    }));
+}
+
+async function fetchYahooNewsRss(query, maxResults) {
+  try {
+    const url = `https://news.yahoo.com/rss?p=${encodeURIComponent(query)}`;
+    const res = await fetchWithTimeout(url, { headers: BROWSER_HEADERS }, 8000);
+    if (!res.ok) return [];
+    const xml = await readResponseTextLimited(res, 512_000);
+    return parseRssFeed(xml).slice(0, maxResults).map(item => ({
+      title: item.title,
+      url: item.url,
+      snippet: item.snippet,
+      publishedAt: item.publishedAt,
+      source: item.source || 'Yahoo News'
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export async function searchNews(query, maxResults = 8) {
+  if (!query || typeof query !== 'string') {
+    return { status: 'error', message: 'Query string is required for news search.' };
+  }
+
+  const capped = Math.min(Math.max(maxResults, 1), 20);
+  const lang = detectLanguage(query);
+  const results = [];
+  const sources = [];
+  const attempts = [];
+  const seenUrls = new Set();
+
+  const add = (item, defaultSource) => {
+    if (!item?.url || seenUrls.has(item.url)) return;
+    seenUrls.add(item.url);
+    const src = item.source || defaultSource;
+    results.push({ ...item, source: src });
+    if (!sources.includes(src)) sources.push(src);
+  };
+
+  const [gSettled, bSettled, ySettled, ddgSettled, imgSettled] = await Promise.allSettled([
+    fetchGoogleNewsRss(query, capped, lang),
+    fetchBingNewsRss(query, capped, lang),
+    fetchYahooNewsRss(query, Math.ceil(capped / 2)),
+    searchDuckDuckGo(`${query} news`, Math.min(capped, 4)),
+    searchWebImages(`${query} news`, 6).catch(() => null)
+  ]);
+
+  if (gSettled.status === 'fulfilled' && Array.isArray(gSettled.value)) {
+    attempts.push({ source: 'Google News', status: gSettled.value.length ? 'success' : 'no_results', count: gSettled.value.length });
+  } else {
+    attempts.push({ source: 'Google News', status: 'error', message: gSettled.reason?.message });
+  }
+
+  if (bSettled.status === 'fulfilled' && Array.isArray(bSettled.value)) {
+    attempts.push({ source: 'Bing News', status: bSettled.value.length ? 'success' : 'no_results', count: bSettled.value.length });
+  } else {
+    attempts.push({ source: 'Bing News', status: 'error', message: bSettled.reason?.message });
+  }
+
+  const gList = (gSettled.status === 'fulfilled' && Array.isArray(gSettled.value)) ? gSettled.value : [];
+  const bList = (bSettled.status === 'fulfilled' && Array.isArray(bSettled.value)) ? bSettled.value : [];
+  const yList = (ySettled.status === 'fulfilled' && Array.isArray(ySettled.value)) ? ySettled.value : [];
+  const ddgList = (ddgSettled.status === 'fulfilled' && Array.isArray(ddgSettled.value)) ? ddgSettled.value : [];
+  const imgRes = imgSettled.status === 'fulfilled' ? imgSettled.value : null;
+  const newsImages = Array.isArray(imgRes?.results) ? imgRes.results.slice(0, 6) : [];
+
+  let i = 0;
+  while (results.length < capped && (i < gList.length || i < bList.length || i < yList.length || i < ddgList.length)) {
+    if (i < gList.length && results.length < capped) add(gList[i], 'Google News');
+    if (i < bList.length && results.length < capped) add(bList[i], 'Bing News');
+    if (i < yList.length && results.length < capped) add(yList[i], 'Yahoo News');
+    if (i < ddgList.length && results.length < capped) add(ddgList[i], 'Web News');
+    i++;
+  }
+
+  return {
+    status: results.length > 0 ? 'success' : 'no_results',
+    query,
+    language: lang,
+    count: results.length,
+    sources,
+    results,
+    ...(newsImages.length > 0 ? { images: newsImages } : {})
+  };
+}
+
+export async function fetchRssFeed(url, maxItems = 10) {
+  if (!url || typeof url !== 'string' || !/^https?:\/\//i.test(url)) {
+    return { status: 'error', message: 'Valid HTTP/HTTPS feed URL is required.' };
+  }
+
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return { status: 'error', message: 'Invalid URL format.' };
+  }
+  const ssrf = await assertSafeUrlHostname(parsedUrl.hostname);
+  if (!ssrf.safe) {
+    return { status: 'error', message: `URL rejected by SSRF guard: ${ssrf.reason}` };
+  }
+
+  const capped = Math.min(Math.max(maxItems, 1), 30);
+
+  try {
+    const res = await fetchWithTimeout(url, { headers: BROWSER_HEADERS }, 12000);
+    if (!res.ok) {
+      return { status: 'error', url, message: `HTTP ${res.status}: feed could not be loaded.` };
+    }
+    const xml = await readResponseTextLimited(res, 1_000_000);
+    const items = parseRssFeed(xml).slice(0, capped);
+    const feedTitle = cleanHtml(stripCdata((xml.match(/<(?:title)>[\s\S]*?<\/(?:title)>/i) || [''])[0]
+      ?.replace(/<\/?title[^>]*>/gi, '')) || '');
+
+    return {
+      status: items.length > 0 ? 'success' : 'no_results',
+      url: res.url || url,
+      feedTitle,
+      count: items.length,
+      items
+    };
+  } catch (err) {
+    return {
+      status: 'error',
+      url,
+      message: err.name === 'AbortError' ? 'Feed fetch timed out (12s)' : err.message
+    };
+  }
+}
+
+export async function fetchWikipediaSummary(term, lang = 'en') {
+  if (!term || typeof term !== 'string') {
+    return { status: 'error', message: 'Search term is required.' };
+  }
+  const wikiLang = ['zh', 'th', 'en'].includes(lang) ? lang : 'en';
+  const headers = { 'User-Agent': 'KikuAgent/2.0 (JuJingyi Fan Knowledge Bot)' };
+
+  const fetchExtract = async (title) => {
+    const url = `https://${wikiLang}.wikipedia.org/w/api.php?action=query&format=json&utf8=1&redirects=1&prop=extracts|pageimages&exintro=1&explaintext=1&pithumbsize=320${wikiLang === 'zh' ? '&variant=zh-cn' : ''}&titles=${encodeURIComponent(title)}`;
+    const res = await fetchWithTimeout(url, { headers }, 9000);
+    if (!res.ok) throw new Error(`Wikipedia HTTP ${res.status}`);
+    const data = await res.json();
+    const pages = data?.query?.pages || {};
+    return Object.values(pages).find(p => p && p.missing === undefined && p.extract) || null;
+  };
+
+  const searchTitle = async () => {
+    const url = `https://${wikiLang}.wikipedia.org/w/api.php?action=query&format=json&utf8=1&list=search&srlimit=1&srsearch=${encodeURIComponent(term)}`;
+    const res = await fetchWithTimeout(url, { headers }, 9000);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data?.query?.search?.[0]?.title || null;
+  };
+
+  try {
+    let page = await fetchExtract(term);
+    if (!page) {
+      const matchedTitle = await searchTitle();
+      if (matchedTitle) page = await fetchExtract(matchedTitle);
+    }
+    if (!page) {
+      return { status: 'not_found', term, source: `Wikipedia (${wikiLang})`, message: `No Wikipedia (${wikiLang}) article found for "${term}".` };
+    }
+    return {
+      status: 'success',
+      term,
+      source: `Wikipedia (${wikiLang})`,
+      title: page.title,
+      summary: String(page.extract || '').slice(0, 3000),
+      thumbnail: page.thumbnail?.source || null,
+      url: `https://${wikiLang}.wikipedia.org/wiki/${encodeURIComponent(String(page.title).replace(/ /g, '_'))}`
+    };
+  } catch (err) {
+    return {
+      status: 'error',
+      term,
+      source: `Wikipedia (${wikiLang})`,
+      message: err.name === 'AbortError' ? 'Wikipedia request timed out (9s)' : err.message
+    };
+  }
+}
+
+function extractDivBlock(html, classHint) {
+  const openMatch = html.match(new RegExp(`<div[^>]+class="[^"]*${classHint}[^"]*"[^>]*>`, 'i'));
+  if (!openMatch) return '';
+  const tagRegex = /<\/?div\b[^>]*>/gi;
+  tagRegex.lastIndex = openMatch.index + openMatch[0].length;
+  const start = tagRegex.lastIndex;
+  let depth = 1;
+  let tag;
+  while ((tag = tagRegex.exec(html)) !== null) {
+    depth += tag[0].startsWith('</') ? -1 : 1;
+    if (depth === 0) return html.slice(start, tag.index);
+  }
+  return html.slice(start, start + 8000);
+}
+
+export function parseBaikePage(html) {
+  const text = String(html || '');
+  const titleMatch = text.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i)
+    || text.match(/<title>([\s\S]*?)<\/title>/i);
+  const descriptionMatch = text.match(/<meta\s+name="description"\s+content="([^"]*)"/i);
+  const summaryBlock = extractDivBlock(text, 'lemma-summary') || extractDivBlock(text, 'para_j');
+
+  const paragraphs = [];
+  let paraMatch;
+  const paraSource = summaryBlock || text;
+  const pRegex = /<p[^>]*>([\s\S]*?)<\/p>/gi;
+  while ((paraMatch = pRegex.exec(paraSource)) !== null && paragraphs.length < 6) {
+    const para = cleanHtml(paraMatch[1]);
+    if (para.length > 10) paragraphs.push(para);
+  }
+  if (paragraphs.length === 0) {
+    const paraDivRegex = /<div[^>]+class="[^"]*para[^"]*"[^>]*>([\s\S]*?)<\/div>/gi;
+    while ((paraMatch = paraDivRegex.exec(paraSource)) !== null && paragraphs.length < 6) {
+      const para = cleanHtml(paraMatch[1]);
+      if (para.length > 10) paragraphs.push(para);
+    }
+  }
+
+  const title = cleanHtml(titleMatch ? titleMatch[1] : '').replace(/_百度百科$/, '').trim();
+  const summary = cleanHtml(summaryBlock || (descriptionMatch ? descriptionMatch[1] : '')).slice(0, 3000);
+
+  return { title, summary, paragraphs };
+}
+
+export async function fetchBaikeSummary(term) {
+  if (!term || typeof term !== 'string') {
+    return { status: 'error', message: 'Search term is required.' };
+  }
+  const url = `https://baike.baidu.com/item/${encodeURIComponent(term)}`;
+
+  try {
+    const res = await fetchWithTimeout(url, {
+      headers: {
+        ...BROWSER_HEADERS,
+        'Accept-Language': 'zh-CN,zh;q=0.9'
+      }
+    }, 12000);
+    if (!res.ok) {
+      return {
+        status: 'error',
+        term,
+        source: 'Baidu Baike',
+        message: `Baidu Baike returned HTTP ${res.status}. Fallback to Wikipedia (zh) or search_chinese_web.`
+      };
+    }
+    const html = await readResponseTextLimited(res, 1_000_000);
+    if (html.includes('百度安全验证') || html.includes('wappass.baidu.com')) {
+      return {
+        status: 'error',
+        term,
+        source: 'Baidu Baike',
+        blocked: true,
+        message: 'Baidu Baike blocked the request (anti-bot verification). Use Wikipedia (zh) or search_chinese_web instead.'
+      };
+    }
+
+    const parsed = parseBaikePage(html);
+    if (!parsed.title && !parsed.summary) {
+      return {
+        status: 'not_found',
+        term,
+        source: 'Baidu Baike',
+        message: `Baidu Baike page could not be parsed for "${term}".`
+      };
+    }
+    return {
+      status: 'success',
+      term,
+      source: 'Baidu Baike',
+      title: parsed.title || term,
+      summary: parsed.summary,
+      paragraphs: parsed.paragraphs,
+      url: res.url || url
+    };
+  } catch (err) {
+    return {
+      status: 'error',
+      term,
+      source: 'Baidu Baike',
+      message: err.name === 'AbortError' ? 'Baidu Baike request timed out (12s)' : err.message
+    };
+  }
+}
+
+export async function fetchWikidataSummary(term, lang = 'zh') {
+  try {
+    const url = `https://www.wikidata.org/w/api.php?action=wbsearchentities&search=${encodeURIComponent(term)}&language=${lang}&limit=1&format=json`;
+    const res = await fetchWithTimeout(url, { headers: { 'User-Agent': 'KikuAgent/2.0' } }, 6000);
+    if (!res.ok) return { status: 'error', source: 'Wikidata', message: `HTTP ${res.status}` };
+    const data = await res.json();
+    const item = (data?.search || [])[0];
+    if (!item) return { status: 'not_found', source: 'Wikidata' };
+    return {
+      status: 'success',
+      term,
+      source: 'Wikidata',
+      title: item.label,
+      summary: item.description || '',
+      paragraphs: [item.description].filter(Boolean),
+      url: `https://www.wikidata.org/wiki/${item.id}`
+    };
+  } catch (err) {
+    return { status: 'error', source: 'Wikidata', message: err.message };
+  }
+}
+
+export async function fetchBangumiSummary(term) {
+  try {
+    const url = `https://api.bgm.tv/search/subject/${encodeURIComponent(term)}?responseGroup=small&max_results=1`;
+    const res = await fetchWithTimeout(url, { headers: { 'User-Agent': 'KikuAgent/2.0' } }, 6000);
+    if (!res.ok) return { status: 'error', source: 'Bangumi', message: `HTTP ${res.status}` };
+    const data = await res.json();
+    const item = (data?.list || [])[0];
+    if (!item) return { status: 'not_found', source: 'Bangumi' };
+    return {
+      status: 'success',
+      term,
+      source: 'Bangumi/Moegirl',
+      title: item.name_cn || item.name,
+      summary: item.summary || '',
+      paragraphs: [item.summary].filter(Boolean),
+      thumbnail: item.images?.large || item.images?.common || null,
+      url: item.url || `https://bgm.tv/subject/${item.id}`
+    };
+  } catch (err) {
+    return { status: 'error', source: 'Bangumi/Moegirl', message: err.message };
+  }
+}
+
+export async function searchEncyclopedia(term, lang = 'en', maxEntries = 2) {
+  if (!term || typeof term !== 'string') {
+    return { status: 'error', message: 'Search term is required.' };
+  }
+
+  const capped = Math.min(Math.max(maxEntries, 1), 6);
+  const entries = [];
+  const attempts = [];
+
+  const collect = (result) => {
+    if (result.status === 'success') {
+      entries.push({
+        source: result.source,
+        title: result.title,
+        summary: result.summary,
+        paragraphs: result.paragraphs,
+        thumbnail: result.thumbnail || null,
+        url: result.url
+      });
+      return true;
+    }
+    attempts.push({ source: result.source, status: result.status, message: result.message });
+    return false;
+  };
+
+  const tasks = [];
+  if (lang === 'zh') {
+    tasks.push(fetchBaikeSummary(term));
+  }
+  tasks.push(fetchWikipediaSummary(term, lang));
+  if (lang !== 'en') {
+    tasks.push(fetchWikipediaSummary(term, 'en'));
+  }
+  tasks.push(fetchWikidataSummary(term, lang));
+  tasks.push(fetchBangumiSummary(term));
+
+  const settled = await Promise.allSettled(tasks);
+  for (const s of settled) {
+    if (entries.length >= capped) break;
+    if (s.status === 'fulfilled' && s.value) {
+      collect(s.value);
+    }
+  }
+
+  if (entries.length === 0 && profileData) {
+    const rawTerm = term.toLowerCase();
+    const match = (profileData.nameEn && profileData.nameEn.toLowerCase().includes(rawTerm)) ||
+                  (profileData.nameZh && profileData.nameZh.includes(term)) ||
+                  (profileData.nameTh && profileData.nameTh.includes(term));
+    if (match) {
+      entries.push({
+        source: 'Local Knowledge Base',
+        title: `${profileData.nameZh || '鞠婧祎'} (${profileData.nameEn || 'Ju Jingyi'})`,
+        summary: profileData.bio || profileData.shortBio || '鞠婧祎，中国内地流行乐女歌手、影视演员。',
+        paragraphs: [profileData.bio, profileData.career].filter(Boolean),
+        thumbnail: profileData.avatar || null,
+        url: 'https://jujingyi-kikuuu.vercel.app'
+      });
+    }
+  }
+
+  return {
+    status: entries.length > 0 ? 'success' : (attempts.some(a => a.status === 'error') ? 'error' : 'not_found'),
+    term,
+    language: lang,
+    count: entries.length,
+    entries,
+    attempts
+  };
+}
+
+export async function searchItunesMusic(term, limit = 8) {
+  const capped = Math.min(Math.max(limit, 1), 25);
+  const url = `https://itunes.apple.com/search?term=${encodeURIComponent(term)}&media=music&entity=musicTrack,musicVideo,album&limit=${capped}`;
+  try {
+    const res = await fetchWithTimeout(url, { headers: { 'Accept': 'application/json' } }, 9000);
+    if (!res.ok) throw new Error(`iTunes HTTP ${res.status}`);
+    const data = await res.json();
+    const items = (data?.results || []).map(r => ({
+      kind: r.kind || 'track',
+      title: r.trackName || r.collectionName || '',
+      artist: r.artistName || '',
+      album: r.collectionName || '',
+      releasedAt: r.releaseDate || '',
+      previewUrl: r.previewUrl || null,
+      url: r.trackViewUrl || r.collectionViewUrl || '',
+      artworkUrl: r.artworkUrl100 || null
+    })).filter(r => r.title);
+    return { status: items.length > 0 ? 'success' : 'no_results', source: 'iTunes', count: items.length, results: items };
+  } catch (err) {
+    return {
+      status: 'error',
+      source: 'iTunes',
+      message: err.name === 'AbortError' ? 'iTunes request timed out (9s)' : err.message
+    };
+  }
+}
+
+export async function searchMusicBrainz(term, limit = 8) {
+  const capped = Math.min(Math.max(limit, 1), 25);
+  const buildUrl = (query) =>
+    `https://musicbrainz.org/ws/2/recording?query=${encodeURIComponent(query)}&fmt=json&limit=${capped}`;
+  const headers = {
+    'User-Agent': 'KikuAgent/2.0 (Ju Jingyi fan knowledge agent)',
+    'Accept': 'application/json'
+  };
+
+  const fetchQuery = async (query) => {
+    const res = await fetchWithTimeout(buildUrl(query), { headers }, 10000);
+    if (!res.ok) throw new Error(`MusicBrainz HTTP ${res.status}`);
+    return res.json();
+  };
+
+  try {
+    let data = await fetchQuery(`artist:"Ju Jingyi" AND ${term}`);
+    let recordings = data?.recordings || [];
+    if (recordings.length === 0) {
+      data = await fetchQuery(term);
+      recordings = data?.recordings || [];
+    }
+
+    const items = recordings.map(r => ({
+      title: r.title || '',
+      artist: (r['artist-credit'] || []).map(a => a?.name).filter(Boolean).join(', '),
+      score: r.score || 0,
+      lengthMs: r.length || null,
+      releases: (r.releases || []).slice(0, 3).map(x => ({
+        title: x.title || '',
+        date: x.date || '',
+        country: x.country || ''
+      }))
+    })).filter(r => r.title);
+
+    return { status: items.length > 0 ? 'success' : 'no_results', source: 'MusicBrainz', count: items.length, results: items };
+  } catch (err) {
+    return {
+      status: 'error',
+      source: 'MusicBrainz',
+      message: err.name === 'AbortError' ? 'MusicBrainz request timed out (10s)' : err.message
+    };
+  }
+}
+
+export async function searchMusicPlatforms(term, maxResults = 8) {
+  if (!term || typeof term !== 'string') {
+    return { status: 'error', message: 'Search term is required for music platform search.' };
+  }
+
+  const capped = Math.min(Math.max(maxResults, 1), 25);
+  const results = [];
+  const sources = [];
+  const seenTracks = new Set();
+
+  const addTrack = (item, sourceName) => {
+    const norm = (item.title + '|' + (item.artist || '')).toLowerCase().trim();
+    if (seenTracks.has(norm)) return;
+    seenTracks.add(norm);
+    results.push({ ...item, source: item.source || sourceName });
+    if (!sources.includes(item.source || sourceName)) sources.push(item.source || sourceName);
+  };
+
+
+  if (Array.isArray(discographyData)) {
+    const termLower = term.toLowerCase();
+    const localTracks = discographyData.filter(d =>
+      (d.title && d.title.toLowerCase().includes(termLower)) ||
+      (d.titleCn && d.titleCn.includes(term)) ||
+      (d.titleTh && d.titleTh.includes(term)) ||
+      (d.album && d.album.toLowerCase().includes(termLower))
+    );
+    for (const t of localTracks.slice(0, 3)) {
+      addTrack({
+        kind: 'track',
+        title: t.titleCn || t.title,
+        artist: '鞠婧祎 (Ju Jingyi)',
+        album: t.album || 'Single',
+        releasedAt: t.releaseDate || t.year || '',
+        url: t.audioUrl || t.videoUrl || '',
+        source: 'Verified Official Discography'
+      }, 'Verified Official Discography');
+    }
+  }
+
+  const fetchBilibiliMusic = async () => {
+    try {
+      const url = `https://api.bilibili.com/x/web-interface/search/type?search_type=video&keyword=${encodeURIComponent(term + ' 音乐 OST')}`;
+      const res = await fetchWithTimeout(url, { headers: BROWSER_HEADERS }, 8000);
+      if (!res.ok) return [];
+      const json = await res.json().catch(() => null);
+      const vlist = (json?.data?.result || []).slice(0, 4);
+      return vlist.map(v => ({
+        kind: 'musicVideo',
+        title: cleanHtml(v.title || ''),
+        artist: v.author || 'Bilibili Creator',
+        album: 'Bilibili Music/Stage',
+        url: `https://www.bilibili.com/video/${v.bvid}`,
+        source: 'Bilibili Music & OST'
+      }));
+    } catch {
+      return [];
+    }
+  };
+
+  const [itunes, musicBrainz, biliMusic] = await Promise.allSettled([
+    searchItunesMusic(term, capped),
+    searchMusicBrainz(term, capped),
+    fetchBilibiliMusic()
+  ]);
+
+  if (itunes.status === 'fulfilled' && itunes.value?.results?.length) {
+    itunes.value.results.forEach(r => addTrack(r, 'iTunes'));
+  }
+  if (musicBrainz.status === 'fulfilled' && musicBrainz.value?.results?.length) {
+    musicBrainz.value.results.forEach(r => addTrack(r, 'MusicBrainz'));
+  }
+  if (biliMusic.status === 'fulfilled' && Array.isArray(biliMusic.value)) {
+    biliMusic.value.forEach(r => addTrack(r, 'Bilibili Music & OST'));
+  }
+
+  if (results.length < capped) {
+    addTrack({
+      kind: 'searchBridge',
+      title: `QQ 音乐: "${term}"`,
+      artist: 'QQ Music Web Bridge',
+      album: 'Online Streaming',
+      url: `https://y.qq.com/n/ryqq/search?w=${encodeURIComponent(term)}`,
+      source: 'QQ Music Bridge'
+    }, 'QQ Music Bridge');
+  }
+
+  return {
+    status: results.length > 0 ? 'success' : 'no_results',
+    term,
+    count: results.length,
+    sources: [...new Set(sources)],
+    results: results.slice(0, capped)
+  };
+}
+
+export function parseBaiduResults(html, maxResults = 8) {
+  const results = [];
+  const seenUrls = new Set();
+  const regex = /<h3[^>]*>\s*<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/h3>([\s\S]*?)(?=<h3|<div[^>]+id="page"|<\/div>\s*<div[^>]+id="rs"|<\/body>|$)/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null && results.length < maxResults) {
+    const title = cleanHtml(match[2]);
+    let rawSnippet = cleanHtml(match[3]);
+    rawSnippet = rawSnippet.replace(/["']?\}[\],\}\s]+.*$/g, '').trim();
+    const snippet = rawSnippet.slice(0, 320);
+    if (title && match[1] && !seenUrls.has(match[1])) {
+      seenUrls.add(match[1]);
+      results.push({ title, url: match[1], snippet, source: 'Baidu' });
+    }
+  }
+  return results;
+}
+
+export async function searchChineseWeb(query, maxResults = 8, options = {}) {
+  if (!query || typeof query !== 'string') {
+    return { status: 'error', message: 'Query string is required for Chinese web search.' };
+  }
+
+  const effectiveQuery = typeof options.queryEnricher === 'function'
+    ? options.queryEnricher(query, 'chinese_web')
+    : getContextualizedSearchQuery(query, 'chinese_web');
+
+  const capped = Math.min(Math.max(maxResults, 1), 20);
+  const results = [];
+  const sources = [];
+  const attempts = [];
+
+  const fetchBaidu = async () => {
+    const t0 = Date.now();
+    try {
+      const baiduUrl = `https://www.baidu.com/s?wd=${encodeURIComponent(effectiveQuery)}&rn=${Math.min(capped * 2, 20)}`;
+      const res = await fetchWithTimeout(baiduUrl, {
+        headers: {
+          ...BROWSER_HEADERS,
+          'Accept-Language': 'zh-CN,zh;q=0.9',
+          'Referer': 'https://www.baidu.com/'
+        }
+      }, 10000);
+      if (res.ok) {
+        const html = await readResponseTextLimited(res, 3_000_000);
+        if (html.includes('百度安全验证') || html.includes('wappass.baidu.com')) {
+          attempts.push({ source: 'Baidu', status: 'blocked', message: 'Baidu anti-bot verification challenge.', durationMs: Date.now() - t0 });
+          return [];
+        }
+        const items = parseBaiduResults(html, capped);
+        attempts.push({ source: 'Baidu', status: items.length ? 'success' : 'no_results', count: items.length, durationMs: Date.now() - t0 });
+        return items;
+      }
+      attempts.push({ source: 'Baidu', status: 'error', message: `HTTP ${res.status}`, durationMs: Date.now() - t0 });
+    } catch (err) {
+      attempts.push({ source: 'Baidu', status: 'error', message: err.name === 'AbortError' ? 'Baidu timeout (10s)' : err.message, durationMs: Date.now() - t0 });
+    }
+    return [];
+  };
+
+  const fetchBingZh = async () => {
+    const t0 = Date.now();
+    try {
+      const items = await searchBing(effectiveQuery, capped, { language: 'zh' });
+      attempts.push({ source: 'Bing (zh)', status: items.length ? 'success' : 'no_results', count: items.length, durationMs: Date.now() - t0 });
+      return items.map(it => ({ ...it, source: 'Bing (zh)' }));
+    } catch (err) {
+      attempts.push({ source: 'Bing (zh)', status: 'error', message: err.message, durationMs: Date.now() - t0 });
+      return [];
+    }
+  };
+
+  const fetchNewsZh = async () => {
+    const t0 = Date.now();
+    try {
+      const [gNews, bNews] = await Promise.allSettled([
+        fetchGoogleNewsRss(effectiveQuery, Math.ceil(capped / 2), 'zh'),
+        fetchBingNewsRss(effectiveQuery, Math.ceil(capped / 2), 'zh')
+      ]);
+      const items = [];
+      if (gNews.status === 'fulfilled' && Array.isArray(gNews.value)) items.push(...gNews.value);
+      if (bNews.status === 'fulfilled' && Array.isArray(bNews.value)) items.push(...bNews.value);
+      attempts.push({ source: 'Chinese News Media', status: items.length ? 'success' : 'no_results', count: items.length, durationMs: Date.now() - t0 });
+      return items.map(it => ({
+        title: it.title,
+        url: it.url,
+        snippet: it.snippet,
+        source: it.source ? `Chinese News (${it.source})` : 'Chinese News Media'
+      }));
+    } catch (err) {
+      attempts.push({ source: 'Chinese News Media', status: 'error', message: err.message, durationMs: Date.now() - t0 });
+      return [];
+    }
+  };
+
+  const fetchBilibili = async () => {
+    const t0 = Date.now();
+    try {
+      const url = `https://api.bilibili.com/x/web-interface/search/all/v2?keyword=${encodeURIComponent(effectiveQuery)}`;
+      const res = await fetchWithTimeout(url, {
+        headers: {
+          ...BROWSER_HEADERS,
+          'Accept-Language': 'zh-CN,zh;q=0.9',
+          'Referer': 'https://www.bilibili.com/'
+        }
+      }, 8000);
+      if (res.ok) {
+        const json = await res.json().catch(() => null);
+        const vlist = (json?.data?.result || []).find(r => r.result_type === 'video')?.data || [];
+        const items = vlist.slice(0, 4).map(v => ({
+          title: cleanHtml(v.title || ''),
+          url: `https://www.bilibili.com/video/${v.bvid}`,
+          snippet: cleanHtml(v.description || `Bilibili video: ${v.author || ''}`).slice(0, 300),
+          source: 'Bilibili Web'
+        }));
+        attempts.push({ source: 'Bilibili', status: items.length ? 'success' : 'no_results', count: items.length, durationMs: Date.now() - t0 });
+        return items;
+      }
+    } catch (err) {
+      attempts.push({ source: 'Bilibili', status: 'error', message: err.message, durationMs: Date.now() - t0 });
+    }
+    return [];
+  };
+
+  const fetchWikiZh = async () => {
+    const t0 = Date.now();
+    try {
+      const items = await searchWikipedia(effectiveQuery, 2, 'zh');
+      attempts.push({ source: 'Chinese Wikipedia', status: items.length ? 'success' : 'no_results', count: items.length, durationMs: Date.now() - t0 });
+      return items.map(it => ({ ...it, source: 'Chinese Wikipedia' }));
+    } catch (err) {
+      attempts.push({ source: 'Chinese Wikipedia', status: 'error', message: err.message, durationMs: Date.now() - t0 });
+      return [];
+    }
+  };
+
+  const fetchBaike = async () => {
+    const t0 = Date.now();
+    try {
+      const baike = await fetchBaikeSummary(effectiveQuery);
+      if (baike.status === 'success') {
+        attempts.push({ source: 'Baidu Baike', status: 'success', count: 1, durationMs: Date.now() - t0 });
+        return [{
+          title: baike.title ? `${baike.title} - 百度百科` : '百度百科',
+          url: baike.url,
+          snippet: (baike.summary || '').slice(0, 320),
+          source: 'Baidu Baike'
+        }];
+      }
+    } catch (err) {
+      attempts.push({ source: 'Baidu Baike', status: 'error', message: err.message, durationMs: Date.now() - t0 });
+    }
+    return [];
+  };
+
+  const fetchOpenWeb = async () => {
+    const t0 = Date.now();
+    try {
+      const cnDomains = options.site ? [options.site] : ['sina.com.cn', 'sohu.com', 'weibo.com', '163.com', 'qq.com'];
+      const ddgPromises = cnDomains.slice(0, 3).map(domain =>
+        searchDuckDuckGo(`${effectiveQuery} site:${domain}`, 2)
+          .then(items => items.map(it => ({ ...it, source: `Web (${domain})` })))
+          .catch(() => [])
+      );
+      const ddgResults = (await Promise.all(ddgPromises)).flat();
+      attempts.push({ source: 'Open Web Portals', status: ddgResults.length ? 'success' : 'no_results', count: ddgResults.length, durationMs: Date.now() - t0 });
+      return ddgResults;
+    } catch (err) {
+      attempts.push({ source: 'Open Web Portals', status: 'error', message: err.message, durationMs: Date.now() - t0 });
+      return [];
+    }
+  };
+
+
+  const settled = await Promise.allSettled([
+    fetchBaidu(),
+    fetchBingZh(),
+    fetchNewsZh(),
+    fetchBilibili(),
+    fetchWikiZh(),
+    fetchBaike(),
+    fetchOpenWeb()
+  ]);
+
+  const buckets = settled.map(s => (s.status === 'fulfilled' && Array.isArray(s.value)) ? s.value : []);
+
+  const seenUrls = new Set();
+  const seenTitles = new Set();
+  let added = true;
+  let baikeCount = 0;
+
+  
+  while (results.length < capped && added) {
+    added = false;
+    for (const bucket of buckets) {
+      if (results.length >= capped) break;
+      if (bucket.length > 0) {
+        const item = bucket.shift();
+        const normUrl = item.url.replace(/^https?:\/\//, '').replace(/\/$/, '').toLowerCase();
+        const normTitle = item.title.trim().toLowerCase();
+
+       
+        if (item.source.includes('Baike') && baikeCount >= 1) continue;
+        if (seenUrls.has(normUrl) || seenTitles.has(normTitle)) continue;
+
+        seenUrls.add(normUrl);
+        seenTitles.add(normTitle);
+        if (item.source.includes('Baike')) baikeCount++;
+
+        results.push(item);
+        if (!sources.includes(item.source)) sources.push(item.source);
+        added = true;
+      }
+    }
+  }
+
+  let cnImages = [];
+  try {
+    const imgRes = await searchWebImages(query, 6).catch(() => null);
+    if (imgRes && Array.isArray(imgRes.results)) {
+      cnImages = imgRes.results.slice(0, 6);
+    }
+  } catch {}
+
+  return {
+    status: results.length > 0 ? 'success' : 'no_results',
+    query,
+    count: results.length,
+    sources: [...new Set(sources)],
+    attempts,
+    results,
+    ...(cnImages.length > 0 ? { images: cnImages } : {})
+  };
+}
+
+export function decodeBaiduUrl(url) {
+  if (!url || typeof url !== 'string') return '';
+  const trimmed = url.trim();
+  if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) return trimmed;
+  if (!trimmed.includes('ippr_z2C$q') && !trimmed.includes('AzdH3F')) return trimmed;
+
+  const keywordMap = {
+    '_z2C$q': ':',
+    '_z&e3B': '.',
+    'AzdH3F': '/'
+  };
+
+  const charMap = {
+    'w': 'a', 'k': 'b', 'v': 'c', '1': 'd', 'j': 'e', 'u': 'f', '2': 'g', 'i': 'h', 't': 'i', '3': 'j', 'h': 'k',
+    's': 'l', '4': 'm', 'g': 'n', '5': 'o', 'r': 'p', 'q': 'q', '6': 'r', 'f': 's', 'p': 't', '7': 'u', 'e': 'v',
+    'o': 'w', '8': '1', 'd': '2', 'n': '3', '9': '4', 'c': '5', 'm': '6', '0': '7', 'b': '8', 'l': '9', 'a': '0'
+  };
+
+  let step1 = trimmed;
+  for (const [k, v] of Object.entries(keywordMap)) {
+    step1 = step1.replaceAll(k, v);
+  }
+
+  let res = '';
+  for (const ch of step1) {
+    res += charMap[ch] !== undefined ? charMap[ch] : ch;
+  }
+  return res;
+}
+
+export async function searchWebImages(query, maxResults = 8) {
+  if (!query || typeof query !== 'string') {
+    return { status: 'error', message: 'Query string is required for image search.' };
+  }
+
+  const effectiveQuery = getContextualizedSearchQuery(query, 'chinese_web');
+  const capped = Math.min(Math.max(maxResults, 1), 25);
+  const results = [];
+  const sources = [];
+  const seenUrls = new Set();
+
+  const addImage = (item, defaultSource) => {
+    if (!item?.imageUrl || seenUrls.has(item.imageUrl)) return false;
+    seenUrls.add(item.imageUrl);
+    const src = item.source || defaultSource;
+    let sourcePageUrl = item.sourcePageUrl || '';
+    if (sourcePageUrl && (sourcePageUrl.includes('ippr_z2C$q') || sourcePageUrl.includes('AzdH3F'))) {
+      sourcePageUrl = decodeBaiduUrl(sourcePageUrl);
+    }
+    if (sourcePageUrl && !/^https?:\/\//i.test(sourcePageUrl)) {
+      sourcePageUrl = '';
+    }
+    results.push({ ...item, sourcePageUrl, source: src });
+    if (!sources.includes(src)) sources.push(src);
+    return true;
+  };
+
+ 
+  if (Array.isArray(galleryData)) {
+    const qLower = query.toLowerCase();
+    const localMatches = galleryData.filter(g =>
+      (g.title && g.title.toLowerCase().includes(qLower)) ||
+      (g.category && g.category.toLowerCase().includes(qLower)) ||
+      (g.tags && g.tags.some(t => t.toLowerCase().includes(qLower)))
+    );
+    for (const g of localMatches.slice(0, 3)) {
+      addImage({
+        title: g.title || effectiveQuery,
+        imageUrl: g.url,
+        thumbUrl: g.url,
+        sourcePageUrl: 'https://jujingyi-kikuuu.vercel.app/#gallery',
+        width: 1080,
+        height: 1440,
+        source: 'Official Gallery'
+      }, 'Official Gallery');
+    }
+  }
+
+
+  const fetchBaiduImages = async () => {
+    try {
+      const baiduImgUrl = `https://image.baidu.com/search/acjson?tn=resultjson_com&logid=${Date.now()}&ipn=rj&ct=201326592&is=&fp=result&word=${encodeURIComponent(effectiveQuery)}&queryWord=${encodeURIComponent(effectiveQuery)}&cl=2&lm=-1&ie=utf-8&oe=utf-8&pn=0&rn=${Math.min(capped * 2, 30)}&gsm=1e`;
+      const res = await fetchWithTimeout(baiduImgUrl, {
+        headers: {
+          ...BROWSER_HEADERS,
+          'Referer': 'https://image.baidu.com/',
+          'Accept': 'text/plain, */*; q=0.01',
+          'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+        }
+      }, 10000);
+      if (res.ok) {
+        const json = await res.json().catch(() => null);
+        const items = Array.isArray(json?.data) ? json.data : [];
+        return items.map(item => {
+          let rawImgUrl = item.middleURL || item.thumbURL || item.hoverURL;
+          if (!rawImgUrl || !rawImgUrl.startsWith('http')) {
+            if (item.objURL) {
+              const decodedObj = decodeBaiduUrl(item.objURL);
+              if (decodedObj && decodedObj.startsWith('http')) {
+                rawImgUrl = decodedObj;
+              }
+            }
+          }
+          if (!rawImgUrl || typeof rawImgUrl !== 'string' || !rawImgUrl.startsWith('http')) return null;
+
+          let sourcePageUrl = decodeBaiduUrl(item.fromURL || '');
+          if (!sourcePageUrl || !/^https?:\/\//i.test(sourcePageUrl)) {
+            if (item.fromURLHost && typeof item.fromURLHost === 'string' && item.fromURLHost.includes('.')) {
+              sourcePageUrl = `https://${item.fromURLHost}`;
+            } else {
+              sourcePageUrl = '';
+            }
+          }
+
+          let thumbUrl = item.thumbURL || rawImgUrl;
+          if (thumbUrl && (thumbUrl.includes('ippr_z2C$q') || thumbUrl.includes('AzdH3F'))) {
+            thumbUrl = decodeBaiduUrl(thumbUrl);
+          }
+
+          return {
+            title: cleanHtml(item.fromPageTitleEnc || item.fromPageTitle || effectiveQuery),
+            imageUrl: rawImgUrl,
+            thumbUrl: thumbUrl || rawImgUrl,
+            sourcePageUrl: sourcePageUrl,
+            width: Number(item.width) || null,
+            height: Number(item.height) || null,
+            source: 'Baidu Images'
+          };
+        }).filter(Boolean);
+      }
+    } catch {}
+    return [];
+  };
+
+
+  const fetchBingImages = async () => {
+    try {
+      const url = `https://www.bing.com/images/async?q=${encodeURIComponent(effectiveQuery)}&mmasync=1`;
+      const res = await fetchWithTimeout(url, {
+        headers: {
+          ...BROWSER_HEADERS,
+          'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8'
+        }
+      }, 10000);
+      if (res.ok) {
+        const html = await res.text();
+        const items = [];
+        const regex = /m="({[\s\S]*?})"/g;
+        let match;
+        while ((match = regex.exec(html)) !== null && items.length < capped) {
+          try {
+            const data = JSON.parse(match[1].replace(/&quot;/g, '"'));
+            if (data.murl && data.murl.startsWith('http')) {
+              items.push({
+                title: cleanHtml(data.t || effectiveQuery),
+                imageUrl: data.murl,
+                thumbUrl: data.turl || data.murl,
+                sourcePageUrl: data.purl || '',
+                width: Number(data.w) || null,
+                height: Number(data.h) || null,
+                source: 'Bing Images'
+              });
+            }
+          } catch {}
+        }
+        return items;
+      }
+    } catch {}
+    return [];
+  };
+
+
+  const fetchBilibiliCovers = async () => {
+    try {
+      const url = `https://api.bilibili.com/x/web-interface/search/all/v2?keyword=${encodeURIComponent(effectiveQuery)}`;
+      const res = await fetchWithTimeout(url, {
+        headers: {
+          ...BROWSER_HEADERS,
+          'Accept-Language': 'zh-CN,zh;q=0.9',
+          'Referer': 'https://www.bilibili.com/'
+        }
+      }, 8000);
+      if (res.ok) {
+        const json = await res.json().catch(() => null);
+        const vlist = (json?.data?.result || []).find(r => r.result_type === 'video')?.data || [];
+        return vlist.slice(0, 5).map(v => {
+          let pic = v.pic || '';
+          if (pic.startsWith('//')) pic = 'https:' + pic;
+          if (!pic.startsWith('http')) return null;
+          return {
+            title: cleanHtml(v.title || effectiveQuery),
+            imageUrl: pic,
+            thumbUrl: pic,
+            sourcePageUrl: `https://www.bilibili.com/video/${v.bvid}`,
+            width: null,
+            height: null,
+            source: 'Bilibili Covers'
+          };
+        }).filter(Boolean);
+      }
+    } catch {}
+    return [];
+  };
+
+
+  const [baiduImgs, bingImgs, biliImgs] = await Promise.allSettled([
+    fetchBaiduImages(),
+    fetchBingImages(),
+    fetchBilibiliCovers()
+  ]);
+
+  const bList = baiduImgs.status === 'fulfilled' && Array.isArray(baiduImgs.value) ? baiduImgs.value : [];
+  const biList = bingImgs.status === 'fulfilled' && Array.isArray(bingImgs.value) ? bingImgs.value : [];
+  const blList = biliImgs.status === 'fulfilled' && Array.isArray(biliImgs.value) ? biliImgs.value : [];
+
+  let idx = 0;
+  while (results.length < capped && (idx < bList.length || idx < biList.length || idx < blList.length)) {
+    if (idx < bList.length && results.length < capped) addImage(bList[idx], 'Baidu Images');
+    if (idx < biList.length && results.length < capped) addImage(biList[idx], 'Bing Images');
+    if (idx < blList.length && results.length < capped) addImage(blList[idx], 'Bilibili Covers');
+    idx++;
+  }
+
+  if (results.length < capped) {
+    try {
+      const webRes = await searchChineseWeb(query, Math.min(capped - results.length, 3));
+      const webResults = webRes?.results || [];
+      const fetchedPages = await Promise.all(webResults.map(async r => {
+        try {
+          return { r, page: await fetchWebpage(r.url, 2000) };
+        } catch {
+          return { r, page: null };
+        }
+      }));
+      for (const { r, page } of fetchedPages) {
+        if (results.length >= capped) break;
+        for (const img of page?.images || []) {
+          if (results.length >= capped) break;
+          if (img.src && img.src.startsWith('http')) {
+            addImage({
+              title: img.alt || r.title || effectiveQuery,
+              imageUrl: img.src,
+              thumbUrl: img.src,
+              sourcePageUrl: r.url,
+              width: null,
+              height: null,
+              source: `Web Portal (${r.source || 'Media'})`
+            }, 'Web Portal');
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return {
+    status: results.length > 0 ? 'success' : 'no_results',
+    query,
+    count: results.length,
+    sources: [...new Set(sources)],
+    results: results.slice(0, capped)
+  };
+}
+
+export const BILIBILI_BVID_PATTERN = /^BV[0-9A-Za-z]{10}$/;
+export const BILIBILI_PLAYER_ORIGIN = 'https://player.bilibili.com';
+
+
+export function buildBilibiliEmbedUrl(bvid, { autoplay = false, page = 1, aid = '', cid = '' } = {}) {
+  const id = String(bvid || '').trim();
+  if (!BILIBILI_BVID_PATTERN.test(id)) return '';
+  const digits = (v) => (/^\d+$/.test(String(v || '').trim()) ? String(v).trim() : '');
+  const aidDigits = digits(aid);
+  const cidDigits = digits(cid);
+  const pageNum = Number(page) >= 1 ? Math.floor(Number(page)) : 1;
+  let params = `bvid=${encodeURIComponent(id)}&page=${pageNum}&high_quality=1&danmaku=0`;
+ 
+  if (aidDigits) params = `aid=${aidDigits}&${params}`;
+  if (cidDigits) params += `&cid=${cidDigits}`;
+  if (autoplay) params += '&autoplay=1';
+  return `${BILIBILI_PLAYER_ORIGIN}/player.html?${params}`;
+}
+
+function escapeBilibiliAttr(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+
+export function buildBilibiliIframeHtml(bvid, { title = 'Bilibili Video', autoplay = false, cssClass = '', aid = '', cid = '', page = 1, width = '100%', height = '500' } = {}) {
+  const src = buildBilibiliEmbedUrl(bvid, { autoplay, aid, cid, page });
+  if (!src) return '';
+  const cls = cssClass ? ` class="${escapeBilibiliAttr(cssClass)}"` : '';
+  return `<iframe src="${src}"${cls} width="${escapeBilibiliAttr(width)}" height="${escapeBilibiliAttr(height)}" style="width:100%;aspect-ratio:16/9;min-height:360px;border:0;" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" title="${escapeBilibiliAttr(title)}" loading="lazy" referrerpolicy="no-referrer"></iframe>`;
+}
+
+
+export function normalizeBilibiliIframeSrc(src, fallbackBvid = '') {
+  const raw = String(src || '').trim();
+  const fallback = String(fallbackBvid || '').trim();
+
+  const fromFallback = fallback && BILIBILI_BVID_PATTERN.test(fallback)
+    ? buildBilibiliEmbedUrl(fallback)
+    : '';
+
+  if (!raw || raw.includes('://:') || /^(\/\/)?:?(\/\/)?:?bilibili\.com\/?$/.test(raw)) {
+    return fromFallback;
+  }
+
+  let candidate = raw;
+  if (candidate.startsWith('//')) candidate = `https:${candidate}`;
+
+  let url;
+  try {
+    url = new URL(candidate, BILIBILI_PLAYER_ORIGIN);
+  } catch {
+    return fromFallback;
+  }
+
+  if (url.hostname !== 'player.bilibili.com') return fromFallback;
+
+  const bvid = (url.searchParams.get('bvid') || '').trim();
+  if (BILIBILI_BVID_PATTERN.test(bvid)) {
+    return buildBilibiliEmbedUrl(bvid, {
+      aid: url.searchParams.get('aid') || '',
+      cid: url.searchParams.get('cid') || '',
+      page: url.searchParams.get('page') || url.searchParams.get('p') || 1,
+      autoplay: url.searchParams.get('autoplay') === '1',
+    });
+  }
+  return fromFallback;
+}
+
+export function isBrokenBilibiliIframeSrc(src) {
+  const raw = String(src || '').trim();
+  if (!raw) return true;
+  if (raw.includes('://:')) return true;
+  const normalized = normalizeBilibiliIframeSrc(raw);
+  return normalized === '';
+}
+
+
+export function normalizeBilibiliPic(pic) {
+  const raw = String(pic || '').trim();
+  if (!raw) return '';
+  if (raw.startsWith('//')) return `https:${raw}`;
+  if (/^http:\/\//i.test(raw)) return raw.replace(/^http:\/\//i, 'https://');
+  if (/^https:\/\//i.test(raw)) return raw;
+  return '';
+}
+
+
+export function parseBilibiliViewPayload(json) {
+  const d = json?.data;
+  if (json?.code !== 0 || !d || !d.bvid) return null;
+  return {
+    title: cleanHtml(d.title || '') || d.bvid,
+    author: d.owner?.name || '',
+    pic: normalizeBilibiliPic(d.pic || ''),
+    duration: Number(d.duration) || 0,
+    publishedAt: d.pubdate ? new Date(d.pubdate * 1000).toISOString() : '',
+    playCount: Number(d.stat?.view) || 0,
+    danmakuCount: Number(d.stat?.danmaku) || 0,
+    cid: d.cid ? String(d.cid) : '',
+  };
+}
+
+
+export function parseBilibiliSearchPayload(json, bvid) {
+  const results = Array.isArray(json?.data?.result) ? json.data.result : [];
+  const exact = results.find(r => r && r.bvid === bvid);
+  if (!exact) return null;
+  return {
+    title: cleanHtml(exact.title || '') || bvid,
+    author: exact.author || '',
+    pic: normalizeBilibiliPic(exact.pic || ''),
+    duration: 0,
+    publishedAt: exact.pubdate ? new Date(exact.pubdate * 1000).toISOString() : '',
+    playCount: Number(exact.play) || 0,
+    danmakuCount: Number(exact.video_review) || 0,
+    cid: '',
+  };
+}
+
+function buildBilibiliVideoPayload(id, parsed) {
+  return {
+    title: parsed.title || id,
+    author: parsed.author || '',
+    pic: parsed.pic || '',
+    duration: parsed.duration || 0,
+    publishedAt: parsed.publishedAt || '',
+    playCount: parsed.playCount || 0,
+    danmakuCount: parsed.danmakuCount || 0,
+    cid: parsed.cid || '',
+    url: `https://www.bilibili.com/video/${id}`,
+    embedUrl: buildBilibiliEmbedUrl(id, { cid: parsed.cid ? String(parsed.cid) : '' }),
+  };
+}
+
+const BILIBILI_INFO_CACHE = new BoundedLruCache(500);
+const BILIBILI_INFO_TTL_MS = 10 * 60_000;
+const BILIBILI_INFO_FAIL_TTL_MS = 60_000;
+
+async function bilibiliApiCookie() {
+  try {
+    const home = await fetchWithTimeout('https://www.bilibili.com/', { headers: BROWSER_HEADERS }, 8000);
+    const setCookies = home.headers.getSetCookie?.() || [];
+    return setCookies.map(c => c.split(';')[0]).join('; ');
+  } catch {
+    return '';
+  }
+}
+
+export async function fetchBilibiliVideoInfo(bvid) {
+  const id = String(bvid || '').trim();
+  if (!BILIBILI_BVID_PATTERN.test(id)) {
+    return { status: 'error', message: 'A valid Bilibili bvid (BV + 10 chars) is required.' };
+  }
+
+  const cached = BILIBILI_INFO_CACHE.get(id);
+  if (cached) return cached;
+  const remember = (value, ttlMs) => {
+    BILIBILI_INFO_CACHE.set(id, value, ttlMs);
+    return value;
+  };
+
+  const cookie = await bilibiliApiCookie();
+  const apiHeaders = {
+    ...BROWSER_HEADERS,
+    'Accept-Language': 'zh-CN,zh;q=0.9',
+    ...(cookie ? { Cookie: cookie } : {}),
+  };
+
+  try {
+
+    const viewRes = await fetchWithTimeout(`https://api.bilibili.com/x/web-interface/view?bvid=${encodeURIComponent(id)}`, {
+      headers: { ...apiHeaders, 'Referer': `https://www.bilibili.com/video/${id}` }
+    }, 12000);
+    const viewJson = await viewRes.json().catch(() => null);
+    const viewParsed = parseBilibiliViewPayload(viewJson);
+    if (viewParsed) {
+      return remember({ status: 'success', bvid: id, video: buildBilibiliVideoPayload(id, viewParsed) }, BILIBILI_INFO_TTL_MS);
+    }
+
+ 
+    const searchRes = await fetchWithTimeout(`https://api.bilibili.com/x/web-interface/search/type?search_type=video&keyword=${encodeURIComponent(id)}&page=1&page_size=20`, {
+      headers: { ...apiHeaders, 'Referer': 'https://search.bilibili.com/' }
+    }, 12000);
+    const searchJson = await searchRes.json().catch(() => null);
+    const searchParsed = parseBilibiliSearchPayload(searchJson, id);
+    if (searchParsed) {
+      return remember({ status: 'success', bvid: id, video: buildBilibiliVideoPayload(id, searchParsed) }, BILIBILI_INFO_TTL_MS);
+    }
+
+    return remember({
+      status: 'error',
+      bvid: id,
+      message: `Bilibili metadata unavailable for ${id} (view API blocked by risk control, search fallback had no exact match).`
+    }, BILIBILI_INFO_FAIL_TTL_MS);
+  } catch (err) {
+    return remember({
+      status: 'error',
+      bvid: id,
+      message: err.name === 'AbortError' ? 'Bilibili request timed out (12s)' : err.message
+    }, BILIBILI_INFO_FAIL_TTL_MS);
+  }
+}
+
+let cachedBilibiliCookie = '';
+let bilibiliCookieExpiresAt = 0;
+let bilibiliCookieFetchPromise = null;
+
+async function getBilibiliCookie() {
+  const now = Date.now();
+  if (cachedBilibiliCookie && now < bilibiliCookieExpiresAt) {
+    return cachedBilibiliCookie;
+  }
+  if (bilibiliCookieFetchPromise) {
+    return bilibiliCookieFetchPromise;
+  }
+  bilibiliCookieFetchPromise = (async () => {
+    try {
+      const home = await fetchWithTimeout('https://www.bilibili.com/', { headers: BROWSER_HEADERS }, 8000);
+      const setCookies = home.headers.getSetCookie?.() || [];
+      const cookie = setCookies.map(c => c.split(';')[0]).join('; ');
+      if (cookie) {
+        cachedBilibiliCookie = cookie;
+        bilibiliCookieExpiresAt = Date.now() + 3600_000;
+      }
+      return cookie;
+    } catch {
+      return cachedBilibiliCookie || '';
+    } finally {
+      bilibiliCookieFetchPromise = null;
+    }
+  })();
+  return bilibiliCookieFetchPromise;
+}
+
+export async function searchBilibili(keyword, maxResults = 8) {
+  if (!keyword || typeof keyword !== 'string') {
+    return { status: 'error', message: 'Keyword is required for Bilibili search.' };
+  }
+
+  const effectiveKeyword = getContextualizedSearchQuery(keyword, 'bilibili');
+  const capped = Math.min(Math.max(maxResults, 1), 20);
+
+  try {
+    const cookie = await getBilibiliCookie();
+
+    const apiUrl = `https://api.bilibili.com/x/web-interface/search/type?search_type=video&keyword=${encodeURIComponent(effectiveKeyword)}&page=1&page_size=${capped}`;
+    const res = await fetchWithTimeout(apiUrl, {
+      headers: {
+        ...BROWSER_HEADERS,
+        'Accept-Language': 'zh-CN,zh;q=0.9',
+        'Referer': 'https://search.bilibili.com/',
+        ...(cookie ? { Cookie: cookie } : {})
+      }
+    }, 12000);
+    if (!res.ok) {
+      return {
+        status: 'error',
+        keyword,
+        searchQuery: effectiveKeyword,
+        message: `Bilibili API returned HTTP ${res.status}. Fallback: search_chinese_web with site:bilibili.com`
+      };
+    }
+    const json = await res.json();
+    if (json?.code !== 0) {
+      return {
+        status: 'error',
+        keyword,
+        searchQuery: effectiveKeyword,
+        message: `Bilibili API returned code ${json?.code} (${json?.message || 'unknown'}). This is usually anti-bot protection — fallback: search_chinese_web with site:bilibili.com`
+      };
+    }
+
+    const items = (json.data?.result || []).slice(0, capped).map(r => {
+      const bvid = r.bvid || '';
+      const rawPic = r.pic || '';
+      const pic = rawPic.startsWith('//') ? `https:${rawPic}` : rawPic;
+      const cleanTitle = cleanHtml(r.title || '');
+      const author = r.author || '';
+      const play = Number(r.play) || 0;
+      const danmaku = Number(r.video_review) || 0;
+
+      let rankScore = 0;
+      const lowerAuthor = author.toLowerCase();
+      const lowerTitle = cleanTitle.toLowerCase();
+      const rawDesc = String(r.description || '');
+      const lowerDesc = rawDesc.toLowerCase();
+
+   
+      const hasArtistInAuthor = lowerAuthor.includes('鞠婧祎工作室') || lowerAuthor.includes('鞠婧祎') || lowerAuthor.includes('studio');
+      const hasArtistInTitle = cleanTitle.includes('鞠婧祎') || cleanTitle.includes('小鞠') || lowerTitle.includes('kiku') || lowerTitle.includes('jujingyi');
+      const hasArtistInDesc = rawDesc.includes('鞠婧祎') || rawDesc.includes('小鞠');
+
+      if (hasArtistInAuthor) {
+        rankScore += 100;
+      } else if (hasArtistInTitle) {
+        rankScore += 80;
+      } else if (hasArtistInDesc) {
+        rankScore += 45;
+      } else {
+      
+        rankScore -= 40;
+      }
+
+
+      if (lowerAuthor.includes('snh48') || lowerAuthor.includes('腾讯') || lowerAuthor.includes('优酷') || lowerAuthor.includes('爱奇艺') || lowerAuthor.includes('芒果') || lowerAuthor.includes('帕莎') || lowerAuthor.includes('prsr') || lowerAuthor.includes('官方')) {
+        rankScore += 60;
+      }
+
+     
+      if (lowerTitle.includes('mv') || cleanTitle.includes('官方') || lowerTitle.includes('official') || cleanTitle.includes('舞台') || cleanTitle.includes('现场') || cleanTitle.includes('代言') || cleanTitle.includes('花絮') || cleanTitle.includes('广告') || lowerTitle.includes('prsr') || cleanTitle.includes('帕莎')) {
+        rankScore += 35;
+      }
+
+      if (play > 0) rankScore += Math.min(Math.log10(play) * 10, 50);
+
+      return {
+        title: cleanTitle,
+        bvid,
+        author,
+        duration: r.duration || '',
+        publishedAt: r.pubdate ? new Date(r.pubdate * 1000).toISOString() : '',
+        playCount: play,
+        danmakuCount: danmaku,
+        pic,
+        embedUrl: bvid ? buildBilibiliEmbedUrl(bvid) : '',
+        description: rawDesc.slice(0, 300),
+        url: bvid ? `https://www.bilibili.com/video/${bvid}` : '',
+        rankScore: Math.round(rankScore * 10) / 10
+      };
+    }).filter(r => r.title && r.url);
+
+    items.sort((a, b) => (b.rankScore || 0) - (a.rankScore || 0));
+
+    return {
+      status: items.length > 0 ? 'success' : 'no_results',
+      keyword,
+      searchQuery: effectiveKeyword,
+      count: items.length,
+      source: 'Bilibili',
+      results: items
+    };
+  } catch (err) {
+    return {
+      status: 'error',
+      keyword,
+      message: err.name === 'AbortError' ? 'Bilibili request timed out (12s)' : err.message
+    };
+  }
+}
+
+export async function webExtract(query, opts = {}) {
+  if (!query || typeof query !== 'string') {
     return { status: 'error', message: 'Query string is required.' };
   }
 
@@ -749,7 +2746,7 @@ export async function webExtract(query, opts = {}) {
   const toFetch = candidates.slice(0, cappedResults);
   const fetchPromises = toFetch.map(async (result) => {
     try {
-      const page = await fetchWebpage(result.url, maxContentLength);
+      const page = await fetchWebpage(result.url, maxContentLength, { query });
       return {
         title: result.title || page.meta?.title || '',
         url: result.url,
@@ -784,22 +2781,31 @@ export async function webExtract(query, opts = {}) {
 
   const fetched = await Promise.all(fetchPromises);
 
-
+  const sharedHashState = { hashes: [] };
   const combinedContent = fetched
     .filter(r => r.fetchStatus === 'success' && r.content)
     .map(r => {
       const metaLine = r.meta?.description ? `\nDescription: ${r.meta.description}` : '';
       const headingsLine = r.headings?.length ? `\nHeadings: ${r.headings.map(h => h.text).join(' | ')}` : '';
-      return `### ${r.title}\nSource: ${r.url}${metaLine}${headingsLine}\n\n${r.content.slice(0, maxContentLength)}`;
+      const passages = filterUniquePassages(splitIntoPassages(r.content), sharedHashState);
+      const body = truncateByWords(passages.map(p => p.text).join('\n\n'), maxContentLength);
+      return `### ${r.title}\nSource: ${r.url}${metaLine}${headingsLine}\n\n${body}`;
     })
     .join('\n\n---\n\n');
 
+  const pagesSucceeded = fetched.filter(r => r.fetchStatus === 'success').length;
+  const status = fetched.length === 0
+    ? 'no_results'
+    : pagesSucceeded === 0 || !combinedContent.length
+      ? 'no_content'
+      : 'success';
+
   return {
-    status: 'success',
+    status,
     query,
     language: searchResult.language,
     pagesFetched: fetched.length,
-    pagesSucceeded: fetched.filter(r => r.fetchStatus === 'success').length,
+    pagesSucceeded,
     combinedContentLength: combinedContent.length,
     pages: fetched.map(r => ({
       title: r.title,