@fjell/cache 4.7.55 → 4.7.57

package/dist/index.js

@@ -16,6 +16,12 @@ import Logging from "@fjell/logging";
 var LibLogger = Logging.getLogger("@fjell/cache");
 var logger_default = LibLogger;
 
+// src/cache/layers/ItemCache.ts
+var logger = logger_default.get("ItemCache");
+
+// src/cache/layers/QueryCache.ts
+var logger2 = logger_default.get("QueryCache");
+
 // src/CacheMap.ts
 var CacheMap = class {
   types;
@@ -25,7 +31,7 @@ var CacheMap = class {
 };
 
 // src/cache/layers/TwoLayerCacheMap.ts
-var logger = logger_default.get("TwoLayerCacheMap");
+var logger3 = logger_default.get("TwoLayerCacheMap");
 var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
   constructor(underlyingCache, options = {}) {
     super(underlyingCache.types);
@@ -35,18 +41,15 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
       // 1 hour for items
       queryTTL: options.queryTTL || 300,
       // 5 minutes for complete queries
-      facetTTL: options.facetTTL || 60,
+      facetTTL: options.facetTTL || 60
       // 1 minute for partial queries
-      debug: options.debug || false
     };
-    if (this.options.debug) {
-      logger.info("TwoLayerCacheMap initialized", {
-        underlyingType: this.underlyingCache.implementationType,
-        itemTTL: this.options.itemTTL,
-        queryTTL: this.options.queryTTL,
-        facetTTL: this.options.facetTTL
-      });
-    }
+    logger3.debug("TwoLayerCacheMap initialized", {
+      underlyingType: this.underlyingCache.implementationType,
+      itemTTL: this.options.itemTTL,
+      queryTTL: this.options.queryTTL,
+      facetTTL: this.options.facetTTL
+    });
   }
   options;
   // Query metadata tracking for enhanced TTL and completeness
@@ -94,13 +97,11 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Set a query result with rich metadata for two-layer architecture
    */
   async setQueryResult(queryHash, itemKeys) {
-    logger.debug("QUERY_CACHE: TwoLayerCacheMap.setQueryResult() called", {
+    logger3.debug("QUERY_CACHE: TwoLayerCacheMap.setQueryResult() called", {
       queryHash,
       itemKeyCount: itemKeys.length,
       itemKeys: itemKeys.map((k) => JSON.stringify(k))
     });
-    await this.underlyingCache.setQueryResult(queryHash, itemKeys);
-    logger.debug("QUERY_CACHE: Stored query result in underlying cache", { queryHash });
     const now = /* @__PURE__ */ new Date();
     const isComplete = this.determineQueryCompleteness(queryHash, itemKeys);
     const ttlSeconds = isComplete ? this.options.queryTTL : this.options.facetTTL;
@@ -114,7 +115,17 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
       params: this.extractParams(queryHash)
     };
     this.queryMetadataMap.set(queryHash, metadata);
-    logger.debug("QUERY_CACHE: Set query result with metadata", {
+    if ("setQueryResult" in this.underlyingCache) {
+      const setQueryResultFn = this.underlyingCache.setQueryResult;
+      if (setQueryResultFn.length >= 3) {
+        await this.underlyingCache.setQueryResult(queryHash, itemKeys, metadata);
+        logger3.debug("QUERY_CACHE: Stored query result with metadata in underlying cache", { queryHash });
+      } else {
+        await this.underlyingCache.setQueryResult(queryHash, itemKeys);
+        logger3.debug("QUERY_CACHE: Stored query result without metadata in underlying cache (not supported)", { queryHash });
+      }
+    }
+    logger3.debug("QUERY_CACHE: Set query result with metadata", {
       queryHash,
       itemCount: itemKeys.length,
       isComplete,
@@ -130,12 +141,27 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Get a query result with expiration checking
    */
   async getQueryResult(queryHash) {
-    logger.debug("QUERY_CACHE: TwoLayerCacheMap.getQueryResult() called", { queryHash });
-    const metadata = this.queryMetadataMap.get(queryHash);
+    logger3.debug("QUERY_CACHE: TwoLayerCacheMap.getQueryResult() called", { queryHash });
+    let metadata = this.queryMetadataMap.get(queryHash);
+    if (!metadata && "getQueryResultWithMetadata" in this.underlyingCache) {
+      logger3.debug("QUERY_CACHE: Metadata not in memory, loading from underlying cache", { queryHash });
+      const resultWithMetadata = await this.underlyingCache.getQueryResultWithMetadata(queryHash);
+      if (resultWithMetadata?.metadata) {
+        const restoredMetadata = resultWithMetadata.metadata;
+        metadata = restoredMetadata;
+        this.queryMetadataMap.set(queryHash, restoredMetadata);
+        logger3.debug("QUERY_CACHE: Loaded metadata from underlying cache", {
+          queryHash,
+          expiresAt: restoredMetadata.expiresAt.toISOString(),
+          isComplete: restoredMetadata.isComplete,
+          queryType: restoredMetadata.queryType
+        });
+      }
+    }
     if (metadata) {
       const now = /* @__PURE__ */ new Date();
       const isExpired = metadata.expiresAt < now;
-      logger.debug("QUERY_CACHE: Query metadata found", {
+      logger3.debug("QUERY_CACHE: Query metadata found", {
         queryHash,
         isExpired,
         expiresAt: metadata.expiresAt.toISOString(),
@@ -144,7 +170,7 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
         queryType: metadata.queryType
       });
       if (isExpired) {
-        logger.debug("QUERY_CACHE: Query result EXPIRED, removing", {
+        logger3.debug("QUERY_CACHE: Query result EXPIRED, removing", {
           queryHash,
           expiresAt: metadata.expiresAt.toISOString(),
           now: now.toISOString()
@@ -153,19 +179,19 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
         return null;
       }
     } else {
-      logger.debug("QUERY_CACHE: No metadata found for query hash", { queryHash });
+      logger3.debug("QUERY_CACHE: No metadata found for query hash (neither in memory nor persistent)", { queryHash });
     }
-    logger.debug("QUERY_CACHE: Fetching query result from underlying cache", { queryHash });
+    logger3.debug("QUERY_CACHE: Fetching query result from underlying cache", { queryHash });
     const result = await this.underlyingCache.getQueryResult(queryHash);
     if (result) {
-      logger.debug("QUERY_CACHE: Query result retrieved from underlying cache", {
+      logger3.debug("QUERY_CACHE: Query result retrieved from underlying cache", {
         queryHash,
         itemCount: result.length,
         isComplete: metadata?.isComplete,
         itemKeys: result.map((k) => JSON.stringify(k))
       });
     } else {
-      logger.debug("QUERY_CACHE: No query result found in underlying cache", { queryHash });
+      logger3.debug("QUERY_CACHE: No query result found in underlying cache", { queryHash });
     }
     return result;
   }
@@ -180,12 +206,12 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Delete a query result and its metadata
    */
   async deleteQueryResult(queryHash) {
-    logger.debug("QUERY_CACHE: TwoLayerCacheMap.deleteQueryResult() called", { queryHash });
+    logger3.debug("QUERY_CACHE: TwoLayerCacheMap.deleteQueryResult() called", { queryHash });
     const hadMetadata = this.queryMetadataMap.has(queryHash);
     const metadata = this.queryMetadataMap.get(queryHash);
     await this.underlyingCache.deleteQueryResult(queryHash);
     this.queryMetadataMap.delete(queryHash);
-    logger.debug("QUERY_CACHE: Deleted query result", {
+    logger3.debug("QUERY_CACHE: Deleted query result", {
       queryHash,
       hadMetadata,
       wasComplete: metadata?.isComplete,
@@ -197,11 +223,11 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Invalidate queries that are affected by item changes
    */
   async invalidateQueriesForItem(itemKey) {
-    logger.debug("QUERY_CACHE: Invalidating queries for item change", {
+    logger3.debug("QUERY_CACHE: Invalidating queries for item change", {
       itemKey: JSON.stringify(itemKey)
     });
     const affectedQueries = await this.findQueriesContainingItem(itemKey);
-    logger.debug("QUERY_CACHE: Found queries containing item", {
+    logger3.debug("QUERY_CACHE: Found queries containing item", {
       itemKey: JSON.stringify(itemKey),
       affectedQueryCount: affectedQueries.length,
       affectedQueries
@@ -210,13 +236,13 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
       await this.deleteQueryResult(queryHash);
     }
     if (affectedQueries.length > 0) {
-      logger.debug("QUERY_CACHE: Invalidated queries for item change", {
+      logger3.debug("QUERY_CACHE: Invalidated queries for item change", {
         itemKey: JSON.stringify(itemKey),
         queriesInvalidated: affectedQueries.length,
         queryHashes: affectedQueries
       });
     } else {
-      logger.debug("QUERY_CACHE: No queries found containing item", {
+      logger3.debug("QUERY_CACHE: No queries found containing item", {
         itemKey: JSON.stringify(itemKey)
       });
     }
@@ -240,13 +266,13 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Determine if a query result is complete or partial based on query hash
    */
   determineQueryCompleteness(queryHash, itemKeys) {
-    if (queryHash.includes('"query":{}') || queryHash.includes('"query": {}')) {
-      return true;
-    }
     if (queryHash.includes("facet:") || queryHash.includes("filter:")) {
       return false;
     }
-    if (queryHash.includes("all:") && !queryHash.includes("query:")) {
+    if (queryHash.startsWith("all:") && (queryHash.includes("query:{}") || queryHash.includes('"query":{}') || queryHash.includes('"query": {}'))) {
+      return true;
+    }
+    if (queryHash.startsWith("all:") && !queryHash.includes("query:")) {
       return true;
     }
     return false;
@@ -359,14 +385,14 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
     const startTime = Date.now();
     const now = /* @__PURE__ */ new Date();
     const expiredQueries = [];
-    logger.debug("TWO_LAYER: Starting query cleanup", {
+    logger3.debug("TWO_LAYER: Starting query cleanup", {
       totalQueries: this.queryMetadataMap.size,
       now: now.toISOString()
     });
     for (const [queryHash, metadata] of this.queryMetadataMap.entries()) {
       if (metadata.expiresAt < now) {
         expiredQueries.push(queryHash);
-        logger.debug("TWO_LAYER: Found expired query", {
+        logger3.debug("TWO_LAYER: Found expired query", {
           queryHash,
           queryType: metadata.queryType,
           isComplete: metadata.isComplete,
@@ -380,13 +406,13 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
     }
     const duration = Date.now() - startTime;
     if (expiredQueries.length > 0) {
-      logger.debug("TWO_LAYER: Query cleanup completed", {
+      logger3.debug("TWO_LAYER: Query cleanup completed", {
         expiredCount: expiredQueries.length,
         totalQueries: this.queryMetadataMap.size,
         duration
       });
     } else {
-      logger.debug("TWO_LAYER: Query cleanup - no expired queries", {
+      logger3.debug("TWO_LAYER: Query cleanup - no expired queries", {
         totalQueries: this.queryMetadataMap.size,
         duration
       });
@@ -402,7 +428,7 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
   // ===== MISSING ABSTRACT METHODS FROM CacheMap =====
   async invalidateItemKeys(keys) {
     const startTime = Date.now();
-    logger.debug("TWO_LAYER: Invalidating item keys", {
+    logger3.debug("TWO_LAYER: Invalidating item keys", {
       keyCount: keys.length,
       keys: keys.map((k) => JSON.stringify(k))
     });
@@ -417,14 +443,14 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
       const invalidated = beforeCount - afterCount;
       totalInvalidatedQueries += invalidated;
       if (invalidated > 0) {
-        logger.debug("TWO_LAYER: Invalidated queries for item", {
+        logger3.debug("TWO_LAYER: Invalidated queries for item", {
           key: JSON.stringify(key),
           queriesInvalidated: invalidated
         });
       }
     }
     const duration = Date.now() - startTime;
-    logger.debug("TWO_LAYER: Item key invalidation completed", {
+    logger3.debug("TWO_LAYER: Item key invalidation completed", {
       keyCount: keys.length,
       totalQueriesInvalidated: totalInvalidatedQueries,
       duration
@@ -433,7 +459,7 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
   async invalidateLocation(locations) {
     const startTime = Date.now();
     const queryCountBefore = this.queryMetadataMap.size;
-    logger.debug("TWO_LAYER: Invalidating location", {
+    logger3.debug("TWO_LAYER: Invalidating location", {
       locations: JSON.stringify(locations),
       queryCountBefore
     });
@@ -442,7 +468,7 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
     }
     this.queryMetadataMap.clear();
     const duration = Date.now() - startTime;
-    logger.debug("TWO_LAYER: Location invalidation completed", {
+    logger3.debug("TWO_LAYER: Location invalidation completed", {
       locations: JSON.stringify(locations),
       queriesCleared: queryCountBefore,
       duration
@@ -451,7 +477,7 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
   async clearQueryResults() {
     const startTime = Date.now();
     const queryCountBefore = this.queryMetadataMap.size;
-    logger.debug("TWO_LAYER: Clearing all query results", {
+    logger3.debug("TWO_LAYER: Clearing all query results", {
       queryCountBefore
     });
     if ("clearQueryResults" in this.underlyingCache && typeof this.underlyingCache.clearQueryResults === "function") {
@@ -459,7 +485,7 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
     }
     this.queryMetadataMap.clear();
     const duration = Date.now() - startTime;
-    logger.debug("TWO_LAYER: Cleared all query results", {
+    logger3.debug("TWO_LAYER: Cleared all query results", {
       queriesCleared: queryCountBefore,
       duration
     });
@@ -578,7 +604,11 @@ var createQueryHash = (pkType, query, locations) => {
     query: sortedQuery,
     locations: normalizedLocations
   };
-  return deterministicStringify(hashInput);
+  const hash = deterministicStringify(hashInput);
+  if (!hash || typeof hash !== "string" || hash.trim() === "") {
+    throw new Error(`Invalid query hash generated: hash is empty or invalid. Input: ${JSON.stringify({ pkType, query, locations })}`);
+  }
+  return hash;
 };
 var createFinderHash = (finder, params, locations) => {
   const normalizedParams = JSON.parse(JSON.stringify(params || {}));
@@ -595,7 +625,11 @@ var createFinderHash = (finder, params, locations) => {
     params: sortedParams,
     locations: normalizedLocations
   };
-  return deterministicStringify(hashInput);
+  const hash = deterministicStringify(hashInput);
+  if (!hash || typeof hash !== "string" || hash.trim() === "") {
+    throw new Error(`Invalid finder hash generated: hash is empty or invalid. Input: ${JSON.stringify({ finder, params, locations })}`);
+  }
+  return hash;
 };
 
 // src/events/CacheEventFactory.ts
@@ -790,7 +824,7 @@ var CacheEventFactory = class {
 };
 
 // src/ops/all.ts
-var logger2 = logger_default.get("all");
+var logger4 = logger_default.get("all");
 var inFlightRequests = /* @__PURE__ */ new Map();
 var CLEANUP_INTERVAL = 3e4;
 var REQUEST_TIMEOUT = 25e3;
@@ -798,14 +832,14 @@ setInterval(() => {
   const now = Date.now();
   inFlightRequests.forEach((request, key) => {
     if (now - request.timestamp > REQUEST_TIMEOUT) {
-      logger2.debug("Cleaning up stale in-flight all() request", { key });
+      logger4.debug("Cleaning up stale in-flight all() request", { key });
       inFlightRequests.delete(key);
     }
   });
 }, CLEANUP_INTERVAL);
 var all = async (query = {}, locations = [], context, allOptions) => {
   const { coordinate } = context;
-  logger2.default("all", { query, locations, allOptions });
+  logger4.default("all", { query, locations, allOptions });
   const wrappedAll = createAllWrapper(
     coordinate,
     async (q, locs, opts) => {
@@ -829,27 +863,27 @@ async function executeAllLogic(query, locations, context, allOptions) {
     }
   });
   if (context.options?.bypassCache) {
-    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger4.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const ret = await api.all(query, locations, allOptions);
-      logger2.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret.items.length });
+      logger4.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret.items.length });
       return ret;
     } catch (error) {
-      logger2.error("API request failed", { query, locations, error });
+      logger4.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger2.debug("QUERY_CACHE: Generated query hash for all()", {
+  logger4.debug("QUERY_CACHE: Generated query hash for all()", {
     queryHash,
     query: JSON.stringify(query),
     locations: JSON.stringify(locations),
     pkType
   });
-  logger2.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
+  logger4.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger2.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+    logger4.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
       queryHash,
       cachedKeyCount: cachedItemKeys.length,
       itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
@@ -861,14 +895,14 @@ async function executeAllLogic(query, locations, context, allOptions) {
       const item = await cacheMap.get(itemKey);
       if (item) {
         cachedItems.push(item);
-        logger2.debug("QUERY_CACHE: Retrieved cached item", {
+        logger4.debug("QUERY_CACHE: Retrieved cached item", {
           itemKey: JSON.stringify(itemKey),
           itemKeyStr: JSON.stringify(item.key)
         });
       } else {
         allItemsAvailable = false;
         missingKeys.push(itemKey);
-        logger2.debug("QUERY_CACHE: Cached item MISSING from item cache", {
+        logger4.debug("QUERY_CACHE: Cached item MISSING from item cache", {
           itemKey: JSON.stringify(itemKey),
           queryHash
         });
@@ -876,13 +910,13 @@ async function executeAllLogic(query, locations, context, allOptions) {
       }
     }
     if (allItemsAvailable) {
-      logger2.debug("QUERY_CACHE: All cached items available, returning from cache", {
+      logger4.debug("QUERY_CACHE: All cached items available, returning from cache", {
         queryHash,
         itemCount: cachedItems.length
       });
       return createCachedResult(cachedItems);
     } else {
-      logger2.debug("QUERY_CACHE: Some cached items missing, invalidating query cache", {
+      logger4.debug("QUERY_CACHE: Some cached items missing, invalidating query cache", {
         queryHash,
         missingKeys: missingKeys.map((k) => JSON.stringify(k)),
         foundCount: cachedItems.length,
@@ -891,11 +925,11 @@ async function executeAllLogic(query, locations, context, allOptions) {
       cacheMap.deleteQueryResult(queryHash);
     }
   } else {
-    logger2.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
+    logger4.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
   const isEmptyQuery = Object.keys(query).length === 0 || (Object.keys(query).length === 1 && "limit" in query || "offset" in query);
   if (!isEmptyQuery) {
-    logger2.debug("QUERY_CACHE: Attempting direct cache query using queryIn() for filtered query", {
+    logger4.debug("QUERY_CACHE: Attempting direct cache query using queryIn() for filtered query", {
       queryHash,
       query: JSON.stringify(query),
       locations: JSON.stringify(locations)
@@ -903,35 +937,35 @@ async function executeAllLogic(query, locations, context, allOptions) {
     try {
       const directCachedItems = await cacheMap.queryIn(query, locations);
       if (directCachedItems && directCachedItems.length > 0) {
-        logger2.debug("QUERY_CACHE: Direct cache query SUCCESS - Found items in item cache", {
+        logger4.debug("QUERY_CACHE: Direct cache query SUCCESS - Found items in item cache", {
           queryHash,
           itemCount: directCachedItems.length,
           itemKeys: directCachedItems.map((item) => JSON.stringify(item.key))
         });
         const itemKeys = directCachedItems.map((item) => item.key);
         await cacheMap.setQueryResult(queryHash, itemKeys);
-        logger2.debug("QUERY_CACHE: Stored query result from direct cache hit", {
+        logger4.debug("QUERY_CACHE: Stored query result from direct cache hit", {
           queryHash,
           itemKeyCount: itemKeys.length,
           itemKeys: itemKeys.map((k) => JSON.stringify(k))
         });
         return createCachedResult(directCachedItems);
       } else {
-        logger2.debug("QUERY_CACHE: Direct cache query returned no items", { queryHash });
+        logger4.debug("QUERY_CACHE: Direct cache query returned no items", { queryHash });
       }
     } catch (error) {
-      logger2.debug("QUERY_CACHE: Error querying cache directly, proceeding to API", {
+      logger4.debug("QUERY_CACHE: Error querying cache directly, proceeding to API", {
         queryHash,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   } else {
-    logger2.debug("QUERY_CACHE: Skipping direct cache query for empty/all query - cannot trust completeness", {
+    logger4.debug("QUERY_CACHE: Skipping direct cache query for empty/all query - cannot trust completeness", {
       queryHash,
       query: JSON.stringify(query)
     });
   }
-  logger2.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+  logger4.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
     queryHash,
     query: JSON.stringify(query),
     locations: JSON.stringify(locations)
@@ -939,7 +973,7 @@ async function executeAllLogic(query, locations, context, allOptions) {
   const timestamp = Date.now();
   const existingRequest = inFlightRequests.get(queryHash);
   if (existingRequest && timestamp - existingRequest.timestamp < REQUEST_TIMEOUT) {
-    logger2.debug("QUERY_CACHE: Using existing in-flight all() request", {
+    logger4.debug("QUERY_CACHE: Using existing in-flight all() request", {
       queryHash,
       age: timestamp - existingRequest.timestamp
     });
@@ -952,19 +986,19 @@ async function executeAllLogic(query, locations, context, allOptions) {
     const cleanup = () => inFlightRequests.delete(queryHash);
     apiRequest.then(cleanup, cleanup);
     apiResult = await apiRequest;
-    logger2.debug("QUERY_CACHE: API response received", {
+    logger4.debug("QUERY_CACHE: API response received", {
       queryHash,
       itemCount: apiResult.items.length,
       total: apiResult.metadata?.total,
       itemKeys: apiResult.items.map((item) => JSON.stringify(item.key))
     });
-    logger2.debug("QUERY_CACHE: Storing items in item cache", {
+    logger4.debug("QUERY_CACHE: Storing items in item cache", {
       queryHash,
       itemCount: apiResult.items.length
     });
     for (const v of apiResult.items) {
       await cacheMap.set(v.key, v);
-      logger2.debug("QUERY_CACHE: Stored item in cache", {
+      logger4.debug("QUERY_CACHE: Stored item in cache", {
         itemKey: JSON.stringify(v.key),
         queryHash
       });
@@ -974,7 +1008,7 @@ async function executeAllLogic(query, locations, context, allOptions) {
       for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
         await cacheMap.delete(parsedKey);
-        logger2.debug("QUERY_CACHE: Evicted item due to cache limits", {
+        logger4.debug("QUERY_CACHE: Evicted item due to cache limits", {
           evictedKey,
           queryHash
         });
@@ -982,29 +1016,29 @@ async function executeAllLogic(query, locations, context, allOptions) {
     }
     const itemKeys = apiResult.items.map((item) => item.key);
     await cacheMap.setQueryResult(queryHash, itemKeys);
-    logger2.debug("QUERY_CACHE: Stored query result in query cache", {
+    logger4.debug("QUERY_CACHE: Stored query result in query cache", {
       queryHash,
       itemKeyCount: itemKeys.length,
       itemKeys: itemKeys.map((k) => JSON.stringify(k))
     });
     const event = CacheEventFactory.createQueryEvent(query, locations, apiResult.items);
     context.eventEmitter.emit(event);
-    logger2.debug("QUERY_CACHE: Emitted query event", { queryHash });
+    logger4.debug("QUERY_CACHE: Emitted query event", { queryHash });
   } catch (e) {
     inFlightRequests.delete(queryHash);
     if (e instanceof NotFoundError) {
-      logger2.debug("QUERY_CACHE: API returned NotFoundError, caching empty result", { queryHash });
+      logger4.debug("QUERY_CACHE: API returned NotFoundError, caching empty result", { queryHash });
       await cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("QUERY_CACHE: Cached empty query result for not found", { queryHash });
+      logger4.debug("QUERY_CACHE: Cached empty query result for not found", { queryHash });
     } else {
-      logger2.debug("QUERY_CACHE: API error occurred", {
+      logger4.debug("QUERY_CACHE: API error occurred", {
         queryHash,
         error: e instanceof Error ? e.message : String(e)
       });
       throw e;
     }
   }
-  logger2.debug("QUERY_CACHE: all() operation completed", {
+  logger4.debug("QUERY_CACHE: all() operation completed", {
     queryHash,
     resultCount: apiResult.items.length,
     total: apiResult.metadata?.total
@@ -1179,10 +1213,10 @@ function validateSizeConfig(config) {
 }
 
 // src/ops/one.ts
-var logger3 = logger_default.get("one");
+var logger5 = logger_default.get("one");
 var one = async (query = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, coordinate } = context;
-  logger3.default("one", { query, locations });
+  logger5.default("one", { query, locations });
   const wrappedOne = createOneWrapper(
     coordinate,
     async (q, locs) => {
@@ -1195,64 +1229,64 @@ var one = async (query = {}, locations = [], context) => {
 async function executeOneLogic(query, locations, context) {
   const { api, cacheMap, pkType, ttlManager } = context;
   if (context.options?.bypassCache) {
-    logger3.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger5.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const retItem2 = await api.one(query, locations);
       if (retItem2) {
-        logger3.debug("API response received (not cached due to bypass)", { query, locations });
+        logger5.debug("API response received (not cached due to bypass)", { query, locations });
         return retItem2;
       } else {
-        logger3.debug("API returned null", { query, locations });
+        logger5.debug("API returned null", { query, locations });
         return null;
       }
     } catch (error) {
-      logger3.error("API request failed", { query, locations, error });
+      logger5.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger3.debug("QUERY_CACHE: Generated query hash for one()", {
+  logger5.debug("QUERY_CACHE: Generated query hash for one()", {
     queryHash,
     query: JSON.stringify(query),
     locations: JSON.stringify(locations),
     pkType
   });
-  logger3.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
+  logger5.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger3.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+    logger5.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
       queryHash,
       cachedKeyCount: cachedItemKeys.length,
       itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
     });
     if (cachedItemKeys.length === 0) {
-      logger3.debug("QUERY_CACHE: Cached empty result (not found)", { queryHash });
+      logger5.debug("QUERY_CACHE: Cached empty result (not found)", { queryHash });
       return null;
     }
     const itemKey = cachedItemKeys[0];
-    logger3.debug("QUERY_CACHE: Retrieving first cached item", {
+    logger5.debug("QUERY_CACHE: Retrieving first cached item", {
       queryHash,
       itemKey: JSON.stringify(itemKey)
     });
     const item = await cacheMap.get(itemKey);
     if (item) {
-      logger3.debug("QUERY_CACHE: Retrieved cached item successfully", {
+      logger5.debug("QUERY_CACHE: Retrieved cached item successfully", {
         queryHash,
         itemKey: JSON.stringify(itemKey),
         itemKeyStr: JSON.stringify(item.key)
       });
       return item;
     } else {
-      logger3.debug("QUERY_CACHE: Cached item MISSING from item cache, invalidating query cache", {
+      logger5.debug("QUERY_CACHE: Cached item MISSING from item cache, invalidating query cache", {
         queryHash,
         itemKey: JSON.stringify(itemKey)
       });
       cacheMap.deleteQueryResult(queryHash);
     }
   } else {
-    logger3.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
+    logger5.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
-  logger3.debug("QUERY_CACHE: Attempting direct cache query using queryIn()", {
+  logger5.debug("QUERY_CACHE: Attempting direct cache query using queryIn()", {
     queryHash,
     query: JSON.stringify(query),
     locations: JSON.stringify(locations)
@@ -1260,28 +1294,28 @@ async function executeOneLogic(query, locations, context) {
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger3.debug("QUERY_CACHE: Direct cache query SUCCESS - Found item in item cache", {
+      logger5.debug("QUERY_CACHE: Direct cache query SUCCESS - Found item in item cache", {
         queryHash,
         itemCount: directCachedItems.length,
         itemKeys: directCachedItems.map((item) => JSON.stringify(item.key))
       });
       const foundItem = directCachedItems[0];
       await cacheMap.setQueryResult(queryHash, [foundItem.key]);
-      logger3.debug("QUERY_CACHE: Stored query result from direct cache hit", {
+      logger5.debug("QUERY_CACHE: Stored query result from direct cache hit", {
         queryHash,
         itemKey: JSON.stringify(foundItem.key)
       });
       return foundItem;
     } else {
-      logger3.debug("QUERY_CACHE: Direct cache query returned no items", { queryHash });
+      logger5.debug("QUERY_CACHE: Direct cache query returned no items", { queryHash });
     }
   } catch (error) {
-    logger3.debug("QUERY_CACHE: Error querying cache directly, proceeding to API", {
+    logger5.debug("QUERY_CACHE: Error querying cache directly, proceeding to API", {
       queryHash,
       error: error instanceof Error ? error.message : String(error)
     });
   }
-  logger3.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+  logger5.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
     queryHash,
     query: JSON.stringify(query),
     locations: JSON.stringify(locations)
@@ -1290,11 +1324,11 @@ async function executeOneLogic(query, locations, context) {
   try {
     retItem = await api.one(query, locations);
     if (retItem) {
-      logger3.debug("QUERY_CACHE: API response received", {
+      logger5.debug("QUERY_CACHE: API response received", {
         queryHash,
         itemKey: JSON.stringify(retItem.key)
       });
-      logger3.debug("QUERY_CACHE: Storing item in item cache", {
+      logger5.debug("QUERY_CACHE: Storing item in item cache", {
         queryHash,
         itemKey: JSON.stringify(retItem.key)
       });
@@ -1317,35 +1351,35 @@ async function executeOneLogic(query, locations, context) {
       for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
         await cacheMap.delete(parsedKey);
-        logger3.debug("QUERY_CACHE: Evicted item due to cache limits", {
+        logger5.debug("QUERY_CACHE: Evicted item due to cache limits", {
           evictedKey,
           queryHash
         });
       }
       await cacheMap.setQueryResult(queryHash, [retItem.key]);
-      logger3.debug("QUERY_CACHE: Stored query result in query cache", {
+      logger5.debug("QUERY_CACHE: Stored query result in query cache", {
         queryHash,
         itemKey: JSON.stringify(retItem.key)
       });
     } else {
-      logger3.debug("QUERY_CACHE: API returned null, caching empty result", { queryHash });
+      logger5.debug("QUERY_CACHE: API returned null, caching empty result", { queryHash });
       await cacheMap.setQueryResult(queryHash, []);
-      logger3.debug("QUERY_CACHE: Cached empty query result", { queryHash });
+      logger5.debug("QUERY_CACHE: Cached empty query result", { queryHash });
     }
   } catch (e) {
     if (e instanceof NotFoundError2) {
-      logger3.debug("QUERY_CACHE: API returned NotFoundError, caching empty result", { queryHash });
+      logger5.debug("QUERY_CACHE: API returned NotFoundError, caching empty result", { queryHash });
       await cacheMap.setQueryResult(queryHash, []);
-      logger3.debug("QUERY_CACHE: Cached empty query result for not found", { queryHash });
+      logger5.debug("QUERY_CACHE: Cached empty query result for not found", { queryHash });
     } else {
-      logger3.debug("QUERY_CACHE: API error occurred", {
+      logger5.debug("QUERY_CACHE: API error occurred", {
         queryHash,
         error: e instanceof Error ? e.message : String(e)
       });
       throw e;
     }
   }
-  logger3.debug("QUERY_CACHE: one() operation completed", {
+  logger5.debug("QUERY_CACHE: one() operation completed", {
     queryHash,
     result: retItem ? JSON.stringify(retItem.key) : null
   });
@@ -1356,10 +1390,10 @@ async function executeOneLogic(query, locations, context) {
 import {
   createCreateWrapper
 } from "@fjell/core";
-var logger4 = logger_default.get("create");
+var logger6 = logger_default.get("create");
 var create = async (v, locations = [], context) => {
   const { coordinate } = context;
-  logger4.default("create", { v, locations });
+  logger6.default("create", { v, locations });
   const wrappedCreate = createCreateWrapper(
     coordinate,
     async (item, createOptions2) => {
@@ -1399,7 +1433,7 @@ import {
   createGetWrapper,
   isValidItemKey
 } from "@fjell/core";
-var logger5 = logger_default.get("get");
+var logger7 = logger_default.get("get");
 var inFlightRequests2 = /* @__PURE__ */ new Map();
 var CLEANUP_TIMEOUT = 5 * 60 * 1e3;
 var cleanupStaleRequests = () => {
@@ -1411,7 +1445,7 @@ var cleanupStaleRequests = () => {
     }
   });
   keysToDelete.forEach((key) => {
-    logger5.debug("Cleaning up stale in-flight request", { key });
+    logger7.debug("Cleaning up stale in-flight request", { key });
     inFlightRequests2.delete(key);
   });
 };
@@ -1419,7 +1453,7 @@ var cleanupInterval = setInterval(cleanupStaleRequests, 60 * 1e3);
 var keyToString = createNormalizedHashFunction();
 var get = async (key, context) => {
   const { api, cacheMap, pkType, ttlManager, statsManager, coordinate } = context;
-  logger5.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
+  logger7.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
   const wrappedGet = createGetWrapper(
     coordinate,
     async (k) => {
@@ -1433,7 +1467,7 @@ async function executeGetLogic(key, context) {
   const startTime = Date.now();
   const { api, cacheMap, pkType, ttlManager, statsManager } = context;
   const keyStr = JSON.stringify(key);
-  logger5.debug("CACHE_OP: get() started", {
+  logger7.debug("CACHE_OP: get() started", {
     key: keyStr,
     ttlEnabled: ttlManager.isTTLEnabled(),
     defaultTTL: ttlManager.getDefaultTTL(),
@@ -1441,32 +1475,32 @@ async function executeGetLogic(key, context) {
   });
   statsManager.incrementRequests();
   if (!isValidItemKey(key)) {
-    logger5.error("CACHE_OP: Invalid key for get", { key: keyStr });
+    logger7.error("CACHE_OP: Invalid key for get", { key: keyStr });
     throw new Error("Key for Get is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger5.debug("CACHE_OP: Cache bypass enabled, fetching directly from API", { key: keyStr });
+    logger7.debug("CACHE_OP: Cache bypass enabled, fetching directly from API", { key: keyStr });
     statsManager.incrementMisses();
     try {
       const apiStartTime = Date.now();
       const ret2 = await api.get(key);
       const apiDuration = Date.now() - apiStartTime;
       if (ret2) {
-        logger5.debug("CACHE_OP: API response received (bypass mode, not cached)", {
+        logger7.debug("CACHE_OP: API response received (bypass mode, not cached)", {
           key: keyStr,
           apiDuration,
           totalDuration: Date.now() - startTime
         });
         return ret2;
       } else {
-        logger5.debug("CACHE_OP: API returned null (bypass mode)", {
+        logger7.debug("CACHE_OP: API returned null (bypass mode)", {
           key: keyStr,
           apiDuration
         });
         return null;
       }
     } catch (error) {
-      logger5.error("CACHE_OP: API request failed in bypass mode", {
+      logger7.error("CACHE_OP: API request failed in bypass mode", {
         key: keyStr,
         duration: Date.now() - startTime,
         error
@@ -1479,7 +1513,7 @@ async function executeGetLogic(key, context) {
     const cachedItem = await cacheMap.get(key);
     const cacheCheckDuration = Date.now() - cacheCheckStart;
     if (cachedItem) {
-      logger5.debug("CACHE_OP: Item found in cache, checking TTL validity", {
+      logger7.debug("CACHE_OP: Item found in cache, checking TTL validity", {
         key: keyStr,
         cacheCheckDuration,
         defaultTTL: ttlManager.getDefaultTTL()
@@ -1489,7 +1523,7 @@ async function executeGetLogic(key, context) {
       const ttlCheckDuration = Date.now() - ttlCheckStart;
       if (isValid) {
         const totalDuration = Date.now() - startTime;
-        logger5.debug("CACHE_OP: Cache HIT with valid TTL", {
+        logger7.debug("CACHE_OP: Cache HIT with valid TTL", {
           key: keyStr,
           cacheCheckDuration,
           ttlCheckDuration,
@@ -1499,7 +1533,7 @@ async function executeGetLogic(key, context) {
         statsManager.incrementHits();
         return cachedItem;
       } else {
-        logger5.debug("CACHE_OP: Cache item EXPIRED, removing from cache", {
+        logger7.debug("CACHE_OP: Cache item EXPIRED, removing from cache", {
           key: keyStr,
           cacheCheckDuration,
           ttlCheckDuration
@@ -1508,13 +1542,13 @@ async function executeGetLogic(key, context) {
         statsManager.incrementMisses();
       }
     } else {
-      logger5.debug("CACHE_OP: Cache MISS (no item found)", {
+      logger7.debug("CACHE_OP: Cache MISS (no item found)", {
         key: keyStr,
         cacheCheckDuration
       });
       statsManager.incrementMisses();
     }
-    logger5.debug("CACHE_OP: Proceeding to API fetch (TTL-enabled cache miss or expired)", {
+    logger7.debug("CACHE_OP: Proceeding to API fetch (TTL-enabled cache miss or expired)", {
       key: keyStr,
       defaultTTL: ttlManager.getDefaultTTL()
     });
@@ -1524,7 +1558,7 @@ async function executeGetLogic(key, context) {
     const cacheCheckDuration = Date.now() - cacheCheckStart;
     if (cachedItem) {
       const totalDuration = Date.now() - startTime;
-      logger5.debug("CACHE_OP: Cache HIT (TTL disabled)", {
+      logger7.debug("CACHE_OP: Cache HIT (TTL disabled)", {
         key: keyStr,
         cacheCheckDuration,
         totalDuration
@@ -1532,7 +1566,7 @@ async function executeGetLogic(key, context) {
       statsManager.incrementHits();
       return cachedItem;
     } else {
-      logger5.debug("CACHE_OP: Cache MISS (TTL disabled)", {
+      logger7.debug("CACHE_OP: Cache MISS (TTL disabled)", {
         key: keyStr,
         cacheCheckDuration
       });
@@ -1546,7 +1580,7 @@ async function executeGetLogic(key, context) {
     let apiRequest;
     const apiStartTime = Date.now();
     if (!requestEntry) {
-      logger5.debug("CACHE_OP: Creating new API request", { key: keyStr });
+      logger7.debug("CACHE_OP: Creating new API request", { key: keyStr });
       apiRequest = api.get(key);
       if (apiRequest && typeof apiRequest.then === "function") {
         const timestamp = Date.now();
@@ -1559,7 +1593,7 @@ async function executeGetLogic(key, context) {
         }
       }
     } else {
-      logger5.debug("CACHE_OP: Using existing in-flight request", {
+      logger7.debug("CACHE_OP: Using existing in-flight request", {
         key: keyStr,
         requestAge: Date.now() - requestEntry.timestamp
       });
@@ -1568,7 +1602,7 @@ async function executeGetLogic(key, context) {
     ret = await apiRequest;
     const apiDuration = Date.now() - apiStartTime;
     if (ret) {
-      logger5.debug("CACHE_OP: API request successful, caching result", {
+      logger7.debug("CACHE_OP: API request successful, caching result", {
         key: keyStr,
         apiDuration,
         itemKeyMatches: JSON.stringify(ret.key) === keyStr
@@ -1590,7 +1624,7 @@ async function executeGetLogic(key, context) {
           estimatedSize
         };
         await cacheMap.setMetadata(itemKeyStr, baseMetadata);
-        logger5.debug("CACHE_OP: Created base metadata for cached item", {
+        logger7.debug("CACHE_OP: Created base metadata for cached item", {
           key: itemKeyStr,
           estimatedSize
         });
@@ -1600,7 +1634,7 @@ async function executeGetLogic(key, context) {
       const evictedKeys = await context.evictionManager.onItemAdded(itemKeyStr, ret, cacheMap);
       const evictionDuration = Date.now() - evictionStart;
       if (evictedKeys.length > 0) {
-        logger5.debug("CACHE_OP: Eviction triggered by new item", {
+        logger7.debug("CACHE_OP: Eviction triggered by new item", {
           key: itemKeyStr,
           evictedCount: evictedKeys.length,
           evictedKeys
@@ -1612,12 +1646,12 @@ async function executeGetLogic(key, context) {
       for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
         await cacheMap.delete(parsedKey);
-        logger5.debug("CACHE_OP: Removed evicted item", { evictedKey });
+        logger7.debug("CACHE_OP: Removed evicted item", { evictedKey });
       }
       const event = CacheEventFactory.itemRetrieved(ret.key, ret, "api");
       context.eventEmitter.emit(event);
       const totalDuration = Date.now() - startTime;
-      logger5.debug("CACHE_OP: get() completed successfully (cache miss)", {
+      logger7.debug("CACHE_OP: get() completed successfully (cache miss)", {
         key: keyStr,
         apiDuration,
         cacheSetDuration,
@@ -1628,7 +1662,7 @@ async function executeGetLogic(key, context) {
         evictedCount: evictedKeys.length
       });
     } else {
-      logger5.debug("CACHE_OP: API returned null", {
+      logger7.debug("CACHE_OP: API returned null", {
         key: keyStr,
         apiDuration,
         totalDuration: Date.now() - startTime
@@ -1637,7 +1671,7 @@ async function executeGetLogic(key, context) {
   } catch (e) {
     inFlightRequests2.delete(requestKeyStr);
     const duration = Date.now() - startTime;
-    logger5.error("CACHE_OP: Error in get() operation", {
+    logger7.error("CACHE_OP: Error in get() operation", {
       key: keyStr,
       duration,
       message: e.message,
@@ -1652,24 +1686,24 @@ async function executeGetLogic(key, context) {
 import {
   isValidItemKey as isValidItemKey2
 } from "@fjell/core";
-var logger6 = logger_default.get("retrieve");
+var logger8 = logger_default.get("retrieve");
 var retrieve = async (key, context) => {
   const startTime = Date.now();
   const { cacheMap, pkType, statsManager } = context;
   const keyStr = JSON.stringify(key);
-  logger6.default("retrieve", { key });
-  logger6.debug("CACHE_OP: retrieve() started", {
+  logger8.default("retrieve", { key });
+  logger8.debug("CACHE_OP: retrieve() started", {
     key: keyStr,
     cacheType: cacheMap.implementationType,
     bypassEnabled: !!context.options?.bypassCache
   });
   statsManager.incrementRequests();
   if (!isValidItemKey2(key)) {
-    logger6.error("CACHE_OP: Invalid key for retrieve", { key: keyStr });
+    logger8.error("CACHE_OP: Invalid key for retrieve", { key: keyStr });
     throw new Error("Key for Retrieve is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger6.debug("CACHE_OP: Cache bypass enabled, fetching directly from API", { key: keyStr });
+    logger8.debug("CACHE_OP: Cache bypass enabled, fetching directly from API", { key: keyStr });
     statsManager.incrementMisses();
     try {
       const apiStartTime = Date.now();
@@ -1677,14 +1711,14 @@ var retrieve = async (key, context) => {
       const retrieved2 = await api.get(key);
       const apiDuration = Date.now() - apiStartTime;
       if (retrieved2) {
-        logger6.debug("CACHE_OP: API response received (bypass mode)", {
+        logger8.debug("CACHE_OP: API response received (bypass mode)", {
           key: keyStr,
           apiDuration,
           hasValue: true
         });
         return [null, retrieved2];
       } else {
-        logger6.debug("CACHE_OP: API returned null (bypass mode)", {
+        logger8.debug("CACHE_OP: API returned null (bypass mode)", {
           key: keyStr,
           apiDuration
         });
@@ -1692,7 +1726,7 @@ var retrieve = async (key, context) => {
       }
     } catch (error) {
       const duration = Date.now() - startTime;
-      logger6.error("CACHE_OP: API request failed in bypass mode", {
+      logger8.error("CACHE_OP: API request failed in bypass mode", {
         key: keyStr,
         duration,
         error
@@ -1701,36 +1735,36 @@ var retrieve = async (key, context) => {
     }
   }
   const containsItemKey = await cacheMap.includesKey(key);
-  logger6.debug("CACHE_OP: Cache key check completed", {
+  logger8.debug("CACHE_OP: Cache key check completed", {
     key: keyStr,
     exists: containsItemKey
   });
   let retrieved;
   let contextToReturn;
   if (containsItemKey) {
-    logger6.default("Looking for Object in Cache", key);
-    logger6.debug("CACHE_OP: Cache HIT - retrieving from cache", { key: keyStr });
+    logger8.default("Looking for Object in Cache", key);
+    logger8.debug("CACHE_OP: Cache HIT - retrieving from cache", { key: keyStr });
     const getStartTime = Date.now();
     retrieved = await cacheMap.get(key);
     const getDuration = Date.now() - getStartTime;
     contextToReturn = null;
     statsManager.incrementHits();
     const totalDuration = Date.now() - startTime;
-    logger6.debug("CACHE_OP: retrieve() completed (cache hit)", {
+    logger8.debug("CACHE_OP: retrieve() completed (cache hit)", {
       key: keyStr,
       getDuration,
       totalDuration,
       hasValue: !!retrieved
     });
   } else {
-    logger6.default("Object Not Found in Cache, Retrieving from Server API", { key });
-    logger6.debug("CACHE_OP: Cache MISS - fetching from API", { key: keyStr });
+    logger8.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    logger8.debug("CACHE_OP: Cache MISS - fetching from API", { key: keyStr });
     statsManager.incrementMisses();
     const apiStartTime = Date.now();
     [contextToReturn, retrieved] = await get(key, context);
     const apiDuration = Date.now() - apiStartTime;
     const totalDuration = Date.now() - startTime;
-    logger6.debug("CACHE_OP: retrieve() completed (cache miss)", {
+    logger8.debug("CACHE_OP: retrieve() completed (cache miss)", {
       key: keyStr,
       apiDuration,
       totalDuration,
@@ -1749,10 +1783,10 @@ import {
   createRemoveWrapper,
   isValidItemKey as isValidItemKey3
 } from "@fjell/core";
-var logger7 = logger_default.get("remove");
+var logger9 = logger_default.get("remove");
 var remove = async (key, context) => {
   const { coordinate } = context;
-  logger7.default("remove", { key });
+  logger9.default("remove", { key });
   const wrappedRemove = createRemoveWrapper(
     coordinate,
     async (k) => {
@@ -1765,7 +1799,7 @@ var remove = async (key, context) => {
 async function executeRemoveLogic(key, context) {
   const { api, cacheMap } = context;
   if (!isValidItemKey3(key)) {
-    logger7.error("Key for Remove is not a valid ItemKey: %j", key);
+    logger9.error("Key for Remove is not a valid ItemKey: %j", key);
     throw new Error("Key for Remove is not a valid ItemKey");
   }
   try {
@@ -1783,9 +1817,9 @@ async function executeRemoveLogic(key, context) {
       { source: "operation", context: { operation: "remove" } }
     );
     context.eventEmitter.emit(queryInvalidatedEvent);
-    logger7.debug("Successfully removed item from API and cache", { key });
+    logger9.debug("Successfully removed item from API and cache", { key });
   } catch (e) {
-    logger7.error("Error deleting item", { error: e });
+    logger9.error("Error deleting item", { error: e });
     throw e;
   }
 }
@@ -1795,10 +1829,10 @@ import {
   createUpdateWrapper,
   isValidItemKey as isValidItemKey4
 } from "@fjell/core";
-var logger8 = logger_default.get("update");
+var logger10 = logger_default.get("update");
 var update = async (key, v, context) => {
   const { coordinate } = context;
-  logger8.default("update", { key, v });
+  logger10.default("update", { key, v });
   const wrappedUpdate = createUpdateWrapper(
     coordinate,
     async (k, item) => {
@@ -1811,16 +1845,16 @@ var update = async (key, v, context) => {
 async function executeUpdateLogic(key, v, context) {
   const { api, cacheMap, pkType } = context;
   if (!isValidItemKey4(key)) {
-    logger8.error("Key for Update is not a valid ItemKey: %j", key);
+    logger10.error("Key for Update is not a valid ItemKey: %j", key);
     throw new Error("Key for Update is not a valid ItemKey");
   }
-  logger8.debug("Invalidating item key before update", { key });
+  logger10.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);
-    logger8.debug("Caching update result", { updatedKey: updated.key });
+    logger10.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);
@@ -1853,7 +1887,7 @@ async function executeUpdateLogic(key, v, context) {
     context.eventEmitter.emit(queryInvalidatedEvent);
     return updated;
   } catch (e) {
-    logger8.error("Error updating item", { error: e });
+    logger10.error("Error updating item", { error: e });
     throw e;
   }
 }
@@ -1866,7 +1900,7 @@ import {
 
 // src/utils/cacheInvalidation.ts
 import { toKeyTypeArray } from "@fjell/core";
-var logger9 = logger_default.get("cache", "utils", "cacheInvalidation");
+var logger11 = logger_default.get("cache", "utils", "cacheInvalidation");
 var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   const keys = [];
   const keyTypeArrays = [];
@@ -1883,7 +1917,7 @@ var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   return { keys, keyTypeArrays };
 };
 var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) => {
-  logger9.debug("Invalidating caches by keys and key types", {
+  logger11.debug("Invalidating caches by keys and key types", {
     keysCount: keys.length,
     keyTypeArrays
   });
@@ -1901,22 +1935,22 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger9.debug("Found cache instance for targeted invalidation", {
+        logger11.debug("Found cache instance for targeted invalidation", {
           keyTypes,
           cacheType: cacheInstance.coordinate.kta,
           keysToInvalidate: cacheKeys.length
         });
         await cacheInstance.cacheMap.invalidateItemKeys(cacheKeys);
         await cacheInstance.cacheMap.clearQueryResults();
-        logger9.debug("Successfully invalidated specific items in cache", {
+        logger11.debug("Successfully invalidated specific items in cache", {
           keyTypes,
           invalidatedCount: cacheKeys.length
         });
       } else {
-        logger9.debug("No cache instance found for key types", { keyTypes });
+        logger11.debug("No cache instance found for key types", { keyTypes });
       }
     } catch (error) {
-      logger9.warning("Failed to invalidate cache for key types", {
+      logger11.warning("Failed to invalidate cache for key types", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1926,12 +1960,12 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger9.debug("Handling location-based invalidation", { keyTypes });
+        logger11.debug("Handling location-based invalidation", { keyTypes });
         await cacheInstance.cacheMap.clearQueryResults();
-        logger9.debug("Successfully cleared query results for location", { keyTypes });
+        logger11.debug("Successfully cleared query results for location", { keyTypes });
       }
     } catch (error) {
-      logger9.warning("Failed to handle location-based invalidation", {
+      logger11.warning("Failed to handle location-based invalidation", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1942,7 +1976,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) => {
-  logger9.debug("Handling action cache invalidation", {
+  logger11.debug("Handling action cache invalidation", {
     affectedItemsCount: affectedItems.length
   });
   const { keys, keyTypeArrays } = extractKeysAndKeyTypesFromActionResult(affectedItems);
@@ -1950,10 +1984,10 @@ var handleActionCacheInvalidation = async (registry, affectedItems) => {
 };
 
 // src/ops/action.ts
-var logger10 = logger_default.get("action");
+var logger12 = logger_default.get("action");
 var action = async (key, action2, body = {}, context) => {
   const { coordinate } = context;
-  logger10.default("action", { key, action: action2, body });
+  logger12.default("action", { key, action: action2, body });
   const wrappedAction = createActionWrapper(
     coordinate,
     async (k, a, b) => {
@@ -1966,28 +2000,28 @@ var action = async (key, action2, body = {}, context) => {
 async function executeActionLogic(key, action2, body, context) {
   const { api, cacheMap, pkType, registry } = context;
   if (!isValidItemKey5(key)) {
-    logger10.error("Key for Action is not a valid ItemKey: %j", key);
+    logger12.error("Key for Action is not a valid ItemKey: %j", key);
     throw new Error("Key for Action is not a valid ItemKey");
   }
-  logger10.debug("Invalidating item key before action", { key });
+  logger12.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) {
-    logger10.debug("Handling cache invalidation for affected items", {
+    logger12.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", {
+      logger12.warning("Failed to handle cache invalidation for affected items", {
         error: error instanceof Error ? error.message : String(error),
         affectedItems
       });
     }
   }
-  logger10.debug("Caching action result", { updatedKey: updated.key });
+  logger12.debug("Caching action result", { updatedKey: updated.key });
   cacheMap.set(updated.key, updated);
   const keyStr = JSON.stringify(updated.key);
   context.ttlManager.onItemAdded(keyStr, cacheMap);
@@ -1997,19 +2031,19 @@ async function executeActionLogic(key, action2, body, context) {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
     } catch (error) {
-      logger10.error("Failed to parse evicted key during deletion", {
+      logger12.error("Failed to parse evicted key during deletion", {
         evictedKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   }
-  logger10.debug("Emitting itemUpdated event after action", {
+  logger12.debug("Emitting itemUpdated event after action", {
     key: updated.key,
     action: action2
   });
   const itemEvent = CacheEventFactory.itemUpdated(updated.key, updated, null, "api");
   context.eventEmitter.emit(itemEvent);
-  logger10.debug("Emitting queryInvalidatedEvent after action", {
+  logger12.debug("Emitting queryInvalidatedEvent after action", {
     eventType: "query_invalidated",
     reason: "item_changed",
     action: action2
@@ -2029,10 +2063,10 @@ import {
   createAllActionWrapper
 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
-var logger11 = logger_default.get("allAction");
+var logger13 = logger_default.get("allAction");
 var allAction = async (action2, body = {}, locations = [], context) => {
   const { coordinate } = context;
-  logger11.default("allAction", { action: action2, body, locations });
+  logger13.default("allAction", { action: action2, body, locations });
   const wrappedAllAction = createAllActionWrapper(
     coordinate,
     async (a, b, locs) => {
@@ -2052,10 +2086,10 @@ async function executeAllActionLogic(action2, body, locations, context) {
         existingItems.push(...cachedItems);
       }
     } catch (error) {
-      logger11.debug("Could not retrieve existing items for comparison", { error });
+      logger13.debug("Could not retrieve existing items for comparison", { error });
     }
   }
-  logger11.debug("Invalidating location before allAction", { locations });
+  logger13.debug("Invalidating location before allAction", { locations });
   await cacheMap.invalidateLocation(locations);
   let ret = [];
   let affectedItems = [];
@@ -2065,7 +2099,7 @@ async function executeAllActionLogic(action2, body, locations, context) {
       ret = result[0];
       affectedItems = result[1];
     } else {
-      logger11.warning("Unexpected result format from allAction", {
+      logger13.warning("Unexpected result format from allAction", {
         resultType: typeof result,
         isArray: Array.isArray(result),
         resultLength: Array.isArray(result) ? result.length : "not array"
@@ -2074,19 +2108,19 @@ async function executeAllActionLogic(action2, body, locations, context) {
       affectedItems = [];
     }
     if (affectedItems && affectedItems.length > 0) {
-      logger11.debug("Handling cache invalidation for affected items", {
+      logger13.debug("Handling cache invalidation for affected items", {
         affectedItemsCount: affectedItems.length
       });
       try {
         await handleActionCacheInvalidation(registry, affectedItems);
       } catch (error) {
-        logger11.warning("Failed to handle cache invalidation for affected items", {
+        logger13.warning("Failed to handle cache invalidation for affected items", {
           error: error instanceof Error ? error.message : String(error),
           affectedItems
         });
       }
     }
-    logger11.debug("Caching allAction results", { resultCount: ret.length });
+    logger13.debug("Caching allAction results", { resultCount: ret.length });
     const modifiedItems = [];
     const newItems = [];
     for (const v of ret) {
@@ -2108,7 +2142,7 @@ async function executeAllActionLogic(action2, body, locations, context) {
       }
     }
     for (const item of modifiedItems) {
-      logger11.debug("Emitting item_updated event for modified item", { key: item.key });
+      logger13.debug("Emitting item_updated event for modified item", { key: item.key });
       const itemEvent = CacheEventFactory.itemUpdated(
         item.key,
         item,
@@ -2119,7 +2153,7 @@ async function executeAllActionLogic(action2, body, locations, context) {
       eventEmitter.emit(itemEvent);
     }
     for (const item of newItems) {
-      logger11.debug("Emitting item_created event for new item", { key: item.key });
+      logger13.debug("Emitting item_created event for new item", { key: item.key });
       const itemEvent = CacheEventFactory.itemCreated(
         item.key,
         item,
@@ -2129,14 +2163,14 @@ async function executeAllActionLogic(action2, body, locations, context) {
     }
     if (modifiedItems.length > 0) {
       const modifiedKeys = modifiedItems.map((item) => item.key);
-      logger11.debug("Invalidating individual item keys for modified items", {
+      logger13.debug("Invalidating individual item keys for modified items", {
         keyCount: modifiedKeys.length,
         keys: modifiedKeys
       });
       await cacheMap.invalidateItemKeys(modifiedKeys);
     }
     await cacheMap.clearQueryResults();
-    logger11.debug("Emitting query_invalidated event after allAction", {
+    logger13.debug("Emitting query_invalidated event after allAction", {
       eventType: "query_invalidated",
       reason: "item_changed",
       action: action2,
@@ -2169,10 +2203,10 @@ async function executeAllActionLogic(action2, body, locations, context) {
 import {
   createFacetWrapper
 } from "@fjell/core";
-var logger12 = logger_default.get("facet");
+var logger14 = logger_default.get("facet");
 var facet = async (key, facet2, params = {}, context) => {
   const { coordinate, api } = context;
-  logger12.default("facet", { key, facet: facet2 });
+  logger14.default("facet", { key, facet: facet2 });
   const wrappedFacet = createFacetWrapper(
     coordinate,
     async (k, f, p) => {
@@ -2186,10 +2220,10 @@ var facet = async (key, facet2, params = {}, context) => {
 import {
   createAllFacetWrapper
 } from "@fjell/core";
-var logger13 = logger_default.get("allFacet");
+var logger15 = logger_default.get("allFacet");
 var allFacet = async (facet2, params = {}, locations = [], context) => {
   const { api, coordinate } = context;
-  logger13.default("allFacet", { facet: facet2, params, locations });
+  logger15.default("allFacet", { facet: facet2, params, locations });
   const wrappedAllFacet = createAllFacetWrapper(
     coordinate,
     async (f, p, locs) => {
@@ -2203,10 +2237,10 @@ var allFacet = async (facet2, params = {}, locations = [], context) => {
 import {
   createFindWrapper
 } from "@fjell/core";
-var logger14 = logger_default.get("find");
+var logger16 = logger_default.get("find");
 var find = async (finder, params = {}, locations = [], context, findOptions) => {
   const { coordinate } = context;
-  logger14.default("find", { finder, params, locations, findOptions });
+  logger16.default("find", { finder, params, locations, findOptions });
   const wrappedFind = createFindWrapper(
     coordinate,
     async (f, p, locs, opts) => {
@@ -2236,90 +2270,97 @@ async function executeFindLogic(finder, params, locations, context, findOptions)
     }
   });
   if (context.options?.bypassCache) {
-    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations, findOptions });
+    logger16.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations, findOptions });
     try {
       const ret2 = await api.find(finder, params, locations, findOptions);
-      logger14.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.items.length, total: ret2.metadata.total });
+      logger16.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.items.length, total: ret2.metadata.total });
       return ret2;
     } catch (error) {
-      logger14.error("API request failed", { finder, params, locations, findOptions, error });
+      logger16.error("API request failed", { finder, params, locations, findOptions, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, params, locations);
-  logger14.debug("QUERY_CACHE: Generated query hash for find()", {
+  logger16.debug("QUERY_CACHE: Generated query hash for find()", {
     queryHash,
     finder,
     params: JSON.stringify(params),
     locations: JSON.stringify(locations)
   });
-  logger14.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
-  const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
-  if (cachedItemKeys) {
-    logger14.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
-      queryHash,
-      cachedKeyCount: cachedItemKeys.length,
-      itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
-    });
-    const cachedItems = [];
-    let allItemsAvailable = true;
-    const missingKeys = [];
-    for (const itemKey of cachedItemKeys) {
-      const item = await cacheMap.get(itemKey);
-      if (item) {
-        cachedItems.push(item);
-        logger14.debug("QUERY_CACHE: Retrieved cached item", {
-          itemKey: JSON.stringify(itemKey),
-          itemKeyStr: JSON.stringify(item.key)
-        });
-      } else {
-        allItemsAvailable = false;
-        missingKeys.push(itemKey);
-        logger14.debug("QUERY_CACHE: Cached item MISSING from item cache", {
-          itemKey: JSON.stringify(itemKey),
-          queryHash
-        });
-        break;
-      }
-    }
-    if (allItemsAvailable) {
-      logger14.debug("QUERY_CACHE: All cached items available, returning from cache", {
+  logger16.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
+  try {
+    const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
+    if (cachedItemKeys) {
+      logger16.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
         queryHash,
-        itemCount: cachedItems.length
+        cachedKeyCount: cachedItemKeys.length,
+        itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
       });
-      let paginatedItems = cachedItems;
-      const offset = findOptions?.offset ?? 0;
-      const limit = findOptions?.limit;
-      if (offset > 0) {
-        paginatedItems = paginatedItems.slice(offset);
-      }
-      if (limit != null && limit >= 0) {
-        paginatedItems = paginatedItems.slice(0, limit);
+      const cachedItems = [];
+      let allItemsAvailable = true;
+      const missingKeys = [];
+      for (const itemKey of cachedItemKeys) {
+        const item = await cacheMap.get(itemKey);
+        if (item) {
+          cachedItems.push(item);
+          logger16.debug("QUERY_CACHE: Retrieved cached item", {
+            itemKey: JSON.stringify(itemKey),
+            itemKeyStr: JSON.stringify(item.key)
+          });
+        } else {
+          allItemsAvailable = false;
+          missingKeys.push(itemKey);
+          logger16.debug("QUERY_CACHE: Cached item MISSING from item cache", {
+            itemKey: JSON.stringify(itemKey),
+            queryHash
+          });
+          break;
+        }
       }
-      return {
-        items: paginatedItems,
-        metadata: {
-          total: cachedItems.length,
-          // Total before pagination
-          returned: paginatedItems.length,
-          offset,
-          limit,
-          hasMore: limit != null && offset + paginatedItems.length < cachedItems.length
+      if (allItemsAvailable) {
+        logger16.debug("QUERY_CACHE: All cached items available, returning from cache", {
+          queryHash,
+          itemCount: cachedItems.length
+        });
+        let paginatedItems = cachedItems;
+        const offset = findOptions?.offset ?? 0;
+        const limit = findOptions?.limit;
+        if (offset > 0) {
+          paginatedItems = paginatedItems.slice(offset);
         }
-      };
+        if (limit != null && limit >= 0) {
+          paginatedItems = paginatedItems.slice(0, limit);
+        }
+        return {
+          items: paginatedItems,
+          metadata: {
+            total: cachedItems.length,
+            // Total before pagination
+            returned: paginatedItems.length,
+            offset,
+            limit,
+            hasMore: limit != null && offset + paginatedItems.length < cachedItems.length
+          }
+        };
+      } else {
+        logger16.debug("QUERY_CACHE: Some cached items missing, invalidating query cache", {
+          queryHash,
+          missingKeys: missingKeys.map((k) => JSON.stringify(k)),
+          foundCount: cachedItems.length,
+          expectedCount: cachedItemKeys.length
+        });
+        cacheMap.deleteQueryResult(queryHash);
+      }
     } else {
-      logger14.debug("QUERY_CACHE: Some cached items missing, invalidating query cache", {
-        queryHash,
-        missingKeys: missingKeys.map((k) => JSON.stringify(k)),
-        foundCount: cachedItems.length,
-        expectedCount: cachedItemKeys.length
-      });
-      cacheMap.deleteQueryResult(queryHash);
+      logger16.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
     }
-  } else {
-    logger14.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
+  } catch (error) {
+    logger16.error("QUERY_CACHE: Error checking query cache, falling back to API", {
+      queryHash,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
-  logger14.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+  logger16.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
     queryHash,
     finder,
     params: JSON.stringify(params),
@@ -2327,19 +2368,19 @@ async function executeFindLogic(finder, params, locations, context, findOptions)
     findOptions
   });
   const ret = await api.find(finder, params, locations, findOptions);
-  logger14.debug("QUERY_CACHE: API response received", {
+  logger16.debug("QUERY_CACHE: API response received", {
     queryHash,
     itemCount: ret.items.length,
     total: ret.metadata.total,
     itemKeys: ret.items.map((item) => JSON.stringify(item.key))
   });
-  logger14.debug("QUERY_CACHE: Storing items in item cache", {
+  logger16.debug("QUERY_CACHE: Storing items in item cache", {
     queryHash,
     itemCount: ret.items.length
   });
   for (const v of ret.items) {
     await cacheMap.set(v.key, v);
-    logger14.debug("QUERY_CACHE: Stored item in cache", {
+    logger16.debug("QUERY_CACHE: Stored item in cache", {
       itemKey: JSON.stringify(v.key),
       queryHash
     });
@@ -2349,7 +2390,7 @@ async function executeFindLogic(finder, params, locations, context, findOptions)
     for (const evictedKey of evictedKeys) {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
-      logger14.debug("QUERY_CACHE: Evicted item due to cache limits", {
+      logger16.debug("QUERY_CACHE: Evicted item due to cache limits", {
         evictedKey,
         queryHash
       });
@@ -2357,15 +2398,15 @@ async function executeFindLogic(finder, params, locations, context, findOptions)
   }
   const itemKeys = ret.items.map((item) => item.key);
   await cacheMap.setQueryResult(queryHash, itemKeys);
-  logger14.debug("QUERY_CACHE: Stored query result in query cache", {
+  logger16.debug("QUERY_CACHE: Stored query result in query cache", {
     queryHash,
     itemKeyCount: itemKeys.length,
     itemKeys: itemKeys.map((k) => JSON.stringify(k))
   });
   const event = CacheEventFactory.createQueryEvent(params, locations, ret.items);
   eventEmitter.emit(event);
-  logger14.debug("QUERY_CACHE: Emitted query event", { queryHash });
-  logger14.debug("QUERY_CACHE: find() operation completed", {
+  logger16.debug("QUERY_CACHE: Emitted query event", { queryHash });
+  logger16.debug("QUERY_CACHE: find() operation completed", {
     queryHash,
     resultCount: ret.items.length,
     total: ret.metadata.total
@@ -2377,10 +2418,10 @@ async function executeFindLogic(finder, params, locations, context, findOptions)
 import {
   createFindOneWrapper
 } from "@fjell/core";
-var logger15 = logger_default.get("findOne");
+var logger17 = logger_default.get("findOne");
 var findOne = async (finder, finderParams = {}, locations = [], context) => {
   const { coordinate } = context;
-  logger15.default("findOne", { finder, finderParams, locations });
+  logger17.default("findOne", { finder, finderParams, locations });
   const wrappedFindOne = createFindOneWrapper(
     coordinate,
     async (f, p, locs) => {
@@ -2393,58 +2434,58 @@ var findOne = async (finder, finderParams = {}, locations = [], context) => {
 async function executeFindOneLogic(finder, finderParams, locations, context) {
   const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
   if (context.options?.bypassCache) {
-    logger15.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
+    logger17.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
     try {
       const ret2 = await api.findOne(finder, finderParams, locations);
       if (ret2 === null) {
         throw new Error(`findOne returned null for finder: ${finder}`);
       }
-      logger15.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
+      logger17.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
       return ret2;
     } catch (error) {
-      logger15.error("API request failed", { finder, finderParams, locations, error });
+      logger17.error("API request failed", { finder, finderParams, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, finderParams, locations);
-  logger15.debug("QUERY_CACHE: Generated query hash for findOne()", {
+  logger17.debug("QUERY_CACHE: Generated query hash for findOne()", {
     queryHash,
     finder,
     finderParams: JSON.stringify(finderParams),
     locations: JSON.stringify(locations)
   });
-  logger15.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
+  logger17.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys && cachedItemKeys.length > 0) {
-    logger15.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+    logger17.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
       queryHash,
       cachedKeyCount: cachedItemKeys.length,
       itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
     });
     const itemKey = cachedItemKeys[0];
-    logger15.debug("QUERY_CACHE: Retrieving first cached item", {
+    logger17.debug("QUERY_CACHE: Retrieving first cached item", {
       queryHash,
       itemKey: JSON.stringify(itemKey)
     });
     const item = await cacheMap.get(itemKey);
     if (item) {
-      logger15.debug("QUERY_CACHE: Retrieved cached item successfully", {
+      logger17.debug("QUERY_CACHE: Retrieved cached item successfully", {
         queryHash,
         itemKey: JSON.stringify(itemKey),
         itemKeyStr: JSON.stringify(item.key)
       });
       return item;
     } else {
-      logger15.debug("QUERY_CACHE: Cached item MISSING from item cache, invalidating query cache", {
+      logger17.debug("QUERY_CACHE: Cached item MISSING from item cache, invalidating query cache", {
         queryHash,
         itemKey: JSON.stringify(itemKey)
       });
       cacheMap.deleteQueryResult(queryHash);
     }
   } else {
-    logger15.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
+    logger17.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
-  logger15.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+  logger17.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
     queryHash,
     finder,
     finderParams: JSON.stringify(finderParams),
@@ -2452,14 +2493,14 @@ async function executeFindOneLogic(finder, finderParams, locations, context) {
   });
   const ret = await api.findOne(finder, finderParams, locations);
   if (ret === null) {
-    logger15.debug("QUERY_CACHE: API returned null, throwing error", { queryHash, finder });
+    logger17.debug("QUERY_CACHE: API returned null, throwing error", { queryHash, finder });
     throw new Error(`findOne returned null for finder: ${finder}`);
   }
-  logger15.debug("QUERY_CACHE: API response received", {
+  logger17.debug("QUERY_CACHE: API response received", {
     queryHash,
     itemKey: JSON.stringify(ret.key)
   });
-  logger15.debug("QUERY_CACHE: Storing item in item cache", {
+  logger17.debug("QUERY_CACHE: Storing item in item cache", {
     queryHash,
     itemKey: JSON.stringify(ret.key)
   });
@@ -2470,20 +2511,20 @@ async function executeFindOneLogic(finder, finderParams, locations, context) {
   for (const evictedKey of evictedKeys) {
     const parsedKey = JSON.parse(evictedKey);
     await cacheMap.delete(parsedKey);
-    logger15.debug("QUERY_CACHE: Evicted item due to cache limits", {
+    logger17.debug("QUERY_CACHE: Evicted item due to cache limits", {
       evictedKey,
       queryHash
     });
   }
   await cacheMap.setQueryResult(queryHash, [ret.key]);
-  logger15.debug("QUERY_CACHE: Stored query result in query cache", {
+  logger17.debug("QUERY_CACHE: Stored query result in query cache", {
     queryHash,
     itemKey: JSON.stringify(ret.key)
   });
   const event = CacheEventFactory.createQueryEvent(finderParams, locations, [ret]);
   eventEmitter.emit(event);
-  logger15.debug("QUERY_CACHE: Emitted query event", { queryHash });
-  logger15.debug("QUERY_CACHE: findOne() operation completed", {
+  logger17.debug("QUERY_CACHE: Emitted query event", { queryHash });
+  logger17.debug("QUERY_CACHE: findOne() operation completed", {
     queryHash,
     itemKey: JSON.stringify(ret.key)
   });
@@ -2495,7 +2536,7 @@ import {
   isItemKeyEqual,
   isValidItemKey as isValidItemKey6
 } from "@fjell/core";
-var logger16 = logger_default.get("set");
+var logger18 = logger_default.get("set");
 var normalizeKeyValue2 = (value) => {
   return String(value);
 };
@@ -2547,17 +2588,17 @@ var set = async (key, v, context) => {
   const startTime = Date.now();
   const { cacheMap, pkType, ttlManager, evictionManager, eventEmitter } = context;
   const keyStr = JSON.stringify(key);
-  logger16.default("set", { key, v });
-  logger16.debug("CACHE_OP: set() started", {
+  logger18.default("set", { key, v });
+  logger18.debug("CACHE_OP: set() started", {
     key: keyStr,
     cacheType: cacheMap.implementationType
   });
   if (!isValidItemKey6(key)) {
-    logger16.error("CACHE_OP: Invalid key for set", { key: keyStr });
+    logger18.error("CACHE_OP: Invalid key for set", { key: keyStr });
     throw new Error("Key for Set is not a valid ItemKey");
   }
   if (!isItemKeyEqualNormalized(key, v.key)) {
-    logger16.error("CACHE_OP: Key mismatch in set", {
+    logger18.error("CACHE_OP: Key mismatch in set", {
       providedKey: keyStr,
       itemKey: JSON.stringify(v.key)
     });
@@ -2566,7 +2607,7 @@ var set = async (key, v, context) => {
   const checkStartTime = Date.now();
   const previousItem = await cacheMap.get(key);
   const checkDuration = Date.now() - checkStartTime;
-  logger16.debug("CACHE_OP: Previous item check", {
+  logger18.debug("CACHE_OP: Previous item check", {
     key: keyStr,
     hadPreviousItem: !!previousItem,
     checkDuration
@@ -2587,12 +2628,12 @@ var set = async (key, v, context) => {
       estimatedSize
     };
     await cacheMap.setMetadata(keyStr, baseMetadata);
-    logger16.debug("CACHE_OP: Created base metadata", {
+    logger18.debug("CACHE_OP: Created base metadata", {
       key: keyStr,
       estimatedSize
     });
   } else {
-    logger16.debug("CACHE_OP: Metadata already exists", {
+    logger18.debug("CACHE_OP: Metadata already exists", {
       key: keyStr,
       addedAt: new Date(metadata.addedAt).toISOString(),
       accessCount: metadata.accessCount
@@ -2606,7 +2647,7 @@ var set = async (key, v, context) => {
   const evictedKeys = await evictionManager.onItemAdded(keyStr, v, cacheMap);
   const evictionDuration = Date.now() - evictionStartTime;
   if (evictedKeys.length > 0) {
-    logger16.debug("CACHE_OP: Eviction triggered by set", {
+    logger18.debug("CACHE_OP: Eviction triggered by set", {
       key: keyStr,
       evictedCount: evictedKeys.length,
       evictedKeys
@@ -2615,12 +2656,12 @@ var set = async (key, v, context) => {
   for (const evictedKey of evictedKeys) {
     const parsedKey = JSON.parse(evictedKey);
     await cacheMap.delete(parsedKey);
-    logger16.debug("CACHE_OP: Removed evicted item", { evictedKey });
+    logger18.debug("CACHE_OP: Removed evicted item", { evictedKey });
   }
   const event = CacheEventFactory.itemSet(key, v, previousItem);
   eventEmitter.emit(event);
   const totalDuration = Date.now() - startTime;
-  logger16.debug("CACHE_OP: set() completed", {
+  logger18.debug("CACHE_OP: set() completed", {
     key: keyStr,
     checkDuration,
     setDuration,
@@ -2639,7 +2680,7 @@ import {
   isComKey,
   isQueryMatch
 } from "@fjell/core";
-var logger17 = logger_default.get("MemoryCacheMap");
+var logger19 = logger_default.get("MemoryCacheMap");
 var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   implementationType = "memory/memory";
   map = {};
@@ -2657,13 +2698,13 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger17.error("Failed to parse initial data key", { keyStr, error });
+          logger19.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger17.trace("get", { key });
+    logger19.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -2678,7 +2719,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger17.trace("set", { key, value });
+    logger19.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const keyStr = JSON.stringify(key);
     this.map[hashedKey] = { originalKey: key, value };
@@ -2705,7 +2746,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
   }
   async delete(key) {
-    logger17.trace("delete", { key });
+    logger19.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -2734,10 +2775,10 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger17.debug("Returning all items, LocKeys is empty");
+      logger19.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger17.debug("allIn", { locations, count: allValues.length });
+      logger19.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey(key)) {
@@ -2749,12 +2790,12 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger17.debug("contains", { query, locations });
+    logger19.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch(item, query));
   }
   async queryIn(query, locations = []) {
-    logger17.debug("queryIn", { query, locations });
+    logger19.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch(item, query));
   }
@@ -2776,32 +2817,45 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return clone;
   }
   // Query result caching methods implementation
-  async setQueryResult(queryHash, itemKeys) {
-    logger17.trace("setQueryResult", { queryHash, itemKeys });
+  async setQueryResult(queryHash, itemKeys, metadata) {
+    logger19.trace("setQueryResult", { queryHash, itemKeys, hasMetadata: !!metadata });
     const entry = {
-      itemKeys: [...itemKeys]
+      itemKeys: [...itemKeys],
       // Create a copy to avoid external mutations
+      metadata
     };
     this.queryResultCache[queryHash] = entry;
   }
   async getQueryResult(queryHash) {
-    logger17.trace("getQueryResult", { queryHash });
+    logger19.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
     }
     return [...entry.itemKeys];
   }
+  async getQueryResultWithMetadata(queryHash) {
+    logger19.trace("getQueryResultWithMetadata", { queryHash });
+    const entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      return null;
+    }
+    return {
+      itemKeys: [...entry.itemKeys],
+      // Return a copy to avoid external mutations
+      metadata: entry.metadata
+    };
+  }
   async hasQueryResult(queryHash) {
     const entry = this.queryResultCache[queryHash];
     return !!entry;
   }
   async deleteQueryResult(queryHash) {
-    logger17.trace("deleteQueryResult", { queryHash });
+    logger19.trace("deleteQueryResult", { queryHash });
     delete this.queryResultCache[queryHash];
   }
   async invalidateItemKeys(keys) {
-    logger17.debug("invalidateItemKeys", { keys });
+    logger19.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2832,14 +2886,14 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       this.deleteQueryResult(queryHash);
     });
-    logger17.debug("Selectively invalidated queries referencing affected keys", {
+    logger19.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
     });
   }
   async invalidateLocation(locations) {
-    logger17.debug("invalidateLocation", { locations });
+    logger19.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2852,7 +2906,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     await this.invalidateItemKeys(keysToInvalidate);
   }
   async clearQueryResults() {
-    logger17.trace("clearQueryResults");
+    logger19.trace("clearQueryResults");
     this.queryResultCache = {};
   }
   // CacheMapMetadataProvider implementation
@@ -2894,7 +2948,7 @@ import {
   isComKey as isComKey2,
   isQueryMatch as isQueryMatch2
 } from "@fjell/core";
-var logger18 = logger_default.get("EnhancedMemoryCacheMap");
+var logger20 = logger_default.get("EnhancedMemoryCacheMap");
 var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   implementationType = "memory/enhanced";
   map = {};
@@ -2913,11 +2967,11 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.normalizedHashFunction = createNormalizedHashFunction();
     if (sizeConfig?.maxSizeBytes) {
       this.maxSizeBytes = parseSizeString(sizeConfig.maxSizeBytes);
-      logger18.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
+      logger20.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
     }
     if (sizeConfig?.maxItems) {
       this.maxItems = sizeConfig.maxItems;
-      logger18.debug("Cache item limit set", { maxItems: this.maxItems });
+      logger20.debug("Cache item limit set", { maxItems: this.maxItems });
     }
     if (initialData) {
       for (const [keyStr, value] of Object.entries(initialData)) {
@@ -2925,13 +2979,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger18.error("Failed to parse initial data key", { keyStr, error });
+          logger20.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger18.trace("get", { key });
+    logger20.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey && entry.value !== null) {
@@ -2940,7 +2994,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger18.trace("set", { key, value });
+    logger20.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const estimatedSize = estimateValueSize(value);
     const existingEntry = this.map[hashedKey];
@@ -2951,7 +3005,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const oldValue = existingEntry.value;
       existingEntry.value = value;
       existingEntry.metadata.estimatedSize = estimatedSize;
-      logger18.trace("Updated existing cache entry", {
+      logger20.trace("Updated existing cache entry", {
         key: hashedKey,
         sizeDiff,
         currentSize: this.currentSizeBytes,
@@ -2972,7 +3026,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       };
       this.currentSizeBytes += estimatedSize;
       this.currentItemCount++;
-      logger18.trace("Added new cache entry", {
+      logger20.trace("Added new cache entry", {
         key: hashedKey,
         size: estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -2989,14 +3043,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.deleteInternal(key, true, "filter");
   }
   deleteInternal(key, invalidateQueries = false, invalidationMode = "remove") {
-    logger18.trace("delete", { key });
+    logger20.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];
-      logger18.trace("Deleted cache entry", {
+      logger20.trace("Deleted cache entry", {
         key: hashedKey,
         freedSize: entry.metadata.estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -3018,7 +3072,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.value);
   }
   async clear() {
-    logger18.debug("Clearing cache", {
+    logger20.debug("Clearing cache", {
       itemsCleared: this.currentItemCount,
       bytesFreed: this.currentSizeBytes
     });
@@ -3029,10 +3083,10 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger18.debug("Returning all items, LocKeys is empty");
+      logger20.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger18.debug("allIn", { locations, count: allValues.length });
+      logger20.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey2(key)) {
@@ -3043,12 +3097,12 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger18.debug("contains", { query, locations });
+    logger20.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch2(item, query));
   }
   async queryIn(query, locations = []) {
-    logger18.debug("queryIn", { query, locations });
+    logger20.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch2(item, query));
   }
@@ -3093,26 +3147,39 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return stats;
   }
   // Query result caching methods
-  async setQueryResult(queryHash, itemKeys) {
-    logger18.trace("setQueryResult", { queryHash, itemKeys });
+  async setQueryResult(queryHash, itemKeys, metadata) {
+    logger20.trace("setQueryResult", { queryHash, itemKeys, hasMetadata: !!metadata });
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
     }
     const entry = {
-      itemKeys: [...itemKeys]
+      itemKeys: [...itemKeys],
       // Create a copy to avoid external mutations
+      metadata
     };
     this.queryResultCache[queryHash] = entry;
     this.addQueryResultToSizeTracking(queryHash, entry);
   }
   async getQueryResult(queryHash) {
-    logger18.trace("getQueryResult", { queryHash });
+    logger20.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
     }
     return [...entry.itemKeys];
   }
+  async getQueryResultWithMetadata(queryHash) {
+    logger20.trace("getQueryResultWithMetadata", { queryHash });
+    const entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      return null;
+    }
+    return {
+      itemKeys: [...entry.itemKeys],
+      // Return a copy to avoid external mutations
+      metadata: entry.metadata
+    };
+  }
   async hasQueryResult(queryHash) {
     const entry = this.queryResultCache[queryHash];
     return !!entry;
@@ -3128,7 +3195,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.queryResultsCacheSize = 0;
   }
   async invalidateItemKeys(keys) {
-    logger18.debug("invalidateItemKeys", { keys });
+    logger20.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3178,7 +3245,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     });
   }
   async invalidateLocation(locations) {
-    logger18.debug("invalidateLocation", { locations });
+    logger20.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -3198,7 +3265,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     const itemKeysSize = estimateValueSize(entry.itemKeys);
     const totalSize = hashSize + itemKeysSize;
     this.queryResultsCacheSize += totalSize;
-    logger18.trace("Added query result to size tracking", {
+    logger20.trace("Added query result to size tracking", {
       queryHash,
       estimatedSize: totalSize,
       totalQueryCacheSize: this.queryResultsCacheSize
@@ -3214,7 +3281,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const itemKeysSize = estimateValueSize(entry.itemKeys);
       const totalSize = hashSize + itemKeysSize;
       this.queryResultsCacheSize = Math.max(0, this.queryResultsCacheSize - totalSize);
-      logger18.trace("Removed query result from size tracking", {
+      logger20.trace("Removed query result from size tracking", {
         queryHash,
         estimatedSize: totalSize,
         totalQueryCacheSize: this.queryResultsCacheSize
@@ -3299,7 +3366,7 @@ import {
   isComKey as isComKey3,
   isQueryMatch as isQueryMatch3
 } from "@fjell/core";
-var logger19 = logger_default.get("LocalStorageCacheMap");
+var logger21 = logger_default.get("LocalStorageCacheMap");
 var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
   implementationType = "browser/localStorage";
   keyPrefix;
@@ -3314,6 +3381,10 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
   }
   getStorageKey(key) {
     const hashedKey = this.normalizedHashFunction(key);
+    if (!hashedKey || typeof hashedKey !== "string" || hashedKey.trim() === "") {
+      logger21.error("Invalid storage key generated from normalizedHashFunction", { key, hashedKey });
+      throw new Error(`Invalid storage key generated for key: ${JSON.stringify(key)}`);
+    }
     return `${this.keyPrefix}:${hashedKey}`;
   }
   isQuotaExceededError(error) {
@@ -3330,7 +3401,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return keys;
     } catch (error) {
-      logger19.error("Error getting keys by prefix from localStorage", { prefix, error });
+      logger21.error("Error getting keys by prefix from localStorage", { prefix, error });
       throw error;
     }
   }
@@ -3338,12 +3409,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       const allEntries = this.collectCacheEntries();
       if (allEntries.length === 0) {
-        logger19.debug("No entries to clean up");
+        logger21.debug("No entries to clean up");
         return false;
       }
       return this.removeOldestEntries(allEntries, aggressive);
     } catch (error) {
-      logger19.error("Failed to cleanup old localStorage entries", { error });
+      logger21.error("Failed to cleanup old localStorage entries", { error });
       return false;
     }
   }
@@ -3369,7 +3440,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           }
         }
       } catch (error) {
-        logger19.debug("Found corrupted entry during cleanup", { key, error });
+        logger21.debug("Found corrupted entry during cleanup", { key, error });
         allEntries.push({ key, timestamp: 0, size: 0 });
       }
     }
@@ -3388,12 +3459,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         removedCount++;
         removedSize += allEntries[i].size;
       } catch (error) {
-        logger19.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
+        logger21.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
       }
     }
     if (removedCount > 0) {
       const cleanupType = aggressive ? "aggressive" : "normal";
-      logger19.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
+      logger21.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
     }
     return removedCount > 0;
   }
@@ -3401,7 +3472,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     return this.getAllKeysStartingWith(`${this.keyPrefix}:`);
   }
   async get(key) {
-    logger19.trace("get", { key });
+    logger21.trace("get", { key });
     try {
       const storageKey = this.getStorageKey(key);
       let stored = localStorage.getItem(storageKey);
@@ -3416,18 +3487,18 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             return parsed.value;
           }
         } catch (parseError) {
-          logger19.debug("Failed to parse stored value", { key, error: parseError });
+          logger21.debug("Failed to parse stored value", { key, error: parseError });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger19.error("Error retrieving from localStorage", { key, error });
+      logger21.error("Error retrieving from localStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
-    logger19.trace("set", { key, value });
+    logger21.trace("set", { key, value });
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
         const storageKey = this.getStorageKey(key);
@@ -3438,12 +3509,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         };
         localStorage.setItem(storageKey, JSON.stringify(toStore));
         if (attempt > 0) {
-          logger19.info(`Successfully stored item after ${attempt} retries`);
+          logger21.info(`Successfully stored item after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger19.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger21.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           value,
           error,
@@ -3470,30 +3541,30 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           const parsed = JSON.parse(stored);
           return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
         } catch (parseError) {
-          logger19.debug("Failed to parse stored value in includesKey", { key, error: parseError });
+          logger21.debug("Failed to parse stored value in includesKey", { key, error: parseError });
           return false;
         }
       }
       return false;
     } catch (error) {
-      logger19.error("Error checking key in localStorage", { key, error });
+      logger21.error("Error checking key in localStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger19.trace("delete", { key });
+    logger21.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       localStorage.removeItem(storageKey);
     } catch (error) {
-      logger19.error("Error deleting from localStorage", { key, error });
+      logger21.error("Error deleting from localStorage", { key, error });
       throw error;
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger19.debug("Returning all items, LocKeys is empty");
+      logger21.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -3505,10 +3576,10 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger21.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey3(key)).filter((key) => {
         const ComKey16 = key;
-        logger19.debug("Comparing Location Keys", {
+        logger21.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey16
         });
@@ -3525,12 +3596,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger19.debug("contains", { query, locations });
+    logger21.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch3(item, query));
   }
   async queryIn(query, locations = []) {
-    logger19.debug("queryIn", { query, locations });
+    logger21.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch3(item, query));
   }
@@ -3544,7 +3615,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         return JSON.parse(stored);
       }
     } catch (parseError) {
-      logger19.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
+      logger21.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
     }
     return null;
   }
@@ -3559,7 +3630,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger19.error("Error getting keys from localStorage", { error });
+      logger21.error("Error getting keys from localStorage", { error });
     }
     return keys;
   }
@@ -3574,37 +3645,46 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger19.error("Error getting values from localStorage", { error });
+      logger21.error("Error getting values from localStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger19.debug("Clearing localStorage cache");
+    logger21.debug("Clearing localStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         localStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger19.error("Error clearing localStorage cache", { error });
+      logger21.error("Error clearing localStorage cache", { error });
       throw error;
     }
   }
   // Query result caching methods implementation
-  async setQueryResult(queryHash, itemKeys) {
-    logger19.trace("setQueryResult", { queryHash, itemKeys });
+  async setQueryResult(queryHash, itemKeys, metadata) {
+    logger21.trace("setQueryResult", { queryHash, itemKeys, hasMetadata: !!metadata });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger21.error("Invalid queryHash provided to setQueryResult", { queryHash, itemKeys });
+      throw new Error(`Invalid queryHash: ${JSON.stringify(queryHash)}`);
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
-      itemKeys
+      itemKeys,
+      metadata
     };
     try {
       localStorage.setItem(queryKey, JSON.stringify(entry));
     } catch (error) {
-      logger19.error("Failed to store query result in localStorage", { queryHash, error });
+      logger21.error("Failed to store query result in localStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger19.trace("getQueryResult", { queryHash });
+    logger21.trace("getQueryResult", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger21.error("Invalid queryHash provided to getQueryResult", { queryHash });
+      return null;
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = localStorage.getItem(queryKey);
@@ -3617,30 +3697,71 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger19.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      logger21.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      return null;
+    }
+  }
+  async getQueryResultWithMetadata(queryHash) {
+    logger21.trace("getQueryResultWithMetadata", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger21.error("Invalid queryHash provided to getQueryResultWithMetadata", { queryHash });
+      return null;
+    }
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    try {
+      const data = localStorage.getItem(queryKey);
+      if (!data) {
+        return null;
+      }
+      const entry = JSON.parse(data);
+      if (Array.isArray(entry)) {
+        return { itemKeys: entry, metadata: void 0 };
+      }
+      if (entry.metadata) {
+        if (entry.metadata.createdAt) {
+          entry.metadata.createdAt = new Date(entry.metadata.createdAt);
+        }
+        if (entry.metadata.expiresAt) {
+          entry.metadata.expiresAt = new Date(entry.metadata.expiresAt);
+        }
+      }
+      return {
+        itemKeys: entry.itemKeys || [],
+        metadata: entry.metadata
+      };
+    } catch (error) {
+      logger21.error("Failed to retrieve query result with metadata from localStorage", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger21.error("Invalid queryHash provided to hasQueryResult", { queryHash });
+      return false;
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       return localStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger19.error("Failed to check query result in localStorage", { queryHash, error });
+      logger21.error("Failed to check query result in localStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger19.trace("deleteQueryResult", { queryHash });
+    logger21.trace("deleteQueryResult", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger21.error("Invalid queryHash provided to deleteQueryResult", { queryHash });
+      return;
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       localStorage.removeItem(queryKey);
     } catch (error) {
-      logger19.error("Failed to delete query result from localStorage", { queryHash, error });
+      logger21.error("Failed to delete query result from localStorage", { queryHash, error });
     }
   }
   async invalidateItemKeys(keys) {
-    logger19.debug("invalidateItemKeys", { keys });
+    logger21.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3678,24 +3799,24 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger19.debug("Failed to parse query result", { queryKey, error });
+          logger21.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         localStorage.removeItem(queryKey);
       });
-      logger19.debug("Selectively invalidated queries referencing affected keys", {
+      logger21.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 });
+      logger21.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger19.debug("invalidateLocation", { locations });
+    logger21.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -3710,7 +3831,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async clearQueryResults() {
-    logger19.trace("clearQueryResults");
+    logger21.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = this.getAllKeysStartingWith(queryPrefix);
@@ -3718,11 +3839,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           localStorage.removeItem(key);
         } catch (error) {
-          logger19.error("Failed to remove query result from localStorage", { key, error });
+          logger21.error("Failed to remove query result from localStorage", { key, error });
         }
       }
     } catch (error) {
-      logger19.error("Failed to clear query results from localStorage", { error });
+      logger21.error("Failed to clear query results from localStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -3734,13 +3855,13 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           return JSON.parse(stored);
         } catch (e) {
-          logger19.debug("Invalid metadata JSON, treating as null", { key, error: e });
+          logger21.debug("Invalid metadata JSON, treating as null", { key, error: e });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger19.error("Error getting metadata from localStorage", { key, error });
+      logger21.error("Error getting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -3750,12 +3871,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         const metadataKey = `${this.keyPrefix}:metadata:${key}`;
         localStorage.setItem(metadataKey, JSON.stringify(metadata));
         if (attempt > 0) {
-          logger19.info(`Successfully stored metadata after ${attempt} retries`);
+          logger21.info(`Successfully stored metadata after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger19.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger21.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           error,
           isLastAttempt
@@ -3777,7 +3898,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       localStorage.removeItem(metadataKey);
     } catch (error) {
-      logger19.error("Error deleting metadata from localStorage", { key, error });
+      logger21.error("Error deleting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -3796,11 +3917,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             metadata.set(metadataKey, parsed);
           }
         } catch (error) {
-          logger19.debug("Skipping invalid metadata entry", { key, error });
+          logger21.debug("Skipping invalid metadata entry", { key, error });
         }
       }
     } catch (error) {
-      logger19.error("Error getting metadata from localStorage", { error });
+      logger21.error("Error getting metadata from localStorage", { error });
       throw error;
     }
     return metadata;
@@ -3811,7 +3932,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const keysToDelete = this.getAllKeysStartingWith(metadataPrefix);
       keysToDelete.forEach((key) => localStorage.removeItem(key));
     } catch (error) {
-      logger19.error("Error clearing metadata from localStorage", { error });
+      logger21.error("Error clearing metadata from localStorage", { error });
       throw error;
     }
   }
@@ -3838,16 +3959,16 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
                 itemCount++;
               }
             } catch (error) {
-              logger19.debug("Invalid entry in getCurrentSize", { key, error });
+              logger21.debug("Invalid entry in getCurrentSize", { key, error });
             }
           }
         } catch (error) {
-          logger19.debug("Size calculation failed, using string length", { key, error });
+          logger21.debug("Size calculation failed, using string length", { key, error });
           sizeBytes += value.length;
         }
       }
     } catch (error) {
-      logger19.error("Error calculating size from localStorage", { error });
+      logger21.error("Error calculating size from localStorage", { error });
       throw error;
     }
     return { itemCount, sizeBytes };
@@ -3868,7 +3989,7 @@ import {
   isQueryMatch as isQueryMatch4
 } from "@fjell/core";
 import safeStringify2 from "fast-safe-stringify";
-var logger20 = logger_default.get("SessionStorageCacheMap");
+var logger22 = logger_default.get("SessionStorageCacheMap");
 var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   implementationType = "browser/sessionStorage";
   keyPrefix;
@@ -3883,6 +4004,10 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
   getStorageKey(key) {
     const hashedKey = this.normalizedHashFunction(key);
+    if (!hashedKey || typeof hashedKey !== "string" || hashedKey.trim() === "") {
+      logger22.error("Invalid storage key generated from normalizedHashFunction", { key, hashedKey });
+      throw new Error(`Invalid storage key generated for key: ${JSON.stringify(key)}`);
+    }
     return `${this.keyPrefix}:${hashedKey}`;
   }
   // Using flatted for safe circular serialization; no manual replacer needed
@@ -3896,7 +4021,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger20.error("Error getting keys from sessionStorage", { error });
+      logger22.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -3919,7 +4044,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async get(key) {
-    logger20.trace("get", { key });
+    logger22.trace("get", { key });
     try {
       const currentHash = this.normalizedHashFunction(key);
       if (this.hasCollisionForHash(currentHash)) {
@@ -3939,14 +4064,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return null;
     } catch (error) {
-      logger20.error("Error retrieving from sessionStorage", { key, error });
+      logger22.error("Error retrieving from sessionStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
     try {
       const storageKey = this.getStorageKey(key);
-      logger20.trace("set", { storageKey });
+      logger22.trace("set", { storageKey });
       const toStore = {
         originalKey: key,
         value,
@@ -3956,7 +4081,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(toStore);
       sessionStorage.setItem(storageKey, jsonString);
     } catch (error) {
-      logger20.error("Error storing to sessionStorage", { errorMessage: error?.message });
+      logger22.error("Error storing to sessionStorage", { errorMessage: error?.message });
       throw new Error(`Failed to store item in sessionStorage: ${error}`);
     }
   }
@@ -3977,23 +4102,23 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return false;
     } catch (error) {
-      logger20.error("Error checking key in sessionStorage", { key, error });
+      logger22.error("Error checking key in sessionStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger20.trace("delete", { key });
+    logger22.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       sessionStorage.removeItem(storageKey);
     } catch (error) {
-      logger20.error("Error deleting from sessionStorage", { key, error });
+      logger22.error("Error deleting from sessionStorage", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger20.debug("Returning all items, LocKeys is empty");
+      logger22.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -4005,10 +4130,10 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger20.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger22.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey4(key)).filter((key) => {
         const ComKey16 = key;
-        logger20.debug("Comparing Location Keys", {
+        logger22.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey16
         });
@@ -4025,12 +4150,12 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger20.debug("contains", { query, locations });
+    logger22.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch4(item, query));
   }
   async queryIn(query, locations = []) {
-    logger20.debug("queryIn", { query, locations });
+    logger22.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch4(item, query));
   }
@@ -4050,11 +4175,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             keys.push(parsed.originalKey);
           }
         } catch (itemError) {
-          logger20.trace("Skipping invalid storage item", { storageKey, error: itemError });
+          logger22.trace("Skipping invalid storage item", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger20.error("Error getting keys from sessionStorage", { error });
+      logger22.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -4071,41 +4196,50 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             values.push(parsed.value);
           }
         } catch (itemError) {
-          logger20.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
+          logger22.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger20.error("Error getting values from sessionStorage", { error });
+      logger22.error("Error getting values from sessionStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger20.debug("Clearing sessionStorage cache");
+    logger22.debug("Clearing sessionStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         sessionStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger20.error("Error clearing sessionStorage cache", { error });
+      logger22.error("Error clearing sessionStorage cache", { error });
     }
   }
   // Query result caching methods implementation
-  async setQueryResult(queryHash, itemKeys) {
-    logger20.trace("setQueryResult", { queryHash, itemKeys });
+  async setQueryResult(queryHash, itemKeys, metadata) {
+    logger22.trace("setQueryResult", { queryHash, itemKeys, hasMetadata: !!metadata });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger22.error("Invalid queryHash provided to setQueryResult", { queryHash, itemKeys });
+      throw new Error(`Invalid queryHash: ${JSON.stringify(queryHash)}`);
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
-      itemKeys
+      itemKeys,
+      metadata
     };
     try {
       const jsonString = safeStringify2(entry);
       sessionStorage.setItem(queryKey, jsonString);
     } catch (error) {
-      logger20.error("Failed to store query result in sessionStorage", { queryHash, error });
+      logger22.error("Failed to store query result in sessionStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger20.trace("getQueryResult", { queryHash });
+    logger22.trace("getQueryResult", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger22.error("Invalid queryHash provided to getQueryResult", { queryHash });
+      return null;
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = sessionStorage.getItem(queryKey);
@@ -4118,30 +4252,71 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger20.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      logger22.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      return null;
+    }
+  }
+  async getQueryResultWithMetadata(queryHash) {
+    logger22.trace("getQueryResultWithMetadata", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger22.error("Invalid queryHash provided to getQueryResultWithMetadata", { queryHash });
+      return null;
+    }
+    const queryKey = `${this.keyPrefix}:query:${queryHash}`;
+    try {
+      const data = sessionStorage.getItem(queryKey);
+      if (!data) {
+        return null;
+      }
+      const entry = JSON.parse(data);
+      if (Array.isArray(entry)) {
+        return { itemKeys: entry, metadata: void 0 };
+      }
+      if (entry.metadata) {
+        if (entry.metadata.createdAt) {
+          entry.metadata.createdAt = new Date(entry.metadata.createdAt);
+        }
+        if (entry.metadata.expiresAt) {
+          entry.metadata.expiresAt = new Date(entry.metadata.expiresAt);
+        }
+      }
+      return {
+        itemKeys: entry.itemKeys || [],
+        metadata: entry.metadata
+      };
+    } catch (error) {
+      logger22.error("Failed to retrieve query result with metadata from sessionStorage", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger22.error("Invalid queryHash provided to hasQueryResult", { queryHash });
+      return false;
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       return sessionStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger20.error("Failed to check query result in sessionStorage", { queryHash, error });
+      logger22.error("Failed to check query result in sessionStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger20.trace("deleteQueryResult", { queryHash });
+    logger22.trace("deleteQueryResult", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger22.error("Invalid queryHash provided to deleteQueryResult", { queryHash });
+      return;
+    }
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       sessionStorage.removeItem(queryKey);
     } catch (error) {
-      logger20.error("Failed to delete query result from sessionStorage", { queryHash, error });
+      logger22.error("Failed to delete query result from sessionStorage", { queryHash, error });
     }
   }
   async clearQueryResults() {
-    logger20.trace("clearQueryResults");
+    logger22.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = [];
@@ -4153,7 +4328,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       keysToRemove.forEach((key) => sessionStorage.removeItem(key));
     } catch (error) {
-      logger20.error("Failed to clear query results from sessionStorage", { error });
+      logger22.error("Failed to clear query results from sessionStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -4200,7 +4375,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return metadata;
     } catch (error) {
-      logger20.error("Error getting all metadata from sessionStorage", { error });
+      logger22.error("Error getting all metadata from sessionStorage", { error });
       return metadata;
     }
   }
@@ -4220,7 +4395,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger20.debug("invalidateItemKeys", { keys });
+    logger22.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -4264,24 +4439,24 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger20.debug("Failed to parse query result", { queryKey, error });
+          logger22.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         sessionStorage.removeItem(queryKey);
       });
-      logger20.debug("Selectively invalidated queries referencing affected keys", {
+      logger22.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.length
       });
     } catch (error) {
-      logger20.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger22.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger20.debug("invalidateLocation", { locations });
+    logger22.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -4347,7 +4522,7 @@ import {
   isQueryMatch as isQueryMatch5
 } from "@fjell/core";
 import safeStringify3 from "fast-safe-stringify";
-var logger21 = logger_default.get("AsyncIndexDBCacheMap");
+var logger23 = logger_default.get("AsyncIndexDBCacheMap");
 var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   types;
   dbName;
@@ -4373,19 +4548,19 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         }
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger21.error("Error opening IndexedDB", { error: request.error });
+          logger23.error("Error opening IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
-          logger21.debug("IndexedDB opened successfully");
+          logger23.debug("IndexedDB opened successfully");
           resolve(request.result);
         };
         request.onupgradeneeded = (event) => {
-          logger21.debug("IndexedDB upgrade needed");
+          logger23.debug("IndexedDB upgrade needed");
           const db = event.target.result;
           if (!db.objectStoreNames.contains(this.storeName)) {
             db.createObjectStore(this.storeName);
-            logger21.debug("Created object store", { storeName: this.storeName });
+            logger23.debug("Created object store", { storeName: this.storeName });
           }
         };
       });
@@ -4393,32 +4568,48 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     return this.dbPromise;
   }
   getStorageKey(key) {
-    return this.normalizedHashFunction(key);
+    const storageKey = this.normalizedHashFunction(key);
+    if (!storageKey || typeof storageKey !== "string" || storageKey.trim() === "") {
+      logger23.error("Invalid storage key generated from normalizedHashFunction", { key, storageKey });
+      throw new Error(`Invalid storage key generated for key: ${JSON.stringify(key)}`);
+    }
+    return storageKey;
   }
   async get(key) {
-    logger21.trace("get", { key });
+    logger23.trace("get", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
       const store = transaction.objectStore(this.storeName);
-      const storageKey = this.getStorageKey(key);
+      let storageKey;
+      try {
+        storageKey = this.getStorageKey(key);
+      } catch (keyError) {
+        logger23.error("Failed to generate storage key", { key, error: keyError });
+        return null;
+      }
       return new Promise((resolve, reject) => {
-        const request = store.get(storageKey);
-        request.onerror = () => {
-          logger21.error("Error getting from IndexedDB", { key, error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          const stored = request.result;
-          if (stored && this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key)) {
-            resolve(stored.value);
-          } else {
-            resolve(null);
-          }
-        };
+        try {
+          const request = store.get(storageKey);
+          request.onerror = () => {
+            logger23.error("Error getting from IndexedDB", { key, storageKey, error: request.error });
+            reject(request.error);
+          };
+          request.onsuccess = () => {
+            const stored = request.result;
+            if (stored && this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key)) {
+              resolve(stored.value);
+            } else {
+              resolve(null);
+            }
+          };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB request", { key, storageKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB get operation", { key, error });
+      logger23.error("Error in IndexedDB get operation", { key, error });
       return null;
     }
   }
@@ -4426,42 +4617,59 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Get both the value and metadata for an item
    */
   async getWithMetadata(key) {
-    logger21.trace("getWithMetadata", { key });
+    logger23.trace("getWithMetadata", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
       const store = transaction.objectStore(this.storeName);
-      const storageKey = this.getStorageKey(key);
+      let storageKey;
+      try {
+        storageKey = this.getStorageKey(key);
+      } catch (keyError) {
+        logger23.error("Failed to generate storage key for getWithMetadata", { key, error: keyError });
+        return null;
+      }
       return new Promise((resolve, reject) => {
-        const request = store.get(storageKey);
-        request.onerror = () => {
-          logger21.error("Error getting from IndexedDB", { key, error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          const stored = request.result;
-          if (stored && this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key)) {
-            resolve({
-              value: stored.value,
-              metadata: stored.metadata
-            });
-          } else {
-            resolve(null);
-          }
-        };
+        try {
+          const request = store.get(storageKey);
+          request.onerror = () => {
+            logger23.error("Error getting from IndexedDB", { key, storageKey, error: request.error });
+            reject(request.error);
+          };
+          request.onsuccess = () => {
+            const stored = request.result;
+            if (stored && this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key)) {
+              resolve({
+                value: stored.value,
+                metadata: stored.metadata
+              });
+            } else {
+              resolve(null);
+            }
+          };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB request for getWithMetadata", { key, storageKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB getWithMetadata operation", { key, error });
+      logger23.error("Error in IndexedDB getWithMetadata operation", { key, error });
       return null;
     }
   }
   async set(key, value, metadata) {
-    logger21.trace("set", { key, value, hasMetadata: !!metadata });
+    logger23.trace("set", { key, value, hasMetadata: !!metadata });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
       const store = transaction.objectStore(this.storeName);
-      const storageKey = this.getStorageKey(key);
+      let storageKey;
+      try {
+        storageKey = this.getStorageKey(key);
+      } catch (keyError) {
+        logger23.error("Failed to generate storage key for set", { key, error: keyError });
+        throw new Error(`Failed to generate storage key: ${keyError}`);
+      }
       const storedItem = {
         originalKey: key,
         value,
@@ -4469,17 +4677,22 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         version: _AsyncIndexDBCacheMap.CURRENT_VERSION
       };
       return new Promise((resolve, reject) => {
-        const request = store.put(storedItem, storageKey);
-        request.onerror = () => {
-          logger21.error("Error setting in IndexedDB", { key, value, error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          resolve();
-        };
+        try {
+          const request = store.put(storedItem, storageKey);
+          request.onerror = () => {
+            logger23.error("Error setting in IndexedDB", { key, storageKey, value, error: request.error });
+            reject(request.error);
+          };
+          request.onsuccess = () => {
+            resolve();
+          };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB put request", { key, storageKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB set operation", { key, value, error });
+      logger23.error("Error in IndexedDB set operation", { key, value, error });
       throw new Error(`Failed to store item in IndexedDB: ${error}`);
     }
   }
@@ -4487,16 +4700,16 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Update only the metadata for an existing item
    */
   async setMetadata(key, metadata) {
-    logger21.trace("setMetadata", { key, metadata });
+    logger23.trace("setMetadata", { key, metadata });
     try {
       const existing = await this.getWithMetadata(key);
       if (existing) {
         await this.set(key, existing.value, metadata);
       } else {
-        logger21.warning("Attempted to set metadata for non-existent item", { key });
+        logger23.warning("Attempted to set metadata for non-existent item", { key });
       }
     } catch (error) {
-      logger21.error("Error in IndexedDB setMetadata operation", { key, error });
+      logger23.error("Error in IndexedDB setMetadata operation", { key, error });
       throw new Error(`Failed to update metadata in IndexedDB: ${error}`);
     }
   }
@@ -4505,62 +4718,84 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
       const store = transaction.objectStore(this.storeName);
-      const storageKey = this.getStorageKey(key);
+      let storageKey;
+      try {
+        storageKey = this.getStorageKey(key);
+      } catch (keyError) {
+        logger23.error("Failed to generate storage key for includesKey", { key, error: keyError });
+        return false;
+      }
       return new Promise((resolve, reject) => {
-        const request = store.get(storageKey);
-        request.onerror = () => {
-          logger21.error("Error checking key in IndexedDB", { key, error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          const stored = request.result;
-          if (stored) {
-            const matches = this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key);
-            resolve(matches);
-          } else {
-            resolve(false);
-          }
-        };
+        try {
+          const request = store.get(storageKey);
+          request.onerror = () => {
+            logger23.error("Error checking key in IndexedDB", { key, storageKey, error: request.error });
+            reject(request.error);
+          };
+          request.onsuccess = () => {
+            const stored = request.result;
+            if (stored) {
+              const matches = this.normalizedHashFunction(stored.originalKey) === this.normalizedHashFunction(key);
+              resolve(matches);
+            } else {
+              resolve(false);
+            }
+          };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB request for includesKey", { key, storageKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB includesKey operation", { key, error });
+      logger23.error("Error in IndexedDB includesKey operation", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger21.trace("delete", { key });
+    logger23.trace("delete", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
       const store = transaction.objectStore(this.storeName);
-      const storageKey = this.getStorageKey(key);
+      let storageKey;
+      try {
+        storageKey = this.getStorageKey(key);
+      } catch (keyError) {
+        logger23.error("Failed to generate storage key for delete", { key, error: keyError });
+        return;
+      }
       return new Promise((resolve, reject) => {
-        const request = store.delete(storageKey);
-        request.onerror = () => {
-          logger21.error("Error deleting from IndexedDB", { key, error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          resolve();
-        };
+        try {
+          const request = store.delete(storageKey);
+          request.onerror = () => {
+            logger23.error("Error deleting from IndexedDB", { key, storageKey, error: request.error });
+            reject(request.error);
+          };
+          request.onsuccess = () => {
+            resolve();
+          };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB delete request", { key, storageKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB delete operation", { key, error });
+      logger23.error("Error in IndexedDB delete operation", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = await this.keys();
     if (locations.length === 0) {
-      logger21.debug("Returning all items, LocKeys is empty");
+      logger23.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;
-      logger21.debug("allIn", { locKeys, keys: allKeys.length });
+      logger23.debug("allIn", { locKeys, keys: allKeys.length });
       const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
         const ComKey16 = key;
-        logger21.debug("Comparing Location Keys", {
+        logger23.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey16
         });
@@ -4572,12 +4807,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async contains(query, locations) {
-    logger21.debug("contains", { query, locations });
+    logger23.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch5(item, query));
   }
   async queryIn(query, locations = []) {
-    logger21.debug("queryIn", { query, locations });
+    logger23.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch5(item, query));
   }
@@ -4593,7 +4828,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger21.error("Error getting keys from IndexedDB", { error: request.error });
+          logger23.error("Error getting keys from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -4608,7 +4843,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB keys operation", { error });
+      logger23.error("Error in IndexedDB keys operation", { error });
       return [];
     }
   }
@@ -4624,7 +4859,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger21.error("Error getting metadata from IndexedDB", { error: request.error });
+          logger23.error("Error getting metadata from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -4642,7 +4877,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB getAllMetadata operation", { error });
+      logger23.error("Error in IndexedDB getAllMetadata operation", { error });
       return metadataMap;
     }
   }
@@ -4655,7 +4890,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger21.error("Error getting values from IndexedDB", { error: request.error });
+          logger23.error("Error getting values from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -4670,12 +4905,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB values operation", { error });
+      logger23.error("Error in IndexedDB values operation", { error });
       return [];
     }
   }
   async clear() {
-    logger21.debug("Clearing IndexedDB cache");
+    logger23.debug("Clearing IndexedDB cache");
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -4683,7 +4918,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.clear();
         request.onerror = () => {
-          logger21.error("Error clearing IndexedDB cache", { error: request.error });
+          logger23.error("Error clearing IndexedDB cache", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -4691,59 +4926,61 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB clear operation", { error });
+      logger23.error("Error in IndexedDB clear operation", { error });
     }
   }
   // Async Query result caching methods
-  async setQueryResult(queryHash, itemKeys) {
-    logger21.trace("setQueryResult", { queryHash, itemKeys });
+  async setQueryResult(queryHash, itemKeys, metadata) {
+    logger23.trace("setQueryResult", { queryHash, itemKeys, hasMetadata: !!metadata });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger23.error("Invalid queryHash provided to setQueryResult", { queryHash, itemKeys });
+      throw new Error(`Invalid queryHash: ${JSON.stringify(queryHash)}`);
+    }
     try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const entry = {
+        itemKeys,
+        metadata: metadata || void 0
+      };
+      const queryKey = `query:${queryHash}`;
       return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.version);
-        request.onerror = () => {
-          logger21.error("Failed to open database for setQueryResult", { error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          const db = request.result;
-          const transaction = db.transaction([this.storeName], "readwrite");
-          const store = transaction.objectStore(this.storeName);
-          const entry = {
-            itemKeys
-          };
-          const queryKey = `query:${queryHash}`;
+        try {
           const putRequest = store.put(safeStringify3(entry), queryKey);
           putRequest.onerror = () => {
-            logger21.error("Failed to store query result", { queryHash, error: putRequest.error });
+            logger23.error("Failed to store query result", { queryHash, error: putRequest.error });
             reject(putRequest.error);
           };
           putRequest.onsuccess = () => {
             resolve();
           };
-        };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB put request for query result", { queryHash, queryKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in setQueryResult", { queryHash, error });
+      logger23.error("Error in setQueryResult", { queryHash, error });
       throw error;
     }
   }
   async getQueryResult(queryHash) {
-    logger21.trace("getQueryResult", { queryHash });
+    logger23.trace("getQueryResult", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger23.error("Invalid queryHash provided to getQueryResult", { queryHash });
+      return null;
+    }
     try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const queryKey = `query:${queryHash}`;
       return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.version);
-        request.onerror = () => {
-          logger21.error("Failed to open database for getQueryResult", { error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          const db = request.result;
-          const transaction = db.transaction([this.storeName], "readonly");
-          const store = transaction.objectStore(this.storeName);
-          const queryKey = `query:${queryHash}`;
+        try {
           const getRequest = store.get(queryKey);
           getRequest.onerror = () => {
-            logger21.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
+            logger23.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
             reject(getRequest.error);
           };
           getRequest.onsuccess = () => {
@@ -4760,58 +4997,120 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               }
               resolve(entry.itemKeys || null);
             } catch (parseError) {
-              logger21.error("Failed to parse query result", { queryHash, error: parseError });
+              logger23.error("Failed to parse query result", { queryHash, error: parseError });
               resolve(null);
             }
           };
-        };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB get request for query result", { queryHash, queryKey, error: requestError });
+          reject(requestError);
+        }
+      });
+    } catch (error) {
+      logger23.error("Error in getQueryResult", { queryHash, error });
+      return null;
+    }
+  }
+  async getQueryResultWithMetadata(queryHash) {
+    logger23.trace("getQueryResultWithMetadata", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger23.error("Invalid queryHash provided to getQueryResultWithMetadata", { queryHash });
+      return null;
+    }
+    try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const queryKey = `query:${queryHash}`;
+      return new Promise((resolve, reject) => {
+        try {
+          const getRequest = store.get(queryKey);
+          getRequest.onerror = () => {
+            logger23.error("Failed to retrieve query result with metadata", { queryHash, error: getRequest.error });
+            reject(getRequest.error);
+          };
+          getRequest.onsuccess = () => {
+            try {
+              const result = getRequest.result;
+              if (!result) {
+                resolve(null);
+                return;
+              }
+              const entry = JSON.parse(result);
+              if (Array.isArray(entry)) {
+                resolve({ itemKeys: entry, metadata: void 0 });
+                return;
+              }
+              if (entry.metadata) {
+                if (entry.metadata.createdAt) {
+                  entry.metadata.createdAt = new Date(entry.metadata.createdAt);
+                }
+                if (entry.metadata.expiresAt) {
+                  entry.metadata.expiresAt = new Date(entry.metadata.expiresAt);
+                }
+              }
+              resolve({
+                itemKeys: entry.itemKeys || [],
+                metadata: entry.metadata
+              });
+            } catch (parseError) {
+              logger23.error("Failed to parse query result with metadata", { queryHash, error: parseError });
+              resolve(null);
+            }
+          };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB get request for query result with metadata", { queryHash, queryKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in getQueryResult", { queryHash, error });
+      logger23.error("Error in getQueryResultWithMetadata", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
-    logger21.trace("hasQueryResult", { queryHash });
+    logger23.trace("hasQueryResult", { queryHash });
     try {
       const result = await this.getQueryResult(queryHash);
       return result !== null;
     } catch (error) {
-      logger21.error("Error in hasQueryResult", { queryHash, error });
+      logger23.error("Error in hasQueryResult", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger21.trace("deleteQueryResult", { queryHash });
+    logger23.trace("deleteQueryResult", { queryHash });
+    if (!queryHash || typeof queryHash !== "string" || queryHash.trim() === "") {
+      logger23.error("Invalid queryHash provided to deleteQueryResult", { queryHash });
+      return;
+    }
     try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const queryKey = `query:${queryHash}`;
       return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.version);
-        request.onerror = () => {
-          logger21.error("Failed to open database for deleteQueryResult", { error: request.error });
-          reject(request.error);
-        };
-        request.onsuccess = () => {
-          const db = request.result;
-          const transaction = db.transaction([this.storeName], "readwrite");
-          const store = transaction.objectStore(this.storeName);
-          const queryKey = `query:${queryHash}`;
+        try {
           const deleteRequest = store.delete(queryKey);
           deleteRequest.onerror = () => {
-            logger21.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
+            logger23.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
             reject(deleteRequest.error);
           };
           deleteRequest.onsuccess = () => {
             resolve();
           };
-        };
+        } catch (requestError) {
+          logger23.error("Error creating IndexedDB delete request for query result", { queryHash, queryKey, error: requestError });
+          reject(requestError);
+        }
       });
     } catch (error) {
-      logger21.error("Error in deleteQueryResult", { queryHash, error });
+      logger23.error("Error in deleteQueryResult", { queryHash, error });
       throw error;
     }
   }
   async invalidateItemKeys(keys) {
-    logger21.debug("invalidateItemKeys", { keys });
+    logger23.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -4848,7 +5147,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
                   queryResults2[queryHash] = itemKeys;
                 }
               } catch (error) {
-                logger21.debug("Failed to parse query result", { key: item.key, error });
+                logger23.debug("Failed to parse query result", { key: item.key, error });
               }
             }
           }
@@ -4876,18 +5175,18 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           });
         }
       }
-      logger21.debug("Selectively invalidated queries referencing affected keys", {
+      logger23.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: Object.keys(queryResults).length
       });
     } catch (error) {
-      logger21.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger23.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger21.debug("invalidateLocation", { locations });
+    logger23.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       await this.clearQueryResults();
@@ -4900,68 +5199,61 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async clearQueryResults() {
-    logger21.trace("clearQueryResults");
+    logger23.trace("clearQueryResults");
     try {
+      const db = await this.getDB();
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
       return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.version);
-        request.onerror = () => {
-          logger21.error("Failed to open database for clearQueryResults", { error: request.error });
-          reject(request.error);
+        const cursorRequest = store.openCursor();
+        const keysToDelete = [];
+        cursorRequest.onerror = () => {
+          logger23.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
+          reject(cursorRequest.error);
         };
-        request.onsuccess = () => {
-          const db = request.result;
-          const transaction = db.transaction([this.storeName], "readwrite");
-          const store = transaction.objectStore(this.storeName);
-          const cursorRequest = store.openCursor();
-          const keysToDelete = [];
-          cursorRequest.onerror = () => {
-            logger21.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
-            reject(cursorRequest.error);
-          };
-          cursorRequest.onsuccess = () => {
-            const cursor = cursorRequest.result;
-            if (cursor) {
-              const key = cursor.key;
-              if (typeof key === "string" && key.startsWith("query:")) {
-                keysToDelete.push(key);
-              }
-              cursor.continue();
-            } else {
-              if (keysToDelete.length === 0) {
-                resolve();
-                return;
-              }
-              let deletedCount = 0;
-              const totalToDelete = keysToDelete.length;
-              keysToDelete.forEach((queryKey) => {
-                const deleteRequest = store.delete(queryKey);
-                deleteRequest.onerror = () => {
-                  logger21.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
-                  deletedCount++;
-                  if (deletedCount === totalToDelete) {
-                    resolve();
-                  }
-                };
-                deleteRequest.onsuccess = () => {
-                  deletedCount++;
-                  if (deletedCount === totalToDelete) {
-                    resolve();
-                  }
-                };
-              });
+        cursorRequest.onsuccess = () => {
+          const cursor = cursorRequest.result;
+          if (cursor) {
+            const key = cursor.key;
+            if (typeof key === "string" && key.startsWith("query:")) {
+              keysToDelete.push(key);
             }
-          };
+            cursor.continue();
+          } else {
+            if (keysToDelete.length === 0) {
+              resolve();
+              return;
+            }
+            let deletedCount = 0;
+            const totalToDelete = keysToDelete.length;
+            keysToDelete.forEach((queryKey) => {
+              const deleteRequest = store.delete(queryKey);
+              deleteRequest.onerror = () => {
+                logger23.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
+                deletedCount++;
+                if (deletedCount === totalToDelete) {
+                  resolve();
+                }
+              };
+              deleteRequest.onsuccess = () => {
+                deletedCount++;
+                if (deletedCount === totalToDelete) {
+                  resolve();
+                }
+              };
+            });
+          }
         };
       });
     } catch (error) {
-      logger21.error("Error in clearQueryResults", { error });
+      logger23.error("Error in clearQueryResults", { error });
       throw error;
     }
   }
 };
 
 // src/browser/IndexDBCacheMap.ts
-var logger22 = logger_default.get("IndexDBCacheMap");
+var logger24 = logger_default.get("IndexDBCacheMap");
 var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   implementationType = "browser/indexedDB";
   // Memory storage
@@ -5125,15 +5417,37 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
     return candidates.filter((item) => isQueryMatch6(item, query));
   }
   // Query result caching methods
-  async setQueryResult(queryHash, itemKeys) {
+  async setQueryResult(queryHash, itemKeys, metadata) {
     this.queryResultCache[queryHash] = {
-      itemKeys
+      itemKeys,
+      metadata
     };
+    await this.asyncCache.setQueryResult(queryHash, itemKeys, metadata);
   }
   async getQueryResult(queryHash) {
     const entry = this.queryResultCache[queryHash];
     return entry ? entry.itemKeys : null;
   }
+  async getQueryResultWithMetadata(queryHash) {
+    let entry = this.queryResultCache[queryHash];
+    if (!entry) {
+      const persistedResult = await this.asyncCache.getQueryResultWithMetadata(queryHash);
+      if (persistedResult) {
+        this.queryResultCache[queryHash] = {
+          itemKeys: persistedResult.itemKeys,
+          metadata: persistedResult.metadata
+        };
+        entry = this.queryResultCache[queryHash];
+      }
+    }
+    if (!entry) {
+      return null;
+    }
+    return {
+      itemKeys: entry.itemKeys,
+      metadata: entry.metadata
+    };
+  }
   async hasQueryResult(queryHash) {
     return queryHash in this.queryResultCache;
   }
@@ -5145,7 +5459,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger22.debug("invalidateItemKeys", { keys });
+    logger24.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -5175,7 +5489,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       delete this.queryResultCache[queryHash];
     });
-    logger22.debug("Selectively invalidated queries referencing affected keys", {
+    logger24.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
@@ -5667,8 +5981,11 @@ var highTrafficTTLConfig = {
   }
 };
 
+// src/cache/warming/CacheWarmer.ts
+var logger25 = logger_default.get("CacheWarmer");
+
 // src/Operations.ts
-var logger23 = logger_default.get("Operations");
+var logger26 = logger_default.get("Operations");
 var CacheMapOperations = class {
   constructor(api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) {
     this.api = api;
@@ -5682,7 +5999,7 @@ var CacheMapOperations = class {
     this.statsManager = statsManager;
     this.registry = registry;
     if (this.options.enableDebugLogging) {
-      logger23.debug("CacheMapOperations initialized", {
+      logger26.debug("CacheMapOperations initialized", {
         cacheType: this.cacheMap.implementationType,
         isTwoLayer: this.cacheMap instanceof TwoLayerCacheMap
       });
@@ -5775,7 +6092,7 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
 };
 
 // src/eviction/EvictionManager.ts
-var logger24 = logger_default.get("EvictionManager");
+var logger27 = logger_default.get("EvictionManager");
 var EvictionManager = class {
   evictionStrategy;
   constructor(evictionStrategy) {
@@ -5787,7 +6104,7 @@ var EvictionManager = class {
    */
   setEvictionStrategy(strategy) {
     this.evictionStrategy = strategy;
-    logger24.debug("Eviction strategy updated", {
+    logger27.debug("Eviction strategy updated", {
       strategy: strategy?.getStrategyName() || "none"
     });
   }
@@ -5808,13 +6125,13 @@ var EvictionManager = class {
       return;
     }
     try {
-      logger24.debug("EVICTION: Item accessed, updating metadata", {
+      logger27.debug("EVICTION: Item accessed, updating metadata", {
         key,
         strategy: this.evictionStrategy.getStrategyName()
       });
       await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger24.error("EVICTION: Error in eviction strategy onItemAccessed", {
+      logger27.error("EVICTION: Error in eviction strategy onItemAccessed", {
         key,
         error,
         strategy: this.evictionStrategy?.getStrategyName()
@@ -5832,12 +6149,12 @@ var EvictionManager = class {
     const startTime = Date.now();
     const evictedKeys = [];
     if (!this.evictionStrategy) {
-      logger24.debug("EVICTION: No eviction strategy configured", { key });
+      logger27.debug("EVICTION: No eviction strategy configured", { key });
       return evictedKeys;
     }
     try {
       const estimatedSize = estimateValueSize(value);
-      logger24.debug("EVICTION: Item addition started", {
+      logger27.debug("EVICTION: Item addition started", {
         key,
         estimatedSize,
         strategy: this.evictionStrategy.getStrategyName()
@@ -5845,7 +6162,7 @@ var EvictionManager = class {
       const contextStartTime = Date.now();
       const context = await this.createEvictionContext(metadataProvider, estimatedSize);
       const contextDuration = Date.now() - contextStartTime;
-      logger24.debug("EVICTION: Current cache state", {
+      logger27.debug("EVICTION: Current cache state", {
         key,
         currentItemCount: context.currentSize.itemCount,
         currentSizeBytes: context.currentSize.sizeBytes,
@@ -5858,7 +6175,7 @@ var EvictionManager = class {
       const keysToEvict = await this.evictionStrategy.selectForEviction(metadataProvider, context);
       const selectionDuration = Date.now() - selectionStartTime;
       if (keysToEvict.length > 0) {
-        logger24.debug("EVICTION: Items selected for eviction", {
+        logger27.debug("EVICTION: Items selected for eviction", {
           key,
           evictCount: keysToEvict.length,
           keysToEvict,
@@ -5870,7 +6187,7 @@ var EvictionManager = class {
       for (const evictKey of keysToEvict) {
         await this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
         evictedKeys.push(evictKey);
-        logger24.debug("EVICTION: Marked item for eviction", {
+        logger27.debug("EVICTION: Marked item for eviction", {
           evictedKey: evictKey,
           newKey: key
         });
@@ -5881,7 +6198,7 @@ var EvictionManager = class {
       const addMetadataDuration = Date.now() - addMetadataStart;
       const totalDuration = Date.now() - startTime;
       if (evictedKeys.length > 0) {
-        logger24.debug("EVICTION: Eviction completed", {
+        logger27.debug("EVICTION: Eviction completed", {
           newKey: key,
           evictedCount: evictedKeys.length,
           evictedKeys,
@@ -5892,14 +6209,14 @@ var EvictionManager = class {
           totalDuration
         });
       } else {
-        logger24.debug("EVICTION: No eviction needed", {
+        logger27.debug("EVICTION: No eviction needed", {
           newKey: key,
           estimatedSize,
           totalDuration
         });
       }
     } catch (error) {
-      logger24.error("EVICTION: Error in eviction strategy onItemAdded", {
+      logger27.error("EVICTION: Error in eviction strategy onItemAdded", {
         key,
         error,
         strategy: this.evictionStrategy?.getStrategyName()
@@ -5919,7 +6236,7 @@ var EvictionManager = class {
     try {
       this.evictionStrategy.onItemRemoved(key, metadataProvider);
     } catch (error) {
-      logger24.error("Error in eviction strategy onItemRemoved", { key, error });
+      logger27.error("Error in eviction strategy onItemRemoved", { key, error });
     }
   }
   /**
@@ -5931,15 +6248,15 @@ var EvictionManager = class {
     const startTime = Date.now();
     const evictedKeys = [];
     if (!this.evictionStrategy) {
-      logger24.debug("EVICTION: No eviction strategy configured for manual eviction");
+      logger27.debug("EVICTION: No eviction strategy configured for manual eviction");
       return evictedKeys;
     }
     try {
-      logger24.debug("EVICTION: Manual eviction started", {
+      logger27.debug("EVICTION: Manual eviction started", {
         strategy: this.evictionStrategy.getStrategyName()
       });
       const context = await this.createEvictionContext(metadataProvider);
-      logger24.debug("EVICTION: Manual eviction - current cache state", {
+      logger27.debug("EVICTION: Manual eviction - current cache state", {
         currentItemCount: context.currentSize.itemCount,
         currentSizeBytes: context.currentSize.sizeBytes,
         maxItems: context.limits.maxItems,
@@ -5952,20 +6269,20 @@ var EvictionManager = class {
       }
       const duration = Date.now() - startTime;
       if (evictedKeys.length > 0) {
-        logger24.debug("EVICTION: Manual eviction completed", {
+        logger27.debug("EVICTION: Manual eviction completed", {
           evictedCount: evictedKeys.length,
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName(),
           duration
         });
       } else {
-        logger24.debug("EVICTION: Manual eviction - no items to evict", {
+        logger27.debug("EVICTION: Manual eviction - no items to evict", {
           strategy: this.evictionStrategy.getStrategyName(),
           duration
         });
       }
     } catch (error) {
-      logger24.error("EVICTION: Error in manual eviction", {
+      logger27.error("EVICTION: Error in manual eviction", {
         error,
         strategy: this.evictionStrategy?.getStrategyName()
       });
@@ -5988,7 +6305,7 @@ var EvictionManager = class {
         this.evictionStrategy.reset();
       }
     }
-    logger24.debug("Eviction manager cleared");
+    logger27.debug("Eviction manager cleared");
   }
   /**
    * Create eviction context from current cache state
@@ -7326,7 +7643,7 @@ function createEvictionStrategy(policy, maxCacheSize, config) {
 }
 
 // src/ttl/TTLManager.ts
-var logger25 = logger_default.get("TTLManager");
+var logger28 = logger_default.get("TTLManager");
 var TTLManager = class {
   config;
   cleanupTimer;
@@ -7338,7 +7655,7 @@ var TTLManager = class {
       validateOnAccess: true,
       ...config
     };
-    logger25.debug("TTL_DEBUG: TTLManager created", {
+    logger28.debug("TTL_DEBUG: TTLManager created", {
       config: this.config,
       isTTLEnabled: this.isTTLEnabled(),
       defaultTTL: this.config.defaultTTL
@@ -7371,13 +7688,13 @@ var TTLManager = class {
         this.startAutoCleanup();
       }
     }
-    logger25.debug("TTL configuration updated", { config: this.config });
+    logger28.debug("TTL configuration updated", { config: this.config });
   }
   /**
    * Set TTL metadata for an item when it's added
    */
   async onItemAdded(key, metadataProvider, itemTTL) {
-    logger25.debug("TTL_DEBUG: onItemAdded called", {
+    logger28.debug("TTL_DEBUG: onItemAdded called", {
       key,
       itemTTL,
       isTTLEnabled: this.isTTLEnabled(),
@@ -7385,19 +7702,19 @@ var TTLManager = class {
       metadataProviderType: metadataProvider?.constructor?.name
     });
     if (!this.isTTLEnabled() && !itemTTL) {
-      logger25.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
+      logger28.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
       return;
     }
-    logger25.debug("TTL_DEBUG: Getting metadata for key", { key });
+    logger28.debug("TTL_DEBUG: Getting metadata for key", { key });
     const metadata = await metadataProvider.getMetadata(key);
-    logger25.debug("TTL_DEBUG: Retrieved metadata", {
+    logger28.debug("TTL_DEBUG: Retrieved metadata", {
       key,
       hasMetadata: !!metadata,
       metadataKeys: metadata ? Object.keys(metadata) : null,
       metadata
     });
     if (!metadata) {
-      logger25.debug("TTL_DEBUG: No metadata found for item when setting TTL", {
+      logger28.debug("TTL_DEBUG: No metadata found for item when setting TTL", {
         key,
         metadataProviderType: metadataProvider?.constructor?.name,
         metadataProviderMethods: metadataProvider ? Object.getOwnPropertyNames(Object.getPrototypeOf(metadataProvider)) : null
@@ -7405,7 +7722,7 @@ var TTLManager = class {
       return;
     }
     const ttl = itemTTL || this.config.defaultTTL;
-    logger25.debug("TTL_DEBUG: Calculated TTL value", {
+    logger28.debug("TTL_DEBUG: Calculated TTL value", {
       key,
       itemTTL,
       defaultTTL: this.config.defaultTTL,
@@ -7418,7 +7735,7 @@ var TTLManager = class {
         expiresAt: metadata.addedAt + ttl,
         ttl
       };
-      logger25.debug("TTL_DEBUG: Setting TTL metadata", {
+      logger28.debug("TTL_DEBUG: Setting TTL metadata", {
         key,
         ttl,
         addedAt: metadata.addedAt,
@@ -7426,9 +7743,9 @@ var TTLManager = class {
         ttlMetadata
       });
       await metadataProvider.setMetadata(key, ttlMetadata);
-      logger25.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+      logger28.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     } else {
-      logger25.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
+      logger28.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
     }
   }
   /**
@@ -7437,14 +7754,14 @@ var TTLManager = class {
   async isExpired(key, metadataProvider) {
     const metadata = await metadataProvider.getMetadata(key);
     if (!metadata || !metadata.expiresAt) {
-      logger25.debug("TTL_CHECK: No TTL set for item", { key, hasMetadata: !!metadata });
+      logger28.debug("TTL_CHECK: No TTL set for item", { key, hasMetadata: !!metadata });
       return false;
     }
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
     const remainingMs = metadata.expiresAt - now;
     if (expired) {
-      logger25.debug("TTL_CHECK: Item EXPIRED", {
+      logger28.debug("TTL_CHECK: Item EXPIRED", {
         key,
         expiresAt: new Date(metadata.expiresAt).toISOString(),
         now: new Date(now).toISOString(),
@@ -7452,7 +7769,7 @@ var TTLManager = class {
         ttl: metadata.ttl
       });
     } else {
-      logger25.debug("TTL_CHECK: Item still valid", {
+      logger28.debug("TTL_CHECK: Item still valid", {
         key,
         expiresAt: new Date(metadata.expiresAt).toISOString(),
         remainingMs,
@@ -7468,17 +7785,17 @@ var TTLManager = class {
    */
   async validateItem(key, metadataProvider) {
     if (!this.config.validateOnAccess) {
-      logger25.debug("TTL_VALIDATE: Validation disabled, skipping check", { key });
+      logger28.debug("TTL_VALIDATE: Validation disabled, skipping check", { key });
       return true;
     }
-    logger25.debug("TTL_VALIDATE: Validating item", {
+    logger28.debug("TTL_VALIDATE: Validating item", {
       key,
       ttlEnabled: this.isTTLEnabled(),
       defaultTTL: this.config.defaultTTL
     });
     const isExpired = await this.isExpired(key, metadataProvider);
     const isValid = !isExpired;
-    logger25.debug("TTL_VALIDATE: Validation result", {
+    logger28.debug("TTL_VALIDATE: Validation result", {
       key,
       isValid,
       isExpired
@@ -7512,7 +7829,7 @@ var TTLManager = class {
     const expiredKeys = [];
     const allMetadata = await metadataProvider.getAllMetadata();
     const now = Date.now();
-    logger25.debug("TTL_CLEANUP: Scanning for expired items", {
+    logger28.debug("TTL_CLEANUP: Scanning for expired items", {
       totalItems: allMetadata.size,
       now: new Date(now).toISOString()
     });
@@ -7523,7 +7840,7 @@ var TTLManager = class {
         itemsWithTTL++;
         if (now >= ttlMetadata.expiresAt) {
           expiredKeys.push(key);
-          logger25.debug("TTL_CLEANUP: Found expired item", {
+          logger28.debug("TTL_CLEANUP: Found expired item", {
             key,
             expiresAt: new Date(ttlMetadata.expiresAt).toISOString(),
             expiredByMs: now - ttlMetadata.expiresAt
@@ -7533,7 +7850,7 @@ var TTLManager = class {
     }
     const duration = Date.now() - startTime;
     if (expiredKeys.length > 0) {
-      logger25.debug("TTL_CLEANUP: Expired items found", {
+      logger28.debug("TTL_CLEANUP: Expired items found", {
         expiredCount: expiredKeys.length,
         totalItems: allMetadata.size,
         itemsWithTTL,
@@ -7541,7 +7858,7 @@ var TTLManager = class {
         duration
       });
     } else {
-      logger25.debug("TTL_CLEANUP: No expired items found", {
+      logger28.debug("TTL_CLEANUP: No expired items found", {
         totalItems: allMetadata.size,
         itemsWithTTL,
         duration
@@ -7573,7 +7890,7 @@ var TTLManager = class {
     }
     metadata.expiresAt += additionalTTL;
     await metadataProvider.setMetadata(key, metadata);
-    logger25.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
+    logger28.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
     return true;
   }
   /**
@@ -7595,7 +7912,7 @@ var TTLManager = class {
       ttl
     };
     await metadataProvider.setMetadata(key, ttlMetadata);
-    logger25.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+    logger28.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     return true;
   }
   /**
@@ -7607,9 +7924,9 @@ var TTLManager = class {
     }
     if (this.config.cleanupInterval) {
       this.cleanupTimer = setInterval(() => {
-        logger25.trace("Auto cleanup timer triggered");
+        logger28.trace("Auto cleanup timer triggered");
       }, this.config.cleanupInterval);
-      logger25.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
+      logger28.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
     }
   }
   /**
@@ -7619,7 +7936,7 @@ var TTLManager = class {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
-      logger25.debug("Auto cleanup stopped");
+      logger28.debug("Auto cleanup stopped");
     }
   }
   /**
@@ -7627,14 +7944,14 @@ var TTLManager = class {
    */
   clear() {
     this.stopAutoCleanup();
-    logger25.debug("TTL manager cleared");
+    logger28.debug("TTL manager cleared");
   }
   /**
    * Cleanup resources
    */
   destroy() {
     this.stopAutoCleanup();
-    logger25.debug("TTL manager destroyed");
+    logger28.debug("TTL manager destroyed");
   }
 };
 
@@ -8034,9 +8351,9 @@ var CacheStatsManager = class {
 };
 
 // src/Cache.ts
-var logger26 = logger_default.get("Cache");
+var logger29 = logger_default.get("Cache");
 var createCache = (api, coordinate, registry, options) => {
-  logger26.debug("createCache", { coordinate, registry, options });
+  logger29.debug("createCache", { coordinate, registry, options });
   const completeOptions = createOptions(options);
   const cacheMap = createCacheMap(coordinate.kta, completeOptions);
   const pkType = coordinate.kta[0];
@@ -8116,13 +8433,13 @@ var isCache2 = (cache) => {
 };
 
 // src/InstanceFactory.ts
-var logger27 = logger_default.get("InstanceFactory");
+var logger30 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (api, options) => {
   const templateOptions = createOptions(options);
   validateOptions(templateOptions);
   return (coordinate, context) => {
     const instanceOptions = createOptions(options);
-    logger27.debug("Creating cache instance", {
+    logger30.debug("Creating cache instance", {
       coordinate,
       registry: context.registry,
       api,
@@ -8189,9 +8506,9 @@ var createInstanceFactory = (api, options) => {
 };
 
 // src/Instance.ts
-var logger28 = logger_default.get("Instance");
+var logger31 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, api, options) => {
-  logger28.debug("createInstance", { coordinate, api, registry, options });
+  logger31.debug("createInstance", { coordinate, api, registry, options });
   return createCache(api, coordinate, registry, options);
 };
 var isInstance = (instance) => {
@@ -8199,7 +8516,7 @@ var isInstance = (instance) => {
 };
 
 // src/Aggregator.ts
-var logger29 = logger_default.get("ItemAggregator");
+var logger32 = logger_default.get("ItemAggregator");
 var toCacheConfig = (config) => {
   let cacheConfig;
   if (config.optional === void 0) {
@@ -8211,22 +8528,22 @@ var toCacheConfig = (config) => {
 };
 var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
   const populate = async (item) => {
-    logger29.default("populate", { item });
+    logger32.default("populate", { item });
     for (const key in aggregates) {
       await populateAggregate(key, item);
     }
     for (const key in events) {
       await populateEvent(key, item);
     }
-    logger29.default("populate done", { item });
+    logger32.default("populate done", { item });
     return item;
   };
   const populateAggregate = async (key, item) => {
-    logger29.default("populate aggregate key", { key });
+    logger32.default("populate aggregate key", { key });
     const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === void 0) {
       if (cacheConfig.optional === false) {
-        logger29.error("Item does not have refs an is not optional ", { item });
+        logger32.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)) {
@@ -8235,7 +8552,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else if (item.refs[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger29.error("Item does not have mandatory ref with key, not optional ", { key, item });
+        logger32.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)) {
@@ -8244,7 +8561,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else {
       const ref = item.refs[key];
-      logger29.default("AGG Retrieving Item in Populate", { key: ref });
+      logger32.default("AGG Retrieving Item in Populate", { key: ref });
       const newItem = await cacheConfig.cache.operations.retrieve(ref);
       if (newItem) {
         if (item.aggs === void 0) {
@@ -8261,25 +8578,25 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const populateEvent = async (key, item) => {
-    logger29.default("populate event key", { key });
+    logger32.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) {
-        logger29.error("Item does not have mandatory event with key", { key, item });
+        logger32.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) {
-        logger29.error(
+        logger32.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 }));
       }
-      logger29.default("EVENT Retrieving Item in Populate", { key: event.by });
+      logger32.default("EVENT Retrieving Item in Populate", { key: event.by });
       const newItem = await cacheConfig.cache.operations.retrieve(event.by);
       if (newItem) {
         event.agg = newItem;
@@ -8287,13 +8604,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const all2 = async (query = {}, locations = []) => {
-    logger29.default("all", { query, locations });
+    logger32.default("all", { query, locations });
     const result = await cache.operations.all(query, locations);
     const populatedItems = await Promise.all(result.items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const one2 = async (query = {}, locations = []) => {
-    logger29.default("one", { query, locations });
+    logger32.default("one", { query, locations });
     const item = await cache.operations.one(query, locations);
     let populatedItem = null;
     if (item) {
@@ -8302,30 +8619,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger29.default("action", { key, action: action3, body });
+    logger32.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 = []) => {
-    logger29.default("action", { action: action3, body, locations });
+    logger32.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 = []) => {
-    logger29.default("allFacet", { facet: facet3, params, locations });
+    logger32.default("allFacet", { facet: facet3, params, locations });
     const response = await cache.operations.allFacet(facet3, params, locations);
     return response;
   };
   const create2 = async (v, locations = []) => {
-    logger29.default("create", { v, locations });
+    logger32.default("create", { v, locations });
     const item = locations.length === 0 ? await cache.operations.create(v) : await cache.operations.create(v, { locations });
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const get2 = async (key) => {
-    logger29.default("get", { key });
+    logger32.default("get", { key });
     const item = await cache.operations.get(key);
     let populatedItem = null;
     if (item) {
@@ -8334,7 +8651,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const retrieve2 = async (key) => {
-    logger29.default("retrieve", { key });
+    logger32.default("retrieve", { key });
     const item = await cache.operations.retrieve(key);
     let populatedItem = null;
     if (item) {
@@ -8343,22 +8660,22 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const remove2 = async (key) => {
-    logger29.default("remove", { key });
+    logger32.default("remove", { key });
     await cache.operations.remove(key);
   };
   const update2 = async (key, v) => {
-    logger29.default("update", { key, v });
+    logger32.default("update", { key, v });
     const item = await cache.operations.update(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const facet2 = async (key, facet3) => {
-    logger29.default("facet", { key, facet: facet3 });
+    logger32.default("facet", { key, facet: facet3 });
     const response = await cache.operations.facet(key, facet3);
     return response;
   };
   const find2 = async (finder, finderParams = {}, locations = [], findOptions) => {
-    logger29.default("find", { finder, finderParams, locations, findOptions });
+    logger32.default("find", { finder, finderParams, locations, findOptions });
     const result = await cache.operations.find(finder, finderParams, locations, findOptions);
     const populatedItems = await Promise.all(result.items.map(async (item) => populate(item)));
     return {
@@ -8367,7 +8684,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     };
   };
   const findOne2 = async (finder, finderParams = {}, locations = []) => {
-    logger29.default("find", { finder, finderParams, locations });
+    logger32.default("find", { finder, finderParams, locations });
     const item = await cache.operations.findOne(finder, finderParams, locations);
     if (!item) {
       return null;
@@ -8376,7 +8693,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const set2 = async (key, v) => {
-    logger29.default("set", { key, v });
+    logger32.default("set", { key, v });
     const item = await cache.operations.set(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
@@ -8428,13 +8745,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger30 = logger_default.get("Registry");
+var logger33 = 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}`);
     }
-    logger30.debug("Creating cache registry", { type, registryHub });
+    logger33.debug("Creating cache registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };