@katlux/providers 0.1.1-alpha.100 → 0.1.1-alpha.101

package/dist/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-const index = require('./shared/providers.CxZeMH3Y.cjs');
 const ofetch = require('ofetch');
 const h3 = require('h3');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 var EDataFilterOperator = /* @__PURE__ */ ((EDataFilterOperator2) => {
   EDataFilterOperator2["Equal"] = "==";
   EDataFilterOperator2["NotEqual"] = "!=";
@@ -37,36 +37,213 @@ var EQueueStorage = /* @__PURE__ */ ((EQueueStorage2) => {
 
 const useDebounce = (callback, delay) => {
   let timeoutId = null;
-  return function(...args) {
+  const debounced = function(...args) {
     if (timeoutId !== null) {
       clearTimeout(timeoutId);
     }
     timeoutId = setTimeout(() => {
+      timeoutId = null;
       callback.apply(this, args);
     }, delay);
   };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
 };
 const debounce = useDebounce;
 
+class DefaultHydrationAdapter {
+  getSSRData(key, context) {
+    const contextData = context?.payload?.data?.[key] ?? context?.ssrContext?.payload?.data?.[key];
+    if (contextData !== void 0 && contextData !== null) {
+      return contextData;
+    }
+    if (typeof window !== "undefined") {
+      const win = window;
+      const clientData = win.__KATLUX_DATA__?.[key] ?? win.__SSR_DATA__?.[key] ?? win.__INITIAL_DATA__?.[key] ?? win.__NEXT_DATA__?.props?.pageProps?.[key];
+      if (clientData !== void 0 && clientData !== null) {
+        return clientData;
+      }
+    }
+    return null;
+  }
+  async fetchWithSSR(key, fetcher, context) {
+    const cached = this.getSSRData(key, context);
+    if (cached !== null) {
+      return cached;
+    }
+    const result = await fetcher();
+    if (context?.payload?.data) {
+      context.payload.data[key] = result;
+    } else if (context?.ssrContext?.payload?.data) {
+      context.ssrContext.payload.data[key] = result;
+    }
+    return result;
+  }
+  clearSSRData(key, context) {
+    if (context?.payload?.data) {
+      delete context.payload.data[key];
+    }
+    if (context?.ssrContext?.payload?.data) {
+      delete context.ssrContext.payload.data[key];
+    }
+    if (typeof window !== "undefined") {
+      const win = window;
+      if (win.__KATLUX_DATA__?.payload?.data) delete win.__KATLUX_DATA__.payload.data[key];
+      if (win.__SSR_DATA__?.payload?.data) delete win.__SSR_DATA__.payload.data[key];
+      if (win.__INITIAL_DATA__?.payload?.data) delete win.__INITIAL_DATA__.payload.data[key];
+    }
+  }
+  getSSRPayload(context) {
+    if (context?.payload?.data) return context.payload.data;
+    if (context?.ssrContext?.payload?.data) return context.ssrContext.payload.data;
+    if (typeof window !== "undefined") {
+      const win = window;
+      return win.__KATLUX_DATA__?.payload?.data || win.__KATLUX_DATA__ || win.__SSR_DATA__?.payload?.data || win.__SSR_DATA__ || win.__INITIAL_DATA__?.payload?.data || win.__INITIAL_DATA__ || null;
+    }
+    return null;
+  }
+}
+
+let currentAdapter = null;
+function getHydrationAdapter() {
+  if (!currentAdapter) {
+    currentAdapter = new DefaultHydrationAdapter();
+  }
+  return currentAdapter;
+}
+function setHydrationAdapter(adapter) {
+  currentAdapter = adapter;
+}
+function getSSRData(key, context) {
+  return getHydrationAdapter().getSSRData(key, context);
+}
+async function fetchWithSSR(key, fetcher, context) {
+  return await getHydrationAdapter().fetchWithSSR(key, fetcher, context);
+}
+function clearSSRData(key, context) {
+  getHydrationAdapter().clearSSRData?.(key, context);
+}
+function getSSRPayload(context) {
+  return getHydrationAdapter().getSSRPayload?.(context) ?? null;
+}
+function getPlatformApp() {
+  if (typeof globalThis.__KATLUX_APP__ !== "undefined") {
+    return globalThis.__KATLUX_APP__;
+  }
+  return null;
+}
+function getAppRoute() {
+  if (typeof window !== "undefined") {
+    const searchParams = new URLSearchParams(window.location.search);
+    const query = {};
+    searchParams.forEach((val, key) => {
+      query[key] = val;
+    });
+    return { query, path: window.location.pathname };
+  }
+  return null;
+}
+function getAppRouter() {
+  if (typeof window !== "undefined") {
+    return {
+      replace: (options) => {
+        const url = new URL(window.location.href);
+        url.search = "";
+        if (options.query) {
+          for (const [k, v] of Object.entries(options.query)) {
+            if (v !== void 0 && v !== null) {
+              url.searchParams.set(k, String(v));
+            }
+          }
+        }
+        window.history.replaceState({}, "", url.toString());
+      }
+    };
+  }
+  return null;
+}
+function onPlatformReady(cb) {
+  if (typeof window !== "undefined") {
+    if (document.readyState === "complete") {
+      setTimeout(cb, 0);
+    } else {
+      window.addEventListener("DOMContentLoaded", cb, { once: true });
+    }
+  } else {
+    setTimeout(cb, 0);
+  }
+}
+
 class ADataProvider {
   idKey = "id";
   pageData = [];
-  rowCount = 0;
-  loading = false;
-  initialLoad = true;
-  error = null;
+  _rowCount = 0;
+  get rowCount() {
+    return this._rowCount;
+  }
+  set rowCount(val) {
+    if (this._rowCount !== val) {
+      this._rowCount = val;
+      this.notify();
+    }
+  }
+  _loading = false;
+  get loading() {
+    return this._loading;
+  }
+  set loading(val) {
+    if (this._loading !== val) {
+      this._loading = val;
+      this.notify();
+    }
+  }
+  _initialLoad = true;
+  get initialLoad() {
+    return this._initialLoad;
+  }
+  set initialLoad(val) {
+    if (this._initialLoad !== val) {
+      this._initialLoad = val;
+      this.notify();
+    }
+  }
+  _error = null;
+  get error() {
+    return this._error;
+  }
+  set error(val) {
+    if (this._error !== val) {
+      this._error = val;
+      this.notify();
+    }
+  }
   SSR = false;
   deduplicate = true;
   context = null;
-  get nuxtApp() {
-    return this.context;
+  urlPageParam = "";
+  _selectedRows = [];
+  get selectedRows() {
+    return this._selectedRows;
+  }
+  set selectedRows(val) {
+    this._selectedRows = Array.isArray(val) ? val : [];
+    this.notify();
   }
-  set nuxtApp(val) {
-    this.context = val;
+  _selectAll = false;
+  get selectAll() {
+    return this._selectAll;
+  }
+  set selectAll(val) {
+    if (this._selectAll !== val) {
+      this._selectAll = val;
+      this.notify();
+    }
   }
-  urlPageParam = "";
-  selectedRows = [];
-  selectAll = false;
   _currentPage = 1;
   _pageSize = 10;
   _filter = null;
@@ -97,6 +274,7 @@ class ADataProvider {
   }
   _listeners = /* @__PURE__ */ new Set();
   _debouncedFilterLoad;
+  _debouncedSortLoad;
   constructor(options) {
     Object.defineProperty(this, "__v_skip", { value: true, enumerable: false });
     if (options?.idKey) {
@@ -112,17 +290,15 @@ class ADataProvider {
     this.urlPageParam = options?.urlPageParam || "";
     if (options?.context) {
       this.context = options.context;
-    } else if (options?.nuxtApp) {
-      this.context = options.nuxtApp;
     } else {
       try {
-        this.context = index.getPlatformApp();
+        this.context = getPlatformApp();
       } catch {
       }
     }
     if (options?.urlPageParam && typeof window !== "undefined") {
       try {
-        const route = index.getAppRoute();
+        const route = getAppRoute();
         if (route) {
           const pageFromUrl = route.query[options.urlPageParam];
           if (pageFromUrl) {
@@ -138,8 +314,11 @@ class ADataProvider {
     this._debouncedFilterLoad = useDebounce(() => {
       this._currentPage = 1;
       this.loadPageData();
-      this.notify();
     }, 300);
+    this._debouncedSortLoad = useDebounce(() => {
+      this._currentPage = 1;
+      this.loadPageData();
+    }, 200);
     this.setFilter = this.setFilter.bind(this);
     this.setSortList = this.setSortList.bind(this);
     this.setCurrentPage = this.setCurrentPage.bind(this);
@@ -149,21 +328,71 @@ class ADataProvider {
     this.loadPageData = this.loadPageData.bind(this);
     this.refresh = this.refresh.bind(this);
     this.subscribe = this.subscribe.bind(this);
-    this.notify = this.notify.bind(this);
+    this.batchUpdates = this.batchUpdates.bind(this);
     this.getState = this.getState.bind(this);
+    this.cancelPending = this.cancelPending.bind(this);
+  }
+  _batchDepth = 0;
+  _pendingNotify = false;
+  _isNotifying = false;
+  /**
+   * Batches multiple state updates so notify() fires exactly once upon completion.
+   */
+  batchUpdates(fn) {
+    this._batchDepth++;
+    let isAsync = false;
+    try {
+      const res = fn();
+      if (res instanceof Promise || res && typeof res.then === "function") {
+        isAsync = true;
+        return Promise.resolve(res).finally(() => {
+          this._batchDepth = Math.max(0, this._batchDepth - 1);
+          if (this._batchDepth === 0 && this._pendingNotify) {
+            this._pendingNotify = false;
+            this.notify();
+          }
+        });
+      }
+      return res;
+    } finally {
+      if (!isAsync) {
+        this._batchDepth = Math.max(0, this._batchDepth - 1);
+        if (this._batchDepth === 0 && this._pendingNotify) {
+          this._pendingNotify = false;
+          this.notify();
+        }
+      }
+    }
   }
   subscribe(listener) {
     this._listeners.add(listener);
     return () => this._listeners.delete(listener);
   }
   notify() {
-    this._listeners.forEach((listener) => {
-      try {
-        listener(this);
-      } catch (e) {
-        console.error("[Katlux Providers] Listener error:", e);
+    if (this._batchDepth > 0) {
+      this._pendingNotify = true;
+      return;
+    }
+    if (this._isNotifying) {
+      this._pendingNotify = true;
+      return;
+    }
+    this._isNotifying = true;
+    try {
+      this._listeners.forEach((listener) => {
+        try {
+          listener(this);
+        } catch (e) {
+          console.error("[Katlux Providers] Listener error:", e);
+        }
+      });
+    } finally {
+      this._isNotifying = false;
+      if (this._pendingNotify && this._batchDepth === 0) {
+        this._pendingNotify = false;
+        this.notify();
       }
-    });
+    }
   }
   getState() {
     return {
@@ -184,20 +413,24 @@ class ADataProvider {
     this._filter = filter;
     this._debouncedFilterLoad();
   }
-  setSortList(sortList) {
+  setSortList(sortList, immediate = false) {
     this._sortList = sortList;
     this._currentPage = 1;
-    this.loadPageData();
-    this.notify();
+    if (immediate) {
+      this.loadPageData();
+    } else {
+      this._debouncedSortLoad();
+    }
   }
   setCurrentPage(currentPage) {
     this._currentPage = currentPage;
+    this._selectAll = false;
     this.loadPageData();
     if (typeof window !== "undefined" && this.urlPageParam) {
       try {
-        const router = index.getAppRouter();
+        const router = getAppRouter();
         if (router) {
-          const currentRoute = router.currentRoute?.value || index.getAppRoute();
+          const currentRoute = router.currentRoute?.value || getAppRoute();
           const currentQuery = { ...currentRoute?.query || {} };
           if (currentPage === 1) {
             delete currentQuery[this.urlPageParam];
@@ -226,6 +459,10 @@ class ADataProvider {
   async refresh(hardRefresh = false) {
     await this.loadPageData({ disableCache: hardRefresh });
   }
+  cancelPending() {
+    this._debouncedFilterLoad?.cancel?.();
+    this._debouncedSortLoad?.cancel?.();
+  }
 }
 
 const compareIn = (rowValue, filterValue) => {
@@ -472,34 +709,35 @@ class CFlatClientDataProvider extends ADataProvider {
     await this.refreshData({ disableCache: hardRefresh });
   }
   async loadPageData() {
-    this.loading = true;
-    this.error = null;
-    try {
-      if (!this.filter) {
-        this.filteredData = this.allData;
-      } else {
-        const { results } = filterData(this.allData, this.filter);
-        this.filteredData = results;
-      }
-      this.rowCount = this.filteredData.length;
-      if (this.sortList.length > 0) {
-        this.filteredData = sortData(this.sortList, this.filteredData);
-      }
-      if (this.pageSize <= 0) {
-        this.pageData = this.filteredData;
-      } else {
-        const startIndex = (this.currentPage - 1) * this.pageSize;
-        const endIndex = startIndex + this.pageSize;
-        this.pageData = this.filteredData.slice(startIndex, endIndex);
+    this.batchUpdates(() => {
+      this.loading = true;
+      this.error = null;
+      try {
+        if (!this.filter) {
+          this.filteredData = this.allData;
+        } else {
+          const { results } = filterData(this.allData, this.filter);
+          this.filteredData = results;
+        }
+        this.rowCount = this.filteredData.length;
+        if (this.sortList.length > 0) {
+          this.filteredData = sortData(this.sortList, this.filteredData);
+        }
+        if (this.pageSize <= 0) {
+          this.pageData = this.filteredData;
+        } else {
+          const startIndex = (this.currentPage - 1) * this.pageSize;
+          const endIndex = startIndex + this.pageSize;
+          this.pageData = this.filteredData.slice(startIndex, endIndex);
+        }
+      } catch (err) {
+        this.error = err;
+        console.warn("[Katlux Providers] CFlatClientDataProvider loadPageData error", err);
+      } finally {
+        this.loading = false;
+        this.initialLoad = false;
       }
-    } catch (err) {
-      this.error = err;
-      console.warn("[Katlux Providers] CFlatClientDataProvider loadPageData error", err);
-    } finally {
-      this.loading = false;
-      this.initialLoad = false;
-      this.notify();
-    }
+    });
   }
 }
 
@@ -569,6 +807,319 @@ class ACacheProvider {
   }
 }
 
+class CApplicationCache extends ACacheProvider {
+  static instance = null;
+  static _storage = null;
+  static get storage() {
+    if (!this._storage) {
+      this._storage = /* @__PURE__ */ new Map();
+    }
+    return this._storage;
+  }
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CApplicationCache();
+    }
+    return this.instance;
+  }
+  static MAX_ENTRIES = 1e4;
+  static getSnapshot() {
+    return this.storage;
+  }
+  /**
+   * Purges expired entries when storage size reaches MAX_ENTRIES watermark.
+   * Avoids persistent background setInterval timers on Node.js/SSR.
+   */
+  static purgeExpiredEntries() {
+    const now = Date.now();
+    const storage = this.storage;
+    for (const [key, entry] of storage.entries()) {
+      if (now - entry.timestamp > entry.lifetime) {
+        storage.delete(key);
+      }
+    }
+  }
+  /**
+   * Clears all cached entries (used for test isolation).
+   */
+  static clear() {
+    this._storage?.clear();
+  }
+  constructor() {
+    super();
+  }
+  isServer(context) {
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    return typeof window === "undefined" || !!event || !!context?.ssrContext || typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && !!undefined;
+  }
+  async getKeyList(context) {
+    if (!this.isServer(context)) return [];
+    const prefix = "cache:";
+    const storage = CApplicationCache.storage;
+    return Array.from(storage.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, context) {
+    if (this.isServer(context)) {
+      const prefixedKey = "cache:" + key;
+      const storage = CApplicationCache.storage;
+      const entry = storage.get(prefixedKey);
+      if (!entry) return null;
+      if (Date.now() - entry.timestamp > entry.lifetime) {
+        storage.delete(prefixedKey);
+        return null;
+      }
+      return entry.data;
+    }
+    return null;
+  }
+  async set(key, data, lifetime, context) {
+    if (this.isServer(context)) {
+      const storage = CApplicationCache.storage;
+      if (storage.size >= CApplicationCache.MAX_ENTRIES) {
+        CApplicationCache.purgeExpiredEntries();
+      }
+      const prefixedKey = "cache:" + key;
+      storage.set(prefixedKey, {
+        data,
+        timestamp: Date.now(),
+        lifetime
+      });
+    }
+  }
+  async remove(key, context) {
+    if (this.isServer(context)) {
+      const prefixedKey = "cache:" + key;
+      CApplicationCache.storage.delete(prefixedKey);
+    }
+  }
+  async removeByPrefix(prefix, context) {
+    if (this.isServer(context)) {
+      const fullPrefix = "cache:" + prefix;
+      const storage = CApplicationCache.storage;
+      const keysToDelete = [];
+      for (const key of storage.keys()) {
+        if (key.startsWith(fullPrefix)) {
+          keysToDelete.push(key);
+        }
+      }
+      for (const key of keysToDelete) {
+        storage.delete(key);
+      }
+    }
+  }
+  async getRemainingTime(key, context) {
+    if (this.isServer(context)) {
+      const prefixedKey = "cache:" + key;
+      const storage = CApplicationCache.storage;
+      const entry = storage.get(prefixedKey);
+      if (!entry) return null;
+      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+    }
+    return null;
+  }
+  async cleanupExpired(context) {
+    if (this.isServer(context)) {
+      CApplicationCache.purgeExpiredEntries();
+    }
+  }
+}
+
+const CApplicationCache$1 = {
+	__proto__: null,
+	CApplicationCache: CApplicationCache
+};
+
+class CMemoryCache extends ACacheProvider {
+  static instance = null;
+  static _storage = null;
+  static get storage() {
+    if (!this._storage) this._storage = /* @__PURE__ */ new Map();
+    return this._storage;
+  }
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CMemoryCache();
+    }
+    return this.instance;
+  }
+  constructor() {
+    super();
+    const isClient = typeof window !== "undefined" || typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && !!undefined;
+    if (isClient && CMemoryCache.storage.size === 0) {
+      this._hydrateFromPayload();
+    }
+  }
+  async _hydrateFromPayload() {
+    try {
+      const payloadData = getSSRPayload();
+      if (!payloadData) return;
+      for (const key in payloadData) {
+        const value = payloadData[key];
+        if (value && typeof value === "object" && "data" in value && "timestamp" in value && "lifetime" in value) {
+          if (typeof value.lifetime === "number") {
+            CMemoryCache.storage.set(key, value);
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("[Katlux Cache] CMemoryCache payload hydration failed", e);
+    }
+  }
+  async getKeyList(context) {
+    const prefix = "cache:";
+    if (this.isServer(context)) {
+      const payload = getSSRPayload(context);
+      if (!payload) return [];
+      return Object.keys(payload).filter((k) => k.startsWith(prefix)).map((k) => k.substring(prefix.length));
+    }
+    return Array.from(CMemoryCache.storage.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, context) {
+    const prefixedKey = "cache:" + key;
+    if (this.isServer(context)) {
+      try {
+        const payloadData = getSSRPayload(context);
+        if (payloadData && payloadData[prefixedKey]) {
+          const entry2 = payloadData[prefixedKey];
+          if (Date.now() - entry2.timestamp <= entry2.lifetime) {
+            return entry2.data;
+          }
+        }
+      } catch (e) {
+        console.warn("[Katlux Cache] CMemoryCache error reading SSR payload for key: " + key, e);
+      }
+      return null;
+    }
+    const entry = CMemoryCache.storage.get(prefixedKey);
+    if (entry) {
+      if (Date.now() - entry.timestamp <= entry.lifetime) {
+        return entry.data;
+      } else {
+        CMemoryCache.storage.delete(prefixedKey);
+      }
+    }
+    try {
+      const payloadData = getSSRPayload(context);
+      if (payloadData && payloadData[prefixedKey]) {
+        const entry2 = payloadData[prefixedKey];
+        if (Date.now() - entry2.timestamp <= entry2.lifetime) {
+          CMemoryCache.storage.set(prefixedKey, entry2);
+          return entry2.data;
+        }
+      }
+    } catch (e) {
+      console.warn("[Katlux Cache] CMemoryCache error reading SSR payload for key: " + key, e);
+    }
+    return null;
+  }
+  isServer(context) {
+    return typeof window === "undefined" || typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && !!undefined || !!context?.event || !!context?.ssrContext || !!context?.node;
+  }
+  async set(key, data, lifetime, context) {
+    const prefixedKey = "cache:" + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (this.isServer(context)) {
+      if (context) {
+        try {
+          const payload = context.payload?.data || context.ssrContext?.payload?.data;
+          if (payload) {
+            payload[prefixedKey] = entry;
+          }
+        } catch (e) {
+          console.warn("[Katlux Cache] CMemoryCache error writing SSR payload for key: " + key, e);
+        }
+      }
+      return;
+    }
+    CMemoryCache.storage.set(prefixedKey, entry);
+  }
+  async remove(key, context) {
+    const prefixedKey = "cache:" + key;
+    if (this.isServer(context)) {
+      if (context) {
+        try {
+          const payload = context.payload?.data || context.ssrContext?.payload?.data;
+          if (payload && payload[prefixedKey]) {
+            delete payload[prefixedKey];
+          }
+        } catch (e) {
+          console.warn("[Katlux Cache] CMemoryCache error deleting key from SSR payload: " + key, e);
+        }
+      }
+      return;
+    }
+    CMemoryCache.storage.delete(prefixedKey);
+  }
+  async removeByPrefix(prefix, context) {
+    const fullPrefix = "cache:" + prefix;
+    if (this.isServer(context)) {
+      if (context) {
+        try {
+          const payload = context.payload?.data || context.ssrContext?.payload?.data;
+          if (payload) {
+            for (const key in payload) {
+              if (key.startsWith(fullPrefix)) {
+                delete payload[key];
+              }
+            }
+          }
+        } catch (e) {
+          console.warn("[Katlux Cache] CMemoryCache error removing by prefix from SSR payload: " + prefix, e);
+        }
+      }
+      return;
+    }
+    const keysToDelete = [];
+    for (const key of CMemoryCache.storage.keys()) {
+      if (key.startsWith(fullPrefix)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      CMemoryCache.storage.delete(key);
+    }
+  }
+  async getRemainingTime(key, context) {
+    const prefixedKey = "cache:" + key;
+    if (this.isServer(context)) {
+      const payload = getSSRPayload(context);
+      if (payload && payload[prefixedKey]) {
+        const entry2 = payload[prefixedKey];
+        return Math.max(0, entry2.timestamp + entry2.lifetime - Date.now());
+      }
+      return null;
+    }
+    const entry = CMemoryCache.storage.get(prefixedKey);
+    if (!entry) return null;
+    return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+  }
+  async cleanupExpired() {
+    if (typeof window === "undefined") return;
+    const prefix = "cache:";
+    const now = Date.now();
+    const keysToDelete = [];
+    for (const [key, entry] of CMemoryCache.storage.entries()) {
+      if (key.startsWith(prefix)) {
+        if (now - entry.timestamp > entry.lifetime) {
+          keysToDelete.push(key);
+        }
+      }
+    }
+    for (const key of keysToDelete) {
+      CMemoryCache.storage.delete(key);
+    }
+  }
+}
+
+const CMemoryCache$1 = {
+	__proto__: null,
+	CMemoryCache: CMemoryCache
+};
+
 class KatluxIndexedDB {
   static db = null;
   static openPromise = null;
@@ -589,7 +1140,7 @@ class KatluxIndexedDB {
       if (typeof indexedDB === "undefined") {
         return reject(new Error("IndexedDB is not available in this environment"));
       }
-      const req = indexedDB.open(KatluxIndexedDB.DB_NAME, KatluxIndexedDB.currentVersion);
+      const req = indexedDB.open(KatluxIndexedDB.DB_NAME);
       req.onupgradeneeded = (event) => {
         const db = event.target.result;
         if (!db.objectStoreNames.contains("cache")) db.createObjectStore("cache");
@@ -601,17 +1152,27 @@ class KatluxIndexedDB {
           }
         }
       };
-      req.onsuccess = () => {
-        KatluxIndexedDB.db = req.result;
-        if (req.result.version) {
-          KatluxIndexedDB.currentVersion = req.result.version;
+      req.onsuccess = async () => {
+        const db = req.result;
+        KatluxIndexedDB.db = db;
+        if (db.version) {
+          KatluxIndexedDB.currentVersion = db.version;
         }
-        req.result.onversionchange = () => {
-          req.result.close();
+        db.onversionchange = () => {
+          db.close();
           KatluxIndexedDB.db = null;
           KatluxIndexedDB.openPromise = null;
           console.warn("[KatluxIndexedDB] Database closed due to version change. Will reopen on next access.");
         };
+        const missingStandards = ["cache", "queue", "dead_letter"].some((s) => !db.objectStoreNames.contains(s));
+        if (missingStandards) {
+          try {
+            const upgraded = await KatluxIndexedDB.upgradeToVersion((db.version || 1) + 1);
+            resolve(upgraded);
+            return;
+          } catch (e) {
+          }
+        }
         resolve(KatluxIndexedDB.db);
       };
       req.onerror = () => {
@@ -624,6 +1185,37 @@ class KatluxIndexedDB {
     });
     return this.openPromise;
   }
+  static async upgradeToVersion(newVersion) {
+    KatluxIndexedDB.currentVersion = newVersion;
+    if (KatluxIndexedDB.db) {
+      KatluxIndexedDB.db.close();
+      KatluxIndexedDB.db = null;
+    }
+    KatluxIndexedDB.openPromise = null;
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(KatluxIndexedDB.DB_NAME, newVersion);
+      req.onupgradeneeded = (event) => {
+        const upgradedDb = event.target.result;
+        if (!upgradedDb.objectStoreNames.contains("cache")) upgradedDb.createObjectStore("cache");
+        if (!upgradedDb.objectStoreNames.contains("queue")) upgradedDb.createObjectStore("queue");
+        if (!upgradedDb.objectStoreNames.contains("dead_letter")) upgradedDb.createObjectStore("dead_letter");
+        for (const s of KatluxIndexedDB.customStores) {
+          if (!upgradedDb.objectStoreNames.contains(s)) {
+            upgradedDb.createObjectStore(s);
+          }
+        }
+      };
+      req.onsuccess = () => {
+        KatluxIndexedDB.db = req.result;
+        KatluxIndexedDB.currentVersion = req.result.version;
+        resolve(req.result);
+      };
+      req.onerror = () => {
+        KatluxIndexedDB.openPromise = null;
+        reject(req.error);
+      };
+    });
+  }
   /**
    * Dynamically ensures that an object store exists in the database.
    * If not present, performs a database version bump and creates the store.
@@ -633,35 +1225,7 @@ class KatluxIndexedDB {
     let db = await KatluxIndexedDB.open();
     if (!db.objectStoreNames.contains(storeName)) {
       const newVersion = (db.version || KatluxIndexedDB.currentVersion) + 1;
-      KatluxIndexedDB.currentVersion = newVersion;
-      if (KatluxIndexedDB.db) {
-        KatluxIndexedDB.db.close();
-        KatluxIndexedDB.db = null;
-      }
-      KatluxIndexedDB.openPromise = null;
-      db = await new Promise((resolve, reject) => {
-        const req = indexedDB.open(KatluxIndexedDB.DB_NAME, newVersion);
-        req.onupgradeneeded = (event) => {
-          const upgradedDb = event.target.result;
-          if (!upgradedDb.objectStoreNames.contains("cache")) upgradedDb.createObjectStore("cache");
-          if (!upgradedDb.objectStoreNames.contains("queue")) upgradedDb.createObjectStore("queue");
-          if (!upgradedDb.objectStoreNames.contains("dead_letter")) upgradedDb.createObjectStore("dead_letter");
-          for (const s of KatluxIndexedDB.customStores) {
-            if (!upgradedDb.objectStoreNames.contains(s)) {
-              upgradedDb.createObjectStore(s);
-            }
-          }
-        };
-        req.onsuccess = () => {
-          KatluxIndexedDB.db = req.result;
-          KatluxIndexedDB.currentVersion = req.result.version;
-          resolve(req.result);
-        };
-        req.onerror = () => {
-          KatluxIndexedDB.openPromise = null;
-          reject(req.error);
-        };
-      });
+      db = await KatluxIndexedDB.upgradeToVersion(newVersion);
     }
     return db;
   }
@@ -814,8 +1378,11 @@ class RequestProviderRegistry {
   /**
    * Register a provider with one or more tags.
    * If the provider is already registered, its tags are updated.
+   * In SSR (Node.js), registration is skipped to prevent process-global memory leaks
+   * and cross-user multi-tenant invalidation.
    */
   static register(provider, tags) {
+    if (typeof window === "undefined") return;
     const existing = this.entries.find((e) => e.provider === provider);
     if (existing) {
       existing.tags = tags;
@@ -835,7 +1402,7 @@ class RequestProviderRegistry {
    */
   static async refreshByTag(tag, hardRefresh = true) {
     const matched = this.entries.filter((e) => e.tags.includes(tag));
-    await Promise.all(matched.map((e) => e.provider.refresh(hardRefresh)));
+    await Promise.allSettled(matched.map((e) => e.provider.refresh(hardRefresh)));
   }
   /**
    * Called internally by RequestProvider (after non-GET success) and by
@@ -853,7 +1420,12 @@ class RequestProviderRegistry {
         toRefresh.add(entry.provider);
       }
     }
-    await Promise.all([...toRefresh].map((p) => p.refresh(true)));
+    const results = await Promise.allSettled([...toRefresh].map((p) => p.refresh(true)));
+    for (const res of results) {
+      if (res.status === "rejected") {
+        console.warn("[RequestProviderRegistry] Provider refresh failed during mutation notification:", res.reason);
+      }
+    }
   }
   /**
    * Returns a copy of all registry entries.
@@ -869,16 +1441,99 @@ class RequestProviderRegistry {
   static clear() {
     this.entries = [];
   }
-}
-
-function generateId() {
-  return Date.now().toString(36) + Math.random().toString(36).slice(2);
-}
-class RequestQueue {
-  // ── State ──────────────────────────────────────────────────────────────────
-  static queue = [];
-  static deadLetterQueue = [];
-  static isFlushing = false;
+}
+
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    return Date.now().toString(36) + Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return Date.now().toString(36) + Math.random().toString(36).slice(2);
+}
+const SENSITIVE_HEADER_KEYS = ["authorization", "cookie", "set-cookie", "x-csrf-token"];
+class RequestQueue {
+  // ── State ──────────────────────────────────────────────────────────────────
+  static queue = [];
+  static deadLetterQueue = [];
+  static isFlushing = false;
+  // ── Capacity & Size Limits ────────────────────────────────────────────────
+  static MAX_PAYLOAD_SIZE_BYTES = 5 * 1024 * 1024;
+  // 5 MB default
+  static MAX_QUEUE_SIZE = 500;
+  static MAX_DEAD_LETTER_SIZE = 200;
+  static setMaxPayloadSize(bytes) {
+    this.MAX_PAYLOAD_SIZE_BYTES = bytes;
+  }
+  static setMaxQueueSize(limit) {
+    this.MAX_QUEUE_SIZE = limit;
+  }
+  static setMaxDeadLetterSize(limit) {
+    this.MAX_DEAD_LETTER_SIZE = limit;
+  }
+  /**
+   * Strips sensitive headers (e.g., authorization, cookie, x-csrf-token) before persisting
+   * request options to persistent storage (IndexedDB / LocalStorage).
+   * Sensitive credentials must never be stored in plaintext in browser storage, and are
+   * instead regenerated dynamically at execution time.
+   */
+  static sanitizeOptions(options) {
+    if (!options) return {};
+    const sanitized = {
+      method: options.method
+    };
+    if (options.headers) {
+      const headersObj = {};
+      const sensitiveSet = new Set(SENSITIVE_HEADER_KEYS.map((k) => k.toLowerCase()));
+      if (typeof options.headers.forEach === "function") {
+        options.headers.forEach((value, key) => {
+          if (!sensitiveSet.has(String(key).toLowerCase())) {
+            headersObj[String(key)] = String(value);
+          }
+        });
+      } else if (Array.isArray(options.headers)) {
+        for (const [key, value] of options.headers) {
+          if (!sensitiveSet.has(String(key).toLowerCase())) {
+            headersObj[String(key)] = String(value);
+          }
+        }
+      } else if (typeof options.headers === "object") {
+        for (const [key, value] of Object.entries(options.headers)) {
+          if (!sensitiveSet.has(key.toLowerCase())) {
+            headersObj[key] = value;
+          }
+        }
+      }
+      sanitized.headers = headersObj;
+    }
+    if (options.query) {
+      try {
+        sanitized.query = JSON.parse(JSON.stringify(options.query));
+      } catch (err) {
+        throw new Error(`[RequestQueue] Failed to serialize request query parameters: ${err?.message || "circular structure"}`);
+      }
+    }
+    if (options.body !== void 0) {
+      try {
+        const serialized = JSON.stringify(options.body);
+        if (serialized && serialized.length > this.MAX_PAYLOAD_SIZE_BYTES) {
+          throw new Error(
+            `[RequestQueue] Payload size (${(serialized.length / (1024 * 1024)).toFixed(2)} MB) exceeds maximum allowed size (${(this.MAX_PAYLOAD_SIZE_BYTES / (1024 * 1024)).toFixed(2)} MB)`
+          );
+        }
+        sanitized.body = JSON.parse(serialized);
+      } catch (err) {
+        if (err.message?.includes("exceeds maximum allowed size")) {
+          throw err;
+        }
+        throw new Error(`[RequestQueue] Failed to serialize request body: ${err?.message || "circular structure"}`);
+      }
+    }
+    return sanitized;
+  }
   // ── Subscribers ────────────────────────────────────────────────────────────
   static _subscribers = /* @__PURE__ */ new Set();
   static subscribe(listener) {
@@ -899,6 +1554,7 @@ class RequestQueue {
   // ── Internal ──────────────────────────────────────────────────────────────
   static adapter = QueueStorageFactory.getAdapter("IndexedDB");
   static initialized = false;
+  static initPromise = null;
   static _onDeadLetter = null;
   static _onFlushComplete = null;
   static _onNetworkError = null;
@@ -909,10 +1565,24 @@ class RequestQueue {
    */
   static async init() {
     if (this.initialized) return;
-    this.initialized = true;
-    this.queue = await this.adapter.loadQueue();
-    this.deadLetterQueue = await this.adapter.loadDeadLetter();
-    this.notify();
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        const loadedQueue = await this.adapter.loadQueue();
+        const loadedDeadLetter = await this.adapter.loadDeadLetter();
+        const existingIds = new Set(this.queue.map((i) => i.id));
+        const mergedQueue = [...loadedQueue.filter((i) => !existingIds.has(i.id)), ...this.queue];
+        const existingDlIds = new Set(this.deadLetterQueue.map((i) => i.id));
+        const mergedDl = [...loadedDeadLetter.filter((i) => !existingDlIds.has(i.id)), ...this.deadLetterQueue];
+        this.queue = mergedQueue;
+        this.deadLetterQueue = mergedDl;
+        this.initialized = true;
+        this.notify();
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
   }
   /**
    * Set the storage backend. Call before init().
@@ -921,6 +1591,7 @@ class RequestQueue {
   static setStorageBackend(backend) {
     this.adapter = QueueStorageFactory.getAdapter(backend);
     this.initialized = false;
+    this.initPromise = null;
   }
   // ── Hooks ─────────────────────────────────────────────────────────────────
   static onDeadLetter(cb) {
@@ -940,8 +1611,13 @@ class RequestQueue {
    */
   static async enqueue(operation) {
     await this.init();
+    const sanitizedOptions = this.sanitizeOptions(operation.options);
+    if (this.queue.length >= this.MAX_QUEUE_SIZE) {
+      this.queue = this.queue.slice(1);
+    }
     const item = {
       ...operation,
+      options: sanitizedOptions,
       id: generateId(),
       createdAt: Date.now(),
       flushAttempts: 0,
@@ -1094,12 +1770,33 @@ class RequestQueue {
     this.notify();
   }
   // ── Internal helpers ──────────────────────────────────────────────────────
+  static regenerateHeaders(existingHeaders) {
+    const headers = {};
+    if (existingHeaders) {
+      if (typeof existingHeaders.forEach === "function") {
+        existingHeaders.forEach((val, key) => {
+          headers[String(key)] = String(val);
+        });
+      } else if (Array.isArray(existingHeaders)) {
+        for (const [key, val] of existingHeaders) {
+          headers[String(key)] = String(val);
+        }
+      } else if (typeof existingHeaders === "object") {
+        Object.assign(headers, existingHeaders);
+      }
+    }
+    if (typeof document !== "undefined" && document.cookie && !headers["cookie"] && !headers["Cookie"]) {
+      headers["cookie"] = document.cookie;
+    }
+    return headers;
+  }
   static async executeRequest(item) {
     const { url, options } = item;
+    const headers = this.regenerateHeaders(options.headers);
     const fetchOptions = {
       method: item.method,
       body: options.body,
-      headers: options.headers,
+      headers,
       query: options.query
     };
     const fetchFn = globalThis.$fetch || ofetch.$fetch;
@@ -1113,6 +1810,9 @@ class RequestQueue {
       httpStatus
     };
     this.queue = this.queue.filter((i) => i.id !== item.id);
+    if (this.deadLetterQueue.length >= this.MAX_DEAD_LETTER_SIZE) {
+      this.deadLetterQueue = this.deadLetterQueue.slice(1);
+    }
     this.deadLetterQueue = [...this.deadLetterQueue, deadItem];
     await this.persistQueue();
     await this.persistDeadLetter();
@@ -1134,11 +1834,45 @@ class RequestQueue {
     this._onDeadLetter = null;
     this._onFlushComplete = null;
     this._onNetworkError = null;
+    this.MAX_PAYLOAD_SIZE_BYTES = 5 * 1024 * 1024;
+    this.MAX_QUEUE_SIZE = 500;
+    this.MAX_DEAD_LETTER_SIZE = 200;
     this._subscribers.clear();
     QueueStorageFactory._reset();
   }
 }
 
+function hashIdentity(str) {
+  if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.node) {
+    try {
+      const getBuiltin = globalThis.process.getBuiltinModule;
+      if (typeof getBuiltin === "function") {
+        const crypto = getBuiltin("node:crypto");
+        if (crypto?.createHash) {
+          return crypto.createHash("sha256").update(str).digest("hex").slice(0, 16);
+        }
+      }
+      const req = typeof require !== "undefined" ? require : globalThis.__non_webpack_require__;
+      if (req) {
+        const crypto = req("node:crypto");
+        if (crypto?.createHash) {
+          return crypto.createHash("sha256").update(str).digest("hex").slice(0, 16);
+        }
+      }
+    } catch {
+    }
+  }
+  let h1 = 3735928559 ^ 5381;
+  let h2 = 1103547991 ^ 5381;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
+}
 class RequestProvider {
   cacheProvider = null;
   cacheStrategy;
@@ -1189,6 +1923,15 @@ class RequestProvider {
   onDataReceived(callback) {
     this.dataReceivedCallback = callback;
   }
+  invokeDataReceivedCallback(data, generation) {
+    if (this.dataReceivedCallback) {
+      try {
+        this.dataReceivedCallback(data, generation);
+      } catch (err) {
+        console.error("[RequestProvider] dataReceivedCallback threw an error:", err);
+      }
+    }
+  }
   hasLastUrl() {
     return !!this.lastUrl;
   }
@@ -1206,18 +1949,79 @@ class RequestProvider {
     }
     return this.request(this.lastUrl, options);
   }
+  resolveContext(options) {
+    if (options?.context) return options.context;
+    try {
+      const getReqEvent = globalThis.useRequestEvent;
+      if (typeof getReqEvent === "function") {
+        const evt = getReqEvent();
+        if (evt) return { event: evt };
+      }
+      const app = globalThis.__KATLUX_APP__ || (globalThis.useNuxtApp ? globalThis.useNuxtApp() : null);
+      if (app?.ssrContext?.event) {
+        return { event: app.ssrContext.event };
+      }
+    } catch {
+    }
+    return null;
+  }
+  getInFlightMap(options) {
+    const ctx = this.resolveContext(options);
+    const isServer = typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && undefined || !!ctx?.event || !!ctx?.ssrContext || !!ctx?.node;
+    if (isServer) {
+      const event = ctx?.event ?? ctx?.ssrContext?.event ?? (ctx?.node ? ctx : null);
+      if (event) {
+        if (!event.context) event.context = {};
+        if (!event.context.__katluxRequestsInFlight) {
+          event.context.__katluxRequestsInFlight = /* @__PURE__ */ new Map();
+        }
+        return event.context.__katluxRequestsInFlight;
+      }
+    }
+    return RequestProvider.requestsInFlight;
+  }
   getUniqueKey(url, options) {
     const namespace = options?.cacheKey || this.cacheKey;
-    if (options?.key) return namespace ? `${namespace}:${options.key}` : options.key;
     const { query, body, headers, method } = options || {};
     const stableStringify = (val) => JSON.stringify(val === void 0 ? null : val);
-    const baseKey = [
+    let serverAuthIdentity = "";
+    const ctx = this.resolveContext(options);
+    const isServer = typeof window === "undefined" || typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && undefined || !!ctx?.event || !!ctx?.ssrContext || !!ctx?.node;
+    if (isServer) {
+      const event = ctx?.event ?? ctx?.ssrContext?.event ?? (ctx?.node ? ctx : null);
+      if (event?.headers?.get) {
+        serverAuthIdentity = event.headers.get("cookie") || event.headers.get("authorization") || "";
+      } else if (event?.node?.req?.headers) {
+        const reqH = event.node.req.headers;
+        serverAuthIdentity = reqH["cookie"] || reqH["authorization"] || "";
+      }
+    }
+    if (options?.key) {
+      const authSuffix = serverAuthIdentity ? `|${hashIdentity(serverAuthIdentity)}` : "";
+      const fullKey = `${options.key}${authSuffix}`;
+      return namespace ? `${namespace}:${fullKey}` : fullKey;
+    }
+    let headersForCache = headers || {};
+    if (!isServer && headers) {
+      headersForCache = {};
+      for (const [k, v] of Object.entries(headers)) {
+        const lower = k.toLowerCase();
+        if (lower !== "authorization" && lower !== "cookie") {
+          headersForCache[k] = v;
+        }
+      }
+    }
+    const parts = [
       url,
       stableStringify(query || {}),
       stableStringify(body || null),
-      stableStringify(headers || {}),
-      method || "GET"
-    ].join("|");
+      stableStringify(headersForCache)
+    ];
+    if (serverAuthIdentity) {
+      parts.push(hashIdentity(serverAuthIdentity));
+    }
+    parts.push(method || "GET");
+    const baseKey = parts.join("|");
     return namespace ? `${namespace}:${baseKey}` : baseKey;
   }
   registerRequest(url, options) {
@@ -1234,15 +2038,16 @@ class RequestProvider {
         label
       });
     }
+    const inFlightMap = this.getInFlightMap(options);
     const uniqueKey = this.getUniqueKey(url, options);
-    const shouldDeduplicate = options?.deduplicate ?? this.deduplicate;
-    if (shouldDeduplicate && RequestProvider.requestsInFlight.has(uniqueKey)) {
-      const inflightPromise = RequestProvider.requestsInFlight.get(uniqueKey);
+    const shouldDeduplicate = (options?.deduplicate ?? this.deduplicate) && method === "GET";
+    if (shouldDeduplicate && inFlightMap.has(uniqueKey)) {
+      const inflightPromise = inFlightMap.get(uniqueKey);
       return inflightPromise.then((result) => {
         this.lastUrl = url;
         this.lastOptions = options;
-        if (this.dataReceivedCallback && method === "GET") {
-          this.dataReceivedCallback(result);
+        if (method === "GET") {
+          this.invokeDataReceivedCallback(result, options?._generation);
         }
         return result;
       });
@@ -1258,11 +2063,11 @@ class RequestProvider {
       RequestProvider.executeAll();
     }).finally(() => {
       if (shouldDeduplicate) {
-        RequestProvider.requestsInFlight.delete(uniqueKey);
+        inFlightMap.delete(uniqueKey);
       }
     });
     if (shouldDeduplicate) {
-      RequestProvider.requestsInFlight.set(uniqueKey, promise);
+      inFlightMap.set(uniqueKey, promise);
     }
     return promise;
   }
@@ -1282,18 +2087,45 @@ class RequestProvider {
       }
     });
   }
+  isSameOriginUrl(url, context) {
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      return true;
+    }
+    try {
+      const targetUrl = new URL(url);
+      if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+        return targetUrl.origin === window.location.origin;
+      }
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+      const host = event?.node?.req?.headers?.host || event?.headers?.get?.("host");
+      if (host) {
+        return targetUrl.host === host;
+      }
+    } catch {
+      return false;
+    }
+    return false;
+  }
   async request(url, options) {
     const { cacheStrategy, lifetime, query, body, headers, method } = options || {};
     const uniqueKey = this.getUniqueKey(url, options);
-    const nuxtApp = options?.nuxtApp;
+    const context = this.resolveContext(options);
     let serverHeaders = {};
-    if (nuxtApp && undefined) {
-      const event = nuxtApp.ssrContext?.event;
+    const isServer = typeof window === "undefined" || typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && undefined || !!context?.event || !!context?.ssrContext || !!context?.node;
+    if (context && isServer && this.isSameOriginUrl(url, context)) {
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
       if (event) {
-        const { getRequestHeader } = await import('h3');
-        const cookieHeader = getRequestHeader(event, "cookie");
-        if (cookieHeader) {
-          serverHeaders = { cookie: cookieHeader };
+        try {
+          const { getRequestHeader } = await import('h3');
+          const cookieHeader = getRequestHeader(event, "cookie");
+          if (cookieHeader) {
+            serverHeaders = { cookie: cookieHeader };
+          }
+        } catch {
+          const cookieHeader = event.node?.req?.headers?.cookie || event.headers?.get?.("cookie");
+          if (cookieHeader) {
+            serverHeaders = { cookie: cookieHeader };
+          }
         }
       }
     }
@@ -1301,49 +2133,72 @@ class RequestProvider {
     const cacheLifetime = lifetime || this.cacheLifetime;
     const requestMethod = method || "GET";
     const isGetRequest = requestMethod === "GET";
-    if (provider && isGetRequest && !options?.disableCache) {
-      const cached = await provider.get(uniqueKey, nuxtApp);
-      if (cached) {
+    const effectiveHeaders = { ...headers, ...serverHeaders };
+    const hasCookieOrAuth = !!serverHeaders.cookie || !!headers?.cookie || !!headers?.Cookie || !!headers?.authorization || !!headers?.Authorization;
+    const isAppCache = provider instanceof CApplicationCache || provider?.constructor?.name === "CApplicationCache" || cacheStrategy === ECacheStrategy.Application;
+    const isServerMemoryCache = typeof window === "undefined" && (provider instanceof CMemoryCache || provider?.constructor?.name === "CMemoryCache" || cacheStrategy === ECacheStrategy.Memory);
+    const canReadFromCache = provider && isGetRequest && !options?.disableCache && !((isAppCache || isServerMemoryCache) && hasCookieOrAuth);
+    if (canReadFromCache) {
+      const cached = await provider.get(uniqueKey, context);
+      if (cached !== null && cached !== void 0) {
         this.lastUrl = url;
         this.lastOptions = options;
-        if (this.dataReceivedCallback) {
-          this.dataReceivedCallback(cached);
-        }
+        this.invokeDataReceivedCallback(cached, options?._generation);
         return cached;
       }
     }
     const fetchOptions = {
       method: requestMethod,
       body,
-      headers: { ...headers, ...serverHeaders },
+      headers: effectiveHeaders,
       query,
+      ...options?.signal ? { signal: options.signal } : {},
       ...options?.disableCache ? { cache: "no-store" } : {}
     };
     const fetchFn = globalThis.$fetch || ofetch.$fetch;
     const responseData = await fetchFn(url, fetchOptions);
     let finalData = responseData;
-    if (!finalData && provider && isGetRequest) {
-      const cached = await provider.get(uniqueKey, nuxtApp);
-      if (cached) {
+    if ((finalData === void 0 || finalData === null) && canReadFromCache) {
+      const cached = await provider.get(uniqueKey, context);
+      if (cached !== null && cached !== void 0) {
         finalData = cached;
       }
     }
-    if (provider && cacheLifetime && finalData && isGetRequest) {
-      await provider.set(uniqueKey, finalData, cacheLifetime, nuxtApp);
+    const canWriteToCache = provider && cacheLifetime && (finalData !== void 0 && finalData !== null) && isGetRequest && !((isAppCache || isServerMemoryCache) && hasCookieOrAuth);
+    if (canWriteToCache) {
+      await provider.set(uniqueKey, finalData, cacheLifetime, context);
     }
     this.lastUrl = url;
     this.lastOptions = options;
-    if (this.dataReceivedCallback && isGetRequest && finalData) {
-      this.dataReceivedCallback(finalData);
+    if (isGetRequest && (finalData !== void 0 && finalData !== null)) {
+      this.invokeDataReceivedCallback(finalData, options?._generation);
     }
     const requestTags = options?.tags || this.tags;
     if (requestTags.length > 0 && requestMethod !== "GET") {
-      RequestProviderRegistry.notifyMutation(requestTags);
+      try {
+        await RequestProviderRegistry.notifyMutation(requestTags);
+      } catch (err) {
+        console.warn("[RequestProvider] notifyMutation failed:", err);
+      }
     }
     return finalData;
   }
 }
 
+function normalizeDataResult(result) {
+  if (result === null || result === void 0) return null;
+  if (Array.isArray(result)) {
+    return { rows: result, rowCount: result.length };
+  }
+  if (typeof result === "object") {
+    const rows = Array.isArray(result.rows) ? result.rows : Array.isArray(result.data) ? result.data : Array.isArray(result.items) ? result.items : null;
+    if (rows !== null) {
+      return { rows, rowCount: result.rowCount ?? result.total ?? rows.length };
+    }
+  }
+  return null;
+}
+
 class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
   apiUrl = "";
   contextKey = "";
@@ -1356,78 +2211,73 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
     if (options?.cacheStrategy) this.cacheStrategy = options.cacheStrategy;
     if (options?.cacheLifetime) this.cacheLifetime = options.cacheLifetime;
     if (options?.refreshOnMutation !== void 0) this.refreshOnMutation = options.refreshOnMutation;
+    if (options?.contextKey) this.contextKey = options.contextKey;
     this.requestProvider.onDataReceived((data) => {
       if (data) {
-        this.setData(data.rows || data);
+        const normalized = normalizeDataResult(data);
+        this.setData(normalized ? normalized.rows : data.rows || data);
       }
     });
   }
   setContextKey(key) {
     this.contextKey = key;
-    this.requestProvider.cacheKey = key;
-    if (this.cacheStrategy) this.requestProvider.setCacheProvider(this.cacheStrategy);
-    if (this.cacheLifetime) this.requestProvider.setCacheLifetime(this.cacheLifetime);
   }
-  async refresh(hardRefresh = false) {
-    await this.refreshData({ disableCache: hardRefresh });
+  setCacheStrategy(strategy) {
+    this.cacheStrategy = strategy;
+    this.requestProvider.setCacheProvider(strategy);
+  }
+  setCacheLifetime(lifetime) {
+    this.cacheLifetime = lifetime;
+    this.requestProvider.setCacheLifetime(lifetime);
   }
   async refreshData(options) {
-    if (!this.requestProvider.hasLastUrl()) {
-      await this._initialFetch(options?.disableCache ?? false);
-      return;
-    }
     this.loading = true;
     this.error = null;
-    try {
-      await this.requestProvider.refresh(options?.disableCache ?? false);
-    } catch (err) {
-      this.error = err;
-      throw err;
-    } finally {
-      this.loading = false;
-    }
-  }
-  async _initialFetch(disableCache = false) {
-    if (!this.SSR && undefined) return;
+    this.notify();
+    const disableCache = options?.disableCache ?? false;
     const fetcher = async () => {
       const promise = this.requestProvider.registerRequest(this.apiUrl, {
         deduplicate: this.deduplicate,
-        nuxtApp: this.context,
         context: this.context,
         disableCache
       });
-      if (this.SSR && undefined) return await promise;
+      if (this.SSR && typeof window === "undefined") return await promise;
       return promise;
     };
     const key = `${this.contextKey}`;
     if (this.contextKey && this.initialLoad && !disableCache) {
-      const result = index.getSSRData(key, this.context);
-      if (result && result.rows) {
-        this.setData(result.rows);
+      const result = getSSRData(key, this.context);
+      const normalized = normalizeDataResult(result);
+      if (normalized) {
+        this.setData(normalized.rows);
         this.initialLoad = false;
         this.loading = false;
         this.notify();
         return;
       }
     }
-    if (undefined && this.contextKey) {
+    if (typeof window === "undefined" && this.contextKey) {
       if (disableCache) {
-        index.clearSSRData(key, this.context);
+        clearSSRData(key, this.context);
       }
-      const result = await index.fetchWithSSR(key, fetcher, this.context);
-      if (result && result.rows) {
-        this.setData(result.rows);
+      try {
+        const result = await fetchWithSSR(key, fetcher, this.context);
+        const normalized = normalizeDataResult(result);
+        if (normalized) {
+          this.setData(normalized.rows);
+          return;
+        }
+      } finally {
         this.initialLoad = false;
         this.loading = false;
         this.notify();
-        return;
       }
     }
     if (!this.SSR) {
       try {
         await this.requestProvider.registerRequest(this.apiUrl, {
           deduplicate: this.deduplicate,
-          nuxtApp: this.nuxtApp,
+          context: this.context,
           disableCache
         });
         this.error = null;
@@ -1452,28 +2302,33 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
   }
   async setAPIUrl(url) {
     this.apiUrl = url;
-    this.setContextKey(url);
+    if (!this.contextKey) {
+      this.setContextKey(this.urlPageParam ? `${url}:${this.urlPageParam}` : url);
+    }
     if (this.SSR && this.initialLoad) {
-      const ssrData = index.getSSRData(url, this.context);
-      if (ssrData && ssrData.rows) {
-        this.setData(ssrData.rows);
+      const ssrData = getSSRData(this.contextKey, this.context);
+      const normalized = normalizeDataResult(ssrData);
+      if (normalized) {
+        this.setData(normalized.rows);
         this.initialLoad = false;
         this.loading = false;
         this.notify();
         return;
       }
     }
-    this.loading = true;
-    this.error = null;
-    if (this.allData.length === 0)
+    if (this.allData.length === 0) {
       await this.refreshData();
+    } else {
+      this.loading = false;
+      this.notify();
+    }
   }
   async create(item) {
     if (!this.apiUrl) return;
     const result = await this.requestProvider.registerRequest(this.apiUrl, {
       method: "POST",
       body: item,
-      nuxtApp: this.nuxtApp
+      context: this.context
     });
     if (this.refreshOnMutation) {
       await this.refresh(true);
@@ -1488,7 +2343,7 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -1497,18 +2352,17 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
     const result = await this.requestProvider.registerRequest(this.apiUrl, {
       method: "PUT",
       body: item,
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation) {
       await this.refresh(true);
     } else {
-      const index$1 = this.allData.findIndex((row) => row[this.idKey] === item[this.idKey]);
-      if (index$1 !== -1) {
+      const index = this.allData.findIndex((row) => row[this.idKey] === item[this.idKey]);
+      if (index !== -1) {
         if (result && result.item) {
-          this.allData[index$1] = result.item;
+          this.allData[index] = result.item;
         } else {
-          this.allData[index$1] = { ...this.allData[index$1], ...item };
+          this.allData[index] = { ...this.allData[index], ...item };
         }
         this.loadPageData();
       }
@@ -1516,7 +2370,7 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -1527,7 +2381,6 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "DELETE",
       body: { id: ids },
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation) {
@@ -1540,7 +2393,7 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -1594,21 +2447,23 @@ class CFlatServerDataProvider extends ADataProvider {
     );
     try {
       if (!options?.disableCache && this.SSR && this.contextKey && this.initialLoad) {
-        const result = index.getSSRData(key, this.context);
-        if (result && result.rows && result.rows.length > 0) {
+        const result = getSSRData(key, this.context);
+        const normalized = normalizeDataResult(result);
+        if (normalized) {
           if (requestId !== this.latestRequestId) return;
-          this.pageData = result.rows || [];
-          this.rowCount = result.rowCount ?? 0;
+          this.pageData = normalized.rows;
+          this.rowCount = normalized.rowCount;
           this.initialLoad = false;
           return;
         }
       }
-      if (this.SSR && this.contextKey && !options?.disableCache && (undefined || this.initialLoad)) {
-        const result = await index.fetchWithSSR(key, fetcher, this.context);
-        if (result && result.rows && result.rows.length > 0) {
+      if (this.SSR && this.contextKey && !options?.disableCache && (typeof window === "undefined" || this.initialLoad)) {
+        const result = await fetchWithSSR(key, fetcher, this.context);
+        const normalized = normalizeDataResult(result);
+        if (normalized) {
           if (requestId !== this.latestRequestId) return;
-          this.pageData = result.rows || [];
-          this.rowCount = result.rowCount ?? 0;
+          this.pageData = normalized.rows;
+          this.rowCount = normalized.rowCount;
           this.initialLoad = false;
           return;
         }
@@ -1616,8 +2471,14 @@ class CFlatServerDataProvider extends ADataProvider {
       const returnedData = await fetcher();
       if (requestId !== this.latestRequestId) return;
       if (returnedData) {
-        this.pageData = returnedData.rows || [];
-        this.rowCount = returnedData.rowCount ?? 0;
+        const normalized = normalizeDataResult(returnedData);
+        if (normalized) {
+          this.pageData = normalized.rows;
+          this.rowCount = normalized.rowCount;
+        } else {
+          this.pageData = returnedData.rows || [];
+          this.rowCount = returnedData.rowCount ?? 0;
+        }
       }
       this.initialLoad = false;
     } catch (err) {
@@ -1646,12 +2507,15 @@ class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
   cacheLifetime = 0;
   refreshOnMutation = true;
   // Default true for server
+  /** Incremented on every new request; stale onDataReceived callbacks are discarded. */
+  _requestGeneration = 0;
   constructor(options) {
     super(options);
     if (options?.cacheStrategy) this.cacheStrategy = options.cacheStrategy;
     if (options?.cacheLifetime) this.cacheLifetime = options.cacheLifetime;
     if (options?.refreshOnMutation !== void 0) this.refreshOnMutation = options.refreshOnMutation;
-    this.requestProvider.onDataReceived((data) => {
+    this.requestProvider.onDataReceived((data, generation) => {
+      if (generation !== void 0 && generation !== this._requestGeneration) return;
       if (data) {
         this.pageData = data.rows || data;
         if (data.rowCount !== void 0) {
@@ -1664,23 +2528,21 @@ class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
     if (hardRefresh && this.requestProvider.cacheProvider) {
       await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
     }
-    this.loading = true;
-    try {
-      await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
-    } finally {
-      this.loading = false;
-    }
+    await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
   }
   async refreshData(options) {
     await this.refresh(options?.disableCache ?? false);
   }
   async setAPIUrl(url) {
     this.apiUrl = url;
-    this.setContextKey(url);
+    if (!this.contextKey) {
+      this.setContextKey(this.urlPageParam ? `${url}:${this.urlPageParam}` : url);
+    }
     if (this.cacheStrategy) this.requestProvider.setCacheProvider(this.cacheStrategy);
     if (this.cacheLifetime) this.requestProvider.setCacheLifetime(this.cacheLifetime);
     await this.setPageDataHandler(
       async (currentPage, pageSize, filter, sortList, options) => {
+        const generation = ++this._requestGeneration;
         const queryParams = {
           pageNumber: currentPage,
           pageSize
@@ -1691,13 +2553,16 @@ class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
         if (sortList && sortList.length > 0) {
           queryParams.sortList = sortList;
         }
-        return await this.requestProvider.registerRequest(this.apiUrl, {
+        const result = await this.requestProvider.registerRequest(this.apiUrl, {
           query: queryParams,
           deduplicate: this.deduplicate,
-          nuxtApp: this.context,
           context: this.context,
-          disableCache: options?.disableCache
+          disableCache: options?.disableCache,
+          signal: options?.signal,
+          _generation: generation
         });
+        if (generation !== this._requestGeneration) return { rows: [], rowCount: 0 };
+        return result;
       }
     );
   }
@@ -1708,7 +2573,6 @@ class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "DELETE",
       body: { id: ids },
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation !== false) {
@@ -1723,7 +2587,6 @@ class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "POST",
       body: item,
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation !== false) {
@@ -1738,7 +2601,6 @@ class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "PUT",
       body: item,
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation !== false) {
@@ -1906,22 +2768,46 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
     }
     return sortedIds;
   }
-  isNodeVisible(node, nodeMap) {
-    if (node.parentId === null || !nodeMap.has(node.parentId)) return true;
+  isNodeVisible(node, nodeMap, visibilityCache) {
+    if (visibilityCache?.has(node.id)) {
+      return visibilityCache.get(node.id);
+    }
+    if (node.parentId === null || !nodeMap.has(node.parentId)) {
+      visibilityCache?.set(node.id, true);
+      return true;
+    }
+    if (visibilityCache?.has(node.parentId)) {
+      const parentVisible = visibilityCache.get(node.parentId);
+      const isVisible2 = parentVisible && this.expandedNodes.has(node.parentId);
+      visibilityCache.set(node.id, isVisible2);
+      return isVisible2;
+    }
     const visited = /* @__PURE__ */ new Set([node.id]);
     let currentId = node.parentId;
+    let isVisible = true;
     while (currentId !== null) {
       if (visited.has(currentId)) {
-        return true;
+        break;
       }
       visited.add(currentId);
+      if (visibilityCache?.has(currentId)) {
+        const ancestorVisible = visibilityCache.get(currentId);
+        if (!ancestorVisible) {
+          isVisible = false;
+          break;
+        }
+      }
       const parent = nodeMap.get(currentId);
-      if (!parent) return true;
+      if (!parent) break;
       const parentExpanded = this.expandedNodes.has(currentId);
-      if (!parentExpanded) return false;
+      if (!parentExpanded) {
+        isVisible = false;
+        break;
+      }
       currentId = parent.parentId !== null && nodeMap.has(parent.parentId) ? parent.parentId : null;
     }
-    return true;
+    visibilityCache?.set(node.id, isVisible);
+    return isVisible;
   }
   paginateNodes(visible) {
     const pageSize = this.pageSize;
@@ -1977,25 +2863,29 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
           current = current.parentId != null ? nodeMap.get(current.parentId) : void 0;
         }
       });
+      const filterExpanded = new Set(this.expandedNodes);
       visibleIds.forEach((id) => {
         if (nodeMap.get(id)?.hasChildren) {
-          this.expandedNodes.add(id);
+          filterExpanded.add(id);
         }
       });
       const filteredNodes = sortedIds.filter((id) => visibleIds.has(id)).map((id) => {
         const node = nodeMap.get(id);
         return {
           ...node,
-          isExpanded: this.expandedNodes.has(id)
+          isExpanded: filterExpanded.has(id)
         };
       });
       this.filteredData = filteredNodes;
-      this.pageData = filteredNodes.map((node) => ({
+      const paginated = this.paginateNodes(filteredNodes);
+      this.pageData = paginated.map((node) => ({
         ...node.data,
         ...node,
         __treeNode: node
       }));
-      this.rowCount = filteredNodes.length;
+      if (this.allData.length > 0) {
+        this.initialLoad = false;
+      }
       return;
     }
     const visible = this.visibleRows;
@@ -2033,10 +2923,11 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
     const nodeMap = this._nodeMap;
     const sortedIds = this._sortedNodeIds;
     const visibleNodes = [];
+    const visibilityCache = /* @__PURE__ */ new Map();
     for (const id of sortedIds) {
       const staticNode = nodeMap.get(id);
       if (!staticNode) continue;
-      if (this.isNodeVisible(staticNode, nodeMap)) {
+      if (this.isNodeVisible(staticNode, nodeMap, visibilityCache)) {
         visibleNodes.push({
           ...staticNode,
           isExpanded: this.expandedNodes.has(id)
@@ -2117,9 +3008,11 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
     if (options?.cacheStrategy) this.cacheStrategy = options.cacheStrategy;
     if (options?.cacheLifetime) this.cacheLifetime = options.cacheLifetime;
     if (options?.refreshOnMutation !== void 0) this.refreshOnMutation = options.refreshOnMutation;
+    if (options?.contextKey) this.contextKey = options.contextKey;
     this.requestProvider.onDataReceived((data) => {
       if (data) {
-        this.setData(data.rows || data);
+        const normalized = normalizeDataResult(data);
+        this.setData(normalized ? normalized.rows : data.rows || data);
       }
     });
   }
@@ -2150,46 +3043,50 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
     }
   }
   async _initialFetch(disableCache = false) {
-    if (!this.SSR && undefined) return;
+    if (!this.SSR && typeof window === "undefined") return;
     const fetcher = async () => {
       const promise = this.requestProvider.registerRequest(this.apiUrl, {
         deduplicate: this.deduplicate,
-        nuxtApp: this.context,
         context: this.context,
         disableCache
       });
-      if (this.SSR && undefined) return await promise;
+      if (this.SSR && typeof window === "undefined") return await promise;
       return promise;
     };
     const key = `${this.contextKey}`;
     if (this.contextKey && this.initialLoad && !disableCache) {
-      const result = index.getSSRData(key, this.context);
-      if (result && result.rows) {
-        this.setData(result.rows);
+      const result = getSSRData(key, this.context);
+      const normalized = normalizeDataResult(result);
+      if (normalized) {
+        this.setData(normalized.rows);
         this.initialLoad = false;
         this.loading = false;
         this.notify();
         return;
       }
     }
-    if (undefined && this.contextKey) {
+    if (typeof window === "undefined" && this.contextKey) {
       if (disableCache) {
-        index.clearSSRData(key, this.context);
+        clearSSRData(key, this.context);
       }
-      const result = await index.fetchWithSSR(key, fetcher, this.context);
-      if (result && result.rows) {
-        this.setData(result.rows);
+      try {
+        const result = await fetchWithSSR(key, fetcher, this.context);
+        const normalized = normalizeDataResult(result);
+        if (normalized) {
+          this.setData(normalized.rows);
+          return;
+        }
+      } finally {
         this.initialLoad = false;
         this.loading = false;
         this.notify();
-        return;
       }
     }
     if (!this.SSR) {
       try {
         await this.requestProvider.registerRequest(this.apiUrl, {
           deduplicate: this.deduplicate,
-          nuxtApp: this.nuxtApp,
+          context: this.context,
           disableCache
         });
         this.error = null;
@@ -2213,19 +3110,34 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
     }
   }
   async setAPIUrl(url) {
-    this.loading = true;
-    this.error = null;
     this.apiUrl = url;
-    this.setContextKey(url);
-    if (this.allData.length === 0)
+    if (!this.contextKey) {
+      this.setContextKey(this.urlPageParam ? `${url}:${this.urlPageParam}` : url);
+    }
+    if (this.SSR && this.initialLoad) {
+      const ssrData = getSSRData(this.contextKey, this.context);
+      const normalized = normalizeDataResult(ssrData);
+      if (normalized) {
+        this.setData(normalized.rows);
+        this.initialLoad = false;
+        this.loading = false;
+        this.notify();
+        return;
+      }
+    }
+    if (this.allData.length === 0) {
       await this.refreshData();
+    } else {
+      this.loading = false;
+      this.notify();
+    }
   }
   async create(item) {
     if (!this.apiUrl) return;
     const result = await this.requestProvider.registerRequest(this.apiUrl, {
       method: "POST",
       body: item,
-      nuxtApp: this.nuxtApp
+      context: this.context
     });
     if (this.refreshOnMutation) {
       await this.refresh(true);
@@ -2241,7 +3153,7 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -2250,18 +3162,17 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
     const result = await this.requestProvider.registerRequest(this.apiUrl, {
       method: "PUT",
       body: item,
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation) {
       await this.refresh(true);
     } else {
-      const index$1 = this.allData.findIndex((row) => row[this.idKey] === item[this.idKey]);
-      if (index$1 !== -1) {
+      const index = this.allData.findIndex((row) => row[this.idKey] === item[this.idKey]);
+      if (index !== -1) {
         if (result && result.item) {
-          this.allData[index$1] = result.item;
+          this.allData[index] = result.item;
         } else {
-          this.allData[index$1] = { ...this.allData[index$1], ...item };
+          this.allData[index] = { ...this.allData[index], ...item };
         }
         this.invalidateStaticCache();
         this.loadPageData();
@@ -2270,7 +3181,7 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -2281,7 +3192,6 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "DELETE",
       body: { id: ids },
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation) {
@@ -2295,7 +3205,7 @@ class CAPITreeClientDataProvider extends CTreeClientDataProvider {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -2374,21 +3284,23 @@ class CTreeServerDataProvider extends ADataProvider {
     );
     try {
       if (!options?.disableCache && this.SSR && this.contextKey && this.initialLoad) {
-        const result = index.getSSRData(key, this.context);
-        if (result && result.rows && result.rows.length > 0) {
+        const result = getSSRData(key, this.context);
+        const normalized = normalizeDataResult(result);
+        if (normalized) {
           if (requestId !== this.latestRequestId) return;
-          this.pageData = result.rows || [];
-          this.rowCount = result.rowCount ?? 0;
+          this.pageData = normalized.rows;
+          this.rowCount = normalized.rowCount;
           this.initialLoad = false;
           return;
         }
       }
-      if (this.SSR && this.contextKey && !options?.disableCache && (undefined || this.initialLoad)) {
-        const result = await index.fetchWithSSR(key, fetcher, this.context);
-        if (result && result.rows && result.rows.length > 0) {
+      if (this.SSR && this.contextKey && !options?.disableCache && (typeof window === "undefined" || this.initialLoad)) {
+        const result = await fetchWithSSR(key, fetcher, this.context);
+        const normalized = normalizeDataResult(result);
+        if (normalized) {
           if (requestId !== this.latestRequestId) return;
-          this.pageData = result.rows || [];
-          this.rowCount = result.rowCount ?? 0;
+          this.pageData = normalized.rows;
+          this.rowCount = normalized.rowCount;
           this.initialLoad = false;
           return;
         }
@@ -2396,8 +3308,14 @@ class CTreeServerDataProvider extends ADataProvider {
       const returnedData = await fetcher();
       if (requestId !== this.latestRequestId) return;
       if (returnedData) {
-        this.pageData = returnedData.rows || [];
-        this.rowCount = returnedData.rowCount ?? 0;
+        const normalized = normalizeDataResult(returnedData);
+        if (normalized) {
+          this.pageData = normalized.rows;
+          this.rowCount = normalized.rowCount;
+        } else {
+          this.pageData = returnedData.rows || [];
+          this.rowCount = returnedData.rowCount ?? 0;
+        }
       }
       this.initialLoad = false;
     } catch (err) {
@@ -2469,12 +3387,15 @@ class CAPITreeServerDataProvider extends CTreeServerDataProvider {
   cacheLifetime = 0;
   refreshOnMutation = true;
   // Default true for server
+  /** Incremented on every new request; stale onDataReceived callbacks are discarded. */
+  _requestGeneration = 0;
   constructor(options) {
     super(options);
     if (options?.cacheStrategy) this.cacheStrategy = options.cacheStrategy;
     if (options?.cacheLifetime) this.cacheLifetime = options.cacheLifetime;
     if (options?.refreshOnMutation !== void 0) this.refreshOnMutation = options.refreshOnMutation;
-    this.requestProvider.onDataReceived((data) => {
+    this.requestProvider.onDataReceived((data, generation) => {
+      if (generation !== void 0 && generation !== this._requestGeneration) return;
       if (data) {
         this.pageData = data.rows || data;
         if (data.rowCount !== void 0) {
@@ -2488,24 +3409,22 @@ class CAPITreeServerDataProvider extends CTreeServerDataProvider {
     if (hardRefresh && this.requestProvider.cacheProvider) {
       await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
     }
-    this.loading = true;
-    try {
-      await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
-    } finally {
-      this.loading = false;
-    }
+    await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
   }
   async refreshData(options) {
     await this.refresh(options?.disableCache ?? false);
   }
   async setAPIUrl(url) {
     this.apiUrl = url;
-    this.setContextKey(url);
+    if (!this.contextKey) {
+      this.setContextKey(this.urlPageParam ? `${url}:${this.urlPageParam}` : url);
+    }
     if (this.cacheStrategy) this.requestProvider.setCacheProvider(this.cacheStrategy);
     if (this.cacheLifetime) this.requestProvider.setCacheLifetime(this.cacheLifetime);
     await this.setPageDataHandler(
       async (currentPage, pageSize, filter, sortList, treeParams, options) => {
-        return await this.requestProvider.registerRequest(this.apiUrl, {
+        const generation = ++this._requestGeneration;
+        const result = await this.requestProvider.registerRequest(this.apiUrl, {
           query: {
             pageNumber: currentPage,
             pageSize,
@@ -2519,10 +3438,13 @@ class CAPITreeServerDataProvider extends CTreeServerDataProvider {
             expandedByDefault: treeParams.expandedByDefault
           },
           deduplicate: this.deduplicate,
-          nuxtApp: this.context,
           context: this.context,
-          disableCache: options?.disableCache
+          disableCache: options?.disableCache,
+          signal: options?.signal,
+          _generation: generation
         });
+        if (generation !== this._requestGeneration) return { rows: [], rowCount: 0 };
+        return result;
       }
     );
   }
@@ -2533,7 +3455,6 @@ class CAPITreeServerDataProvider extends CTreeServerDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "DELETE",
       body: { id: ids },
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation !== false) {
@@ -2548,7 +3469,6 @@ class CAPITreeServerDataProvider extends CTreeServerDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "POST",
       body: item,
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation !== false) {
@@ -2563,7 +3483,6 @@ class CAPITreeServerDataProvider extends CTreeServerDataProvider {
     await this.requestProvider.registerRequest(this.apiUrl, {
       method: "PUT",
       body: item,
-      nuxtApp: this.context,
       context: this.context
     });
     if (this.refreshOnMutation !== false) {
@@ -2599,11 +3518,12 @@ class CCookieCache extends ACacheProvider {
     }
     return null;
   }
-  isClient(nuxtApp) {
-    return typeof document !== "undefined" && !nuxtApp || !!undefined;
+  isClient(context) {
+    const isExplicitServer = typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && undefined || !!context?.event || !!context?.ssrContext || !!context?.node;
+    return typeof document !== "undefined" && !isExplicitServer || typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== "undefined" && !!undefined && !isExplicitServer;
   }
-  async getKeyList(nuxtApp) {
-    if (this.isClient(nuxtApp)) {
+  async getKeyList(context) {
+    if (this.isClient(context)) {
       const cookieStr = typeof document !== "undefined" ? document.cookie : "";
       if (!cookieStr) return [];
       const keys = [];
@@ -2620,8 +3540,8 @@ class CCookieCache extends ACacheProvider {
         }
       }
       return keys;
-    } else if (nuxtApp) {
-      const event = nuxtApp.ssrContext?.event;
+    } else if (context) {
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
       if (event) {
         const cookies = h3.parseCookies(event);
         const keys = [];
@@ -2634,10 +3554,10 @@ class CCookieCache extends ACacheProvider {
     }
     return [];
   }
-  async get(key, nuxtApp) {
+  async get(key, context) {
     const cookieKey = this.getCookieKey(key);
     let rawValue = null;
-    if (this.isClient(nuxtApp)) {
+    if (this.isClient(context)) {
       const namePrefix = cookieKey + "=";
       const cookies = (typeof document !== "undefined" ? document.cookie : "").split(";");
       for (let i = 0; i < cookies.length; i++) {
@@ -2647,10 +3567,14 @@ class CCookieCache extends ACacheProvider {
           break;
         }
       }
-    } else if (nuxtApp) {
-      const event = nuxtApp.ssrContext?.event;
+    } else if (context) {
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
       if (event) {
-        rawValue = h3.getCookie(event, cookieKey) ?? null;
+        try {
+          rawValue = h3.getCookie(event, cookieKey) ?? null;
+        } catch {
+          rawValue = null;
+        }
       }
     }
     if (!rawValue) return null;
@@ -2666,7 +3590,7 @@ class CCookieCache extends ACacheProvider {
         if (Date.now() - val.timestamp <= val.lifetime) {
           return val.data;
         } else {
-          await this.remove(key, nuxtApp);
+          await this.remove(key, context);
         }
       }
       return null;
@@ -2675,7 +3599,7 @@ class CCookieCache extends ACacheProvider {
       return null;
     }
   }
-  async set(key, data, lifetime, nuxtApp) {
+  async set(key, data, lifetime, context) {
     const cookieKey = this.getCookieKey(key);
     const entry = {
       data,
@@ -2683,53 +3607,56 @@ class CCookieCache extends ACacheProvider {
       lifetime
     };
     const serialized = JSON.stringify(entry);
-    if (cookieKey.length + serialized.length > 4e3) {
-      console.warn(`[CCookieCache] Payload for key "${key}" exceeds cookie size limit. Skipping cookie write.`);
+    const cookieValue = encodeURIComponent(serialized);
+    if (cookieKey.length + cookieValue.length > 4e3) {
+      console.warn(`[CCookieCache] Payload for key "${key}" exceeds cookie size limit (${cookieKey.length + cookieValue.length} bytes encoded). Skipping cookie write.`);
       return;
     }
     const maxAge = Math.floor(lifetime / 1e3);
-    const cookieValue = encodeURIComponent(serialized);
-    if (this.isClient(nuxtApp)) {
+    if (this.isClient(context)) {
       if (typeof document !== "undefined") {
         document.cookie = `${cookieKey}=${cookieValue}; Max-Age=${maxAge}; Path=/; SameSite=Lax`;
       }
-    } else if (nuxtApp) {
-      const event = nuxtApp.ssrContext?.event;
+    } else if (context) {
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
       if (event) {
-        h3.setCookie(event, cookieKey, serialized, {
-          maxAge,
-          path: "/",
-          sameSite: "lax",
-          httpOnly: true
-        });
+        try {
+          h3.setCookie(event, cookieKey, serialized, {
+            maxAge,
+            path: "/",
+            sameSite: "lax",
+            httpOnly: true
+          });
+        } catch {
+        }
       }
     }
   }
-  async remove(key, nuxtApp) {
+  async remove(key, context) {
     const cookieKey = this.getCookieKey(key);
-    if (this.isClient(nuxtApp)) {
+    if (this.isClient(context)) {
       if (typeof document !== "undefined") {
         document.cookie = `${cookieKey}=; Max-Age=0; Path=/; SameSite=Lax`;
       }
-    } else if (nuxtApp) {
-      const event = nuxtApp.ssrContext?.event;
+    } else if (context) {
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
       if (event) {
         h3.deleteCookie(event, cookieKey, { path: "/", sameSite: "lax", httpOnly: true });
       }
     }
   }
-  async removeByPrefix(prefix, nuxtApp) {
-    const keys = await this.getKeyList(nuxtApp);
+  async removeByPrefix(prefix, context) {
+    const keys = await this.getKeyList(context);
     for (const k of keys) {
       if (k.startsWith(prefix)) {
-        await this.remove(k, nuxtApp);
+        await this.remove(k, context);
       }
     }
   }
-  async getRemainingTime(key, nuxtApp) {
+  async getRemainingTime(key, context) {
     const cookieKey = this.getCookieKey(key);
     let rawValue = null;
-    if (this.isClient(nuxtApp)) {
+    if (this.isClient(context)) {
       const namePrefix = cookieKey + "=";
       const cookies = (typeof document !== "undefined" ? document.cookie : "").split(";");
       for (let i = 0; i < cookies.length; i++) {
@@ -2739,8 +3666,8 @@ class CCookieCache extends ACacheProvider {
           break;
         }
       }
-    } else if (nuxtApp) {
-      const event = nuxtApp.ssrContext?.event;
+    } else if (context) {
+      const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
       if (event) {
         rawValue = h3.getCookie(event, cookieKey) ?? null;
       }
@@ -2764,7 +3691,7 @@ class CCookieCache extends ACacheProvider {
     }
   }
   async cleanupExpired() {
-    if (undefined && typeof document !== "undefined") {
+    if (this.isClient() && typeof document !== "undefined") {
       const now = Date.now();
       const cookies = document.cookie.split(";");
       for (let i = 0; i < cookies.length; i++) {
@@ -2815,17 +3742,38 @@ class CSessionCache extends ACacheProvider {
   static getSnapshot() {
     return this.storage;
   }
-  static cleanupTimer = null;
-  static initCleanupTimer() {
-    if (CSessionCache.cleanupTimer) return;
-    if (typeof window !== "undefined" && typeof setInterval !== "undefined") {
-      CSessionCache.cleanupTimer = setInterval(() => {
-        CSessionCache.getInstance().cleanupExpired().catch((err) => {
-          console.warn("[Katlux Cache] CSessionCache background cleanup error", err);
-        });
-      }, 5 * 60 * 1e3);
-      if (CSessionCache.cleanupTimer?.unref) {
-        CSessionCache.cleanupTimer.unref();
+  static MAX_SERVER_SESSIONS = 5e3;
+  /**
+   * Purges expired entries across all server sessions synchronously when the storage
+   * exceeds MAX_SERVER_SESSIONS. Avoids persistent background setInterval timers on Node.js/SSR.
+   */
+  static purgeExpiredServerSessions() {
+    const now = Date.now();
+    const prefix = "cache:";
+    const sessionsToDelete = [];
+    for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
+      const keysToDelete = [];
+      for (const [key, entry] of sessionData.entries()) {
+        if (key.startsWith(prefix) && now - entry.timestamp > entry.lifetime) {
+          keysToDelete.push(key);
+        }
+      }
+      for (const key of keysToDelete) {
+        sessionData.delete(key);
+      }
+      if (sessionData.size === 0) {
+        sessionsToDelete.push(sessionId);
+      }
+    }
+    for (const sessionId of sessionsToDelete) {
+      CSessionCache.storage.delete(sessionId);
+    }
+    while (CSessionCache.storage.size >= CSessionCache.MAX_SERVER_SESSIONS && CSessionCache.storage.size > 0) {
+      const oldestSessionKey = CSessionCache.storage.keys().next().value;
+      if (oldestSessionKey) {
+        CSessionCache.storage.delete(oldestSessionKey);
+      } else {
+        break;
       }
     }
   }
@@ -2835,12 +3783,22 @@ class CSessionCache extends ACacheProvider {
   constructor() {
     super();
     this.sessionIdCache = CCookieCache.getInstance();
-    CSessionCache.initCleanupTimer();
   }
   /**
    * Generate a UUID v4 sessionId
    */
   generateSessionId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+      const bytes = new Uint8Array(16);
+      crypto.getRandomValues(bytes);
+      bytes[6] = bytes[6] & 15 | 64;
+      bytes[8] = bytes[8] & 63 | 128;
+      const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
     return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
       const r = Math.random() * 16 | 0;
       const v = c === "x" ? r : r & 3 | 8;
@@ -2850,44 +3808,99 @@ class CSessionCache extends ACacheProvider {
   /**
    * Get or create sessionId
    */
-  async getSessionId(nuxtApp) {
-    const contextSessionId = nuxtApp?.ssrContext?.event?.context?.sessionId;
+  async getSessionId(context) {
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
+    if (isServer && !event) {
+      return "__no_session__";
+    }
+    const contextSessionId = event?.context?.sessionId;
     if (contextSessionId) {
       return contextSessionId;
     }
-    if (this.sessionId) {
+    if (!isServer && this.sessionId) {
       return this.sessionId;
     }
-    if (!this.sessionIdCache) {
-      return this.generateSessionId();
+    let existingId = null;
+    if (isServer && event) {
+      const req = event.node?.req || event.req;
+      const cookieHeader = req?.headers?.cookie || "";
+      const match = cookieHeader.match(/(?:^|; )_session_id=([^;]*)/);
+      if (match) existingId = decodeURIComponent(match[1]);
+    } else if (!isServer && typeof document !== "undefined") {
+      const match = document.cookie.match(/(?:^|; )_session_id=([^;]*)/);
+      if (match) existingId = decodeURIComponent(match[1]);
+    }
+    if (!existingId && this.sessionIdCache) {
+      existingId = await this.sessionIdCache.get(this.SESSION_ID_KEY, context);
     }
-    const existingId = await this.sessionIdCache.get(this.SESSION_ID_KEY, nuxtApp);
     if (existingId) {
-      this.sessionId = existingId;
+      if (isServer) {
+        if (event) {
+          if (!event.context) event.context = {};
+          event.context.sessionId = existingId;
+        }
+      } else {
+        this.sessionId = existingId;
+      }
       return existingId;
     }
     const newId = this.generateSessionId();
-    this.sessionId = newId;
+    if (isServer) {
+      if (event) {
+        if (!event.context) event.context = {};
+        event.context.sessionId = newId;
+      }
+    } else {
+      this.sessionId = newId;
+      if (typeof document !== "undefined") {
+        document.cookie = `_session_id=${encodeURIComponent(newId)}; path=/; max-age=31536000; SameSite=Lax`;
+      }
+    }
     if (this.sessionIdCache) {
-      await this.sessionIdCache.set(this.SESSION_ID_KEY, newId, 365 * 24 * 60 * 60 * 1e3, nuxtApp);
+      await this.sessionIdCache.set(this.SESSION_ID_KEY, newId, 365 * 24 * 60 * 60 * 1e3, context);
     }
     return newId;
   }
-  async getKeyList(nuxtApp) {
+  async getKeyList(context) {
     const prefix = "cache:";
-    if (undefined) {
-      return Object.keys(sessionStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
+    if (isServer) {
+      const sessionId = await this.getSessionId(context);
+      const sessionData = CSessionCache.storage.get(sessionId);
+      if (!sessionData) {
+        return [];
+      }
+      return Array.from(sessionData.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
     }
-    const sessionId = await this.getSessionId(nuxtApp);
-    const sessionData = CSessionCache.storage.get(sessionId);
-    if (!sessionData) {
-      return [];
+    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+      return Object.keys(sessionStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
     }
-    return Array.from(sessionData.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+    return [];
   }
-  async get(key, nuxtApp) {
+  async get(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
+    if (isServer) {
+      const sessionId = await this.getSessionId(context);
+      const sessionData = CSessionCache.storage.get(sessionId);
+      if (!sessionData) {
+        return null;
+      }
+      const entry = sessionData.get(prefixedKey);
+      if (!entry) {
+        return null;
+      }
+      if (Date.now() - entry.timestamp <= entry.lifetime) {
+        return entry.data;
+      } else {
+        sessionData.delete(prefixedKey);
+        return null;
+      }
+    }
+    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
       try {
         const stored = sessionStorage.getItem(prefixedKey);
         if (stored) {
@@ -2902,7 +3915,7 @@ class CSessionCache extends ACacheProvider {
         console.warn("[Katlux Cache] CSessionCache parse error for key: " + key, e);
       }
       try {
-        const payloadData = window.__NUXT__?.payload?.data;
+        const payloadData = getSSRPayload(context);
         if (payloadData && payloadData[prefixedKey]) {
           const entry = payloadData[prefixedKey];
           if (Date.now() - entry.timestamp <= entry.lifetime) {
@@ -2915,73 +3928,56 @@ class CSessionCache extends ACacheProvider {
       }
       return null;
     }
-    if (undefined) {
-      const sessionId = await this.getSessionId(nuxtApp);
-      const sessionData = CSessionCache.storage.get(sessionId);
-      if (!sessionData) {
-        return null;
-      }
-      const entry = sessionData.get(prefixedKey);
-      if (!entry) {
-        return null;
-      }
-      if (Date.now() - entry.timestamp <= entry.lifetime) {
-        return entry.data;
-      } else {
-        sessionData.delete(prefixedKey);
-        return null;
-      }
-    }
     return null;
   }
-  async set(key, data, lifetime, nuxtApp) {
+  async set(key, data, lifetime, context) {
     const prefixedKey = "cache:" + key;
     const entry = {
       data,
       timestamp: Date.now(),
       lifetime
     };
-    if (undefined) {
-      try {
-        sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache sessionStorage setItem error (possible quota exceeded) for key: " + key, e);
-      }
-    }
-    if (undefined || nuxtApp) {
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
+    if (isServer) {
       try {
-        const sessionId = await this.getSessionId(nuxtApp);
+        const sessionId = await this.getSessionId(context);
+        if (sessionId === "__no_session__") return;
+        if (CSessionCache.storage.size >= CSessionCache.MAX_SERVER_SESSIONS) {
+          CSessionCache.purgeExpiredServerSessions();
+        }
         let sessionData = CSessionCache.storage.get(sessionId);
         if (!sessionData) {
           sessionData = /* @__PURE__ */ new Map();
-          CSessionCache.storage.set(sessionId, sessionData);
-        }
-        sessionData.set(prefixedKey, entry);
-        if (nuxtApp) {
-          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-          if (payload) {
-            payload[prefixedKey] = entry;
-          }
+          CSessionCache.storage.set(sessionId, sessionData);
         }
+        sessionData.set(prefixedKey, entry);
       } catch (e) {
         console.warn("[Katlux Cache] CSessionCache server session storage error for key: " + key, e);
       }
+      return;
+    }
+    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+      try {
+        sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
+      } catch (e) {
+        console.warn("[Katlux Cache] CSessionCache sessionStorage setItem error (possible quota exceeded) for key: " + key, e);
+      }
     }
   }
-  async remove(key, nuxtApp) {
+  async remove(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
-      sessionStorage.removeItem(prefixedKey);
-    }
-    if (undefined) {
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
+    if (isServer) {
       try {
-        const sessionId = await this.getSessionId(nuxtApp);
+        const sessionId = await this.getSessionId(context);
         const sessionData = CSessionCache.storage.get(sessionId);
         if (sessionData) {
           sessionData.delete(prefixedKey);
         }
-        if (nuxtApp) {
-          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (context) {
+          const payload = context.payload?.data || context.ssrContext?.payload?.data;
           if (payload && payload[prefixedKey]) {
             delete payload[prefixedKey];
           }
@@ -2989,11 +3985,15 @@ class CSessionCache extends ACacheProvider {
       } catch (e) {
         console.warn("[Katlux Cache] CSessionCache remove error on server for key: " + key, e);
       }
+      return;
+    }
+    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+      sessionStorage.removeItem(prefixedKey);
     }
   }
-  async removeByPrefix(prefix, nuxtApp) {
+  async removeByPrefix(prefix, context) {
     const fullPrefix = "cache:" + prefix;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       const keysToDelete = [];
       for (let i = 0; i < sessionStorage.length; i++) {
         const key = sessionStorage.key(i);
@@ -3005,9 +4005,9 @@ class CSessionCache extends ACacheProvider {
         sessionStorage.removeItem(key);
       }
     }
-    if (undefined) {
+    if (typeof window === "undefined") {
       try {
-        const sessionId = await this.getSessionId(nuxtApp);
+        const sessionId = await this.getSessionId(context);
         const sessionData = CSessionCache.storage.get(sessionId);
         if (sessionData) {
           const keysToDelete = [];
@@ -3020,8 +4020,8 @@ class CSessionCache extends ACacheProvider {
             sessionData.delete(key);
           }
         }
-        if (nuxtApp) {
-          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (context) {
+          const payload = context.payload?.data || context.ssrContext?.payload?.data;
           if (payload) {
             for (const key in payload) {
               if (key.startsWith(fullPrefix)) {
@@ -3035,9 +4035,9 @@ class CSessionCache extends ACacheProvider {
       }
     }
   }
-  async getRemainingTime(key, nuxtApp) {
+  async getRemainingTime(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       const entryStr = sessionStorage.getItem(prefixedKey);
       if (!entryStr) return null;
       try {
@@ -3048,8 +4048,8 @@ class CSessionCache extends ACacheProvider {
         return null;
       }
     }
-    if (undefined) {
-      const sessionId = await this.getSessionId(nuxtApp);
+    if (typeof window === "undefined") {
+      const sessionId = await this.getSessionId(context);
       const sessionData = CSessionCache.storage.get(sessionId);
       if (!sessionData) return null;
       const entry = sessionData.get(prefixedKey);
@@ -3061,7 +4061,7 @@ class CSessionCache extends ACacheProvider {
   async cleanupExpired() {
     const prefix = "cache:";
     const now = Date.now();
-    if (undefined) {
+    if (typeof window !== "undefined") {
       const keysToDelete = [];
       for (let i = 0; i < sessionStorage.length; i++) {
         const key = sessionStorage.key(i);
@@ -3084,7 +4084,7 @@ class CSessionCache extends ACacheProvider {
         sessionStorage.removeItem(key);
       }
     }
-    if (undefined || CSessionCache.storage.size > 0) {
+    if (typeof window === "undefined" || CSessionCache.storage.size > 0) {
       const sessionsToDelete = [];
       for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
         const keysToDelete = [];
@@ -3125,13 +4125,13 @@ class CLocalStorageCache extends ACacheProvider {
   type = "LocalStorage";
   constructor() {
     super();
-    if (undefined) {
+    if (typeof window !== "undefined") {
       this._hydrateFromPayload();
     }
   }
   async _hydrateFromPayload() {
     try {
-      const payloadData = index.getSSRPayload();
+      const payloadData = getSSRPayload();
       if (!payloadData) return;
       const prefix = "cache:";
       for (const key in payloadData) {
@@ -3150,14 +4150,14 @@ class CLocalStorageCache extends ACacheProvider {
       console.warn("[Katlux Cache] LocalStorage payload hydration failed", e);
     }
   }
-  async getKeyList(nuxtApp) {
-    if (!undefined) return [];
+  async getKeyList(context) {
+    if (!(typeof window !== "undefined")) return [];
     const prefix = "cache:";
     return Object.keys(localStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
   }
-  async get(key, nuxtApp) {
+  async get(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         const stored = localStorage.getItem(prefixedKey);
         if (stored) {
@@ -3173,11 +4173,11 @@ class CLocalStorageCache extends ACacheProvider {
       }
     }
     try {
-      const payloadData = index.getSSRPayload(nuxtApp);
+      const payloadData = getSSRPayload(context);
       if (payloadData && payloadData[prefixedKey]) {
         const entry = payloadData[prefixedKey];
         if (Date.now() - entry.timestamp <= entry.lifetime) {
-          if (undefined) {
+          if (typeof window !== "undefined") {
             localStorage.setItem(prefixedKey, JSON.stringify(entry));
           }
           return entry.data;
@@ -3188,24 +4188,14 @@ class CLocalStorageCache extends ACacheProvider {
     }
     return null;
   }
-  async set(key, data, lifetime, nuxtApp) {
+  async set(key, data, lifetime, context) {
     const prefixedKey = "cache:" + key;
     const entry = {
       data,
       timestamp: Date.now(),
       lifetime
     };
-    if (undefined && nuxtApp) {
-      try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-        if (payload) {
-          payload[prefixedKey] = entry;
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] LocalStorage error writing to SSR payload for key: " + key, e);
-      }
-    }
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         localStorage.setItem(prefixedKey, JSON.stringify(entry));
       } catch (e) {
@@ -3213,14 +4203,14 @@ class CLocalStorageCache extends ACacheProvider {
       }
     }
   }
-  async remove(key, nuxtApp) {
+  async remove(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       localStorage.removeItem(prefixedKey);
     }
-    if (undefined && nuxtApp) {
+    if (typeof window === "undefined" && context) {
       try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
         if (payload && payload[prefixedKey]) {
           delete payload[prefixedKey];
         }
@@ -3229,9 +4219,9 @@ class CLocalStorageCache extends ACacheProvider {
       }
     }
   }
-  async removeByPrefix(prefix, nuxtApp) {
+  async removeByPrefix(prefix, context) {
     const fullPrefix = "cache:" + prefix;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       const keysToDelete = [];
       for (let i = 0; i < localStorage.length; i++) {
         const key = localStorage.key(i);
@@ -3243,9 +4233,9 @@ class CLocalStorageCache extends ACacheProvider {
         localStorage.removeItem(key);
       }
     }
-    if (undefined && nuxtApp) {
+    if (typeof window === "undefined" && context) {
       try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
         if (payload) {
           for (const key in payload) {
             if (key.startsWith(fullPrefix)) {
@@ -3258,8 +4248,8 @@ class CLocalStorageCache extends ACacheProvider {
       }
     }
   }
-  async getRemainingTime(key, nuxtApp) {
-    if (undefined) {
+  async getRemainingTime(key, context) {
+    if (typeof window !== "undefined") {
       const prefixedKey = "cache:" + key;
       const entryStr = localStorage.getItem(prefixedKey);
       if (!entryStr) return null;
@@ -3274,7 +4264,7 @@ class CLocalStorageCache extends ACacheProvider {
     return null;
   }
   async cleanupExpired() {
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         const prefix = "cache:";
         const now = Date.now();
@@ -3312,21 +4302,31 @@ const CLocalStorageCache$1 = {
 
 class CIndexedDBCache extends ACacheProvider {
   static instance = null;
-  static getInstance() {
-    if (!this.instance) {
-      this.instance = new CIndexedDBCache();
+  static instances = /* @__PURE__ */ new Map();
+  storeName;
+  static getInstance(storeName = "cache") {
+    if (storeName === "cache" && this.instance) {
+      return this.instance;
     }
-    return this.instance;
+    if (!this.instances.has(storeName)) {
+      const inst = new CIndexedDBCache(storeName);
+      this.instances.set(storeName, inst);
+      if (storeName === "cache") {
+        this.instance = inst;
+      }
+    }
+    return this.instances.get(storeName);
   }
-  constructor() {
+  constructor(storeName = "cache") {
     super();
-    if (undefined) {
+    this.storeName = storeName;
+    if (typeof window !== "undefined") {
       this._hydrateFromPayload();
     }
   }
   async _hydrateFromPayload() {
     try {
-      const payloadData = index.getSSRPayload();
+      const payloadData = getSSRPayload();
       if (!payloadData) return;
       const prefix = "cache:";
       let count = 0;
@@ -3336,8 +4336,8 @@ class CIndexedDBCache extends ACacheProvider {
           if (value && typeof value === "object" && "data" in value && "timestamp" in value && "lifetime" in value) {
             KatluxIndexedDB.open().then(async (db) => {
               try {
-                const tx = db.transaction("cache", "readwrite");
-                const store = tx.objectStore("cache");
+                const tx = db.transaction(this.storeName, "readwrite");
+                const store = tx.objectStore(this.storeName);
                 store.put(value, key);
                 tx.commit?.();
               } catch (e) {
@@ -3354,10 +4354,10 @@ class CIndexedDBCache extends ACacheProvider {
     }
   }
   async getStore(mode) {
-    return KatluxIndexedDB.getStore("cache", mode);
+    return KatluxIndexedDB.getStore(this.storeName, mode);
   }
-  async getKeyList(nuxtApp) {
-    if (!undefined) return [];
+  async getKeyList(context) {
+    if (!(typeof window !== "undefined")) return [];
     try {
       const store = await this.getStore("readonly");
       const keys = await new Promise((resolve, reject) => {
@@ -3372,9 +4372,9 @@ class CIndexedDBCache extends ACacheProvider {
       return [];
     }
   }
-  async get(key, nuxtApp) {
+  async get(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         const store = await this.getStore("readonly");
         const data = await new Promise((resolve, reject) => {
@@ -3395,12 +4395,12 @@ class CIndexedDBCache extends ACacheProvider {
       }
     }
     try {
-      const payloadData = index.getSSRPayload(nuxtApp);
+      const payloadData = getSSRPayload(context);
       if (payloadData && payloadData[prefixedKey]) {
         const entry = payloadData[prefixedKey];
         if (Date.now() - entry.timestamp <= entry.lifetime) {
-          if (undefined) {
-            this.set(key, entry.data, entry.lifetime, nuxtApp);
+          if (typeof window !== "undefined") {
+            this.set(key, entry.data, entry.lifetime, context);
           }
           return entry.data;
         }
@@ -3410,24 +4410,14 @@ class CIndexedDBCache extends ACacheProvider {
     }
     return null;
   }
-  async set(key, data, lifetime, nuxtApp) {
+  async set(key, data, lifetime, context) {
     const prefixedKey = "cache:" + key;
     const entry = {
       data,
       timestamp: Date.now(),
       lifetime
     };
-    if (undefined && nuxtApp) {
-      try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-        if (payload) {
-          payload[prefixedKey] = entry;
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] IndexedDB error writing SSR payload for key: " + key, e);
-      }
-    }
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         const store = await this.getStore("readwrite");
         await new Promise((resolve, reject) => {
@@ -3440,9 +4430,9 @@ class CIndexedDBCache extends ACacheProvider {
       }
     }
   }
-  async remove(key, nuxtApp) {
+  async remove(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         const store = await this.getStore("readwrite");
         await new Promise((resolve, reject) => {
@@ -3454,9 +4444,9 @@ class CIndexedDBCache extends ACacheProvider {
         console.warn("[Katlux Cache] IndexedDB error deleting key: " + key, e);
       }
     }
-    if (undefined && nuxtApp) {
+    if (typeof window === "undefined" && context) {
       try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
         if (payload && payload[prefixedKey]) {
           delete payload[prefixedKey];
         }
@@ -3465,9 +4455,9 @@ class CIndexedDBCache extends ACacheProvider {
       }
     }
   }
-  async removeByPrefix(prefix, nuxtApp) {
+  async removeByPrefix(prefix, context) {
     const fullPrefix = "cache:" + prefix;
-    if (undefined) {
+    if (typeof window !== "undefined") {
       try {
         const store = await this.getStore("readwrite");
         const allKeys = await new Promise((resolve, reject) => {
@@ -3487,9 +4477,9 @@ class CIndexedDBCache extends ACacheProvider {
         console.warn("[Katlux Cache] IndexedDB error removing by prefix: " + prefix, e);
       }
     }
-    if (undefined && nuxtApp) {
+    if (typeof window === "undefined" && context) {
       try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
         if (payload) {
           for (const key in payload) {
             if (key.startsWith(fullPrefix)) {
@@ -3502,8 +4492,8 @@ class CIndexedDBCache extends ACacheProvider {
       }
     }
   }
-  async getRemainingTime(key, nuxtApp) {
-    if (undefined) {
+  async getRemainingTime(key, context) {
+    if (typeof window !== "undefined") {
       try {
         const prefixedKey = "cache:" + key;
         const store = await this.getStore("readonly");
@@ -3522,7 +4512,7 @@ class CIndexedDBCache extends ACacheProvider {
     return null;
   }
   async cleanupExpired() {
-    if (!undefined) return;
+    if (!(typeof window !== "undefined")) return;
     try {
       const prefix = "cache:";
       const now = Date.now();
@@ -3563,275 +4553,6 @@ const CIndexedDBCache$1 = {
 	CIndexedDBCache: CIndexedDBCache
 };
 
-class CMemoryCache extends ACacheProvider {
-  static instance = null;
-  static _storage = null;
-  static get storage() {
-    if (!this._storage) this._storage = /* @__PURE__ */ new Map();
-    return this._storage;
-  }
-  static getInstance() {
-    if (!this.instance) {
-      this.instance = new CMemoryCache();
-    }
-    return this.instance;
-  }
-  constructor() {
-    super();
-    if (undefined && CMemoryCache.storage.size === 0) {
-      this._hydrateFromPayload();
-    }
-  }
-  async _hydrateFromPayload() {
-    try {
-      const payloadData = index.getSSRPayload();
-      if (!payloadData) return;
-      for (const key in payloadData) {
-        const value = payloadData[key];
-        if (value && typeof value === "object" && "data" in value && "timestamp" in value && "lifetime" in value) {
-          if (typeof value.lifetime === "number") {
-            CMemoryCache.storage.set(key, value);
-          }
-        }
-      }
-    } catch (e) {
-      console.warn("[Katlux Cache] CMemoryCache payload hydration failed", e);
-    }
-  }
-  async getKeyList(nuxtApp) {
-    const prefix = "cache:";
-    return Array.from(CMemoryCache.storage.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
-  }
-  async get(key, nuxtApp) {
-    const prefixedKey = "cache:" + key;
-    const entry = CMemoryCache.storage.get(prefixedKey);
-    if (entry) {
-      if (Date.now() - entry.timestamp <= entry.lifetime) {
-        return entry.data;
-      } else {
-        CMemoryCache.storage.delete(prefixedKey);
-      }
-    }
-    try {
-      const payloadData = index.getSSRPayload(nuxtApp);
-      if (payloadData && payloadData[prefixedKey]) {
-        const entry2 = payloadData[prefixedKey];
-        if (Date.now() - entry2.timestamp <= entry2.lifetime) {
-          CMemoryCache.storage.set(prefixedKey, entry2);
-          return entry2.data;
-        }
-      }
-    } catch (e) {
-      console.warn("[Katlux Cache] CMemoryCache error reading SSR payload for key: " + key, e);
-    }
-    return null;
-  }
-  async set(key, data, lifetime, nuxtApp) {
-    const prefixedKey = "cache:" + key;
-    const entry = {
-      data,
-      timestamp: Date.now(),
-      lifetime
-    };
-    if (undefined && nuxtApp) {
-      try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-        if (payload) {
-          payload[prefixedKey] = entry;
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] CMemoryCache error writing SSR payload for key: " + key, e);
-      }
-    }
-    CMemoryCache.storage.set(prefixedKey, entry);
-  }
-  async remove(key, nuxtApp) {
-    const prefixedKey = "cache:" + key;
-    CMemoryCache.storage.delete(prefixedKey);
-    if (undefined && nuxtApp) {
-      try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-        if (payload && payload[prefixedKey]) {
-          delete payload[prefixedKey];
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] CMemoryCache error deleting key from SSR payload: " + key, e);
-      }
-    }
-  }
-  async removeByPrefix(prefix, nuxtApp) {
-    const fullPrefix = "cache:" + prefix;
-    const keysToDelete = [];
-    for (const key of CMemoryCache.storage.keys()) {
-      if (key.startsWith(fullPrefix)) {
-        keysToDelete.push(key);
-      }
-    }
-    for (const key of keysToDelete) {
-      CMemoryCache.storage.delete(key);
-    }
-    if (undefined && nuxtApp) {
-      try {
-        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-        if (payload) {
-          for (const key in payload) {
-            if (key.startsWith(fullPrefix)) {
-              delete payload[key];
-            }
-          }
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] CMemoryCache error removing prefix from SSR payload: " + prefix, e);
-      }
-    }
-  }
-  async getRemainingTime(key, nuxtApp) {
-    const prefixedKey = "cache:" + key;
-    const entry = CMemoryCache.storage.get(prefixedKey);
-    if (!entry) return null;
-    return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
-  }
-  async cleanupExpired() {
-    const prefix = "cache:";
-    const now = Date.now();
-    const keysToDelete = [];
-    for (const [key, entry] of CMemoryCache.storage.entries()) {
-      if (key.startsWith(prefix)) {
-        if (now - entry.timestamp > entry.lifetime) {
-          keysToDelete.push(key);
-        }
-      }
-    }
-    for (const key of keysToDelete) {
-      CMemoryCache.storage.delete(key);
-    }
-  }
-}
-
-const CMemoryCache$1 = {
-	__proto__: null,
-	CMemoryCache: CMemoryCache
-};
-
-class CApplicationCache extends ACacheProvider {
-  static instance = null;
-  static _storage = null;
-  static get storage() {
-    if (!this._storage) {
-      this._storage = /* @__PURE__ */ new Map();
-    }
-    return this._storage;
-  }
-  static getInstance() {
-    if (!this.instance) {
-      this.instance = new CApplicationCache();
-    }
-    return this.instance;
-  }
-  static getSnapshot() {
-    return this.storage;
-  }
-  constructor() {
-    super();
-  }
-  async getKeyList(nuxtApp) {
-    const prefix = "cache:";
-    const storage = CApplicationCache.storage;
-    return Array.from(storage.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
-  }
-  async get(key, nuxtApp) {
-    if (undefined) {
-      const prefixedKey = "cache:" + key;
-      const storage = CApplicationCache.storage;
-      const entry = storage.get(prefixedKey);
-      if (!entry) return null;
-      if (Date.now() - entry.timestamp > entry.lifetime) {
-        storage.delete(prefixedKey);
-        return null;
-      }
-      return entry.data;
-    }
-    return null;
-  }
-  async set(key, data, lifetime, nuxtApp) {
-    if (undefined) {
-      const prefixedKey = "cache:" + key;
-      const storage = CApplicationCache.storage;
-      storage.set(prefixedKey, {
-        data,
-        timestamp: Date.now(),
-        lifetime
-      });
-    }
-  }
-  async remove(key, nuxtApp) {
-    if (undefined) {
-      const prefixedKey = "cache:" + key;
-      CApplicationCache.storage.delete(prefixedKey);
-    }
-  }
-  async removeByPrefix(prefix, nuxtApp) {
-    if (undefined) {
-      const fullPrefix = "cache:" + prefix;
-      const storage = CApplicationCache.storage;
-      const keysToDelete = [];
-      for (const key of storage.keys()) {
-        if (key.startsWith(fullPrefix)) {
-          keysToDelete.push(key);
-        }
-      }
-      for (const key of keysToDelete) {
-        storage.delete(key);
-      }
-    }
-  }
-  async getRemainingTime(key, nuxtApp) {
-    if (undefined) {
-      const prefixedKey = "cache:" + key;
-      const storage = CApplicationCache.storage;
-      const entry = storage.get(prefixedKey);
-      if (!entry) return null;
-      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
-    }
-    return null;
-  }
-  async cleanupExpired() {
-    if (undefined) {
-      const prefix = "cache:";
-      const now = Date.now();
-      const storage = CApplicationCache.storage;
-      const keysToDelete = [];
-      for (const [key, entry] of storage.entries()) {
-        if (key.startsWith(prefix)) {
-          if (now - entry.timestamp > entry.lifetime) {
-            keysToDelete.push(key);
-          }
-        }
-      }
-      for (const key of keysToDelete) {
-        storage.delete(key);
-      }
-    }
-  }
-}
-
-const CApplicationCache$1 = {
-	__proto__: null,
-	CApplicationCache: CApplicationCache
-};
-
-exports.DefaultHydrationAdapter = index.DefaultHydrationAdapter;
-exports.NuxtHydrationAdapter = index.NuxtHydrationAdapter;
-exports.clearSSRData = index.clearSSRData;
-exports.fetchWithSSR = index.fetchWithSSR;
-exports.getAppRoute = index.getAppRoute;
-exports.getAppRouter = index.getAppRouter;
-exports.getHydrationAdapter = index.getHydrationAdapter;
-exports.getPlatformApp = index.getPlatformApp;
-exports.getSSRData = index.getSSRData;
-exports.getSSRPayload = index.getSSRPayload;
-exports.onPlatformReady = index.onPlatformReady;
-exports.setHydrationAdapter = index.setHydrationAdapter;
 exports.AAPIDataProvider = AAPIDataProvider;
 exports.ADataProvider = ADataProvider;
 exports.CAPIFlatClientDataProvider = CAPIFlatClientDataProvider;
@@ -3849,6 +4570,7 @@ exports.CSessionCache = CSessionCache;
 exports.CTreeClientDataProvider = CTreeClientDataProvider;
 exports.CTreeServerDataProvider = CTreeServerDataProvider;
 exports.CacheProviderFactory = CacheProviderFactory;
+exports.DefaultHydrationAdapter = DefaultHydrationAdapter;
 exports.ECacheStrategy = ECacheStrategy;
 exports.EDataFilterOperator = EDataFilterOperator;
 exports.EQueueStorage = EQueueStorage;
@@ -3857,7 +4579,9 @@ exports.QueueStorageFactory = QueueStorageFactory;
 exports.RequestProvider = RequestProvider;
 exports.RequestProviderRegistry = RequestProviderRegistry;
 exports.RequestQueue = RequestQueue;
+exports.SENSITIVE_HEADER_KEYS = SENSITIVE_HEADER_KEYS;
 exports.applyOperator = applyOperator;
+exports.clearSSRData = clearSSRData;
 exports.compareAnd = compareAnd;
 exports.compareEqual = compareEqual;
 exports.compareIn = compareIn;
@@ -3865,8 +4589,17 @@ exports.compareOr = compareOr;
 exports.compareValues = compareValues;
 exports.debounce = debounce;
 exports.evaluateFilter = evaluateFilter;
+exports.fetchWithSSR = fetchWithSSR;
 exports.filterData = filterData;
 exports.filterTreeData = filterTreeData;
+exports.getAppRoute = getAppRoute;
+exports.getAppRouter = getAppRouter;
+exports.getHydrationAdapter = getHydrationAdapter;
+exports.getPlatformApp = getPlatformApp;
+exports.getSSRData = getSSRData;
+exports.getSSRPayload = getSSRPayload;
+exports.onPlatformReady = onPlatformReady;
+exports.setHydrationAdapter = setHydrationAdapter;
 exports.sortData = sortData;
 exports.useDebounce = useDebounce;
 exports.useFilterLogic = useFilterLogic;