hexo-theme-stellar 1.44.0 → 2.0.0-rc.2

package/source/js/runtime/legacy-request-adapter.js

@@ -0,0 +1,47 @@
+export function installLegacyRequestAdapter(utils, client, policy) {
+  if (!utils || typeof utils !== 'object') {
+    throw new TypeError('[stellar runtime] utils is required for the data-service adapter');
+  }
+  if (!policy || !Number.isInteger(policy.retries) || !(policy.timeoutMs > 0)) {
+    throw new TypeError('[stellar runtime] request policy is required for the data-service adapter');
+  }
+  const loaded = new WeakSet();
+
+  function serviceId(element, options) {
+    if (typeof options?.service === 'string' && options.service.length > 0) return options.service;
+    const match = String(element?.className || '').match(/\bds-([\w-]+)\b/);
+    return match?.[1] || null;
+  }
+
+  const request = function request(element, url, callback, onFailure, options = {}) {
+    if (element && loaded.has(element)) return Promise.resolve(null);
+    const requestOptions = Object.assign({ retries: policy.retries, timeout: policy.timeoutMs }, options, {
+      service: serviceId(element, options),
+      onNetworkStart: () => utils.onLoading?.(element)
+    });
+    return client.request(url, requestOptions).then(async response => {
+      if (element) loaded.add(element);
+      utils.onLoadSuccess?.(element);
+      await callback(response);
+      return response;
+    }).catch(error => {
+      utils.onLoadFailure?.(element);
+      onFailure?.(error);
+      throw error;
+    });
+  };
+
+  const requestWithoutLoading = function requestWithoutLoading(url, options = {}, maxRetry = policy.retries, timeout = policy.timeoutMs) {
+    return client.request(url, Object.assign({}, options, {
+      retries: maxRetry,
+      timeout
+    }));
+  };
+  utils.request = request;
+  utils.requestWithoutLoading = requestWithoutLoading;
+  const bridge = globalThis.__stellarRequestBridge;
+  if (bridge && typeof bridge.resolve === 'function') {
+    bridge.resolve(Object.freeze({ request, requestWithoutLoading }));
+    delete bridge.resolve;
+  }
+}

package/source/js/runtime/request-cache.js

@@ -0,0 +1,219 @@
+export const REQUEST_CACHE_PREFIX = 'Stellar.request-cache.v2.';
+
+function responseFrom(entry) {
+  return new Response(entry.text, {
+    status: 200,
+    statusText: 'OK',
+    headers: { 'Content-Type': entry.contentType || 'application/json' }
+  });
+}
+
+function requestKey(url, options) {
+  return `${options?.method || 'GET'} ${url}`;
+}
+
+function utf8Bytes(value) {
+  if (typeof TextEncoder === 'function') return new TextEncoder().encode(value).byteLength;
+  return value.length;
+}
+
+export function createRequestClient(options = {}) {
+  const policy = options.policy;
+  if (!policy || !Number.isInteger(policy.retries) || !(policy.timeoutMs > 0) || !(policy.idleTimeoutMs > 0) || !(policy.maxCacheEntryBytes > 0)) {
+    throw new TypeError('[stellar runtime] request policy is required');
+  }
+  const fetchImpl = options.fetch || globalThis.fetch?.bind(globalThis);
+  let storage = options.storage;
+  if (!storage) {
+    try { storage = globalThis.localStorage; } catch (error) { void error; storage = null; }
+  }
+  const now = options.clock || Date.now;
+  const schedule = options.scheduler || (fn => {
+    if (typeof globalThis.requestIdleCallback === 'function') {
+      globalThis.requestIdleCallback(fn, { timeout: policy.idleTimeoutMs });
+    } else {
+      setTimeout(fn, 0);
+    }
+  });
+  const dispatch = typeof options.dispatch === 'function' ? options.dispatch : () => {};
+  const config = options.cache;
+  if (!config || typeof config.enabled !== 'boolean' || !(config.defaultTtl >= 0) || !config.ttl || !(config.maxEntries >= 0)) {
+    throw new TypeError('[stellar runtime] cache policy is required');
+  }
+  const pending = new Map();
+  let cacheEnabled = config.enabled === true;
+
+  if (typeof fetchImpl !== 'function') throw new TypeError('[stellar runtime] fetch is required');
+
+  function serviceTtl(service) {
+    const value = service && config.ttl?.[service] != null ? config.ttl[service] : config.defaultTtl;
+    return typeof value === 'number' && value > 0 ? value : 0;
+  }
+
+  function shouldCache(url, requestOptions) {
+    if (!cacheEnabled || requestOptions.cache === false || requestOptions.cache === 'no-store') return false;
+    if ((requestOptions.method || 'GET') !== 'GET') return false;
+    return !/[?&]t=\d{10,}/.test(url);
+  }
+
+  function read(url) {
+    try {
+      const raw = storage?.getItem(REQUEST_CACHE_PREFIX + url);
+      if (!raw) return null;
+      const entry = JSON.parse(raw);
+      if (!entry || typeof entry.text !== 'string' || typeof entry.ts !== 'number' || typeof entry.ttl !== 'number') return null;
+      return entry;
+    } catch (error) {
+      void error;
+      return null;
+    }
+  }
+
+  function keys() {
+    const result = [];
+    if (!storage) return result;
+    try {
+      for (let index = 0; index < storage.length; index++) {
+        const key = storage.key(index);
+        if (key?.startsWith(REQUEST_CACHE_PREFIX)) result.push(key);
+      }
+    } catch (error) { void error; }
+    return result;
+  }
+
+  function clearCache() {
+    if (!storage) return Object.freeze({ ok: false, partial: false, removed: 0, failed: 1 });
+    try { void storage.length; } catch (error) {
+      void error;
+      return Object.freeze({ ok: false, partial: false, removed: 0, failed: 1 });
+    }
+    const targets = keys();
+    let removed = 0;
+    let failed = 0;
+    targets.forEach(key => {
+      try {
+        storage.removeItem(key);
+        removed++;
+      } catch (error) {
+        void error;
+        failed++;
+      }
+    });
+    return Object.freeze({ ok: failed === 0, partial: removed > 0 && failed > 0, removed, failed });
+  }
+
+  function evictOldest(exceptKey = '') {
+    const candidates = keys().filter(key => key !== exceptKey).map(key => {
+      let ts = 0;
+      try {
+        ts = JSON.parse(storage.getItem(key) || 'null')?.ts || 0;
+      } catch (error) {
+        void error;
+      }
+      return { key, ts };
+    }).sort((left, right) => left.ts - right.ts);
+    if (candidates[0]) storage.removeItem(candidates[0].key);
+  }
+
+  function trim() {
+    const all = keys().map(key => {
+      let ts = 0;
+      try {
+        ts = JSON.parse(storage.getItem(key) || 'null')?.ts || 0;
+      } catch (error) {
+        void error;
+      }
+      return { key, ts };
+    }).sort((left, right) => left.ts - right.ts);
+    while (all.length > config.maxEntries) storage.removeItem(all.shift().key);
+  }
+
+  function write(url, text, contentType, ttl) {
+    if (!storage || !(ttl > 0) || utf8Bytes(text) > policy.maxCacheEntryBytes) return;
+    const key = REQUEST_CACHE_PREFIX + url;
+    const value = JSON.stringify({ text, contentType, ts: now(), ttl });
+    try {
+      storage.setItem(key, value);
+      trim();
+    } catch (error) {
+      void error;
+      try {
+        evictOldest(key);
+        storage.setItem(key, value);
+        trim();
+      } catch (error) {
+        void error;
+        cacheEnabled = false;
+      }
+    }
+  }
+
+  function isFresh(entry) {
+    return !!entry && entry.ttl > 0 && now() - entry.ts < entry.ttl * 1000;
+  }
+
+  function sharedFetch(url, requestOptions, timeout) {
+    const key = requestKey(url, requestOptions);
+    if (pending.has(key)) return pending.get(key).then(response => response.clone());
+    dispatch('stellar:request-start', { key });
+    const controller = typeof AbortController === 'function' ? new AbortController() : null;
+    const timer = controller ? setTimeout(() => controller.abort(), timeout) : null;
+    const fetchOptions = Object.assign({}, requestOptions);
+    delete fetchOptions.service;
+    delete fetchOptions.retries;
+    delete fetchOptions.timeout;
+    delete fetchOptions.onNetworkStart;
+    if (fetchOptions.cache === false) delete fetchOptions.cache;
+    const callerSignal = fetchOptions.signal;
+    let removeCallerAbort = null;
+    if (controller) {
+      const abortFromCaller = () => controller.abort(callerSignal?.reason);
+      if (callerSignal?.aborted) abortFromCaller();
+      else if (callerSignal?.addEventListener) {
+        callerSignal.addEventListener('abort', abortFromCaller, { once: true });
+        removeCallerAbort = () => callerSignal.removeEventListener('abort', abortFromCaller);
+      }
+      fetchOptions.signal = controller.signal;
+    }
+    const promise = Promise.resolve(fetchImpl(url, fetchOptions)).then(response => {
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return response;
+    }).finally(() => {
+      if (timer !== null) clearTimeout(timer);
+      removeCallerAbort?.();
+      pending.delete(key);
+      dispatch('stellar:request-end', { key });
+    });
+    pending.set(key, promise);
+    return promise.then(response => response.clone());
+  }
+
+  async function request(url, requestOptions = {}) {
+    const ttl = serviceTtl(requestOptions.service);
+    const cacheable = shouldCache(url, requestOptions) && ttl > 0;
+    const cached = cacheable ? read(url) : null;
+    if (isFresh(cached)) return responseFrom(cached);
+    if (typeof requestOptions.onNetworkStart === 'function') requestOptions.onNetworkStart();
+
+    const retries = Number.isInteger(requestOptions.retries) ? requestOptions.retries : policy.retries;
+    const timeout = typeof requestOptions.timeout === 'number' ? requestOptions.timeout : policy.timeoutMs;
+    let error;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const response = await sharedFetch(url, requestOptions, timeout);
+        if (cacheable) {
+          const clone = response.clone();
+          const contentType = clone.headers.get('Content-Type') || 'application/json';
+          schedule(() => clone.text().then(text => write(url, text, contentType, ttl)).catch(() => {}));
+        }
+        return response;
+      } catch (caught) {
+        error = caught;
+      }
+    }
+    if (cached) return responseFrom(cached);
+    throw error;
+  }
+
+  return Object.freeze({ request, clearCache });
+}

package/source/js/search/algolia-search.js

@@ -1,13 +1,17 @@
-utils.js(window.searchConfig.js).then(() => {
-  var inputArea = document.querySelector("input#search-input");
-  if (!inputArea) {
-    return;
+(function() {
+  var roots = new WeakMap();
+  function mount(root) {
+  root = root || document;
+  if (roots.has(root)) return roots.get(root);
+  var searchWrappers = Array.from(root.querySelectorAll('.search-wrapper'));
+  if (searchWrappers.length === 0) {
+    return function () {};
   }
 
-  var resultArea = document.querySelector("#search-result");
-  var searchWrapper = document.querySelector("#search-wrapper");
   var client = algoliasearch(window.searchConfig.appId, window.searchConfig.apiKey);
   var index = client.initIndex(window.searchConfig.indexName);
+  var active = true;
+  var cleanups = [];
 
   function getCardHoverApi() {
     if (typeof stellar === 'undefined' || !stellar.cardHover) return null;
@@ -34,8 +38,8 @@ utils.js(window.searchConfig.js).then(() => {
     return hits.filter(hit => regex.test(hit.url));
   }
 
-  function displayResults(hits) {
-    var resultList = document.createElement("ul");
+  function displayResults(ownerDocument, searchWrapper, resultArea, hits) {
+    var resultList = ownerDocument.createElement("ul");
     resultList.classList.add("search-result-list", "ui-collection-adapter");
     if (hits.length === 0) {
       searchWrapper.classList.add('noresult');
@@ -44,16 +48,16 @@ utils.js(window.searchConfig.js).then(() => {
       hits.forEach(function(hit) {
         var contentSnippet = hit._snippetResult.content.value;
         var title = hit.hierarchy.lvl1 || 'Untitled';
-        var item = document.createElement("li");
-        var titleSpan = document.createElement("span");
+        var item = ownerDocument.createElement("li");
+        var titleSpan = ownerDocument.createElement("span");
         titleSpan.className = "search-result-title";
         titleSpan.textContent = title;
 
-        var link = document.createElement("a");
-        link.className = "card-hover card-hover--spotlight";
+        var link = ownerDocument.createElement("a");
+        link.className = ctx.ui.classes.interactiveSpotlight;
         link.href = hit.url;
 
-        var content = document.createElement("p");
+        var content = ownerDocument.createElement("p");
         content.className = "search-result-content";
         content.innerHTML = contentSnippet;
 
@@ -68,46 +72,67 @@ utils.js(window.searchConfig.js).then(() => {
     mountResultCards(resultList);
   }
 
-  inputArea.addEventListener("input", function() {
-    var query = inputArea.value.trim();
-    var filterPath = inputArea.getAttribute('data-filter');
+  searchWrappers.forEach(function(searchWrapper) {
+    var inputArea = searchWrapper.querySelector('.search-input');
+    var resultArea = searchWrapper.querySelector('.search-result');
+    if (!inputArea || !resultArea) return;
+    var ownerDocument = inputArea.ownerDocument || document;
+    var onInput = function() {
+      var query = inputArea.value.trim();
+      var filterPath = inputArea.getAttribute('data-algolia-filter-path');
+
+      if (query.length <= 0) {
+        searchWrapper.setAttribute('searching', 'false');
+        unmountResultCards(resultArea);
+        resultArea.replaceChildren();
+        return;
+      }
 
-    if (query.length <= 0) {
-      searchWrapper.setAttribute('searching', 'false');
+      searchWrapper.setAttribute('searching', 'true');
+
+      index.search(query, {
+        hitsPerPage: window.searchConfig.hitsPerPage,
+        attributesToHighlight: ['content'],
+        attributesToSnippet: ['content:30'],
+        highlightPreTag: '<span class="search-keyword">',
+        highlightPostTag: '</span>',
+        restrictSearchableAttributes: ['content']
+      }).then(function(responses) {
+        if (active) displayResults(ownerDocument, searchWrapper, resultArea, filterResults(responses.hits, filterPath));
+      });
+    };
+
+    var onKeydown = function(e) {
+      if (e.key == 'Enter') e.preventDefault();
+    };
+    inputArea.addEventListener("input", onInput);
+    inputArea.addEventListener("keydown", onKeydown);
+
+    var observer = new MutationObserver(function(mutationsList) {
+      if (mutationsList.length === 1) {
+        if (mutationsList[0].addedNodes.length) {
+          searchWrapper.classList.remove('noresult');
+        } else if (mutationsList[0].removedNodes.length) {
+          searchWrapper.classList.add('noresult');
+        }
+      }
+    });
+    observer.observe(resultArea, { childList: true });
+    cleanups.push(function() {
+      inputArea.removeEventListener("input", onInput);
+      inputArea.removeEventListener("keydown", onKeydown);
+      observer.disconnect();
       unmountResultCards(resultArea);
-      resultArea.replaceChildren();
-      return;
-    }
-
-    searchWrapper.setAttribute('searching', 'true');
-
-    index.search(query, {
-      hitsPerPage: window.searchConfig.hitsPerPage,
-      attributesToHighlight: ['content'],
-      attributesToSnippet: ['content:30'],
-      highlightPreTag: '<span class="search-keyword">',
-      highlightPostTag: '</span>',
-      restrictSearchableAttributes: ['content']
-    }).then(function(responses) {
-      displayResults(filterResults(responses.hits, filterPath));
     });
   });
 
-  inputArea.addEventListener("keydown", function(e) {
-    if (e.key == 'Enter') {
-      e.preventDefault();
-    }
-  });
-
-  var observer = new MutationObserver(function(mutationsList) {
-    if (mutationsList.length === 1) {
-      if (mutationsList[0].addedNodes.length) {
-        searchWrapper.classList.remove('noresult');
-      } else if (mutationsList[0].removedNodes.length) {
-        searchWrapper.classList.add('noresult');
-      }
-    }
-  });
-
-  observer.observe(resultArea, { childList: true });
-});
+  var cleanup = function() {
+    active = false;
+    cleanups.forEach(function(dispose) { dispose(); });
+    roots.delete(root);
+  };
+  roots.set(root, cleanup);
+  return cleanup;
+  }
+  window.stellarAlgoliaSearch = { mount: mount };
+})();

package/source/js/search/highlight.js

@@ -15,7 +15,7 @@
 
   function highlightKeyword() {
     // 优先主栏正文（避免命中 wiki 封面等其它 md-text 容器）
-    var root = document.querySelector('.l_main .md-text') || document.querySelector('.md-text');
+    var root = document.querySelector('.site-main .md-text') || document.querySelector('.md-text');
     if (!root) return;
 
     var re = new RegExp(escapeRegExp(keyword), 'gi');

package/source/js/search/local-search.js

@@ -1,6 +1,6 @@
 var searchCache = null;          // 当前可用的搜索数据（数组）
 var searchCacheEntry = null;     // 最近读取/写入的缓存条目 { ts, ttl, data }
-var searchCacheKey = 'search_cache_v4';
+var searchCacheKey = 'search_cache_v5';
 var searchFetchPromise = null;   // 单飞：同一时刻只允许一个请求
 
 var searchLazyLoad = true;
@@ -65,6 +65,18 @@ function loadCacheIntoMemory() {
   return searchCacheEntry;
 }
 
+function clearSearchCache() {
+  searchCache = null;
+  searchCacheEntry = null;
+  searchFetchPromise = null;
+  try {
+    localStorage.removeItem(searchCacheKey);
+    return { ok: true, partial: false, removed: 1, failed: 0 };
+  } catch (e) {
+    return { ok: false, partial: false, removed: 0, failed: 1 };
+  }
+}
+
 // 是否需要发起请求：不缓存 / 无缓存 / 缓存过期
 function needsFetch() {
   if (searchCacheTtl <= 0) return true;
@@ -96,10 +108,12 @@ function fetchSearchData(path) {
   return searchFetchPromise;
 }
 
-var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
-  var $input = document.getElementById(searchId);
+var searchFunc = function(path, wrapperId, searchId, contentId, root) {
+  root = root || document;
+  var $input = root.querySelector('#' + searchId);
   if (!$input || $input._searchInitialized === true) return;
   if ($input._searchInitialized === 'pending') return; // 数据加载中，等待完成后初始化
+  var ownerDocument = $input.ownerDocument || document;
 
   function getAllCombinations(keywords) {
     const result = [];
@@ -150,20 +164,20 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
 
   // 构建单条搜索结果 DOM
   function buildResultElement(dataTitle, sectionName, secText, secFirst, pairs, href) {
-    const li = document.createElement('li');
+    const li = ownerDocument.createElement('li');
 
     // 文章标题位于链接上方，不参与跳转
-    const titleSpan = document.createElement('span');
+    const titleSpan = ownerDocument.createElement('span');
     titleSpan.className = 'search-result-title';
     titleSpan.textContent = dataTitle;
     li.appendChild(titleSpan);
 
-    const a = document.createElement('a');
-    a.className = 'card-hover card-hover--spotlight';
+    const a = ownerDocument.createElement('a');
+    a.className = ctx.ui.classes.interactiveSpotlight;
     a.href = href;
 
     if (sectionName) {
-      const sectionSpan = document.createElement('span');
+      const sectionSpan = ownerDocument.createElement('span');
       sectionSpan.className = 'search-result-section';
       sectionSpan.textContent = sectionName;
       a.appendChild(sectionSpan);
@@ -180,7 +194,7 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
         return "<span class=\"search-keyword\">" + keyword + "</span>";
       });
 
-      const para = document.createElement('p');
+      const para = ownerDocument.createElement('p');
       para.className = 'search-result-content';
       para.innerHTML = matchContent + '...';
       a.appendChild(para);
@@ -195,10 +209,10 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
     if ($input._searchInitialized === true) return; // 防止重复绑定
     $input._searchInitialized = true;
 
-    var $resultContent = document.getElementById(contentId);
-    var $wrapper = document.getElementById(wrapperId);
+    var $resultContent = root.querySelector('#' + contentId);
+    var $wrapper = root.querySelector('#' + wrapperId);
 
-    $input.addEventListener("input", function() {
+    var onInput = function() {
       var rawValue = this.value.trim();
       unmountResultCards($resultContent);
       $resultContent.innerHTML = "";
@@ -211,10 +225,11 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
       var pairs = buildKeywordPairs(this.value);
       var resultList = [];
 
-      // 读取模块级 searchCache：后台刷新后即时生效
+      // 读取模块级 searchCache：后台刷新后即时生效；搜索域由每次打开浮层的入口更新。
+      var activeDomain = this.getAttribute('data-domain') || '';
       (searchCache || []).forEach(function(data) {
         if (!data.content?.trim().length) return;
-        if (filter && !data.path.includes(filter)) return;
+        if (activeDomain && !data.domains?.includes(activeDomain)) return;
 
         var dataTitle = data.title?.trim() || 'Untitled';
         var dataTitleLowerCase = dataTitle.toLowerCase();
@@ -296,7 +311,7 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
           return b.rank - a.rank || a.offset - b.offset;
         });
 
-        const ul = document.createElement('ul');
+        const ul = ownerDocument.createElement('ul');
         ul.className = 'search-result-list ui-collection-adapter';
         resultList.forEach(function(item) {
           ul.appendChild(item.element);
@@ -306,13 +321,21 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
         $resultContent.appendChild(ul);
         mountResultCards(ul);
       }
-    });
+    };
 
-    $input.addEventListener("keydown", function(e) {
+    var onKeydown = function(e) {
       if (e.key == 'Enter') {
         e.preventDefault();
       }
-    });
+    };
+    $input.addEventListener("input", onInput);
+    $input.addEventListener("keydown", onKeydown);
+    $input._searchCleanup = function() {
+      $input.removeEventListener("input", onInput);
+      $input.removeEventListener("keydown", onKeydown);
+      $input._searchInitialized = undefined;
+      $input._searchCleanup = undefined;
+    };
 
     // 同步当前状态：已有文字立即执行一次搜索，否则清除加载态
     if ($input.value && $input.value.trim().length > 0) {
@@ -345,7 +368,7 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
       if ($input._searchInitialized === 'pending') {
         $input._searchInitialized = undefined; // 允许下次聚焦重试
       }
-      var $wrapper = document.getElementById(wrapperId);
+      var $wrapper = root.querySelector('#' + wrapperId);
       if ($wrapper) $wrapper.setAttribute('searching', 'false');
     });
 };
@@ -359,43 +382,59 @@ var searchFunc = function(path, filter, wrapperId, searchId, contentId) {
 })();
 
 // 聚焦触发：懒加载模式下首次聚焦搜索框才加载数据
-document.addEventListener("focusin", function(e) {
-  var input = e.target;
-  if (!input || input.id !== 'search-input') return;
-  var path = getSearchPath();
-  var filter = input.getAttribute('data-filter') || '';
-
-  // 已初始化：仅按需后台刷新（刷新失败下次聚焦自动重试）
-  if (input._searchInitialized === true) {
-    if (needsFetch()) {
-      fetchSearchData(path).catch(function() {});
+var localSearchRoots = new WeakMap();
+
+function mountLocalSearch(root) {
+  root = root || document;
+  if (localSearchRoots.has(root)) return localSearchRoots.get(root);
+  var wrappers = Array.from(root.querySelectorAll('.search-wrapper'));
+  var observers = [];
+  var onFocus = function(e) {
+    var input = e.target;
+    if (!input || !input.classList?.contains('search-input')) return;
+    var wrapper = input.closest('.search-wrapper');
+    if (!wrapper) return;
+    var resultArea = wrapper.querySelector('.search-result');
+    if (!resultArea) return;
+    var path = getSearchPath();
+    if (input._searchInitialized === true) {
+      if (needsFetch()) fetchSearchData(path).catch(function() {});
+      return;
+    }
+    if (searchLazyLoad && !searchCache && !loadCacheIntoMemory()) {
+      wrapper.setAttribute('searching', 'true');
+    }
+    searchFunc(path, wrapper.id, input.id, resultArea.id, root);
+    if (searchCache && needsFetch()) fetchSearchData(path).catch(function() {});
+  };
+  root.addEventListener("focusin", onFocus);
+  wrappers.forEach(function(wrapper) {
+    var resultArea = wrapper.querySelector('.search-result');
+    var input = wrapper.querySelector('.search-input');
+    if (!resultArea || !input) return;
+    var observer = new MutationObserver(function() {
+      var hasResults = resultArea.querySelector(".search-result-list li");
+      wrapper.classList.toggle('noresult', !hasResults);
+    });
+    observer.observe(resultArea, { childList: true, subtree: true });
+    observers.push(observer);
+    if (!searchLazyLoad && input._searchInitialized !== true) {
+      searchFunc(getSearchPath(), wrapper.id, input.id, resultArea.id, root);
     }
-    return;
-  }
-
-  // 懒加载：无可用数据时显示加载态（复用 searching 绿色图标状态）
-  if (searchLazyLoad && !searchCache && !loadCacheIntoMemory()) {
-    var $wrapper = document.getElementById('search-wrapper');
-    if ($wrapper) $wrapper.setAttribute('searching', 'true');
-  }
-
-  searchFunc(path, filter, 'search-wrapper', 'search-input', 'search-result');
-
-  // 有数据但已过期（或 ttl=0）→ 后台刷新
-  if (searchCache && needsFetch()) {
-    fetchSearchData(path).catch(function() {});
-  }
-});
-
-// 无结果/有结果状态兜底
-(function() {
-  var resultArea = document.querySelector("div#search-result");
-  if (!resultArea) return;
-
-  var observer = new MutationObserver(function(mutationsList) {
-    var hasResults = resultArea.querySelector(".search-result-list li");
-    var wrapper = document.querySelector('.search-wrapper');
-    if (wrapper) wrapper.classList.toggle('noresult', !hasResults);
   });
-  observer.observe(resultArea, { childList: true, subtree: true });
-})();
+  var cleanup = function() {
+    root.removeEventListener("focusin", onFocus);
+    observers.forEach(function(observer) { observer.disconnect(); });
+    wrappers.forEach(function(wrapper) {
+      var input = wrapper.querySelector('.search-input');
+      if (!input) return;
+      input._searchCleanup?.();
+      input._searchInitialized = undefined;
+    });
+    localSearchRoots.delete(root);
+  };
+  localSearchRoots.set(root, cleanup);
+  return cleanup;
+}
+
+window.stellarLocalSearch = { mount: mountLocalSearch, clearCache: clearSearchCache };