npm - @fjell/cache - Versions diffs - 4.7.14 → 4.7.16 - Mend

@fjell/cache 4.7.14 → 4.7.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +10 -0
package/dist/CacheContext.d.ts +4 -1
package/dist/CacheContext.d.ts.map +1 -1
package/dist/Operations.d.ts +4 -1
package/dist/Operations.d.ts.map +1 -1
package/dist/Options.d.ts.map +1 -1
package/dist/index.js +603 -315
package/dist/ops/action.d.ts.map +1 -1
package/dist/ops/allAction.d.ts.map +1 -1
package/dist/utils/cacheInvalidation.d.ts +18 -0
package/dist/utils/cacheInvalidation.d.ts.map +1 -0
package/package.json +8 -8

package/dist/index.js CHANGED Viewed

@@ -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
@@ -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,
@@ -1117,19 +1246,19 @@ var allAction = async (action2, body = {}, locations = [], context) => {
 };
 // 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
@@ -4009,13 +4138,15 @@ var createOptions = (cacheOptions) => {
       ...cacheOptions.memoryConfig.size
     } : DEFAULT_CACHE_OPTIONS.memoryConfig?.size
   } : { ...DEFAULT_CACHE_OPTIONS.memoryConfig };
-  return {
+  const result = {
     ...DEFAULT_CACHE_OPTIONS,
     ...cacheOptions,
     indexedDBConfig,
     webStorageConfig,
     memoryConfig
   };
+  validateOptions(result);
+  return result;
 };
 var createCacheMap = (kta, options) => {
   switch (options.cacheType) {
@@ -4058,6 +4189,76 @@ var createCacheMap = (kta, options) => {
   }
 };
 var validateOptions = (options) => {
+  const validProperties = /* @__PURE__ */ new Set([
+    // Core options
+    "cacheType",
+    "enableDebugLogging",
+    "autoSync",
+    "ttl",
+    "bypassCache",
+    "maxRetries",
+    "retryDelay",
+    // Config objects
+    "indexedDBConfig",
+    "webStorageConfig",
+    "memoryConfig",
+    "customCacheMapFactory",
+    "evictionConfig"
+  ]);
+  const unknownProperties = [];
+  const propertySuggestions = {
+    "byPassCache": ["bypassCache"],
+    "bypasscache": ["bypassCache"],
+    "bypass_cache": ["bypassCache"],
+    "cacheType": ["cacheType"],
+    "cachetype": ["cacheType"],
+    "cache_type": ["cacheType"],
+    "enableDebugLogging": ["enableDebugLogging"],
+    "enabledebuglogging": ["enableDebugLogging"],
+    "enable_debug_logging": ["enableDebugLogging"],
+    "autoSync": ["autoSync"],
+    "autosync": ["autoSync"],
+    "auto_sync": ["autoSync"],
+    "maxRetries": ["maxRetries"],
+    "maxretries": ["maxRetries"],
+    "max_retries": ["maxRetries"],
+    "retryDelay": ["retryDelay"],
+    "retrydelay": ["retryDelay"],
+    "retry_delay": ["retryDelay"],
+    "indexedDBConfig": ["indexedDBConfig"],
+    "indexeddbconfig": ["indexedDBConfig"],
+    "indexed_db_config": ["indexedDBConfig"],
+    "webStorageConfig": ["webStorageConfig"],
+    "webstorageconfig": ["webStorageConfig"],
+    "web_storage_config": ["webStorageConfig"],
+    "memoryConfig": ["memoryConfig"],
+    "memoryconfig": ["memoryConfig"],
+    "memory_config": ["memoryConfig"],
+    "customCacheMapFactory": ["customCacheMapFactory"],
+    "customcachemapfactory": ["customCacheMapFactory"],
+    "custom_cache_map_factory": ["customCacheMapFactory"],
+    "evictionConfig": ["evictionConfig"],
+    "evictionconfig": ["evictionConfig"],
+    "eviction_config": ["evictionConfig"]
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (!validProperties.has(key)) {
+      unknownProperties.push(key);
+    }
+  }
+  if (unknownProperties.length > 0) {
+    const suggestions = unknownProperties.map((prop) => {
+      const suggestion = propertySuggestions[prop];
+      if (suggestion) {
+        return `"${prop}" \u2192 "${suggestion[0]}"`;
+      }
+      return `"${prop}"`;
+    });
+    const errorMessage = `Unknown configuration properties detected: ${unknownProperties.join(", ")}.
+Valid properties are: ${Array.from(validProperties).join(", ")}.
+Did you mean: ${suggestions.join(", ")}?`;
+    throw new Error(errorMessage);
+  }
   if (options.cacheType === "custom" && !options.customCacheMapFactory) {
     throw new Error('customCacheMapFactory is required when cacheType is "custom"');
   }
@@ -4082,6 +4283,92 @@ var validateOptions = (options) => {
   if (options.indexedDBConfig?.size) {
     validateSizeConfig(options.indexedDBConfig.size);
   }
+  if (options.indexedDBConfig) {
+    const validIndexedDBProps = /* @__PURE__ */ new Set(["dbName", "version", "storeName", "size"]);
+    const unknownIndexedDBProps = Object.keys(options.indexedDBConfig).filter((key) => !validIndexedDBProps.has(key));
+    if (unknownIndexedDBProps.length > 0) {
+      const suggestions = unknownIndexedDBProps.map((prop) => {
+        const suggestion = {
+          "dbname": "dbName",
+          "db_name": "dbName",
+          "storename": "storeName",
+          "store_name": "storeName"
+        }[prop];
+        return suggestion ? `"${prop}" \u2192 "${suggestion}"` : `"${prop}"`;
+      });
+      throw new Error(`Unknown IndexedDB configuration properties: ${unknownIndexedDBProps.join(", ")}.
+Valid properties are: ${Array.from(validIndexedDBProps).join(", ")}.
+Did you mean: ${suggestions.join(", ")}?`);
+    }
+  }
+  if (options.webStorageConfig) {
+    const validWebStorageProps = /* @__PURE__ */ new Set(["keyPrefix", "compress", "size"]);
+    const unknownWebStorageProps = Object.keys(options.webStorageConfig).filter((key) => !validWebStorageProps.has(key));
+    if (unknownWebStorageProps.length > 0) {
+      const suggestions = unknownWebStorageProps.map((prop) => {
+        const suggestion = {
+          "keyprefix": "keyPrefix",
+          "key_prefix": "keyPrefix"
+        }[prop];
+        return suggestion ? `"${prop}" \u2192 "${suggestion}"` : `"${prop}"`;
+      });
+      throw new Error(`Unknown WebStorage configuration properties: ${unknownWebStorageProps.join(", ")}.
+Valid properties are: ${Array.from(validWebStorageProps).join(", ")}.
+Did you mean: ${suggestions.join(", ")}?`);
+    }
+  }
+  if (options.memoryConfig) {
+    const validMemoryProps = /* @__PURE__ */ new Set(["maxItems", "size"]);
+    const unknownMemoryProps = Object.keys(options.memoryConfig).filter((key) => !validMemoryProps.has(key));
+    if (unknownMemoryProps.length > 0) {
+      const suggestions = unknownMemoryProps.map((prop) => {
+        const suggestion = {
+          "maxitems": "maxItems",
+          "max_items": "maxItems"
+        }[prop];
+        return suggestion ? `"${prop}" \u2192 "${suggestion}"` : `"${prop}"`;
+      });
+      throw new Error(`Unknown Memory configuration properties: ${unknownMemoryProps.join(", ")}.
+Valid properties are: ${Array.from(validMemoryProps).join(", ")}.
+Did you mean: ${suggestions.join(", ")}?`);
+    }
+  }
+  if (options.evictionConfig) {
+    const validEvictionProps = /* @__PURE__ */ new Set(["type", "config"]);
+    const unknownEvictionProps = Object.keys(options.evictionConfig).filter((key) => !validEvictionProps.has(key));
+    if (unknownEvictionProps.length > 0) {
+      const suggestions = unknownEvictionProps.map((prop) => {
+        const suggestion = {
+          "evictionstrategy": "type",
+          "eviction_strategy": "type",
+          "evictionconfig": "config",
+          "eviction_config": "config"
+        }[prop];
+        return suggestion ? `"${prop}" \u2192 "${suggestion}"` : `"${prop}"`;
+      });
+      throw new Error(`Unknown Eviction configuration properties: ${unknownEvictionProps.join(", ")}.
+Valid properties are: ${Array.from(validEvictionProps).join(", ")}.
+Did you mean: ${suggestions.join(", ")}?`);
+    }
+    if (options.evictionConfig.type) {
+      const validTypes = /* @__PURE__ */ new Set(["lru", "lfu", "fifo", "mru", "random", "arc", "2q"]);
+      if (!validTypes.has(options.evictionConfig.type)) {
+        const suggestions = {
+          "LRU": "lru",
+          "LFU": "lfu",
+          "FIFO": "fifo",
+          "MRU": "mru",
+          "RANDOM": "random",
+          "ARC": "arc",
+          "2Q": "2q",
+          "twoqueue": "2q",
+          "two_queue": "2q"
+        }[options.evictionConfig.type];
+        const suggestionText = suggestions ? ` Did you mean "${suggestions}"?` : "";
+        throw new Error(`Invalid eviction strategy type: "${options.evictionConfig.type}". Valid types are: ${Array.from(validTypes).join(", ")}.${suggestionText}`);
+      }
+    }
+  }
   if (["localStorage", "sessionStorage"].includes(options.cacheType)) {
     const isRealBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement === "function";
     if (!isRealBrowser) {
@@ -4110,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),
@@ -4132,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) {
@@ -4144,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"
     });
   }
@@ -4167,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 });
     }
   }
   /**
@@ -4192,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;
   }
@@ -4215,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 });
     }
   }
   /**
@@ -4236,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;
   }
@@ -5589,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;
@@ -5601,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
@@ -5634,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(),
@@ -5648,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
@@ -5668,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,
@@ -5681,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,
@@ -5689,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 });
     }
   }
   /**
@@ -5705,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;
   }
@@ -5752,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;
   }
@@ -5780,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;
   }
   /**
@@ -5802,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;
   }
   /**
@@ -5814,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 });
     }
   }
   /**
@@ -5826,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");
     }
   }
   /**
@@ -5834,7 +6121,7 @@ var TTLManager = class {
    */
   destroy() {
     this.stopAutoCleanup();
-    logger22.debug("TTL manager destroyed");
+    logger23.debug("TTL manager destroyed");
   }
 };
@@ -6234,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];
@@ -6259,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,
@@ -6311,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,
@@ -6348,7 +6635,8 @@ var createInstanceFactory = (api, options) => {
       eventEmitter,
       ttlManager,
       evictionManager,
-      statsManager
+      statsManager,
+      context.registry
     );
     return {
       coordinate,
@@ -6388,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) => {
@@ -6398,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) {
@@ -6410,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)) {
@@ -6434,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)) {
@@ -6443,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) {
@@ -6457,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;
@@ -6483,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) {
@@ -6498,30 +6786,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger26.default("action", { key, action: action3, body });
+    logger27.default("action", { key, action: action3, body });
     const item = await cache.operations.action(key, action3, body);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const allAction2 = async (action3, body = {}, locations = []) => {
-    logger26.default("action", { action: action3, body, locations });
+    logger27.default("action", { action: action3, body, locations });
     const items = await cache.operations.allAction(action3, body, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const allFacet2 = async (facet3, params = {}, locations = []) => {
-    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) {
@@ -6530,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) {
@@ -6539,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;
@@ -6618,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;
   };
@@ -6662,7 +6950,7 @@ export {
   createValidatedConfig,
   estimateValueSize,
   formatBytes,
-  isCache,
+  isCache2 as isCache,
   isInstance,
   isLocKeyArrayEqual,
   normalizeKeyValue,