@fjell/cache 4.7.2 → 4.7.4

package/dist/index.js

@@ -340,19 +340,31 @@ var all = async (query = {}, locations = [], context) => {
       cacheMap.deleteQueryResult(queryHash);
     }
   }
+  try {
+    const directCachedItems = await cacheMap.queryIn(query, locations);
+    if (directCachedItems && directCachedItems.length > 0) {
+      logger.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
+      const itemKeys = directCachedItems.map((item) => item.key);
+      await cacheMap.setQueryResult(queryHash, itemKeys);
+      logger.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
+      return [context, validatePK(directCachedItems, pkType)];
+    }
+  } catch (error) {
+    logger.debug("Error querying cache directly, proceeding to API", { error });
+  }
   let ret = [];
   try {
     ret = await api.all(query, locations);
-    ret.forEach((v) => {
-      cacheMap.set(v.key, v);
+    for (const v of ret) {
+      await cacheMap.set(v.key, v);
       const keyStr = JSON.stringify(v.key);
       ttlManager.onItemAdded(keyStr, cacheMap);
-      const evictedKeys = context.evictionManager.onItemAdded(keyStr, v, cacheMap);
-      evictedKeys.forEach((evictedKey) => {
+      const evictedKeys = await context.evictionManager.onItemAdded(keyStr, v, cacheMap);
+      for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
-        cacheMap.delete(parsedKey);
-      });
-    });
+        await cacheMap.delete(parsedKey);
+      }
+    }
     const itemKeys = ret.map((item) => item.key);
     cacheMap.setQueryResult(queryHash, itemKeys);
     logger.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
@@ -374,85 +386,6 @@ import {
   validatePK as validatePK2
 } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/http-api";
-var logger2 = logger_default.get("one");
-var one = async (query = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager } = context;
-  logger2.default("one", { query, locations });
-  const queryHash = createQueryHash(pkType, query, locations);
-  logger2.debug("Generated query hash for one", { queryHash });
-  const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
-  if (cachedItemKeys) {
-    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
-    if (cachedItemKeys.length === 0) {
-      return [context, null];
-    }
-    const item = await 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);
-      const keyStr = JSON.stringify(retItem.key);
-      ttlManager.onItemAdded(keyStr, cacheMap);
-      const evictedKeys = context.evictionManager.onItemAdded(keyStr, retItem, cacheMap);
-      evictedKeys.forEach((evictedKey) => {
-        const parsedKey = JSON.parse(evictedKey);
-        cacheMap.delete(parsedKey);
-      });
-      cacheMap.setQueryResult(queryHash, [retItem.key]);
-      logger2.debug("Cached query result", { queryHash, itemKey: retItem.key });
-    } else {
-      cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result", { queryHash });
-    }
-  } catch (e) {
-    if (e instanceof NotFoundError2) {
-      cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result for not found", { queryHash });
-    } else {
-      throw e;
-    }
-  }
-  return [
-    context,
-    retItem ? validatePK2(retItem, pkType) : null
-  ];
-};
-
-// src/ops/create.ts
-import {
-  validatePK as validatePK3
-} from "@fjell/core";
-var logger3 = logger_default.get("create");
-var create = async (v, locations = [], context) => {
-  const { api, cacheMap, pkType, eventEmitter, ttlManager, evictionManager } = context;
-  logger3.default("create", { v, locations });
-  const created = await api.create(v, locations);
-  cacheMap.set(created.key, created);
-  const keyStr = JSON.stringify(created.key);
-  ttlManager.onItemAdded(keyStr, cacheMap);
-  const evictedKeys = evictionManager.onItemAdded(keyStr, created, cacheMap);
-  evictedKeys.forEach((evictedKey) => {
-    const parsedKey = JSON.parse(evictedKey);
-    cacheMap.delete(parsedKey);
-  });
-  const event = CacheEventFactory.itemCreated(created.key, created, "api");
-  eventEmitter.emit(event);
-  return [context, validatePK3(created, pkType)];
-};
-
-// src/ops/get.ts
-import {
-  isValidItemKey,
-  validatePK as validatePK4
-} from "@fjell/core";
 
 // src/utils/CacheSize.ts
 import safeStringify from "fast-safe-stringify";
@@ -614,7 +547,110 @@ function validateSizeConfig(config) {
   }
 }
 
+// src/ops/one.ts
+var logger2 = logger_default.get("one");
+var one = async (query = {}, locations = [], context) => {
+  const { api, cacheMap, pkType, ttlManager } = context;
+  logger2.default("one", { query, locations });
+  const queryHash = createQueryHash(pkType, query, locations);
+  logger2.debug("Generated query hash for one", { queryHash });
+  const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
+  if (cachedItemKeys) {
+    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    if (cachedItemKeys.length === 0) {
+      return [context, null];
+    }
+    const item = await cacheMap.get(cachedItemKeys[0]);
+    if (item) {
+      return [context, validatePK2(item, pkType)];
+    } else {
+      logger2.debug("Cached item missing, invalidating query cache");
+      cacheMap.deleteQueryResult(queryHash);
+    }
+  }
+  try {
+    const directCachedItems = await cacheMap.queryIn(query, locations);
+    if (directCachedItems && directCachedItems.length > 0) {
+      logger2.debug("Found item directly in cache, skipping API call");
+      const foundItem = directCachedItems[0];
+      await cacheMap.setQueryResult(queryHash, [foundItem.key]);
+      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
+      return [context, validatePK2(foundItem, pkType)];
+    }
+  } catch (error) {
+    logger2.debug("Error querying cache directly, proceeding to API", { error });
+  }
+  let retItem = null;
+  try {
+    retItem = await api.one(query, locations);
+    if (retItem) {
+      await cacheMap.set(retItem.key, retItem);
+      const keyStr = JSON.stringify(retItem.key);
+      const metadata = await cacheMap.getMetadata(keyStr);
+      if (!metadata) {
+        const now = Date.now();
+        const baseMetadata = {
+          key: keyStr,
+          addedAt: now,
+          lastAccessedAt: now,
+          accessCount: 1,
+          estimatedSize: estimateValueSize(retItem)
+        };
+        await cacheMap.setMetadata(keyStr, baseMetadata);
+      }
+      await ttlManager.onItemAdded(keyStr, cacheMap);
+      const evictedKeys = await context.evictionManager.onItemAdded(keyStr, retItem, cacheMap);
+      for (const evictedKey of evictedKeys) {
+        const parsedKey = JSON.parse(evictedKey);
+        await cacheMap.delete(parsedKey);
+      }
+      await cacheMap.setQueryResult(queryHash, [retItem.key]);
+      logger2.debug("Cached query result", { queryHash, itemKey: retItem.key });
+    } else {
+      await cacheMap.setQueryResult(queryHash, []);
+      logger2.debug("Cached empty query result", { queryHash });
+    }
+  } catch (e) {
+    if (e instanceof NotFoundError2) {
+      cacheMap.setQueryResult(queryHash, []);
+      logger2.debug("Cached empty query result for not found", { queryHash });
+    } else {
+      throw e;
+    }
+  }
+  return [
+    context,
+    retItem ? validatePK2(retItem, pkType) : null
+  ];
+};
+
+// src/ops/create.ts
+import {
+  validatePK as validatePK3
+} from "@fjell/core";
+var logger3 = logger_default.get("create");
+var create = async (v, locations = [], context) => {
+  const { api, cacheMap, pkType, eventEmitter, ttlManager, evictionManager } = context;
+  logger3.default("create", { v, locations });
+  const created = await api.create(v, locations);
+  cacheMap.set(created.key, created);
+  const keyStr = JSON.stringify(created.key);
+  ttlManager.onItemAdded(keyStr, cacheMap);
+  const evictedKeys = await evictionManager.onItemAdded(keyStr, created, cacheMap);
+  for (const evictedKey of evictedKeys) {
+    const parsedKey = JSON.parse(evictedKey);
+    await cacheMap.delete(parsedKey);
+  }
+  const event = CacheEventFactory.itemCreated(created.key, created, "api");
+  eventEmitter.emit(event);
+  return [context, validatePK3(created, pkType)];
+};
+
 // src/ops/get.ts
+import {
+  isValidItemKey,
+  validatePK as validatePK4
+} from "@fjell/core";
 var logger4 = logger_default.get("get");
 var inFlightRequests = /* @__PURE__ */ new Map();
 var CLEANUP_TIMEOUT = 5 * 60 * 1e3;
@@ -645,7 +681,7 @@ var get = async (key, context) => {
     const keyStr2 = JSON.stringify(key);
     const cachedItem = await cacheMap.get(key);
     if (cachedItem) {
-      const isValid = ttlManager.validateItem(keyStr2, cacheMap);
+      const isValid = await ttlManager.validateItem(keyStr2, cacheMap);
       if (isValid) {
         logger4.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
         statsManager.incrementHits();
@@ -692,9 +728,9 @@ var get = async (key, context) => {
     }
     ret = await apiRequest;
     if (ret) {
-      cacheMap.set(ret.key, ret);
+      await cacheMap.set(ret.key, ret);
       const keyStr2 = JSON.stringify(ret.key);
-      const metadata = cacheMap.getMetadata?.(keyStr2);
+      const metadata = await cacheMap.getMetadata(keyStr2);
       if (!metadata) {
         const now = Date.now();
         const baseMetadata = {
@@ -704,14 +740,14 @@ var get = async (key, context) => {
           accessCount: 1,
           estimatedSize: estimateValueSize(ret)
         };
-        cacheMap.setMetadata?.(keyStr2, baseMetadata);
+        await cacheMap.setMetadata(keyStr2, baseMetadata);
       }
-      const evictedKeys = context.evictionManager.onItemAdded(keyStr2, ret, cacheMap);
-      ttlManager.onItemAdded(keyStr2, cacheMap);
-      evictedKeys.forEach((evictedKey) => {
+      const evictedKeys = await context.evictionManager.onItemAdded(keyStr2, ret, cacheMap);
+      await ttlManager.onItemAdded(keyStr2, cacheMap);
+      for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
-        cacheMap.delete(parsedKey);
-      });
+        await cacheMap.delete(parsedKey);
+      }
       const event = CacheEventFactory.itemRetrieved(ret.key, ret, "api");
       context.eventEmitter.emit(event);
     }
@@ -807,14 +843,26 @@ var update = async (key, v, context) => {
     const previousItem = await cacheMap.get(key);
     const updated = await api.update(key, v);
     logger7.debug("Caching update result", { updatedKey: updated.key });
-    cacheMap.set(updated.key, updated);
+    await cacheMap.set(updated.key, updated);
     const keyStr = JSON.stringify(updated.key);
-    context.ttlManager.onItemAdded(keyStr, cacheMap);
-    const evictedKeys = context.evictionManager.onItemAdded(keyStr, updated, cacheMap);
-    evictedKeys.forEach((evictedKey) => {
+    const metadata = await cacheMap.getMetadata(keyStr);
+    if (!metadata) {
+      const now = Date.now();
+      const baseMetadata = {
+        key: keyStr,
+        addedAt: now,
+        lastAccessedAt: now,
+        accessCount: 1,
+        estimatedSize: estimateValueSize(updated)
+      };
+      await cacheMap.setMetadata(keyStr, baseMetadata);
+    }
+    await context.ttlManager.onItemAdded(keyStr, cacheMap);
+    const evictedKeys = await context.evictionManager.onItemAdded(keyStr, updated, cacheMap);
+    for (const evictedKey of evictedKeys) {
       const parsedKey = JSON.parse(evictedKey);
-      cacheMap.delete(parsedKey);
-    });
+      await cacheMap.delete(parsedKey);
+    }
     const event = CacheEventFactory.itemUpdated(updated.key, updated, previousItem, "api");
     context.eventEmitter.emit(event);
     return [context, validatePK6(updated, pkType)];
@@ -844,18 +892,18 @@ var action = async (key, action2, body = {}, context) => {
   cacheMap.set(updated.key, updated);
   const keyStr = JSON.stringify(updated.key);
   context.ttlManager.onItemAdded(keyStr, cacheMap);
-  const evictedKeys = context.evictionManager.onItemAdded(keyStr, updated, cacheMap);
-  evictedKeys.forEach((evictedKey) => {
+  const evictedKeys = await context.evictionManager.onItemAdded(keyStr, updated, cacheMap);
+  for (const evictedKey of evictedKeys) {
     try {
       const parsedKey = JSON.parse(evictedKey);
-      cacheMap.delete(parsedKey);
+      await cacheMap.delete(parsedKey);
     } catch (error) {
       logger8.error("Failed to parse evicted key during deletion", {
         evictedKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
-  });
+  }
   return [context, validatePK7(updated, pkType)];
 };
 
@@ -874,16 +922,16 @@ var allAction = async (action2, body = {}, locations = [], context) => {
   try {
     ret = await api.allAction(action2, body, locations);
     logger9.debug("Caching allAction results", { resultCount: ret.length });
-    ret.forEach((v) => {
-      cacheMap.set(v.key, v);
+    for (const v of ret) {
+      await cacheMap.set(v.key, v);
       const keyStr = JSON.stringify(v.key);
       context.ttlManager.onItemAdded(keyStr, cacheMap);
-      const evictedKeys = context.evictionManager.onItemAdded(keyStr, v, cacheMap);
-      evictedKeys.forEach((evictedKey) => {
+      const evictedKeys = await context.evictionManager.onItemAdded(keyStr, v, cacheMap);
+      for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
-        cacheMap.delete(parsedKey);
-      });
-    });
+        await cacheMap.delete(parsedKey);
+      }
+    }
   } catch (e) {
     if (e instanceof NotFoundError3) {
     } else {
@@ -943,16 +991,16 @@ var find = async (finder, params = {}, locations = [], context) => {
     }
   }
   const ret = await api.find(finder, params, locations);
-  ret.forEach((v) => {
-    cacheMap.set(v.key, v);
+  for (const v of ret) {
+    await cacheMap.set(v.key, v);
     const keyStr = JSON.stringify(v.key);
     ttlManager.onItemAdded(keyStr, cacheMap);
-    const evictedKeys = context.evictionManager.onItemAdded(keyStr, v, cacheMap);
-    evictedKeys.forEach((evictedKey) => {
+    const evictedKeys = await context.evictionManager.onItemAdded(keyStr, v, cacheMap);
+    for (const evictedKey of evictedKeys) {
       const parsedKey = JSON.parse(evictedKey);
-      cacheMap.delete(parsedKey);
-    });
-  });
+      await cacheMap.delete(parsedKey);
+    }
+  }
   const itemKeys = ret.map((item) => item.key);
   cacheMap.setQueryResult(queryHash, itemKeys);
   logger12.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
@@ -984,11 +1032,11 @@ var findOne = async (finder, finderParams = {}, locations = [], context) => {
   cacheMap.set(ret.key, ret);
   const keyStr = JSON.stringify(ret.key);
   ttlManager.onItemAdded(keyStr, cacheMap);
-  const evictedKeys = context.evictionManager.onItemAdded(keyStr, ret, cacheMap);
-  evictedKeys.forEach((evictedKey) => {
+  const evictedKeys = await context.evictionManager.onItemAdded(keyStr, ret, cacheMap);
+  for (const evictedKey of evictedKeys) {
     const parsedKey = JSON.parse(evictedKey);
-    cacheMap.delete(parsedKey);
-  });
+    await cacheMap.delete(parsedKey);
+  }
   cacheMap.setQueryResult(queryHash, [ret.key]);
   logger13.debug("Cached query result", { queryHash, itemKey: ret.key });
   return [context, validatePK10(ret, pkType)];
@@ -1061,14 +1109,26 @@ var set = async (key, v, context) => {
     throw new Error("Key does not match item key");
   }
   const previousItem = await cacheMap.get(key);
-  cacheMap.set(key, v);
+  await cacheMap.set(key, v);
   const keyStr = JSON.stringify(key);
-  ttlManager.onItemAdded(keyStr, cacheMap);
-  const evictedKeys = evictionManager.onItemAdded(keyStr, v, cacheMap);
-  evictedKeys.forEach((evictedKey) => {
+  const metadata = await cacheMap.getMetadata(keyStr);
+  if (!metadata) {
+    const now = Date.now();
+    const baseMetadata = {
+      key: keyStr,
+      addedAt: now,
+      lastAccessedAt: now,
+      accessCount: 1,
+      estimatedSize: estimateValueSize(v)
+    };
+    await cacheMap.setMetadata(keyStr, baseMetadata);
+  }
+  await ttlManager.onItemAdded(keyStr, cacheMap);
+  const evictedKeys = await evictionManager.onItemAdded(keyStr, v, cacheMap);
+  for (const evictedKey of evictedKeys) {
     const parsedKey = JSON.parse(evictedKey);
-    cacheMap.delete(parsedKey);
-  });
+    await cacheMap.delete(parsedKey);
+  }
   const event = CacheEventFactory.itemSet(key, v, previousItem);
   eventEmitter.emit(event);
   return [context, validatePK11(v, pkType)];
@@ -1127,7 +1187,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     }
     return null;
   }
-  set(key, value) {
+  async set(key, value) {
     logger15.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const keyStr = JSON.stringify(key);
@@ -1154,7 +1214,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     const entry = this.map[hashedKey];
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
   }
-  delete(key) {
+  async delete(key) {
     logger15.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
@@ -1170,13 +1230,13 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
       }
     }
   }
-  keys() {
+  async keys() {
     return Object.values(this.map).map((entry) => entry.originalKey);
   }
   async values() {
     return Object.values(this.map).map((entry) => entry.value);
   }
-  clear() {
+  async clear() {
     this.map = {};
     this.metadataMap.clear();
     this.queryResultCache = {};
@@ -1210,10 +1270,11 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   }
   async clone() {
     const clone = new _MemoryCacheMap(this.types);
-    for (const key of this.keys()) {
+    const keys = await this.keys();
+    for (const key of keys) {
       const value = await this.get(key);
       if (value) {
-        clone.set(key, value);
+        await clone.set(key, value);
       }
     }
     for (const [queryHash, entry] of Object.entries(this.queryResultCache)) {
@@ -1225,7 +1286,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return clone;
   }
   // Query result caching methods implementation
-  setQueryResult(queryHash, itemKeys) {
+  async setQueryResult(queryHash, itemKeys) {
     logger15.trace("setQueryResult", { queryHash, itemKeys });
     const entry = {
       itemKeys: [...itemKeys]
@@ -1241,54 +1302,54 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     }
     return [...entry.itemKeys];
   }
-  hasQueryResult(queryHash) {
+  async hasQueryResult(queryHash) {
     const entry = this.queryResultCache[queryHash];
     return !!entry;
   }
-  deleteQueryResult(queryHash) {
+  async deleteQueryResult(queryHash) {
     logger15.trace("deleteQueryResult", { queryHash });
     delete this.queryResultCache[queryHash];
   }
-  invalidateItemKeys(keys) {
+  async invalidateItemKeys(keys) {
     logger15.debug("invalidateItemKeys", { keys });
-    keys.forEach((key) => {
-      this.delete(key);
-    });
+    for (const key of keys) {
+      await this.delete(key);
+    }
   }
   async invalidateLocation(locations) {
     logger15.debug("invalidateLocation", { locations });
     if (locations.length === 0) {
-      const allKeys = this.keys();
+      const allKeys = await this.keys();
       const primaryKeys = allKeys.filter((key) => !isComKey(key));
-      this.invalidateItemKeys(primaryKeys);
+      await this.invalidateItemKeys(primaryKeys);
     } else {
       const itemsInLocation = await this.allIn(locations);
       const keysToInvalidate = itemsInLocation.map((item) => item.key);
-      this.invalidateItemKeys(keysToInvalidate);
+      await this.invalidateItemKeys(keysToInvalidate);
     }
-    this.clearQueryResults();
+    await this.clearQueryResults();
   }
-  clearQueryResults() {
+  async clearQueryResults() {
     logger15.trace("clearQueryResults");
     this.queryResultCache = {};
   }
   // CacheMapMetadataProvider implementation
-  getMetadata(key) {
+  async getMetadata(key) {
     return this.metadataMap.get(key) || null;
   }
-  setMetadata(key, metadata) {
+  async setMetadata(key, metadata) {
     this.metadataMap.set(key, metadata);
   }
-  deleteMetadata(key) {
+  async deleteMetadata(key) {
     this.metadataMap.delete(key);
   }
-  getAllMetadata() {
+  async getAllMetadata() {
     return new Map(this.metadataMap);
   }
-  clearMetadata() {
+  async clearMetadata() {
     this.metadataMap.clear();
   }
-  getCurrentSize() {
+  async getCurrentSize() {
     let sizeBytes = 0;
     for (const entry of Object.values(this.map)) {
       sizeBytes += estimateValueSize(entry.value);
@@ -1298,7 +1359,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
       sizeBytes
     };
   }
-  getSizeLimits() {
+  async getSizeLimits() {
     return {
       maxItems: null,
       maxSizeBytes: null
@@ -1356,7 +1417,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
     return null;
   }
-  set(key, value) {
+  async set(key, value) {
     logger16.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const estimatedSize = estimateValueSize(value);
@@ -1402,7 +1463,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     const entry = this.map[hashedKey];
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey && entry.value !== null;
   }
-  delete(key) {
+  async delete(key) {
     this.deleteInternal(key, true, "filter");
   }
   deleteInternal(key, invalidateQueries = false, invalidationMode = "remove") {
@@ -1428,13 +1489,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       }
     }
   }
-  keys() {
+  async keys() {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.originalKey);
   }
   async values() {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.value);
   }
-  clear() {
+  async clear() {
     logger16.debug("Clearing cache", {
       itemsCleared: this.currentItemCount,
       bytesFreed: this.currentSizeBytes
@@ -1478,14 +1539,15 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       sizeConfig.maxItems = this.maxItems;
     }
     const clone = new _EnhancedMemoryCacheMap(this.types, sizeConfig);
-    for (const key of this.keys()) {
+    const keys = await this.keys();
+    for (const key of keys) {
       const value = await this.get(key);
       if (value) {
-        clone.set(key, value);
+        await clone.set(key, value);
       }
     }
     for (const [queryHash, entry] of Object.entries(this.queryResultCache)) {
-      clone.setQueryResult(queryHash, entry.itemKeys);
+      await clone.setQueryResult(queryHash, entry.itemKeys);
     }
     return clone;
   }
@@ -1509,7 +1571,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return stats;
   }
   // Query result caching methods
-  setQueryResult(queryHash, itemKeys) {
+  async setQueryResult(queryHash, itemKeys) {
     logger16.trace("setQueryResult", { queryHash, itemKeys });
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
@@ -1529,28 +1591,28 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
     return [...entry.itemKeys];
   }
-  hasQueryResult(queryHash) {
+  async hasQueryResult(queryHash) {
     const entry = this.queryResultCache[queryHash];
     return !!entry;
   }
-  deleteQueryResult(queryHash) {
+  async deleteQueryResult(queryHash) {
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
       delete this.queryResultCache[queryHash];
     }
   }
-  clearQueryResults() {
+  async clearQueryResults() {
     this.queryResultCache = {};
     this.queryResultsCacheSize = 0;
   }
-  invalidateItemKeys(keys) {
+  async invalidateItemKeys(keys) {
     logger16.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
-    keys.forEach((key) => {
+    for (const key of keys) {
       this.deleteInternal(key, false);
-    });
+    }
     this.invalidateQueriesReferencingKeys(keys);
   }
   filterQueriesReferencingKeys(keys) {
@@ -1597,14 +1659,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     logger16.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
-      const allKeys = this.keys();
+      const allKeys = await this.keys();
       const primaryKeys = allKeys.filter((key) => !isComKey2(key));
       keysToInvalidate = primaryKeys;
     } else {
       const itemsInLocation = await this.allIn(locations);
       keysToInvalidate = itemsInLocation.map((item) => item.key);
     }
-    this.invalidateItemKeys(keysToInvalidate);
+    await this.invalidateItemKeys(keysToInvalidate);
   }
   /**
    * Add query result to size tracking
@@ -1644,14 +1706,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return this.currentSizeBytes + this.queryResultsCacheSize;
   }
   // CacheMapMetadataProvider implementation
-  getMetadata(key) {
+  async getMetadata(key) {
     const entry = this.map[key];
     if (entry && !entry.metadataCleared) {
       return entry.metadata;
     }
     return null;
   }
-  setMetadata(key, metadata) {
+  async setMetadata(key, metadata) {
     const entry = this.map[key];
     if (entry) {
       entry.metadata = metadata;
@@ -1672,9 +1734,9 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       };
     }
   }
-  deleteMetadata(_key) {
+  async deleteMetadata(_key) {
   }
-  getAllMetadata() {
+  async getAllMetadata() {
     const metadata = /* @__PURE__ */ new Map();
     for (const [hashedKey, entry] of Object.entries(this.map)) {
       if (!entry.metadataCleared) {
@@ -1683,7 +1745,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
     return metadata;
   }
-  clearMetadata() {
+  async clearMetadata() {
     const keysToRemove = [];
     for (const [hashedKey, entry] of Object.entries(this.map)) {
       if (entry.value === null) {
@@ -1696,13 +1758,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       delete this.map[key];
     }
   }
-  getCurrentSize() {
+  async getCurrentSize() {
     return {
       itemCount: this.currentItemCount,
       sizeBytes: this.currentSizeBytes
     };
   }
-  getSizeLimits() {
+  async getSizeLimits() {
     return {
       maxItems: this.maxItems ?? null,
       maxSizeBytes: this.maxSizeBytes ?? null
@@ -1842,7 +1904,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       return null;
     }
   }
-  set(key, value) {
+  async set(key, value) {
     logger17.trace("set", { key, value });
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
@@ -1896,7 +1958,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       return false;
     }
   }
-  delete(key) {
+  async delete(key) {
     logger17.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
@@ -1911,7 +1973,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     if (locations.length === 0) {
       logger17.debug("Returning all items, LocKeys is empty");
       const items = [];
-      for (const key of allKeys) {
+      for (const key of await allKeys) {
         const item = await this.get(key);
         if (item !== null) {
           items.push(item);
@@ -1920,14 +1982,15 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       return items;
     } else {
       const locKeys = locations;
-      logger17.debug("allIn", { locKeys, keys: allKeys.length });
-      const filteredKeys = allKeys.filter((key) => key && isComKey3(key)).filter((key) => {
-        const ComKey12 = key;
+      const resolvedKeys = await allKeys;
+      logger17.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      const filteredKeys = resolvedKeys.filter((key) => key && isComKey3(key)).filter((key) => {
+        const ComKey13 = key;
         logger17.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey12
+          ComKey: ComKey13
         });
-        return isLocKeyArrayEqual(locKeys, ComKey12.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey13.loc);
       });
       const items = [];
       for (const key of filteredKeys) {
@@ -1963,7 +2026,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
     return null;
   }
-  keys() {
+  async keys() {
     const keys = [];
     try {
       const storageKeys = this.getAllStorageKeys();
@@ -1993,7 +2056,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
     return values;
   }
-  clear() {
+  async clear() {
     logger17.debug("Clearing localStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
@@ -2006,7 +2069,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   // Query result caching methods implementation
-  setQueryResult(queryHash, itemKeys) {
+  async setQueryResult(queryHash, itemKeys) {
     logger17.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
@@ -2036,7 +2099,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       return null;
     }
   }
-  hasQueryResult(queryHash) {
+  async hasQueryResult(queryHash) {
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       return localStorage.getItem(queryKey) !== null;
@@ -2045,7 +2108,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       return false;
     }
   }
-  deleteQueryResult(queryHash) {
+  async deleteQueryResult(queryHash) {
     logger17.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
@@ -2054,36 +2117,37 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       logger17.error("Failed to delete query result from localStorage", { queryHash, error });
     }
   }
-  invalidateItemKeys(keys) {
+  async invalidateItemKeys(keys) {
     logger17.debug("invalidateItemKeys", { keys });
-    keys.forEach((key) => {
+    for (const key of keys) {
       try {
-        this.delete(key);
+        await this.delete(key);
       } catch (error) {
         logger17.error("Failed to delete key during invalidation", { key, error });
       }
-    });
+    }
   }
   async invalidateLocation(locations) {
     logger17.debug("invalidateLocation", { locations });
     try {
       if (locations.length === 0) {
-        const allKeys = this.keys();
+        const allKeys = await this.keys();
         const primaryKeys = allKeys.filter((key) => !isComKey3(key));
-        this.invalidateItemKeys(primaryKeys);
+        await this.invalidateItemKeys(primaryKeys);
       } else {
-        const keysToInvalidate = this.keys().filter((key) => key && isComKey3(key)).filter((key) => {
+        const allKeys = await this.keys();
+        const keysToInvalidate = allKeys.filter((key) => key && isComKey3(key)).filter((key) => {
           const compositeKey = key;
           return isLocKeyArrayEqual(locations, compositeKey.loc);
         });
-        this.invalidateItemKeys(keysToInvalidate);
+        await this.invalidateItemKeys(keysToInvalidate);
       }
-      this.clearQueryResults();
+      await this.clearQueryResults();
     } catch (error) {
       logger17.error("Error in invalidateLocation", { locations, error });
     }
   }
-  clearQueryResults() {
+  async clearQueryResults() {
     logger17.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
@@ -2100,7 +2164,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   // CacheMapMetadataProvider implementation
-  getMetadata(key) {
+  async getMetadata(key) {
     try {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       const stored = localStorage.getItem(metadataKey);
@@ -2118,7 +2182,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       throw error;
     }
   }
-  setMetadata(key, metadata) {
+  async setMetadata(key, metadata) {
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
         const metadataKey = `${this.keyPrefix}:metadata:${key}`;
@@ -2146,7 +2210,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
     }
   }
-  deleteMetadata(key) {
+  async deleteMetadata(key) {
     try {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       localStorage.removeItem(metadataKey);
@@ -2155,7 +2219,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       throw error;
     }
   }
-  getAllMetadata() {
+  async getAllMetadata() {
     const metadata = /* @__PURE__ */ new Map();
     try {
       const metadataPrefix = `${this.keyPrefix}:metadata:`;
@@ -2179,7 +2243,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
     return metadata;
   }
-  clearMetadata() {
+  async clearMetadata() {
     try {
       const metadataPrefix = `${this.keyPrefix}:metadata:`;
       const keysToDelete = this.getAllKeysStartingWith(metadataPrefix);
@@ -2189,7 +2253,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       throw error;
     }
   }
-  getCurrentSize() {
+  async getCurrentSize() {
     let itemCount = 0;
     let sizeBytes = 0;
     try {
@@ -2228,7 +2292,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
     return { itemCount, sizeBytes };
   }
-  getSizeLimits() {
+  async getSizeLimits() {
     return {
       maxItems: null,
       // No specific item limit
@@ -2319,7 +2383,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return null;
     }
   }
-  set(key, value) {
+  async set(key, value) {
     try {
       const storageKey = this.getStorageKey(key);
       logger18.trace("set", { storageKey });
@@ -2357,7 +2421,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return false;
     }
   }
-  delete(key) {
+  async delete(key) {
     logger18.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
@@ -2371,7 +2435,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     if (locations.length === 0) {
       logger18.debug("Returning all items, LocKeys is empty");
       const items = [];
-      for (const key of allKeys) {
+      for (const key of await allKeys) {
         const item = await this.get(key);
         if (item !== null) {
           items.push(item);
@@ -2380,14 +2444,15 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return items;
     } else {
       const locKeys = locations;
-      logger18.debug("allIn", { locKeys, keys: allKeys.length });
-      const filteredKeys = allKeys.filter((key) => key && isComKey4(key)).filter((key) => {
-        const ComKey12 = key;
+      const resolvedKeys = await allKeys;
+      logger18.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      const filteredKeys = resolvedKeys.filter((key) => key && isComKey4(key)).filter((key) => {
+        const ComKey13 = key;
         logger18.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey12
+          ComKey: ComKey13
         });
-        return isLocKeyArrayEqual(locKeys, ComKey12.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey13.loc);
       });
       const items = [];
       for (const key of filteredKeys) {
@@ -2412,7 +2477,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   async clone() {
     return new _SessionStorageCacheMap(this.types, this.keyPrefix);
   }
-  keys() {
+  async keys() {
     const keys = [];
     try {
       const storageKeys = this.getAllStorageKeys();
@@ -2454,7 +2519,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
     return values;
   }
-  clear() {
+  async clear() {
     logger18.debug("Clearing sessionStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
@@ -2466,7 +2531,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   // Query result caching methods implementation
-  setQueryResult(queryHash, itemKeys) {
+  async setQueryResult(queryHash, itemKeys) {
     logger18.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
@@ -2497,7 +2562,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return null;
     }
   }
-  hasQueryResult(queryHash) {
+  async hasQueryResult(queryHash) {
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       return sessionStorage.getItem(queryKey) !== null;
@@ -2506,7 +2571,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return false;
     }
   }
-  deleteQueryResult(queryHash) {
+  async deleteQueryResult(queryHash) {
     logger18.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
@@ -2515,26 +2580,26 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       logger18.error("Failed to delete query result from sessionStorage", { queryHash, error });
     }
   }
-  invalidateItemKeys(keys) {
+  async invalidateItemKeys(keys) {
     logger18.debug("invalidateItemKeys", { keys });
-    keys.forEach((key) => {
-      this.delete(key);
-    });
+    for (const key of keys) {
+      await this.delete(key);
+    }
   }
   async invalidateLocation(locations) {
     logger18.debug("invalidateLocation", { locations });
     if (locations.length === 0) {
-      const allKeys = this.keys();
+      const allKeys = await this.keys();
       const primaryKeys = allKeys.filter((key) => !isComKey4(key));
-      this.invalidateItemKeys(primaryKeys);
+      await this.invalidateItemKeys(primaryKeys);
     } else {
       const itemsInLocation = await this.allIn(locations);
       const keysToInvalidate = itemsInLocation.map((item) => item.key);
-      this.invalidateItemKeys(keysToInvalidate);
+      await this.invalidateItemKeys(keysToInvalidate);
     }
-    this.clearQueryResults();
+    await this.clearQueryResults();
   }
-  clearQueryResults() {
+  async clearQueryResults() {
     logger18.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
@@ -2551,7 +2616,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   // CacheMapMetadataProvider implementation
-  getMetadata(key) {
+  async getMetadata(key) {
     try {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       const stored = sessionStorage.getItem(metadataKey);
@@ -2560,7 +2625,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return null;
     }
   }
-  setMetadata(key, metadata) {
+  async setMetadata(key, metadata) {
     try {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       const jsonString = safeStringify2(metadata);
@@ -2568,14 +2633,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } catch {
     }
   }
-  deleteMetadata(key) {
+  async deleteMetadata(key) {
     try {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       sessionStorage.removeItem(metadataKey);
     } catch {
     }
   }
-  getAllMetadata() {
+  async getAllMetadata() {
     const metadata = /* @__PURE__ */ new Map();
     const metadataPrefix = `${this.keyPrefix}:metadata:`;
     try {
@@ -2598,7 +2663,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       return metadata;
     }
   }
-  clearMetadata() {
+  async clearMetadata() {
     try {
       const metadataPrefix = `${this.keyPrefix}:metadata:`;
       const keysToDelete = [];
@@ -2612,7 +2677,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } catch {
     }
   }
-  getCurrentSize() {
+  async getCurrentSize() {
     let itemCount = 0;
     let sizeBytes = 0;
     try {
@@ -2642,7 +2707,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
     return { itemCount, sizeBytes };
   }
-  getSizeLimits() {
+  async getSizeLimits() {
     return {
       maxItems: null,
       // No specific item limit
@@ -2652,6 +2717,12 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
 };
 
+// src/browser/IndexDBCacheMap.ts
+import {
+  isComKey as isComKey6,
+  isQueryMatch as isQueryMatch6
+} from "@fjell/core";
+
 // src/browser/AsyncIndexDBCacheMap.ts
 import {
   isComKey as isComKey5,
@@ -2666,6 +2737,8 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   version;
   normalizedHashFunction;
   dbPromise = null;
+  // Current storage format version
+  static CURRENT_VERSION = 1;
   constructor(types, dbName = "fjell-indexdb-cache", storeName = "cache", version = 1) {
     this.types = types;
     this.dbName = dbName;
@@ -2676,6 +2749,10 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   async getDB() {
     if (!this.dbPromise) {
       this.dbPromise = new Promise((resolve, reject) => {
+        if (typeof indexedDB === "undefined") {
+          reject(new Error("IndexedDB is not available in this environment"));
+          return;
+        }
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
           logger19.error("Error opening IndexedDB", { error: request.error });
@@ -2727,8 +2804,41 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return null;
     }
   }
-  async set(key, value) {
-    logger19.trace("set", { key, value });
+  /**
+   * Get both the value and metadata for an item
+   */
+  async getWithMetadata(key) {
+    logger19.trace("getWithMetadata", { 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({
+              value: stored.value,
+              metadata: stored.metadata
+            });
+          } else {
+            resolve(null);
+          }
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB getWithMetadata operation", { key, error });
+      return null;
+    }
+  }
+  async set(key, value, metadata) {
+    logger19.trace("set", { key, value, hasMetadata: !!metadata });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -2736,7 +2846,9 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       const storageKey = this.getStorageKey(key);
       const storedItem = {
         originalKey: key,
-        value
+        value,
+        metadata,
+        version: _AsyncIndexDBCacheMap.CURRENT_VERSION
       };
       return new Promise((resolve, reject) => {
         const request = store.put(storedItem, storageKey);
@@ -2753,6 +2865,23 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       throw new Error(`Failed to store item in IndexedDB: ${error}`);
     }
   }
+  /**
+   * Update only the metadata for an existing item
+   */
+  async setMetadata(key, metadata) {
+    logger19.trace("setMetadata", { key, metadata });
+    try {
+      const existing = await this.getWithMetadata(key);
+      if (existing) {
+        await this.set(key, existing.value, metadata);
+      } else {
+        logger19.warning("Attempted to set metadata for non-existent item", { key });
+      }
+    } catch (error) {
+      logger19.error("Error in IndexedDB setMetadata operation", { key, error });
+      throw new Error(`Failed to update metadata in IndexedDB: ${error}`);
+    }
+  }
   async includesKey(key) {
     try {
       const db = await this.getDB();
@@ -2812,12 +2941,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       const locKeys = locations;
       logger19.debug("allIn", { locKeys, keys: allKeys.length });
       const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
-        const ComKey12 = key;
+        const ComKey13 = key;
         logger19.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey12
+          ComKey: ComKey13
         });
-        return isLocKeyArrayEqual(locKeys, ComKey12.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey13.loc);
       });
       const promises = filteredKeys.map((key) => this.get(key));
       const results = await Promise.all(promises);
@@ -2865,6 +2994,40 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return [];
     }
   }
+  /**
+   * Get all metadata entries from IndexedDB
+   */
+  async getAllMetadata() {
+    const metadataMap = /* @__PURE__ */ new Map();
+    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 metadata from IndexedDB", { error: request.error });
+          reject(request.error);
+        };
+        request.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            const stored = cursor.value;
+            if (stored.metadata) {
+              const keyStr = JSON.stringify(stored.originalKey);
+              metadataMap.set(keyStr, stored.metadata);
+            }
+            cursor.continue();
+          } else {
+            resolve(metadataMap);
+          }
+        };
+      });
+    } catch (error) {
+      logger19.error("Error in IndexedDB getAllMetadata operation", { error });
+      return metadataMap;
+    }
+  }
   async values() {
     const values = [];
     try {
@@ -3108,247 +3271,249 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
 };
 
 // src/browser/IndexDBCacheMap.ts
+var logger20 = logger_default.get("IndexDBCacheMap");
 var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   implementationType = "browser/indexedDB";
+  // Memory storage
+  memoryMap = {};
+  queryResultCache = {};
+  metadataMap = /* @__PURE__ */ new Map();
+  normalizedHashFunction;
+  types;
+  // IndexedDB for persistence
   asyncCache;
-  memoryCache;
+  // Background sync management
   syncInterval = null;
-  SYNC_INTERVAL_MS = 5e3;
-  // Sync every 5 seconds
-  pendingSyncOperations = /* @__PURE__ */ new Map();
-  initializationPromise = null;
-  isInitialized = false;
-  MAX_RETRY_ATTEMPTS = 3;
-  operationSequence = 0;
+  pendingOperations = [];
+  sequenceCounter = 0;
   constructor(types, dbName = "fjell-indexdb-cache", storeName = "cache", version = 1) {
     super(types);
+    this.types = types;
+    this.normalizedHashFunction = createNormalizedHashFunction();
     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);
-            }
+    try {
+      const keys = await this.asyncCache.keys();
+      for (const key of keys) {
+        const hashedKey = this.normalizedHashFunction(key);
+        if (!this.memoryMap[hashedKey]) {
+          const value = await this.asyncCache.get(key);
+          if (value) {
+            this.memoryMap[hashedKey] = {
+              originalKey: key,
+              value
+            };
           }
         }
-        this.isInitialized = true;
-      } catch (error) {
-        console.warn("Failed to initialize from IndexedDB:", error);
-        this.isInitialized = true;
       }
-    })();
-    return this.initializationPromise;
+    } catch (error) {
+      console.warn("Failed to initialize from IndexedDB, using memory-only mode:", error);
+    }
   }
   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 = await this.memoryCache.get(key);
-        if (value) {
-          await this.asyncCache.set(key, value);
-        }
-      }
-    } catch (error) {
-      console.warn("Failed to sync to IndexedDB:", error);
-    }
+      this.processPendingOperations();
+    }, 10);
   }
   async processPendingOperations() {
-    const pendingOps = Array.from(this.pendingSyncOperations.entries());
-    for (const [keyStr, operation] of pendingOps) {
-      if (operation.cancelled) {
-        this.pendingSyncOperations.delete(keyStr);
-        continue;
-      }
+    if (this.pendingOperations.length === 0) return;
+    const operations = [...this.pendingOperations];
+    this.pendingOperations = [];
+    for (const op of operations) {
       try {
-        await operation.promise;
-        const currentOp = this.pendingSyncOperations.get(keyStr);
-        if (currentOp && currentOp.sequenceId === operation.sequenceId) {
-          this.pendingSyncOperations.delete(keyStr);
+        switch (op.type) {
+          case "set":
+            if (op.key && op.value) {
+              await this.asyncCache.set(op.key, op.value, op.metadata);
+            }
+            break;
+          case "delete":
+            if (op.key) {
+              await this.asyncCache.delete(op.key);
+            }
+            break;
+          case "clear":
+            await this.asyncCache.clear();
+            break;
         }
       } catch (error) {
-        console.warn(`Failed to process pending ${operation.type} operation:`, error);
-        const currentOp = this.pendingSyncOperations.get(keyStr);
-        if (!currentOp || currentOp.sequenceId !== operation.sequenceId || currentOp.cancelled) {
-          if (currentOp && currentOp.sequenceId === operation.sequenceId) {
-            this.pendingSyncOperations.delete(keyStr);
-          }
-        }
+        console.warn("Failed to sync operation to IndexedDB:", error);
       }
     }
   }
-  queueForSync(key, value) {
-    const keyStr = JSON.stringify(key);
-    const sequenceId = ++this.operationSequence;
-    const existingOp = this.pendingSyncOperations.get(keyStr);
-    if (existingOp) {
-      existingOp.cancelled = true;
+  // Synchronous memory operations
+  async get(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.memoryMap[hashedKey];
+    if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
+      return entry.value;
     }
-    const syncPromise = (async () => {
-      try {
-        await this.asyncCache.set(key, value);
-        const currentOp = this.pendingSyncOperations.get(keyStr);
-        if (currentOp && currentOp.sequenceId === sequenceId && !currentOp.cancelled) {
-          this.pendingSyncOperations.delete(keyStr);
-        }
-      } catch (error) {
-        console.warn("Failed to sync single operation to IndexedDB:", error);
-        const currentOp = this.pendingSyncOperations.get(keyStr);
-        if (!currentOp || currentOp.sequenceId !== sequenceId || currentOp.cancelled) {
-          if (currentOp && currentOp.sequenceId === sequenceId) {
-            this.pendingSyncOperations.delete(keyStr);
-          }
-        }
-      }
-    })();
-    this.pendingSyncOperations.set(keyStr, {
+    return null;
+  }
+  async set(key, value) {
+    const hashedKey = this.normalizedHashFunction(key);
+    const now = Date.now();
+    const metadata = {
+      key: JSON.stringify(key),
+      addedAt: now,
+      lastAccessedAt: now,
+      accessCount: 1,
+      estimatedSize: JSON.stringify(value).length
+      // rough estimate
+    };
+    this.memoryMap[hashedKey] = {
+      originalKey: key,
+      value
+    };
+    this.pendingOperations.push({
       type: "set",
       key,
       value,
-      sequenceId,
-      promise: syncPromise,
-      cancelled: false
+      metadata,
+      sequenceId: ++this.sequenceCounter
     });
+    this.processPendingOperations();
   }
-  queueDeleteForSync(key) {
-    const keyStr = JSON.stringify(key);
-    const sequenceId = ++this.operationSequence;
-    const existingOp = this.pendingSyncOperations.get(keyStr);
-    if (existingOp) {
-      existingOp.cancelled = true;
-    }
-    const syncPromise = (async () => {
-      try {
-        await this.asyncCache.delete(key);
-        const currentOp = this.pendingSyncOperations.get(keyStr);
-        if (currentOp && currentOp.sequenceId === sequenceId && !currentOp.cancelled) {
-          this.pendingSyncOperations.delete(keyStr);
-        }
-      } catch (error) {
-        console.warn("Failed to sync delete operation to IndexedDB:", error);
-        const currentOp = this.pendingSyncOperations.get(keyStr);
-        if (!currentOp || currentOp.sequenceId !== sequenceId || currentOp.cancelled) {
-          if (currentOp && currentOp.sequenceId === sequenceId) {
-            this.pendingSyncOperations.delete(keyStr);
-          }
-        }
-      }
-    })();
-    this.pendingSyncOperations.set(keyStr, {
+  async includesKey(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    const entry = this.memoryMap[hashedKey];
+    return !!(entry && this.normalizedHashFunction(entry.originalKey) === hashedKey);
+  }
+  async delete(key) {
+    const hashedKey = this.normalizedHashFunction(key);
+    delete this.memoryMap[hashedKey];
+    this.metadataMap.delete(hashedKey);
+    this.pendingOperations.push({
       type: "delete",
       key,
-      sequenceId,
-      promise: syncPromise,
-      cancelled: false
+      sequenceId: ++this.sequenceCounter
     });
+    this.processPendingOperations();
   }
-  queueClearForSync() {
-    for (const operation of this.pendingSyncOperations.values()) {
-      operation.cancelled = true;
-    }
-    this.pendingSyncOperations.clear();
-    Promise.resolve().then(async () => {
-      try {
-        await this.asyncCache.clear();
-      } catch (error) {
-        console.warn("Failed to sync clear operation to IndexedDB:", error);
-      }
-    });
+  async keys() {
+    return Object.values(this.memoryMap).map((entry) => entry.originalKey);
   }
-  async get(key) {
-    if (!this.isInitialized && this.initializationPromise) {
-      try {
-        await this.initializationPromise;
-      } catch (error) {
-        console.warn("IndexedDB initialization failed, using memory cache only:", error);
-      }
-    }
-    return this.memoryCache.get(key);
+  async values() {
+    return Object.values(this.memoryMap).map((entry) => entry.value);
   }
-  set(key, value) {
-    this.memoryCache.set(key, value);
-    this.queueForSync(key, value);
+  async clear() {
+    this.memoryMap = {};
+    this.queryResultCache = {};
+    this.metadataMap.clear();
+    this.pendingOperations.push({
+      type: "clear",
+      sequenceId: ++this.sequenceCounter
+    });
+    this.processPendingOperations();
   }
-  async includesKey(key) {
-    if (!this.isInitialized && this.initializationPromise) {
-      try {
-        await this.initializationPromise;
-      } catch (error) {
-        console.warn("IndexedDB initialization failed, using memory cache only:", error);
+  async allIn(locations) {
+    const result = [];
+    for (const entry of Object.values(this.memoryMap)) {
+      const key = entry.originalKey;
+      if (locations.length === 0) {
+        result.push(entry.value);
+      } else if (isComKey6(key)) {
+        if (isLocKeyArrayEqual(key.loc, locations)) {
+          result.push(entry.value);
+        }
       }
     }
-    return this.memoryCache.includesKey(key);
-  }
-  delete(key) {
-    this.memoryCache.delete(key);
-    this.queueDeleteForSync(key);
-  }
-  async allIn(locations) {
-    return this.memoryCache.allIn(locations);
+    return result;
   }
   async contains(query, locations) {
-    return this.memoryCache.contains(query, locations);
+    const items = await this.queryIn(query, locations);
+    return items.length > 0;
   }
   async queryIn(query, locations) {
-    return this.memoryCache.queryIn(query, locations);
+    const candidates = await this.allIn(locations);
+    if (!query.compoundCondition) {
+      return candidates;
+    }
+    return candidates.filter((item) => isQueryMatch6(item, query));
   }
-  async clone() {
-    return new _IndexDBCacheMap(this.types);
+  // Query result caching methods
+  async setQueryResult(queryHash, itemKeys) {
+    this.queryResultCache[queryHash] = {
+      itemKeys
+    };
   }
-  keys() {
-    return this.memoryCache.keys();
+  async getQueryResult(queryHash) {
+    const entry = this.queryResultCache[queryHash];
+    return entry ? entry.itemKeys : null;
   }
-  async values() {
-    return this.memoryCache.values();
+  async hasQueryResult(queryHash) {
+    return queryHash in this.queryResultCache;
   }
-  clear() {
-    this.memoryCache.clear();
-    this.queueClearForSync();
+  async deleteQueryResult(queryHash) {
+    delete this.queryResultCache[queryHash];
   }
-  // Query result caching methods implementation
-  setQueryResult(queryHash, itemKeys) {
-    return this.memoryCache.setQueryResult(queryHash, itemKeys);
+  async clearQueryResults() {
+    this.queryResultCache = {};
   }
-  async getQueryResult(queryHash) {
-    if (!this.isInitialized && this.initializationPromise) {
-      try {
-        await this.initializationPromise;
-      } catch (error) {
-        console.warn("IndexedDB initialization failed, using memory cache only:", error);
+  // Invalidation methods
+  async invalidateItemKeys(keys) {
+    for (const queryHash in this.queryResultCache) {
+      const entry = this.queryResultCache[queryHash];
+      if (entry && entry.itemKeys.some((key) => keys.some(
+        (affectedKey) => this.normalizedHashFunction(affectedKey) === this.normalizedHashFunction(key)
+      ))) {
+        delete this.queryResultCache[queryHash];
       }
     }
-    return this.memoryCache.getQueryResult(queryHash);
   }
-  hasQueryResult(queryHash) {
-    return this.memoryCache.hasQueryResult(queryHash);
+  async invalidateLocation(locations) {
+    const itemsToDelete = [];
+    for (const entry of Object.values(this.memoryMap)) {
+      const key = entry.originalKey;
+      if (isComKey6(key) && isLocKeyArrayEqual(key.loc, locations)) {
+        itemsToDelete.push(key);
+      }
+    }
+    this.invalidateItemKeys(itemsToDelete);
   }
-  deleteQueryResult(queryHash) {
-    return this.memoryCache.deleteQueryResult(queryHash);
+  // Metadata operations
+  async getMetadata(key) {
+    return this.metadataMap.get(key) || null;
   }
-  invalidateItemKeys(keys) {
-    return this.memoryCache.invalidateItemKeys(keys);
+  async setMetadata(key, metadata) {
+    this.metadataMap.set(key, metadata);
   }
-  async invalidateLocation(locations) {
-    return await this.memoryCache.invalidateLocation(locations);
+  async deleteMetadata(key) {
+    this.metadataMap.delete(key);
   }
-  clearQueryResults() {
-    return this.memoryCache.clearQueryResults();
+  async getAllMetadata() {
+    return new Map(this.metadataMap);
+  }
+  async clearMetadata() {
+    this.metadataMap.clear();
+  }
+  // Size operations
+  async getCurrentSize() {
+    const itemCount = Object.keys(this.memoryMap).length;
+    let sizeBytes = 0;
+    for (const entry of Object.values(this.memoryMap)) {
+      sizeBytes += JSON.stringify(entry.value).length;
+    }
+    return { itemCount, sizeBytes };
+  }
+  async getSizeLimits() {
+    return { maxItems: null, maxSizeBytes: null };
+  }
+  // Clone operation
+  async clone() {
+    const cloned = new _IndexDBCacheMap(
+      this.types,
+      "fjell-indexdb-cache-clone",
+      "cache-clone",
+      1
+    );
+    cloned.memoryMap = { ...this.memoryMap };
+    cloned.queryResultCache = { ...this.queryResultCache };
+    cloned.metadataMap = new Map(this.metadataMap);
+    return cloned;
   }
   /**
    * Clean up resources when the cache is no longer needed
@@ -3359,29 +3524,6 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
       this.syncInterval = null;
     }
   }
-  // CacheMapMetadataProvider implementation
-  // Delegate to the memory cache for metadata operations for consistency
-  getMetadata(key) {
-    return this.memoryCache.getMetadata(key);
-  }
-  setMetadata(key, metadata) {
-    this.memoryCache.setMetadata(key, metadata);
-  }
-  deleteMetadata(key) {
-    this.memoryCache.deleteMetadata(key);
-  }
-  getAllMetadata() {
-    return this.memoryCache.getAllMetadata();
-  }
-  clearMetadata() {
-    this.memoryCache.clearMetadata();
-  }
-  getCurrentSize() {
-    return this.memoryCache.getCurrentSize();
-  }
-  getSizeLimits() {
-    return this.memoryCache.getSizeLimits();
-  }
 };
 
 // src/Options.ts
@@ -3561,7 +3703,7 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
 };
 
 // src/eviction/EvictionManager.ts
-var logger20 = logger_default.get("EvictionManager");
+var logger21 = logger_default.get("EvictionManager");
 var EvictionManager = class {
   evictionStrategy;
   constructor(evictionStrategy) {
@@ -3573,7 +3715,7 @@ var EvictionManager = class {
    */
   setEvictionStrategy(strategy) {
     this.evictionStrategy = strategy;
-    logger20.debug("Eviction strategy updated", {
+    logger21.debug("Eviction strategy updated", {
       strategy: strategy?.getStrategyName() || "none"
     });
   }
@@ -3589,14 +3731,14 @@ var EvictionManager = class {
    * @param key - Item key
    * @param metadataProvider - Cache metadata provider
    */
-  onItemAccessed(key, metadataProvider) {
+  async onItemAccessed(key, metadataProvider) {
     if (!this.evictionStrategy) {
       return;
     }
     try {
-      this.evictionStrategy.onItemAccessed(key, metadataProvider);
+      await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger20.error("Error in eviction strategy onItemAccessed", { key, error });
+      logger21.error("Error in eviction strategy onItemAccessed", { key, error });
     }
   }
   /**
@@ -3606,29 +3748,29 @@ var EvictionManager = class {
    * @param metadataProvider - Cache metadata provider
    * @returns Array of keys that were evicted
    */
-  onItemAdded(key, value, metadataProvider) {
+  async onItemAdded(key, value, metadataProvider) {
     const evictedKeys = [];
     if (!this.evictionStrategy) {
       return evictedKeys;
     }
     try {
       const estimatedSize = estimateValueSize(value);
-      const context = this.createEvictionContext(metadataProvider, estimatedSize);
-      const keysToEvict = this.evictionStrategy.selectForEviction(metadataProvider, context);
+      const context = await this.createEvictionContext(metadataProvider, estimatedSize);
+      const keysToEvict = await this.evictionStrategy.selectForEviction(metadataProvider, context);
       for (const evictKey of keysToEvict) {
-        this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
+        await this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
         evictedKeys.push(evictKey);
       }
-      this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
+      await this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
       if (evictedKeys.length > 0) {
-        logger20.debug("Items evicted during addition", {
+        logger21.debug("Items evicted during addition", {
           newKey: key,
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger20.error("Error in eviction strategy onItemAdded", { key, error });
+      logger21.error("Error in eviction strategy onItemAdded", { key, error });
     }
     return evictedKeys;
   }
@@ -3644,7 +3786,7 @@ var EvictionManager = class {
     try {
       this.evictionStrategy.onItemRemoved(key, metadataProvider);
     } catch (error) {
-      logger20.error("Error in eviction strategy onItemRemoved", { key, error });
+      logger21.error("Error in eviction strategy onItemRemoved", { key, error });
     }
   }
   /**
@@ -3652,26 +3794,26 @@ var EvictionManager = class {
    * @param metadataProvider - Cache metadata provider
    * @returns Array of keys that were evicted
    */
-  performEviction(metadataProvider) {
+  async performEviction(metadataProvider) {
     const evictedKeys = [];
     if (!this.evictionStrategy) {
       return evictedKeys;
     }
     try {
-      const context = this.createEvictionContext(metadataProvider);
-      const keysToEvict = this.evictionStrategy.selectForEviction(metadataProvider, context);
+      const context = await this.createEvictionContext(metadataProvider);
+      const keysToEvict = await this.evictionStrategy.selectForEviction(metadataProvider, context);
       for (const evictKey of keysToEvict) {
-        this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
+        await this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
         evictedKeys.push(evictKey);
       }
       if (evictedKeys.length > 0) {
-        logger20.debug("Manual eviction performed", {
+        logger21.debug("Manual eviction performed", {
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger20.error("Error in manual eviction", { error });
+      logger21.error("Error in manual eviction", { error });
     }
     return evictedKeys;
   }
@@ -3688,9 +3830,9 @@ var EvictionManager = class {
    * @param newItemSize - Size of item being added (optional)
    * @returns Eviction context
    */
-  createEvictionContext(metadataProvider, newItemSize) {
-    const currentSize = metadataProvider.getCurrentSize();
-    const limits = metadataProvider.getSizeLimits();
+  async createEvictionContext(metadataProvider, newItemSize) {
+    const currentSize = await metadataProvider.getCurrentSize();
+    const limits = await metadataProvider.getSizeLimits();
     return {
       currentSize,
       limits,
@@ -3772,11 +3914,11 @@ var EvictionStrategy = class {
 
 // src/eviction/strategies/LRUEvictionStrategy.ts
 var LRUEvictionStrategy = class extends EvictionStrategy {
-  selectForEviction(metadataProvider, context) {
+  async selectForEviction(metadataProvider, context) {
     if (!this.isEvictionNeeded(context)) {
       return [];
     }
-    const allMetadata = metadataProvider.getAllMetadata();
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) {
       return [];
     }
@@ -3788,15 +3930,15 @@ var LRUEvictionStrategy = class extends EvictionStrategy {
     }
     return keysToEvict;
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (metadata) {
       metadata.lastAccessedAt = Date.now();
       metadata.accessCount++;
-      metadataProvider.setMetadata(key, metadata);
+      await metadataProvider.setMetadata(key, metadata);
     }
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
     const metadata = {
       key,
@@ -3805,10 +3947,10 @@ var LRUEvictionStrategy = class extends EvictionStrategy {
       accessCount: 1,
       estimatedSize
     };
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
-    metadataProvider.deleteMetadata(key);
+  async onItemRemoved(key, metadataProvider) {
+    await metadataProvider.deleteMetadata(key);
   }
   getStrategyName() {
     return "lru";
@@ -4142,8 +4284,8 @@ var LFUEvictionStrategy = class extends EvictionStrategy {
     this.sketch = this.config.useProbabilisticCounting ? new CountMinSketch(this.config.sketchWidth, this.config.sketchDepth) : null;
     this.lastDecayTime = Date.now();
   }
-  selectForEviction(metadataProvider, context) {
-    const allMetadata = metadataProvider.getAllMetadata();
+  async selectForEviction(metadataProvider, context) {
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) return [];
     if (!this.isEvictionNeeded(context)) {
       return [];
@@ -4161,8 +4303,8 @@ var LFUEvictionStrategy = class extends EvictionStrategy {
     });
     return sortedEntries.slice(0, evictionCount).map(([key]) => key);
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata) return;
     const now = Date.now();
     metadata.lastAccessedAt = now;
@@ -4175,9 +4317,9 @@ var LFUEvictionStrategy = class extends EvictionStrategy {
     }
     metadata.frequencyScore = this.calculateFrequencyScore(metadata, now);
     metadata.lastFrequencyUpdate = now;
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
     const metadata = {
       key,
@@ -4192,10 +4334,10 @@ var LFUEvictionStrategy = class extends EvictionStrategy {
     if (this.sketch) {
       this.sketch.increment(key);
     }
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
-    metadataProvider.deleteMetadata(key);
+  async onItemRemoved(key, metadataProvider) {
+    await metadataProvider.deleteMetadata(key);
   }
   /**
    * Get the effective frequency for an item, applying real-time decay if needed
@@ -4262,11 +4404,11 @@ var LFUEvictionStrategy = class extends EvictionStrategy {
 
 // src/eviction/strategies/FIFOEvictionStrategy.ts
 var FIFOEvictionStrategy = class extends EvictionStrategy {
-  selectForEviction(metadataProvider, context) {
+  async selectForEviction(metadataProvider, context) {
     if (!this.isEvictionNeeded(context)) {
       return [];
     }
-    const allMetadata = metadataProvider.getAllMetadata();
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) {
       return [];
     }
@@ -4278,15 +4420,15 @@ var FIFOEvictionStrategy = class extends EvictionStrategy {
     }
     return keysToEvict;
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (metadata) {
       metadata.lastAccessedAt = Date.now();
       metadata.accessCount++;
-      metadataProvider.setMetadata(key, metadata);
+      await metadataProvider.setMetadata(key, metadata);
     }
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
     const metadata = {
       key,
@@ -4295,10 +4437,10 @@ var FIFOEvictionStrategy = class extends EvictionStrategy {
       accessCount: 1,
       estimatedSize
     };
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
-    metadataProvider.deleteMetadata(key);
+  async onItemRemoved(key, metadataProvider) {
+    await metadataProvider.deleteMetadata(key);
   }
   getStrategyName() {
     return "fifo";
@@ -4310,8 +4452,8 @@ var MRUEvictionStrategy = class extends EvictionStrategy {
   getStrategyName() {
     return "MRU";
   }
-  selectForEviction(metadataProvider, context) {
-    const allMetadata = metadataProvider.getAllMetadata();
+  async selectForEviction(metadataProvider, context) {
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) return [];
     if (!this.isEvictionNeeded(context)) {
       return [];
@@ -4323,14 +4465,14 @@ var MRUEvictionStrategy = class extends EvictionStrategy {
     });
     return sortedEntries.slice(0, evictionCount).map(([key]) => key);
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata) return;
     metadata.lastAccessedAt = Date.now();
     metadata.accessCount++;
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
     const metadata = {
       key,
@@ -4339,20 +4481,20 @@ var MRUEvictionStrategy = class extends EvictionStrategy {
       accessCount: 1,
       estimatedSize
     };
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
-    metadataProvider.deleteMetadata(key);
+  async onItemRemoved(key, metadataProvider) {
+    await metadataProvider.deleteMetadata(key);
   }
 };
 
 // src/eviction/strategies/RandomEvictionStrategy.ts
 var RandomEvictionStrategy = class extends EvictionStrategy {
-  selectForEviction(metadataProvider, context) {
+  async selectForEviction(metadataProvider, context) {
     if (!this.isEvictionNeeded(context)) {
       return [];
     }
-    const allMetadata = metadataProvider.getAllMetadata();
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) {
       return [];
     }
@@ -4366,15 +4508,15 @@ var RandomEvictionStrategy = class extends EvictionStrategy {
     }
     return keysToEvict;
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (metadata) {
       metadata.lastAccessedAt = Date.now();
       metadata.accessCount++;
-      metadataProvider.setMetadata(key, metadata);
+      await metadataProvider.setMetadata(key, metadata);
     }
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
     const metadata = {
       key,
@@ -4383,10 +4525,10 @@ var RandomEvictionStrategy = class extends EvictionStrategy {
       accessCount: 1,
       estimatedSize
     };
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
-    metadataProvider.deleteMetadata(key);
+  async onItemRemoved(key, metadataProvider) {
+    await metadataProvider.deleteMetadata(key);
   }
   getStrategyName() {
     return "random";
@@ -4414,8 +4556,8 @@ var ARCEvictionStrategy = class extends EvictionStrategy {
     this.maxGhostSize = this.config.maxCacheSize;
     this.lastDecayTime = Date.now();
   }
-  selectForEviction(metadataProvider, context) {
-    const allMetadata = metadataProvider.getAllMetadata();
+  async selectForEviction(metadataProvider, context) {
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) return [];
     if (!this.isEvictionNeeded(context)) {
       return [];
@@ -4485,8 +4627,8 @@ var ARCEvictionStrategy = class extends EvictionStrategy {
     }
     return null;
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata) return;
     const now = Date.now();
     const updatedMetadata = {
@@ -4523,9 +4665,9 @@ var ARCEvictionStrategy = class extends EvictionStrategy {
     if (targetAdjusted) {
       this.cleanupGhostLists();
     }
-    metadataProvider.setMetadata(key, updatedMetadata);
+    await metadataProvider.setMetadata(key, updatedMetadata);
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
     const metadata = {
       key,
@@ -4539,16 +4681,16 @@ var ARCEvictionStrategy = class extends EvictionStrategy {
       metadata.frequencyScore = 1;
       metadata.lastFrequencyUpdate = now;
     }
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemRemoved(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (metadata && this.isFrequentItem(metadata)) {
       this.addToFrequentGhosts(key);
     } else {
       this.addToRecentGhosts(key);
     }
-    metadataProvider.deleteMetadata(key);
+    await metadataProvider.deleteMetadata(key);
     this.cleanupGhostLists();
   }
   /**
@@ -4746,15 +4888,15 @@ var TwoQueueEvictionStrategy = class extends EvictionStrategy {
     this.maxGhostSize = this.config.maxCacheSize;
     this.lastDecayTime = Date.now();
   }
-  selectForEviction(metadataProvider, context) {
-    const allMetadata = metadataProvider.getAllMetadata();
+  async selectForEviction(metadataProvider, context) {
+    const allMetadata = await metadataProvider.getAllMetadata();
     if (allMetadata.size === 0) return [];
     if (!this.isEvictionNeeded(context)) {
       return [];
     }
     const evictionCount = this.calculateEvictionCount(context);
     if (evictionCount <= 0) return [];
-    this.applyPeriodicDecay(allMetadata);
+    await this.applyPeriodicDecay(allMetadata);
     const keysToEvict = [];
     for (let i = 0; i < evictionCount; i++) {
       let keyToEvict = null;
@@ -4817,8 +4959,8 @@ var TwoQueueEvictionStrategy = class extends EvictionStrategy {
     }
     return bestKey || (items.size > 0 ? items.keys().next().value ?? null : null);
   }
-  onItemAccessed(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async onItemAccessed(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata) return;
     const now = Date.now();
     metadata.lastAccessedAt = now;
@@ -4841,11 +4983,11 @@ var TwoQueueEvictionStrategy = class extends EvictionStrategy {
         this.hotQueue.unshift(key);
       }
     }
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemAdded(key, estimatedSize, metadataProvider) {
+  async onItemAdded(key, estimatedSize, metadataProvider) {
     const now = Date.now();
-    let metadata = metadataProvider.getMetadata(key);
+    let metadata = await metadataProvider.getMetadata(key);
     if (!metadata) {
       metadata = {
         key,
@@ -4878,9 +5020,9 @@ var TwoQueueEvictionStrategy = class extends EvictionStrategy {
         this.ghostQueue.delete(firstKey);
       }
     }
-    metadataProvider.setMetadata(key, metadata);
+    await metadataProvider.setMetadata(key, metadata);
   }
-  onItemRemoved(key, metadataProvider) {
+  async onItemRemoved(key, metadataProvider) {
     const recentIndex = this.recentQueue.indexOf(key);
     if (recentIndex !== -1) {
       this.recentQueue.splice(recentIndex, 1);
@@ -4889,7 +5031,7 @@ var TwoQueueEvictionStrategy = class extends EvictionStrategy {
     if (hotIndex !== -1) {
       this.hotQueue.splice(hotIndex, 1);
     }
-    metadataProvider.deleteMetadata(key);
+    await metadataProvider.deleteMetadata(key);
   }
   /**
    * Determine if an item should be promoted from recent to hot queue
@@ -4934,7 +5076,7 @@ var TwoQueueEvictionStrategy = class extends EvictionStrategy {
   /**
    * Apply periodic decay to hot queue items
    */
-  applyPeriodicDecay(items) {
+  async applyPeriodicDecay(items) {
     if ((this.config.hotQueueDecayFactor ?? 0) === 0) return;
     const now = Date.now();
     const timeSinceDecay = now - this.lastDecayTime;
@@ -5018,7 +5160,7 @@ function createEvictionStrategy(policy, maxCacheSize, config) {
 }
 
 // src/ttl/TTLManager.ts
-var logger21 = logger_default.get("TTLManager");
+var logger22 = logger_default.get("TTLManager");
 var TTLManager = class {
   config;
   cleanupTimer;
@@ -5058,18 +5200,18 @@ var TTLManager = class {
         this.startAutoCleanup();
       }
     }
-    logger21.debug("TTL configuration updated", { config: this.config });
+    logger22.debug("TTL configuration updated", { config: this.config });
   }
   /**
    * Set TTL metadata for an item when it's added
    */
-  onItemAdded(key, metadataProvider, itemTTL) {
+  async onItemAdded(key, metadataProvider, itemTTL) {
     if (!this.isTTLEnabled() && !itemTTL) {
       return;
     }
-    const metadata = metadataProvider.getMetadata(key);
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata) {
-      logger21.warning("No metadata found for item when setting TTL", { key });
+      logger22.warning("No metadata found for item when setting TTL", { key });
       return;
     }
     const ttl = itemTTL || this.config.defaultTTL;
@@ -5079,22 +5221,22 @@ var TTLManager = class {
         expiresAt: metadata.addedAt + ttl,
         ttl
       };
-      metadataProvider.setMetadata(key, ttlMetadata);
-      logger21.trace("TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+      await metadataProvider.setMetadata(key, ttlMetadata);
+      logger22.trace("TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     }
   }
   /**
    * Check if an item has expired
    */
-  isExpired(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async isExpired(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata || !metadata.expiresAt) {
       return false;
     }
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
     if (expired) {
-      logger21.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
+      logger22.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
     }
     return expired;
   }
@@ -5102,17 +5244,17 @@ var TTLManager = class {
    * Check if an item is valid (not expired) before returning it
    * Returns true if item is valid, false if expired
    */
-  validateItem(key, metadataProvider) {
+  async validateItem(key, metadataProvider) {
     if (!this.config.validateOnAccess) {
       return true;
     }
-    return !this.isExpired(key, metadataProvider);
+    return !await this.isExpired(key, metadataProvider);
   }
   /**
    * Get TTL information for an item
    */
-  getItemTTLInfo(key, metadataProvider) {
-    const metadata = metadataProvider.getMetadata(key);
+  async getItemTTLInfo(key, metadataProvider) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata || !metadata.expiresAt) {
       return { hasTTL: false, isExpired: false };
     }
@@ -5130,9 +5272,9 @@ var TTLManager = class {
   /**
    * Find all expired items
    */
-  findExpiredItems(metadataProvider) {
+  async findExpiredItems(metadataProvider) {
     const expiredKeys = [];
-    const allMetadata = metadataProvider.getAllMetadata();
+    const allMetadata = await metadataProvider.getAllMetadata();
     const now = Date.now();
     for (const [key, metadata] of allMetadata) {
       const ttlMetadata = metadata;
@@ -5141,7 +5283,7 @@ var TTLManager = class {
       }
     }
     if (expiredKeys.length > 0) {
-      logger21.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
+      logger22.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
     }
     return expiredKeys;
   }
@@ -5149,34 +5291,34 @@ var TTLManager = class {
    * Manually clean up expired items
    * Returns the keys of items that were expired
    */
-  cleanupExpiredItems(metadataProvider) {
-    return this.findExpiredItems(metadataProvider);
+  async cleanupExpiredItems(metadataProvider) {
+    return await this.findExpiredItems(metadataProvider);
   }
   /**
    * Get remaining TTL for an item in milliseconds
    */
-  getRemainingTTL(key, metadataProvider) {
-    const info = this.getItemTTLInfo(key, metadataProvider);
+  async getRemainingTTL(key, metadataProvider) {
+    const info = await this.getItemTTLInfo(key, metadataProvider);
     return info.hasTTL ? info.remainingTTL || 0 : null;
   }
   /**
    * Extend TTL for an item
    */
-  extendTTL(key, metadataProvider, additionalTTL) {
-    const metadata = metadataProvider.getMetadata(key);
+  async extendTTL(key, metadataProvider, additionalTTL) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata || !metadata.expiresAt) {
       return false;
     }
     metadata.expiresAt += additionalTTL;
-    metadataProvider.setMetadata(key, metadata);
-    logger21.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
+    await metadataProvider.setMetadata(key, metadata);
+    logger22.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
     return true;
   }
   /**
    * Reset TTL for an item (refresh expiration)
    */
-  refreshTTL(key, metadataProvider, newTTL) {
-    const metadata = metadataProvider.getMetadata(key);
+  async refreshTTL(key, metadataProvider, newTTL) {
+    const metadata = await metadataProvider.getMetadata(key);
     if (!metadata) {
       return false;
     }
@@ -5190,8 +5332,8 @@ var TTLManager = class {
       expiresAt: now + ttl,
       ttl
     };
-    metadataProvider.setMetadata(key, ttlMetadata);
-    logger21.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+    await metadataProvider.setMetadata(key, ttlMetadata);
+    logger22.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     return true;
   }
   /**
@@ -5203,9 +5345,9 @@ var TTLManager = class {
     }
     if (this.config.cleanupInterval) {
       this.cleanupTimer = setInterval(() => {
-        logger21.trace("Auto cleanup timer triggered");
+        logger22.trace("Auto cleanup timer triggered");
       }, this.config.cleanupInterval);
-      logger21.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
+      logger22.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
     }
   }
   /**
@@ -5215,7 +5357,7 @@ var TTLManager = class {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
-      logger21.debug("Auto cleanup stopped");
+      logger22.debug("Auto cleanup stopped");
     }
   }
   /**
@@ -5223,7 +5365,7 @@ var TTLManager = class {
    */
   destroy() {
     this.stopAutoCleanup();
-    logger21.debug("TTL manager destroyed");
+    logger22.debug("TTL manager destroyed");
   }
 };
 
@@ -5498,12 +5640,13 @@ var CacheEventEmitter = class {
   }
   /**
    * Check if two location arrays match
+   * Filter locations must be a prefix of event locations (in order)
    */
   locationsMatch(filter, eventLocations) {
-    if (filter.length === 0 && eventLocations.length === 0) {
-      return true;
+    if (filter.length === 0) {
+      return eventLocations.length === 0;
     }
-    if (filter.length !== eventLocations.length) {
+    if (filter.length > eventLocations.length) {
       return false;
     }
     return filter.every((filterLoc, index) => {
@@ -5620,9 +5763,9 @@ var CacheStatsManager = class {
 };
 
 // src/Cache.ts
-var logger22 = logger_default.get("Cache");
+var logger23 = logger_default.get("Cache");
 var createCache = (api, coordinate, registry, options) => {
-  logger22.debug("createCache", { coordinate, registry, options });
+  logger23.debug("createCache", { coordinate, registry, options });
   const completeOptions = createOptions(options);
   const cacheMap = createCacheMap(coordinate.kta, completeOptions);
   const pkType = coordinate.kta[0];
@@ -5701,13 +5844,13 @@ var isCache = (cache) => {
 };
 
 // src/InstanceFactory.ts
-var logger23 = logger_default.get("InstanceFactory");
+var logger24 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (api, options) => {
   const templateOptions = createOptions(options);
   validateOptions(templateOptions);
   return (coordinate, context) => {
     const instanceOptions = createOptions(options);
-    logger23.debug("Creating cache instance", {
+    logger24.debug("Creating cache instance", {
       coordinate,
       registry: context.registry,
       api,
@@ -5771,9 +5914,9 @@ var createInstanceFactory = (api, options) => {
 };
 
 // src/Instance.ts
-var logger24 = logger_default.get("Instance");
+var logger25 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, api, options) => {
-  logger24.debug("createInstance", { coordinate, api, registry, options });
+  logger25.debug("createInstance", { coordinate, api, registry, options });
   return createCache(api, coordinate, registry, options);
 };
 var isInstance = (instance) => {
@@ -5781,7 +5924,7 @@ var isInstance = (instance) => {
 };
 
 // src/Aggregator.ts
-var logger25 = logger_default.get("ItemAggregator");
+var logger26 = logger_default.get("ItemAggregator");
 var toCacheConfig = (config) => {
   let cacheConfig;
   if (config.optional === void 0) {
@@ -5793,22 +5936,22 @@ var toCacheConfig = (config) => {
 };
 var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
   const populate = async (item) => {
-    logger25.default("populate", { item });
+    logger26.default("populate", { item });
     for (const key in aggregates) {
       await populateAggregate(key, item);
     }
     for (const key in events) {
       await populateEvent(key, item);
     }
-    logger25.default("populate done", { item });
+    logger26.default("populate done", { item });
     return item;
   };
   const populateAggregate = async (key, item) => {
-    logger25.default("populate aggregate key", { key });
+    logger26.default("populate aggregate key", { key });
     const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === void 0) {
       if (cacheConfig.optional === false) {
-        logger25.error("Item does not have refs an is not optional ", { item });
+        logger26.error("Item does not have refs an is not optional ", { 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)) {
@@ -5817,7 +5960,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else if (item.refs[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger25.error("Item does not have mandatory ref with key, not optional ", { key, item });
+        logger26.error("Item does not have mandatory ref with key, not optional ", { key, 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)) {
@@ -5826,7 +5969,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else {
       const ref = item.refs[key];
-      logger25.default("AGG Retrieving Item in Populate", { key: ref });
+      logger26.default("AGG Retrieving Item in Populate", { key: ref });
       const newItem = await cacheConfig.cache.operations.retrieve(ref);
       if (newItem) {
         if (item.aggs === void 0) {
@@ -5840,25 +5983,25 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const populateEvent = async (key, item) => {
-    logger25.default("populate event key", { key });
+    logger26.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) {
-        logger25.error("Item does not have mandatory event with key", { key, item });
+        logger26.error("Item does not have mandatory event with key", { key, 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) {
-        logger25.error(
+        logger26.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 }));
       }
-      logger25.default("EVENT Retrieving Item in Populate", { key: event.by });
+      logger26.default("EVENT Retrieving Item in Populate", { key: event.by });
       const newItem = await cacheConfig.cache.operations.retrieve(event.by);
       if (newItem) {
         event.agg = newItem;
@@ -5866,13 +6009,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const all2 = async (query = {}, locations = []) => {
-    logger25.default("all", { query, locations });
+    logger26.default("all", { query, locations });
     const items = await cache.operations.all(query, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const one2 = async (query = {}, locations = []) => {
-    logger25.default("one", { query, locations });
+    logger26.default("one", { query, locations });
     const item = await cache.operations.one(query, locations);
     let populatedItem = null;
     if (item) {
@@ -5881,30 +6024,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger25.default("action", { key, action: action3, body });
+    logger26.default("action", { key, action: action3, body });
     const item = await cache.operations.action(key, action3, body);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const allAction2 = async (action3, body = {}, locations = []) => {
-    logger25.default("action", { action: action3, body, locations });
+    logger26.default("action", { action: action3, body, locations });
     const items = await cache.operations.allAction(action3, body, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const allFacet2 = async (facet3, params = {}, locations = []) => {
-    logger25.default("allFacet", { facet: facet3, params, locations });
+    logger26.default("allFacet", { facet: facet3, params, locations });
     const response = await cache.operations.allFacet(facet3, params, locations);
     return response;
   };
   const create2 = async (v, locations = []) => {
-    logger25.default("create", { v, locations });
+    logger26.default("create", { v, locations });
     const item = await cache.operations.create(v, locations);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const get2 = async (key) => {
-    logger25.default("get", { key });
+    logger26.default("get", { key });
     const item = await cache.operations.get(key);
     let populatedItem = null;
     if (item) {
@@ -5913,7 +6056,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const retrieve2 = async (key) => {
-    logger25.default("retrieve", { key });
+    logger26.default("retrieve", { key });
     const item = await cache.operations.retrieve(key);
     let populatedItem = null;
     if (item) {
@@ -5922,34 +6065,34 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const remove2 = async (key) => {
-    logger25.default("remove", { key });
+    logger26.default("remove", { key });
     await cache.operations.remove(key);
   };
   const update2 = async (key, v) => {
-    logger25.default("update", { key, v });
+    logger26.default("update", { key, v });
     const item = await cache.operations.update(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const facet2 = async (key, facet3) => {
-    logger25.default("facet", { key, facet: facet3 });
+    logger26.default("facet", { key, facet: facet3 });
     const response = await cache.operations.facet(key, facet3);
     return response;
   };
   const find2 = async (finder, finderParams = {}, locations = []) => {
-    logger25.default("find", { finder, finderParams, locations });
+    logger26.default("find", { finder, finderParams, locations });
     const items = await cache.operations.find(finder, finderParams, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const findOne2 = async (finder, finderParams = {}, locations = []) => {
-    logger25.default("find", { finder, finderParams, locations });
+    logger26.default("find", { finder, finderParams, locations });
     const item = await cache.operations.findOne(finder, finderParams, locations);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const set2 = async (key, v) => {
-    logger25.default("set", { key, v });
+    logger26.default("set", { key, v });
     const item = await cache.operations.set(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
@@ -6001,13 +6144,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger26 = logger_default.get("Registry");
+var logger27 = 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}`);
     }
-    logger26.debug("Creating cache registry", { type, registryHub });
+    logger27.debug("Creating cache registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };