@fjell/cache 4.6.22 → 4.7.0

package/dist/index.js

@@ -1,227 +1,38 @@
-// src/logger.ts
-import Logging from "@fjell/logging";
-var LibLogger = Logging.getLogger("@fjell/cache");
-var logger_default = LibLogger;
-
-// src/Aggregator.ts
-var logger = logger_default.get("ItemAggregator");
-var toCacheConfig = (config) => {
-  let cacheConfig;
-  if (config.optional === void 0) {
-    cacheConfig = { cache: config, optional: false };
-  } else {
-    cacheConfig = config;
-  }
-  return cacheConfig;
-};
-var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
-  const populate = async (item) => {
-    logger.default("populate", { item });
-    for (const key in aggregates) {
-      await populateAggregate(key, item);
-    }
-    for (const key in events) {
-      await populateEvent(key, item);
-    }
-    logger.default("populate done", { item });
-    return item;
-  };
-  const populateAggregate = async (key, item) => {
-    logger.default("populate aggregate key", { key });
-    const cacheConfig = toCacheConfig(aggregates[key]);
-    if (item.refs === void 0) {
-      if (cacheConfig.optional === false) {
-        logger.error("Item does not have refs an is not optional " + JSON.stringify(item));
-        throw new Error("Item does not have refs an is not optional " + JSON.stringify(item));
-      } else {
-        if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
-          delete item.events[key];
-        }
-      }
-    } else if (item.refs[key] === void 0) {
-      if (cacheConfig.optional === false) {
-        logger.error("Item does not have mandatory ref with key, not optional " + key + " " + JSON.stringify(item));
-        throw new Error("Item does not have mandatory ref with key, not optional " + key + " " + JSON.stringify(item));
-      } else {
-        if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
-          delete item.events[key];
-        }
-      }
-    } else {
-      const ref = item.refs[key];
-      logger.default("AGG Retrieving Item in Populate", { key: ref });
-      const [, newItem] = await cacheConfig.cache.operations.retrieve(ref);
-      if (newItem) {
-        if (item.aggs === void 0) {
-          item.aggs = {};
-        }
-        item.aggs[key] = {
-          key: ref,
-          item: newItem
-        };
-      }
-    }
-  };
-  const populateEvent = async (key, item) => {
-    logger.default("populate event key", { key });
-    const cacheConfig = toCacheConfig(events[key]);
-    if (item.events === void 0) {
-      throw new Error("Item does not have events " + JSON.stringify(item));
-    } else if (item.events[key] === void 0) {
-      if (cacheConfig.optional === false) {
-        logger.error("Item does not have mandatory event with key " + key + " " + JSON.stringify(item));
-        throw new Error("Item does not have mandatory event with key " + key + " " + JSON.stringify(item));
-      }
-    } else {
-      const event = item.events[key];
-      if (event.by === void 0) {
-        logger.error(
-          "populateEvent with an Event that does not have by",
-          { event, ik: item.key, eventKey: key }
-        );
-        throw new Error("populateEvent with an Event that does not have by: " + JSON.stringify({ key, event }));
-      }
-      logger.default("EVENT Retrieving Item in Populate", { key: event.by });
-      const [, newItem] = await cacheConfig.cache.operations.retrieve(event.by);
-      if (newItem) {
-        event.agg = newItem;
-      }
-    }
-  };
-  const all2 = async (query = {}, locations = []) => {
-    logger.default("all", { query, locations });
-    const [cacheMap, items] = await cache.operations.all(query, locations);
-    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
-    return [cacheMap, populatedItems];
-  };
-  const one2 = async (query = {}, locations = []) => {
-    logger.default("one", { query, locations });
-    const [cacheMap, item] = await cache.operations.one(query, locations);
-    let populatedItem = null;
-    if (item) {
-      populatedItem = await populate(item);
-    }
-    return [cacheMap, populatedItem];
-  };
-  const action2 = async (key, action3, body = {}) => {
-    logger.default("action", { key, action: action3, body });
-    const [cacheMap, item] = await cache.operations.action(key, action3, body);
-    const populatedItem = await populate(item);
-    return [cacheMap, populatedItem];
-  };
-  const allAction2 = async (action3, body = {}, locations = []) => {
-    logger.default("action", { action: action3, body, locations });
-    const [cacheMap, items] = await cache.operations.allAction(action3, body, locations);
-    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
-    return [cacheMap, populatedItems];
-  };
-  const allFacet2 = async (facet3, params = {}, locations = []) => {
-    logger.default("allFacet", { facet: facet3, params, locations });
-    const [cacheMap, response] = await cache.operations.allFacet(facet3, params, locations);
-    return [cacheMap, response];
-  };
-  const create2 = async (v, locations = []) => {
-    logger.default("create", { v, locations });
-    const [cacheMap, item] = await cache.operations.create(v, locations);
-    const populatedItem = await populate(item);
-    return [cacheMap, populatedItem];
-  };
-  const get2 = async (key) => {
-    logger.default("get", { key });
-    const [cacheMap, item] = await cache.operations.get(key);
-    let populatedItem = null;
-    if (item) {
-      populatedItem = await populate(item);
-    }
-    return [cacheMap, populatedItem];
-  };
-  const retrieve2 = async (key) => {
-    logger.default("retrieve", { key });
-    const [cacheMap, item] = await cache.operations.retrieve(key);
-    let populatedItem = null;
-    if (item) {
-      populatedItem = await populate(item);
-    }
-    return [cacheMap, populatedItem];
-  };
-  const remove2 = async (key) => {
-    logger.default("remove", { key });
-    const cacheMap = await cache.operations.remove(key);
-    return cacheMap;
-  };
-  const update2 = async (key, v) => {
-    logger.default("update", { key, v });
-    const [cacheMap, item] = await cache.operations.update(key, v);
-    const populatedItem = await populate(item);
-    return [cacheMap, populatedItem];
-  };
-  const facet2 = async (key, facet3) => {
-    logger.default("facet", { key, facet: facet3 });
-    const [cacheMap, response] = await cache.operations.facet(key, facet3);
-    return [cacheMap, response];
-  };
-  const find2 = async (finder, finderParams = {}, locations = []) => {
-    logger.default("find", { finder, finderParams, locations });
-    const [cacheMap, items] = await cache.operations.find(finder, finderParams, locations);
-    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
-    return [cacheMap, populatedItems];
-  };
-  const findOne2 = async (finder, finderParams = {}, locations = []) => {
-    logger.default("find", { finder, finderParams, locations });
-    const [cacheMap, item] = await cache.operations.findOne(finder, finderParams, locations);
-    const populatedItem = await populate(item);
-    return [cacheMap, populatedItem];
-  };
-  const set2 = async (key, v) => {
-    logger.default("set", { key, v });
-    const [cacheMap, item] = await cache.operations.set(key, v);
-    const populatedItem = await populate(item);
-    return [cacheMap, populatedItem];
-  };
-  const reset2 = async () => {
-    const cacheMap = await cache.operations.reset();
-    return cacheMap;
-  };
+// src/CacheContext.ts
+var createCacheContext = (api, cacheMap, pkType, options) => {
   return {
-    // Cache properties
-    coordinate: cache.coordinate,
-    registry: cache.registry,
-    api: cache.api,
-    cacheMap: cache.cacheMap,
-    operations: cache.operations,
-    // Cache operations exposed directly
-    all: all2,
-    one: one2,
-    action: action2,
-    allAction: allAction2,
-    allFacet: allFacet2,
-    create: create2,
-    get: get2,
-    retrieve: retrieve2,
-    remove: remove2,
-    update: update2,
-    facet: facet2,
-    find: find2,
-    findOne: findOne2,
-    reset: reset2,
-    set: set2,
-    // Aggregator-specific operations
-    populate,
-    populateAggregate,
-    populateEvent
+    api,
+    cacheMap,
+    pkType,
+    options,
+    itemTtl: options.memoryConfig?.ttl || options.ttl,
+    queryTtl: options.memoryConfig?.ttl || options.ttl
   };
 };
 
-// src/CacheMap.ts
+// src/ops/all.ts
 import {
-  Dictionary,
-  isComKey,
-  isQueryMatch
+  validatePK
 } from "@fjell/core";
-var logger2 = logger_default.get("CacheMap");
+import { NotFoundError } from "@fjell/http-api";
+
+// src/normalization.ts
 var normalizeKeyValue = (value) => {
   return String(value);
 };
+var deterministicStringify = (obj) => {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(deterministicStringify).join(",") + "]";
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const keyValuePairs = sortedKeys.map((key) => {
+    return JSON.stringify(key) + ":" + deterministicStringify(obj[key]);
+  });
+  return "{" + keyValuePairs.join(",") + "}";
+};
 var createNormalizedHashFunction = () => {
   return (key) => {
     if (typeof key === "object" && key !== null) {
@@ -240,7 +51,7 @@ var createNormalizedHashFunction = () => {
           return locItem;
         });
       }
-      return JSON.stringify(normalizedKey);
+      return deterministicStringify(normalizedKey);
     }
     return JSON.stringify(key);
   };
@@ -252,7 +63,7 @@ var isLocKeyArrayEqual = (a, b) => {
   for (let i = 0; i < a.length; i++) {
     const normalizedA = normalizeLocKeyItem(a[i]);
     const normalizedB = normalizeLocKeyItem(b[i]);
-    if (JSON.stringify(normalizedA) !== JSON.stringify(normalizedB)) {
+    if (deterministicStringify(normalizedA) !== deterministicStringify(normalizedB)) {
       return false;
     }
   }
@@ -268,88 +79,92 @@ var normalizeLocKeyItem = (item) => {
   }
   return item;
 };
-var CacheMap = class _CacheMap extends Dictionary {
-  types;
-  normalizedHashFunction;
-  constructor(types, map) {
-    const hashFunc = createNormalizedHashFunction();
-    super(map, hashFunc);
-    this.types = types;
-    this.normalizedHashFunction = hashFunc;
-  }
-  get(key) {
-    logger2.trace("get", { key });
-    const hashedKey = this.normalizedHashFunction(key);
-    const entry = this.map[hashedKey];
-    return entry && this.normalizedHashFunction(entry.originalKey) === this.normalizedHashFunction(key) ? entry.value : null;
-  }
-  includesKey(key) {
-    const hashedKey = this.normalizedHashFunction(key);
-    const entry = this.map[hashedKey];
-    return entry ? this.normalizedHashFunction(entry.originalKey) === this.normalizedHashFunction(key) : false;
-  }
-  delete(key) {
-    logger2.trace("delete", { key });
-    const hashedKey = this.normalizedHashFunction(key);
-    delete this.map[hashedKey];
-  }
-  allIn(locations) {
-    if (locations.length === 0) {
-      logger2.debug("Returning all items, LocKeys is empty");
-      return this.values();
-    } else {
-      const locKeys = locations;
-      logger2.debug("allIn", { locKeys, keys: this.keys().length });
-      return this.keys().filter((key) => key && isComKey(key)).filter((key) => {
-        const ComKey8 = key;
-        logger2.debug("Comparing Location Keys", {
-          locKeys,
-          ComKey: ComKey8
-        });
-        return isLocKeyArrayEqual(locKeys, ComKey8.loc);
-      }).map((key) => this.get(key));
-    }
-  }
-  // TODO: Can we do case insensitive matching?
-  contains(query, locations) {
-    logger2.debug("contains", { query, locations });
-    const items = this.allIn(locations);
-    return items.some((item) => isQueryMatch(item, query));
-  }
-  queryIn(query, locations = []) {
-    logger2.debug("queryIn", { query, locations });
-    const items = this.allIn(locations);
-    return items.filter((item) => isQueryMatch(item, query));
-  }
-  clone() {
-    const clone = new _CacheMap(this.types);
-    clone.map = this.map;
-    clone.normalizedHashFunction = this.normalizedHashFunction;
-    return clone;
-  }
+var createQueryHash = (pkType, query, locations) => {
+  const normalizedQuery = JSON.parse(JSON.stringify(query || {}));
+  const sortedQueryKeys = Object.keys(normalizedQuery).sort();
+  const sortedQuery = {};
+  sortedQueryKeys.forEach((key) => {
+    sortedQuery[key] = normalizedQuery[key];
+  });
+  const locationsArray = Array.isArray(locations) ? locations : [];
+  const normalizedLocations = locationsArray.map(normalizeLocKeyItem);
+  const hashInput = {
+    type: "query",
+    pkType,
+    query: sortedQuery,
+    locations: normalizedLocations
+  };
+  return deterministicStringify(hashInput);
 };
+var createFinderHash = (finder, params, locations) => {
+  const normalizedParams = JSON.parse(JSON.stringify(params || {}));
+  const sortedParamKeys = Object.keys(normalizedParams).sort();
+  const sortedParams = {};
+  sortedParamKeys.forEach((key) => {
+    sortedParams[key] = normalizedParams[key];
+  });
+  const locationsArray = Array.isArray(locations) ? locations : [];
+  const normalizedLocations = locationsArray.map(normalizeLocKeyItem);
+  const hashInput = {
+    type: "finder",
+    finder,
+    params: sortedParams,
+    locations: normalizedLocations
+  };
+  return deterministicStringify(hashInput);
+};
+
+// src/logger.ts
+import Logging from "@fjell/logging";
+var LibLogger = Logging.getLogger("@fjell/cache");
+var logger_default = LibLogger;
 
 // src/ops/all.ts
-import {
-  validatePK
-} from "@fjell/core";
-import { NotFoundError } from "@fjell/http-api";
-var logger3 = logger_default.get("all");
-var all = async (api, cacheMap, pkType, query = {}, locations = []) => {
-  logger3.default("all", { query, locations });
+var logger = logger_default.get("all");
+var all = async (query = {}, locations = [], context) => {
+  const { api, cacheMap, pkType, queryTtl } = context;
+  logger.default("all", { query, locations });
+  const queryHash = createQueryHash(pkType, query, locations);
+  logger.debug("Generated query hash for all", { queryHash });
+  const cachedItemKeys = cacheMap.getQueryResult(queryHash);
+  if (cachedItemKeys) {
+    logger.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    const cachedItems = [];
+    let allItemsAvailable = true;
+    for (const itemKey of cachedItemKeys) {
+      const item = cacheMap.get(itemKey);
+      if (item) {
+        cachedItems.push(item);
+      } else {
+        allItemsAvailable = false;
+        break;
+      }
+    }
+    if (allItemsAvailable) {
+      return [context, validatePK(cachedItems, pkType)];
+    } else {
+      logger.debug("Some cached items missing, invalidating query cache");
+      cacheMap.deleteQueryResult(queryHash);
+    }
+  }
   let ret = [];
   try {
     ret = await api.all(query, locations);
     ret.forEach((v) => {
       cacheMap.set(v.key, v);
     });
+    const itemKeys = ret.map((item) => item.key);
+    cacheMap.setQueryResult(queryHash, itemKeys, queryTtl);
+    logger.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length, ttl: queryTtl });
   } catch (e) {
     if (e instanceof NotFoundError) {
+      cacheMap.setQueryResult(queryHash, [], queryTtl);
+      logger.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
   }
-  return [cacheMap, validatePK(ret, pkType)];
+  return [context, validatePK(ret, pkType)];
 };
 
 // src/ops/one.ts
@@ -357,23 +172,47 @@ import {
   validatePK as validatePK2
 } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/http-api";
-var logger4 = logger_default.get("one");
-var one = async (api, cacheMap, pkType, query = {}, locations = []) => {
-  logger4.default("one", { query, locations });
-  let retItem = null;
-  try {
+var logger2 = logger_default.get("one");
+var one = async (query = {}, locations = [], context) => {
+  const { api, cacheMap, pkType, queryTtl } = context;
+  logger2.default("one", { query, locations });
+  const queryHash = createQueryHash(pkType, query, locations);
+  logger2.debug("Generated query hash for one", { queryHash });
+  const cachedItemKeys = cacheMap.getQueryResult(queryHash);
+  if (cachedItemKeys) {
+    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    if (cachedItemKeys.length === 0) {
+      return [context, null];
+    }
+    const item = cacheMap.get(cachedItemKeys[0]);
+    if (item) {
+      return [context, validatePK2(item, pkType)];
+    } else {
+      logger2.debug("Cached item missing, invalidating query cache");
+      cacheMap.deleteQueryResult(queryHash);
+    }
+  }
+  let retItem = null;
+  try {
     retItem = await api.one(query, locations);
     if (retItem) {
       cacheMap.set(retItem.key, retItem);
+      cacheMap.setQueryResult(queryHash, [retItem.key], queryTtl);
+      logger2.debug("Cached query result", { queryHash, itemKey: retItem.key, ttl: queryTtl });
+    } else {
+      cacheMap.setQueryResult(queryHash, [], queryTtl);
+      logger2.debug("Cached empty query result", { queryHash, ttl: queryTtl });
     }
   } catch (e) {
     if (e instanceof NotFoundError2) {
+      cacheMap.setQueryResult(queryHash, [], queryTtl);
+      logger2.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
   }
   return [
-    cacheMap,
+    context,
     retItem ? validatePK2(retItem, pkType) : null
   ];
 };
@@ -382,12 +221,13 @@ var one = async (api, cacheMap, pkType, query = {}, locations = []) => {
 import {
   validatePK as validatePK3
 } from "@fjell/core";
-var logger5 = logger_default.get("create");
-var create = async (api, cacheMap, pkType, v, locations = []) => {
-  logger5.default("create", { v, locations });
+var logger3 = logger_default.get("create");
+var create = async (v, locations = [], context) => {
+  const { api, cacheMap, pkType } = context;
+  logger3.default("create", { v, locations });
   const created = await api.create(v, locations);
   cacheMap.set(created.key, created);
-  return [cacheMap, validatePK3(created, pkType)];
+  return [context, validatePK3(created, pkType)];
 };
 
 // src/ops/get.ts
@@ -395,25 +235,53 @@ import {
   isValidItemKey,
   validatePK as validatePK4
 } from "@fjell/core";
-var logger6 = logger_default.get("get");
-var get = async (api, cacheMap, pkType, key) => {
-  logger6.default("get", { key });
+var logger4 = logger_default.get("get");
+var inFlightRequests = /* @__PURE__ */ new Map();
+var keyToString = (key) => {
+  return JSON.stringify(key);
+};
+var get = async (key, context) => {
+  const { api, cacheMap, pkType, itemTtl } = context;
+  logger4.default("get", { key, itemTtl });
   if (!isValidItemKey(key)) {
-    logger6.error("Key for Get is not a valid ItemKey: %j", key);
+    logger4.error("Key for Get is not a valid ItemKey: %j", key);
     throw new Error("Key for Get is not a valid ItemKey");
   }
+  if (typeof itemTtl === "number" && itemTtl > 0) {
+    const cachedItem = cacheMap.getWithTTL(key, itemTtl);
+    if (cachedItem) {
+      logger4.debug("Cache hit with TTL", { key, itemTtl });
+      return [context, validatePK4(cachedItem, pkType)];
+    }
+    logger4.debug("Cache miss or expired", { key, itemTtl });
+  }
   let ret;
+  const keyStr = keyToString(key);
   try {
-    ret = await api.get(key);
+    let apiRequest = inFlightRequests.get(keyStr);
+    if (!apiRequest) {
+      apiRequest = api.get(key);
+      inFlightRequests.set(keyStr, apiRequest);
+      if (apiRequest && typeof apiRequest.finally === "function") {
+        apiRequest.finally(() => {
+          inFlightRequests.delete(keyStr);
+        });
+      } else {
+        inFlightRequests.delete(keyStr);
+      }
+    } else {
+      logger4.debug("Using in-flight request for key", { key });
+    }
+    ret = await apiRequest;
     if (ret) {
       cacheMap.set(ret.key, ret);
     }
   } catch (e) {
-    logger6.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+    logger4.error("Error getting item for key", { key, message: e.message, stack: e.stack });
     throw e;
   }
   return [
-    cacheMap,
+    context,
     ret ? validatePK4(ret, pkType) : null
   ];
 };
@@ -423,24 +291,25 @@ import {
   isValidItemKey as isValidItemKey2,
   validatePK as validatePK5
 } from "@fjell/core";
-var logger7 = logger_default.get("retrieve");
-var retrieve = async (api, cacheMap, pkType, key) => {
-  logger7.default("retrieve", { key });
+var logger5 = logger_default.get("retrieve");
+var retrieve = async (key, context) => {
+  const { cacheMap, pkType } = context;
+  logger5.default("retrieve", { key });
   if (!isValidItemKey2(key)) {
-    logger7.error("Key for Retrieve is not a valid ItemKey: %j", key);
+    logger5.error("Key for Retrieve is not a valid ItemKey: %j", key);
     throw new Error("Key for Retrieve is not a valid ItemKey");
   }
   const containsItemKey = cacheMap.includesKey(key);
   let retrieved;
   if (containsItemKey) {
-    logger7.default("Looking for Object in Cache", key);
+    logger5.default("Looking for Object in Cache", key);
     retrieved = cacheMap.get(key);
   } else {
-    logger7.default("Object Not Found in Cache, Retrieving from Server API", { key });
-    [, retrieved] = await get(api, cacheMap, pkType, key);
+    logger5.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    [, retrieved] = await get(key, context);
   }
   const retValue = [
-    containsItemKey ? null : cacheMap,
+    containsItemKey ? null : context,
     retrieved ? validatePK5(retrieved, pkType) : null
   ];
   return retValue;
@@ -450,21 +319,23 @@ var retrieve = async (api, cacheMap, pkType, key) => {
 import {
   isValidItemKey as isValidItemKey3
 } from "@fjell/core";
-var logger8 = logger_default.get("remove");
-var remove = async (api, cacheMap, key) => {
-  logger8.default("remove", { key });
+var logger6 = logger_default.get("remove");
+var remove = async (key, context) => {
+  const { api, cacheMap } = context;
+  logger6.default("remove", { key });
   if (!isValidItemKey3(key)) {
-    logger8.error("Key for Remove is not a valid ItemKey: %j", key);
+    logger6.error("Key for Remove is not a valid ItemKey: %j", key);
     throw new Error("Key for Remove is not a valid ItemKey");
   }
   try {
     await api.remove(key);
     cacheMap.delete(key);
+    logger6.debug("Successfully removed item from API and cache", { key });
   } catch (e) {
-    logger8.error("Error deleting item", { error: e });
+    logger6.error("Error deleting item", { error: e });
     throw e;
   }
-  return cacheMap;
+  return context;
 };
 
 // src/ops/update.ts
@@ -472,19 +343,23 @@ import {
   isValidItemKey as isValidItemKey4,
   validatePK as validatePK6
 } from "@fjell/core";
-var logger9 = logger_default.get("update");
-var update = async (api, cacheMap, pkType, key, v) => {
-  logger9.default("update", { key, v });
+var logger7 = logger_default.get("update");
+var update = async (key, v, context) => {
+  const { api, cacheMap, pkType } = context;
+  logger7.default("update", { key, v });
   if (!isValidItemKey4(key)) {
-    logger9.error("Key for Update is not a valid ItemKey: %j", key);
+    logger7.error("Key for Update is not a valid ItemKey: %j", key);
     throw new Error("Key for Update is not a valid ItemKey");
   }
+  logger7.debug("Invalidating item key before update", { key });
+  cacheMap.invalidateItemKeys([key]);
   try {
     const updated = await api.update(key, v);
+    logger7.debug("Caching update result", { updatedKey: updated.key });
     cacheMap.set(updated.key, updated);
-    return [cacheMap, validatePK6(updated, pkType)];
+    return [context, validatePK6(updated, pkType)];
   } catch (e) {
-    logger9.error("Error updating item", { error: e });
+    logger7.error("Error updating item", { error: e });
     throw e;
   }
 };
@@ -494,16 +369,20 @@ import {
   isValidItemKey as isValidItemKey5,
   validatePK as validatePK7
 } from "@fjell/core";
-var logger10 = logger_default.get("action");
-var action = async (api, cacheMap, pkType, key, action2, body = {}) => {
-  logger10.default("action", { key, action: action2, body });
+var logger8 = logger_default.get("action");
+var action = async (key, action2, body = {}, context) => {
+  const { api, cacheMap, pkType } = context;
+  logger8.default("action", { key, action: action2, body });
   if (!isValidItemKey5(key)) {
-    logger10.error("Key for Action is not a valid ItemKey: %j", key);
+    logger8.error("Key for Action is not a valid ItemKey: %j", key);
     throw new Error("Key for Action is not a valid ItemKey");
   }
+  logger8.debug("Invalidating item key before action", { key });
+  cacheMap.invalidateItemKeys([key]);
   const updated = await api.action(key, action2, body);
+  logger8.debug("Caching action result", { updatedKey: updated.key });
   cacheMap.set(updated.key, updated);
-  return [cacheMap, validatePK7(updated, pkType)];
+  return [context, validatePK7(updated, pkType)];
 };
 
 // src/ops/allAction.ts
@@ -511,12 +390,16 @@ import {
   validatePK as validatePK8
 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
-var logger11 = logger_default.get("allAction");
-var allAction = async (api, cacheMap, pkType, action2, body = {}, locations = []) => {
-  logger11.default("allAction", { action: action2, body, locations });
+var logger9 = logger_default.get("allAction");
+var allAction = async (action2, body = {}, locations = [], context) => {
+  const { api, cacheMap, pkType } = context;
+  logger9.default("allAction", { action: action2, body, locations });
+  logger9.debug("Invalidating location before allAction", { locations });
+  cacheMap.invalidateLocation(locations);
   let ret = [];
   try {
     ret = await api.allAction(action2, body, locations);
+    logger9.debug("Caching allAction results", { resultCount: ret.length });
     ret.forEach((v) => {
       cacheMap.set(v.key, v);
     });
@@ -526,49 +409,94 @@ var allAction = async (api, cacheMap, pkType, action2, body = {}, locations = []
       throw e;
     }
   }
-  return [cacheMap, validatePK8(ret, pkType)];
+  return [context, validatePK8(ret, pkType)];
 };
 
 // src/ops/facet.ts
-var logger12 = logger_default.get("facet");
-var facet = async (api, cacheMap, key, facet2, params = {}) => {
-  logger12.default("facet", { key, facet: facet2 });
+var logger10 = logger_default.get("facet");
+var facet = async (key, facet2, params = {}, context) => {
+  const { api } = context;
+  logger10.default("facet", { key, facet: facet2 });
   const ret = await api.facet(key, facet2, params);
-  return [cacheMap, ret];
+  return ret;
 };
 
 // src/ops/allFacet.ts
-var logger13 = logger_default.get("allFacet");
-var allFacet = async (api, cacheMap, facet2, params = {}, locations = []) => {
-  logger13.default("allFacet", { facet: facet2, params, locations });
+var logger11 = logger_default.get("allFacet");
+var allFacet = async (facet2, params = {}, locations = [], context) => {
+  const { api } = context;
+  logger11.default("allFacet", { facet: facet2, params, locations });
   const ret = await api.allFacet(facet2, params, locations);
-  return [cacheMap, ret];
+  return ret;
 };
 
 // src/ops/find.ts
 import {
   validatePK as validatePK9
 } from "@fjell/core";
-var logger14 = logger_default.get("find");
-var find = async (api, cacheMap, pkType, finder, params = {}, locations = []) => {
-  logger14.default("find", { finder, params, locations });
+var logger12 = logger_default.get("find");
+var find = async (finder, params = {}, locations = [], context) => {
+  const { api, cacheMap, pkType, queryTtl } = context;
+  logger12.default("find", { finder, params, locations });
+  const queryHash = createFinderHash(finder, params, locations);
+  logger12.debug("Generated query hash for find", { queryHash });
+  const cachedItemKeys = cacheMap.getQueryResult(queryHash);
+  if (cachedItemKeys) {
+    logger12.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    const cachedItems = [];
+    let allItemsAvailable = true;
+    for (const itemKey of cachedItemKeys) {
+      const item = cacheMap.get(itemKey);
+      if (item) {
+        cachedItems.push(item);
+      } else {
+        allItemsAvailable = false;
+        break;
+      }
+    }
+    if (allItemsAvailable) {
+      return [context, validatePK9(cachedItems, pkType)];
+    } else {
+      logger12.debug("Some cached items missing, invalidating query cache");
+      cacheMap.deleteQueryResult(queryHash);
+    }
+  }
   const ret = await api.find(finder, params, locations);
   ret.forEach((v) => {
     cacheMap.set(v.key, v);
   });
-  return [cacheMap, validatePK9(ret, pkType)];
+  const itemKeys = ret.map((item) => item.key);
+  cacheMap.setQueryResult(queryHash, itemKeys, queryTtl);
+  logger12.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length, ttl: queryTtl });
+  return [context, validatePK9(ret, pkType)];
 };
 
 // src/ops/findOne.ts
 import {
   validatePK as validatePK10
 } from "@fjell/core";
-var logger15 = logger_default.get("findOne");
-var findOne = async (api, cacheMap, pkType, finder, finderParams = {}, locations = []) => {
-  logger15.default("findOne", { finder, finderParams, locations });
+var logger13 = logger_default.get("findOne");
+var findOne = async (finder, finderParams = {}, locations = [], context) => {
+  const { api, cacheMap, pkType, queryTtl } = context;
+  logger13.default("findOne", { finder, finderParams, locations });
+  const queryHash = createFinderHash(finder, finderParams, locations);
+  logger13.debug("Generated query hash for findOne", { queryHash });
+  const cachedItemKeys = cacheMap.getQueryResult(queryHash);
+  if (cachedItemKeys && cachedItemKeys.length > 0) {
+    logger13.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    const item = cacheMap.get(cachedItemKeys[0]);
+    if (item) {
+      return [context, validatePK10(item, pkType)];
+    } else {
+      logger13.debug("Cached item missing, invalidating query cache");
+      cacheMap.deleteQueryResult(queryHash);
+    }
+  }
   const ret = await api.findOne(finder, finderParams, locations);
   cacheMap.set(ret.key, ret);
-  return [cacheMap, validatePK10(ret, pkType)];
+  cacheMap.setQueryResult(queryHash, [ret.key], queryTtl);
+  logger13.debug("Cached query result", { queryHash, itemKey: ret.key, ttl: queryTtl });
+  return [context, validatePK10(ret, pkType)];
 };
 
 // src/ops/set.ts
@@ -577,7 +505,7 @@ import {
   isValidItemKey as isValidItemKey6,
   validatePK as validatePK11
 } from "@fjell/core";
-var logger16 = logger_default.get("set");
+var logger14 = logger_default.get("set");
 var normalizeKeyValue2 = (value) => {
   return String(value);
 };
@@ -588,146 +516,3651 @@ var isItemKeyEqualNormalized = (a, b) => {
 };
 var normalizeKey = (key) => {
   if (typeof key === "object" && key !== null) {
-    const normalizedKey = JSON.parse(JSON.stringify(key));
-    if ("pk" in normalizedKey && normalizedKey.pk !== null) {
-      normalizedKey.pk = normalizeKeyValue2(normalizedKey.pk);
+    let needsNormalization = false;
+    let normalizedKey = key;
+    if ("pk" in key && key.pk !== null && typeof key.pk !== "string") {
+      needsNormalization = true;
     }
-    if ("lk" in normalizedKey && normalizedKey.lk !== null) {
-      normalizedKey.lk = normalizeKeyValue2(normalizedKey.lk);
+    if ("lk" in key && key.lk !== null && typeof key.lk !== "string") {
+      needsNormalization = true;
     }
-    if ("loc" in normalizedKey && Array.isArray(normalizedKey.loc)) {
-      normalizedKey.loc = normalizedKey.loc.map((locItem) => {
-        if (locItem && "lk" in locItem && locItem.lk !== null) {
-          return { ...locItem, lk: normalizeKeyValue2(locItem.lk) };
+    if ("loc" in key && Array.isArray(key.loc)) {
+      for (const locItem of key.loc) {
+        if (locItem && "lk" in locItem && locItem.lk !== null && typeof locItem.lk !== "string") {
+          needsNormalization = true;
+          break;
         }
-        return locItem;
-      });
+      }
+    }
+    if (needsNormalization) {
+      normalizedKey = { ...key };
+      if ("pk" in normalizedKey && normalizedKey.pk !== null) {
+        normalizedKey.pk = normalizeKeyValue2(normalizedKey.pk);
+      }
+      if ("lk" in normalizedKey && normalizedKey.lk !== null) {
+        normalizedKey.lk = normalizeKeyValue2(normalizedKey.lk);
+      }
+      if ("loc" in normalizedKey && Array.isArray(normalizedKey.loc)) {
+        normalizedKey.loc = normalizedKey.loc.map((locItem) => {
+          if (locItem && "lk" in locItem && locItem.lk !== null && typeof locItem.lk !== "string") {
+            return { ...locItem, lk: normalizeKeyValue2(locItem.lk) };
+          }
+          return locItem;
+        });
+      }
     }
     return normalizedKey;
   }
   return key;
 };
-var set = async (cacheMap, pkType, key, v) => {
-  logger16.default("set", { key, v });
+var set = async (key, v, context) => {
+  const { cacheMap, pkType } = context;
+  logger14.default("set", { key, v });
   if (!isValidItemKey6(key)) {
-    logger16.error("Key for Set is not a valid ItemKey: %j", key);
+    logger14.error("Key for Set is not a valid ItemKey: %j", key);
     throw new Error("Key for Set is not a valid ItemKey");
   }
   validatePK11(v, pkType);
   if (!isItemKeyEqualNormalized(key, v.key)) {
-    logger16.error("Key does not match item key: %j != %j", key, v.key);
+    logger14.error("Key does not match item key: %j != %j", key, v.key);
     throw new Error("Key does not match item key");
   }
   cacheMap.set(key, v);
-  return [cacheMap, validatePK11(v, pkType)];
+  return [context, validatePK11(v, pkType)];
 };
 
-// src/ops/reset.ts
-var reset = async (coordinate) => {
-  const cacheMap = new CacheMap(coordinate.kta);
-  return [cacheMap];
-};
+// src/memory/MemoryCacheMap.ts
+import {
+  isComKey,
+  isQueryMatch
+} from "@fjell/core";
 
-// src/Operations.ts
-var createOperations = (api, coordinate, cacheMap, pkType) => {
-  return {
-    all: (query, locations) => all(api, cacheMap, pkType, query, locations),
-    one: (query, locations) => one(api, cacheMap, pkType, query, locations),
-    create: (item, locations) => create(api, cacheMap, pkType, item, locations),
-    get: (key) => get(api, cacheMap, pkType, key),
-    retrieve: (key) => retrieve(api, cacheMap, pkType, key),
-    remove: (key) => remove(api, cacheMap, key),
-    update: (key, item) => update(api, cacheMap, pkType, key, item),
-    action: (key, actionName, body) => action(api, cacheMap, pkType, key, actionName, body),
-    allAction: (actionName, body, locations) => allAction(api, cacheMap, pkType, actionName, body, locations),
-    facet: (key, facetName, params) => facet(api, cacheMap, key, facetName, params),
-    allFacet: (facetName, params, locations) => allFacet(api, cacheMap, facetName, params, locations),
-    find: (finder, params, locations) => find(api, cacheMap, pkType, finder, params, locations),
-    findOne: (finder, params, locations) => findOne(api, cacheMap, pkType, finder, params, locations),
-    set: (key, item) => set(cacheMap, pkType, key, item),
-    reset: () => reset(coordinate)
-  };
+// src/CacheMap.ts
+var CacheMap = class {
+  types;
+  constructor(types) {
+    this.types = types;
+  }
 };
 
-// src/Cache.ts
-var logger17 = logger_default.get("Cache");
-var createCache = (api, coordinate, registry) => {
-  logger17.debug("createCache", { coordinate, registry });
-  const cacheMap = new CacheMap(coordinate.kta);
-  const pkType = coordinate.kta[0];
-  const operations = createOperations(api, coordinate, cacheMap, pkType);
-  return {
-    coordinate,
-    registry,
-    api,
-    cacheMap,
-    operations
-  };
+// src/memory/MemoryCacheMap.ts
+var logger15 = logger_default.get("MemoryCacheMap");
+var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
+  map = {};
+  normalizedHashFunction;
+  // Query result cache: maps query hash to cache entry with expiration
+  queryResultCache = {};
+  constructor(types, initialData) {
+    super(types);
+    this.normalizedHashFunction = createNormalizedHashFunction();
+    if (initialData) {
+      for (const [keyStr, value] of Object.entries(initialData)) {
+        try {
+          const key = JSON.parse(keyStr);
+          this.set(key, value);
+        } catch (error) {
+          logger15.error("Failed to parse initial data key", { keyStr, error });
+        }
+      }
+    }
+  }
+  get(key) {
+    logger15.trace("get", { key });
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    return entry && this.normalizedHashFunction(entry.originalKey) === hashedKey ? entry.value : null;
+  }
+  getWithTTL(key, ttl) {
+    logger15.trace("getWithTTL", { key, ttl });
+    if (ttl === 0) {
+      return null;
+    }
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    if (!entry || this.normalizedHashFunction(entry.originalKey) !== hashedKey) {
+      return null;
+    }
+    const now = Date.now();
+    const age = now - entry.timestamp;
+    if (age >= ttl) {
+      logger15.trace("Item expired, removing from cache", { key, age, ttl });
+      delete this.map[hashedKey];
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    logger15.trace("set", { key, value });
+    const hashedKey = this.normalizedHashFunction(key);
+    this.map[hashedKey] = { originalKey: key, value, timestamp: Date.now() };
+  }
+  includesKey(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
+  }
+  delete(key) {
+    logger15.trace("delete", { key });
+    const hashedKey = this.normalizedHashFunction(key);
+    delete this.map[hashedKey];
+  }
+  keys() {
+    return Object.values(this.map).map((entry) => entry.originalKey);
+  }
+  values() {
+    return Object.values(this.map).map((entry) => entry.value);
+  }
+  clear() {
+    this.map = {};
+  }
+  allIn(locations) {
+    const allValues = this.values();
+    if (locations.length === 0) {
+      logger15.debug("Returning all items, LocKeys is empty");
+      return allValues;
+    } else {
+      logger15.debug("allIn", { locations, count: allValues.length });
+      return allValues.filter((item) => {
+        const key = item.key;
+        if (key && isComKey(key)) {
+          const comKey = key;
+          return isLocKeyArrayEqual(locations, comKey.loc);
+        }
+        return false;
+      });
+    }
+  }
+  contains(query, locations) {
+    logger15.debug("contains", { query, locations });
+    const items = this.allIn(locations);
+    return items.some((item) => isQueryMatch(item, query));
+  }
+  queryIn(query, locations = []) {
+    logger15.debug("queryIn", { query, locations });
+    const items = this.allIn(locations);
+    return items.filter((item) => isQueryMatch(item, query));
+  }
+  clone() {
+    const clone = new _MemoryCacheMap(this.types);
+    for (const key of this.keys()) {
+      const value = this.get(key);
+      if (value) {
+        clone.set(key, value);
+      }
+    }
+    for (const [queryHash, entry] of Object.entries(this.queryResultCache)) {
+      clone.queryResultCache[queryHash] = {
+        itemKeys: [...entry.itemKeys],
+        // Shallow copy of the array
+        expiresAt: entry.expiresAt
+      };
+    }
+    return clone;
+  }
+  // Query result caching methods implementation
+  setQueryResult(queryHash, itemKeys, ttl) {
+    logger15.trace("setQueryResult", { queryHash, itemKeys, ttl });
+    const entry = {
+      itemKeys: [...itemKeys]
+      // Create a copy to avoid external mutations
+    };
+    if (ttl) {
+      entry.expiresAt = Date.now() + ttl;
+    }
+    this.queryResultCache[queryHash] = entry;
+  }
+  getQueryResult(queryHash) {
+    logger15.trace("getQueryResult", { queryHash });
+    const entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      logger15.trace("Query result expired, removing", { queryHash, expiresAt: entry.expiresAt });
+      delete this.queryResultCache[queryHash];
+      return null;
+    }
+    return [...entry.itemKeys];
+  }
+  hasQueryResult(queryHash) {
+    const entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      return false;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      logger15.trace("Query result expired, removing", { queryHash, expiresAt: entry.expiresAt });
+      delete this.queryResultCache[queryHash];
+      return false;
+    }
+    return true;
+  }
+  deleteQueryResult(queryHash) {
+    logger15.trace("deleteQueryResult", { queryHash });
+    delete this.queryResultCache[queryHash];
+  }
+  invalidateItemKeys(keys) {
+    logger15.debug("invalidateItemKeys", { keys });
+    keys.forEach((key) => {
+      this.delete(key);
+    });
+  }
+  invalidateLocation(locations) {
+    logger15.debug("invalidateLocation", { locations });
+    if (locations.length === 0) {
+      const allKeys = this.keys();
+      const primaryKeys = allKeys.filter((key) => !isComKey(key));
+      this.invalidateItemKeys(primaryKeys);
+    } else {
+      const itemsInLocation = this.allIn(locations);
+      const keysToInvalidate = itemsInLocation.map((item) => item.key);
+      this.invalidateItemKeys(keysToInvalidate);
+    }
+    this.clearQueryResults();
+  }
+  clearQueryResults() {
+    logger15.trace("clearQueryResults");
+    this.queryResultCache = {};
+  }
 };
-var isCache = (cache) => {
-  return cache !== null && typeof cache === "object" && "coordinate" in cache && "registry" in cache && "api" in cache && "cacheMap" in cache && "operations" in cache;
+
+// src/memory/EnhancedMemoryCacheMap.ts
+import {
+  isComKey as isComKey2,
+  isQueryMatch as isQueryMatch2
+} from "@fjell/core";
+
+// src/eviction/EvictionStrategy.ts
+var EvictionStrategy = class {
 };
 
-// src/Instance.ts
-var logger18 = logger_default.get("Instance");
-var createInstance = (registry, coordinate, api) => {
-  logger18.debug("createInstance", { coordinate, api, registry });
-  return createCache(api, coordinate, registry);
+// src/eviction/EvictionStrategyConfig.ts
+var DEFAULT_LFU_CONFIG = {
+  type: "lfu",
+  decayFactor: 0.1,
+  decayInterval: 6e4,
+  // 1 minute
+  sketchWidth: 1024,
+  sketchDepth: 4,
+  useProbabilisticCounting: true,
+  minFrequencyThreshold: 1
 };
-var isInstance = (instance) => {
-  return instance !== null && typeof instance === "object" && "coordinate" in instance && "registry" in instance && "api" in instance && "cacheMap" in instance && "operations" in instance;
+var DEFAULT_ARC_CONFIG = {
+  type: "arc",
+  maxCacheSize: 1e3,
+  frequencyThreshold: 2,
+  useEnhancedFrequency: true,
+  frequencyDecayFactor: 0.05,
+  frequencyDecayInterval: 6e5,
+  // 10 minutes
+  useFrequencyWeightedSelection: true,
+  adaptiveLearningRate: 1
+};
+var DEFAULT_TWO_QUEUE_CONFIG = {
+  type: "2q",
+  maxCacheSize: 1e3,
+  useFrequencyPromotion: true,
+  promotionThreshold: 2,
+  hotQueueDecayFactor: 0.05,
+  hotQueueDecayInterval: 3e5,
+  // 5 minutes
+  useFrequencyWeightedLRU: true
 };
 
-// src/InstanceFactory.ts
-var logger19 = logger_default.get("InstanceFactory");
-var createInstanceFactory = (api) => {
-  return (coordinate, context) => {
-    logger19.debug("Creating cache instance", { coordinate, registry: context.registry, api });
-    const cacheMap = new CacheMap(coordinate.kta);
-    const pkType = coordinate.kta[0];
-    const operations = createOperations(api, coordinate, cacheMap, pkType);
-    return {
-      coordinate,
-      registry: context.registry,
-      api,
-      cacheMap,
-      operations
+// src/eviction/strategies/LRUEvictionStrategy.ts
+var LRUEvictionStrategy = class extends EvictionStrategy {
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, metadata] of items) {
+      if (metadata.lastAccessedAt < oldestTime) {
+        oldestTime = metadata.lastAccessedAt;
+        oldestKey = key;
+      }
+    }
+    return oldestKey;
+  }
+  onItemAccessed(_key, metadata) {
+    metadata.lastAccessedAt = Date.now();
+    metadata.accessCount++;
+  }
+  onItemAdded(_key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+  }
+  onItemRemoved() {
+  }
+};
+
+// src/eviction/EvictionStrategyValidation.ts
+function validateNumberRange(value, min, max, fieldName) {
+  if (typeof value !== "number" || isNaN(value) || !isFinite(value)) {
+    throw new Error(`${fieldName} must be a finite number`);
+  }
+  if (value < min || value > max) {
+    throw new Error(`${fieldName} must be between ${min} and ${max}, got ${value}`);
+  }
+}
+function validatePositiveInteger(value, fieldName) {
+  if (typeof value !== "number" || isNaN(value) || !isFinite(value)) {
+    throw new Error(`${fieldName} must be a finite number`);
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${fieldName} must be a positive integer, got ${value}`);
+  }
+}
+function sanitizeLFUConfig(config) {
+  const sanitized = { ...config };
+  if (typeof sanitized.decayFactor === "number") {
+    if (sanitized.decayFactor < 0) {
+      console.warn(`decayFactor must be between 0 and 1, got ${sanitized.decayFactor}. Correcting to 0.`);
+      sanitized.decayFactor = 0;
+    } else if (sanitized.decayFactor > 1) {
+      console.warn(`decayFactor must be between 0 and 1, got ${sanitized.decayFactor}. Correcting to 1.`);
+      sanitized.decayFactor = 1;
+    }
+  }
+  if (typeof sanitized.decayInterval === "number" && sanitized.decayInterval <= 0) {
+    console.warn(`decayInterval must be positive, got ${sanitized.decayInterval}. Correcting to 300000.`);
+    sanitized.decayInterval = 3e5;
+  }
+  if (typeof sanitized.sketchWidth === "number") {
+    if (sanitized.sketchWidth <= 0) {
+      console.warn(`sketchWidth must be positive, got ${sanitized.sketchWidth}. Correcting to 1024.`);
+      sanitized.sketchWidth = 1024;
+    } else if (sanitized.sketchWidth < 16) {
+      console.warn(`sketchWidth should be at least 16 for optimal performance, got ${sanitized.sketchWidth}. Correcting to 16.`);
+      sanitized.sketchWidth = 16;
+    } else if (sanitized.sketchWidth > 65536) {
+      console.warn(`sketchWidth should not exceed 65536 for optimal performance, got ${sanitized.sketchWidth}. Correcting to 65536.`);
+      sanitized.sketchWidth = 65536;
+    }
+  }
+  if (typeof sanitized.sketchDepth === "number") {
+    if (sanitized.sketchDepth <= 0) {
+      console.warn(`sketchDepth must be positive, got ${sanitized.sketchDepth}. Correcting to 4.`);
+      sanitized.sketchDepth = 4;
+    } else if (sanitized.sketchDepth < 1) {
+      console.warn(`sketchDepth should be at least 1 for optimal accuracy, got ${sanitized.sketchDepth}. Correcting to 1.`);
+      sanitized.sketchDepth = 1;
+    } else if (sanitized.sketchDepth > 16) {
+      console.warn(`sketchDepth should not exceed 16 for optimal accuracy, got ${sanitized.sketchDepth}. Correcting to 16.`);
+      sanitized.sketchDepth = 16;
+    }
+  }
+  if (typeof sanitized.minFrequencyThreshold === "number" && sanitized.minFrequencyThreshold <= 0) {
+    console.warn(`minFrequencyThreshold must be positive, got ${sanitized.minFrequencyThreshold}. Correcting to 1.`);
+    sanitized.minFrequencyThreshold = 1;
+  }
+  return sanitized;
+}
+function validateLFUConfig(config) {
+  if (typeof config.decayFactor === "number") {
+    validateNumberRange(config.decayFactor, 0, 1, "decayFactor");
+  }
+  if (typeof config.decayInterval === "number") {
+    validatePositiveInteger(config.decayInterval, "decayInterval");
+  }
+  if (typeof config.sketchWidth === "number") {
+    validatePositiveInteger(config.sketchWidth, "sketchWidth");
+    if (config.sketchWidth < 16 || config.sketchWidth > 65536) {
+      throw new Error(`sketchWidth must be between 16 and 65536, got ${config.sketchWidth}`);
+    }
+  }
+  if (typeof config.sketchDepth === "number") {
+    validatePositiveInteger(config.sketchDepth, "sketchDepth");
+    if (config.sketchDepth < 1 || config.sketchDepth > 16) {
+      throw new Error(`sketchDepth must be between 1 and 16, got ${config.sketchDepth}`);
+    }
+  }
+  if (typeof config.minFrequencyThreshold === "number") {
+    validatePositiveInteger(config.minFrequencyThreshold, "minFrequencyThreshold");
+  }
+}
+function sanitizeARCConfig(config) {
+  const sanitized = { ...config };
+  if (typeof sanitized.maxCacheSize === "number" && sanitized.maxCacheSize <= 0) {
+    console.warn(`maxCacheSize must be positive, got ${sanitized.maxCacheSize}. Correcting to 1000.`);
+    sanitized.maxCacheSize = 1e3;
+  }
+  if (typeof sanitized.frequencyThreshold === "number" && sanitized.frequencyThreshold <= 0) {
+    console.warn(`frequencyThreshold must be positive, got ${sanitized.frequencyThreshold}. Correcting to 2.`);
+    sanitized.frequencyThreshold = 2;
+  }
+  if (typeof sanitized.frequencyDecayFactor === "number") {
+    if (sanitized.frequencyDecayFactor < 0) {
+      console.warn(`frequencyDecayFactor must be between 0 and 1, got ${sanitized.frequencyDecayFactor}. Correcting to 0.`);
+      sanitized.frequencyDecayFactor = 0;
+    } else if (sanitized.frequencyDecayFactor > 1) {
+      console.warn(`frequencyDecayFactor must be between 0 and 1, got ${sanitized.frequencyDecayFactor}. Correcting to 1.`);
+      sanitized.frequencyDecayFactor = 1;
+    }
+  }
+  if (typeof sanitized.frequencyDecayInterval === "number" && sanitized.frequencyDecayInterval <= 0) {
+    console.warn(`frequencyDecayInterval must be positive, got ${sanitized.frequencyDecayInterval}. Correcting to 60000.`);
+    sanitized.frequencyDecayInterval = 6e4;
+  }
+  if (typeof sanitized.adaptiveLearningRate === "number") {
+    if (sanitized.adaptiveLearningRate < 0) {
+      console.warn(`adaptiveLearningRate must be between 0 and 10, got ${sanitized.adaptiveLearningRate}. Correcting to 0.`);
+      sanitized.adaptiveLearningRate = 0;
+    } else if (sanitized.adaptiveLearningRate > 10) {
+      console.warn(`adaptiveLearningRate must be between 0 and 10, got ${sanitized.adaptiveLearningRate}. Correcting to 10.`);
+      sanitized.adaptiveLearningRate = 10;
+    }
+  }
+  return sanitized;
+}
+function validateARCConfig(config) {
+  if (typeof config.maxCacheSize === "number") {
+    validatePositiveInteger(config.maxCacheSize, "maxCacheSize");
+  }
+  if (typeof config.frequencyThreshold === "number") {
+    validatePositiveInteger(config.frequencyThreshold, "frequencyThreshold");
+  }
+  if (typeof config.frequencyDecayFactor === "number") {
+    validateNumberRange(config.frequencyDecayFactor, 0, 1, "frequencyDecayFactor");
+  }
+  if (typeof config.frequencyDecayInterval === "number") {
+    validatePositiveInteger(config.frequencyDecayInterval, "frequencyDecayInterval");
+  }
+  if (typeof config.adaptiveLearningRate === "number") {
+    validateNumberRange(config.adaptiveLearningRate, 0, 10, "adaptiveLearningRate");
+  }
+}
+function sanitizeTwoQueueConfig(config) {
+  const sanitized = { ...config };
+  if (typeof sanitized.maxCacheSize === "number" && sanitized.maxCacheSize <= 0) {
+    console.warn(`maxCacheSize must be positive, got ${sanitized.maxCacheSize}. Correcting to 1000.`);
+    sanitized.maxCacheSize = 1e3;
+  }
+  if (typeof sanitized.promotionThreshold === "number" && sanitized.promotionThreshold <= 0) {
+    console.warn(`promotionThreshold must be positive, got ${sanitized.promotionThreshold}. Correcting to 2.`);
+    sanitized.promotionThreshold = 2;
+  }
+  if (typeof sanitized.hotQueueDecayFactor === "number") {
+    if (sanitized.hotQueueDecayFactor < 0) {
+      console.warn(`hotQueueDecayFactor must be between 0 and 1, got ${sanitized.hotQueueDecayFactor}. Correcting to 0.`);
+      sanitized.hotQueueDecayFactor = 0;
+    } else if (sanitized.hotQueueDecayFactor > 1) {
+      console.warn(`hotQueueDecayFactor must be between 0 and 1, got ${sanitized.hotQueueDecayFactor}. Correcting to 1.`);
+      sanitized.hotQueueDecayFactor = 1;
+    }
+  }
+  if (typeof sanitized.hotQueueDecayInterval === "number" && sanitized.hotQueueDecayInterval <= 0) {
+    console.warn(`hotQueueDecayInterval must be positive, got ${sanitized.hotQueueDecayInterval}. Correcting to 300000.`);
+    sanitized.hotQueueDecayInterval = 3e5;
+  }
+  return sanitized;
+}
+function validateTwoQueueConfig(config) {
+  if (typeof config.maxCacheSize === "number") {
+    validatePositiveInteger(config.maxCacheSize, "maxCacheSize");
+  }
+  if (typeof config.promotionThreshold === "number") {
+    validatePositiveInteger(config.promotionThreshold, "promotionThreshold");
+  }
+  if (typeof config.hotQueueDecayFactor === "number") {
+    validateNumberRange(config.hotQueueDecayFactor, 0, 1, "hotQueueDecayFactor");
+  }
+  if (typeof config.hotQueueDecayInterval === "number") {
+    validatePositiveInteger(config.hotQueueDecayInterval, "hotQueueDecayInterval");
+  }
+}
+function validateEvictionStrategyConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Configuration must be a non-null object");
+  }
+  if (!config.type) {
+    throw new Error("Configuration must specify a type");
+  }
+  const validTypes = ["lfu", "lru", "fifo", "mru", "random", "arc", "2q"];
+  if (!validTypes.includes(config.type)) {
+    throw new Error(`Invalid eviction strategy type: ${config.type}. Must be one of: ${validTypes.join(", ")}`);
+  }
+  switch (config.type) {
+    case "lfu":
+      validateLFUConfig(config);
+      break;
+    case "arc":
+      validateARCConfig(config);
+      break;
+    case "2q":
+      validateTwoQueueConfig(config);
+      break;
+    case "lru":
+    case "fifo":
+    case "mru":
+    case "random":
+      break;
+    default:
+      throw new Error(`Unsupported eviction strategy type: ${config.type}`);
+  }
+}
+function sanitizeConfigByType(config) {
+  if (!config.type) {
+    return config;
+  }
+  switch (config.type) {
+    case "lfu":
+      return sanitizeLFUConfig(config);
+    case "arc":
+      return sanitizeARCConfig(config);
+    case "2q":
+      return sanitizeTwoQueueConfig(config);
+    case "lru":
+    case "fifo":
+    case "mru":
+    case "random":
+      return config;
+    default:
+      return config;
+  }
+}
+function createValidatedConfig(baseConfig, userConfig) {
+  const sanitizedUserConfig = sanitizeConfigByType(userConfig);
+  const mergedConfig = { ...baseConfig, ...sanitizedUserConfig };
+  validateEvictionStrategyConfig(mergedConfig);
+  return mergedConfig;
+}
+
+// src/eviction/strategies/LFUEvictionStrategy.ts
+function fnv1aHash(key, seed) {
+  const FNV_OFFSET_BASIS = 2166136261;
+  const FNV_PRIME = 16777619;
+  let hash = (FNV_OFFSET_BASIS ^ seed) >>> 0;
+  for (let i = 0; i < key.length; i++) {
+    hash ^= key.charCodeAt(i);
+    hash = hash * FNV_PRIME >>> 0;
+  }
+  hash ^= hash >>> 16;
+  hash = hash * 2246822507 >>> 0;
+  hash ^= hash >>> 13;
+  hash = hash * 3266489909 >>> 0;
+  hash ^= hash >>> 16;
+  return hash >>> 0;
+}
+var CountMinSketch = class {
+  sketches;
+  width;
+  depth;
+  seeds;
+  constructor(width = 1024, depth = 4) {
+    this.width = width;
+    this.depth = depth;
+    this.sketches = Array(depth).fill(null).map(() => new Array(width).fill(0));
+    this.seeds = Array(depth).fill(null).map(() => Math.floor(Math.random() * 1e6));
+  }
+  /**
+   * Check if a number is a power of 2 for optimized bit masking
+   */
+  isPowerOfTwo(n) {
+    return n > 0 && (n & n - 1) === 0;
+  }
+  /**
+   * Increment the frequency count for a key
+   */
+  increment(key) {
+    for (let i = 0; i < this.depth; i++) {
+      const hash = fnv1aHash(key, this.seeds[i]);
+      const index = this.isPowerOfTwo(this.width) ? hash & this.width - 1 : hash % this.width;
+      this.sketches[i][index]++;
+    }
+  }
+  /**
+   * Estimate the frequency count for a key
+   */
+  estimate(key) {
+    let minCount = Infinity;
+    for (let i = 0; i < this.depth; i++) {
+      const hash = fnv1aHash(key, this.seeds[i]);
+      const index = this.isPowerOfTwo(this.width) ? hash & this.width - 1 : hash % this.width;
+      minCount = Math.min(minCount, this.sketches[i][index]);
+    }
+    return minCount === Infinity ? 0 : minCount;
+  }
+  /**
+   * Apply decay to all frequencies
+   */
+  decay(factor) {
+    for (let i = 0; i < this.depth; i++) {
+      for (let j = 0; j < this.width; j++) {
+        this.sketches[i][j] = Math.floor(this.sketches[i][j] * (1 - factor));
+      }
+    }
+  }
+  /**
+   * Reset all frequencies to zero
+   */
+  reset() {
+    for (let i = 0; i < this.depth; i++) {
+      for (let j = 0; j < this.width; j++) {
+        this.sketches[i][j] = 0;
+      }
+    }
+  }
+};
+var LFUEvictionStrategy = class extends EvictionStrategy {
+  config;
+  sketch;
+  lastDecayTime;
+  constructor(config = {}) {
+    super();
+    const defaultBackwardsCompatible = {
+      useProbabilisticCounting: false,
+      decayFactor: 0,
+      decayInterval: Number.MAX_SAFE_INTEGER
     };
-  };
+    const baseConfig = { ...DEFAULT_LFU_CONFIG, ...defaultBackwardsCompatible };
+    this.config = createValidatedConfig(baseConfig, config);
+    this.sketch = this.config.useProbabilisticCounting ? new CountMinSketch(this.config.sketchWidth, this.config.sketchDepth) : null;
+    this.lastDecayTime = Date.now();
+  }
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    this.applyPeriodicDecay();
+    let leastUsedKey = null;
+    let lowestFrequency = Infinity;
+    let oldestAccessTime = Infinity;
+    for (const [key, metadata] of items) {
+      const frequency = this.getEffectiveFrequency(key, metadata);
+      if (frequency < lowestFrequency || frequency === lowestFrequency && metadata.lastAccessedAt < oldestAccessTime) {
+        lowestFrequency = frequency;
+        oldestAccessTime = metadata.lastAccessedAt;
+        leastUsedKey = key;
+      }
+    }
+    return leastUsedKey;
+  }
+  onItemAccessed(key, metadata) {
+    const now = Date.now();
+    metadata.lastAccessedAt = now;
+    metadata.accessCount++;
+    if (this.sketch) {
+      this.sketch.increment(key);
+      metadata.rawFrequency = this.sketch.estimate(key);
+    } else {
+      metadata.rawFrequency = metadata.accessCount;
+    }
+    if ((this.config.decayFactor ?? 0) > 0) {
+      metadata.frequencyScore = this.calculateFrequencyScore(metadata, now);
+      metadata.lastFrequencyUpdate = now;
+    }
+  }
+  onItemAdded(key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+    metadata.rawFrequency = 1;
+    if ((this.config.decayFactor ?? 0) > 0) {
+      metadata.frequencyScore = 1;
+      metadata.lastFrequencyUpdate = now;
+    }
+    if (this.sketch) {
+      this.sketch.increment(key);
+    }
+  }
+  onItemRemoved() {
+  }
+  /**
+   * Get the effective frequency for an item, applying real-time decay if needed
+   */
+  getEffectiveFrequency(_key, metadata) {
+    if ((this.config.decayFactor ?? 0) === 0) {
+      return metadata.rawFrequency || metadata.accessCount;
+    }
+    const now = Date.now();
+    if (typeof metadata.frequencyScore === "number" && typeof metadata.lastFrequencyUpdate === "number") {
+      const timeSinceUpdate = now - metadata.lastFrequencyUpdate;
+      const decayAmount = timeSinceUpdate / (this.config.decayInterval ?? 6e4) * (this.config.decayFactor ?? 0.1);
+      return Math.max(this.config.minFrequencyThreshold ?? 1, metadata.frequencyScore * (1 - decayAmount));
+    }
+    return metadata.rawFrequency || metadata.accessCount;
+  }
+  /**
+   * Calculate frequency score with decay applied
+   */
+  calculateFrequencyScore(metadata, currentTime) {
+    const rawFreq = metadata.rawFrequency || metadata.accessCount;
+    if (typeof metadata.lastFrequencyUpdate !== "number") {
+      return rawFreq;
+    }
+    const timeSinceUpdate = currentTime - metadata.lastFrequencyUpdate;
+    const decayAmount = timeSinceUpdate / (this.config.decayInterval ?? 6e4) * (this.config.decayFactor ?? 0.1);
+    const previousScore = metadata.frequencyScore || rawFreq;
+    const decayedScore = previousScore * (1 - decayAmount);
+    return Math.max(this.config.minFrequencyThreshold ?? 1, decayedScore + 1);
+  }
+  /**
+   * Apply periodic decay to the frequency sketch and metadata
+   */
+  applyPeriodicDecay() {
+    if ((this.config.decayFactor ?? 0) === 0) return;
+    const now = Date.now();
+    const timeSinceDecay = now - this.lastDecayTime;
+    if (timeSinceDecay >= (this.config.decayInterval ?? 6e4)) {
+      if (this.sketch) {
+        this.sketch.decay(this.config.decayFactor ?? 0.1);
+      }
+      this.lastDecayTime = now;
+    }
+  }
+  /**
+   * Get configuration for this strategy
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Reset frequency tracking (useful for testing or cache clearing)
+   */
+  reset() {
+    if (this.sketch) {
+      this.sketch.reset();
+    }
+    this.lastDecayTime = Date.now();
+  }
 };
 
-// src/Registry.ts
-import {
-  createRegistry as createBaseRegistry
-} from "@fjell/registry";
-var logger20 = logger_default.get("Registry");
-var createRegistryFactory = () => {
-  return (type, registryHub) => {
-    if (type !== "cache") {
-      throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
-    }
-    logger20.debug("Creating cache registry", { type, registryHub });
-    const baseRegistry = createBaseRegistry(type, registryHub);
-    return baseRegistry;
-  };
+// src/eviction/strategies/FIFOEvictionStrategy.ts
+var FIFOEvictionStrategy = class extends EvictionStrategy {
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, metadata] of items) {
+      if (metadata.addedAt < oldestTime) {
+        oldestTime = metadata.addedAt;
+        oldestKey = key;
+      }
+    }
+    return oldestKey;
+  }
+  onItemAccessed(_key, metadata) {
+    metadata.lastAccessedAt = Date.now();
+    metadata.accessCount++;
+  }
+  onItemAdded(_key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+  }
+  onItemRemoved() {
+  }
 };
-var createRegistry = (registryHub) => {
-  const baseRegistry = createBaseRegistry("cache", registryHub);
-  return {
-    ...baseRegistry
+
+// src/eviction/strategies/MRUEvictionStrategy.ts
+var MRUEvictionStrategy = class extends EvictionStrategy {
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    let newestKey = null;
+    let newestTime = -1;
+    for (const [key, metadata] of items) {
+      if (metadata.lastAccessedAt > newestTime) {
+        newestTime = metadata.lastAccessedAt;
+        newestKey = key;
+      }
+    }
+    return newestKey;
+  }
+  onItemAccessed(_key, metadata) {
+    metadata.lastAccessedAt = Date.now();
+    metadata.accessCount++;
+  }
+  onItemAdded(_key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+  }
+  onItemRemoved() {
+  }
+};
+
+// src/eviction/strategies/RandomEvictionStrategy.ts
+var RandomEvictionStrategy = class extends EvictionStrategy {
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    const keys = Array.from(items.keys());
+    const randomIndex = Math.floor(Math.random() * keys.length);
+    return keys[randomIndex];
+  }
+  onItemAccessed(_key, metadata) {
+    metadata.lastAccessedAt = Date.now();
+    metadata.accessCount++;
+  }
+  onItemAdded(_key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+  }
+  onItemRemoved() {
+  }
+};
+
+// src/eviction/strategies/ARCEvictionStrategy.ts
+var ARCEvictionStrategy = class extends EvictionStrategy {
+  recentGhosts = /* @__PURE__ */ new Set();
+  // T1 ghost entries
+  frequentGhosts = /* @__PURE__ */ new Set();
+  // T2 ghost entries
+  targetRecentSize = 0;
+  // Target size for T1 (recent entries)
+  config;
+  maxGhostSize;
+  lastDecayTime;
+  constructor(maxCacheSize = 1e3, config = {}) {
+    super();
+    const baseConfig = { ...DEFAULT_ARC_CONFIG, maxCacheSize };
+    this.config = createValidatedConfig(baseConfig, config);
+    this.maxGhostSize = this.config.maxCacheSize;
+    this.lastDecayTime = Date.now();
+  }
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    this.applyPeriodicDecay(items);
+    const recentItems = /* @__PURE__ */ new Map();
+    const frequentItems = /* @__PURE__ */ new Map();
+    for (const [key, metadata] of items) {
+      if (this.isFrequentItem(metadata)) {
+        frequentItems.set(key, metadata);
+      } else {
+        recentItems.set(key, metadata);
+      }
+    }
+    if (recentItems.size > this.targetRecentSize && recentItems.size > 0) {
+      return this.config.useFrequencyWeightedSelection ? this.selectFrequencyWeightedFromItems(recentItems, "recent") : this.selectLRUFromItems(recentItems);
+    } else if (frequentItems.size > 0) {
+      return this.config.useFrequencyWeightedSelection ? this.selectFrequencyWeightedFromItems(frequentItems, "frequent") : this.selectLRUFromItems(frequentItems);
+    }
+    return this.config.useFrequencyWeightedSelection ? this.selectFrequencyWeightedFromItems(items, "fallback") : this.selectLRUFromItems(items);
+  }
+  selectLRUFromItems(items) {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, metadata] of items) {
+      if (metadata.lastAccessedAt < oldestTime) {
+        oldestTime = metadata.lastAccessedAt;
+        oldestKey = key;
+      }
+    }
+    return oldestKey;
+  }
+  onItemAccessed(key, metadata) {
+    const now = Date.now();
+    metadata.lastAccessedAt = now;
+    metadata.accessCount++;
+    metadata.rawFrequency = metadata.accessCount;
+    if (this.config.useEnhancedFrequency && (this.config.frequencyDecayFactor ?? 0) > 0) {
+      metadata.frequencyScore = this.calculateFrequencyScore(metadata, now);
+      metadata.lastFrequencyUpdate = now;
+    }
+    const learningRate = this.config.adaptiveLearningRate ?? 1;
+    if (this.recentGhosts.has(key)) {
+      const adjustment = Math.ceil(learningRate);
+      this.targetRecentSize = Math.min(this.targetRecentSize + adjustment, this.maxGhostSize);
+      this.recentGhosts.delete(key);
+    } else if (this.frequentGhosts.has(key)) {
+      const adjustment = Math.ceil(learningRate);
+      this.targetRecentSize = Math.max(this.targetRecentSize - adjustment, 0);
+      this.frequentGhosts.delete(key);
+    }
+  }
+  onItemAdded(key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+    metadata.rawFrequency = 1;
+    if (this.config.useEnhancedFrequency && (this.config.frequencyDecayFactor ?? 0) > 0) {
+      metadata.frequencyScore = 1;
+      metadata.lastFrequencyUpdate = now;
+    }
+  }
+  onItemRemoved(key) {
+    this.addToRecentGhosts(key);
+    this.cleanupGhostLists();
+  }
+  /**
+   * Add key to recent ghost list with proper size management
+   */
+  addToRecentGhosts(key) {
+    this.frequentGhosts.delete(key);
+    this.recentGhosts.add(key);
+    while (this.recentGhosts.size > this.maxGhostSize) {
+      const firstKey = this.recentGhosts.values().next().value;
+      if (firstKey) {
+        this.recentGhosts.delete(firstKey);
+      }
+    }
+  }
+  /**
+   * Add key to frequent ghost list with proper size management
+   */
+  addToFrequentGhosts(key) {
+    this.recentGhosts.delete(key);
+    this.frequentGhosts.add(key);
+    while (this.frequentGhosts.size > this.maxGhostSize) {
+      const firstKey = this.frequentGhosts.values().next().value;
+      if (firstKey) {
+        this.frequentGhosts.delete(firstKey);
+      }
+    }
+  }
+  /**
+   * Cleanup ghost lists to prevent memory leaks
+   */
+  cleanupGhostLists() {
+    while (this.recentGhosts.size > this.maxGhostSize) {
+      const firstKey = this.recentGhosts.values().next().value;
+      if (firstKey) {
+        this.recentGhosts.delete(firstKey);
+      } else {
+        break;
+      }
+    }
+    while (this.frequentGhosts.size > this.maxGhostSize) {
+      const firstKey = this.frequentGhosts.values().next().value;
+      if (firstKey) {
+        this.frequentGhosts.delete(firstKey);
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * Determine if an item should be classified as frequent vs recent
+   */
+  isFrequentItem(metadata) {
+    if (!this.config.useEnhancedFrequency) {
+      return metadata.accessCount > 1;
+    }
+    const frequency = this.getEffectiveFrequency(metadata);
+    return frequency >= (this.config.frequencyThreshold ?? 2);
+  }
+  /**
+   * Get effective frequency for an item, applying decay if enabled
+   */
+  getEffectiveFrequency(metadata) {
+    if (!this.config.useEnhancedFrequency || (this.config.frequencyDecayFactor ?? 0) === 0) {
+      return metadata.rawFrequency || metadata.accessCount;
+    }
+    const now = Date.now();
+    if (typeof metadata.frequencyScore === "number" && typeof metadata.lastFrequencyUpdate === "number") {
+      const timeSinceUpdate = now - metadata.lastFrequencyUpdate;
+      const decayAmount = timeSinceUpdate / (this.config.frequencyDecayInterval ?? 6e5) * (this.config.frequencyDecayFactor ?? 0.05);
+      return Math.max(1, metadata.frequencyScore * (1 - decayAmount));
+    }
+    return metadata.rawFrequency || metadata.accessCount;
+  }
+  /**
+   * Calculate frequency score with decay applied
+   */
+  calculateFrequencyScore(metadata, currentTime) {
+    const rawFreq = metadata.rawFrequency || metadata.accessCount;
+    if (typeof metadata.lastFrequencyUpdate !== "number") {
+      return rawFreq;
+    }
+    const timeSinceUpdate = currentTime - metadata.lastFrequencyUpdate;
+    const decayAmount = timeSinceUpdate / (this.config.frequencyDecayInterval ?? 6e5) * (this.config.frequencyDecayFactor ?? 0.05);
+    const previousScore = metadata.frequencyScore || rawFreq;
+    const decayedScore = previousScore * (1 - decayAmount);
+    return Math.max(1, decayedScore + 1);
+  }
+  /**
+   * Select eviction candidate using frequency-weighted approach
+   */
+  selectFrequencyWeightedFromItems(items, context) {
+    let bestKey = null;
+    let bestScore = Infinity;
+    for (const [key, metadata] of items) {
+      const frequency = this.getEffectiveFrequency(metadata);
+      const timeFactor = Date.now() - metadata.lastAccessedAt;
+      let score;
+      if (context === "recent") {
+        score = timeFactor + 1e3 / Math.max(1, frequency);
+      } else if (context === "frequent") {
+        score = timeFactor / 1e3 + 10 / Math.max(1, frequency);
+      } else {
+        score = timeFactor / 1e3 / Math.max(1, frequency);
+      }
+      if (score < bestScore) {
+        bestScore = score;
+        bestKey = key;
+      }
+    }
+    return bestKey || (items.size > 0 ? items.keys().next().value ?? null : null);
+  }
+  /**
+   * Apply periodic decay to frequency scores
+   */
+  applyPeriodicDecay(items) {
+    if (!this.config.useEnhancedFrequency || (this.config.frequencyDecayFactor ?? 0) === 0) return;
+    const now = Date.now();
+    const timeSinceDecay = now - this.lastDecayTime;
+    if (timeSinceDecay >= (this.config.frequencyDecayInterval ?? 6e5)) {
+      if (items.size > 0) {
+        for (const metadata of items.values()) {
+          if (typeof metadata.frequencyScore === "number") {
+            const decayAmount = this.config.frequencyDecayFactor ?? 0.05;
+            metadata.frequencyScore = Math.max(1, metadata.frequencyScore * (1 - decayAmount));
+          }
+        }
+        this.lastDecayTime = now;
+      }
+    }
+  }
+  /**
+   * Get configuration for this strategy
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Reset internal state (useful for testing)
+   */
+  reset() {
+    this.recentGhosts.clear();
+    this.frequentGhosts.clear();
+    this.targetRecentSize = 0;
+    this.lastDecayTime = Date.now();
+  }
+  /**
+   * Get current adaptive state for monitoring/debugging
+   */
+  getAdaptiveState() {
+    return {
+      targetRecentSize: this.targetRecentSize,
+      recentGhostSize: this.recentGhosts.size,
+      frequentGhostSize: this.frequentGhosts.size
+    };
+  }
+};
+
+// src/eviction/strategies/TwoQueueEvictionStrategy.ts
+var TwoQueueEvictionStrategy = class extends EvictionStrategy {
+  recentQueue = [];
+  // A1 queue for recent items
+  hotQueue = [];
+  // Am queue for hot items
+  ghostQueue = /* @__PURE__ */ new Set();
+  // A1out ghost queue
+  config;
+  maxRecentSize;
+  maxGhostSize;
+  lastDecayTime;
+  constructor(maxCacheSize = 1e3, config = {}) {
+    super();
+    const baseConfig = { ...DEFAULT_TWO_QUEUE_CONFIG, maxCacheSize };
+    this.config = createValidatedConfig(baseConfig, config);
+    this.maxRecentSize = Math.max(1, Math.floor(this.config.maxCacheSize * 0.25));
+    this.maxGhostSize = this.config.maxCacheSize;
+    this.lastDecayTime = Date.now();
+  }
+  selectForEviction(items) {
+    if (items.size === 0) return null;
+    this.applyPeriodicDecay(items);
+    for (let i = this.recentQueue.length - 1; i >= 0; i--) {
+      const key = this.recentQueue[i];
+      if (items.has(key)) {
+        return key;
+      }
+    }
+    if (this.config.useFrequencyWeightedLRU) {
+      return this.selectFromHotQueueFrequencyWeighted(items);
+    } else {
+      return this.selectFromHotQueueLRU(items);
+    }
+  }
+  /**
+   * Select eviction candidate from hot queue using traditional LRU
+   */
+  selectFromHotQueueLRU(items) {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const key of this.hotQueue) {
+      const metadata = items.get(key);
+      if (metadata && metadata.lastAccessedAt < oldestTime) {
+        oldestTime = metadata.lastAccessedAt;
+        oldestKey = key;
+      }
+    }
+    return oldestKey || (items.size > 0 ? items.keys().next().value ?? null : null);
+  }
+  /**
+   * Select eviction candidate from hot queue using frequency-weighted LRU
+   */
+  selectFromHotQueueFrequencyWeighted(items) {
+    let bestKey = null;
+    let lowestScore = Infinity;
+    for (const key of this.hotQueue) {
+      const metadata = items.get(key);
+      if (!metadata) continue;
+      const frequency = this.getEffectiveFrequency(metadata);
+      const timeFactor = Date.now() - metadata.lastAccessedAt;
+      const normalizedTimeFactor = timeFactor / (1e3 * 60);
+      const score = normalizedTimeFactor / Math.max(1, frequency);
+      if (score < lowestScore) {
+        lowestScore = score;
+        bestKey = key;
+      }
+    }
+    return bestKey || (items.size > 0 ? items.keys().next().value ?? null : null);
+  }
+  onItemAccessed(key, metadata) {
+    const now = Date.now();
+    metadata.lastAccessedAt = now;
+    metadata.accessCount++;
+    metadata.rawFrequency = metadata.accessCount;
+    if ((this.config.hotQueueDecayFactor ?? 0) > 0) {
+      metadata.frequencyScore = this.calculateFrequencyScore(metadata, now);
+      metadata.lastFrequencyUpdate = now;
+    }
+    const recentIndex = this.recentQueue.indexOf(key);
+    if (recentIndex !== -1) {
+      if (this.shouldPromoteToHotQueue(metadata)) {
+        this.recentQueue.splice(recentIndex, 1);
+        this.hotQueue.unshift(key);
+      }
+    } else {
+      const hotIndex = this.hotQueue.indexOf(key);
+      if (hotIndex !== -1) {
+        this.hotQueue.splice(hotIndex, 1);
+        this.hotQueue.unshift(key);
+      }
+    }
+  }
+  onItemAdded(key, metadata) {
+    const now = Date.now();
+    metadata.addedAt = now;
+    metadata.lastAccessedAt = now;
+    metadata.accessCount = 1;
+    metadata.rawFrequency = 1;
+    if ((this.config.hotQueueDecayFactor ?? 0) > 0) {
+      metadata.frequencyScore = 1;
+      metadata.lastFrequencyUpdate = now;
+    }
+    if (this.ghostQueue.has(key)) {
+      this.ghostQueue.delete(key);
+      this.hotQueue.unshift(key);
+    } else {
+      this.recentQueue.unshift(key);
+      if (this.recentQueue.length > this.maxRecentSize) {
+        const evicted = this.recentQueue.pop();
+        if (evicted) {
+          this.ghostQueue.add(evicted);
+        }
+      }
+    }
+    if (this.ghostQueue.size > this.maxGhostSize) {
+      const firstKey = this.ghostQueue.values().next().value;
+      if (firstKey) {
+        this.ghostQueue.delete(firstKey);
+      }
+    }
+  }
+  onItemRemoved(key) {
+    const recentIndex = this.recentQueue.indexOf(key);
+    if (recentIndex !== -1) {
+      this.recentQueue.splice(recentIndex, 1);
+    }
+    const hotIndex = this.hotQueue.indexOf(key);
+    if (hotIndex !== -1) {
+      this.hotQueue.splice(hotIndex, 1);
+    }
+  }
+  /**
+   * Determine if an item should be promoted from recent to hot queue
+   */
+  shouldPromoteToHotQueue(metadata) {
+    if (!this.config.useFrequencyPromotion) {
+      return metadata.accessCount >= 2;
+    }
+    const threshold = this.config.promotionThreshold ?? 2;
+    const frequency = this.getEffectiveFrequency(metadata);
+    return frequency >= threshold;
+  }
+  /**
+   * Get effective frequency for an item, applying decay if enabled
+   */
+  getEffectiveFrequency(metadata) {
+    if ((this.config.hotQueueDecayFactor ?? 0) === 0) {
+      return metadata.rawFrequency || metadata.accessCount;
+    }
+    const now = Date.now();
+    if (typeof metadata.frequencyScore === "number" && typeof metadata.lastFrequencyUpdate === "number") {
+      const timeSinceUpdate = now - metadata.lastFrequencyUpdate;
+      const decayAmount = timeSinceUpdate / (this.config.hotQueueDecayInterval ?? 3e5) * (this.config.hotQueueDecayFactor ?? 0.05);
+      return Math.max(1, metadata.frequencyScore * (1 - decayAmount));
+    }
+    return metadata.rawFrequency || metadata.accessCount;
+  }
+  /**
+   * Calculate frequency score with decay applied
+   */
+  calculateFrequencyScore(metadata, currentTime) {
+    const rawFreq = metadata.rawFrequency || metadata.accessCount;
+    if (typeof metadata.lastFrequencyUpdate !== "number") {
+      return rawFreq;
+    }
+    const timeSinceUpdate = currentTime - metadata.lastFrequencyUpdate;
+    const decayAmount = timeSinceUpdate / (this.config.hotQueueDecayInterval ?? 3e5) * (this.config.hotQueueDecayFactor ?? 0.05);
+    const previousScore = metadata.frequencyScore || rawFreq;
+    const decayedScore = previousScore * (1 - decayAmount);
+    return Math.max(1, decayedScore + 1);
+  }
+  /**
+   * Apply periodic decay to hot queue items
+   */
+  applyPeriodicDecay(items) {
+    if ((this.config.hotQueueDecayFactor ?? 0) === 0) return;
+    const now = Date.now();
+    const timeSinceDecay = now - this.lastDecayTime;
+    if (timeSinceDecay >= (this.config.hotQueueDecayInterval ?? 3e5)) {
+      if (this.hotQueue.length > 0) {
+        for (const key of this.hotQueue) {
+          const metadata = items.get(key);
+          if (metadata && typeof metadata.frequencyScore === "number") {
+            const decayAmount = this.config.hotQueueDecayFactor ?? 0.05;
+            metadata.frequencyScore = Math.max(1, metadata.frequencyScore * (1 - decayAmount));
+          }
+        }
+        this.lastDecayTime = now;
+      }
+    }
+  }
+  /**
+   * Get configuration for this strategy
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Reset internal state (useful for testing)
+   */
+  reset() {
+    this.recentQueue = [];
+    this.hotQueue = [];
+    this.ghostQueue.clear();
+    this.lastDecayTime = Date.now();
+  }
+};
+
+// src/eviction/EvictionStrategyFactory.ts
+function createEvictionStrategy(policy, maxCacheSize, config) {
+  const safeMaxCacheSize = typeof maxCacheSize === "number" && maxCacheSize > 0 ? maxCacheSize : 1e3;
+  switch (policy) {
+    case "lru":
+      return new LRUEvictionStrategy();
+    case "lfu": {
+      try {
+        const lfuConfig = config?.type === "lfu" ? config : { type: "lfu" };
+        return new LFUEvictionStrategy(lfuConfig);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to create lfu strategy with provided configuration, falling back to LRU:`, errorMessage);
+        return new LRUEvictionStrategy();
+      }
+    }
+    case "fifo":
+      return new FIFOEvictionStrategy();
+    case "mru":
+      return new MRUEvictionStrategy();
+    case "random":
+      return new RandomEvictionStrategy();
+    case "arc": {
+      try {
+        const arcConfig = config?.type === "arc" ? config : { ...DEFAULT_ARC_CONFIG, maxCacheSize: safeMaxCacheSize };
+        const finalMaxSize = arcConfig.maxCacheSize && arcConfig.maxCacheSize > 0 ? arcConfig.maxCacheSize : safeMaxCacheSize;
+        return new ARCEvictionStrategy(finalMaxSize, { ...arcConfig, maxCacheSize: finalMaxSize });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to create arc strategy with provided configuration, falling back to LRU:`, errorMessage);
+        return new LRUEvictionStrategy();
+      }
+    }
+    case "2q": {
+      try {
+        const twoQConfig = config?.type === "2q" ? config : { ...DEFAULT_TWO_QUEUE_CONFIG, maxCacheSize: safeMaxCacheSize };
+        const finalMaxSize = twoQConfig.maxCacheSize && twoQConfig.maxCacheSize > 0 ? twoQConfig.maxCacheSize : safeMaxCacheSize;
+        return new TwoQueueEvictionStrategy(finalMaxSize, { ...twoQConfig, maxCacheSize: finalMaxSize });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to create 2q strategy with provided configuration, falling back to LRU:`, errorMessage);
+        return new LRUEvictionStrategy();
+      }
+    }
+    default:
+      throw new Error(`Unsupported eviction policy: ${policy}`);
+  }
+}
+
+// src/utils/CacheSize.ts
+var SIZE_UNITS = {
+  // Decimal units (powers of 1000)
+  "b": 1,
+  "byte": 1,
+  "bytes": 1,
+  "kb": 1e3,
+  "kilobyte": 1e3,
+  "kilobytes": 1e3,
+  "mb": 1e3 * 1e3,
+  "megabyte": 1e3 * 1e3,
+  "megabytes": 1e3 * 1e3,
+  "gb": 1e3 * 1e3 * 1e3,
+  "gigabyte": 1e3 * 1e3 * 1e3,
+  "gigabytes": 1e3 * 1e3 * 1e3,
+  "tb": 1e3 * 1e3 * 1e3 * 1e3,
+  "terabyte": 1e3 * 1e3 * 1e3 * 1e3,
+  "terabytes": 1e3 * 1e3 * 1e3 * 1e3,
+  // Binary units (powers of 1024)
+  "kib": 1024,
+  "kibibyte": 1024,
+  "kibibytes": 1024,
+  "mib": 1024 * 1024,
+  "mebibyte": 1024 * 1024,
+  "mebibytes": 1024 * 1024,
+  "gib": 1024 * 1024 * 1024,
+  "gibibyte": 1024 * 1024 * 1024,
+  "gibibytes": 1024 * 1024 * 1024,
+  "tib": 1024 * 1024 * 1024 * 1024,
+  "tebibyte": 1024 * 1024 * 1024 * 1024,
+  "tebibytes": 1024 * 1024 * 1024 * 1024
+};
+function parseSizeString(sizeStr) {
+  if (!sizeStr || typeof sizeStr !== "string") {
+    throw new Error("Size string must be a non-empty string");
+  }
+  const trimmed = sizeStr.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const bytes = parseFloat(trimmed);
+    if (isNaN(bytes) || bytes < 0) {
+      throw new Error(`Invalid size value: ${sizeStr}`);
+    }
+    return Math.floor(bytes);
+  }
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*([a-zA-Z]+)$/);
+  if (!match) {
+    throw new Error(`Invalid size format: ${sizeStr}. Expected format: '100', '5KB', '10MB', etc.`);
+  }
+  const [, valueStr, unitStr] = match;
+  const value = parseFloat(valueStr);
+  const unit = unitStr.toLowerCase();
+  if (isNaN(value) || value < 0) {
+    throw new Error(`Invalid size value: ${valueStr}`);
+  }
+  const multiplier = SIZE_UNITS[unit];
+  if (!(unit in SIZE_UNITS)) {
+    const supportedUnits = Object.keys(SIZE_UNITS).filter((u) => u.length <= 3).join(", ");
+    throw new Error(`Unsupported size unit: ${unitStr}. Supported units: ${supportedUnits}`);
+  }
+  return Math.floor(value * multiplier);
+}
+function formatBytes(bytes, binary = false) {
+  if (bytes === 0) return "0 B";
+  if (bytes < 0) return `${bytes} B`;
+  const k = binary ? 1024 : 1e3;
+  const sizes = binary ? ["B", "KiB", "MiB", "GiB", "TiB", "PiB"] : ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = bytes / Math.pow(k, i);
+  const formatted = size % 1 === 0 ? size.toString() : size.toFixed(1);
+  return `${formatted} ${sizes[i]}`;
+}
+function estimateValueSize(value) {
+  if (value === null || typeof value === "undefined") {
+    return 8;
+  }
+  switch (typeof value) {
+    case "boolean":
+      return 4;
+    case "number":
+      return 8;
+    case "string":
+      return value.length * 2;
+    case "object":
+      if (Array.isArray(value)) {
+        return value.reduce((total, item) => total + estimateValueSize(item), 24);
+      }
+      try {
+        const jsonString = JSON.stringify(value);
+        return jsonString.length * 2 + 16;
+      } catch {
+        return 64;
+      }
+    default:
+      return 32;
+  }
+}
+function validateSizeConfig(config) {
+  if (typeof config.maxSizeBytes !== "undefined") {
+    try {
+      const bytes = parseSizeString(config.maxSizeBytes);
+      if (bytes <= 0) {
+        throw new Error("maxSizeBytes must be positive");
+      }
+    } catch (error) {
+      throw new Error(`Invalid maxSizeBytes: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (typeof config.maxItems !== "undefined") {
+    if (!Number.isInteger(config.maxItems) || config.maxItems <= 0) {
+      throw new Error("maxItems must be a positive integer");
+    }
+  }
+}
+
+// src/memory/EnhancedMemoryCacheMap.ts
+var logger16 = logger_default.get("EnhancedMemoryCacheMap");
+var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
+  map = {};
+  normalizedHashFunction;
+  // Query result cache: maps query hash to cache entry with expiration
+  queryResultCache = {};
+  // Mutex-like tracking for TTL operations to prevent race conditions
+  ttlOperationsInProgress = /* @__PURE__ */ new Set();
+  // Size tracking
+  currentSizeBytes = 0;
+  currentItemCount = 0;
+  queryResultsCacheSize = 0;
+  // Size limits
+  maxSizeBytes;
+  maxItems;
+  // Eviction strategy
+  evictionStrategy;
+  constructor(types, sizeConfig, initialData) {
+    super(types);
+    this.normalizedHashFunction = createNormalizedHashFunction();
+    if (sizeConfig?.maxSizeBytes) {
+      this.maxSizeBytes = parseSizeString(sizeConfig.maxSizeBytes);
+      logger16.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
+    }
+    if (sizeConfig?.maxItems) {
+      this.maxItems = sizeConfig.maxItems;
+      logger16.debug("Cache item limit set", { maxItems: this.maxItems });
+    }
+    const policy = sizeConfig?.evictionPolicy || "lru";
+    const maxCacheSize = this.maxItems || 1e3;
+    this.evictionStrategy = createEvictionStrategy(policy, maxCacheSize);
+    logger16.debug("Eviction strategy initialized", { policy });
+    if (initialData) {
+      for (const [keyStr, value] of Object.entries(initialData)) {
+        try {
+          const key = JSON.parse(keyStr);
+          this.set(key, value);
+        } catch (error) {
+          logger16.error("Failed to parse initial data key", { keyStr, error });
+        }
+      }
+    }
+  }
+  get(key) {
+    logger16.trace("get", { key });
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
+      this.evictionStrategy.onItemAccessed(hashedKey, entry.metadata);
+      return entry.value;
+    }
+    return null;
+  }
+  getWithTTL(key, ttl) {
+    logger16.trace("getWithTTL", { key, ttl });
+    if (ttl === 0) {
+      return null;
+    }
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
+      const now = Date.now();
+      const age = now - entry.metadata.addedAt;
+      if (age >= ttl) {
+        logger16.trace("Item expired, removing from enhanced cache", { key, age, ttl });
+        this.delete(key);
+        return null;
+      }
+      this.evictionStrategy.onItemAccessed(hashedKey, entry.metadata);
+      return entry.value;
+    }
+    return null;
+  }
+  set(key, value) {
+    logger16.trace("set", { key, value });
+    const hashedKey = this.normalizedHashFunction(key);
+    const estimatedSize = estimateValueSize(value);
+    const existingEntry = this.map[hashedKey];
+    const isUpdate = existingEntry && this.normalizedHashFunction(existingEntry.originalKey) === hashedKey;
+    if (isUpdate) {
+      const sizeDiff = estimatedSize - existingEntry.metadata.estimatedSize;
+      this.currentSizeBytes += sizeDiff;
+      const oldValue = existingEntry.value;
+      existingEntry.value = value;
+      existingEntry.metadata.estimatedSize = estimatedSize;
+      this.evictionStrategy.onItemRemoved(hashedKey);
+      this.evictionStrategy.onItemAdded(hashedKey, existingEntry.metadata);
+      logger16.trace("Updated existing cache entry", {
+        key: hashedKey,
+        sizeDiff,
+        currentSize: this.currentSizeBytes,
+        oldValue: oldValue !== value
+      });
+    } else {
+      this.ensureSpaceAvailable(estimatedSize);
+      const metadata = {
+        addedAt: Date.now(),
+        lastAccessedAt: Date.now(),
+        accessCount: 0,
+        estimatedSize,
+        key: hashedKey
+      };
+      this.map[hashedKey] = {
+        originalKey: key,
+        value,
+        metadata
+      };
+      this.currentSizeBytes += estimatedSize;
+      this.currentItemCount++;
+      this.evictionStrategy.onItemAdded(hashedKey, metadata);
+      logger16.trace("Added new cache entry", {
+        key: hashedKey,
+        size: estimatedSize,
+        currentSize: this.currentSizeBytes,
+        currentCount: this.currentItemCount
+      });
+    }
+  }
+  includesKey(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
+  }
+  delete(key) {
+    logger16.trace("delete", { key });
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.map[hashedKey];
+    if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
+      this.currentSizeBytes -= entry.metadata.estimatedSize;
+      this.currentItemCount--;
+      this.evictionStrategy.onItemRemoved(hashedKey);
+      delete this.map[hashedKey];
+      logger16.trace("Deleted cache entry", {
+        key: hashedKey,
+        freedSize: entry.metadata.estimatedSize,
+        currentSize: this.currentSizeBytes,
+        currentCount: this.currentItemCount
+      });
+    }
+  }
+  keys() {
+    return Object.values(this.map).map((entry) => entry.originalKey);
+  }
+  values() {
+    return Object.values(this.map).map((entry) => entry.value);
+  }
+  clear() {
+    logger16.debug("Clearing cache", {
+      itemsCleared: this.currentItemCount,
+      bytesFreed: this.currentSizeBytes
+    });
+    for (const hashedKey of Object.keys(this.map)) {
+      this.evictionStrategy.onItemRemoved(hashedKey);
+    }
+    this.map = {};
+    this.currentSizeBytes = 0;
+    this.currentItemCount = 0;
+  }
+  allIn(locations) {
+    const allValues = this.values();
+    if (locations.length === 0) {
+      logger16.debug("Returning all items, LocKeys is empty");
+      return allValues;
+    } else {
+      logger16.debug("allIn", { locations, count: allValues.length });
+      return allValues.filter((item) => {
+        const key = item.key;
+        if (key && isComKey2(key)) {
+          return isLocKeyArrayEqual(locations, key.loc);
+        }
+        return false;
+      });
+    }
+  }
+  contains(query, locations) {
+    logger16.debug("contains", { query, locations });
+    const items = this.allIn(locations);
+    return items.some((item) => isQueryMatch2(item, query));
+  }
+  queryIn(query, locations = []) {
+    logger16.debug("queryIn", { query, locations });
+    const items = this.allIn(locations);
+    return items.filter((item) => isQueryMatch2(item, query));
+  }
+  clone() {
+    const sizeConfig = {};
+    if (this.maxSizeBytes) {
+      sizeConfig.maxSizeBytes = this.maxSizeBytes.toString();
+    }
+    if (this.maxItems) {
+      sizeConfig.maxItems = this.maxItems;
+    }
+    const clone = new _EnhancedMemoryCacheMap(this.types, sizeConfig);
+    for (const key of this.keys()) {
+      const value = this.get(key);
+      if (value) {
+        clone.set(key, value);
+      }
+    }
+    return clone;
+  }
+  /**
+   * Get current cache statistics
+   */
+  getStats() {
+    const stats = {
+      currentSizeBytes: this.currentSizeBytes,
+      currentItemCount: this.currentItemCount,
+      maxSizeBytes: this.maxSizeBytes,
+      maxItems: this.maxItems,
+      utilizationPercent: {}
+    };
+    if (this.maxSizeBytes) {
+      stats.utilizationPercent.bytes = this.currentSizeBytes / this.maxSizeBytes * 100;
+    }
+    if (this.maxItems) {
+      stats.utilizationPercent.items = this.currentItemCount / this.maxItems * 100;
+    }
+    return stats;
+  }
+  /**
+   * Ensure there's space available for a new item of the given size
+   * Evicts items if necessary based on the configured eviction policy
+   */
+  ensureSpaceAvailable(newItemSize) {
+    const itemMetadata = /* @__PURE__ */ new Map();
+    for (const [hashedKey, entry] of Object.entries(this.map)) {
+      itemMetadata.set(hashedKey, entry.metadata);
+    }
+    while (this.maxItems && this.currentItemCount >= this.maxItems) {
+      const keyToEvict = this.evictionStrategy.selectForEviction(itemMetadata);
+      if (!keyToEvict) {
+        logger16.debug("No item selected for eviction despite being over item limit");
+        break;
+      }
+      this.evictItem(keyToEvict, itemMetadata);
+      logger16.debug("Evicted item due to count limit", {
+        evictedKey: keyToEvict,
+        currentCount: this.currentItemCount,
+        maxItems: this.maxItems
+      });
+    }
+    while (this.maxSizeBytes && this.getTotalSizeBytes() + newItemSize > this.maxSizeBytes) {
+      const keyToEvict = this.evictionStrategy.selectForEviction(itemMetadata);
+      if (!keyToEvict) {
+        logger16.debug("No item selected for eviction despite being over size limit");
+        break;
+      }
+      this.evictItem(keyToEvict, itemMetadata);
+      logger16.debug("Evicted item due to size limit", {
+        evictedKey: keyToEvict,
+        currentItemsSize: this.currentSizeBytes,
+        queryResultsSize: this.queryResultsCacheSize,
+        totalSize: this.getTotalSizeBytes(),
+        newItemSize,
+        maxSizeBytes: this.maxSizeBytes
+      });
+    }
+  }
+  /**
+   * Evict a specific item and update metadata tracking
+   */
+  evictItem(hashedKey, itemMetadata) {
+    const entry = this.map[hashedKey];
+    if (entry) {
+      const originalKey = entry.originalKey;
+      this.delete(originalKey);
+      itemMetadata.delete(hashedKey);
+    }
+  }
+  // Query result caching methods
+  setQueryResult(queryHash, itemKeys, ttl) {
+    logger16.trace("setQueryResult", { queryHash, itemKeys, ttl });
+    if (queryHash in this.queryResultCache) {
+      this.removeQueryResultFromSizeTracking(queryHash);
+    }
+    const entry = {
+      itemKeys: [...itemKeys]
+      // Create a copy to avoid external mutations
+    };
+    if (ttl) {
+      entry.expiresAt = Date.now() + ttl;
+    }
+    this.queryResultCache[queryHash] = entry;
+    this.addQueryResultToSizeTracking(queryHash, entry);
+  }
+  getQueryResult(queryHash) {
+    logger16.trace("getQueryResult", { queryHash });
+    if (this.ttlOperationsInProgress.has(queryHash)) {
+      const entry2 = this.queryResultCache[queryHash];
+      return entry2 ? [...entry2.itemKeys] : null;
+    }
+    const entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.ttlOperationsInProgress.add(queryHash);
+      try {
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+          logger16.trace("Query result expired, removing", { queryHash, expiresAt: entry.expiresAt });
+          this.removeQueryResultFromSizeTracking(queryHash);
+          delete this.queryResultCache[queryHash];
+          return null;
+        }
+      } finally {
+        this.ttlOperationsInProgress.delete(queryHash);
+      }
+    }
+    return [...entry.itemKeys];
+  }
+  hasQueryResult(queryHash) {
+    if (this.ttlOperationsInProgress.has(queryHash)) {
+      return queryHash in this.queryResultCache;
+    }
+    const entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      return false;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.ttlOperationsInProgress.add(queryHash);
+      try {
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+          this.removeQueryResultFromSizeTracking(queryHash);
+          delete this.queryResultCache[queryHash];
+          return false;
+        }
+      } finally {
+        this.ttlOperationsInProgress.delete(queryHash);
+      }
+    }
+    return true;
+  }
+  deleteQueryResult(queryHash) {
+    if (queryHash in this.queryResultCache) {
+      this.removeQueryResultFromSizeTracking(queryHash);
+      delete this.queryResultCache[queryHash];
+    }
+  }
+  clearQueryResults() {
+    this.queryResultCache = {};
+    this.queryResultsCacheSize = 0;
+  }
+  invalidateItemKeys(keys) {
+    logger16.debug("invalidateItemKeys", { keys });
+    keys.forEach((key) => {
+      this.delete(key);
+    });
+  }
+  invalidateLocation(locations) {
+    logger16.debug("invalidateLocation", { locations });
+    if (locations.length === 0) {
+      const allKeys = this.keys();
+      const primaryKeys = allKeys.filter((key) => !isComKey2(key));
+      this.invalidateItemKeys(primaryKeys);
+    } else {
+      const itemsInLocation = this.allIn(locations);
+      const keysToInvalidate = itemsInLocation.map((item) => item.key);
+      this.invalidateItemKeys(keysToInvalidate);
+    }
+    this.clearQueryResults();
+  }
+  /**
+   * Add query result to size tracking
+   */
+  addQueryResultToSizeTracking(queryHash, entry) {
+    const hashSize = estimateValueSize(queryHash);
+    const itemKeysSize = estimateValueSize(entry.itemKeys);
+    const metadataSize = entry.expiresAt ? 8 : 0;
+    const totalSize = hashSize + itemKeysSize + metadataSize;
+    this.queryResultsCacheSize += totalSize;
+    logger16.trace("Added query result to size tracking", {
+      queryHash,
+      estimatedSize: totalSize,
+      totalQueryCacheSize: this.queryResultsCacheSize
+    });
+  }
+  /**
+   * Remove query result from size tracking
+   */
+  removeQueryResultFromSizeTracking(queryHash) {
+    const entry = this.queryResultCache[queryHash];
+    if (entry) {
+      const hashSize = estimateValueSize(queryHash);
+      const itemKeysSize = estimateValueSize(entry.itemKeys);
+      const metadataSize = entry.expiresAt ? 8 : 0;
+      const totalSize = hashSize + itemKeysSize + metadataSize;
+      this.queryResultsCacheSize = Math.max(0, this.queryResultsCacheSize - totalSize);
+      logger16.trace("Removed query result from size tracking", {
+        queryHash,
+        estimatedSize: totalSize,
+        totalQueryCacheSize: this.queryResultsCacheSize
+      });
+    }
+  }
+  /**
+   * Get total cache size including query results
+   */
+  getTotalSizeBytes() {
+    return this.currentSizeBytes + this.queryResultsCacheSize;
+  }
+};
+
+// src/browser/LocalStorageCacheMap.ts
+import {
+  isComKey as isComKey3,
+  isQueryMatch as isQueryMatch3
+} from "@fjell/core";
+var logger17 = logger_default.get("LocalStorageCacheMap");
+var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
+  keyPrefix;
+  normalizedHashFunction;
+  fallbackCache = null;
+  quotaExceeded = false;
+  constructor(types, keyPrefix = "fjell-cache") {
+    super(types);
+    this.keyPrefix = keyPrefix;
+    this.normalizedHashFunction = createNormalizedHashFunction();
+  }
+  getStorageKey(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    return `${this.keyPrefix}:${hashedKey}`;
+  }
+  initializeFallbackCache() {
+    if (!this.fallbackCache) {
+      this.fallbackCache = new MemoryCacheMap(this.types);
+      logger17.warning("LocalStorage quota exceeded, falling back to in-memory cache");
+    }
+  }
+  isQuotaExceededError(error) {
+    return error && (error.name === "QuotaExceededError" || error.name === "NS_ERROR_DOM_QUOTA_REACHED" || error.code === 22 || error.code === 1014);
+  }
+  tryCleanupOldEntries() {
+    try {
+      const allEntries = this.collectCacheEntries();
+      return this.removeOldestEntries(allEntries);
+    } catch (error) {
+      logger17.error("Failed to cleanup old localStorage entries", { error });
+      return false;
+    }
+  }
+  collectCacheEntries() {
+    const allEntries = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (!key || !key.startsWith(this.keyPrefix + ":")) {
+        continue;
+      }
+      try {
+        const stored = localStorage.getItem(key);
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          allEntries.push({ key, timestamp: parsed.timestamp || 0 });
+        }
+      } catch {
+        allEntries.push({ key, timestamp: 0 });
+      }
+    }
+    return allEntries;
+  }
+  removeOldestEntries(allEntries) {
+    allEntries.sort((a, b) => a.timestamp - b.timestamp);
+    const toRemove = Math.ceil(allEntries.length * 0.25);
+    for (let i = 0; i < toRemove; i++) {
+      localStorage.removeItem(allEntries[i].key);
+    }
+    logger17.info(`Cleaned up ${toRemove} old localStorage entries to free space`);
+    return toRemove > 0;
+  }
+  getAllStorageKeys() {
+    const keys = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && key.startsWith(`${this.keyPrefix}:`)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  get(key) {
+    logger17.trace("get", { key });
+    if (this.quotaExceeded && this.fallbackCache) {
+      const memoryResult = this.fallbackCache.get(key);
+      if (memoryResult) {
+        return memoryResult;
+      }
+    }
+    try {
+      const storageKey = this.getStorageKey(key);
+      const stored = localStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key)) {
+          return parsed.value;
+        }
+      }
+      if (!this.quotaExceeded && this.fallbackCache) {
+        return this.fallbackCache.get(key);
+      }
+      return null;
+    } catch (error) {
+      logger17.error("Error retrieving from localStorage", { key, error });
+      if (this.fallbackCache) {
+        return this.fallbackCache.get(key);
+      }
+      return null;
+    }
+  }
+  getWithTTL(key, ttl) {
+    logger17.trace("getWithTTL", { key, ttl });
+    if (ttl === 0) {
+      return null;
+    }
+    try {
+      const storageKey = this.getStorageKey(key);
+      const stored = localStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (this.normalizedHashFunction(parsed.originalKey) !== this.normalizedHashFunction(key)) {
+          return null;
+        }
+        if (typeof parsed.timestamp === "number" && !isNaN(parsed.timestamp)) {
+          const now = Date.now();
+          const age = now - parsed.timestamp;
+          if (age >= ttl) {
+            logger17.trace("Item expired, removing from localStorage", { key, age, ttl });
+            localStorage.removeItem(storageKey);
+            return null;
+          }
+        }
+        return parsed.value;
+      }
+      return null;
+    } catch (error) {
+      logger17.error("Error retrieving with TTL from localStorage", { key, ttl, error });
+      return null;
+    }
+  }
+  set(key, value) {
+    logger17.trace("set", { key, value });
+    if (this.quotaExceeded && this.fallbackCache) {
+      this.fallbackCache.set(key, value);
+      return;
+    }
+    try {
+      const storageKey = this.getStorageKey(key);
+      const toStore = {
+        originalKey: key,
+        value,
+        timestamp: Date.now()
+      };
+      localStorage.setItem(storageKey, JSON.stringify(toStore));
+      if (this.quotaExceeded) {
+        logger17.info("LocalStorage is working again, switching back from fallback cache");
+        this.quotaExceeded = false;
+      }
+    } catch (error) {
+      logger17.error("Error storing to localStorage", { key, value, error });
+      if (this.isQuotaExceededError(error)) {
+        logger17.warning("LocalStorage quota exceeded, attempting cleanup...");
+        const cleanupSucceeded = this.tryCleanupOldEntries();
+        if (cleanupSucceeded) {
+          try {
+            const storageKey = this.getStorageKey(key);
+            const toStore = {
+              originalKey: key,
+              value,
+              timestamp: Date.now()
+            };
+            localStorage.setItem(storageKey, JSON.stringify(toStore));
+            logger17.info("Successfully stored item after cleanup");
+            return;
+          } catch {
+            logger17.warning("Storage failed even after cleanup, falling back to memory cache");
+          }
+        }
+        this.quotaExceeded = true;
+        this.initializeFallbackCache();
+        if (this.fallbackCache) {
+          this.fallbackCache.set(key, value);
+          logger17.info("Item stored in fallback memory cache");
+        }
+      } else {
+        throw new Error(`Failed to store item in localStorage: ${error}`);
+      }
+    }
+  }
+  includesKey(key) {
+    if (this.quotaExceeded && this.fallbackCache) {
+      if (this.fallbackCache.includesKey(key)) {
+        return true;
+      }
+    }
+    try {
+      const storageKey = this.getStorageKey(key);
+      const stored = localStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
+      }
+      if (!this.quotaExceeded && this.fallbackCache) {
+        return this.fallbackCache.includesKey(key);
+      }
+      return false;
+    } catch (error) {
+      logger17.error("Error checking key in localStorage", { key, error });
+      if (this.fallbackCache) {
+        return this.fallbackCache.includesKey(key);
+      }
+      return false;
+    }
+  }
+  delete(key) {
+    logger17.trace("delete", { key });
+    if (this.fallbackCache) {
+      this.fallbackCache.delete(key);
+    }
+    try {
+      const storageKey = this.getStorageKey(key);
+      localStorage.removeItem(storageKey);
+    } catch (error) {
+      logger17.error("Error deleting from localStorage", { key, error });
+    }
+  }
+  allIn(locations) {
+    const allKeys = this.keys();
+    if (locations.length === 0) {
+      logger17.debug("Returning all items, LocKeys is empty");
+      return allKeys.map((key) => this.get(key)).filter((item) => item !== null);
+    } else {
+      const locKeys = locations;
+      logger17.debug("allIn", { locKeys, keys: allKeys.length });
+      return allKeys.filter((key) => key && isComKey3(key)).filter((key) => {
+        const ComKey12 = key;
+        logger17.debug("Comparing Location Keys", {
+          locKeys,
+          ComKey: ComKey12
+        });
+        return isLocKeyArrayEqual(locKeys, ComKey12.loc);
+      }).map((key) => this.get(key));
+    }
+  }
+  contains(query, locations) {
+    logger17.debug("contains", { query, locations });
+    const items = this.allIn(locations);
+    return items.some((item) => isQueryMatch3(item, query));
+  }
+  queryIn(query, locations = []) {
+    logger17.debug("queryIn", { query, locations });
+    const items = this.allIn(locations);
+    return items.filter((item) => isQueryMatch3(item, query));
+  }
+  clone() {
+    return new _LocalStorageCacheMap(this.types, this.keyPrefix);
+  }
+  parseStorageEntry(storageKey) {
+    try {
+      const stored = localStorage.getItem(storageKey);
+      if (stored) {
+        return JSON.parse(stored);
+      }
+    } catch (parseError) {
+      logger17.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
+    }
+    return null;
+  }
+  keys() {
+    const keys = [];
+    try {
+      const storageKeys = this.getAllStorageKeys();
+      for (const storageKey of storageKeys) {
+        const parsed = this.parseStorageEntry(storageKey);
+        if (parsed?.originalKey) {
+          keys.push(parsed.originalKey);
+        }
+      }
+    } catch (error) {
+      logger17.error("Error getting keys from localStorage", { error });
+    }
+    return keys;
+  }
+  values() {
+    const values = [];
+    try {
+      const storageKeys = this.getAllStorageKeys();
+      for (const storageKey of storageKeys) {
+        const parsed = this.parseStorageEntry(storageKey);
+        if (parsed?.value) {
+          values.push(parsed.value);
+        }
+      }
+    } catch (error) {
+      logger17.error("Error getting values from localStorage", { error });
+    }
+    return values;
+  }
+  clear() {
+    logger17.debug("Clearing localStorage cache");
+    try {
+      const storageKeys = this.getAllStorageKeys();
+      for (const storageKey of storageKeys) {
+        if (!storageKey.includes(":query:")) {
+          localStorage.removeItem(storageKey);
+        }
+      }
+    } catch (error) {
+      logger17.error("Error clearing localStorage cache", { error });
+    }
+  }
+  // Query result caching methods implementation
+  setQueryResult(queryHash, itemKeys, ttl) {
+    logger17.trace("setQueryResult", { queryHash, itemKeys, ttl });
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    const entry = {
+      itemKeys
+    };
+    if (ttl) {
+      entry.expiresAt = Date.now() + ttl;
+    }
+    try {
+      localStorage.setItem(queryKey, JSON.stringify(entry));
+    } catch (error) {
+      logger17.error("Failed to store query result in localStorage", { queryHash, error });
+    }
+  }
+  getQueryResult(queryHash) {
+    logger17.trace("getQueryResult", { queryHash });
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    try {
+      const data = localStorage.getItem(queryKey);
+      if (!data) {
+        return null;
+      }
+      const entry = JSON.parse(data);
+      if (Array.isArray(entry)) {
+        return entry;
+      }
+      if (entry.expiresAt && Date.now() > entry.expiresAt) {
+        logger17.trace("Query result expired, removing", { queryHash, expiresAt: entry.expiresAt });
+        localStorage.removeItem(queryKey);
+        return null;
+      }
+      return entry.itemKeys || null;
+    } catch (error) {
+      logger17.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      return null;
+    }
+  }
+  hasQueryResult(queryHash) {
+    return this.getQueryResult(queryHash) !== null;
+  }
+  deleteQueryResult(queryHash) {
+    logger17.trace("deleteQueryResult", { queryHash });
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    try {
+      localStorage.removeItem(queryKey);
+    } catch (error) {
+      logger17.error("Failed to delete query result from localStorage", { queryHash, error });
+    }
+  }
+  invalidateItemKeys(keys) {
+    logger17.debug("invalidateItemKeys", { keys });
+    keys.forEach((key) => {
+      this.delete(key);
+    });
+  }
+  invalidateLocation(locations) {
+    logger17.debug("invalidateLocation", { locations });
+    if (locations.length === 0) {
+      const allKeys = this.keys();
+      const primaryKeys = allKeys.filter((key) => !isComKey3(key));
+      this.invalidateItemKeys(primaryKeys);
+    } else {
+      const itemsInLocation = this.allIn(locations);
+      const keysToInvalidate = itemsInLocation.map((item) => item.key);
+      this.invalidateItemKeys(keysToInvalidate);
+    }
+    this.clearQueryResults();
+  }
+  clearQueryResults() {
+    logger17.trace("clearQueryResults");
+    const queryPrefix = `${this.keyPrefix}:query:`;
+    try {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(queryPrefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => localStorage.removeItem(key));
+    } catch (error) {
+      logger17.error("Failed to clear query results from localStorage", { error });
+    }
+  }
+};
+
+// src/browser/SessionStorageCacheMap.ts
+import {
+  isComKey as isComKey4,
+  isQueryMatch as isQueryMatch4
+} from "@fjell/core";
+var logger18 = logger_default.get("SessionStorageCacheMap");
+var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
+  keyPrefix;
+  normalizedHashFunction;
+  constructor(types, keyPrefix = "fjell-session-cache") {
+    super(types);
+    this.keyPrefix = keyPrefix;
+    this.normalizedHashFunction = createNormalizedHashFunction();
+  }
+  getStorageKey(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    return `${this.keyPrefix}:${hashedKey}`;
+  }
+  getAllStorageKeys() {
+    const keys = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key && key.startsWith(`${this.keyPrefix}:`)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  get(key) {
+    logger18.trace("get", { key });
+    try {
+      const storageKey = this.getStorageKey(key);
+      const stored = sessionStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key)) {
+          return parsed.value;
+        }
+      }
+      return null;
+    } catch (error) {
+      logger18.error("Error retrieving from sessionStorage", { key, error });
+      return null;
+    }
+  }
+  getWithTTL(key, ttl) {
+    logger18.trace("getWithTTL", { key, ttl });
+    if (ttl === 0) {
+      return null;
+    }
+    try {
+      const storageKey = this.getStorageKey(key);
+      const stored = sessionStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (this.normalizedHashFunction(parsed.originalKey) !== this.normalizedHashFunction(key)) {
+          return null;
+        }
+        if (typeof parsed.timestamp === "number" && !isNaN(parsed.timestamp)) {
+          const now = Date.now();
+          const age = now - parsed.timestamp;
+          if (age >= ttl) {
+            logger18.trace("Item expired, removing from sessionStorage", { key, age, ttl });
+            sessionStorage.removeItem(storageKey);
+            return null;
+          }
+        } else {
+          logger18.trace("Item has no valid timestamp, treating as expired", { key });
+          sessionStorage.removeItem(storageKey);
+          return null;
+        }
+        return parsed.value;
+      }
+      return null;
+    } catch (error) {
+      logger18.error("Error retrieving with TTL from sessionStorage", { key, ttl, error });
+      return null;
+    }
+  }
+  set(key, value) {
+    logger18.trace("set", { key, value });
+    try {
+      const storageKey = this.getStorageKey(key);
+      const toStore = {
+        originalKey: key,
+        value,
+        timestamp: Date.now()
+      };
+      sessionStorage.setItem(storageKey, JSON.stringify(toStore));
+    } catch (error) {
+      logger18.error("Error storing to sessionStorage", { key, value, error });
+      throw new Error(`Failed to store item in sessionStorage: ${error}`);
+    }
+  }
+  includesKey(key) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      const stored = sessionStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
+      }
+      return false;
+    } catch (error) {
+      logger18.error("Error checking key in sessionStorage", { key, error });
+      return false;
+    }
+  }
+  delete(key) {
+    logger18.trace("delete", { key });
+    try {
+      const storageKey = this.getStorageKey(key);
+      sessionStorage.removeItem(storageKey);
+    } catch (error) {
+      logger18.error("Error deleting from sessionStorage", { key, error });
+    }
+  }
+  allIn(locations) {
+    const allKeys = this.keys();
+    if (locations.length === 0) {
+      logger18.debug("Returning all items, LocKeys is empty");
+      return allKeys.map((key) => this.get(key)).filter((item) => item !== null);
+    } else {
+      const locKeys = locations;
+      logger18.debug("allIn", { locKeys, keys: allKeys.length });
+      return allKeys.filter((key) => key && isComKey4(key)).filter((key) => {
+        const ComKey12 = key;
+        logger18.debug("Comparing Location Keys", {
+          locKeys,
+          ComKey: ComKey12
+        });
+        return isLocKeyArrayEqual(locKeys, ComKey12.loc);
+      }).map((key) => this.get(key));
+    }
+  }
+  contains(query, locations) {
+    logger18.debug("contains", { query, locations });
+    const items = this.allIn(locations);
+    return items.some((item) => isQueryMatch4(item, query));
+  }
+  queryIn(query, locations = []) {
+    logger18.debug("queryIn", { query, locations });
+    const items = this.allIn(locations);
+    return items.filter((item) => isQueryMatch4(item, query));
+  }
+  clone() {
+    return new _SessionStorageCacheMap(this.types, this.keyPrefix);
+  }
+  keys() {
+    const keys = [];
+    try {
+      const storageKeys = this.getAllStorageKeys();
+      for (const storageKey of storageKeys) {
+        const stored = sessionStorage.getItem(storageKey);
+        if (!stored) continue;
+        try {
+          const parsed = JSON.parse(stored);
+          if (parsed.originalKey) {
+            keys.push(parsed.originalKey);
+          }
+        } catch (itemError) {
+          logger18.trace("Skipping invalid storage item", { storageKey, error: itemError });
+        }
+      }
+    } catch (error) {
+      logger18.error("Error getting keys from sessionStorage", { error });
+    }
+    return keys;
+  }
+  values() {
+    const values = [];
+    try {
+      const storageKeys = this.getAllStorageKeys();
+      for (const storageKey of storageKeys) {
+        const stored = sessionStorage.getItem(storageKey);
+        if (!stored) continue;
+        try {
+          const parsed = JSON.parse(stored);
+          if (parsed.value != null) {
+            values.push(parsed.value);
+          }
+        } catch (itemError) {
+          logger18.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
+        }
+      }
+    } catch (error) {
+      logger18.error("Error getting values from sessionStorage", { error });
+    }
+    return values;
+  }
+  clear() {
+    logger18.debug("Clearing sessionStorage cache");
+    try {
+      const storageKeys = this.getAllStorageKeys();
+      for (const storageKey of storageKeys) {
+        sessionStorage.removeItem(storageKey);
+      }
+    } catch (error) {
+      logger18.error("Error clearing sessionStorage cache", { error });
+    }
+  }
+  // Query result caching methods implementation
+  setQueryResult(queryHash, itemKeys, ttl) {
+    logger18.trace("setQueryResult", { queryHash, itemKeys, ttl });
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    const entry = {
+      itemKeys
+    };
+    if (ttl) {
+      entry.expiresAt = Date.now() + ttl;
+    }
+    try {
+      sessionStorage.setItem(queryKey, JSON.stringify(entry));
+    } catch (error) {
+      logger18.error("Failed to store query result in sessionStorage", { queryHash, error });
+    }
+  }
+  getQueryResult(queryHash) {
+    logger18.trace("getQueryResult", { queryHash });
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    try {
+      const data = sessionStorage.getItem(queryKey);
+      if (!data) {
+        return null;
+      }
+      const entry = JSON.parse(data);
+      if (Array.isArray(entry)) {
+        return entry;
+      }
+      if (entry.expiresAt && Date.now() > entry.expiresAt) {
+        logger18.trace("Query result expired, removing", { queryHash, expiresAt: entry.expiresAt });
+        sessionStorage.removeItem(queryKey);
+        return null;
+      }
+      return entry.itemKeys || null;
+    } catch (error) {
+      logger18.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      return null;
+    }
+  }
+  hasQueryResult(queryHash) {
+    return this.getQueryResult(queryHash) !== null;
+  }
+  deleteQueryResult(queryHash) {
+    logger18.trace("deleteQueryResult", { queryHash });
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    try {
+      sessionStorage.removeItem(queryKey);
+    } catch (error) {
+      logger18.error("Failed to delete query result from sessionStorage", { queryHash, error });
+    }
+  }
+  invalidateItemKeys(keys) {
+    logger18.debug("invalidateItemKeys", { keys });
+    keys.forEach((key) => {
+      this.delete(key);
+    });
+  }
+  invalidateLocation(locations) {
+    logger18.debug("invalidateLocation", { locations });
+    if (locations.length === 0) {
+      const allKeys = this.keys();
+      const primaryKeys = allKeys.filter((key) => !isComKey4(key));
+      this.invalidateItemKeys(primaryKeys);
+    } else {
+      const itemsInLocation = this.allIn(locations);
+      const keysToInvalidate = itemsInLocation.map((item) => item.key);
+      this.invalidateItemKeys(keysToInvalidate);
+    }
+    this.clearQueryResults();
+  }
+  clearQueryResults() {
+    logger18.trace("clearQueryResults");
+    const queryPrefix = `${this.keyPrefix}:query:`;
+    try {
+      const keysToRemove = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key && key.startsWith(queryPrefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => sessionStorage.removeItem(key));
+    } catch (error) {
+      logger18.error("Failed to clear query results from sessionStorage", { error });
+    }
+  }
+};
+
+// src/browser/AsyncIndexDBCacheMap.ts
+import {
+  isComKey as isComKey5,
+  isQueryMatch as isQueryMatch5
+} from "@fjell/core";
+var logger19 = logger_default.get("AsyncIndexDBCacheMap");
+var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
+  types;
+  dbName;
+  storeName;
+  version;
+  normalizedHashFunction;
+  dbPromise = null;
+  constructor(types, dbName = "fjell-indexdb-cache", storeName = "cache", version = 1) {
+    this.types = types;
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.version = version;
+    this.normalizedHashFunction = createNormalizedHashFunction();
+  }
+  async getDB() {
+    if (!this.dbPromise) {
+      this.dbPromise = new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, this.version);
+        request.onerror = () => {
+          logger19.error("Error opening IndexedDB", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          logger19.debug("IndexedDB opened successfully");
+          resolve(request.result);
+        };
+        request.onupgradeneeded = (event) => {
+          logger19.debug("IndexedDB upgrade needed");
+          const db = event.target.result;
+          if (!db.objectStoreNames.contains(this.storeName)) {
+            db.createObjectStore(this.storeName);
+            logger19.debug("Created object store", { storeName: this.storeName });
+          }
+        };
+      });
+    }
+    return this.dbPromise;
+  }
+  getStorageKey(key) {
+    return this.normalizedHashFunction(key);
+  }
+  async get(key) {
+    logger19.trace("get", { key });
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const storageKey = this.getStorageKey(key);
+      return new Promise((resolve, reject) => {
+        const request = store.get(storageKey);
+        request.onerror = () => {
+          logger19.error("Error getting from IndexedDB", { key, error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const stored = request.result;
+          if (stored && this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key)) {
+            resolve(stored.value);
+          } else {
+            resolve(null);
+          }
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB get operation", { key, error });
+      return null;
+    }
+  }
+  async set(key, value) {
+    logger19.trace("set", { key, value });
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const storageKey = this.getStorageKey(key);
+      const storedItem = {
+        originalKey: key,
+        value
+      };
+      return new Promise((resolve, reject) => {
+        const request = store.put(storedItem, storageKey);
+        request.onerror = () => {
+          logger19.error("Error setting in IndexedDB", { key, value, error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          resolve();
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB set operation", { key, value, error });
+      throw new Error(`Failed to store item in IndexedDB: ${error}`);
+    }
+  }
+  async includesKey(key) {
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const storageKey = this.getStorageKey(key);
+      return new Promise((resolve, reject) => {
+        const request = store.get(storageKey);
+        request.onerror = () => {
+          logger19.error("Error checking key in IndexedDB", { key, error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const stored = request.result;
+          if (stored) {
+            const matches = this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key);
+            resolve(matches);
+          } else {
+            resolve(false);
+          }
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB includesKey operation", { key, error });
+      return false;
+    }
+  }
+  async delete(key) {
+    logger19.trace("delete", { key });
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const storageKey = this.getStorageKey(key);
+      return new Promise((resolve, reject) => {
+        const request = store.delete(storageKey);
+        request.onerror = () => {
+          logger19.error("Error deleting from IndexedDB", { key, error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          resolve();
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB delete operation", { key, error });
+    }
+  }
+  async allIn(locations) {
+    const allKeys = await this.keys();
+    if (locations.length === 0) {
+      logger19.debug("Returning all items, LocKeys is empty");
+      const promises = allKeys.map((key) => this.get(key));
+      const results = await Promise.all(promises);
+      return results.filter((item) => item !== null);
+    } else {
+      const locKeys = locations;
+      logger19.debug("allIn", { locKeys, keys: allKeys.length });
+      const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
+        const ComKey12 = key;
+        logger19.debug("Comparing Location Keys", {
+          locKeys,
+          ComKey: ComKey12
+        });
+        return isLocKeyArrayEqual(locKeys, ComKey12.loc);
+      });
+      const promises = filteredKeys.map((key) => this.get(key));
+      const results = await Promise.all(promises);
+      return results.filter((item) => item !== null);
+    }
+  }
+  async contains(query, locations) {
+    logger19.debug("contains", { query, locations });
+    const items = await this.allIn(locations);
+    return items.some((item) => isQueryMatch5(item, query));
+  }
+  async queryIn(query, locations = []) {
+    logger19.debug("queryIn", { query, locations });
+    const items = await this.allIn(locations);
+    return items.filter((item) => isQueryMatch5(item, query));
+  }
+  clone() {
+    return new _AsyncIndexDBCacheMap(this.types, this.dbName, this.storeName, this.version);
+  }
+  async keys() {
+    const keys = [];
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      return new Promise((resolve, reject) => {
+        const request = store.openCursor();
+        request.onerror = () => {
+          logger19.error("Error getting keys from IndexedDB", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            const stored = cursor.value;
+            keys.push(stored.originalKey);
+            cursor.continue();
+          } else {
+            resolve(keys);
+          }
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB keys operation", { error });
+      return [];
+    }
+  }
+  async values() {
+    const values = [];
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      return new Promise((resolve, reject) => {
+        const request = store.openCursor();
+        request.onerror = () => {
+          logger19.error("Error getting values from IndexedDB", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            const stored = cursor.value;
+            values.push(stored.value);
+            cursor.continue();
+          } else {
+            resolve(values);
+          }
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB values operation", { error });
+      return [];
+    }
+  }
+  async clear() {
+    logger19.debug("Clearing IndexedDB cache");
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      return new Promise((resolve, reject) => {
+        const request = store.clear();
+        request.onerror = () => {
+          logger19.error("Error clearing IndexedDB cache", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          resolve();
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB clear operation", { error });
+    }
+  }
+  // Async Query result caching methods
+  async setQueryResult(queryHash, itemKeys, ttl) {
+    logger19.trace("setQueryResult", { queryHash, itemKeys, ttl });
+    try {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, this.version);
+        request.onerror = () => {
+          logger19.error("Failed to open database for setQueryResult", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const db = request.result;
+          const transaction = db.transaction([this.storeName], "readwrite");
+          const store = transaction.objectStore(this.storeName);
+          const entry = {
+            itemKeys,
+            expiresAt: ttl ? Date.now() + ttl : null
+          };
+          const queryKey = `query:${queryHash}`;
+          const putRequest = store.put(JSON.stringify(entry), queryKey);
+          putRequest.onerror = () => {
+            logger19.error("Failed to store query result", { queryHash, error: putRequest.error });
+            reject(putRequest.error);
+          };
+          putRequest.onsuccess = () => {
+            resolve();
+          };
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in setQueryResult", { queryHash, error });
+      throw error;
+    }
+  }
+  async getQueryResult(queryHash) {
+    logger19.trace("getQueryResult", { queryHash });
+    try {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, this.version);
+        request.onerror = () => {
+          logger19.error("Failed to open database for getQueryResult", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const db = request.result;
+          const transaction = db.transaction([this.storeName], "readonly");
+          const store = transaction.objectStore(this.storeName);
+          const queryKey = `query:${queryHash}`;
+          const getRequest = store.get(queryKey);
+          getRequest.onerror = () => {
+            logger19.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
+            reject(getRequest.error);
+          };
+          getRequest.onsuccess = () => {
+            try {
+              const result = getRequest.result;
+              if (!result) {
+                resolve(null);
+                return;
+              }
+              const entry = JSON.parse(result);
+              if (Array.isArray(entry)) {
+                resolve(entry);
+                return;
+              }
+              if (entry.expiresAt && Date.now() > entry.expiresAt) {
+                logger19.trace("Query result expired, removing", { queryHash, expiresAt: entry.expiresAt });
+                const deleteTransaction = db.transaction([this.storeName], "readwrite");
+                const deleteStore = deleteTransaction.objectStore(this.storeName);
+                deleteStore.delete(queryKey);
+                resolve(null);
+                return;
+              }
+              resolve(entry.itemKeys || null);
+            } catch (parseError) {
+              logger19.error("Failed to parse query result", { queryHash, error: parseError });
+              resolve(null);
+            }
+          };
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in getQueryResult", { queryHash, error });
+      return null;
+    }
+  }
+  async hasQueryResult(queryHash) {
+    logger19.trace("hasQueryResult", { queryHash });
+    try {
+      const result = await this.getQueryResult(queryHash);
+      return result !== null;
+    } catch (error) {
+      logger19.error("Error in hasQueryResult", { queryHash, error });
+      return false;
+    }
+  }
+  async deleteQueryResult(queryHash) {
+    logger19.trace("deleteQueryResult", { queryHash });
+    try {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, this.version);
+        request.onerror = () => {
+          logger19.error("Failed to open database for deleteQueryResult", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const db = request.result;
+          const transaction = db.transaction([this.storeName], "readwrite");
+          const store = transaction.objectStore(this.storeName);
+          const queryKey = `query:${queryHash}`;
+          const deleteRequest = store.delete(queryKey);
+          deleteRequest.onerror = () => {
+            logger19.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
+            reject(deleteRequest.error);
+          };
+          deleteRequest.onsuccess = () => {
+            resolve();
+          };
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in deleteQueryResult", { queryHash, error });
+      throw error;
+    }
+  }
+  async invalidateItemKeys(keys) {
+    logger19.debug("invalidateItemKeys", { keys });
+    for (const key of keys) {
+      await this.delete(key);
+    }
+  }
+  async invalidateLocation(locations) {
+    logger19.debug("invalidateLocation", { locations });
+    if (locations.length === 0) {
+      await this.clearQueryResults();
+    } else {
+      const itemsInLocation = await this.allIn(locations);
+      const keysToInvalidate = itemsInLocation.map((item) => item.key);
+      await this.invalidateItemKeys(keysToInvalidate);
+    }
+    await this.clearQueryResults();
+  }
+  async clearQueryResults() {
+    logger19.trace("clearQueryResults");
+    try {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, this.version);
+        request.onerror = () => {
+          logger19.error("Failed to open database for clearQueryResults", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const db = request.result;
+          const transaction = db.transaction([this.storeName], "readwrite");
+          const store = transaction.objectStore(this.storeName);
+          const cursorRequest = store.openCursor();
+          const keysToDelete = [];
+          cursorRequest.onerror = () => {
+            logger19.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
+            reject(cursorRequest.error);
+          };
+          cursorRequest.onsuccess = () => {
+            const cursor = cursorRequest.result;
+            if (cursor) {
+              const key = cursor.key;
+              if (typeof key === "string" && key.startsWith("query:")) {
+                keysToDelete.push(key);
+              }
+              cursor.continue();
+            } else {
+              if (keysToDelete.length === 0) {
+                resolve();
+                return;
+              }
+              let deletedCount = 0;
+              const totalToDelete = keysToDelete.length;
+              keysToDelete.forEach((queryKey) => {
+                const deleteRequest = store.delete(queryKey);
+                deleteRequest.onerror = () => {
+                  logger19.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
+                  deletedCount++;
+                  if (deletedCount === totalToDelete) {
+                    resolve();
+                  }
+                };
+                deleteRequest.onsuccess = () => {
+                  deletedCount++;
+                  if (deletedCount === totalToDelete) {
+                    resolve();
+                  }
+                };
+              });
+            }
+          };
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in clearQueryResults", { error });
+      throw error;
+    }
+  }
+};
+
+// src/browser/IndexDBCacheMap.ts
+var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
+  asyncCache;
+  memoryCache;
+  syncInterval = null;
+  SYNC_INTERVAL_MS = 5e3;
+  // Sync every 5 seconds
+  pendingSyncOperations = /* @__PURE__ */ new Map();
+  initializationPromise = null;
+  isInitialized = false;
+  MAX_RETRY_ATTEMPTS = 3;
+  constructor(types, dbName = "fjell-indexdb-cache", storeName = "cache", version = 1) {
+    super(types);
+    this.asyncCache = new AsyncIndexDBCacheMap(types, dbName, storeName, version);
+    this.memoryCache = new MemoryCacheMap(types);
+    this.initializeFromIndexedDB();
+    this.startPeriodicSync();
+  }
+  async initializeFromIndexedDB() {
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+    this.initializationPromise = (async () => {
+      try {
+        const keys = await this.asyncCache.keys();
+        for (const key of keys) {
+          if (!this.memoryCache.includesKey(key)) {
+            const value = await this.asyncCache.get(key);
+            if (value) {
+              this.memoryCache.set(key, value);
+            }
+          }
+        }
+        this.isInitialized = true;
+      } catch (error) {
+        console.warn("Failed to initialize from IndexedDB:", error);
+        this.isInitialized = true;
+      }
+    })();
+    return this.initializationPromise;
+  }
+  startPeriodicSync() {
+    this.syncInterval = setInterval(() => {
+      this.syncToIndexedDB();
+    }, this.SYNC_INTERVAL_MS);
+  }
+  async syncToIndexedDB() {
+    try {
+      await this.processPendingOperations();
+      const memoryKeys = this.memoryCache.keys();
+      for (const key of memoryKeys) {
+        const value = this.memoryCache.get(key);
+        if (value) {
+          await this.asyncCache.set(key, value);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to sync to IndexedDB:", error);
+    }
+  }
+  async processPendingOperations() {
+    const pendingOps = Array.from(this.pendingSyncOperations.entries());
+    for (const [keyStr, operation] of pendingOps) {
+      try {
+        if (operation.type === "set" && operation.value) {
+          await this.asyncCache.set(operation.key, operation.value);
+        } else if (operation.type === "delete") {
+          await this.asyncCache.delete(operation.key);
+        }
+        this.pendingSyncOperations.delete(keyStr);
+      } catch (error) {
+        console.warn(`Failed to process pending ${operation.type} operation:`, error);
+      }
+    }
+  }
+  queueForSync(key, value) {
+    const keyStr = JSON.stringify(key);
+    this.pendingSyncOperations.set(keyStr, { type: "set", key, value });
+    setTimeout(async () => {
+      try {
+        await this.asyncCache.set(key, value);
+        const pending = this.pendingSyncOperations.get(keyStr);
+        if (pending && pending.type === "set" && pending.value === value) {
+          this.pendingSyncOperations.delete(keyStr);
+        }
+      } catch (error) {
+        console.warn("Failed to sync single operation to IndexedDB:", error);
+      }
+    }, 0);
+  }
+  queueDeleteForSync(key) {
+    const keyStr = JSON.stringify(key);
+    this.pendingSyncOperations.set(keyStr, { type: "delete", key });
+    setTimeout(async () => {
+      try {
+        await this.asyncCache.delete(key);
+        const pending = this.pendingSyncOperations.get(keyStr);
+        if (pending && pending.type === "delete") {
+          this.pendingSyncOperations.delete(keyStr);
+        }
+      } catch (error) {
+        console.warn("Failed to sync delete operation to IndexedDB:", error);
+      }
+    }, 0);
+  }
+  queueClearForSync() {
+    this.pendingSyncOperations.clear();
+    setTimeout(async () => {
+      try {
+        await this.asyncCache.clear();
+      } catch (error) {
+        console.warn("Failed to sync clear operation to IndexedDB:", error);
+      }
+    }, 0);
+  }
+  get(key) {
+    if (!this.isInitialized && this.initializationPromise) {
+    }
+    return this.memoryCache.get(key);
+  }
+  getWithTTL(key, ttl) {
+    return this.memoryCache.getWithTTL(key, ttl);
+  }
+  set(key, value) {
+    this.memoryCache.set(key, value);
+    this.queueForSync(key, value);
+  }
+  includesKey(key) {
+    return this.memoryCache.includesKey(key);
+  }
+  delete(key) {
+    this.memoryCache.delete(key);
+    this.queueDeleteForSync(key);
+  }
+  allIn(locations) {
+    return this.memoryCache.allIn(locations);
+  }
+  contains(query, locations) {
+    return this.memoryCache.contains(query, locations);
+  }
+  queryIn(query, locations) {
+    return this.memoryCache.queryIn(query, locations);
+  }
+  clone() {
+    return new _IndexDBCacheMap(this.types);
+  }
+  keys() {
+    return this.memoryCache.keys();
+  }
+  values() {
+    return this.memoryCache.values();
+  }
+  clear() {
+    this.memoryCache.clear();
+    this.queueClearForSync();
+  }
+  // Query result caching methods implementation
+  setQueryResult(queryHash, itemKeys, ttl) {
+    return this.memoryCache.setQueryResult(queryHash, itemKeys, ttl);
+  }
+  getQueryResult(queryHash) {
+    return this.memoryCache.getQueryResult(queryHash);
+  }
+  hasQueryResult(queryHash) {
+    return this.memoryCache.hasQueryResult(queryHash);
+  }
+  deleteQueryResult(queryHash) {
+    return this.memoryCache.deleteQueryResult(queryHash);
+  }
+  invalidateItemKeys(keys) {
+    return this.memoryCache.invalidateItemKeys(keys);
+  }
+  invalidateLocation(locations) {
+    return this.memoryCache.invalidateLocation(locations);
+  }
+  clearQueryResults() {
+    return this.memoryCache.clearQueryResults();
+  }
+  /**
+   * Clean up resources when the cache is no longer needed
+   */
+  destroy() {
+    if (this.syncInterval) {
+      clearInterval(this.syncInterval);
+      this.syncInterval = null;
+    }
+  }
+};
+
+// src/Options.ts
+var DEFAULT_CACHE_OPTIONS = {
+  cacheType: "memory",
+  enableDebugLogging: false,
+  autoSync: true,
+  maxRetries: 3,
+  retryDelay: 1e3,
+  indexedDBConfig: {
+    dbName: "fjell-cache",
+    version: 1,
+    storeName: "cache",
+    size: {
+      evictionPolicy: "lru"
+    }
+  },
+  webStorageConfig: {
+    keyPrefix: "fjell-cache:",
+    compress: false,
+    size: {
+      evictionPolicy: "lru"
+    }
+  },
+  memoryConfig: {
+    // No limits by default
+    size: {
+      evictionPolicy: "lru"
+    }
+  }
+};
+var createOptions = (cacheOptions) => {
+  const indexedDBConfig = cacheOptions?.indexedDBConfig ? {
+    ...DEFAULT_CACHE_OPTIONS.indexedDBConfig,
+    ...cacheOptions.indexedDBConfig,
+    size: cacheOptions.indexedDBConfig.size ? {
+      ...DEFAULT_CACHE_OPTIONS.indexedDBConfig?.size,
+      ...cacheOptions.indexedDBConfig.size
+    } : DEFAULT_CACHE_OPTIONS.indexedDBConfig?.size
+  } : { ...DEFAULT_CACHE_OPTIONS.indexedDBConfig };
+  const webStorageConfig = cacheOptions?.webStorageConfig ? {
+    ...DEFAULT_CACHE_OPTIONS.webStorageConfig,
+    ...cacheOptions.webStorageConfig,
+    size: cacheOptions.webStorageConfig.size ? {
+      ...DEFAULT_CACHE_OPTIONS.webStorageConfig?.size,
+      ...cacheOptions.webStorageConfig.size
+    } : DEFAULT_CACHE_OPTIONS.webStorageConfig?.size
+  } : { ...DEFAULT_CACHE_OPTIONS.webStorageConfig };
+  const memoryConfig = cacheOptions?.memoryConfig ? {
+    ...DEFAULT_CACHE_OPTIONS.memoryConfig,
+    ...cacheOptions.memoryConfig,
+    size: cacheOptions.memoryConfig.size ? {
+      ...DEFAULT_CACHE_OPTIONS.memoryConfig?.size,
+      ...cacheOptions.memoryConfig.size
+    } : DEFAULT_CACHE_OPTIONS.memoryConfig?.size
+  } : { ...DEFAULT_CACHE_OPTIONS.memoryConfig };
+  return {
+    ...DEFAULT_CACHE_OPTIONS,
+    ...cacheOptions,
+    indexedDBConfig,
+    webStorageConfig,
+    memoryConfig
+  };
+};
+var createCacheMap = (kta, options) => {
+  switch (options.cacheType) {
+    case "memory":
+      if (options.memoryConfig?.size && (options.memoryConfig.size.maxSizeBytes || options.memoryConfig.size.maxItems)) {
+        return new EnhancedMemoryCacheMap(
+          kta,
+          options.memoryConfig.size
+        );
+      }
+      return new MemoryCacheMap(kta);
+    case "localStorage":
+      return new LocalStorageCacheMap(
+        kta,
+        options.webStorageConfig?.keyPrefix
+      );
+    case "sessionStorage":
+      return new SessionStorageCacheMap(
+        kta,
+        options.webStorageConfig?.keyPrefix
+      );
+    case "indexedDB":
+      return new IndexDBCacheMap(
+        kta,
+        options.indexedDBConfig?.dbName,
+        options.indexedDBConfig?.storeName,
+        options.indexedDBConfig?.version
+      );
+    case "custom":
+      if (!options.customCacheMapFactory) {
+        throw new Error('Custom cache map factory is required when cacheType is "custom"');
+      }
+      return options.customCacheMapFactory(kta);
+    default:
+      throw new Error(`Unsupported cache type: ${options.cacheType}`);
+  }
+};
+var validateOptions = (options) => {
+  if (options.cacheType === "custom" && !options.customCacheMapFactory) {
+    throw new Error('customCacheMapFactory is required when cacheType is "custom"');
+  }
+  if (typeof options.maxRetries === "number" && options.maxRetries < 0) {
+    throw new Error("maxRetries must be non-negative");
+  }
+  if (typeof options.retryDelay === "number" && options.retryDelay < 0) {
+    throw new Error("retryDelay must be non-negative");
+  }
+  if (typeof options.ttl === "number" && options.ttl <= 0) {
+    throw new Error("ttl must be positive");
+  }
+  if (typeof options.memoryConfig?.maxItems === "number" && options.memoryConfig.maxItems <= 0) {
+    throw new Error("memoryConfig.maxItems must be positive");
+  }
+  if (typeof options.memoryConfig?.ttl === "number" && options.memoryConfig.ttl <= 0) {
+    throw new Error("memoryConfig.ttl must be positive");
+  }
+  if (options.memoryConfig?.size) {
+    validateSizeConfig(options.memoryConfig.size);
+  }
+  if (options.webStorageConfig?.size) {
+    validateSizeConfig(options.webStorageConfig.size);
+  }
+  if (options.indexedDBConfig?.size) {
+    validateSizeConfig(options.indexedDBConfig.size);
+  }
+  if (["localStorage", "sessionStorage"].includes(options.cacheType)) {
+    if (typeof window === "undefined" || !window[options.cacheType]) {
+      throw new Error(`${options.cacheType} is not available in non-browser environments`);
+    }
+  }
+  if (options.cacheType === "indexedDB") {
+    if (typeof window === "undefined" || !window.indexedDB) {
+      throw new Error(`${options.cacheType} is not available in this environment`);
+    }
+  }
+  if (options.cacheType === "asyncIndexedDB") {
+    throw new Error("asyncIndexedDB cannot be used with synchronous cache factory. Use AsyncIndexDBCacheMap directly for async operations.");
+  }
+};
+
+// src/ops/reset.ts
+var reset = async (coordinate, options) => {
+  const cacheMap = createCacheMap(coordinate.kta, options);
+  return [cacheMap];
+};
+
+// src/Operations.ts
+var createOperations = (api, coordinate, cacheMap, pkType, options) => {
+  const context = createCacheContext(api, cacheMap, pkType, options);
+  return {
+    all: (query, locations) => all(query, locations, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    one: (query, locations) => one(query, locations, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    create: (item, locations) => create(item, locations, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    get: (key) => get(key, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    retrieve: (key) => retrieve(key, context).then(([ctx, result]) => [ctx ? ctx.cacheMap : null, result]),
+    remove: (key) => remove(key, context).then((ctx) => ctx.cacheMap),
+    update: (key, item) => update(key, item, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    action: (key, actionName, body) => action(key, actionName, body, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    allAction: (actionName, body, locations) => allAction(actionName, body, locations, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    facet: (key, facetName, params) => facet(key, facetName, params, context).then((result) => [context.cacheMap, result]),
+    allFacet: (facetName, params, locations) => allFacet(facetName, params, locations, context).then((result) => [context.cacheMap, result]),
+    find: (finder, params, locations) => find(finder, params, locations, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    findOne: (finder, params, locations) => findOne(finder, params, locations, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    set: (key, item) => set(key, item, context).then(([ctx, result]) => [ctx.cacheMap, result]),
+    reset: () => reset(coordinate, options)
+  };
+};
+
+// src/Cache.ts
+var logger20 = logger_default.get("Cache");
+var createCache = (api, coordinate, registry, options) => {
+  logger20.debug("createCache", { coordinate, registry, options });
+  const completeOptions = createOptions(options);
+  const cacheMap = createCacheMap(coordinate.kta, completeOptions);
+  const pkType = coordinate.kta[0];
+  const operations = createOperations(api, coordinate, cacheMap, pkType, completeOptions);
+  return {
+    coordinate,
+    registry,
+    api,
+    cacheMap,
+    operations,
+    options: completeOptions
+  };
+};
+var isCache = (cache) => {
+  return cache !== null && typeof cache === "object" && "coordinate" in cache && "registry" in cache && "api" in cache && "cacheMap" in cache && "operations" in cache;
+};
+
+// src/InstanceFactory.ts
+var logger21 = logger_default.get("InstanceFactory");
+var createInstanceFactory = (api, options) => {
+  const templateOptions = createOptions(options);
+  validateOptions(templateOptions);
+  return (coordinate, context) => {
+    const instanceOptions = createOptions(options);
+    logger21.debug("Creating cache instance", {
+      coordinate,
+      registry: context.registry,
+      api,
+      cacheType: instanceOptions.cacheType,
+      options: instanceOptions
+    });
+    const cacheMap = createCacheMap(coordinate.kta, instanceOptions);
+    const pkType = coordinate.kta[0];
+    const operations = createOperations(api, coordinate, cacheMap, pkType, instanceOptions);
+    return {
+      coordinate,
+      registry: context.registry,
+      api,
+      cacheMap,
+      operations,
+      options: instanceOptions
+    };
+  };
+};
+
+// src/Instance.ts
+var logger22 = logger_default.get("Instance");
+var createInstance = (registry, coordinate, api, options) => {
+  logger22.debug("createInstance", { coordinate, api, registry, options });
+  return createCache(api, coordinate, registry, options);
+};
+var isInstance = (instance) => {
+  return instance !== null && typeof instance === "object" && "coordinate" in instance && "registry" in instance && "api" in instance && "cacheMap" in instance && "operations" in instance;
+};
+
+// src/Aggregator.ts
+var logger23 = logger_default.get("ItemAggregator");
+var toCacheConfig = (config) => {
+  let cacheConfig;
+  if (config.optional === void 0) {
+    cacheConfig = { cache: config, optional: false };
+  } else {
+    cacheConfig = config;
+  }
+  return cacheConfig;
+};
+var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
+  const populate = async (item) => {
+    logger23.default("populate", { item });
+    for (const key in aggregates) {
+      await populateAggregate(key, item);
+    }
+    for (const key in events) {
+      await populateEvent(key, item);
+    }
+    logger23.default("populate done", { item });
+    return item;
+  };
+  const populateAggregate = async (key, item) => {
+    logger23.default("populate aggregate key", { key });
+    const cacheConfig = toCacheConfig(aggregates[key]);
+    if (item.refs === void 0) {
+      if (cacheConfig.optional === false) {
+        logger23.error("Item does not have refs an is not optional " + JSON.stringify(item));
+        throw new Error("Item does not have refs an is not optional " + JSON.stringify(item));
+      } else {
+        if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
+          delete item.events[key];
+        }
+      }
+    } else if (item.refs[key] === void 0) {
+      if (cacheConfig.optional === false) {
+        logger23.error("Item does not have mandatory ref with key, not optional " + key + " " + JSON.stringify(item));
+        throw new Error("Item does not have mandatory ref with key, not optional " + key + " " + JSON.stringify(item));
+      } else {
+        if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
+          delete item.events[key];
+        }
+      }
+    } else {
+      const ref = item.refs[key];
+      logger23.default("AGG Retrieving Item in Populate", { key: ref });
+      const [, newItem] = await cacheConfig.cache.operations.retrieve(ref);
+      if (newItem) {
+        if (item.aggs === void 0) {
+          item.aggs = {};
+        }
+        item.aggs[key] = {
+          key: ref,
+          item: newItem
+        };
+      }
+    }
+  };
+  const populateEvent = async (key, item) => {
+    logger23.default("populate event key", { key });
+    const cacheConfig = toCacheConfig(events[key]);
+    if (item.events === void 0) {
+      throw new Error("Item does not have events " + JSON.stringify(item));
+    } else if (item.events[key] === void 0) {
+      if (cacheConfig.optional === false) {
+        logger23.error("Item does not have mandatory event with key " + key + " " + JSON.stringify(item));
+        throw new Error("Item does not have mandatory event with key " + key + " " + JSON.stringify(item));
+      }
+    } else {
+      const event = item.events[key];
+      if (event.by === void 0) {
+        logger23.error(
+          "populateEvent with an Event that does not have by",
+          { event, ik: item.key, eventKey: key }
+        );
+        throw new Error("populateEvent with an Event that does not have by: " + JSON.stringify({ key, event }));
+      }
+      logger23.default("EVENT Retrieving Item in Populate", { key: event.by });
+      const [, newItem] = await cacheConfig.cache.operations.retrieve(event.by);
+      if (newItem) {
+        event.agg = newItem;
+      }
+    }
+  };
+  const all2 = async (query = {}, locations = []) => {
+    logger23.default("all", { query, locations });
+    const [cacheMap, items] = await cache.operations.all(query, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  };
+  const one2 = async (query = {}, locations = []) => {
+    logger23.default("one", { query, locations });
+    const [cacheMap, item] = await cache.operations.one(query, locations);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  };
+  const action2 = async (key, action3, body = {}) => {
+    logger23.default("action", { key, action: action3, body });
+    const [cacheMap, item] = await cache.operations.action(key, action3, body);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const allAction2 = async (action3, body = {}, locations = []) => {
+    logger23.default("action", { action: action3, body, locations });
+    const [cacheMap, items] = await cache.operations.allAction(action3, body, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  };
+  const allFacet2 = async (facet3, params = {}, locations = []) => {
+    logger23.default("allFacet", { facet: facet3, params, locations });
+    const [cacheMap, response] = await cache.operations.allFacet(facet3, params, locations);
+    return [cacheMap, response];
+  };
+  const create2 = async (v, locations = []) => {
+    logger23.default("create", { v, locations });
+    const [cacheMap, item] = await cache.operations.create(v, locations);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const get2 = async (key) => {
+    logger23.default("get", { key });
+    const [cacheMap, item] = await cache.operations.get(key);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  };
+  const retrieve2 = async (key) => {
+    logger23.default("retrieve", { key });
+    const [cacheMap, item] = await cache.operations.retrieve(key);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  };
+  const remove2 = async (key) => {
+    logger23.default("remove", { key });
+    const cacheMap = await cache.operations.remove(key);
+    return cacheMap;
+  };
+  const update2 = async (key, v) => {
+    logger23.default("update", { key, v });
+    const [cacheMap, item] = await cache.operations.update(key, v);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const facet2 = async (key, facet3) => {
+    logger23.default("facet", { key, facet: facet3 });
+    const [cacheMap, response] = await cache.operations.facet(key, facet3);
+    return [cacheMap, response];
+  };
+  const find2 = async (finder, finderParams = {}, locations = []) => {
+    logger23.default("find", { finder, finderParams, locations });
+    const [cacheMap, items] = await cache.operations.find(finder, finderParams, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  };
+  const findOne2 = async (finder, finderParams = {}, locations = []) => {
+    logger23.default("find", { finder, finderParams, locations });
+    const [cacheMap, item] = await cache.operations.findOne(finder, finderParams, locations);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const set2 = async (key, v) => {
+    logger23.default("set", { key, v });
+    const [cacheMap, item] = await cache.operations.set(key, v);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const reset2 = async () => {
+    const cacheMap = await cache.operations.reset();
+    return cacheMap;
+  };
+  return {
+    // Cache properties
+    coordinate: cache.coordinate,
+    registry: cache.registry,
+    api: cache.api,
+    cacheMap: cache.cacheMap,
+    operations: cache.operations,
+    // Cache operations exposed directly
+    all: all2,
+    one: one2,
+    action: action2,
+    allAction: allAction2,
+    allFacet: allFacet2,
+    create: create2,
+    get: get2,
+    retrieve: retrieve2,
+    remove: remove2,
+    update: update2,
+    facet: facet2,
+    find: find2,
+    findOne: findOne2,
+    reset: reset2,
+    set: set2,
+    // Aggregator-specific operations
+    populate,
+    populateAggregate,
+    populateEvent
   };
 };
 export {
+  AsyncIndexDBCacheMap,
   CacheMap,
+  EnhancedMemoryCacheMap,
+  IndexDBCacheMap,
+  LocalStorageCacheMap,
+  MemoryCacheMap,
+  SessionStorageCacheMap,
   createAggregator,
   createCache,
+  createCacheMap,
+  createEvictionStrategy,
   createInstance,
   createInstanceFactory,
+  createNormalizedHashFunction,
   createOperations,
-  createRegistry,
-  createRegistryFactory,
+  createOptions,
+  createValidatedConfig,
+  estimateValueSize,
+  formatBytes,
   isCache,
   isInstance,
-  toCacheConfig
+  isLocKeyArrayEqual,
+  normalizeKeyValue,
+  normalizeLocKeyItem,
+  parseSizeString,
+  toCacheConfig,
+  validateARCConfig,
+  validateEvictionStrategyConfig,
+  validateLFUConfig,
+  validateOptions,
+  validateSizeConfig,
+  validateTwoQueueConfig
 };
 //# sourceMappingURL=index.js.map