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

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"] = "!=";
@@ -21,7 +21,8 @@ var EDataFilterOperator = /* @__PURE__ */ ((EDataFilterOperator2) => {
 })(EDataFilterOperator || {});
 var ECacheStrategy = /* @__PURE__ */ ((ECacheStrategy2) => {
   ECacheStrategy2["Application"] = "Application";
-  ECacheStrategy2["Session"] = "Session";
+  ECacheStrategy2["ServerSession"] = "ServerSession";
+  ECacheStrategy2["BrowserSession"] = "BrowserSession";
   ECacheStrategy2["Memory"] = "Memory";
   ECacheStrategy2["LocalStorage"] = "LocalStorage";
   ECacheStrategy2["IndexedDB"] = "IndexedDB";
@@ -37,36 +38,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 +275,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 +291,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) {
@@ -135,11 +312,16 @@ class ADataProvider {
       } catch {
       }
     }
+    const filterDebounceTime = typeof options?.filterDebounce === "number" ? options.filterDebounce : 300;
+    const sortDebounceTime = typeof options?.sortDebounce === "number" ? options.sortDebounce : 200;
     this._debouncedFilterLoad = useDebounce(() => {
       this._currentPage = 1;
       this.loadPageData();
-      this.notify();
-    }, 300);
+    }, filterDebounceTime);
+    this._debouncedSortLoad = useDebounce(() => {
+      this._currentPage = 1;
+      this.loadPageData();
+    }, sortDebounceTime);
     this.setFilter = this.setFilter.bind(this);
     this.setSortList = this.setSortList.bind(this);
     this.setCurrentPage = this.setCurrentPage.bind(this);
@@ -149,21 +331,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 {
@@ -180,24 +412,35 @@ class ADataProvider {
       selectAll: this.selectAll
     };
   }
-  setFilter(filter) {
+  setFilter(filter, immediate = false) {
     this._filter = filter;
-    this._debouncedFilterLoad();
+    this._currentPage = 1;
+    if (immediate) {
+      this._debouncedFilterLoad?.cancel?.();
+      this.loadPageData();
+    } else {
+      this._debouncedFilterLoad();
+    }
   }
-  setSortList(sortList) {
+  setSortList(sortList, immediate = false) {
     this._sortList = sortList;
     this._currentPage = 1;
-    this.loadPageData();
-    this.notify();
+    if (immediate) {
+      this._debouncedSortLoad?.cancel?.();
+      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 +469,10 @@ class ADataProvider {
   async refresh(hardRefresh = false) {
     await this.loadPageData({ disableCache: hardRefresh });
   }
+  cancelPending() {
+    this._debouncedFilterLoad?.cancel?.();
+    this._debouncedSortLoad?.cancel?.();
+  }
 }
 
 const compareIn = (rowValue, filterValue) => {
@@ -259,22 +506,38 @@ const compareValues = (rowValue, filterValue) => {
   return String(rowValue).localeCompare(String(filterValue));
 };
 const compareAnd = (row, nested) => {
-  const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
-  const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
-  if (validFilters.length === 0) return true;
-  return validFilters.every((f) => {
-    const active = f.active !== false;
-    return active ? evaluateFilter(f, row) : true;
-  });
+  if (!nested) return true;
+  const subFilters = Array.isArray(nested) ? nested : typeof nested === "object" ? Object.values(nested) : [];
+  const len = subFilters.length;
+  for (let i = 0; i < len; i++) {
+    const f = subFilters[i];
+    if (f && typeof f === "object" && "operator" in f && "field" in f) {
+      const active = f.active !== false;
+      if (active && !evaluateFilter(f, row)) {
+        return false;
+      }
+    }
+  }
+  return true;
 };
 const compareOr = (row, nested) => {
-  const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
-  const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
-  const activeFilters = validFilters.filter((f) => f.active !== false);
-  if (activeFilters.length === 0) return true;
-  return activeFilters.some((f) => {
-    return evaluateFilter(f, row);
-  });
+  if (!nested) return true;
+  const subFilters = Array.isArray(nested) ? nested : typeof nested === "object" ? Object.values(nested) : [];
+  const len = subFilters.length;
+  let hasActive = false;
+  for (let i = 0; i < len; i++) {
+    const f = subFilters[i];
+    if (f && typeof f === "object" && "operator" in f && "field" in f) {
+      const active = f.active !== false;
+      if (active) {
+        hasActive = true;
+        if (evaluateFilter(f, row)) {
+          return true;
+        }
+      }
+    }
+  }
+  return !hasActive;
 };
 const applyOperator = (operator, rowValue, filterValue) => {
   switch (operator) {
@@ -307,20 +570,26 @@ const applyOperator = (operator, rowValue, filterValue) => {
   }
 };
 const evaluateFilter = (filter, row) => {
-  if (!filter || !filter.operator) return true;
-  if (filter.operator === EDataFilterOperator.And || filter.operator === EDataFilterOperator.Or || filter.operator === EDataFilterOperator.Nand || filter.operator === EDataFilterOperator.Nor) {
-    return !filter.active || applyOperator(filter.operator, row, filter.field);
+  if (!filter || !filter.operator || filter.active === false) return true;
+  const op = filter.operator;
+  if (op === EDataFilterOperator.And || op === EDataFilterOperator.Or || op === EDataFilterOperator.Nand || op === EDataFilterOperator.Nor) {
+    return applyOperator(op, row, filter.field);
   }
   if (filter.field && typeof filter.field === "object" && "operator" in filter.field && "field" in filter.field) {
-    return !filter.active || evaluateFilter(filter.field, row);
+    return evaluateFilter(filter.field, row);
   }
   const field = filter.field;
-  const fieldKeys = Object.keys(field);
-  return !filter.active || fieldKeys.every((key) => {
-    const filterValue = field[key];
-    const rowValue = row[key];
-    return applyOperator(filter.operator, rowValue, filterValue);
-  });
+  if (!field || typeof field !== "object") return true;
+  for (const key in field) {
+    if (Object.prototype.hasOwnProperty.call(field, key)) {
+      const filterValue = field[key];
+      const rowValue = row ? row[key] : void 0;
+      if (!applyOperator(op, rowValue, filterValue)) {
+        return false;
+      }
+    }
+  }
+  return true;
 };
 const filterTreeData = (nodes, filter, options) => {
   const { idKey, parentKey } = options;
@@ -388,7 +657,13 @@ const filterData = (data, filter, options) => {
     );
     return { results: visibleNodes, expandedNodes };
   }
-  const results = data.filter((row) => evaluateFilter(filter, row));
+  const len = data.length;
+  const results = [];
+  for (let i = 0; i < len; i++) {
+    if (evaluateFilter(filter, data[i])) {
+      results.push(data[i]);
+    }
+  }
   return { results };
 };
 const useFilterLogic = () => {
@@ -456,50 +731,94 @@ const useSortLogic = () => {
 };
 
 class CFlatClientDataProvider extends ADataProvider {
-  allData = [];
+  _allData = [];
   filteredData = [];
+  // Reference map array holding active sorted & filtered row references
+  _rowMap = [];
+  _filterDirty = true;
+  _sortDirty = true;
   constructor(options) {
     super(options);
   }
+  get allData() {
+    return this._allData;
+  }
+  set allData(data) {
+    this._allData = Array.isArray(data) ? data : [];
+    this._filterDirty = true;
+    this._sortDirty = true;
+  }
+  get rowMap() {
+    return this._rowMap;
+  }
   setData(data) {
     this.allData = Array.isArray(data) ? data : [];
     this.loadPageData();
   }
+  setFilter(filter, immediate = false) {
+    this._filterDirty = true;
+    this._sortDirty = true;
+    super.setFilter(filter, immediate);
+  }
+  setSortList(sortList, immediate = false) {
+    this._sortDirty = true;
+    super.setSortList(sortList, immediate);
+  }
+  /**
+   * Explicitly rebuilds the reference map array if row properties inside allData were mutated in-place.
+   */
+  updateMap() {
+    this._filterDirty = true;
+    this._sortDirty = true;
+    this.loadPageData();
+  }
   async refreshData(options) {
+    this._filterDirty = true;
+    this._sortDirty = true;
     await this.loadPageData();
   }
   async refresh(hardRefresh = false) {
     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._filterDirty) {
+          if (!this.filter || !this.filter.active) {
+            this.filteredData = this.allData;
+          } else {
+            const { results } = filterData(this.allData, this.filter);
+            this.filteredData = results;
+          }
+          this.rowCount = this.filteredData.length;
+          this._filterDirty = false;
+          this._sortDirty = true;
+        }
+        if (this._sortDirty) {
+          if (this.sortList.length > 0) {
+            this._rowMap = sortData(this.sortList, this.filteredData);
+          } else {
+            this._rowMap = this.filteredData;
+          }
+          this._sortDirty = false;
+        }
+        if (this.pageSize <= 0) {
+          this.pageData = this._rowMap;
+        } else {
+          const startIndex = (this.currentPage - 1) * this.pageSize;
+          const endIndex = startIndex + this.pageSize;
+          this.pageData = this._rowMap.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();
-    }
+    });
   }
 }
 
@@ -508,7 +827,8 @@ class CacheProviderFactory {
   static customDrivers = /* @__PURE__ */ new Map();
   static defaultLoaders = {
     [ECacheStrategy.Application]: () => Promise.resolve().then(function () { return CApplicationCache$1; }).then((m) => m.CApplicationCache),
-    [ECacheStrategy.Session]: () => Promise.resolve().then(function () { return CSessionCache$1; }).then((m) => m.CSessionCache),
+    [ECacheStrategy.ServerSession]: () => Promise.resolve().then(function () { return CServerSessionCache$1; }).then((m) => m.CServerSessionCache),
+    [ECacheStrategy.BrowserSession]: () => Promise.resolve().then(function () { return CBrowserSessionCache$1; }).then((m) => m.CBrowserSessionCache),
     [ECacheStrategy.Memory]: () => Promise.resolve().then(function () { return CMemoryCache$1; }).then((m) => m.CMemoryCache),
     [ECacheStrategy.LocalStorage]: () => Promise.resolve().then(function () { return CLocalStorageCache$1; }).then((m) => m.CLocalStorageCache),
     [ECacheStrategy.IndexedDB]: () => Promise.resolve().then(function () { return CIndexedDBCache$1; }).then((m) => m.CIndexedDBCache),
@@ -569,118 +889,444 @@ class ACacheProvider {
   }
 }
 
-class KatluxIndexedDB {
-  static db = null;
-  static openPromise = null;
-  static currentVersion = 3;
-  static customStores = /* @__PURE__ */ new Set();
-  static DB_NAME = "KatluxDB";
-  static get DB_VERSION() {
-    return KatluxIndexedDB.currentVersion;
-  }
-  /**
-   * Opens (or returns the existing) shared IDBDatabase connection.
-   * Safe to call multiple times — always resolves to the same instance.
-   */
-  static open() {
-    if (this.db) return Promise.resolve(this.db);
-    if (this.openPromise) return this.openPromise;
-    this.openPromise = new Promise((resolve, reject) => {
-      if (typeof indexedDB === "undefined") {
-        return reject(new Error("IndexedDB is not available in this environment"));
-      }
-      const req = indexedDB.open(KatluxIndexedDB.DB_NAME, KatluxIndexedDB.currentVersion);
-      req.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        if (!db.objectStoreNames.contains("cache")) db.createObjectStore("cache");
-        if (!db.objectStoreNames.contains("queue")) db.createObjectStore("queue");
-        if (!db.objectStoreNames.contains("dead_letter")) db.createObjectStore("dead_letter");
-        for (const store of KatluxIndexedDB.customStores) {
-          if (!db.objectStoreNames.contains(store)) {
-            db.createObjectStore(store);
-          }
-        }
-      };
-      req.onsuccess = () => {
-        KatluxIndexedDB.db = req.result;
-        if (req.result.version) {
-          KatluxIndexedDB.currentVersion = req.result.version;
-        }
-        req.result.onversionchange = () => {
-          req.result.close();
-          KatluxIndexedDB.db = null;
-          KatluxIndexedDB.openPromise = null;
-          console.warn("[KatluxIndexedDB] Database closed due to version change. Will reopen on next access.");
-        };
-        resolve(KatluxIndexedDB.db);
-      };
-      req.onerror = () => {
-        KatluxIndexedDB.openPromise = null;
-        reject(req.error);
-      };
-      req.onblocked = () => {
-        console.warn("[KatluxIndexedDB] Database upgrade blocked by another open connection.");
-      };
-    });
-    return this.openPromise;
+class CApplicationCache extends ACacheProvider {
+  static instance = null;
+  static _storage = null;
+  static get storage() {
+    if (!this._storage) {
+      this._storage = /* @__PURE__ */ new Map();
+    }
+    return this._storage;
   }
-  /**
-   * Dynamically ensures that an object store exists in the database.
-   * If not present, performs a database version bump and creates the store.
-   */
-  static async ensureStore(storeName) {
-    KatluxIndexedDB.customStores.add(storeName);
-    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);
-        };
-      });
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CApplicationCache();
     }
-    return db;
+    return this.instance;
+  }
+  static MAX_ENTRIES = 1e4;
+  static getSnapshot() {
+    return this.storage;
   }
   /**
-   * Returns a transaction-bound object store.
-   * Convenience wrapper used by CIndexedDBCache, QueueStorage adapters, etc.
+   * Purges expired entries when storage size reaches MAX_ENTRIES watermark.
+   * Avoids persistent background setInterval timers on Node.js/SSR.
    */
-  static async getStore(storeName, mode) {
-    let db = await KatluxIndexedDB.open();
-    if (!db.objectStoreNames.contains(storeName)) {
-      db = await KatluxIndexedDB.ensureStore(storeName);
+  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);
+      }
     }
-    return db.transaction(storeName, mode).objectStore(storeName);
   }
   /**
-   * For testing only — resets the singleton so tests can start fresh.
+   * Clears all cached entries (used for test isolation).
    */
-  static _reset() {
-    if (this.db) {
+  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;
+  static currentVersion = 3;
+  static customStores = /* @__PURE__ */ new Set();
+  static DB_NAME = "KatluxDB";
+  static get DB_VERSION() {
+    return KatluxIndexedDB.currentVersion;
+  }
+  /**
+   * Opens (or returns the existing) shared IDBDatabase connection.
+   * Safe to call multiple times — always resolves to the same instance.
+   */
+  static open() {
+    if (this.db) return Promise.resolve(this.db);
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = new Promise((resolve, reject) => {
+      if (typeof indexedDB === "undefined") {
+        return reject(new Error("IndexedDB is not available in this environment"));
+      }
+      const req = indexedDB.open(KatluxIndexedDB.DB_NAME);
+      req.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains("cache")) db.createObjectStore("cache");
+        if (!db.objectStoreNames.contains("queue")) db.createObjectStore("queue");
+        if (!db.objectStoreNames.contains("dead_letter")) db.createObjectStore("dead_letter");
+        for (const store of KatluxIndexedDB.customStores) {
+          if (!db.objectStoreNames.contains(store)) {
+            db.createObjectStore(store);
+          }
+        }
+      };
+      req.onsuccess = async () => {
+        const db = req.result;
+        KatluxIndexedDB.db = db;
+        if (db.version) {
+          KatluxIndexedDB.currentVersion = db.version;
+        }
+        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 = () => {
+        KatluxIndexedDB.openPromise = null;
+        reject(req.error);
+      };
+      req.onblocked = () => {
+        console.warn("[KatluxIndexedDB] Database upgrade blocked by another open connection.");
+      };
+    });
+    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.
+   */
+  static async ensureStore(storeName) {
+    KatluxIndexedDB.customStores.add(storeName);
+    let db = await KatluxIndexedDB.open();
+    if (!db.objectStoreNames.contains(storeName)) {
+      const newVersion = (db.version || KatluxIndexedDB.currentVersion) + 1;
+      db = await KatluxIndexedDB.upgradeToVersion(newVersion);
+    }
+    return db;
+  }
+  /**
+   * Returns a transaction-bound object store.
+   * Convenience wrapper used by CIndexedDBCache, QueueStorage adapters, etc.
+   */
+  static async getStore(storeName, mode) {
+    let db = await KatluxIndexedDB.open();
+    if (!db.objectStoreNames.contains(storeName)) {
+      db = await KatluxIndexedDB.ensureStore(storeName);
+    }
+    return db.transaction(storeName, mode).objectStore(storeName);
+  }
+  /**
+   * For testing only — resets the singleton so tests can start fresh.
+   */
+  static _reset() {
+    if (this.db) {
       this.db.close();
       this.db = null;
     }
@@ -814,8 +1460,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 +1484,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 +1502,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.
@@ -872,13 +1526,96 @@ class RequestProviderRegistry {
 }
 
 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 +1636,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 +1647,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 +1673,7 @@ class RequestQueue {
   static setStorageBackend(backend) {
     this.adapter = QueueStorageFactory.getAdapter(backend);
     this.initialized = false;
+    this.initPromise = null;
   }
   // ── Hooks ─────────────────────────────────────────────────────────────────
   static onDeadLetter(cb) {
@@ -940,8 +1693,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 +1852,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 +1892,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 +1916,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 +2005,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 +2031,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 +2120,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 +2145,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 +2169,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 +2215,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 +2293,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 +2384,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 +2425,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,26 +2434,25 @@ 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();
+        this.updateMap();
       }
       if (this.requestProvider.cacheProvider) {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
       }
       if (this.contextKey) {
-        index.clearSSRData(this.contextKey, this.context);
+        clearSSRData(this.contextKey, this.context);
       }
     }
   }
@@ -1527,7 +2463,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 +2475,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 +2529,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 +2553,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 +2589,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 +2610,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 +2635,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 +2655,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 +2669,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 +2683,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) {
@@ -1775,10 +2719,16 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
   _staticNodesCache = null;
   _nodeMapCache = null;
   _sortedNodeIdsCache = null;
+  _filteredNodesCache = null;
   invalidateStaticCache() {
     this._staticNodesCache = null;
     this._nodeMapCache = null;
     this._sortedNodeIdsCache = null;
+    this._filteredNodesCache = null;
+  }
+  setFilter(filter, immediate = false) {
+    this._filteredNodesCache = null;
+    super.setFilter(filter, immediate);
   }
   get _staticNodes() {
     if (!this._staticNodesCache) {
@@ -1906,22 +2856,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;
@@ -1961,41 +2935,48 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
     }
   }
   updatePageData() {
-    if (!this._staticNodesCache || this._staticNodesCache.length !== this.allData.length) {
-      this.invalidateStaticCache();
-    }
-    const nodeMap = this._nodeMap;
-    const sortedIds = this._sortedNodeIds;
-    if (this.filter && this.filter.active) {
-      const matchingNodes = this._staticNodes.filter((node) => evaluateFilter(this.filter, node.data));
-      const matchingIds = new Set(matchingNodes.map((node) => node.id));
-      const visibleIds = /* @__PURE__ */ new Set();
-      matchingIds.forEach((id) => {
-        let current = nodeMap.get(id);
-        while (current) {
-          visibleIds.add(current.id);
-          current = current.parentId != null ? nodeMap.get(current.parentId) : void 0;
-        }
-      });
-      visibleIds.forEach((id) => {
-        if (nodeMap.get(id)?.hasChildren) {
-          this.expandedNodes.add(id);
-        }
-      });
-      const filteredNodes = sortedIds.filter((id) => visibleIds.has(id)).map((id) => {
-        const node = nodeMap.get(id);
-        return {
-          ...node,
-          isExpanded: this.expandedNodes.has(id)
-        };
-      });
+    if (!this._staticNodesCache || this._staticNodesCache.length !== this.allData.length) {
+      this.invalidateStaticCache();
+    }
+    const nodeMap = this._nodeMap;
+    const sortedIds = this._sortedNodeIds;
+    if (this.filter && this.filter.active) {
+      if (!this._filteredNodesCache) {
+        const matchingNodes = this._staticNodes.filter((node) => evaluateFilter(this.filter, node.data));
+        const matchingIds = new Set(matchingNodes.map((node) => node.id));
+        const visibleIds = /* @__PURE__ */ new Set();
+        matchingIds.forEach((id) => {
+          let current = nodeMap.get(id);
+          while (current) {
+            visibleIds.add(current.id);
+            current = current.parentId != null ? nodeMap.get(current.parentId) : void 0;
+          }
+        });
+        const filterExpanded = new Set(this.expandedNodes);
+        visibleIds.forEach((id) => {
+          if (nodeMap.get(id)?.hasChildren) {
+            filterExpanded.add(id);
+          }
+        });
+        this._filteredNodesCache = sortedIds.filter((id) => visibleIds.has(id)).map((id) => {
+          const node = nodeMap.get(id);
+          return {
+            ...node,
+            isExpanded: filterExpanded.has(id)
+          };
+        });
+      }
+      const filteredNodes = this._filteredNodesCache;
       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 +3014,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 +3099,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 +3134,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 +3201,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 +3244,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 +3253,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 +3272,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 +3283,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 +3296,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 +3375,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 +3399,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 +3478,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 +3500,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 +3529,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 +3546,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 +3560,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 +3574,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 +3609,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 +3631,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 +3645,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 +3658,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 +3681,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 +3690,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 +3698,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 +3757,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 +3782,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++) {
@@ -2796,16 +3814,16 @@ const CCookieCache$1 = {
 	CCookieCache: CCookieCache
 };
 
-class CSessionCache extends ACacheProvider {
+class CServerSessionCache extends ACacheProvider {
   static instance = null;
   static getInstance() {
     if (!this.instance) {
-      this.instance = new CSessionCache();
+      this.instance = new CServerSessionCache();
     }
     return this.instance;
   }
   static get storage() {
-    const globalKey = Symbol.for("Katlux_CSessionCache_Storage");
+    const globalKey = Symbol.for("Katlux_CServerSessionCache_Storage");
     const _global = globalThis;
     if (!_global[globalKey]) {
       _global[globalKey] = /* @__PURE__ */ new Map();
@@ -2815,32 +3833,62 @@ 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 CServerSessionCache.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) {
+      CServerSessionCache.storage.delete(sessionId);
+    }
+    while (CServerSessionCache.storage.size >= CServerSessionCache.MAX_SERVER_SESSIONS && CServerSessionCache.storage.size > 0) {
+      const oldestSessionKey = CServerSessionCache.storage.keys().next().value;
+      if (oldestSessionKey) {
+        CServerSessionCache.storage.delete(oldestSessionKey);
+      } else {
+        break;
       }
     }
   }
   sessionIdCache = null;
-  sessionId = null;
   SESSION_ID_KEY = "_session_id";
   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;
@@ -2848,270 +3896,304 @@ class CSessionCache extends ACacheProvider {
     });
   }
   /**
-   * Get or create sessionId
+   * Get or create sessionId — server-only path.
+   * Returns '__no_session__' sentinel when no isolatable H3 event context is available.
    */
-  async getSessionId(nuxtApp) {
-    const contextSessionId = nuxtApp?.ssrContext?.event?.context?.sessionId;
+  async getSessionId(context) {
+    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
+    if (!event) {
+      return "__no_session__";
+    }
+    const contextSessionId = event?.context?.sessionId;
     if (contextSessionId) {
       return contextSessionId;
     }
-    if (this.sessionId) {
-      return this.sessionId;
+    let existingId = null;
+    const req = event.node?.req || event.req;
+    const cookieHeader = req?.headers?.cookie || "";
+    const match = cookieHeader.match(/(?:^|; )_session_id=([^;]*)/);
+    if (match) existingId = decodeURIComponent(match[1]);
+    if (!existingId && this.sessionIdCache) {
+      existingId = await this.sessionIdCache.get(this.SESSION_ID_KEY, context);
     }
-    if (!this.sessionIdCache) {
-      return this.generateSessionId();
-    }
-    const existingId = await this.sessionIdCache.get(this.SESSION_ID_KEY, nuxtApp);
     if (existingId) {
-      this.sessionId = existingId;
+      if (!event.context) event.context = {};
+      event.context.sessionId = existingId;
       return existingId;
     }
     const newId = this.generateSessionId();
-    this.sessionId = newId;
+    if (!event.context) event.context = {};
+    event.context.sessionId = newId;
     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 sessionId = await this.getSessionId(nuxtApp);
-    const sessionData = CSessionCache.storage.get(sessionId);
+    const sessionId = await this.getSessionId(context);
+    const sessionData = CServerSessionCache.storage.get(sessionId);
     if (!sessionData) {
       return [];
     }
     return Array.from(sessionData.keys()).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) {
-      try {
-        const stored = sessionStorage.getItem(prefixedKey);
-        if (stored) {
-          const entry = JSON.parse(stored);
-          if (Date.now() - entry.timestamp <= entry.lifetime) {
-            return entry.data;
-          } else {
-            sessionStorage.removeItem(prefixedKey);
-          }
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache parse error for key: " + key, e);
-      }
-      try {
-        const payloadData = window.__NUXT__?.payload?.data;
-        if (payloadData && payloadData[prefixedKey]) {
-          const entry = payloadData[prefixedKey];
-          if (Date.now() - entry.timestamp <= entry.lifetime) {
-            window.sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
-            return entry.data;
-          }
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache SSR payload fallback error for key: " + key, e);
-      }
+    const sessionId = await this.getSessionId(context);
+    const sessionData = CServerSessionCache.storage.get(sessionId);
+    if (!sessionData) {
       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;
-      }
+    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);
+    try {
+      const sessionId = await this.getSessionId(context);
+      if (sessionId === "__no_session__") return;
+      if (CServerSessionCache.storage.size >= CServerSessionCache.MAX_SERVER_SESSIONS) {
+        CServerSessionCache.purgeExpiredServerSessions();
       }
-    }
-    if (undefined || nuxtApp) {
-      try {
-        const sessionId = await this.getSessionId(nuxtApp);
-        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;
-          }
-        }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache server session storage error for key: " + key, e);
+      let sessionData = CServerSessionCache.storage.get(sessionId);
+      if (!sessionData) {
+        sessionData = /* @__PURE__ */ new Map();
+        CServerSessionCache.storage.set(sessionId, sessionData);
       }
+      sessionData.set(prefixedKey, entry);
+    } catch (e) {
+      console.warn("[Katlux Cache] CServerSessionCache server session storage error for key: " + key, e);
     }
   }
-  async remove(key, nuxtApp) {
+  async remove(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
-      sessionStorage.removeItem(prefixedKey);
-    }
-    if (undefined) {
-      try {
-        const sessionId = await this.getSessionId(nuxtApp);
-        const sessionData = CSessionCache.storage.get(sessionId);
-        if (sessionData) {
-          sessionData.delete(prefixedKey);
-        }
-        if (nuxtApp) {
-          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-          if (payload && payload[prefixedKey]) {
-            delete payload[prefixedKey];
-          }
+    try {
+      const sessionId = await this.getSessionId(context);
+      const sessionData = CServerSessionCache.storage.get(sessionId);
+      if (sessionData) {
+        sessionData.delete(prefixedKey);
+      }
+      if (context) {
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
+        if (payload && payload[prefixedKey]) {
+          delete payload[prefixedKey];
         }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache remove error on server for key: " + key, e);
       }
+    } catch (e) {
+      console.warn("[Katlux Cache] CServerSessionCache remove error for key: " + key, e);
     }
   }
-  async removeByPrefix(prefix, nuxtApp) {
+  async removeByPrefix(prefix, context) {
     const fullPrefix = "cache:" + prefix;
-    if (undefined) {
-      const keysToDelete = [];
-      for (let i = 0; i < sessionStorage.length; i++) {
-        const key = sessionStorage.key(i);
-        if (key && key.startsWith(fullPrefix)) {
-          keysToDelete.push(key);
+    try {
+      const sessionId = await this.getSessionId(context);
+      const sessionData = CServerSessionCache.storage.get(sessionId);
+      if (sessionData) {
+        const keysToDelete = [];
+        for (const key of sessionData.keys()) {
+          if (key.startsWith(fullPrefix)) {
+            keysToDelete.push(key);
+          }
+        }
+        for (const key of keysToDelete) {
+          sessionData.delete(key);
         }
       }
-      for (const key of keysToDelete) {
-        sessionStorage.removeItem(key);
-      }
-    }
-    if (undefined) {
-      try {
-        const sessionId = await this.getSessionId(nuxtApp);
-        const sessionData = CSessionCache.storage.get(sessionId);
-        if (sessionData) {
-          const keysToDelete = [];
-          for (const key of sessionData.keys()) {
+      if (context) {
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
+        if (payload) {
+          for (const key in payload) {
             if (key.startsWith(fullPrefix)) {
-              keysToDelete.push(key);
-            }
-          }
-          for (const key of keysToDelete) {
-            sessionData.delete(key);
-          }
-        }
-        if (nuxtApp) {
-          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
-          if (payload) {
-            for (const key in payload) {
-              if (key.startsWith(fullPrefix)) {
-                delete payload[key];
-              }
+              delete payload[key];
             }
           }
         }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache removeByPrefix error on server for prefix: " + prefix, e);
       }
+    } catch (e) {
+      console.warn("[Katlux Cache] CServerSessionCache removeByPrefix error for prefix: " + prefix, e);
     }
   }
-  async getRemainingTime(key, nuxtApp) {
+  async getRemainingTime(key, context) {
     const prefixedKey = "cache:" + key;
-    if (undefined) {
-      const entryStr = sessionStorage.getItem(prefixedKey);
-      if (!entryStr) return null;
-      try {
-        const entry = JSON.parse(entryStr);
-        return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache getRemainingTime parse error for key: " + key, e);
-        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;
-      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
-    }
-    return null;
+    const sessionId = await this.getSessionId(context);
+    const sessionData = CServerSessionCache.storage.get(sessionId);
+    if (!sessionData) return null;
+    const entry = sessionData.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();
-    if (undefined) {
+    const sessionsToDelete = [];
+    for (const [sessionId, sessionData] of CServerSessionCache.storage.entries()) {
       const keysToDelete = [];
-      for (let i = 0; i < sessionStorage.length; i++) {
-        const key = sessionStorage.key(i);
-        if (key && key.startsWith(prefix)) {
-          const stored = sessionStorage.getItem(key);
-          if (stored) {
-            try {
-              const entry = JSON.parse(stored);
-              if (now - entry.timestamp > entry.lifetime) {
-                keysToDelete.push(key);
-              }
-            } catch (e) {
-              console.warn("[Katlux Cache] CSessionCache cleanupExpired parse error for key: " + key, e);
-              keysToDelete.push(key);
-            }
+      for (const [key, entry] of sessionData.entries()) {
+        if (key.startsWith(prefix)) {
+          if (now - entry.timestamp > entry.lifetime) {
+            keysToDelete.push(key);
           }
         }
       }
       for (const key of keysToDelete) {
-        sessionStorage.removeItem(key);
+        sessionData.delete(key);
+      }
+      if (sessionData.size === 0) {
+        sessionsToDelete.push(sessionId);
       }
     }
-    if (undefined || CSessionCache.storage.size > 0) {
-      const sessionsToDelete = [];
-      for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
-        const keysToDelete = [];
-        for (const [key, entry] of sessionData.entries()) {
-          if (key.startsWith(prefix)) {
+    for (const sessionId of sessionsToDelete) {
+      CServerSessionCache.storage.delete(sessionId);
+    }
+  }
+}
+
+const CServerSessionCache$1 = {
+	__proto__: null,
+	CServerSessionCache: CServerSessionCache
+};
+
+class CBrowserSessionCache extends ACacheProvider {
+  static instance = null;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CBrowserSessionCache();
+    }
+    return this.instance;
+  }
+  PREFIX = "bscache:";
+  async getKeyList(_context) {
+    if (typeof window === "undefined") return [];
+    return Object.keys(sessionStorage).filter((key) => key.startsWith(this.PREFIX)).map((key) => key.substring(this.PREFIX.length));
+  }
+  async get(key, context) {
+    if (typeof window === "undefined") return null;
+    const prefixedKey = this.PREFIX + key;
+    try {
+      const stored = sessionStorage.getItem(prefixedKey);
+      if (stored) {
+        const entry = JSON.parse(stored);
+        if (Date.now() - entry.timestamp <= entry.lifetime) {
+          return entry.data;
+        } else {
+          sessionStorage.removeItem(prefixedKey);
+        }
+      }
+    } catch (e) {
+      console.warn("[Katlux Cache] CBrowserSessionCache parse error for key: " + key, e);
+    }
+    try {
+      const payloadData = getSSRPayload(context);
+      if (payloadData && payloadData[prefixedKey]) {
+        const entry = payloadData[prefixedKey];
+        if (Date.now() - entry.timestamp <= entry.lifetime) {
+          window.sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
+          return entry.data;
+        }
+      }
+    } catch (e) {
+      console.warn("[Katlux Cache] CBrowserSessionCache SSR payload hydration error for key: " + key, e);
+    }
+    return null;
+  }
+  async set(key, data, lifetime, context) {
+    const prefixedKey = this.PREFIX + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (typeof window === "undefined") {
+      try {
+        const payload = context?.payload?.data ?? context?.ssrContext?.payload?.data;
+        if (payload) {
+          payload[prefixedKey] = entry;
+        }
+      } catch (e) {
+        console.warn("[Katlux Cache] CBrowserSessionCache SSR payload write error for key: " + key, e);
+      }
+      return;
+    }
+    try {
+      sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
+    } catch (e) {
+      console.warn("[Katlux Cache] CBrowserSessionCache sessionStorage setItem error (possible quota exceeded) for key: " + key, e);
+    }
+  }
+  async remove(key, _context) {
+    if (typeof window === "undefined") return;
+    sessionStorage.removeItem(this.PREFIX + key);
+  }
+  async removeByPrefix(prefix, _context) {
+    if (typeof window === "undefined") return;
+    const fullPrefix = this.PREFIX + prefix;
+    const keysToDelete = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key && key.startsWith(fullPrefix)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      sessionStorage.removeItem(key);
+    }
+  }
+  async getRemainingTime(key, _context) {
+    if (typeof window === "undefined") return null;
+    const stored = sessionStorage.getItem(this.PREFIX + key);
+    if (!stored) return null;
+    try {
+      const entry = JSON.parse(stored);
+      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+    } catch (e) {
+      console.warn("[Katlux Cache] CBrowserSessionCache getRemainingTime parse error for key: " + key, e);
+      return null;
+    }
+  }
+  async cleanupExpired(_context) {
+    if (typeof window === "undefined") return;
+    const now = Date.now();
+    const keysToDelete = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key && key.startsWith(this.PREFIX)) {
+        const stored = sessionStorage.getItem(key);
+        if (stored) {
+          try {
+            const entry = JSON.parse(stored);
             if (now - entry.timestamp > entry.lifetime) {
               keysToDelete.push(key);
             }
+          } catch (e) {
+            console.warn("[Katlux Cache] CBrowserSessionCache cleanupExpired parse error for key: " + key, e);
+            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);
       }
     }
+    for (const key of keysToDelete) {
+      sessionStorage.removeItem(key);
+    }
   }
 }
 
-const CSessionCache$1 = {
+const CBrowserSessionCache$1 = {
 	__proto__: null,
-	CSessionCache: CSessionCache
+	CBrowserSessionCache: CBrowserSessionCache
 };
 
 class CLocalStorageCache extends ACacheProvider {
@@ -3125,13 +4207,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 +4232,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 +4255,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 +4270,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 +4285,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 +4301,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 +4315,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 +4330,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 +4346,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 +4384,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 +4418,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 +4436,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 +4454,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 +4477,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 +4492,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 +4512,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 +4526,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 +4537,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 +4559,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 +4574,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 +4594,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 +4635,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;
@@ -3839,16 +4642,18 @@ exports.CAPIFlatServerDataProvider = CAPIFlatServerDataProvider;
 exports.CAPITreeClientDataProvider = CAPITreeClientDataProvider;
 exports.CAPITreeServerDataProvider = CAPITreeServerDataProvider;
 exports.CApplicationCache = CApplicationCache;
+exports.CBrowserSessionCache = CBrowserSessionCache;
 exports.CCookieCache = CCookieCache;
 exports.CFlatClientDataProvider = CFlatClientDataProvider;
 exports.CFlatServerDataProvider = CFlatServerDataProvider;
 exports.CIndexedDBCache = CIndexedDBCache;
 exports.CLocalStorageCache = CLocalStorageCache;
 exports.CMemoryCache = CMemoryCache;
-exports.CSessionCache = CSessionCache;
+exports.CServerSessionCache = CServerSessionCache;
 exports.CTreeClientDataProvider = CTreeClientDataProvider;
 exports.CTreeServerDataProvider = CTreeServerDataProvider;
 exports.CacheProviderFactory = CacheProviderFactory;
+exports.DefaultHydrationAdapter = DefaultHydrationAdapter;
 exports.ECacheStrategy = ECacheStrategy;
 exports.EDataFilterOperator = EDataFilterOperator;
 exports.EQueueStorage = EQueueStorage;
@@ -3857,7 +4662,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 +4672,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;