@fjell/cache 4.7.29 → 4.7.30

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/CacheContext.ts
-var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) => {
+var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry, coordinate) => {
   return {
     api,
     cacheMap,
@@ -9,7 +9,8 @@ var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManag
     ttlManager,
     evictionManager,
     statsManager,
-    registry
+    registry,
+    coordinate
   };
 };
 
@@ -313,27 +314,74 @@ import Logging from "@fjell/logging";
 var LibLogger = Logging.getLogger("@fjell/cache");
 var logger_default = LibLogger;
 
+// src/validation/LocationKeyValidator.ts
+var logger = logger_default.get("LocationKeyValidator");
+var validateLocations = (locations, coordinate, operation) => {
+  if (!locations || locations.length === 0) {
+    return;
+  }
+  const keyTypeArray = coordinate.kta;
+  const expectedLocationTypes = keyTypeArray.slice(1);
+  const actualLocationTypes = locations.map((loc) => loc.kt);
+  logger.debug(`Validating locations for ${operation}`, {
+    expected: expectedLocationTypes,
+    actual: actualLocationTypes,
+    coordinate: keyTypeArray
+  });
+  if (actualLocationTypes.length > expectedLocationTypes.length) {
+    logger.error("Location key array has too many elements", {
+      expected: expectedLocationTypes.length,
+      actual: actualLocationTypes.length,
+      expectedTypes: expectedLocationTypes,
+      actualTypes: actualLocationTypes,
+      coordinate,
+      operation
+    });
+    throw new Error(
+      `Invalid location key array for ${operation}: Expected at most ${expectedLocationTypes.length} location keys (hierarchy: [${expectedLocationTypes.join(", ")}]), but received ${actualLocationTypes.length} (types: [${actualLocationTypes.join(", ")}])`
+    );
+  }
+  for (let i = 0; i < actualLocationTypes.length; i++) {
+    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
+      logger.error("Location key array order mismatch", {
+        position: i,
+        expected: expectedLocationTypes[i],
+        actual: actualLocationTypes[i],
+        expectedHierarchy: expectedLocationTypes,
+        actualOrder: actualLocationTypes,
+        coordinate,
+        operation
+      });
+      throw new Error(
+        `Invalid location key array order for ${operation}: At position ${i}, expected key type "${expectedLocationTypes[i]}" but received "${actualLocationTypes[i]}". Location keys must be ordered according to the hierarchy: [${expectedLocationTypes.join(", ")}]. Received order: [${actualLocationTypes.join(", ")}]`
+      );
+    }
+  }
+  logger.debug(`Location key array validation passed for ${operation}`, { locations });
+};
+
 // src/ops/all.ts
-var logger = logger_default.get("all");
+var logger2 = logger_default.get("all");
 var all = async (query = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager } = context;
-  logger.default("all", { query, locations });
+  const { api, cacheMap, pkType, ttlManager, coordinate } = context;
+  logger2.default("all", { query, locations });
+  validateLocations(locations, coordinate, "all");
   if (context.options?.bypassCache) {
-    logger.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const ret2 = await api.all(query, locations);
-      logger.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret2.length });
+      logger2.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret2.length });
       return [context, validatePK(ret2, pkType)];
     } catch (error) {
-      logger.error("API request failed", { query, locations, error });
+      logger2.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger.debug("Generated query hash for all", { queryHash });
+  logger2.debug("Generated query hash for all", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -348,21 +396,21 @@ var all = async (query = {}, locations = [], context) => {
     if (allItemsAvailable) {
       return [context, validatePK(cachedItems, pkType)];
     } else {
-      logger.debug("Some cached items missing, invalidating query cache");
+      logger2.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
+      logger2.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
       const itemKeys = directCachedItems.map((item) => item.key);
       await cacheMap.setQueryResult(queryHash, itemKeys);
-      logger.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
+      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
       return [context, validatePK(directCachedItems, pkType)];
     }
   } catch (error) {
-    logger.debug("Error querying cache directly, proceeding to API", { error });
+    logger2.debug("Error querying cache directly, proceeding to API", { error });
   }
   let ret = [];
   try {
@@ -379,13 +427,13 @@ var all = async (query = {}, locations = [], context) => {
     }
     const itemKeys = ret.map((item) => item.key);
     cacheMap.setQueryResult(queryHash, itemKeys);
-    logger.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+    logger2.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
     const event = CacheEventFactory.createQueryEvent(query, locations, ret);
     context.eventEmitter.emit(event);
   } catch (e) {
     if (e instanceof NotFoundError) {
       cacheMap.setQueryResult(queryHash, []);
-      logger.debug("Cached empty query result for not found", { queryHash });
+      logger2.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
@@ -560,31 +608,32 @@ function validateSizeConfig(config) {
 }
 
 // src/ops/one.ts
-var logger2 = logger_default.get("one");
+var logger3 = logger_default.get("one");
 var one = async (query = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager } = context;
-  logger2.default("one", { query, locations });
+  const { api, cacheMap, pkType, ttlManager, coordinate } = context;
+  logger3.default("one", { query, locations });
+  validateLocations(locations, coordinate, "one");
   if (context.options?.bypassCache) {
-    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger3.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const retItem2 = await api.one(query, locations);
       if (retItem2) {
-        logger2.debug("API response received (not cached due to bypass)", { query, locations });
+        logger3.debug("API response received (not cached due to bypass)", { query, locations });
         return [context, validatePK2(retItem2, pkType)];
       } else {
-        logger2.debug("API returned null", { query, locations });
+        logger3.debug("API returned null", { query, locations });
         return [context, null];
       }
     } catch (error) {
-      logger2.error("API request failed", { query, locations, error });
+      logger3.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger2.debug("Generated query hash for one", { queryHash });
+  logger3.debug("Generated query hash for one", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger3.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     if (cachedItemKeys.length === 0) {
       return [context, null];
     }
@@ -592,21 +641,21 @@ var one = async (query = {}, locations = [], context) => {
     if (item) {
       return [context, validatePK2(item, pkType)];
     } else {
-      logger2.debug("Cached item missing, invalidating query cache");
+      logger3.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger2.debug("Found item directly in cache, skipping API call");
+      logger3.debug("Found item directly in cache, skipping API call");
       const foundItem = directCachedItems[0];
       await cacheMap.setQueryResult(queryHash, [foundItem.key]);
-      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
+      logger3.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
       return [context, validatePK2(foundItem, pkType)];
     }
   } catch (error) {
-    logger2.debug("Error querying cache directly, proceeding to API", { error });
+    logger3.debug("Error querying cache directly, proceeding to API", { error });
   }
   let retItem = null;
   try {
@@ -633,15 +682,15 @@ var one = async (query = {}, locations = [], context) => {
         await cacheMap.delete(parsedKey);
       }
       await cacheMap.setQueryResult(queryHash, [retItem.key]);
-      logger2.debug("Cached query result", { queryHash, itemKey: retItem.key });
+      logger3.debug("Cached query result", { queryHash, itemKey: retItem.key });
     } else {
       await cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result", { queryHash });
+      logger3.debug("Cached empty query result", { queryHash });
     }
   } catch (e) {
     if (e instanceof NotFoundError2) {
       cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result for not found", { queryHash });
+      logger3.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
@@ -656,10 +705,11 @@ var one = async (query = {}, locations = [], context) => {
 import {
   validatePK as validatePK3
 } from "@fjell/core";
-var logger3 = logger_default.get("create");
+var logger4 = logger_default.get("create");
 var create = async (v, locations = [], context) => {
-  const { api, cacheMap, pkType, eventEmitter, ttlManager, evictionManager } = context;
-  logger3.default("create", { v, locations });
+  const { api, cacheMap, pkType, eventEmitter, ttlManager, evictionManager, coordinate } = context;
+  logger4.default("create", { v, locations });
+  validateLocations(locations, coordinate, "create");
   const created = await api.create(v, locations);
   cacheMap.set(created.key, created);
   const keyStr = JSON.stringify(created.key);
@@ -687,7 +737,7 @@ import {
   isValidItemKey,
   validatePK as validatePK4
 } from "@fjell/core";
-var logger4 = logger_default.get("get");
+var logger5 = logger_default.get("get");
 var inFlightRequests = /* @__PURE__ */ new Map();
 var CLEANUP_TIMEOUT = 5 * 60 * 1e3;
 var cleanupStaleRequests = () => {
@@ -699,7 +749,7 @@ var cleanupStaleRequests = () => {
     }
   });
   keysToDelete.forEach((key) => {
-    logger4.debug("Cleaning up stale in-flight request", { key });
+    logger5.debug("Cleaning up stale in-flight request", { key });
     inFlightRequests.delete(key);
   });
 };
@@ -707,26 +757,26 @@ var cleanupInterval = setInterval(cleanupStaleRequests, 60 * 1e3);
 var keyToString = createNormalizedHashFunction();
 var get = async (key, context) => {
   const { api, cacheMap, pkType, ttlManager, statsManager } = context;
-  logger4.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
+  logger5.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
   statsManager.incrementRequests();
   if (!isValidItemKey(key)) {
-    logger4.error("Key for Get is not a valid ItemKey: %j", key);
+    logger5.error("Key for Get is not a valid ItemKey: %j", key);
     throw new Error("Key for Get is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger4.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
     statsManager.incrementMisses();
     try {
       const ret2 = await api.get(key);
       if (ret2) {
-        logger4.debug("API response received (not cached due to bypass)", { key });
+        logger5.debug("API response received (not cached due to bypass)", { key });
         return [context, validatePK4(ret2, pkType)];
       } else {
-        logger4.debug("API returned null", { key });
+        logger5.debug("API returned null", { key });
         return [context, null];
       }
     } catch (error) {
-      logger4.error("API request failed", { key, error });
+      logger5.error("API request failed", { key, error });
       throw error;
     }
   }
@@ -736,22 +786,22 @@ var get = async (key, context) => {
     if (cachedItem) {
       const isValid = await ttlManager.validateItem(keyStr2, cacheMap);
       if (isValid) {
-        logger4.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
+        logger5.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
         statsManager.incrementHits();
         return [context, validatePK4(cachedItem, pkType)];
       } else {
-        logger4.debug("Cache item expired, removing", { key });
+        logger5.debug("Cache item expired, removing", { key });
         cacheMap.delete(key);
         statsManager.incrementMisses();
       }
     } else {
       statsManager.incrementMisses();
     }
-    logger4.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
+    logger5.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
   } else {
     const cachedItem = await cacheMap.get(key);
     if (cachedItem) {
-      logger4.debug("Cache hit (TTL disabled)", { key });
+      logger5.debug("Cache hit (TTL disabled)", { key });
       statsManager.incrementHits();
       return [context, validatePK4(cachedItem, pkType)];
     } else {
@@ -776,7 +826,7 @@ var get = async (key, context) => {
         }
       }
     } else {
-      logger4.debug("Using in-flight request for key", { key });
+      logger5.debug("Using in-flight request for key", { key });
       apiRequest = requestEntry.promise;
     }
     ret = await apiRequest;
@@ -806,7 +856,7 @@ var get = async (key, context) => {
     }
   } catch (e) {
     inFlightRequests.delete(keyStr);
-    logger4.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+    logger5.error("Error getting item for key", { key, message: e.message, stack: e.stack });
     throw e;
   }
   return [
@@ -820,30 +870,30 @@ import {
   isValidItemKey as isValidItemKey2,
   validatePK as validatePK5
 } from "@fjell/core";
-var logger5 = logger_default.get("retrieve");
+var logger6 = logger_default.get("retrieve");
 var retrieve = async (key, context) => {
   const { cacheMap, pkType, statsManager } = context;
-  logger5.default("retrieve", { key });
+  logger6.default("retrieve", { key });
   statsManager.incrementRequests();
   if (!isValidItemKey2(key)) {
-    logger5.error("Key for Retrieve is not a valid ItemKey: %j", key);
+    logger6.error("Key for Retrieve is not a valid ItemKey: %j", key);
     throw new Error("Key for Retrieve is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger6.debug("Cache bypass enabled, fetching directly from API", { key });
     statsManager.incrementMisses();
     try {
       const { api } = context;
       const retrieved2 = await api.get(key);
       if (retrieved2) {
-        logger5.debug("API response received (not cached due to bypass)", { key });
+        logger6.debug("API response received (not cached due to bypass)", { key });
         return [null, validatePK5(retrieved2, pkType)];
       } else {
-        logger5.debug("API returned null", { key });
+        logger6.debug("API returned null", { key });
         return [null, null];
       }
     } catch (error) {
-      logger5.error("API request failed", { key, error });
+      logger6.error("API request failed", { key, error });
       throw error;
     }
   }
@@ -851,12 +901,12 @@ var retrieve = async (key, context) => {
   let retrieved;
   let contextToReturn;
   if (containsItemKey) {
-    logger5.default("Looking for Object in Cache", key);
+    logger6.default("Looking for Object in Cache", key);
     retrieved = await cacheMap.get(key);
     contextToReturn = null;
     statsManager.incrementHits();
   } else {
-    logger5.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    logger6.default("Object Not Found in Cache, Retrieving from Server API", { key });
     statsManager.incrementMisses();
     [contextToReturn, retrieved] = await get(key, context);
   }
@@ -871,12 +921,12 @@ var retrieve = async (key, context) => {
 import {
   isValidItemKey as isValidItemKey3
 } from "@fjell/core";
-var logger6 = logger_default.get("remove");
+var logger7 = logger_default.get("remove");
 var remove = async (key, context) => {
   const { api, cacheMap } = context;
-  logger6.default("remove", { key });
+  logger7.default("remove", { key });
   if (!isValidItemKey3(key)) {
-    logger6.error("Key for Remove is not a valid ItemKey: %j", key);
+    logger7.error("Key for Remove is not a valid ItemKey: %j", key);
     throw new Error("Key for Remove is not a valid ItemKey");
   }
   try {
@@ -895,9 +945,9 @@ var remove = async (key, context) => {
       { source: "operation", context: { operation: "remove" } }
     );
     context.eventEmitter.emit(queryInvalidatedEvent);
-    logger6.debug("Successfully removed item from API and cache", { key });
+    logger7.debug("Successfully removed item from API and cache", { key });
   } catch (e) {
-    logger6.error("Error deleting item", { error: e });
+    logger7.error("Error deleting item", { error: e });
     throw e;
   }
   return context;
@@ -908,21 +958,21 @@ import {
   isValidItemKey as isValidItemKey4,
   validatePK as validatePK6
 } from "@fjell/core";
-var logger7 = logger_default.get("update");
+var logger8 = logger_default.get("update");
 var update = async (key, v, context) => {
   const { api, cacheMap, pkType } = context;
-  logger7.default("update", { key, v });
+  logger8.default("update", { key, v });
   if (!isValidItemKey4(key)) {
-    logger7.error("Key for Update is not a valid ItemKey: %j", key);
+    logger8.error("Key for Update is not a valid ItemKey: %j", key);
     throw new Error("Key for Update is not a valid ItemKey");
   }
-  logger7.debug("Invalidating item key before update", { key });
+  logger8.debug("Invalidating item key before update", { key });
   cacheMap.invalidateItemKeys([key]);
   await cacheMap.clearQueryResults();
   try {
     const previousItem = await cacheMap.get(key);
     const updated = await api.update(key, v);
-    logger7.debug("Caching update result", { updatedKey: updated.key });
+    logger8.debug("Caching update result", { updatedKey: updated.key });
     await cacheMap.set(updated.key, updated);
     const cachedItem = await cacheMap.get(updated.key);
     const keyStr = JSON.stringify(updated.key);
@@ -955,7 +1005,7 @@ var update = async (key, v, context) => {
     context.eventEmitter.emit(queryInvalidatedEvent);
     return [context, validatePK6(updated, pkType)];
   } catch (e) {
-    logger7.error("Error updating item", { error: e });
+    logger8.error("Error updating item", { error: e });
     throw e;
   }
 };
@@ -968,7 +1018,7 @@ import {
 
 // src/utils/cacheInvalidation.ts
 import { toKeyTypeArray } from "@fjell/core";
-var logger8 = logger_default.get("cache", "utils", "cacheInvalidation");
+var logger9 = logger_default.get("cache", "utils", "cacheInvalidation");
 var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   const keys = [];
   const keyTypeArrays = [];
@@ -985,7 +1035,7 @@ var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   return { keys, keyTypeArrays };
 };
 var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) => {
-  logger8.debug("Invalidating caches by keys and key types", {
+  logger9.debug("Invalidating caches by keys and key types", {
     keysCount: keys.length,
     keyTypeArrays
   });
@@ -1003,22 +1053,22 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger8.debug("Found cache instance for targeted invalidation", {
+        logger9.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", {
+        logger9.debug("Successfully invalidated specific items in cache", {
           keyTypes,
           invalidatedCount: cacheKeys.length
         });
       } else {
-        logger8.debug("No cache instance found for key types", { keyTypes });
+        logger9.debug("No cache instance found for key types", { keyTypes });
       }
     } catch (error) {
-      logger8.warning("Failed to invalidate cache for key types", {
+      logger9.warning("Failed to invalidate cache for key types", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1028,12 +1078,12 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger8.debug("Handling location-based invalidation", { keyTypes });
+        logger9.debug("Handling location-based invalidation", { keyTypes });
         await cacheInstance.cacheMap.clearQueryResults();
-        logger8.debug("Successfully cleared query results for location", { keyTypes });
+        logger9.debug("Successfully cleared query results for location", { keyTypes });
       }
     } catch (error) {
-      logger8.warning("Failed to handle location-based invalidation", {
+      logger9.warning("Failed to handle location-based invalidation", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1044,7 +1094,7 @@ 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", {
+  logger9.debug("Handling action cache invalidation", {
     affectedItemsCount: affectedItems.length
   });
   const { keys, keyTypeArrays } = extractKeysAndKeyTypesFromActionResult(affectedItems);
@@ -1052,33 +1102,33 @@ var handleActionCacheInvalidation = async (registry, affectedItems) => {
 };
 
 // src/ops/action.ts
-var logger9 = logger_default.get("action");
+var logger10 = logger_default.get("action");
 var action = async (key, action2, body = {}, context) => {
   const { api, cacheMap, pkType, registry } = context;
-  logger9.default("action", { key, action: action2, body });
+  logger10.default("action", { key, action: action2, body });
   if (!isValidItemKey5(key)) {
-    logger9.error("Key for Action is not a valid ItemKey: %j", key);
+    logger10.error("Key for Action is not a valid ItemKey: %j", key);
     throw new Error("Key for Action is not a valid ItemKey");
   }
-  logger9.debug("Invalidating item key before action", { key });
+  logger10.debug("Invalidating item key before action", { key });
   cacheMap.invalidateItemKeys([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", {
+    logger10.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", {
+      logger10.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 });
+  logger10.debug("Caching action result", { updatedKey: updated.key });
   cacheMap.set(updated.key, updated);
   const keyStr = JSON.stringify(updated.key);
   context.ttlManager.onItemAdded(keyStr, cacheMap);
@@ -1088,19 +1138,19 @@ var action = async (key, action2, body = {}, context) => {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
     } catch (error) {
-      logger9.error("Failed to parse evicted key during deletion", {
+      logger10.error("Failed to parse evicted key during deletion", {
         evictedKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   }
-  logger9.debug("Emitting itemUpdated event after action", {
+  logger10.debug("Emitting itemUpdated event after action", {
     key: updated.key,
     action: action2
   });
   const itemEvent = CacheEventFactory.itemUpdated(updated.key, updated, null, "api");
   context.eventEmitter.emit(itemEvent);
-  logger9.debug("Emitting queryInvalidatedEvent after action", {
+  logger10.debug("Emitting queryInvalidatedEvent after action", {
     eventType: "query_invalidated",
     reason: "item_changed",
     action: action2
@@ -1120,10 +1170,11 @@ import {
   validatePK as validatePK8
 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
-var logger10 = logger_default.get("allAction");
+var logger11 = logger_default.get("allAction");
 var allAction = async (action2, body = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, eventEmitter, registry } = context;
-  logger10.default("allAction", { action: action2, body, locations });
+  const { api, cacheMap, pkType, eventEmitter, registry, coordinate } = context;
+  logger11.default("allAction", { action: action2, body, locations });
+  validateLocations(locations, coordinate, "allAction");
   const existingItems = [];
   if (locations && locations.length > 0) {
     try {
@@ -1132,10 +1183,10 @@ var allAction = async (action2, body = {}, locations = [], context) => {
         existingItems.push(...cachedItems);
       }
     } catch (error) {
-      logger10.debug("Could not retrieve existing items for comparison", { error });
+      logger11.debug("Could not retrieve existing items for comparison", { error });
     }
   }
-  logger10.debug("Invalidating location before allAction", { locations });
+  logger11.debug("Invalidating location before allAction", { locations });
   await cacheMap.invalidateLocation(locations);
   let ret = [];
   let affectedItems = [];
@@ -1145,7 +1196,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       ret = result[0];
       affectedItems = result[1];
     } else {
-      logger10.warning("Unexpected result format from allAction", {
+      logger11.warning("Unexpected result format from allAction", {
         resultType: typeof result,
         isArray: Array.isArray(result),
         resultLength: Array.isArray(result) ? result.length : "not array"
@@ -1154,19 +1205,19 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       affectedItems = [];
     }
     if (affectedItems && affectedItems.length > 0) {
-      logger10.debug("Handling cache invalidation for affected items", {
+      logger11.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", {
+        logger11.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 });
+    logger11.debug("Caching allAction results", { resultCount: ret.length });
     const modifiedItems = [];
     const newItems = [];
     for (const v of ret) {
@@ -1188,7 +1239,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       }
     }
     for (const item of modifiedItems) {
-      logger10.debug("Emitting item_updated event for modified item", { key: item.key });
+      logger11.debug("Emitting item_updated event for modified item", { key: item.key });
       const itemEvent = CacheEventFactory.itemUpdated(
         item.key,
         item,
@@ -1199,7 +1250,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       eventEmitter.emit(itemEvent);
     }
     for (const item of newItems) {
-      logger10.debug("Emitting item_created event for new item", { key: item.key });
+      logger11.debug("Emitting item_created event for new item", { key: item.key });
       const itemEvent = CacheEventFactory.itemCreated(
         item.key,
         item,
@@ -1209,14 +1260,14 @@ var allAction = async (action2, body = {}, locations = [], context) => {
     }
     if (modifiedItems.length > 0) {
       const modifiedKeys = modifiedItems.map((item) => item.key);
-      logger10.debug("Invalidating individual item keys for modified items", {
+      logger11.debug("Invalidating individual item keys for modified items", {
         keyCount: modifiedKeys.length,
         keys: modifiedKeys
       });
       await cacheMap.invalidateItemKeys(modifiedKeys);
     }
     await cacheMap.clearQueryResults();
-    logger10.debug("Emitting query_invalidated event after allAction", {
+    logger11.debug("Emitting query_invalidated event after allAction", {
       eventType: "query_invalidated",
       reason: "item_changed",
       action: action2,
@@ -1246,19 +1297,20 @@ var allAction = async (action2, body = {}, locations = [], context) => {
 };
 
 // src/ops/facet.ts
-var logger11 = logger_default.get("facet");
+var logger12 = logger_default.get("facet");
 var facet = async (key, facet2, params = {}, context) => {
   const { api } = context;
-  logger11.default("facet", { key, facet: facet2 });
+  logger12.default("facet", { key, facet: facet2 });
   const ret = await api.facet(key, facet2, params);
   return ret;
 };
 
 // src/ops/allFacet.ts
-var logger12 = logger_default.get("allFacet");
+var logger13 = logger_default.get("allFacet");
 var allFacet = async (facet2, params = {}, locations = [], context) => {
-  const { api } = context;
-  logger12.default("allFacet", { facet: facet2, params, locations });
+  const { api, coordinate } = context;
+  logger13.default("allFacet", { facet: facet2, params, locations });
+  validateLocations(locations, coordinate, "allFacet");
   const ret = await api.allFacet(facet2, params, locations);
   return ret;
 };
@@ -1267,26 +1319,27 @@ var allFacet = async (facet2, params = {}, locations = [], context) => {
 import {
   validatePK as validatePK9
 } from "@fjell/core";
-var logger13 = logger_default.get("find");
+var logger14 = logger_default.get("find");
 var find = async (finder, params = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
-  logger13.default("find", { finder, params, locations });
+  const { api, cacheMap, pkType, ttlManager, eventEmitter, coordinate } = context;
+  logger14.default("find", { finder, params, locations });
+  validateLocations(locations, coordinate, "find");
   if (context.options?.bypassCache) {
-    logger13.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
+    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
     try {
       const ret2 = await api.find(finder, params, locations);
-      logger13.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
+      logger14.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
       return [context, validatePK9(ret2, pkType)];
     } catch (error) {
-      logger13.error("API request failed", { finder, params, locations, error });
+      logger14.error("API request failed", { finder, params, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, params, locations);
-  logger13.debug("Generated query hash for find", { queryHash, finder, params, locations });
+  logger14.debug("Generated query hash for find", { queryHash, finder, params, locations });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger13.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
+    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -1301,7 +1354,7 @@ var find = async (finder, params = {}, locations = [], context) => {
     if (allItemsAvailable) {
       return [context, validatePK9(cachedItems, pkType)];
     } else {
-      logger13.debug("Some cached items missing, invalidating query cache");
+      logger14.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1318,7 +1371,7 @@ var find = async (finder, params = {}, locations = [], context) => {
   }
   const itemKeys = ret.map((item) => item.key);
   cacheMap.setQueryResult(queryHash, itemKeys);
-  logger13.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+  logger14.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
   const event = CacheEventFactory.createQueryEvent(params, locations, ret);
   eventEmitter.emit(event);
   return [context, validatePK9(ret, pkType)];
@@ -1328,31 +1381,32 @@ var find = async (finder, params = {}, locations = [], context) => {
 import {
   validatePK as validatePK10
 } from "@fjell/core";
-var logger14 = logger_default.get("findOne");
+var logger15 = logger_default.get("findOne");
 var findOne = async (finder, finderParams = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
-  logger14.default("findOne", { finder, finderParams, locations });
+  const { api, cacheMap, pkType, ttlManager, eventEmitter, coordinate } = context;
+  logger15.default("findOne", { finder, finderParams, locations });
+  validateLocations(locations, coordinate, "findOne");
   if (context.options?.bypassCache) {
-    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
+    logger15.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
     try {
       const ret2 = await api.findOne(finder, finderParams, locations);
-      logger14.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
+      logger15.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
       return [context, validatePK10(ret2, pkType)];
     } catch (error) {
-      logger14.error("API request failed", { finder, finderParams, locations, error });
+      logger15.error("API request failed", { finder, finderParams, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, finderParams, locations);
-  logger14.debug("Generated query hash for findOne", { queryHash });
+  logger15.debug("Generated query hash for findOne", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys && cachedItemKeys.length > 0) {
-    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger15.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const item = await cacheMap.get(cachedItemKeys[0]);
     if (item) {
       return [context, validatePK10(item, pkType)];
     } else {
-      logger14.debug("Cached item missing, invalidating query cache");
+      logger15.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1366,7 +1420,7 @@ var findOne = async (finder, finderParams = {}, locations = [], context) => {
     await cacheMap.delete(parsedKey);
   }
   cacheMap.setQueryResult(queryHash, [ret.key]);
-  logger14.debug("Cached query result", { queryHash, itemKey: ret.key });
+  logger15.debug("Cached query result", { queryHash, itemKey: ret.key });
   const event = CacheEventFactory.createQueryEvent(finderParams, locations, [ret]);
   eventEmitter.emit(event);
   return [context, validatePK10(ret, pkType)];
@@ -1378,7 +1432,7 @@ import {
   isValidItemKey as isValidItemKey6,
   validatePK as validatePK11
 } from "@fjell/core";
-var logger15 = logger_default.get("set");
+var logger16 = logger_default.get("set");
 var normalizeKeyValue2 = (value) => {
   return String(value);
 };
@@ -1428,14 +1482,14 @@ var normalizeKey = (key) => {
 };
 var set = async (key, v, context) => {
   const { cacheMap, pkType, ttlManager, evictionManager, eventEmitter } = context;
-  logger15.default("set", { key, v });
+  logger16.default("set", { key, v });
   if (!isValidItemKey6(key)) {
-    logger15.error("Key for Set is not a valid ItemKey: %j", key);
+    logger16.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)) {
-    logger15.error("Key does not match item key: %j != %j", key, v.key);
+    logger16.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);
@@ -1479,7 +1533,7 @@ var CacheMap = class {
 };
 
 // src/memory/MemoryCacheMap.ts
-var logger16 = logger_default.get("MemoryCacheMap");
+var logger17 = logger_default.get("MemoryCacheMap");
 var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   implementationType = "memory/memory";
   map = {};
@@ -1497,13 +1551,13 @@ var MemoryCacheMap = class _MemoryCacheMap 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) {
@@ -1518,7 +1572,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger16.trace("set", { key, value });
+    logger17.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const keyStr = JSON.stringify(key);
     this.map[hashedKey] = { originalKey: key, value };
@@ -1545,7 +1599,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
   }
   async delete(key) {
-    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) {
@@ -1574,10 +1628,10 @@ var MemoryCacheMap = class _MemoryCacheMap 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 && isComKey(key)) {
@@ -1589,12 +1643,12 @@ var MemoryCacheMap = class _MemoryCacheMap 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) => isQueryMatch(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) => isQueryMatch(item, query));
   }
@@ -1617,7 +1671,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger16.trace("setQueryResult", { queryHash, itemKeys });
+    logger17.trace("setQueryResult", { queryHash, itemKeys });
     const entry = {
       itemKeys: [...itemKeys]
       // Create a copy to avoid external mutations
@@ -1625,7 +1679,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     this.queryResultCache[queryHash] = entry;
   }
   async getQueryResult(queryHash) {
-    logger16.trace("getQueryResult", { queryHash });
+    logger17.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -1637,11 +1691,11 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry;
   }
   async deleteQueryResult(queryHash) {
-    logger16.trace("deleteQueryResult", { queryHash });
+    logger17.trace("deleteQueryResult", { queryHash });
     delete this.queryResultCache[queryHash];
   }
   async invalidateItemKeys(keys) {
-    logger16.debug("invalidateItemKeys", { keys });
+    logger17.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -1672,14 +1726,14 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       this.deleteQueryResult(queryHash);
     });
-    logger16.debug("Selectively invalidated queries referencing affected keys", {
+    logger17.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
     });
   }
   async invalidateLocation(locations) {
-    logger16.debug("invalidateLocation", { locations });
+    logger17.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -1692,7 +1746,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     await this.invalidateItemKeys(keysToInvalidate);
   }
   async clearQueryResults() {
-    logger16.trace("clearQueryResults");
+    logger17.trace("clearQueryResults");
     this.queryResultCache = {};
   }
   // CacheMapMetadataProvider implementation
@@ -1734,7 +1788,7 @@ import {
   isComKey as isComKey2,
   isQueryMatch as isQueryMatch2
 } from "@fjell/core";
-var logger17 = logger_default.get("EnhancedMemoryCacheMap");
+var logger18 = logger_default.get("EnhancedMemoryCacheMap");
 var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   implementationType = "memory/enhanced";
   map = {};
@@ -1753,11 +1807,11 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.normalizedHashFunction = createNormalizedHashFunction();
     if (sizeConfig?.maxSizeBytes) {
       this.maxSizeBytes = parseSizeString(sizeConfig.maxSizeBytes);
-      logger17.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
+      logger18.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
     }
     if (sizeConfig?.maxItems) {
       this.maxItems = sizeConfig.maxItems;
-      logger17.debug("Cache item limit set", { maxItems: this.maxItems });
+      logger18.debug("Cache item limit set", { maxItems: this.maxItems });
     }
     if (initialData) {
       for (const [keyStr, value] of Object.entries(initialData)) {
@@ -1765,13 +1819,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger17.error("Failed to parse initial data key", { keyStr, error });
+          logger18.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger17.trace("get", { key });
+    logger18.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey && entry.value !== null) {
@@ -1780,7 +1834,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger17.trace("set", { key, value });
+    logger18.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const estimatedSize = estimateValueSize(value);
     const existingEntry = this.map[hashedKey];
@@ -1791,7 +1845,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const oldValue = existingEntry.value;
       existingEntry.value = value;
       existingEntry.metadata.estimatedSize = estimatedSize;
-      logger17.trace("Updated existing cache entry", {
+      logger18.trace("Updated existing cache entry", {
         key: hashedKey,
         sizeDiff,
         currentSize: this.currentSizeBytes,
@@ -1812,7 +1866,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       };
       this.currentSizeBytes += estimatedSize;
       this.currentItemCount++;
-      logger17.trace("Added new cache entry", {
+      logger18.trace("Added new cache entry", {
         key: hashedKey,
         size: estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1829,14 +1883,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.deleteInternal(key, true, "filter");
   }
   deleteInternal(key, invalidateQueries = false, invalidationMode = "remove") {
-    logger17.trace("delete", { key });
+    logger18.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];
-      logger17.trace("Deleted cache entry", {
+      logger18.trace("Deleted cache entry", {
         key: hashedKey,
         freedSize: entry.metadata.estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1858,7 +1912,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.value);
   }
   async clear() {
-    logger17.debug("Clearing cache", {
+    logger18.debug("Clearing cache", {
       itemsCleared: this.currentItemCount,
       bytesFreed: this.currentSizeBytes
     });
@@ -1869,10 +1923,10 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger17.debug("Returning all items, LocKeys is empty");
+      logger18.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger17.debug("allIn", { locations, count: allValues.length });
+      logger18.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey2(key)) {
@@ -1883,12 +1937,12 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap 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) => isQueryMatch2(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) => isQueryMatch2(item, query));
   }
@@ -1934,7 +1988,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   }
   // Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger17.trace("setQueryResult", { queryHash, itemKeys });
+    logger18.trace("setQueryResult", { queryHash, itemKeys });
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
     }
@@ -1946,7 +2000,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.addQueryResultToSizeTracking(queryHash, entry);
   }
   async getQueryResult(queryHash) {
-    logger17.trace("getQueryResult", { queryHash });
+    logger18.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -1968,7 +2022,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.queryResultsCacheSize = 0;
   }
   async invalidateItemKeys(keys) {
-    logger17.debug("invalidateItemKeys", { keys });
+    logger18.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2018,7 +2072,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     });
   }
   async invalidateLocation(locations) {
-    logger17.debug("invalidateLocation", { locations });
+    logger18.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2038,7 +2092,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     const itemKeysSize = estimateValueSize(entry.itemKeys);
     const totalSize = hashSize + itemKeysSize;
     this.queryResultsCacheSize += totalSize;
-    logger17.trace("Added query result to size tracking", {
+    logger18.trace("Added query result to size tracking", {
       queryHash,
       estimatedSize: totalSize,
       totalQueryCacheSize: this.queryResultsCacheSize
@@ -2054,7 +2108,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const itemKeysSize = estimateValueSize(entry.itemKeys);
       const totalSize = hashSize + itemKeysSize;
       this.queryResultsCacheSize = Math.max(0, this.queryResultsCacheSize - totalSize);
-      logger17.trace("Removed query result from size tracking", {
+      logger18.trace("Removed query result from size tracking", {
         queryHash,
         estimatedSize: totalSize,
         totalQueryCacheSize: this.queryResultsCacheSize
@@ -2139,7 +2193,7 @@ import {
   isComKey as isComKey3,
   isQueryMatch as isQueryMatch3
 } from "@fjell/core";
-var logger18 = logger_default.get("LocalStorageCacheMap");
+var logger19 = logger_default.get("LocalStorageCacheMap");
 var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
   implementationType = "browser/localStorage";
   keyPrefix;
@@ -2170,7 +2224,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return keys;
     } catch (error) {
-      logger18.error("Error getting keys by prefix from localStorage", { prefix, error });
+      logger19.error("Error getting keys by prefix from localStorage", { prefix, error });
       throw error;
     }
   }
@@ -2178,12 +2232,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       const allEntries = this.collectCacheEntries();
       if (allEntries.length === 0) {
-        logger18.debug("No entries to clean up");
+        logger19.debug("No entries to clean up");
         return false;
       }
       return this.removeOldestEntries(allEntries, aggressive);
     } catch (error) {
-      logger18.error("Failed to cleanup old localStorage entries", { error });
+      logger19.error("Failed to cleanup old localStorage entries", { error });
       return false;
     }
   }
@@ -2209,7 +2263,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           }
         }
       } catch (error) {
-        logger18.debug("Found corrupted entry during cleanup", { key, error });
+        logger19.debug("Found corrupted entry during cleanup", { key, error });
         allEntries.push({ key, timestamp: 0, size: 0 });
       }
     }
@@ -2228,12 +2282,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         removedCount++;
         removedSize += allEntries[i].size;
       } catch (error) {
-        logger18.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
+        logger19.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
       }
     }
     if (removedCount > 0) {
       const cleanupType = aggressive ? "aggressive" : "normal";
-      logger18.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
+      logger19.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
     }
     return removedCount > 0;
   }
@@ -2241,7 +2295,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     return this.getAllKeysStartingWith(`${this.keyPrefix}:`);
   }
   async get(key) {
-    logger18.trace("get", { key });
+    logger19.trace("get", { key });
     try {
       const storageKey = this.getStorageKey(key);
       let stored = localStorage.getItem(storageKey);
@@ -2256,18 +2310,18 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             return parsed.value;
           }
         } catch (parseError) {
-          logger18.debug("Failed to parse stored value", { key, error: parseError });
+          logger19.debug("Failed to parse stored value", { key, error: parseError });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger18.error("Error retrieving from localStorage", { key, error });
+      logger19.error("Error retrieving from localStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
-    logger18.trace("set", { key, value });
+    logger19.trace("set", { key, value });
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
         const storageKey = this.getStorageKey(key);
@@ -2278,12 +2332,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         };
         localStorage.setItem(storageKey, JSON.stringify(toStore));
         if (attempt > 0) {
-          logger18.info(`Successfully stored item after ${attempt} retries`);
+          logger19.info(`Successfully stored item after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger18.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger19.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           value,
           error,
@@ -2310,30 +2364,30 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           const parsed = JSON.parse(stored);
           return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
         } catch (parseError) {
-          logger18.debug("Failed to parse stored value in includesKey", { key, error: parseError });
+          logger19.debug("Failed to parse stored value in includesKey", { key, error: parseError });
           return false;
         }
       }
       return false;
     } catch (error) {
-      logger18.error("Error checking key in localStorage", { key, error });
+      logger19.error("Error checking key in localStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger18.trace("delete", { key });
+    logger19.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       localStorage.removeItem(storageKey);
     } catch (error) {
-      logger18.error("Error deleting from localStorage", { key, error });
+      logger19.error("Error deleting from localStorage", { key, error });
       throw 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);
@@ -2345,10 +2399,10 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap 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 && isComKey3(key)).filter((key) => {
         const ComKey15 = key;
-        logger18.debug("Comparing Location Keys", {
+        logger19.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey15
         });
@@ -2365,12 +2419,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap 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) => isQueryMatch3(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) => isQueryMatch3(item, query));
   }
@@ -2384,7 +2438,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         return JSON.parse(stored);
       }
     } catch (parseError) {
-      logger18.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
+      logger19.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
     }
     return null;
   }
@@ -2399,7 +2453,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger18.error("Error getting keys from localStorage", { error });
+      logger19.error("Error getting keys from localStorage", { error });
     }
     return keys;
   }
@@ -2414,25 +2468,25 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger18.error("Error getting values from localStorage", { error });
+      logger19.error("Error getting values from localStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger18.debug("Clearing localStorage cache");
+    logger19.debug("Clearing localStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         localStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger18.error("Error clearing localStorage cache", { error });
+      logger19.error("Error clearing localStorage cache", { error });
       throw 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
@@ -2440,11 +2494,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       localStorage.setItem(queryKey, JSON.stringify(entry));
     } catch (error) {
-      logger18.error("Failed to store query result in localStorage", { queryHash, error });
+      logger19.error("Failed to store query result in localStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger18.trace("getQueryResult", { queryHash });
+    logger19.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = localStorage.getItem(queryKey);
@@ -2457,7 +2511,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger18.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      logger19.error("Failed to retrieve query result from localStorage", { queryHash, error });
       return null;
     }
   }
@@ -2466,21 +2520,21 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       return localStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger18.error("Failed to check query result in localStorage", { queryHash, error });
+      logger19.error("Failed to check query result in localStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger18.trace("deleteQueryResult", { queryHash });
+    logger19.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       localStorage.removeItem(queryKey);
     } catch (error) {
-      logger18.error("Failed to delete query result from localStorage", { queryHash, error });
+      logger19.error("Failed to delete query result from localStorage", { queryHash, error });
     }
   }
   async invalidateItemKeys(keys) {
-    logger18.debug("invalidateItemKeys", { keys });
+    logger19.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2518,24 +2572,24 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap 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) => {
         localStorage.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();
@@ -2550,7 +2604,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async clearQueryResults() {
-    logger18.trace("clearQueryResults");
+    logger19.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = this.getAllKeysStartingWith(queryPrefix);
@@ -2558,11 +2612,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           localStorage.removeItem(key);
         } catch (error) {
-          logger18.error("Failed to remove query result from localStorage", { key, error });
+          logger19.error("Failed to remove query result from localStorage", { key, error });
         }
       }
     } catch (error) {
-      logger18.error("Failed to clear query results from localStorage", { error });
+      logger19.error("Failed to clear query results from localStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -2574,13 +2628,13 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           return JSON.parse(stored);
         } catch (e) {
-          logger18.debug("Invalid metadata JSON, treating as null", { key, error: e });
+          logger19.debug("Invalid metadata JSON, treating as null", { key, error: e });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger18.error("Error getting metadata from localStorage", { key, error });
+      logger19.error("Error getting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2590,12 +2644,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         const metadataKey = `${this.keyPrefix}:metadata:${key}`;
         localStorage.setItem(metadataKey, JSON.stringify(metadata));
         if (attempt > 0) {
-          logger18.info(`Successfully stored metadata after ${attempt} retries`);
+          logger19.info(`Successfully stored metadata after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger18.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger19.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           error,
           isLastAttempt
@@ -2617,7 +2671,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       localStorage.removeItem(metadataKey);
     } catch (error) {
-      logger18.error("Error deleting metadata from localStorage", { key, error });
+      logger19.error("Error deleting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2636,11 +2690,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             metadata.set(metadataKey, parsed);
           }
         } catch (error) {
-          logger18.debug("Skipping invalid metadata entry", { key, error });
+          logger19.debug("Skipping invalid metadata entry", { key, error });
         }
       }
     } catch (error) {
-      logger18.error("Error getting metadata from localStorage", { error });
+      logger19.error("Error getting metadata from localStorage", { error });
       throw error;
     }
     return metadata;
@@ -2651,7 +2705,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const keysToDelete = this.getAllKeysStartingWith(metadataPrefix);
       keysToDelete.forEach((key) => localStorage.removeItem(key));
     } catch (error) {
-      logger18.error("Error clearing metadata from localStorage", { error });
+      logger19.error("Error clearing metadata from localStorage", { error });
       throw error;
     }
   }
@@ -2678,16 +2732,16 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
                 itemCount++;
               }
             } catch (error) {
-              logger18.debug("Invalid entry in getCurrentSize", { key, error });
+              logger19.debug("Invalid entry in getCurrentSize", { key, error });
             }
           }
         } catch (error) {
-          logger18.debug("Size calculation failed, using string length", { key, error });
+          logger19.debug("Size calculation failed, using string length", { key, error });
           sizeBytes += value.length;
         }
       }
     } catch (error) {
-      logger18.error("Error calculating size from localStorage", { error });
+      logger19.error("Error calculating size from localStorage", { error });
       throw error;
     }
     return { itemCount, sizeBytes };
@@ -2708,7 +2762,7 @@ import {
   isQueryMatch as isQueryMatch4
 } from "@fjell/core";
 import safeStringify2 from "fast-safe-stringify";
-var logger19 = logger_default.get("SessionStorageCacheMap");
+var logger20 = logger_default.get("SessionStorageCacheMap");
 var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   implementationType = "browser/sessionStorage";
   keyPrefix;
@@ -2736,7 +2790,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger19.error("Error getting keys from sessionStorage", { error });
+      logger20.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2759,7 +2813,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async get(key) {
-    logger19.trace("get", { key });
+    logger20.trace("get", { key });
     try {
       const currentHash = this.normalizedHashFunction(key);
       if (this.hasCollisionForHash(currentHash)) {
@@ -2779,14 +2833,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return null;
     } catch (error) {
-      logger19.error("Error retrieving from sessionStorage", { key, error });
+      logger20.error("Error retrieving from sessionStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
     try {
       const storageKey = this.getStorageKey(key);
-      logger19.trace("set", { storageKey });
+      logger20.trace("set", { storageKey });
       const toStore = {
         originalKey: key,
         value,
@@ -2796,7 +2850,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(toStore);
       sessionStorage.setItem(storageKey, jsonString);
     } catch (error) {
-      logger19.error("Error storing to sessionStorage", { errorMessage: error?.message });
+      logger20.error("Error storing to sessionStorage", { errorMessage: error?.message });
       throw new Error(`Failed to store item in sessionStorage: ${error}`);
     }
   }
@@ -2817,23 +2871,23 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return false;
     } catch (error) {
-      logger19.error("Error checking key in sessionStorage", { key, error });
+      logger20.error("Error checking key in sessionStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger19.trace("delete", { key });
+    logger20.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       sessionStorage.removeItem(storageKey);
     } catch (error) {
-      logger19.error("Error deleting from sessionStorage", { key, error });
+      logger20.error("Error deleting from sessionStorage", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger19.debug("Returning all items, LocKeys is empty");
+      logger20.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -2845,10 +2899,10 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger20.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey4(key)).filter((key) => {
         const ComKey15 = key;
-        logger19.debug("Comparing Location Keys", {
+        logger20.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey15
         });
@@ -2865,12 +2919,12 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger19.debug("contains", { query, locations });
+    logger20.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch4(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) => isQueryMatch4(item, query));
   }
@@ -2890,11 +2944,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             keys.push(parsed.originalKey);
           }
         } catch (itemError) {
-          logger19.trace("Skipping invalid storage item", { storageKey, error: itemError });
+          logger20.trace("Skipping invalid storage item", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger19.error("Error getting keys from sessionStorage", { error });
+      logger20.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2911,28 +2965,28 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             values.push(parsed.value);
           }
         } catch (itemError) {
-          logger19.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
+          logger20.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger19.error("Error getting values from sessionStorage", { error });
+      logger20.error("Error getting values from sessionStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger19.debug("Clearing sessionStorage cache");
+    logger20.debug("Clearing sessionStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         sessionStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger19.error("Error clearing sessionStorage cache", { error });
+      logger20.error("Error clearing sessionStorage cache", { error });
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger19.trace("setQueryResult", { queryHash, itemKeys });
+    logger20.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -2941,11 +2995,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(entry);
       sessionStorage.setItem(queryKey, jsonString);
     } catch (error) {
-      logger19.error("Failed to store query result in sessionStorage", { queryHash, error });
+      logger20.error("Failed to store query result in sessionStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger19.trace("getQueryResult", { queryHash });
+    logger20.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = sessionStorage.getItem(queryKey);
@@ -2958,7 +3012,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger19.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      logger20.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
       return null;
     }
   }
@@ -2967,21 +3021,21 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     try {
       return sessionStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger19.error("Failed to check query result in sessionStorage", { queryHash, error });
+      logger20.error("Failed to check query result in sessionStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger19.trace("deleteQueryResult", { queryHash });
+    logger20.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       sessionStorage.removeItem(queryKey);
     } catch (error) {
-      logger19.error("Failed to delete query result from sessionStorage", { queryHash, error });
+      logger20.error("Failed to delete query result from sessionStorage", { queryHash, error });
     }
   }
   async clearQueryResults() {
-    logger19.trace("clearQueryResults");
+    logger20.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = [];
@@ -2993,7 +3047,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       keysToRemove.forEach((key) => sessionStorage.removeItem(key));
     } catch (error) {
-      logger19.error("Failed to clear query results from sessionStorage", { error });
+      logger20.error("Failed to clear query results from sessionStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -3040,7 +3094,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return metadata;
     } catch (error) {
-      logger19.error("Error getting all metadata from sessionStorage", { error });
+      logger20.error("Error getting all metadata from sessionStorage", { error });
       return metadata;
     }
   }
@@ -3060,7 +3114,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger19.debug("invalidateItemKeys", { keys });
+    logger20.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3104,24 +3158,24 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger19.debug("Failed to parse query result", { queryKey, error });
+          logger20.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         sessionStorage.removeItem(queryKey);
       });
-      logger19.debug("Selectively invalidated queries referencing affected keys", {
+      logger20.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.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) {
       const allKeys = await this.keys();
@@ -3187,7 +3241,7 @@ import {
   isQueryMatch as isQueryMatch5
 } from "@fjell/core";
 import safeStringify3 from "fast-safe-stringify";
-var logger20 = logger_default.get("AsyncIndexDBCacheMap");
+var logger21 = logger_default.get("AsyncIndexDBCacheMap");
 var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   types;
   dbName;
@@ -3213,19 +3267,19 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         }
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Error opening IndexedDB", { error: request.error });
+          logger21.error("Error opening IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
-          logger20.debug("IndexedDB opened successfully");
+          logger21.debug("IndexedDB opened successfully");
           resolve(request.result);
         };
         request.onupgradeneeded = (event) => {
-          logger20.debug("IndexedDB upgrade needed");
+          logger21.debug("IndexedDB upgrade needed");
           const db = event.target.result;
           if (!db.objectStoreNames.contains(this.storeName)) {
             db.createObjectStore(this.storeName);
-            logger20.debug("Created object store", { storeName: this.storeName });
+            logger21.debug("Created object store", { storeName: this.storeName });
           }
         };
       });
@@ -3236,7 +3290,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     return this.normalizedHashFunction(key);
   }
   async get(key) {
-    logger20.trace("get", { key });
+    logger21.trace("get", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3245,7 +3299,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger20.error("Error getting from IndexedDB", { key, error: request.error });
+          logger21.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3258,7 +3312,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB get operation", { key, error });
+      logger21.error("Error in IndexedDB get operation", { key, error });
       return null;
     }
   }
@@ -3266,7 +3320,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Get both the value and metadata for an item
    */
   async getWithMetadata(key) {
-    logger20.trace("getWithMetadata", { key });
+    logger21.trace("getWithMetadata", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3275,7 +3329,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger20.error("Error getting from IndexedDB", { key, error: request.error });
+          logger21.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3291,12 +3345,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB getWithMetadata operation", { key, error });
+      logger21.error("Error in IndexedDB getWithMetadata operation", { key, error });
       return null;
     }
   }
   async set(key, value, metadata) {
-    logger20.trace("set", { key, value, hasMetadata: !!metadata });
+    logger21.trace("set", { key, value, hasMetadata: !!metadata });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3311,7 +3365,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.put(storedItem, storageKey);
         request.onerror = () => {
-          logger20.error("Error setting in IndexedDB", { key, value, error: request.error });
+          logger21.error("Error setting in IndexedDB", { key, value, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3319,7 +3373,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB set operation", { key, value, error });
+      logger21.error("Error in IndexedDB set operation", { key, value, error });
       throw new Error(`Failed to store item in IndexedDB: ${error}`);
     }
   }
@@ -3327,16 +3381,16 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Update only the metadata for an existing item
    */
   async setMetadata(key, metadata) {
-    logger20.trace("setMetadata", { key, metadata });
+    logger21.trace("setMetadata", { key, metadata });
     try {
       const existing = await this.getWithMetadata(key);
       if (existing) {
         await this.set(key, existing.value, metadata);
       } else {
-        logger20.warning("Attempted to set metadata for non-existent item", { key });
+        logger21.warning("Attempted to set metadata for non-existent item", { key });
       }
     } catch (error) {
-      logger20.error("Error in IndexedDB setMetadata operation", { key, error });
+      logger21.error("Error in IndexedDB setMetadata operation", { key, error });
       throw new Error(`Failed to update metadata in IndexedDB: ${error}`);
     }
   }
@@ -3349,7 +3403,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger20.error("Error checking key in IndexedDB", { key, error: request.error });
+          logger21.error("Error checking key in IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3363,12 +3417,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB includesKey operation", { key, error });
+      logger21.error("Error in IndexedDB includesKey operation", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger20.trace("delete", { key });
+    logger21.trace("delete", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3377,7 +3431,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.delete(storageKey);
         request.onerror = () => {
-          logger20.error("Error deleting from IndexedDB", { key, error: request.error });
+          logger21.error("Error deleting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3385,22 +3439,22 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB delete operation", { key, error });
+      logger21.error("Error in IndexedDB delete operation", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = await this.keys();
     if (locations.length === 0) {
-      logger20.debug("Returning all items, LocKeys is empty");
+      logger21.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;
-      logger20.debug("allIn", { locKeys, keys: allKeys.length });
+      logger21.debug("allIn", { locKeys, keys: allKeys.length });
       const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
         const ComKey15 = key;
-        logger20.debug("Comparing Location Keys", {
+        logger21.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey15
         });
@@ -3412,12 +3466,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async contains(query, locations) {
-    logger20.debug("contains", { query, locations });
+    logger21.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch5(item, query));
   }
   async queryIn(query, locations = []) {
-    logger20.debug("queryIn", { query, locations });
+    logger21.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch5(item, query));
   }
@@ -3433,7 +3487,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger20.error("Error getting keys from IndexedDB", { error: request.error });
+          logger21.error("Error getting keys from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3448,7 +3502,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB keys operation", { error });
+      logger21.error("Error in IndexedDB keys operation", { error });
       return [];
     }
   }
@@ -3464,7 +3518,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger20.error("Error getting metadata from IndexedDB", { error: request.error });
+          logger21.error("Error getting metadata from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3482,7 +3536,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB getAllMetadata operation", { error });
+      logger21.error("Error in IndexedDB getAllMetadata operation", { error });
       return metadataMap;
     }
   }
@@ -3495,7 +3549,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger20.error("Error getting values from IndexedDB", { error: request.error });
+          logger21.error("Error getting values from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3510,12 +3564,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB values operation", { error });
+      logger21.error("Error in IndexedDB values operation", { error });
       return [];
     }
   }
   async clear() {
-    logger20.debug("Clearing IndexedDB cache");
+    logger21.debug("Clearing IndexedDB cache");
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3523,7 +3577,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.clear();
         request.onerror = () => {
-          logger20.error("Error clearing IndexedDB cache", { error: request.error });
+          logger21.error("Error clearing IndexedDB cache", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3531,17 +3585,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB clear operation", { error });
+      logger21.error("Error in IndexedDB clear operation", { error });
     }
   }
   // Async Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger20.trace("setQueryResult", { queryHash, itemKeys });
+    logger21.trace("setQueryResult", { queryHash, itemKeys });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for setQueryResult", { error: request.error });
+          logger21.error("Failed to open database for setQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3554,7 +3608,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const putRequest = store.put(safeStringify3(entry), queryKey);
           putRequest.onerror = () => {
-            logger20.error("Failed to store query result", { queryHash, error: putRequest.error });
+            logger21.error("Failed to store query result", { queryHash, error: putRequest.error });
             reject(putRequest.error);
           };
           putRequest.onsuccess = () => {
@@ -3563,17 +3617,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in setQueryResult", { queryHash, error });
+      logger21.error("Error in setQueryResult", { queryHash, error });
       throw error;
     }
   }
   async getQueryResult(queryHash) {
-    logger20.trace("getQueryResult", { queryHash });
+    logger21.trace("getQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for getQueryResult", { error: request.error });
+          logger21.error("Failed to open database for getQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3583,7 +3637,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const getRequest = store.get(queryKey);
           getRequest.onerror = () => {
-            logger20.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
+            logger21.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
             reject(getRequest.error);
           };
           getRequest.onsuccess = () => {
@@ -3600,34 +3654,34 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               }
               resolve(entry.itemKeys || null);
             } catch (parseError) {
-              logger20.error("Failed to parse query result", { queryHash, error: parseError });
+              logger21.error("Failed to parse query result", { queryHash, error: parseError });
               resolve(null);
             }
           };
         };
       });
     } catch (error) {
-      logger20.error("Error in getQueryResult", { queryHash, error });
+      logger21.error("Error in getQueryResult", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
-    logger20.trace("hasQueryResult", { queryHash });
+    logger21.trace("hasQueryResult", { queryHash });
     try {
       const result = await this.getQueryResult(queryHash);
       return result !== null;
     } catch (error) {
-      logger20.error("Error in hasQueryResult", { queryHash, error });
+      logger21.error("Error in hasQueryResult", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger20.trace("deleteQueryResult", { queryHash });
+    logger21.trace("deleteQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for deleteQueryResult", { error: request.error });
+          logger21.error("Failed to open database for deleteQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3637,7 +3691,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const deleteRequest = store.delete(queryKey);
           deleteRequest.onerror = () => {
-            logger20.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
+            logger21.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
             reject(deleteRequest.error);
           };
           deleteRequest.onsuccess = () => {
@@ -3646,12 +3700,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in deleteQueryResult", { queryHash, error });
+      logger21.error("Error in deleteQueryResult", { queryHash, error });
       throw error;
     }
   }
   async invalidateItemKeys(keys) {
-    logger20.debug("invalidateItemKeys", { keys });
+    logger21.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3688,7 +3742,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
                   queryResults2[queryHash] = itemKeys;
                 }
               } catch (error) {
-                logger20.debug("Failed to parse query result", { key: item.key, error });
+                logger21.debug("Failed to parse query result", { key: item.key, error });
               }
             }
           }
@@ -3716,18 +3770,18 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           });
         }
       }
-      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(queryResults).length
       });
     } catch (error) {
-      logger20.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger21.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger20.debug("invalidateLocation", { locations });
+    logger21.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       await this.clearQueryResults();
@@ -3740,12 +3794,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async clearQueryResults() {
-    logger20.trace("clearQueryResults");
+    logger21.trace("clearQueryResults");
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for clearQueryResults", { error: request.error });
+          logger21.error("Failed to open database for clearQueryResults", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3755,7 +3809,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const cursorRequest = store.openCursor();
           const keysToDelete = [];
           cursorRequest.onerror = () => {
-            logger20.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
+            logger21.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
             reject(cursorRequest.error);
           };
           cursorRequest.onsuccess = () => {
@@ -3776,7 +3830,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               keysToDelete.forEach((queryKey) => {
                 const deleteRequest = store.delete(queryKey);
                 deleteRequest.onerror = () => {
-                  logger20.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
+                  logger21.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
                   deletedCount++;
                   if (deletedCount === totalToDelete) {
                     resolve();
@@ -3794,14 +3848,14 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in clearQueryResults", { error });
+      logger21.error("Error in clearQueryResults", { error });
       throw error;
     }
   }
 };
 
 // src/browser/IndexDBCacheMap.ts
-var logger21 = logger_default.get("IndexDBCacheMap");
+var logger22 = logger_default.get("IndexDBCacheMap");
 var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   implementationType = "browser/indexedDB";
   // Memory storage
@@ -3985,7 +4039,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger21.debug("invalidateItemKeys", { keys });
+    logger22.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -4015,7 +4069,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       delete this.queryResultCache[queryHash];
     });
-    logger21.debug("Selectively invalidated queries referencing affected keys", {
+    logger22.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
@@ -4398,7 +4452,7 @@ var reset = async (coordinate, options) => {
 
 // src/Operations.ts
 var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) => {
-  const context = createCacheContext(api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry);
+  const context = createCacheContext(api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry, coordinate);
   return {
     all: (query, locations) => all(query, locations, context).then(([ctx, result]) => result),
     one: (query, locations) => one(query, locations, context).then(([ctx, result]) => result),
@@ -4419,7 +4473,7 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
 };
 
 // src/eviction/EvictionManager.ts
-var logger22 = logger_default.get("EvictionManager");
+var logger23 = logger_default.get("EvictionManager");
 var EvictionManager = class {
   evictionStrategy;
   constructor(evictionStrategy) {
@@ -4431,7 +4485,7 @@ var EvictionManager = class {
    */
   setEvictionStrategy(strategy) {
     this.evictionStrategy = strategy;
-    logger22.debug("Eviction strategy updated", {
+    logger23.debug("Eviction strategy updated", {
       strategy: strategy?.getStrategyName() || "none"
     });
   }
@@ -4454,7 +4508,7 @@ var EvictionManager = class {
     try {
       await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger22.error("Error in eviction strategy onItemAccessed", { key, error });
+      logger23.error("Error in eviction strategy onItemAccessed", { key, error });
     }
   }
   /**
@@ -4479,14 +4533,14 @@ var EvictionManager = class {
       }
       await this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
       if (evictedKeys.length > 0) {
-        logger22.debug("Items evicted during addition", {
+        logger23.debug("Items evicted during addition", {
           newKey: key,
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger22.error("Error in eviction strategy onItemAdded", { key, error });
+      logger23.error("Error in eviction strategy onItemAdded", { key, error });
     }
     return evictedKeys;
   }
@@ -4502,7 +4556,7 @@ var EvictionManager = class {
     try {
       this.evictionStrategy.onItemRemoved(key, metadataProvider);
     } catch (error) {
-      logger22.error("Error in eviction strategy onItemRemoved", { key, error });
+      logger23.error("Error in eviction strategy onItemRemoved", { key, error });
     }
   }
   /**
@@ -4523,13 +4577,13 @@ var EvictionManager = class {
         evictedKeys.push(evictKey);
       }
       if (evictedKeys.length > 0) {
-        logger22.debug("Manual eviction performed", {
+        logger23.debug("Manual eviction performed", {
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger22.error("Error in manual eviction", { error });
+      logger23.error("Error in manual eviction", { error });
     }
     return evictedKeys;
   }
@@ -4549,7 +4603,7 @@ var EvictionManager = class {
         this.evictionStrategy.reset();
       }
     }
-    logger22.debug("Eviction manager cleared");
+    logger23.debug("Eviction manager cleared");
   }
   /**
    * Create eviction context from current cache state
@@ -5887,7 +5941,7 @@ function createEvictionStrategy(policy, maxCacheSize, config) {
 }
 
 // src/ttl/TTLManager.ts
-var logger23 = logger_default.get("TTLManager");
+var logger24 = logger_default.get("TTLManager");
 var TTLManager = class {
   config;
   cleanupTimer;
@@ -5899,7 +5953,7 @@ var TTLManager = class {
       validateOnAccess: true,
       ...config
     };
-    logger23.debug("TTL_DEBUG: TTLManager created", {
+    logger24.debug("TTL_DEBUG: TTLManager created", {
       config: this.config,
       isTTLEnabled: this.isTTLEnabled(),
       defaultTTL: this.config.defaultTTL
@@ -5932,13 +5986,13 @@ var TTLManager = class {
         this.startAutoCleanup();
       }
     }
-    logger23.debug("TTL configuration updated", { config: this.config });
+    logger24.debug("TTL configuration updated", { config: this.config });
   }
   /**
    * Set TTL metadata for an item when it's added
    */
   async onItemAdded(key, metadataProvider, itemTTL) {
-    logger23.debug("TTL_DEBUG: onItemAdded called", {
+    logger24.debug("TTL_DEBUG: onItemAdded called", {
       key,
       itemTTL,
       isTTLEnabled: this.isTTLEnabled(),
@@ -5946,19 +6000,19 @@ var TTLManager = class {
       metadataProviderType: metadataProvider?.constructor?.name
     });
     if (!this.isTTLEnabled() && !itemTTL) {
-      logger23.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
+      logger24.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
       return;
     }
-    logger23.debug("TTL_DEBUG: Getting metadata for key", { key });
+    logger24.debug("TTL_DEBUG: Getting metadata for key", { key });
     const metadata = await metadataProvider.getMetadata(key);
-    logger23.debug("TTL_DEBUG: Retrieved metadata", {
+    logger24.debug("TTL_DEBUG: Retrieved metadata", {
       key,
       hasMetadata: !!metadata,
       metadataKeys: metadata ? Object.keys(metadata) : null,
       metadata
     });
     if (!metadata) {
-      logger23.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
+      logger24.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
         key,
         metadataProviderType: metadataProvider?.constructor?.name,
         metadataProviderMethods: metadataProvider ? Object.getOwnPropertyNames(Object.getPrototypeOf(metadataProvider)) : null
@@ -5966,7 +6020,7 @@ var TTLManager = class {
       return;
     }
     const ttl = itemTTL || this.config.defaultTTL;
-    logger23.debug("TTL_DEBUG: Calculated TTL value", {
+    logger24.debug("TTL_DEBUG: Calculated TTL value", {
       key,
       itemTTL,
       defaultTTL: this.config.defaultTTL,
@@ -5979,7 +6033,7 @@ var TTLManager = class {
         expiresAt: metadata.addedAt + ttl,
         ttl
       };
-      logger23.debug("TTL_DEBUG: Setting TTL metadata", {
+      logger24.debug("TTL_DEBUG: Setting TTL metadata", {
         key,
         ttl,
         addedAt: metadata.addedAt,
@@ -5987,9 +6041,9 @@ var TTLManager = class {
         ttlMetadata
       });
       await metadataProvider.setMetadata(key, ttlMetadata);
-      logger23.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+      logger24.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     } else {
-      logger23.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
+      logger24.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
     }
   }
   /**
@@ -6003,7 +6057,7 @@ var TTLManager = class {
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
     if (expired) {
-      logger23.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
+      logger24.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
     }
     return expired;
   }
@@ -6050,7 +6104,7 @@ var TTLManager = class {
       }
     }
     if (expiredKeys.length > 0) {
-      logger23.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
+      logger24.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
     }
     return expiredKeys;
   }
@@ -6078,7 +6132,7 @@ var TTLManager = class {
     }
     metadata.expiresAt += additionalTTL;
     await metadataProvider.setMetadata(key, metadata);
-    logger23.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
+    logger24.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
     return true;
   }
   /**
@@ -6100,7 +6154,7 @@ var TTLManager = class {
       ttl
     };
     await metadataProvider.setMetadata(key, ttlMetadata);
-    logger23.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+    logger24.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     return true;
   }
   /**
@@ -6112,9 +6166,9 @@ var TTLManager = class {
     }
     if (this.config.cleanupInterval) {
       this.cleanupTimer = setInterval(() => {
-        logger23.trace("Auto cleanup timer triggered");
+        logger24.trace("Auto cleanup timer triggered");
       }, this.config.cleanupInterval);
-      logger23.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
+      logger24.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
     }
   }
   /**
@@ -6124,7 +6178,7 @@ var TTLManager = class {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
-      logger23.debug("Auto cleanup stopped");
+      logger24.debug("Auto cleanup stopped");
     }
   }
   /**
@@ -6132,14 +6186,14 @@ var TTLManager = class {
    */
   clear() {
     this.stopAutoCleanup();
-    logger23.debug("TTL manager cleared");
+    logger24.debug("TTL manager cleared");
   }
   /**
    * Cleanup resources
    */
   destroy() {
     this.stopAutoCleanup();
-    logger23.debug("TTL manager destroyed");
+    logger24.debug("TTL manager destroyed");
   }
 };
 
@@ -6539,9 +6593,9 @@ var CacheStatsManager = class {
 };
 
 // src/Cache.ts
-var logger24 = logger_default.get("Cache");
+var logger25 = logger_default.get("Cache");
 var createCache = (api, coordinate, registry, options) => {
-  logger24.debug("createCache", { coordinate, registry, options });
+  logger25.debug("createCache", { coordinate, registry, options });
   const completeOptions = createOptions(options);
   const cacheMap = createCacheMap(coordinate.kta, completeOptions);
   const pkType = coordinate.kta[0];
@@ -6621,13 +6675,13 @@ var isCache2 = (cache) => {
 };
 
 // src/InstanceFactory.ts
-var logger25 = logger_default.get("InstanceFactory");
+var logger26 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (api, options) => {
   const templateOptions = createOptions(options);
   validateOptions(templateOptions);
   return (coordinate, context) => {
     const instanceOptions = createOptions(options);
-    logger25.debug("Creating cache instance", {
+    logger26.debug("Creating cache instance", {
       coordinate,
       registry: context.registry,
       api,
@@ -6694,9 +6748,9 @@ var createInstanceFactory = (api, options) => {
 };
 
 // src/Instance.ts
-var logger26 = logger_default.get("Instance");
+var logger27 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, api, options) => {
-  logger26.debug("createInstance", { coordinate, api, registry, options });
+  logger27.debug("createInstance", { coordinate, api, registry, options });
   return createCache(api, coordinate, registry, options);
 };
 var isInstance = (instance) => {
@@ -6704,7 +6758,7 @@ var isInstance = (instance) => {
 };
 
 // src/Aggregator.ts
-var logger27 = logger_default.get("ItemAggregator");
+var logger28 = logger_default.get("ItemAggregator");
 var toCacheConfig = (config) => {
   let cacheConfig;
   if (config.optional === void 0) {
@@ -6716,22 +6770,22 @@ var toCacheConfig = (config) => {
 };
 var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
   const populate = async (item) => {
-    logger27.default("populate", { item });
+    logger28.default("populate", { item });
     for (const key in aggregates) {
       await populateAggregate(key, item);
     }
     for (const key in events) {
       await populateEvent(key, item);
     }
-    logger27.default("populate done", { item });
+    logger28.default("populate done", { item });
     return item;
   };
   const populateAggregate = async (key, item) => {
-    logger27.default("populate aggregate key", { key });
+    logger28.default("populate aggregate key", { key });
     const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === void 0) {
       if (cacheConfig.optional === false) {
-        logger27.error("Item does not have refs an is not optional ", { item });
+        logger28.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)) {
@@ -6740,7 +6794,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else if (item.refs[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger27.error("Item does not have mandatory ref with key, not optional ", { key, item });
+        logger28.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)) {
@@ -6749,7 +6803,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else {
       const ref = item.refs[key];
-      logger27.default("AGG Retrieving Item in Populate", { key: ref });
+      logger28.default("AGG Retrieving Item in Populate", { key: ref });
       const newItem = await cacheConfig.cache.operations.retrieve(ref);
       if (newItem) {
         if (item.aggs === void 0) {
@@ -6766,25 +6820,25 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const populateEvent = async (key, item) => {
-    logger27.default("populate event key", { key });
+    logger28.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) {
-        logger27.error("Item does not have mandatory event with key", { key, item });
+        logger28.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) {
-        logger27.error(
+        logger28.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 }));
       }
-      logger27.default("EVENT Retrieving Item in Populate", { key: event.by });
+      logger28.default("EVENT Retrieving Item in Populate", { key: event.by });
       const newItem = await cacheConfig.cache.operations.retrieve(event.by);
       if (newItem) {
         event.agg = newItem;
@@ -6792,13 +6846,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const all2 = async (query = {}, locations = []) => {
-    logger27.default("all", { query, locations });
+    logger28.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 = []) => {
-    logger27.default("one", { query, locations });
+    logger28.default("one", { query, locations });
     const item = await cache.operations.one(query, locations);
     let populatedItem = null;
     if (item) {
@@ -6807,30 +6861,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger27.default("action", { key, action: action3, body });
+    logger28.default("action", { key, action: action3, body });
     const [item, affectedItems] = await cache.operations.action(key, action3, body);
     const populatedItem = await populate(item);
     return [populatedItem, affectedItems];
   };
   const allAction2 = async (action3, body = {}, locations = []) => {
-    logger27.default("action", { action: action3, body, locations });
+    logger28.default("action", { action: action3, body, locations });
     const [items, affectedItems] = await cache.operations.allAction(action3, body, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return [populatedItems, affectedItems];
   };
   const allFacet2 = async (facet3, params = {}, locations = []) => {
-    logger27.default("allFacet", { facet: facet3, params, locations });
+    logger28.default("allFacet", { facet: facet3, params, locations });
     const response = await cache.operations.allFacet(facet3, params, locations);
     return response;
   };
   const create2 = async (v, locations = []) => {
-    logger27.default("create", { v, locations });
+    logger28.default("create", { v, locations });
     const item = await cache.operations.create(v, locations);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const get2 = async (key) => {
-    logger27.default("get", { key });
+    logger28.default("get", { key });
     const item = await cache.operations.get(key);
     let populatedItem = null;
     if (item) {
@@ -6839,7 +6893,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const retrieve2 = async (key) => {
-    logger27.default("retrieve", { key });
+    logger28.default("retrieve", { key });
     const item = await cache.operations.retrieve(key);
     let populatedItem = null;
     if (item) {
@@ -6848,34 +6902,34 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const remove2 = async (key) => {
-    logger27.default("remove", { key });
+    logger28.default("remove", { key });
     await cache.operations.remove(key);
   };
   const update2 = async (key, v) => {
-    logger27.default("update", { key, v });
+    logger28.default("update", { key, v });
     const item = await cache.operations.update(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const facet2 = async (key, facet3) => {
-    logger27.default("facet", { key, facet: facet3 });
+    logger28.default("facet", { key, facet: facet3 });
     const response = await cache.operations.facet(key, facet3);
     return response;
   };
   const find2 = async (finder, finderParams = {}, locations = []) => {
-    logger27.default("find", { finder, finderParams, locations });
+    logger28.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 = []) => {
-    logger27.default("find", { finder, finderParams, locations });
+    logger28.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) => {
-    logger27.default("set", { key, v });
+    logger28.default("set", { key, v });
     const item = await cache.operations.set(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
@@ -6927,13 +6981,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger28 = logger_default.get("Registry");
+var logger29 = 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}`);
     }
-    logger28.debug("Creating cache registry", { type, registryHub });
+    logger29.debug("Creating cache registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };