@fjell/cache 4.7.15 → 4.7.17

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/CacheContext.ts
-var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager) => {
+var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) => {
   return {
     api,
     cacheMap,
@@ -8,7 +8,8 @@ var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManag
     eventEmitter,
     ttlManager,
     evictionManager,
-    statsManager
+    statsManager,
+    registry
   };
 };
 
@@ -964,18 +965,120 @@ import {
   isValidItemKey as isValidItemKey5,
   validatePK as validatePK7
 } from "@fjell/core";
-var logger8 = logger_default.get("action");
+
+// src/utils/cacheInvalidation.ts
+import { toKeyTypeArray } from "@fjell/core";
+var logger8 = logger_default.get("cache", "utils", "cacheInvalidation");
+var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
+  const keys = [];
+  const keyTypeArrays = [];
+  for (const item of affectedItems) {
+    if (Array.isArray(item)) {
+      const keyTypes = item.map((locKey) => locKey.kt);
+      keyTypeArrays.push(keyTypes);
+    } else if ("kt" in item && "pk" in item) {
+      keys.push(item);
+      const keyTypes = toKeyTypeArray(item);
+      keyTypeArrays.push(keyTypes);
+    }
+  }
+  return { keys, keyTypeArrays };
+};
+var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) => {
+  logger8.debug("Invalidating caches by keys and key types", {
+    keysCount: keys.length,
+    keyTypeArrays
+  });
+  const keysByKeyTypes = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const keyTypes = "loc" in key ? [key.kt, ...key.loc.map((locKey) => locKey.kt)] : [key.kt];
+    const keyTypesKey = keyTypes.join("|");
+    if (!keysByKeyTypes.has(keyTypesKey)) {
+      keysByKeyTypes.set(keyTypesKey, []);
+    }
+    keysByKeyTypes.get(keyTypesKey).push(key);
+  }
+  for (const [keyTypesKey, cacheKeys] of keysByKeyTypes) {
+    const keyTypes = keyTypesKey.split("|");
+    try {
+      const cacheInstance = registry.get(keyTypes);
+      if (cacheInstance && isCache(cacheInstance)) {
+        logger8.debug("Found cache instance for targeted invalidation", {
+          keyTypes,
+          cacheType: cacheInstance.coordinate.kta,
+          keysToInvalidate: cacheKeys.length
+        });
+        await cacheInstance.cacheMap.invalidateItemKeys(cacheKeys);
+        await cacheInstance.cacheMap.clearQueryResults();
+        logger8.debug("Successfully invalidated specific items in cache", {
+          keyTypes,
+          invalidatedCount: cacheKeys.length
+        });
+      } else {
+        logger8.debug("No cache instance found for key types", { keyTypes });
+      }
+    } catch (error) {
+      logger8.warning("Failed to invalidate cache for key types", {
+        keyTypes,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const keyTypes of keyTypeArrays) {
+    try {
+      const cacheInstance = registry.get(keyTypes);
+      if (cacheInstance && isCache(cacheInstance)) {
+        logger8.debug("Handling location-based invalidation", { keyTypes });
+        await cacheInstance.cacheMap.clearQueryResults();
+        logger8.debug("Successfully cleared query results for location", { keyTypes });
+      }
+    } catch (error) {
+      logger8.warning("Failed to handle location-based invalidation", {
+        keyTypes,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+};
+function isCache(instance) {
+  return instance !== null && typeof instance === "object" && "operations" in instance && "cacheMap" in instance && typeof instance.cacheMap.invalidateItemKeys === "function";
+}
+var handleActionCacheInvalidation = async (registry, affectedItems) => {
+  logger8.debug("Handling action cache invalidation", {
+    affectedItemsCount: affectedItems.length
+  });
+  const { keys, keyTypeArrays } = extractKeysAndKeyTypesFromActionResult(affectedItems);
+  await invalidateCachesByKeysAndKeyTypes(registry, keys, keyTypeArrays);
+};
+
+// src/ops/action.ts
+var logger9 = logger_default.get("action");
 var action = async (key, action2, body = {}, context) => {
-  const { api, cacheMap, pkType } = context;
-  logger8.default("action", { key, action: action2, body });
+  const { api, cacheMap, pkType, registry } = context;
+  logger9.default("action", { key, action: action2, body });
   if (!isValidItemKey5(key)) {
-    logger8.error("Key for Action is not a valid ItemKey: %j", key);
+    logger9.error("Key for Action is not a valid ItemKey: %j", key);
     throw new Error("Key for Action is not a valid ItemKey");
   }
-  logger8.debug("Invalidating item key before action", { key });
+  logger9.debug("Invalidating item key before action", { key });
   cacheMap.invalidateItemKeys([key]);
-  const updated = await api.action(key, action2, body);
-  logger8.debug("Caching action result", { updatedKey: updated.key });
+  const result = await api.action(key, action2, body);
+  const updated = result[0];
+  const affectedItems = result[1];
+  if (affectedItems && affectedItems.length > 0) {
+    logger9.debug("Handling cache invalidation for affected items", {
+      affectedItemsCount: affectedItems.length
+    });
+    try {
+      await handleActionCacheInvalidation(registry, affectedItems);
+    } catch (error) {
+      logger9.warning("Failed to handle cache invalidation for affected items", {
+        error: error instanceof Error ? error.message : String(error),
+        affectedItems
+      });
+    }
+  }
+  logger9.debug("Caching action result", { updatedKey: updated.key });
   cacheMap.set(updated.key, updated);
   const keyStr = JSON.stringify(updated.key);
   context.ttlManager.onItemAdded(keyStr, cacheMap);
@@ -985,19 +1088,19 @@ var action = async (key, action2, body = {}, context) => {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
     } catch (error) {
-      logger8.error("Failed to parse evicted key during deletion", {
+      logger9.error("Failed to parse evicted key during deletion", {
         evictedKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   }
-  logger8.debug("Emitting itemUpdated event after action", {
+  logger9.debug("Emitting itemUpdated event after action", {
     key: updated.key,
     action: action2
   });
   const itemEvent = CacheEventFactory.itemUpdated(updated.key, updated, null, "api");
   context.eventEmitter.emit(itemEvent);
-  logger8.debug("Emitting queryInvalidatedEvent after action", {
+  logger9.debug("Emitting queryInvalidatedEvent after action", {
     eventType: "query_invalidated",
     reason: "item_changed",
     action: action2
@@ -1009,7 +1112,7 @@ var action = async (key, action2, body = {}, context) => {
     { source: "operation", context: { operation: "action" } }
   );
   context.eventEmitter.emit(queryInvalidatedEvent);
-  return [context, validatePK7(updated, pkType)];
+  return [context, validatePK7(updated, pkType), affectedItems];
 };
 
 // src/ops/allAction.ts
@@ -1017,10 +1120,10 @@ import {
   validatePK as validatePK8
 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
-var logger9 = logger_default.get("allAction");
+var logger10 = logger_default.get("allAction");
 var allAction = async (action2, body = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, eventEmitter } = context;
-  logger9.default("allAction", { action: action2, body, locations });
+  const { api, cacheMap, pkType, eventEmitter, registry } = context;
+  logger10.default("allAction", { action: action2, body, locations });
   const existingItems = [];
   if (locations && locations.length > 0) {
     try {
@@ -1029,15 +1132,41 @@ var allAction = async (action2, body = {}, locations = [], context) => {
         existingItems.push(...cachedItems);
       }
     } catch (error) {
-      logger9.debug("Could not retrieve existing items for comparison", { error });
+      logger10.debug("Could not retrieve existing items for comparison", { error });
     }
   }
-  logger9.debug("Invalidating location before allAction", { locations });
+  logger10.debug("Invalidating location before allAction", { locations });
   await cacheMap.invalidateLocation(locations);
   let ret = [];
+  let affectedItems = [];
   try {
-    ret = await api.allAction(action2, body, locations);
-    logger9.debug("Caching allAction results", { resultCount: ret.length });
+    const result = await api.allAction(action2, body, locations);
+    if (Array.isArray(result) && result.length === 2) {
+      ret = result[0];
+      affectedItems = result[1];
+    } else {
+      logger10.warning("Unexpected result format from allAction", {
+        resultType: typeof result,
+        isArray: Array.isArray(result),
+        resultLength: Array.isArray(result) ? result.length : "not array"
+      });
+      ret = [];
+      affectedItems = [];
+    }
+    if (affectedItems && affectedItems.length > 0) {
+      logger10.debug("Handling cache invalidation for affected items", {
+        affectedItemsCount: affectedItems.length
+      });
+      try {
+        await handleActionCacheInvalidation(registry, affectedItems);
+      } catch (error) {
+        logger10.warning("Failed to handle cache invalidation for affected items", {
+          error: error instanceof Error ? error.message : String(error),
+          affectedItems
+        });
+      }
+    }
+    logger10.debug("Caching allAction results", { resultCount: ret.length });
     const modifiedItems = [];
     const newItems = [];
     for (const v of ret) {
@@ -1059,7 +1188,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       }
     }
     for (const item of modifiedItems) {
-      logger9.debug("Emitting item_updated event for modified item", { key: item.key });
+      logger10.debug("Emitting item_updated event for modified item", { key: item.key });
       const itemEvent = CacheEventFactory.itemUpdated(
         item.key,
         item,
@@ -1070,7 +1199,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       eventEmitter.emit(itemEvent);
     }
     for (const item of newItems) {
-      logger9.debug("Emitting item_created event for new item", { key: item.key });
+      logger10.debug("Emitting item_created event for new item", { key: item.key });
       const itemEvent = CacheEventFactory.itemCreated(
         item.key,
         item,
@@ -1080,14 +1209,14 @@ var allAction = async (action2, body = {}, locations = [], context) => {
     }
     if (modifiedItems.length > 0) {
       const modifiedKeys = modifiedItems.map((item) => item.key);
-      logger9.debug("Invalidating individual item keys for modified items", {
+      logger10.debug("Invalidating individual item keys for modified items", {
         keyCount: modifiedKeys.length,
         keys: modifiedKeys
       });
       await cacheMap.invalidateItemKeys(modifiedKeys);
     }
     await cacheMap.clearQueryResults();
-    logger9.debug("Emitting query_invalidated event after allAction", {
+    logger10.debug("Emitting query_invalidated event after allAction", {
       eventType: "query_invalidated",
       reason: "item_changed",
       action: action2,
@@ -1113,23 +1242,23 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       throw e;
     }
   }
-  return [context, validatePK8(ret, pkType)];
+  return [context, validatePK8(ret, pkType), affectedItems];
 };
 
 // src/ops/facet.ts
-var logger10 = logger_default.get("facet");
+var logger11 = logger_default.get("facet");
 var facet = async (key, facet2, params = {}, context) => {
   const { api } = context;
-  logger10.default("facet", { key, facet: facet2 });
+  logger11.default("facet", { key, facet: facet2 });
   const ret = await api.facet(key, facet2, params);
   return ret;
 };
 
 // src/ops/allFacet.ts
-var logger11 = logger_default.get("allFacet");
+var logger12 = logger_default.get("allFacet");
 var allFacet = async (facet2, params = {}, locations = [], context) => {
   const { api } = context;
-  logger11.default("allFacet", { facet: facet2, params, locations });
+  logger12.default("allFacet", { facet: facet2, params, locations });
   const ret = await api.allFacet(facet2, params, locations);
   return ret;
 };
@@ -1138,26 +1267,26 @@ var allFacet = async (facet2, params = {}, locations = [], context) => {
 import {
   validatePK as validatePK9
 } from "@fjell/core";
-var logger12 = logger_default.get("find");
+var logger13 = logger_default.get("find");
 var find = async (finder, params = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
-  logger12.default("find", { finder, params, locations });
+  logger13.default("find", { finder, params, locations });
   if (context.options?.bypassCache) {
-    logger12.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
+    logger13.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
     try {
       const ret2 = await api.find(finder, params, locations);
-      logger12.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
+      logger13.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
       return [context, validatePK9(ret2, pkType)];
     } catch (error) {
-      logger12.error("API request failed", { finder, params, locations, error });
+      logger13.error("API request failed", { finder, params, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, params, locations);
-  logger12.debug("Generated query hash for find", { queryHash, finder, params, locations });
+  logger13.debug("Generated query hash for find", { queryHash, finder, params, locations });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger12.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
+    logger13.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -1172,7 +1301,7 @@ var find = async (finder, params = {}, locations = [], context) => {
     if (allItemsAvailable) {
       return [context, validatePK9(cachedItems, pkType)];
     } else {
-      logger12.debug("Some cached items missing, invalidating query cache");
+      logger13.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1189,7 +1318,7 @@ var find = async (finder, params = {}, locations = [], context) => {
   }
   const itemKeys = ret.map((item) => item.key);
   cacheMap.setQueryResult(queryHash, itemKeys);
-  logger12.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+  logger13.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
   const event = CacheEventFactory.createQueryEvent(params, locations, ret);
   eventEmitter.emit(event);
   return [context, validatePK9(ret, pkType)];
@@ -1199,31 +1328,31 @@ var find = async (finder, params = {}, locations = [], context) => {
 import {
   validatePK as validatePK10
 } from "@fjell/core";
-var logger13 = logger_default.get("findOne");
+var logger14 = logger_default.get("findOne");
 var findOne = async (finder, finderParams = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
-  logger13.default("findOne", { finder, finderParams, locations });
+  logger14.default("findOne", { finder, finderParams, locations });
   if (context.options?.bypassCache) {
-    logger13.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
+    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
     try {
       const ret2 = await api.findOne(finder, finderParams, locations);
-      logger13.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
+      logger14.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
       return [context, validatePK10(ret2, pkType)];
     } catch (error) {
-      logger13.error("API request failed", { finder, finderParams, locations, error });
+      logger14.error("API request failed", { finder, finderParams, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, finderParams, locations);
-  logger13.debug("Generated query hash for findOne", { queryHash });
+  logger14.debug("Generated query hash for findOne", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys && cachedItemKeys.length > 0) {
-    logger13.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const item = await cacheMap.get(cachedItemKeys[0]);
     if (item) {
       return [context, validatePK10(item, pkType)];
     } else {
-      logger13.debug("Cached item missing, invalidating query cache");
+      logger14.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1237,7 +1366,7 @@ var findOne = async (finder, finderParams = {}, locations = [], context) => {
     await cacheMap.delete(parsedKey);
   }
   cacheMap.setQueryResult(queryHash, [ret.key]);
-  logger13.debug("Cached query result", { queryHash, itemKey: ret.key });
+  logger14.debug("Cached query result", { queryHash, itemKey: ret.key });
   const event = CacheEventFactory.createQueryEvent(finderParams, locations, [ret]);
   eventEmitter.emit(event);
   return [context, validatePK10(ret, pkType)];
@@ -1249,7 +1378,7 @@ import {
   isValidItemKey as isValidItemKey6,
   validatePK as validatePK11
 } from "@fjell/core";
-var logger14 = logger_default.get("set");
+var logger15 = logger_default.get("set");
 var normalizeKeyValue2 = (value) => {
   return String(value);
 };
@@ -1299,14 +1428,14 @@ var normalizeKey = (key) => {
 };
 var set = async (key, v, context) => {
   const { cacheMap, pkType, ttlManager, evictionManager, eventEmitter } = context;
-  logger14.default("set", { key, v });
+  logger15.default("set", { key, v });
   if (!isValidItemKey6(key)) {
-    logger14.error("Key for Set is not a valid ItemKey: %j", key);
+    logger15.error("Key for Set is not a valid ItemKey: %j", key);
     throw new Error("Key for Set is not a valid ItemKey");
   }
   validatePK11(v, pkType);
   if (!isItemKeyEqualNormalized(key, v.key)) {
-    logger14.error("Key does not match item key: %j != %j", key, v.key);
+    logger15.error("Key does not match item key: %j != %j", key, v.key);
     throw new Error("Key does not match item key");
   }
   const previousItem = await cacheMap.get(key);
@@ -1350,7 +1479,7 @@ var CacheMap = class {
 };
 
 // src/memory/MemoryCacheMap.ts
-var logger15 = logger_default.get("MemoryCacheMap");
+var logger16 = logger_default.get("MemoryCacheMap");
 var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   implementationType = "memory/memory";
   map = {};
@@ -1368,13 +1497,13 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger15.error("Failed to parse initial data key", { keyStr, error });
+          logger16.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger15.trace("get", { key });
+    logger16.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -1389,7 +1518,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger15.trace("set", { key, value });
+    logger16.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const keyStr = JSON.stringify(key);
     this.map[hashedKey] = { originalKey: key, value };
@@ -1416,7 +1545,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
   }
   async delete(key) {
-    logger15.trace("delete", { key });
+    logger16.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -1445,10 +1574,10 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger15.debug("Returning all items, LocKeys is empty");
+      logger16.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger15.debug("allIn", { locations, count: allValues.length });
+      logger16.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey(key)) {
@@ -1460,12 +1589,12 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger15.debug("contains", { query, locations });
+    logger16.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch(item, query));
   }
   async queryIn(query, locations = []) {
-    logger15.debug("queryIn", { query, locations });
+    logger16.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch(item, query));
   }
@@ -1488,7 +1617,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger15.trace("setQueryResult", { queryHash, itemKeys });
+    logger16.trace("setQueryResult", { queryHash, itemKeys });
     const entry = {
       itemKeys: [...itemKeys]
       // Create a copy to avoid external mutations
@@ -1496,7 +1625,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     this.queryResultCache[queryHash] = entry;
   }
   async getQueryResult(queryHash) {
-    logger15.trace("getQueryResult", { queryHash });
+    logger16.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -1508,11 +1637,11 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry;
   }
   async deleteQueryResult(queryHash) {
-    logger15.trace("deleteQueryResult", { queryHash });
+    logger16.trace("deleteQueryResult", { queryHash });
     delete this.queryResultCache[queryHash];
   }
   async invalidateItemKeys(keys) {
-    logger15.debug("invalidateItemKeys", { keys });
+    logger16.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -1543,14 +1672,14 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       this.deleteQueryResult(queryHash);
     });
-    logger15.debug("Selectively invalidated queries referencing affected keys", {
+    logger16.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
     });
   }
   async invalidateLocation(locations) {
-    logger15.debug("invalidateLocation", { locations });
+    logger16.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -1563,7 +1692,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     await this.invalidateItemKeys(keysToInvalidate);
   }
   async clearQueryResults() {
-    logger15.trace("clearQueryResults");
+    logger16.trace("clearQueryResults");
     this.queryResultCache = {};
   }
   // CacheMapMetadataProvider implementation
@@ -1605,7 +1734,7 @@ import {
   isComKey as isComKey2,
   isQueryMatch as isQueryMatch2
 } from "@fjell/core";
-var logger16 = logger_default.get("EnhancedMemoryCacheMap");
+var logger17 = logger_default.get("EnhancedMemoryCacheMap");
 var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   implementationType = "memory/enhanced";
   map = {};
@@ -1624,11 +1753,11 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.normalizedHashFunction = createNormalizedHashFunction();
     if (sizeConfig?.maxSizeBytes) {
       this.maxSizeBytes = parseSizeString(sizeConfig.maxSizeBytes);
-      logger16.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
+      logger17.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
     }
     if (sizeConfig?.maxItems) {
       this.maxItems = sizeConfig.maxItems;
-      logger16.debug("Cache item limit set", { maxItems: this.maxItems });
+      logger17.debug("Cache item limit set", { maxItems: this.maxItems });
     }
     if (initialData) {
       for (const [keyStr, value] of Object.entries(initialData)) {
@@ -1636,13 +1765,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger16.error("Failed to parse initial data key", { keyStr, error });
+          logger17.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger16.trace("get", { key });
+    logger17.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey && entry.value !== null) {
@@ -1651,7 +1780,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger16.trace("set", { key, value });
+    logger17.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const estimatedSize = estimateValueSize(value);
     const existingEntry = this.map[hashedKey];
@@ -1662,7 +1791,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const oldValue = existingEntry.value;
       existingEntry.value = value;
       existingEntry.metadata.estimatedSize = estimatedSize;
-      logger16.trace("Updated existing cache entry", {
+      logger17.trace("Updated existing cache entry", {
         key: hashedKey,
         sizeDiff,
         currentSize: this.currentSizeBytes,
@@ -1683,7 +1812,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       };
       this.currentSizeBytes += estimatedSize;
       this.currentItemCount++;
-      logger16.trace("Added new cache entry", {
+      logger17.trace("Added new cache entry", {
         key: hashedKey,
         size: estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1700,14 +1829,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.deleteInternal(key, true, "filter");
   }
   deleteInternal(key, invalidateQueries = false, invalidationMode = "remove") {
-    logger16.trace("delete", { key });
+    logger17.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
       this.currentSizeBytes -= entry.metadata.estimatedSize;
       this.currentItemCount--;
       delete this.map[hashedKey];
-      logger16.trace("Deleted cache entry", {
+      logger17.trace("Deleted cache entry", {
         key: hashedKey,
         freedSize: entry.metadata.estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1729,7 +1858,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.value);
   }
   async clear() {
-    logger16.debug("Clearing cache", {
+    logger17.debug("Clearing cache", {
       itemsCleared: this.currentItemCount,
       bytesFreed: this.currentSizeBytes
     });
@@ -1740,10 +1869,10 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger16.debug("Returning all items, LocKeys is empty");
+      logger17.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger16.debug("allIn", { locations, count: allValues.length });
+      logger17.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey2(key)) {
@@ -1754,12 +1883,12 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger16.debug("contains", { query, locations });
+    logger17.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch2(item, query));
   }
   async queryIn(query, locations = []) {
-    logger16.debug("queryIn", { query, locations });
+    logger17.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch2(item, query));
   }
@@ -1805,7 +1934,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   }
   // Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger16.trace("setQueryResult", { queryHash, itemKeys });
+    logger17.trace("setQueryResult", { queryHash, itemKeys });
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
     }
@@ -1817,7 +1946,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.addQueryResultToSizeTracking(queryHash, entry);
   }
   async getQueryResult(queryHash) {
-    logger16.trace("getQueryResult", { queryHash });
+    logger17.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -1839,7 +1968,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.queryResultsCacheSize = 0;
   }
   async invalidateItemKeys(keys) {
-    logger16.debug("invalidateItemKeys", { keys });
+    logger17.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -1889,7 +2018,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     });
   }
   async invalidateLocation(locations) {
-    logger16.debug("invalidateLocation", { locations });
+    logger17.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -1909,7 +2038,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     const itemKeysSize = estimateValueSize(entry.itemKeys);
     const totalSize = hashSize + itemKeysSize;
     this.queryResultsCacheSize += totalSize;
-    logger16.trace("Added query result to size tracking", {
+    logger17.trace("Added query result to size tracking", {
       queryHash,
       estimatedSize: totalSize,
       totalQueryCacheSize: this.queryResultsCacheSize
@@ -1925,7 +2054,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const itemKeysSize = estimateValueSize(entry.itemKeys);
       const totalSize = hashSize + itemKeysSize;
       this.queryResultsCacheSize = Math.max(0, this.queryResultsCacheSize - totalSize);
-      logger16.trace("Removed query result from size tracking", {
+      logger17.trace("Removed query result from size tracking", {
         queryHash,
         estimatedSize: totalSize,
         totalQueryCacheSize: this.queryResultsCacheSize
@@ -2010,7 +2139,7 @@ import {
   isComKey as isComKey3,
   isQueryMatch as isQueryMatch3
 } from "@fjell/core";
-var logger17 = logger_default.get("LocalStorageCacheMap");
+var logger18 = logger_default.get("LocalStorageCacheMap");
 var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
   implementationType = "browser/localStorage";
   keyPrefix;
@@ -2041,7 +2170,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return keys;
     } catch (error) {
-      logger17.error("Error getting keys by prefix from localStorage", { prefix, error });
+      logger18.error("Error getting keys by prefix from localStorage", { prefix, error });
       throw error;
     }
   }
@@ -2049,12 +2178,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       const allEntries = this.collectCacheEntries();
       if (allEntries.length === 0) {
-        logger17.debug("No entries to clean up");
+        logger18.debug("No entries to clean up");
         return false;
       }
       return this.removeOldestEntries(allEntries, aggressive);
     } catch (error) {
-      logger17.error("Failed to cleanup old localStorage entries", { error });
+      logger18.error("Failed to cleanup old localStorage entries", { error });
       return false;
     }
   }
@@ -2080,7 +2209,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           }
         }
       } catch (error) {
-        logger17.debug("Found corrupted entry during cleanup", { key, error });
+        logger18.debug("Found corrupted entry during cleanup", { key, error });
         allEntries.push({ key, timestamp: 0, size: 0 });
       }
     }
@@ -2099,12 +2228,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         removedCount++;
         removedSize += allEntries[i].size;
       } catch (error) {
-        logger17.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
+        logger18.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
       }
     }
     if (removedCount > 0) {
       const cleanupType = aggressive ? "aggressive" : "normal";
-      logger17.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
+      logger18.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
     }
     return removedCount > 0;
   }
@@ -2112,7 +2241,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     return this.getAllKeysStartingWith(`${this.keyPrefix}:`);
   }
   async get(key) {
-    logger17.trace("get", { key });
+    logger18.trace("get", { key });
     try {
       const storageKey = this.getStorageKey(key);
       let stored = localStorage.getItem(storageKey);
@@ -2127,18 +2256,18 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             return parsed.value;
           }
         } catch (parseError) {
-          logger17.debug("Failed to parse stored value", { key, error: parseError });
+          logger18.debug("Failed to parse stored value", { key, error: parseError });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger17.error("Error retrieving from localStorage", { key, error });
+      logger18.error("Error retrieving from localStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
-    logger17.trace("set", { key, value });
+    logger18.trace("set", { key, value });
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
         const storageKey = this.getStorageKey(key);
@@ -2149,12 +2278,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         };
         localStorage.setItem(storageKey, JSON.stringify(toStore));
         if (attempt > 0) {
-          logger17.info(`Successfully stored item after ${attempt} retries`);
+          logger18.info(`Successfully stored item after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger17.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger18.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           value,
           error,
@@ -2181,30 +2310,30 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           const parsed = JSON.parse(stored);
           return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
         } catch (parseError) {
-          logger17.debug("Failed to parse stored value in includesKey", { key, error: parseError });
+          logger18.debug("Failed to parse stored value in includesKey", { key, error: parseError });
           return false;
         }
       }
       return false;
     } catch (error) {
-      logger17.error("Error checking key in localStorage", { key, error });
+      logger18.error("Error checking key in localStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger17.trace("delete", { key });
+    logger18.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       localStorage.removeItem(storageKey);
     } catch (error) {
-      logger17.error("Error deleting from localStorage", { key, error });
+      logger18.error("Error deleting from localStorage", { key, error });
       throw error;
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger17.debug("Returning all items, LocKeys is empty");
+      logger18.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -2216,14 +2345,14 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger17.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger18.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey3(key)).filter((key) => {
-        const ComKey13 = key;
-        logger17.debug("Comparing Location Keys", {
+        const ComKey15 = key;
+        logger18.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey13
+          ComKey: ComKey15
         });
-        return isLocKeyArrayEqual(locKeys, ComKey13.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey15.loc);
       });
       const items = [];
       for (const key of filteredKeys) {
@@ -2236,12 +2365,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger17.debug("contains", { query, locations });
+    logger18.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch3(item, query));
   }
   async queryIn(query, locations = []) {
-    logger17.debug("queryIn", { query, locations });
+    logger18.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch3(item, query));
   }
@@ -2255,7 +2384,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         return JSON.parse(stored);
       }
     } catch (parseError) {
-      logger17.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
+      logger18.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
     }
     return null;
   }
@@ -2270,7 +2399,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger17.error("Error getting keys from localStorage", { error });
+      logger18.error("Error getting keys from localStorage", { error });
     }
     return keys;
   }
@@ -2285,25 +2414,25 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger17.error("Error getting values from localStorage", { error });
+      logger18.error("Error getting values from localStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger17.debug("Clearing localStorage cache");
+    logger18.debug("Clearing localStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         localStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger17.error("Error clearing localStorage cache", { error });
+      logger18.error("Error clearing localStorage cache", { error });
       throw error;
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger17.trace("setQueryResult", { queryHash, itemKeys });
+    logger18.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -2311,11 +2440,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       localStorage.setItem(queryKey, JSON.stringify(entry));
     } catch (error) {
-      logger17.error("Failed to store query result in localStorage", { queryHash, error });
+      logger18.error("Failed to store query result in localStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger17.trace("getQueryResult", { queryHash });
+    logger18.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = localStorage.getItem(queryKey);
@@ -2328,7 +2457,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger17.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      logger18.error("Failed to retrieve query result from localStorage", { queryHash, error });
       return null;
     }
   }
@@ -2337,21 +2466,21 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       return localStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger17.error("Failed to check query result in localStorage", { queryHash, error });
+      logger18.error("Failed to check query result in localStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger17.trace("deleteQueryResult", { queryHash });
+    logger18.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       localStorage.removeItem(queryKey);
     } catch (error) {
-      logger17.error("Failed to delete query result from localStorage", { queryHash, error });
+      logger18.error("Failed to delete query result from localStorage", { queryHash, error });
     }
   }
   async invalidateItemKeys(keys) {
-    logger17.debug("invalidateItemKeys", { keys });
+    logger18.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2389,24 +2518,24 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger17.debug("Failed to parse query result", { queryKey, error });
+          logger18.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         localStorage.removeItem(queryKey);
       });
-      logger17.debug("Selectively invalidated queries referencing affected keys", {
+      logger18.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.length
       });
     } catch (error) {
-      logger17.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger18.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger17.debug("invalidateLocation", { locations });
+    logger18.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2421,7 +2550,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async clearQueryResults() {
-    logger17.trace("clearQueryResults");
+    logger18.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = this.getAllKeysStartingWith(queryPrefix);
@@ -2429,11 +2558,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           localStorage.removeItem(key);
         } catch (error) {
-          logger17.error("Failed to remove query result from localStorage", { key, error });
+          logger18.error("Failed to remove query result from localStorage", { key, error });
         }
       }
     } catch (error) {
-      logger17.error("Failed to clear query results from localStorage", { error });
+      logger18.error("Failed to clear query results from localStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -2445,13 +2574,13 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           return JSON.parse(stored);
         } catch (e) {
-          logger17.debug("Invalid metadata JSON, treating as null", { key, error: e });
+          logger18.debug("Invalid metadata JSON, treating as null", { key, error: e });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger17.error("Error getting metadata from localStorage", { key, error });
+      logger18.error("Error getting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2461,12 +2590,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         const metadataKey = `${this.keyPrefix}:metadata:${key}`;
         localStorage.setItem(metadataKey, JSON.stringify(metadata));
         if (attempt > 0) {
-          logger17.info(`Successfully stored metadata after ${attempt} retries`);
+          logger18.info(`Successfully stored metadata after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger17.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger18.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           error,
           isLastAttempt
@@ -2488,7 +2617,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       localStorage.removeItem(metadataKey);
     } catch (error) {
-      logger17.error("Error deleting metadata from localStorage", { key, error });
+      logger18.error("Error deleting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2507,11 +2636,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             metadata.set(metadataKey, parsed);
           }
         } catch (error) {
-          logger17.debug("Skipping invalid metadata entry", { key, error });
+          logger18.debug("Skipping invalid metadata entry", { key, error });
         }
       }
     } catch (error) {
-      logger17.error("Error getting metadata from localStorage", { error });
+      logger18.error("Error getting metadata from localStorage", { error });
       throw error;
     }
     return metadata;
@@ -2522,7 +2651,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const keysToDelete = this.getAllKeysStartingWith(metadataPrefix);
       keysToDelete.forEach((key) => localStorage.removeItem(key));
     } catch (error) {
-      logger17.error("Error clearing metadata from localStorage", { error });
+      logger18.error("Error clearing metadata from localStorage", { error });
       throw error;
     }
   }
@@ -2549,16 +2678,16 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
                 itemCount++;
               }
             } catch (error) {
-              logger17.debug("Invalid entry in getCurrentSize", { key, error });
+              logger18.debug("Invalid entry in getCurrentSize", { key, error });
             }
           }
         } catch (error) {
-          logger17.debug("Size calculation failed, using string length", { key, error });
+          logger18.debug("Size calculation failed, using string length", { key, error });
           sizeBytes += value.length;
         }
       }
     } catch (error) {
-      logger17.error("Error calculating size from localStorage", { error });
+      logger18.error("Error calculating size from localStorage", { error });
       throw error;
     }
     return { itemCount, sizeBytes };
@@ -2579,7 +2708,7 @@ import {
   isQueryMatch as isQueryMatch4
 } from "@fjell/core";
 import safeStringify2 from "fast-safe-stringify";
-var logger18 = logger_default.get("SessionStorageCacheMap");
+var logger19 = logger_default.get("SessionStorageCacheMap");
 var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   implementationType = "browser/sessionStorage";
   keyPrefix;
@@ -2607,7 +2736,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger18.error("Error getting keys from sessionStorage", { error });
+      logger19.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2630,7 +2759,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async get(key) {
-    logger18.trace("get", { key });
+    logger19.trace("get", { key });
     try {
       const currentHash = this.normalizedHashFunction(key);
       if (this.hasCollisionForHash(currentHash)) {
@@ -2650,14 +2779,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return null;
     } catch (error) {
-      logger18.error("Error retrieving from sessionStorage", { key, error });
+      logger19.error("Error retrieving from sessionStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
     try {
       const storageKey = this.getStorageKey(key);
-      logger18.trace("set", { storageKey });
+      logger19.trace("set", { storageKey });
       const toStore = {
         originalKey: key,
         value,
@@ -2667,7 +2796,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(toStore);
       sessionStorage.setItem(storageKey, jsonString);
     } catch (error) {
-      logger18.error("Error storing to sessionStorage", { errorMessage: error?.message });
+      logger19.error("Error storing to sessionStorage", { errorMessage: error?.message });
       throw new Error(`Failed to store item in sessionStorage: ${error}`);
     }
   }
@@ -2688,23 +2817,23 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return false;
     } catch (error) {
-      logger18.error("Error checking key in sessionStorage", { key, error });
+      logger19.error("Error checking key in sessionStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger18.trace("delete", { key });
+    logger19.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       sessionStorage.removeItem(storageKey);
     } catch (error) {
-      logger18.error("Error deleting from sessionStorage", { key, error });
+      logger19.error("Error deleting from sessionStorage", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger18.debug("Returning all items, LocKeys is empty");
+      logger19.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -2716,14 +2845,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger18.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey4(key)).filter((key) => {
-        const ComKey13 = key;
-        logger18.debug("Comparing Location Keys", {
+        const ComKey15 = key;
+        logger19.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey13
+          ComKey: ComKey15
         });
-        return isLocKeyArrayEqual(locKeys, ComKey13.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey15.loc);
       });
       const items = [];
       for (const key of filteredKeys) {
@@ -2736,12 +2865,12 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger18.debug("contains", { query, locations });
+    logger19.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch4(item, query));
   }
   async queryIn(query, locations = []) {
-    logger18.debug("queryIn", { query, locations });
+    logger19.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch4(item, query));
   }
@@ -2761,11 +2890,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             keys.push(parsed.originalKey);
           }
         } catch (itemError) {
-          logger18.trace("Skipping invalid storage item", { storageKey, error: itemError });
+          logger19.trace("Skipping invalid storage item", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger18.error("Error getting keys from sessionStorage", { error });
+      logger19.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2782,28 +2911,28 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             values.push(parsed.value);
           }
         } catch (itemError) {
-          logger18.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
+          logger19.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger18.error("Error getting values from sessionStorage", { error });
+      logger19.error("Error getting values from sessionStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger18.debug("Clearing sessionStorage cache");
+    logger19.debug("Clearing sessionStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         sessionStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger18.error("Error clearing sessionStorage cache", { error });
+      logger19.error("Error clearing sessionStorage cache", { error });
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger18.trace("setQueryResult", { queryHash, itemKeys });
+    logger19.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -2812,11 +2941,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(entry);
       sessionStorage.setItem(queryKey, jsonString);
     } catch (error) {
-      logger18.error("Failed to store query result in sessionStorage", { queryHash, error });
+      logger19.error("Failed to store query result in sessionStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger18.trace("getQueryResult", { queryHash });
+    logger19.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = sessionStorage.getItem(queryKey);
@@ -2829,7 +2958,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger18.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      logger19.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
       return null;
     }
   }
@@ -2838,21 +2967,21 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     try {
       return sessionStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger18.error("Failed to check query result in sessionStorage", { queryHash, error });
+      logger19.error("Failed to check query result in sessionStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger18.trace("deleteQueryResult", { queryHash });
+    logger19.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       sessionStorage.removeItem(queryKey);
     } catch (error) {
-      logger18.error("Failed to delete query result from sessionStorage", { queryHash, error });
+      logger19.error("Failed to delete query result from sessionStorage", { queryHash, error });
     }
   }
   async clearQueryResults() {
-    logger18.trace("clearQueryResults");
+    logger19.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = [];
@@ -2864,7 +2993,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       keysToRemove.forEach((key) => sessionStorage.removeItem(key));
     } catch (error) {
-      logger18.error("Failed to clear query results from sessionStorage", { error });
+      logger19.error("Failed to clear query results from sessionStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -2911,7 +3040,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return metadata;
     } catch (error) {
-      logger18.error("Error getting all metadata from sessionStorage", { error });
+      logger19.error("Error getting all metadata from sessionStorage", { error });
       return metadata;
     }
   }
@@ -2931,7 +3060,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger18.debug("invalidateItemKeys", { keys });
+    logger19.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2975,24 +3104,24 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger18.debug("Failed to parse query result", { queryKey, error });
+          logger19.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         sessionStorage.removeItem(queryKey);
       });
-      logger18.debug("Selectively invalidated queries referencing affected keys", {
+      logger19.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.length
       });
     } catch (error) {
-      logger18.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger19.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger18.debug("invalidateLocation", { locations });
+    logger19.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -3058,7 +3187,7 @@ import {
   isQueryMatch as isQueryMatch5
 } from "@fjell/core";
 import safeStringify3 from "fast-safe-stringify";
-var logger19 = logger_default.get("AsyncIndexDBCacheMap");
+var logger20 = logger_default.get("AsyncIndexDBCacheMap");
 var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   types;
   dbName;
@@ -3084,19 +3213,19 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         }
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger19.error("Error opening IndexedDB", { error: request.error });
+          logger20.error("Error opening IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
-          logger19.debug("IndexedDB opened successfully");
+          logger20.debug("IndexedDB opened successfully");
           resolve(request.result);
         };
         request.onupgradeneeded = (event) => {
-          logger19.debug("IndexedDB upgrade needed");
+          logger20.debug("IndexedDB upgrade needed");
           const db = event.target.result;
           if (!db.objectStoreNames.contains(this.storeName)) {
             db.createObjectStore(this.storeName);
-            logger19.debug("Created object store", { storeName: this.storeName });
+            logger20.debug("Created object store", { storeName: this.storeName });
           }
         };
       });
@@ -3107,7 +3236,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     return this.normalizedHashFunction(key);
   }
   async get(key) {
-    logger19.trace("get", { key });
+    logger20.trace("get", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3116,7 +3245,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger19.error("Error getting from IndexedDB", { key, error: request.error });
+          logger20.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3129,7 +3258,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB get operation", { key, error });
+      logger20.error("Error in IndexedDB get operation", { key, error });
       return null;
     }
   }
@@ -3137,7 +3266,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Get both the value and metadata for an item
    */
   async getWithMetadata(key) {
-    logger19.trace("getWithMetadata", { key });
+    logger20.trace("getWithMetadata", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3146,7 +3275,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger19.error("Error getting from IndexedDB", { key, error: request.error });
+          logger20.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3162,12 +3291,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB getWithMetadata operation", { key, error });
+      logger20.error("Error in IndexedDB getWithMetadata operation", { key, error });
       return null;
     }
   }
   async set(key, value, metadata) {
-    logger19.trace("set", { key, value, hasMetadata: !!metadata });
+    logger20.trace("set", { key, value, hasMetadata: !!metadata });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3182,7 +3311,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.put(storedItem, storageKey);
         request.onerror = () => {
-          logger19.error("Error setting in IndexedDB", { key, value, error: request.error });
+          logger20.error("Error setting in IndexedDB", { key, value, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3190,7 +3319,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB set operation", { key, value, error });
+      logger20.error("Error in IndexedDB set operation", { key, value, error });
       throw new Error(`Failed to store item in IndexedDB: ${error}`);
     }
   }
@@ -3198,16 +3327,16 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Update only the metadata for an existing item
    */
   async setMetadata(key, metadata) {
-    logger19.trace("setMetadata", { key, metadata });
+    logger20.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 });
+        logger20.warning("Attempted to set metadata for non-existent item", { key });
       }
     } catch (error) {
-      logger19.error("Error in IndexedDB setMetadata operation", { key, error });
+      logger20.error("Error in IndexedDB setMetadata operation", { key, error });
       throw new Error(`Failed to update metadata in IndexedDB: ${error}`);
     }
   }
@@ -3220,7 +3349,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger19.error("Error checking key in IndexedDB", { key, error: request.error });
+          logger20.error("Error checking key in IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3234,12 +3363,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB includesKey operation", { key, error });
+      logger20.error("Error in IndexedDB includesKey operation", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger19.trace("delete", { key });
+    logger20.trace("delete", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3248,7 +3377,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.delete(storageKey);
         request.onerror = () => {
-          logger19.error("Error deleting from IndexedDB", { key, error: request.error });
+          logger20.error("Error deleting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3256,26 +3385,26 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB delete operation", { key, error });
+      logger20.error("Error in IndexedDB delete operation", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = await this.keys();
     if (locations.length === 0) {
-      logger19.debug("Returning all items, LocKeys is empty");
+      logger20.debug("Returning all items, LocKeys is empty");
       const promises = allKeys.map((key) => this.get(key));
       const results = await Promise.all(promises);
       return results.filter((item) => item !== null);
     } else {
       const locKeys = locations;
-      logger19.debug("allIn", { locKeys, keys: allKeys.length });
+      logger20.debug("allIn", { locKeys, keys: allKeys.length });
       const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
-        const ComKey13 = key;
-        logger19.debug("Comparing Location Keys", {
+        const ComKey15 = key;
+        logger20.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey13
+          ComKey: ComKey15
         });
-        return isLocKeyArrayEqual(locKeys, ComKey13.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey15.loc);
       });
       const promises = filteredKeys.map((key) => this.get(key));
       const results = await Promise.all(promises);
@@ -3283,12 +3412,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async contains(query, locations) {
-    logger19.debug("contains", { query, locations });
+    logger20.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch5(item, query));
   }
   async queryIn(query, locations = []) {
-    logger19.debug("queryIn", { query, locations });
+    logger20.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch5(item, query));
   }
@@ -3304,7 +3433,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger19.error("Error getting keys from IndexedDB", { error: request.error });
+          logger20.error("Error getting keys from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3319,7 +3448,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB keys operation", { error });
+      logger20.error("Error in IndexedDB keys operation", { error });
       return [];
     }
   }
@@ -3335,7 +3464,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger19.error("Error getting metadata from IndexedDB", { error: request.error });
+          logger20.error("Error getting metadata from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3353,7 +3482,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB getAllMetadata operation", { error });
+      logger20.error("Error in IndexedDB getAllMetadata operation", { error });
       return metadataMap;
     }
   }
@@ -3366,7 +3495,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger19.error("Error getting values from IndexedDB", { error: request.error });
+          logger20.error("Error getting values from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3381,12 +3510,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB values operation", { error });
+      logger20.error("Error in IndexedDB values operation", { error });
       return [];
     }
   }
   async clear() {
-    logger19.debug("Clearing IndexedDB cache");
+    logger20.debug("Clearing IndexedDB cache");
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3394,7 +3523,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.clear();
         request.onerror = () => {
-          logger19.error("Error clearing IndexedDB cache", { error: request.error });
+          logger20.error("Error clearing IndexedDB cache", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3402,17 +3531,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in IndexedDB clear operation", { error });
+      logger20.error("Error in IndexedDB clear operation", { error });
     }
   }
   // Async Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger19.trace("setQueryResult", { queryHash, itemKeys });
+    logger20.trace("setQueryResult", { queryHash, itemKeys });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger19.error("Failed to open database for setQueryResult", { error: request.error });
+          logger20.error("Failed to open database for setQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3425,7 +3554,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const putRequest = store.put(safeStringify3(entry), queryKey);
           putRequest.onerror = () => {
-            logger19.error("Failed to store query result", { queryHash, error: putRequest.error });
+            logger20.error("Failed to store query result", { queryHash, error: putRequest.error });
             reject(putRequest.error);
           };
           putRequest.onsuccess = () => {
@@ -3434,17 +3563,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in setQueryResult", { queryHash, error });
+      logger20.error("Error in setQueryResult", { queryHash, error });
       throw error;
     }
   }
   async getQueryResult(queryHash) {
-    logger19.trace("getQueryResult", { queryHash });
+    logger20.trace("getQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger19.error("Failed to open database for getQueryResult", { error: request.error });
+          logger20.error("Failed to open database for getQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3454,7 +3583,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const getRequest = store.get(queryKey);
           getRequest.onerror = () => {
-            logger19.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
+            logger20.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
             reject(getRequest.error);
           };
           getRequest.onsuccess = () => {
@@ -3471,34 +3600,34 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               }
               resolve(entry.itemKeys || null);
             } catch (parseError) {
-              logger19.error("Failed to parse query result", { queryHash, error: parseError });
+              logger20.error("Failed to parse query result", { queryHash, error: parseError });
               resolve(null);
             }
           };
         };
       });
     } catch (error) {
-      logger19.error("Error in getQueryResult", { queryHash, error });
+      logger20.error("Error in getQueryResult", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
-    logger19.trace("hasQueryResult", { queryHash });
+    logger20.trace("hasQueryResult", { queryHash });
     try {
       const result = await this.getQueryResult(queryHash);
       return result !== null;
     } catch (error) {
-      logger19.error("Error in hasQueryResult", { queryHash, error });
+      logger20.error("Error in hasQueryResult", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger19.trace("deleteQueryResult", { queryHash });
+    logger20.trace("deleteQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger19.error("Failed to open database for deleteQueryResult", { error: request.error });
+          logger20.error("Failed to open database for deleteQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3508,7 +3637,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const deleteRequest = store.delete(queryKey);
           deleteRequest.onerror = () => {
-            logger19.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
+            logger20.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
             reject(deleteRequest.error);
           };
           deleteRequest.onsuccess = () => {
@@ -3517,12 +3646,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in deleteQueryResult", { queryHash, error });
+      logger20.error("Error in deleteQueryResult", { queryHash, error });
       throw error;
     }
   }
   async invalidateItemKeys(keys) {
-    logger19.debug("invalidateItemKeys", { keys });
+    logger20.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3559,7 +3688,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
                   queryResults2[queryHash] = itemKeys;
                 }
               } catch (error) {
-                logger19.debug("Failed to parse query result", { key: item.key, error });
+                logger20.debug("Failed to parse query result", { key: item.key, error });
               }
             }
           }
@@ -3587,18 +3716,18 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           });
         }
       }
-      logger19.debug("Selectively invalidated queries referencing affected keys", {
+      logger20.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: Object.keys(queryResults).length
       });
     } catch (error) {
-      logger19.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger20.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger19.debug("invalidateLocation", { locations });
+    logger20.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       await this.clearQueryResults();
@@ -3611,12 +3740,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async clearQueryResults() {
-    logger19.trace("clearQueryResults");
+    logger20.trace("clearQueryResults");
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger19.error("Failed to open database for clearQueryResults", { error: request.error });
+          logger20.error("Failed to open database for clearQueryResults", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3626,7 +3755,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const cursorRequest = store.openCursor();
           const keysToDelete = [];
           cursorRequest.onerror = () => {
-            logger19.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
+            logger20.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
             reject(cursorRequest.error);
           };
           cursorRequest.onsuccess = () => {
@@ -3647,7 +3776,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               keysToDelete.forEach((queryKey) => {
                 const deleteRequest = store.delete(queryKey);
                 deleteRequest.onerror = () => {
-                  logger19.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
+                  logger20.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
                   deletedCount++;
                   if (deletedCount === totalToDelete) {
                     resolve();
@@ -3665,14 +3794,14 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger19.error("Error in clearQueryResults", { error });
+      logger20.error("Error in clearQueryResults", { error });
       throw error;
     }
   }
 };
 
 // src/browser/IndexDBCacheMap.ts
-var logger20 = logger_default.get("IndexDBCacheMap");
+var logger21 = logger_default.get("IndexDBCacheMap");
 var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   implementationType = "browser/indexedDB";
   // Memory storage
@@ -3856,7 +3985,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger20.debug("invalidateItemKeys", { keys });
+    logger21.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3886,7 +4015,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       delete this.queryResultCache[queryHash];
     });
-    logger20.debug("Selectively invalidated queries referencing affected keys", {
+    logger21.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
@@ -4268,8 +4397,8 @@ var reset = async (coordinate, options) => {
 };
 
 // src/Operations.ts
-var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager) => {
-  const context = createCacheContext(api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager);
+var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) => {
+  const context = createCacheContext(api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry);
   return {
     all: (query, locations) => all(query, locations, context).then(([ctx, result]) => result),
     one: (query, locations) => one(query, locations, context).then(([ctx, result]) => result),
@@ -4278,8 +4407,8 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
     retrieve: (key) => retrieve(key, context).then(([ctx, result]) => result),
     remove: (key) => remove(key, context).then((ctx) => void 0),
     update: (key, item) => update(key, item, context).then(([ctx, result]) => result),
-    action: (key, actionName, body) => action(key, actionName, body, context).then(([ctx, result]) => result),
-    allAction: (actionName, body, locations) => allAction(actionName, body, locations, context).then(([ctx, result]) => result),
+    action: (key, actionName, body) => action(key, actionName, body, context).then(([ctx, result, affectedItems]) => [result, affectedItems]),
+    allAction: (actionName, body, locations) => allAction(actionName, body, locations, context).then(([ctx, result, affectedItems]) => [result, affectedItems]),
     facet: (key, facetName, params) => facet(key, facetName, params, context).then((result) => result),
     allFacet: (facetName, params, locations) => allFacet(facetName, params, locations, context).then((result) => result),
     find: (finder, params, locations) => find(finder, params, locations, context).then(([ctx, result]) => result),
@@ -4290,7 +4419,7 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
 };
 
 // src/eviction/EvictionManager.ts
-var logger21 = logger_default.get("EvictionManager");
+var logger22 = logger_default.get("EvictionManager");
 var EvictionManager = class {
   evictionStrategy;
   constructor(evictionStrategy) {
@@ -4302,7 +4431,7 @@ var EvictionManager = class {
    */
   setEvictionStrategy(strategy) {
     this.evictionStrategy = strategy;
-    logger21.debug("Eviction strategy updated", {
+    logger22.debug("Eviction strategy updated", {
       strategy: strategy?.getStrategyName() || "none"
     });
   }
@@ -4325,7 +4454,7 @@ var EvictionManager = class {
     try {
       await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger21.error("Error in eviction strategy onItemAccessed", { key, error });
+      logger22.error("Error in eviction strategy onItemAccessed", { key, error });
     }
   }
   /**
@@ -4350,14 +4479,14 @@ var EvictionManager = class {
       }
       await this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
       if (evictedKeys.length > 0) {
-        logger21.debug("Items evicted during addition", {
+        logger22.debug("Items evicted during addition", {
           newKey: key,
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger21.error("Error in eviction strategy onItemAdded", { key, error });
+      logger22.error("Error in eviction strategy onItemAdded", { key, error });
     }
     return evictedKeys;
   }
@@ -4373,7 +4502,7 @@ var EvictionManager = class {
     try {
       this.evictionStrategy.onItemRemoved(key, metadataProvider);
     } catch (error) {
-      logger21.error("Error in eviction strategy onItemRemoved", { key, error });
+      logger22.error("Error in eviction strategy onItemRemoved", { key, error });
     }
   }
   /**
@@ -4394,13 +4523,13 @@ var EvictionManager = class {
         evictedKeys.push(evictKey);
       }
       if (evictedKeys.length > 0) {
-        logger21.debug("Manual eviction performed", {
+        logger22.debug("Manual eviction performed", {
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger21.error("Error in manual eviction", { error });
+      logger22.error("Error in manual eviction", { error });
     }
     return evictedKeys;
   }
@@ -5747,7 +5876,7 @@ function createEvictionStrategy(policy, maxCacheSize, config) {
 }
 
 // src/ttl/TTLManager.ts
-var logger22 = logger_default.get("TTLManager");
+var logger23 = logger_default.get("TTLManager");
 var TTLManager = class {
   config;
   cleanupTimer;
@@ -5759,7 +5888,7 @@ var TTLManager = class {
       validateOnAccess: true,
       ...config
     };
-    logger22.debug("TTL_DEBUG: TTLManager created", {
+    logger23.debug("TTL_DEBUG: TTLManager created", {
       config: this.config,
       isTTLEnabled: this.isTTLEnabled(),
       defaultTTL: this.config.defaultTTL
@@ -5792,13 +5921,13 @@ var TTLManager = class {
         this.startAutoCleanup();
       }
     }
-    logger22.debug("TTL configuration updated", { config: this.config });
+    logger23.debug("TTL configuration updated", { config: this.config });
   }
   /**
    * Set TTL metadata for an item when it's added
    */
   async onItemAdded(key, metadataProvider, itemTTL) {
-    logger22.debug("TTL_DEBUG: onItemAdded called", {
+    logger23.debug("TTL_DEBUG: onItemAdded called", {
       key,
       itemTTL,
       isTTLEnabled: this.isTTLEnabled(),
@@ -5806,19 +5935,19 @@ var TTLManager = class {
       metadataProviderType: metadataProvider?.constructor?.name
     });
     if (!this.isTTLEnabled() && !itemTTL) {
-      logger22.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
+      logger23.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
       return;
     }
-    logger22.debug("TTL_DEBUG: Getting metadata for key", { key });
+    logger23.debug("TTL_DEBUG: Getting metadata for key", { key });
     const metadata = await metadataProvider.getMetadata(key);
-    logger22.debug("TTL_DEBUG: Retrieved metadata", {
+    logger23.debug("TTL_DEBUG: Retrieved metadata", {
       key,
       hasMetadata: !!metadata,
       metadataKeys: metadata ? Object.keys(metadata) : null,
       metadata
     });
     if (!metadata) {
-      logger22.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
+      logger23.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
         key,
         metadataProviderType: metadataProvider?.constructor?.name,
         metadataProviderMethods: metadataProvider ? Object.getOwnPropertyNames(Object.getPrototypeOf(metadataProvider)) : null
@@ -5826,7 +5955,7 @@ var TTLManager = class {
       return;
     }
     const ttl = itemTTL || this.config.defaultTTL;
-    logger22.debug("TTL_DEBUG: Calculated TTL value", {
+    logger23.debug("TTL_DEBUG: Calculated TTL value", {
       key,
       itemTTL,
       defaultTTL: this.config.defaultTTL,
@@ -5839,7 +5968,7 @@ var TTLManager = class {
         expiresAt: metadata.addedAt + ttl,
         ttl
       };
-      logger22.debug("TTL_DEBUG: Setting TTL metadata", {
+      logger23.debug("TTL_DEBUG: Setting TTL metadata", {
         key,
         ttl,
         addedAt: metadata.addedAt,
@@ -5847,9 +5976,9 @@ var TTLManager = class {
         ttlMetadata
       });
       await metadataProvider.setMetadata(key, ttlMetadata);
-      logger22.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+      logger23.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     } else {
-      logger22.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
+      logger23.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
     }
   }
   /**
@@ -5863,7 +5992,7 @@ var TTLManager = class {
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
     if (expired) {
-      logger22.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
+      logger23.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
     }
     return expired;
   }
@@ -5910,7 +6039,7 @@ var TTLManager = class {
       }
     }
     if (expiredKeys.length > 0) {
-      logger22.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
+      logger23.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
     }
     return expiredKeys;
   }
@@ -5938,7 +6067,7 @@ var TTLManager = class {
     }
     metadata.expiresAt += additionalTTL;
     await metadataProvider.setMetadata(key, metadata);
-    logger22.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
+    logger23.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
     return true;
   }
   /**
@@ -5960,7 +6089,7 @@ var TTLManager = class {
       ttl
     };
     await metadataProvider.setMetadata(key, ttlMetadata);
-    logger22.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+    logger23.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     return true;
   }
   /**
@@ -5972,9 +6101,9 @@ var TTLManager = class {
     }
     if (this.config.cleanupInterval) {
       this.cleanupTimer = setInterval(() => {
-        logger22.trace("Auto cleanup timer triggered");
+        logger23.trace("Auto cleanup timer triggered");
       }, this.config.cleanupInterval);
-      logger22.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
+      logger23.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
     }
   }
   /**
@@ -5984,7 +6113,7 @@ var TTLManager = class {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
-      logger22.debug("Auto cleanup stopped");
+      logger23.debug("Auto cleanup stopped");
     }
   }
   /**
@@ -5992,7 +6121,7 @@ var TTLManager = class {
    */
   destroy() {
     this.stopAutoCleanup();
-    logger22.debug("TTL manager destroyed");
+    logger23.debug("TTL manager destroyed");
   }
 };
 
@@ -6392,9 +6521,9 @@ var CacheStatsManager = class {
 };
 
 // src/Cache.ts
-var logger23 = logger_default.get("Cache");
+var logger24 = logger_default.get("Cache");
 var createCache = (api, coordinate, registry, options) => {
-  logger23.debug("createCache", { coordinate, registry, options });
+  logger24.debug("createCache", { coordinate, registry, options });
   const completeOptions = createOptions(options);
   const cacheMap = createCacheMap(coordinate.kta, completeOptions);
   const pkType = coordinate.kta[0];
@@ -6417,7 +6546,7 @@ var createCache = (api, coordinate, registry, options) => {
     validateOnAccess: true
   });
   const statsManager = new CacheStatsManager();
-  const operations = createOperations(api, coordinate, cacheMap, pkType, completeOptions, eventEmitter, ttlManager, evictionManager, statsManager);
+  const operations = createOperations(api, coordinate, cacheMap, pkType, completeOptions, eventEmitter, ttlManager, evictionManager, statsManager, registry);
   const cache = {
     coordinate,
     registry,
@@ -6469,18 +6598,18 @@ var createCache = (api, coordinate, registry, options) => {
   };
   return cache;
 };
-var isCache = (cache) => {
+var isCache2 = (cache) => {
   return cache !== null && typeof cache === "object" && "coordinate" in cache && "registry" in cache && "api" in cache && "cacheMap" in cache && "operations" in cache;
 };
 
 // src/InstanceFactory.ts
-var logger24 = logger_default.get("InstanceFactory");
+var logger25 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (api, options) => {
   const templateOptions = createOptions(options);
   validateOptions(templateOptions);
   return (coordinate, context) => {
     const instanceOptions = createOptions(options);
-    logger24.debug("Creating cache instance", {
+    logger25.debug("Creating cache instance", {
       coordinate,
       registry: context.registry,
       api,
@@ -6506,7 +6635,8 @@ var createInstanceFactory = (api, options) => {
       eventEmitter,
       ttlManager,
       evictionManager,
-      statsManager
+      statsManager,
+      context.registry
     );
     return {
       coordinate,
@@ -6546,9 +6676,9 @@ var createInstanceFactory = (api, options) => {
 };
 
 // src/Instance.ts
-var logger25 = logger_default.get("Instance");
+var logger26 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, api, options) => {
-  logger25.debug("createInstance", { coordinate, api, registry, options });
+  logger26.debug("createInstance", { coordinate, api, registry, options });
   return createCache(api, coordinate, registry, options);
 };
 var isInstance = (instance) => {
@@ -6556,7 +6686,7 @@ var isInstance = (instance) => {
 };
 
 // src/Aggregator.ts
-var logger26 = logger_default.get("ItemAggregator");
+var logger27 = logger_default.get("ItemAggregator");
 var toCacheConfig = (config) => {
   let cacheConfig;
   if (config.optional === void 0) {
@@ -6568,22 +6698,22 @@ var toCacheConfig = (config) => {
 };
 var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
   const populate = async (item) => {
-    logger26.default("populate", { item });
+    logger27.default("populate", { item });
     for (const key in aggregates) {
       await populateAggregate(key, item);
     }
     for (const key in events) {
       await populateEvent(key, item);
     }
-    logger26.default("populate done", { item });
+    logger27.default("populate done", { item });
     return item;
   };
   const populateAggregate = async (key, item) => {
-    logger26.default("populate aggregate key", { key });
+    logger27.default("populate aggregate key", { key });
     const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === void 0) {
       if (cacheConfig.optional === false) {
-        logger26.error("Item does not have refs an is not optional ", { item });
+        logger27.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)) {
@@ -6592,7 +6722,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else if (item.refs[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger26.error("Item does not have mandatory ref with key, not optional ", { key, item });
+        logger27.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)) {
@@ -6601,7 +6731,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else {
       const ref = item.refs[key];
-      logger26.default("AGG Retrieving Item in Populate", { key: ref });
+      logger27.default("AGG Retrieving Item in Populate", { key: ref });
       const newItem = await cacheConfig.cache.operations.retrieve(ref);
       if (newItem) {
         if (item.aggs === void 0) {
@@ -6615,25 +6745,25 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const populateEvent = async (key, item) => {
-    logger26.default("populate event key", { key });
+    logger27.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) {
-        logger26.error("Item does not have mandatory event with key", { key, item });
+        logger27.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) {
-        logger26.error(
+        logger27.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 }));
       }
-      logger26.default("EVENT Retrieving Item in Populate", { key: event.by });
+      logger27.default("EVENT Retrieving Item in Populate", { key: event.by });
       const newItem = await cacheConfig.cache.operations.retrieve(event.by);
       if (newItem) {
         event.agg = newItem;
@@ -6641,13 +6771,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const all2 = async (query = {}, locations = []) => {
-    logger26.default("all", { query, locations });
+    logger27.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 = []) => {
-    logger26.default("one", { query, locations });
+    logger27.default("one", { query, locations });
     const item = await cache.operations.one(query, locations);
     let populatedItem = null;
     if (item) {
@@ -6656,30 +6786,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger26.default("action", { key, action: action3, body });
-    const item = await cache.operations.action(key, action3, body);
+    logger27.default("action", { key, action: action3, body });
+    const [item, affectedItems] = await cache.operations.action(key, action3, body);
     const populatedItem = await populate(item);
-    return populatedItem;
+    return [populatedItem, affectedItems];
   };
   const allAction2 = async (action3, body = {}, locations = []) => {
-    logger26.default("action", { action: action3, body, locations });
-    const items = await cache.operations.allAction(action3, body, locations);
+    logger27.default("action", { action: action3, body, locations });
+    const [items, affectedItems] = await cache.operations.allAction(action3, body, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
-    return populatedItems;
+    return [populatedItems, affectedItems];
   };
   const allFacet2 = async (facet3, params = {}, locations = []) => {
-    logger26.default("allFacet", { facet: facet3, params, locations });
+    logger27.default("allFacet", { facet: facet3, params, locations });
     const response = await cache.operations.allFacet(facet3, params, locations);
     return response;
   };
   const create2 = async (v, locations = []) => {
-    logger26.default("create", { v, locations });
+    logger27.default("create", { v, locations });
     const item = await cache.operations.create(v, locations);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const get2 = async (key) => {
-    logger26.default("get", { key });
+    logger27.default("get", { key });
     const item = await cache.operations.get(key);
     let populatedItem = null;
     if (item) {
@@ -6688,7 +6818,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const retrieve2 = async (key) => {
-    logger26.default("retrieve", { key });
+    logger27.default("retrieve", { key });
     const item = await cache.operations.retrieve(key);
     let populatedItem = null;
     if (item) {
@@ -6697,34 +6827,34 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const remove2 = async (key) => {
-    logger26.default("remove", { key });
+    logger27.default("remove", { key });
     await cache.operations.remove(key);
   };
   const update2 = async (key, v) => {
-    logger26.default("update", { key, v });
+    logger27.default("update", { key, v });
     const item = await cache.operations.update(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const facet2 = async (key, facet3) => {
-    logger26.default("facet", { key, facet: facet3 });
+    logger27.default("facet", { key, facet: facet3 });
     const response = await cache.operations.facet(key, facet3);
     return response;
   };
   const find2 = async (finder, finderParams = {}, locations = []) => {
-    logger26.default("find", { finder, finderParams, locations });
+    logger27.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 = []) => {
-    logger26.default("find", { finder, finderParams, locations });
+    logger27.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) => {
-    logger26.default("set", { key, v });
+    logger27.default("set", { key, v });
     const item = await cache.operations.set(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
@@ -6776,13 +6906,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger27 = logger_default.get("Registry");
+var logger28 = 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}`);
     }
-    logger27.debug("Creating cache registry", { type, registryHub });
+    logger28.debug("Creating cache registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };
@@ -6820,7 +6950,7 @@ export {
   createValidatedConfig,
   estimateValueSize,
   formatBytes,
-  isCache,
+  isCache2 as isCache,
   isInstance,
   isLocKeyArrayEqual,
   normalizeKeyValue,