@yunfie/search-js 1.0.0

package/src/cache/persistent.ts

@@ -0,0 +1,106 @@
+// src/cache/persistent.ts
+import { getConfig } from "../config.js";
+
+let _dbPromise: Promise<IDBDatabase | null> | null = null;
+
+function _open(): Promise<IDBDatabase | null> {
+  if (typeof globalThis.indexedDB === "undefined") return Promise.resolve(null);
+  if (_dbPromise) return _dbPromise;
+
+  _dbPromise = new Promise<IDBDatabase | null>((resolve) => {
+    const req = indexedDB.open("ApiCache", 2);
+    req.onerror = () => { console.warn("IndexedDB unavailable"); resolve(null); };
+    req.onsuccess = () => resolve(req.result);
+    req.onupgradeneeded = (e: IDBVersionChangeEvent) => {
+      const db = (e.target as IDBOpenDBRequest).result;
+      if (!db.objectStoreNames.contains("cache")) {
+        db.createObjectStore("cache").createIndex("time", "time");
+      }
+    };
+  });
+
+  return _dbPromise;
+}
+
+export async function getP(key: string): Promise<unknown> {
+  const db = await _open();
+  if (!db) return null;
+
+  return new Promise<unknown>((resolve) => {
+    const req = db
+      .transaction(["cache"], "readonly")
+      .objectStore("cache")
+      .get(key);
+    req.onsuccess = () => {
+      const item = req.result as { time: number; data: unknown } | undefined;
+      resolve(
+        item && Date.now() - item.time < getConfig().CACHE_TTL ? item.data : null
+      );
+    };
+    req.onerror = () => resolve(null);
+  });
+}
+
+export async function setP(key: string, data: unknown): Promise<void> {
+  const db = await _open();
+  if (!db) return;
+
+  const cfg = getConfig();
+  return new Promise<void>((resolve, reject) => {
+    const tx = db.transaction(["cache"], "readwrite");
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+
+    const objectStore = tx.objectStore("cache");
+    const countReq = objectStore.count();
+
+    countReq.onsuccess = () => {
+      if (countReq.result >= cfg.PERSISTENT_CACHE_MAX) {
+        const maxDel = Math.ceil(cfg.PERSISTENT_CACHE_MAX * 0.2);
+        const cur = objectStore.index("time").openCursor(IDBKeyRange.lowerBound(0));
+        let deleted = 0;
+        cur.onsuccess = (e: Event) => {
+          const c = (e.target as IDBRequest<IDBCursorWithValue | null>).result;
+          if (c && deleted < maxDel) {
+            c.delete(); deleted++; c.continue();
+          } else {
+            objectStore.put({ data, time: Date.now() }, key);
+            resolve();
+          }
+        };
+        cur.onerror = () => reject(cur.error);
+      } else {
+        objectStore.put({ data, time: Date.now() }, key);
+        tx.oncomplete = () => resolve();
+      }
+    };
+    countReq.onerror = () => reject(countReq.error);
+  });
+}
+
+export async function cleanup(): Promise<void> {
+  const db = await _open();
+  if (!db) return;
+  const cfg = getConfig();
+  const cutoff = Date.now() - cfg.CACHE_TTL;
+
+  return new Promise<void>((resolve) => {
+    const req = db
+      .transaction(["cache"], "readwrite")
+      .objectStore("cache")
+      .index("time")
+      .openCursor(IDBKeyRange.upperBound(cutoff));
+    req.onsuccess = (e: Event) => {
+      const c = (e.target as IDBRequest<IDBCursorWithValue | null>).result;
+      if (c) { c.delete(); c.continue(); }
+      else resolve();
+    };
+    req.onerror = () => resolve();
+  });
+}
+
+export async function destroyDB(): Promise<void> {
+  const db = await _open();
+  db?.close();
+  _dbPromise = null;
+}

package/src/config.ts

@@ -0,0 +1,53 @@
+// src/config.ts
+
+export interface Config {
+  API_BASE: string;
+  CACHE_TTL: number;
+  CACHE_MAX: number;
+  CACHE_LOW_MEMORY: number;
+  MEMORY_PRESSURE_NORMAL: number;
+  MEMORY_PRESSURE_CRITICAL: number;
+  STRINGIFY_SIZE_THRESHOLD: number;
+  TIMEOUT: number;
+  RETRIES: number;
+  RETRY_BACKOFF_BASE: number;
+  MAX_CONCURRENT_REQUESTS: number;
+  MAX_CONCURRENT_LOW_MEMORY: number;
+  STREAMING_BUFFER_SIZE: number;
+  PERSISTENT_CACHE_MAX: number;
+  PERSISTENT_CLEANUP_INTERVAL: number;
+  MEMORY_CHECK_INTERVAL: number;
+  SUGGEST_TTL: number;
+  SUGGEST_DEBOUNCE_MS: number;
+}
+
+export const defaults: Config = {
+  API_BASE: "https://api.wholphin.net",
+  CACHE_TTL: 1000 * 60 * 5,
+  CACHE_MAX: 30,
+  CACHE_LOW_MEMORY: 10,
+  MEMORY_PRESSURE_NORMAL: 0.65,
+  MEMORY_PRESSURE_CRITICAL: 0.80,
+  STRINGIFY_SIZE_THRESHOLD: 1024 * 10,
+  TIMEOUT: 8000,
+  RETRIES: 3,
+  RETRY_BACKOFF_BASE: 1000,
+  MAX_CONCURRENT_REQUESTS: 6,
+  MAX_CONCURRENT_LOW_MEMORY: 2,
+  STREAMING_BUFFER_SIZE: 1024 * 10,
+  PERSISTENT_CACHE_MAX: 500,
+  PERSISTENT_CLEANUP_INTERVAL: 1000 * 60 * 30,
+  MEMORY_CHECK_INTERVAL: 1000 * 60,
+  SUGGEST_TTL: 1000 * 30,
+  SUGGEST_DEBOUNCE_MS: 200,
+};
+
+let _config: Config = { ...defaults };
+
+export function configure(overrides: Partial<Config> = {}): void {
+  _config = { ...defaults, ...overrides };
+}
+
+export function getConfig(): Config {
+  return _config;
+}

package/src/events.ts

@@ -0,0 +1,57 @@
+// src/events.ts
+
+export type SearchEventMap = {
+  memoryStateChange: { isLow: boolean; isCritical: boolean };
+  online: undefined;
+  offline: undefined;
+  cacheRefreshed: { key: string };
+};
+
+type Handler<T> = T extends undefined ? () => void : (payload: T) => void;
+
+type Listeners = {
+  [K in keyof SearchEventMap]: Set<Handler<SearchEventMap[K]>>;
+};
+
+const _listeners: Listeners = {
+  memoryStateChange: new Set(),
+  online: new Set(),
+  offline: new Set(),
+  cacheRefreshed: new Set(),
+};
+
+export function on<K extends keyof SearchEventMap>(
+  event: K,
+  handler: Handler<SearchEventMap[K]>
+): () => void {
+  (_listeners[event] as Set<Handler<SearchEventMap[K]>>).add(handler);
+  return () => off(event, handler);
+}
+
+export function off<K extends keyof SearchEventMap>(
+  event: K,
+  handler: Handler<SearchEventMap[K]>
+): void {
+  (_listeners[event] as Set<Handler<SearchEventMap[K]>>).delete(handler);
+}
+
+export function emit<K extends keyof SearchEventMap>(
+  event: K,
+  ...args: SearchEventMap[K] extends undefined ? [] : [SearchEventMap[K]]
+): void {
+  const set = _listeners[event] as Set<Handler<SearchEventMap[K]>>;
+  for (const fn of [...set]) {
+    try {
+      // @ts-expect-error payload is type-safe but TS can't follow the union
+      fn(...args);
+    } catch (e) {
+      console.error("[search-js] event handler error:", e);
+    }
+  }
+}
+
+export function clearAllListeners(): void {
+  for (const key of Object.keys(_listeners) as (keyof SearchEventMap)[]) {
+    (_listeners[key] as Set<unknown>).clear();
+  }
+}

package/src/history.ts

@@ -0,0 +1,70 @@
+// src/history.ts
+
+const STORAGE_KEY = "__search_js_history__";
+const MAX_HISTORY = 20;
+
+export interface HistoryEntry {
+  q: string;
+  type: string;
+  time: number;
+}
+
+function _isAvailable(): boolean {
+  try { return typeof localStorage !== "undefined"; }
+  catch { return false; }
+}
+
+function _load(): HistoryEntry[] {
+  if (!_isAvailable()) return [];
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    return raw ? (JSON.parse(raw) as HistoryEntry[]) : [];
+  } catch { return []; }
+}
+
+function _save(entries: HistoryEntry[]): void {
+  if (!_isAvailable()) return;
+  try { localStorage.setItem(STORAGE_KEY, JSON.stringify(entries)); }
+  catch { /* quota exceeded */ }
+}
+
+export function addHistory(q: string, type = "web"): void {
+  if (!q.trim()) return;
+  const entries = _load().filter(
+    (e) => !(e.q.toLowerCase() === q.trim().toLowerCase() && e.type === type)
+  );
+  entries.unshift({ q: q.trim(), type, time: Date.now() });
+  _save(entries.slice(0, MAX_HISTORY));
+}
+
+export function getHistory(prefix?: string): HistoryEntry[] {
+  const entries = _load();
+  if (!prefix) return entries;
+  const lower = prefix.trim().toLowerCase();
+  return entries.filter((e) => e.q.toLowerCase().startsWith(lower));
+}
+
+export function removeHistory(q: string, type = "web"): void {
+  _save(
+    _load().filter(
+      (e) => !(e.q.toLowerCase() === q.trim().toLowerCase() && e.type === type)
+    )
+  );
+}
+
+export function clearHistory(): void {
+  if (_isAvailable()) localStorage.removeItem(STORAGE_KEY);
+}
+
+export function mergeWithHistory(
+  q: string,
+  suggestItems: { title: string }[]
+): { title: string; fromHistory: boolean }[] {
+  const histEntries = getHistory(q);
+  const histSet = new Set(histEntries.map((e) => e.q.toLowerCase()));
+  const histResults = histEntries.map((e) => ({ title: e.q, fromHistory: true as const }));
+  const filtered = suggestItems
+    .filter((s) => !histSet.has(s.title.toLowerCase()))
+    .map((s) => ({ title: s.title, fromHistory: false as const }));
+  return [...histResults, ...filtered];
+}

package/src/index.ts

@@ -0,0 +1,307 @@
+// src/index.ts
+import { configure, getConfig, type Config } from "./config.js";
+import { store as memStore, clearStore, evictExpired, trimToHalf } from "./cache/memory.js";
+import { getCacheKey, get as memGet, set as memSet } from "./cache/memory.js";
+import { getP, setP, cleanup, destroyDB } from "./cache/persistent.js";
+import { initMemoryMonitor, getIsLowMemory, getIsCriticalMemory, getCurrentCacheMax, destroyMemoryMonitor } from "./memory.js";
+import { enqueue, Priority, clearQueues, type PriorityValue } from "./request/queue.js";
+import { fetchWithRetry, cancel as cancelRequest, cancelAll, type FetchResult } from "./request/retry.js";
+import { debounce } from "./utils.js";
+import {
+  extractMeta, extractDetail,
+  type ResultMeta, type ResultDetail, type ParsedResponse,
+} from "./parser.js";
+import {
+  getSuggest as _getSuggest,
+  getSuggestDebounced,
+  clearSuggestCache,
+  type SuggestItem,
+  type SuggestResult,
+} from "./suggest.js";
+import { on, off, emit, clearAllListeners, type SearchEventMap } from "./events.js";
+import { addHistory, getHistory, removeHistory, clearHistory, mergeWithHistory, type HistoryEntry } from "./history.js";
+import { initOfflineMonitor, destroyOfflineMonitor, getIsOnline, addRetryTask } from "./offline.js";
+
+export {
+  configure, debounce,
+  cancelRequest, cancelAll,
+  getSuggestDebounced,
+  on, off,
+  addHistory, getHistory, removeHistory, clearHistory, mergeWithHistory,
+  getIsOnline,
+};
+export type {
+  Config, FetchResult,
+  ResultMeta, ResultDetail, ParsedResponse,
+  SuggestItem, SuggestResult,
+  SearchEventMap, HistoryEntry,
+};
+
+export type SearchType = "web" | "image" | "video" | "news" | "panel";
+
+const HEAVY_TYPES: ReadonlySet<SearchType> = new Set(["image", "video"]);
+
+export interface SearchOptions {
+  q: string;
+  page?: number;
+  type?: SearchType;
+  safesearch?: 0 | 1 | 2;
+  lang?: string;
+  enableStreaming?: boolean;
+  onChunk?: (chunk: unknown) => void;
+  usePersistentCache?: boolean;
+  metaOnly?: boolean;
+  signal?: AbortSignal;
+}
+
+export interface RequestOptions {
+  useCache?: boolean;
+  priority?: PriorityValue;
+  onChunk?: ((chunk: unknown) => void) | null;
+  usePersistentCache?: boolean;
+  signal?: AbortSignal;
+}
+
+export interface SearchStats {
+  memoryCacheSize: number;
+  memoryCacheMax: number;
+  isLowMemory: boolean;
+  isCriticalMemory: boolean;
+  inFlightCount: number;
+  isOnline: boolean;
+}
+
+export function getSearchStats(): SearchStats {
+  return {
+    memoryCacheSize:  memStore.size,
+    memoryCacheMax:   getCurrentCacheMax(),
+    isLowMemory:      getIsLowMemory(),
+    isCriticalMemory: getIsCriticalMemory(),
+    inFlightCount:    inFlight.size,
+    isOnline:         getIsOnline(),
+  };
+}
+
+let _cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+export function init(options: Partial<Config> = {}): void {
+  configure(options);
+  initMemoryMonitor(memStore);
+  initOfflineMonitor();
+  if (_cleanupTimer !== null) clearInterval(_cleanupTimer);
+  _cleanupTimer = setInterval(cleanup, getConfig().PERSISTENT_CLEANUP_INTERVAL);
+}
+
+export async function destroy(): Promise<void> {
+  cancelAll();
+  clearQueues();
+  inFlight.clear();
+  clearStore();
+  clearSuggestCache();
+  clearAllListeners();
+  destroyOfflineMonitor();
+  await destroyDB();
+  destroyMemoryMonitor();
+  if (_cleanupTimer !== null) {
+    clearInterval(_cleanupTimer);
+    _cleanupTimer = null;
+  }
+}
+
+const inFlight = new Map<string, Promise<FetchResult>>();
+
+function _requestKey(endpoint: string, params: Record<string, unknown>): string {
+  const p = params as { q?: string; page?: number; type?: string };
+  return endpoint + "\x00" + (p.q ?? "") + "\x00" + (p.page ?? 1) + "\x00" + (p.type ?? "web");
+}
+
+async function request(
+  endpoint: string,
+  params: Record<string, unknown> = {},
+  {
+    useCache = true,
+    priority = Priority.NORMAL,
+    onChunk,
+    usePersistentCache = false,
+    signal,
+  }: RequestOptions = {}
+): Promise<FetchResult> {
+  const cfg    = getConfig();
+  const lowMem = getIsLowMemory();
+  const offline = !getIsOnline();
+
+  if (getIsCriticalMemory()) { evictExpired(); trimToHalf(); }
+  else if (lowMem) { evictExpired(); }
+
+  const url = new URL(cfg.API_BASE + endpoint);
+  for (const k in params) {
+    const v = params[k];
+    if (v != null) url.searchParams.append(k, String(v));
+  }
+
+  const cacheKey = getCacheKey(endpoint, params);
+  const reqKey   = _requestKey(endpoint, params);
+
+  if (useCache) {
+    const hit = memGet(cacheKey);
+    if (hit) {
+      if (hit.expired && !lowMem && !offline) {
+        enqueue(async () => {
+          const r = await fetchWithRetry(url.toString(), _fetchOpts, reqKey);
+          if (r.ok) {
+            memSet(cacheKey, r.data);
+            if (usePersistentCache) await setP(cacheKey, r.data);
+            emit("cacheRefreshed", { key: cacheKey });
+          }
+        }, priority);
+      }
+      return { ok: true, data: hit.data, cached: true, stale: hit.expired };
+    }
+    if (usePersistentCache) {
+      const pData = await getP(cacheKey);
+      if (pData) {
+        if (!lowMem) memSet(cacheKey, pData);
+        return { ok: true, data: pData, cached: true, persistent: true };
+      }
+    }
+  }
+
+  if (offline) return { ok: false, error: "offline" };
+  if (signal?.aborted) return { ok: false, error: "cancelled" };
+
+  const existing = inFlight.get(reqKey);
+  if (existing) return existing;
+
+  const fetchOpts: RequestInit = signal ? { ..._fetchOpts, signal } : _fetchOpts;
+
+  const promise = new Promise<FetchResult>((resolve) => {
+    const onAbort = (): void => resolve({ ok: false, error: "cancelled" });
+    signal?.addEventListener("abort", onAbort, { once: true });
+
+    enqueue(async () => {
+      signal?.removeEventListener("abort", onAbort);
+      if (signal?.aborted) { resolve({ ok: false, error: "cancelled" }); return; }
+      try {
+        const result = await fetchWithRetry(url.toString(), fetchOpts, reqKey, onChunk ?? undefined);
+        if (result.ok && useCache && !result.streamed) {
+          if (!lowMem) memSet(cacheKey, result.data);
+          if (usePersistentCache) await setP(cacheKey, result.data);
+        }
+        if (!result.ok && result.error === "network_error") {
+          addRetryTask(async () => {
+            const r = await fetchWithRetry(url.toString(), _fetchOpts, reqKey);
+            if (r.ok) {
+              if (!lowMem) memSet(cacheKey, r.data);
+              if (usePersistentCache) await setP(cacheKey, r.data);
+            }
+          });
+        }
+        resolve(result);
+      } catch (e) {
+        resolve({ ok: false, error: e instanceof Error ? e.message : "unknown_error" });
+      } finally {
+        inFlight.delete(reqKey);
+      }
+    }, priority);
+  });
+
+  inFlight.set(reqKey, promise);
+  return promise;
+}
+
+const _fetchOpts: RequestInit = Object.freeze({
+  method: "GET",
+  headers: Object.freeze({ Accept: "application/json" }),
+});
+
+function _prefetch(endpoint: string, params: Record<string, unknown>): void {
+  if (getIsLowMemory() || !getIsOnline()) return;
+  const cacheKey = getCacheKey(endpoint, params);
+  const hit = memGet(cacheKey);
+  if (hit && !hit.expired) return;
+  if (inFlight.has(_requestKey(endpoint, params))) return;
+  request(endpoint, params, { priority: Priority.LOW }).catch(() => {});
+}
+
+export async function search({
+  q, page = 1, type = "web", safesearch = 0, lang = "ja",
+  enableStreaming = false, onChunk, usePersistentCache = false, metaOnly = false, signal,
+}: SearchOptions): Promise<FetchResult> {
+  if (!q?.trim()) return { ok: false, error: "empty_query" };
+  const lowMem     = getIsLowMemory();
+  const isHeavy    = HEAVY_TYPES.has(type);
+  const forceStream = isHeavy && lowMem;
+  const params = { q: q.trim(), page, type, safesearch, lang };
+  if (page < 10 && !lowMem) _prefetch("/search", { ...params, page: page + 1 });
+  if (forceStream || (enableStreaming && onChunk)) {
+    return request("/search", params, { priority: Priority.NORMAL, onChunk: onChunk ?? undefined, usePersistentCache, signal });
+  }
+  const result = await request("/search", params, { priority: Priority.NORMAL, onChunk: null, usePersistentCache, signal });
+  if (!result.ok) return result;
+  if (isHeavy || metaOnly || lowMem) {
+    return { ...result, data: extractMeta(result.data, type, lowMem) };
+  }
+  return result;
+}
+
+export function searchMeta(opts: Omit<SearchOptions, "metaOnly" | "enableStreaming" | "onChunk">): Promise<FetchResult> {
+  return search({ ...opts, metaOnly: true });
+}
+
+export async function fetchDetail(
+  opts: Omit<SearchOptions, "metaOnly" | "enableStreaming" | "onChunk">,
+  idx: number
+): Promise<ResultDetail | null> {
+  const { q, page = 1, type = "web", safesearch = 0, lang = "ja", usePersistentCache = false } = opts;
+  if (!q?.trim()) return null;
+  const params   = { q: q.trim(), page, type, safesearch, lang };
+  const cacheKey = getCacheKey("/search", params);
+  const hit = memGet(cacheKey);
+  if (hit) return extractDetail(hit.data, idx);
+  if (usePersistentCache) {
+    const pData = await getP(cacheKey);
+    if (pData) return extractDetail(pData, idx);
+  }
+  const result = await request("/search", params, { priority: Priority.NORMAL, usePersistentCache });
+  return result.ok ? extractDetail(result.data, idx) : null;
+}
+
+export function getSuggest(q: string): Promise<SuggestResult> { return _getSuggest(q); }
+
+export interface Pager {
+  next(): Promise<FetchResult | null>;
+  prev(): Promise<FetchResult | null>;
+  readonly currentPage: number;
+  reset(): void;
+}
+
+export function createPager(opts: Omit<SearchOptions, "page">, maxPage = 10): Pager {
+  let _page = 0;
+  return {
+    get currentPage() { return _page; },
+    async next() { if (_page >= maxPage) return null; _page++; return search({ ...opts, page: _page }); },
+    async prev() { if (_page <= 1) return null; _page--; return search({ ...opts, page: _page }); },
+    reset() { _page = 0; },
+  };
+}
+
+export type SearchAllResult = Partial<Record<SearchType, FetchResult>>;
+
+export async function searchAll(
+  opts: Omit<SearchOptions, "type">,
+  types: SearchType[] = ["web", "news"]
+): Promise<SearchAllResult> {
+  const entries = await Promise.allSettled(types.map((type) => search({ ...opts, type })));
+  const result: SearchAllResult = {};
+  for (let i = 0; i < types.length; i++) {
+    const s = entries[i];
+    if (s.status === "fulfilled" && s.value.ok) result[types[i]] = s.value;
+  }
+  return result;
+}
+
+export const searchWeb   = (q: string, page = 1, signal?: AbortSignal): Promise<FetchResult> => search({ q, page, type: "web",   signal });
+export const searchImage = (q: string, page = 1, signal?: AbortSignal): Promise<FetchResult> => search({ q, page, type: "image", signal });
+export const searchVideo = (q: string, page = 1, signal?: AbortSignal): Promise<FetchResult> => search({ q, page, type: "video", signal });
+export const searchNews  = (q: string, page = 1, signal?: AbortSignal): Promise<FetchResult> => search({ q, page, type: "news",  signal });
+export const searchPanel = (q: string,            signal?: AbortSignal): Promise<FetchResult> => search({ q,       type: "panel", signal });

package/src/memory.ts

@@ -0,0 +1,101 @@
+// src/memory.ts
+import { getConfig } from "./config.js";
+import { emit } from "./events.js";
+
+interface Capabilities {
+  performanceMemory: boolean;
+  deviceMemory: boolean;
+}
+
+const capabilities: Capabilities = {
+  performanceMemory:
+    typeof performance !== "undefined" &&
+    !!(performance as Performance & { memory?: unknown }).memory,
+  deviceMemory:
+    typeof navigator !== "undefined" &&
+    typeof (navigator as Navigator & { deviceMemory?: number }).deviceMemory === "number",
+};
+
+let isLowMemory = false;
+let isCriticalMemory = false;
+let currentCacheMax = 0;
+let _monitorTimer: ReturnType<typeof setInterval> | null = null;
+
+export const getIsLowMemory = (): boolean => isLowMemory;
+export const getIsCriticalMemory = (): boolean => isCriticalMemory;
+export const getCurrentCacheMax = (): number => currentCacheMax;
+
+export function initMemoryMonitor(cacheRef: Map<unknown, unknown>): void {
+  if (_monitorTimer !== null) {
+    clearInterval(_monitorTimer);
+    _monitorTimer = null;
+  }
+
+  const cfg = getConfig();
+  currentCacheMax = cfg.CACHE_MAX;
+
+  const nav = navigator as Navigator & { deviceMemory?: number };
+  if (capabilities.deviceMemory && nav.deviceMemory !== undefined && nav.deviceMemory <= 2) {
+    currentCacheMax = cfg.CACHE_LOW_MEMORY;
+  }
+
+  _monitorTimer = setInterval(() => _check(cacheRef), cfg.MEMORY_CHECK_INTERVAL);
+}
+
+export function destroyMemoryMonitor(): void {
+  if (_monitorTimer !== null) {
+    clearInterval(_monitorTimer);
+    _monitorTimer = null;
+  }
+  isLowMemory = false;
+  isCriticalMemory = false;
+}
+
+function _check(cacheRef: Map<unknown, unknown>): void {
+  const cfg = getConfig();
+  let pressure = 0;
+
+  if (capabilities.performanceMemory) {
+    const mem = (performance as Performance & {
+      memory: { usedJSHeapSize: number; jsHeapSizeLimit: number };
+    }).memory;
+    pressure = Math.max(pressure, (mem.usedJSHeapSize / mem.jsHeapSizeLimit) * 100);
+  }
+
+  if (cacheRef.size > currentCacheMax * 0.85) {
+    pressure = Math.max(pressure, 65);
+  }
+
+  const prevLow      = isLowMemory;
+  const prevCritical = isCriticalMemory;
+
+  const normalThreshold   = cfg.MEMORY_PRESSURE_NORMAL * 100;
+  const criticalThreshold = cfg.MEMORY_PRESSURE_CRITICAL * 100;
+
+  isCriticalMemory = pressure > criticalThreshold;
+  isLowMemory      = pressure > normalThreshold;
+
+  if (isLowMemory !== prevLow || isCriticalMemory !== prevCritical) {
+    emit("memoryStateChange", { isLow: isLowMemory, isCritical: isCriticalMemory });
+  }
+
+  if (isLowMemory) {
+    const target = isCriticalMemory
+      ? Math.ceil(cfg.CACHE_LOW_MEMORY * 0.5)
+      : cfg.CACHE_LOW_MEMORY;
+    if (currentCacheMax > target) {
+      _trimCache(cacheRef, target);
+      currentCacheMax = target;
+    }
+  } else if (!isLowMemory && prevLow) {
+    currentCacheMax = Math.min(cfg.CACHE_MAX, Math.ceil(currentCacheMax * 1.5));
+  }
+}
+
+function _trimCache(cacheRef: Map<unknown, unknown>, maxSize: number): void {
+  while (cacheRef.size > maxSize) {
+    const firstKey = cacheRef.keys().next().value;
+    if (firstKey !== undefined) cacheRef.delete(firstKey);
+    else break;
+  }
+}