@fjell/cache 4.7.40 → 4.7.42

package/dist/index.js

@@ -1,9 +1,365 @@
 // src/Operations.ts
 import {
+  createAllFacetWrapper as createAllFacetWrapper2,
+  createAllWrapper as createAllWrapper2,
+  createCreateWrapper as createCreateWrapper2,
+  createGetWrapper as createGetWrapper2,
+  createOneWrapper as createOneWrapper2,
+  createRemoveWrapper as createRemoveWrapper2,
+  createUpdateWrapper as createUpdateWrapper2,
   isOperationComKey as isComKey7,
   isOperationPriKey as isPriKey
 } from "@fjell/core";
 
+// src/logger.ts
+import Logging from "@fjell/logging";
+var LibLogger = Logging.getLogger("@fjell/cache");
+var logger_default = LibLogger;
+
+// src/CacheMap.ts
+var CacheMap = class {
+  types;
+  constructor(types) {
+    this.types = types;
+  }
+};
+
+// src/cache/layers/TwoLayerCacheMap.ts
+var logger = logger_default.get("TwoLayerCacheMap");
+var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
+  constructor(underlyingCache, options = {}) {
+    super(underlyingCache.types);
+    this.underlyingCache = underlyingCache;
+    this.options = {
+      itemTTL: options.itemTTL || 3600,
+      // 1 hour for items
+      queryTTL: options.queryTTL || 300,
+      // 5 minutes for complete queries
+      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
+      });
+    }
+  }
+  options;
+  // Query metadata tracking for enhanced TTL and completeness
+  queryMetadataMap = /* @__PURE__ */ new Map();
+  // ===== PASS-THROUGH METHODS TO UNDERLYING CACHE (ITEM LAYER) =====
+  async get(key) {
+    return this.underlyingCache.get(key);
+  }
+  async set(key, value) {
+    await this.underlyingCache.set(key, value);
+    await this.invalidateQueriesForItem(key);
+  }
+  async includesKey(key) {
+    return this.underlyingCache.includesKey(key);
+  }
+  async delete(key) {
+    await this.underlyingCache.delete(key);
+    await this.invalidateQueriesForItem(key);
+  }
+  async allIn(locations) {
+    return this.underlyingCache.allIn(locations);
+  }
+  async contains(query, locations) {
+    return this.underlyingCache.contains(query, locations);
+  }
+  async queryIn(query, locations) {
+    return this.underlyingCache.queryIn(query, locations);
+  }
+  async clone() {
+    const clonedUnderlying = await this.underlyingCache.clone();
+    return new _TwoLayerCacheMap(clonedUnderlying, this.options);
+  }
+  async keys() {
+    return this.underlyingCache.keys();
+  }
+  async values() {
+    return this.underlyingCache.values();
+  }
+  async clear() {
+    await this.underlyingCache.clear();
+    this.queryMetadataMap.clear();
+  }
+  // ===== ENHANCED QUERY LAYER METHODS =====
+  /**
+   * Set a query result with rich metadata for two-layer architecture
+   */
+  async setQueryResult(queryHash, itemKeys) {
+    await this.underlyingCache.setQueryResult(queryHash, itemKeys);
+    const now = /* @__PURE__ */ new Date();
+    const isComplete = this.determineQueryCompleteness(queryHash, itemKeys);
+    const ttlSeconds = isComplete ? this.options.queryTTL : this.options.facetTTL;
+    const metadata = {
+      queryType: this.extractQueryType(queryHash),
+      isComplete,
+      createdAt: now,
+      expiresAt: new Date(now.getTime() + ttlSeconds * 1e3),
+      filter: this.extractFilter(queryHash),
+      params: this.extractParams(queryHash)
+    };
+    this.queryMetadataMap.set(queryHash, metadata);
+    if (this.options.debug) {
+      logger.debug("Set query result with metadata", {
+        queryHash,
+        itemCount: itemKeys.length,
+        isComplete,
+        ttlSeconds,
+        expiresAt: metadata.expiresAt.toISOString()
+      });
+    }
+  }
+  /**
+   * Get a query result with expiration checking
+   */
+  async getQueryResult(queryHash) {
+    const metadata = this.queryMetadataMap.get(queryHash);
+    if (metadata && metadata.expiresAt < /* @__PURE__ */ new Date()) {
+      await this.deleteQueryResult(queryHash);
+      if (this.options.debug) {
+        logger.debug("Query result expired and removed", { queryHash });
+      }
+      return null;
+    }
+    const result = await this.underlyingCache.getQueryResult(queryHash);
+    if (result && this.options.debug) {
+      logger.debug("Query result cache hit", {
+        queryHash,
+        itemCount: result.length,
+        isComplete: metadata?.isComplete
+      });
+    }
+    return result;
+  }
+  /**
+   * Check if query result exists and is not expired
+   */
+  async hasQueryResult(queryHash) {
+    const result = await this.getQueryResult(queryHash);
+    return result !== null;
+  }
+  /**
+   * Delete a query result and its metadata
+   */
+  async deleteQueryResult(queryHash) {
+    await this.underlyingCache.deleteQueryResult(queryHash);
+    this.queryMetadataMap.delete(queryHash);
+    if (this.options.debug) {
+      logger.debug("Deleted query result", { queryHash });
+    }
+  }
+  // ===== QUERY INVALIDATION (CRITICAL FOR TWO-LAYER ARCHITECTURE) =====
+  /**
+   * Invalidate queries that are affected by item changes
+   */
+  async invalidateQueriesForItem(itemKey) {
+    const affectedQueries = await this.findQueriesContainingItem(itemKey);
+    for (const queryHash of affectedQueries) {
+      await this.deleteQueryResult(queryHash);
+    }
+    if (this.options.debug && affectedQueries.length > 0) {
+      logger.debug("Invalidated queries for item change", {
+        itemKey: JSON.stringify(itemKey),
+        queriesInvalidated: affectedQueries.length
+      });
+    }
+  }
+  /**
+   * Find queries that contain a specific item (requires scanning - can be optimized)
+   */
+  async findQueriesContainingItem(itemKey) {
+    const affectedQueries = [];
+    const itemKeyStr = JSON.stringify(itemKey);
+    for (const [queryHash, metadata] of this.queryMetadataMap.entries()) {
+      const queryResult = await this.underlyingCache.getQueryResult(queryHash);
+      if (queryResult && queryResult.some((key) => JSON.stringify(key) === itemKeyStr)) {
+        affectedQueries.push(queryHash);
+      }
+    }
+    return affectedQueries;
+  }
+  // ===== METADATA UTILITY METHODS =====
+  /**
+   * Determine if a query result is complete or partial based on query hash
+   */
+  determineQueryCompleteness(queryHash, itemKeys) {
+    if (queryHash.includes("facet:") || queryHash.includes("filter:")) {
+      return false;
+    }
+    if (queryHash.includes("all:") && !queryHash.includes("query:")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Extract query type from hash for metadata
+   */
+  extractQueryType(queryHash) {
+    if (queryHash.startsWith("all:")) return "all";
+    if (queryHash.startsWith("find:")) return "find";
+    if (queryHash.startsWith("one:")) return "one";
+    if (queryHash.startsWith("facet:")) return "facet";
+    return "unknown";
+  }
+  /**
+   * Extract filter information from query hash
+   */
+  extractFilter(queryHash) {
+    const filterMatch = queryHash.match(/filter:([^:]+)/);
+    return filterMatch ? filterMatch[1] : void 0;
+  }
+  /**
+   * Extract parameters from query hash
+   */
+  extractParams(queryHash) {
+    try {
+      const paramsMatch = queryHash.match(/params:(.+)$/);
+      return paramsMatch ? JSON.parse(decodeURIComponent(paramsMatch[1])) : void 0;
+    } catch (error) {
+      return void 0;
+    }
+  }
+  // ===== METADATA PROVIDER METHODS (DELEGATE TO UNDERLYING) =====
+  async getMetadata(key) {
+    if ("getMetadata" in this.underlyingCache) {
+      return this.underlyingCache.getMetadata(key);
+    }
+    return null;
+  }
+  async setMetadata(key, metadata) {
+    if ("setMetadata" in this.underlyingCache) {
+      await this.underlyingCache.setMetadata(key, metadata);
+    }
+  }
+  async deleteMetadata(key) {
+    if ("deleteMetadata" in this.underlyingCache) {
+      await this.underlyingCache.deleteMetadata(key);
+    }
+  }
+  async getAllMetadata() {
+    if ("getAllMetadata" in this.underlyingCache) {
+      return this.underlyingCache.getAllMetadata();
+    }
+    return /* @__PURE__ */ new Map();
+  }
+  async clearMetadata() {
+    if ("clearMetadata" in this.underlyingCache) {
+      await this.underlyingCache.clearMetadata();
+    }
+  }
+  async getCurrentSize() {
+    if ("getCurrentSize" in this.underlyingCache) {
+      return this.underlyingCache.getCurrentSize();
+    }
+    const keys = await this.keys();
+    return { itemCount: keys.length, sizeBytes: 0 };
+  }
+  async getSizeLimits() {
+    if ("getSizeLimits" in this.underlyingCache) {
+      return this.underlyingCache.getSizeLimits();
+    }
+    return { maxItems: null, maxSizeBytes: null };
+  }
+  // ===== TWO-LAYER SPECIFIC METHODS =====
+  /**
+   * Get statistics about the two-layer cache
+   */
+  getTwoLayerStats() {
+    const now = /* @__PURE__ */ new Date();
+    let expiredQueries = 0;
+    let validQueries = 0;
+    let completeQueries = 0;
+    let partialQueries = 0;
+    for (const [queryHash, metadata] of this.queryMetadataMap.entries()) {
+      if (metadata.expiresAt < now) {
+        expiredQueries++;
+      } else {
+        validQueries++;
+        if (metadata.isComplete) {
+          completeQueries++;
+        } else {
+          partialQueries++;
+        }
+      }
+    }
+    return {
+      queryMetadata: {
+        total: this.queryMetadataMap.size,
+        valid: validQueries,
+        expired: expiredQueries,
+        complete: completeQueries,
+        partial: partialQueries
+      }
+    };
+  }
+  /**
+   * Clean up expired queries
+   */
+  async cleanup() {
+    const now = /* @__PURE__ */ new Date();
+    const expiredQueries = [];
+    for (const [queryHash, metadata] of this.queryMetadataMap.entries()) {
+      if (metadata.expiresAt < now) {
+        expiredQueries.push(queryHash);
+      }
+    }
+    for (const queryHash of expiredQueries) {
+      await this.deleteQueryResult(queryHash);
+    }
+    if (this.options.debug && expiredQueries.length > 0) {
+      logger.debug("Cleaned up expired queries", { count: expiredQueries.length });
+    }
+    return expiredQueries.length;
+  }
+  // ===== PROPERTIES =====
+  get implementationType() {
+    return `two-layer/${this.underlyingCache.implementationType}`;
+  }
+  // Note: Removed types getter to avoid override conflict with base class
+  // The types are accessible through super.types
+  // ===== MISSING ABSTRACT METHODS FROM CacheMap =====
+  async invalidateItemKeys(keys) {
+    if ("invalidateItemKeys" in this.underlyingCache && typeof this.underlyingCache.invalidateItemKeys === "function") {
+      await this.underlyingCache.invalidateItemKeys(keys);
+    }
+    for (const key of keys) {
+      await this.invalidateQueriesForItem(key);
+    }
+  }
+  async invalidateLocation(locations) {
+    if ("invalidateLocation" in this.underlyingCache && typeof this.underlyingCache.invalidateLocation === "function") {
+      await this.underlyingCache.invalidateLocation(locations);
+    }
+    this.queryMetadataMap.clear();
+  }
+  async clearQueryResults() {
+    if ("clearQueryResults" in this.underlyingCache && typeof this.underlyingCache.clearQueryResults === "function") {
+      await this.underlyingCache.clearQueryResults();
+    }
+    this.queryMetadataMap.clear();
+  }
+  /**
+   * Check if two-layer mode is enabled
+   */
+  get isTwoLayerEnabled() {
+    return true;
+  }
+  /**
+   * Get the underlying cache implementation
+   */
+  get underlying() {
+    return this.underlyingCache;
+  }
+};
+
 // src/CacheContext.ts
 var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry, coordinate) => {
   return {
@@ -315,16 +671,11 @@ var CacheEventFactory = class {
   }
 };
 
-// src/logger.ts
-import Logging from "@fjell/logging";
-var LibLogger = Logging.getLogger("@fjell/cache");
-var logger_default = LibLogger;
-
 // src/ops/all.ts
-var logger = logger_default.get("all");
+var logger2 = logger_default.get("all");
 var all = async (query = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, coordinate } = context;
-  logger.default("all", { query, locations });
+  logger2.default("all", { query, locations });
   const wrappedAll = createAllWrapper(
     coordinate,
     async (q, locs) => {
@@ -337,21 +688,21 @@ var all = async (query = {}, locations = [], context) => {
 async function executeAllLogic(query, locations, context) {
   const { api, cacheMap, pkType, ttlManager } = context;
   if (context.options?.bypassCache) {
-    logger.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const ret2 = await api.all(query, locations);
-      logger.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret2.length });
+      logger2.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret2.length });
       return ret2;
     } catch (error) {
-      logger.error("API request failed", { query, locations, error });
+      logger2.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger.debug("Generated query hash for all", { queryHash });
+  logger2.debug("Generated query hash for all", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -366,21 +717,21 @@ async function executeAllLogic(query, locations, context) {
     if (allItemsAvailable) {
       return cachedItems;
     } else {
-      logger.debug("Some cached items missing, invalidating query cache");
+      logger2.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
+      logger2.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
       const itemKeys = directCachedItems.map((item) => item.key);
       await cacheMap.setQueryResult(queryHash, itemKeys);
-      logger.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
+      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
       return directCachedItems;
     }
   } catch (error) {
-    logger.debug("Error querying cache directly, proceeding to API", { error });
+    logger2.debug("Error querying cache directly, proceeding to API", { error });
   }
   let ret = [];
   try {
@@ -397,13 +748,13 @@ async function executeAllLogic(query, locations, context) {
     }
     const itemKeys = ret.map((item) => item.key);
     cacheMap.setQueryResult(queryHash, itemKeys);
-    logger.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+    logger2.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
     const event = CacheEventFactory.createQueryEvent(query, locations, ret);
     context.eventEmitter.emit(event);
   } catch (e) {
     if (e instanceof NotFoundError) {
       cacheMap.setQueryResult(queryHash, []);
-      logger.debug("Cached empty query result for not found", { queryHash });
+      logger2.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
@@ -578,10 +929,10 @@ function validateSizeConfig(config) {
 }
 
 // src/ops/one.ts
-var logger2 = logger_default.get("one");
+var logger3 = logger_default.get("one");
 var one = async (query = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, coordinate } = context;
-  logger2.default("one", { query, locations });
+  logger3.default("one", { query, locations });
   const wrappedOne = createOneWrapper(
     coordinate,
     async (q, locs) => {
@@ -594,26 +945,26 @@ var one = async (query = {}, locations = [], context) => {
 async function executeOneLogic(query, locations, context) {
   const { api, cacheMap, pkType, ttlManager } = context;
   if (context.options?.bypassCache) {
-    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger3.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const retItem2 = await api.one(query, locations);
       if (retItem2) {
-        logger2.debug("API response received (not cached due to bypass)", { query, locations });
+        logger3.debug("API response received (not cached due to bypass)", { query, locations });
         return retItem2;
       } else {
-        logger2.debug("API returned null", { query, locations });
+        logger3.debug("API returned null", { query, locations });
         return null;
       }
     } catch (error) {
-      logger2.error("API request failed", { query, locations, error });
+      logger3.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger2.debug("Generated query hash for one", { queryHash });
+  logger3.debug("Generated query hash for one", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger3.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     if (cachedItemKeys.length === 0) {
       return null;
     }
@@ -621,21 +972,21 @@ async function executeOneLogic(query, locations, context) {
     if (item) {
       return item;
     } else {
-      logger2.debug("Cached item missing, invalidating query cache");
+      logger3.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger2.debug("Found item directly in cache, skipping API call");
+      logger3.debug("Found item directly in cache, skipping API call");
       const foundItem = directCachedItems[0];
       await cacheMap.setQueryResult(queryHash, [foundItem.key]);
-      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
+      logger3.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
       return foundItem;
     }
   } catch (error) {
-    logger2.debug("Error querying cache directly, proceeding to API", { error });
+    logger3.debug("Error querying cache directly, proceeding to API", { error });
   }
   let retItem = null;
   try {
@@ -662,15 +1013,15 @@ async function executeOneLogic(query, locations, context) {
         await cacheMap.delete(parsedKey);
       }
       await cacheMap.setQueryResult(queryHash, [retItem.key]);
-      logger2.debug("Cached query result", { queryHash, itemKey: retItem.key });
+      logger3.debug("Cached query result", { queryHash, itemKey: retItem.key });
     } else {
       await cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result", { queryHash });
+      logger3.debug("Cached empty query result", { queryHash });
     }
   } catch (e) {
     if (e instanceof NotFoundError2) {
       cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result for not found", { queryHash });
+      logger3.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
@@ -682,10 +1033,10 @@ async function executeOneLogic(query, locations, context) {
 import {
   createCreateWrapper
 } from "@fjell/core";
-var logger3 = logger_default.get("create");
+var logger4 = logger_default.get("create");
 var create = async (v, locations = [], context) => {
   const { coordinate } = context;
-  logger3.default("create", { v, locations });
+  logger4.default("create", { v, locations });
   const wrappedCreate = createCreateWrapper(
     coordinate,
     async (item, createOptions2) => {
@@ -725,7 +1076,7 @@ import {
   createGetWrapper,
   isValidItemKey
 } from "@fjell/core";
-var logger4 = logger_default.get("get");
+var logger5 = logger_default.get("get");
 var inFlightRequests = /* @__PURE__ */ new Map();
 var CLEANUP_TIMEOUT = 5 * 60 * 1e3;
 var cleanupStaleRequests = () => {
@@ -737,7 +1088,7 @@ var cleanupStaleRequests = () => {
     }
   });
   keysToDelete.forEach((key) => {
-    logger4.debug("Cleaning up stale in-flight request", { key });
+    logger5.debug("Cleaning up stale in-flight request", { key });
     inFlightRequests.delete(key);
   });
 };
@@ -745,7 +1096,7 @@ var cleanupInterval = setInterval(cleanupStaleRequests, 60 * 1e3);
 var keyToString = createNormalizedHashFunction();
 var get = async (key, context) => {
   const { api, cacheMap, pkType, ttlManager, statsManager, coordinate } = context;
-  logger4.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
+  logger5.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
   const wrappedGet = createGetWrapper(
     coordinate,
     async (k) => {
@@ -759,23 +1110,23 @@ async function executeGetLogic(key, context) {
   const { api, cacheMap, pkType, ttlManager, statsManager } = context;
   statsManager.incrementRequests();
   if (!isValidItemKey(key)) {
-    logger4.error("Key for Get is not a valid ItemKey: %j", key);
+    logger5.error("Key for Get is not a valid ItemKey: %j", key);
     throw new Error("Key for Get is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger4.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
     statsManager.incrementMisses();
     try {
       const ret2 = await api.get(key);
       if (ret2) {
-        logger4.debug("API response received (not cached due to bypass)", { key });
+        logger5.debug("API response received (not cached due to bypass)", { key });
         return ret2;
       } else {
-        logger4.debug("API returned null", { key });
+        logger5.debug("API returned null", { key });
         return null;
       }
     } catch (error) {
-      logger4.error("API request failed", { key, error });
+      logger5.error("API request failed", { key, error });
       throw error;
     }
   }
@@ -785,22 +1136,22 @@ async function executeGetLogic(key, context) {
     if (cachedItem) {
       const isValid = await ttlManager.validateItem(keyStr2, cacheMap);
       if (isValid) {
-        logger4.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
+        logger5.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
         statsManager.incrementHits();
         return cachedItem;
       } else {
-        logger4.debug("Cache item expired, removing", { key });
+        logger5.debug("Cache item expired, removing", { key });
         cacheMap.delete(key);
         statsManager.incrementMisses();
       }
     } else {
       statsManager.incrementMisses();
     }
-    logger4.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
+    logger5.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
   } else {
     const cachedItem = await cacheMap.get(key);
     if (cachedItem) {
-      logger4.debug("Cache hit (TTL disabled)", { key });
+      logger5.debug("Cache hit (TTL disabled)", { key });
       statsManager.incrementHits();
       return cachedItem;
     } else {
@@ -825,7 +1176,7 @@ async function executeGetLogic(key, context) {
         }
       }
     } else {
-      logger4.debug("Using in-flight request for key", { key });
+      logger5.debug("Using in-flight request for key", { key });
       apiRequest = requestEntry.promise;
     }
     ret = await apiRequest;
@@ -855,7 +1206,7 @@ async function executeGetLogic(key, context) {
     }
   } catch (e) {
     inFlightRequests.delete(keyStr);
-    logger4.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+    logger5.error("Error getting item for key", { key, message: e.message, stack: e.stack });
     throw e;
   }
   return ret || null;
@@ -865,30 +1216,30 @@ async function executeGetLogic(key, context) {
 import {
   isValidItemKey as isValidItemKey2
 } from "@fjell/core";
-var logger5 = logger_default.get("retrieve");
+var logger6 = logger_default.get("retrieve");
 var retrieve = async (key, context) => {
   const { cacheMap, pkType, statsManager } = context;
-  logger5.default("retrieve", { key });
+  logger6.default("retrieve", { key });
   statsManager.incrementRequests();
   if (!isValidItemKey2(key)) {
-    logger5.error("Key for Retrieve is not a valid ItemKey: %j", key);
+    logger6.error("Key for Retrieve is not a valid ItemKey: %j", key);
     throw new Error("Key for Retrieve is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger6.debug("Cache bypass enabled, fetching directly from API", { key });
     statsManager.incrementMisses();
     try {
       const { api } = context;
       const retrieved2 = await api.get(key);
       if (retrieved2) {
-        logger5.debug("API response received (not cached due to bypass)", { key });
+        logger6.debug("API response received (not cached due to bypass)", { key });
         return [null, retrieved2];
       } else {
-        logger5.debug("API returned null", { key });
+        logger6.debug("API returned null", { key });
         return [null, null];
       }
     } catch (error) {
-      logger5.error("API request failed", { key, error });
+      logger6.error("API request failed", { key, error });
       throw error;
     }
   }
@@ -896,12 +1247,12 @@ var retrieve = async (key, context) => {
   let retrieved;
   let contextToReturn;
   if (containsItemKey) {
-    logger5.default("Looking for Object in Cache", key);
+    logger6.default("Looking for Object in Cache", key);
     retrieved = await cacheMap.get(key);
     contextToReturn = null;
     statsManager.incrementHits();
   } else {
-    logger5.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    logger6.default("Object Not Found in Cache, Retrieving from Server API", { key });
     statsManager.incrementMisses();
     [contextToReturn, retrieved] = await get(key, context);
   }
@@ -917,10 +1268,10 @@ import {
   createRemoveWrapper,
   isValidItemKey as isValidItemKey3
 } from "@fjell/core";
-var logger6 = logger_default.get("remove");
+var logger7 = logger_default.get("remove");
 var remove = async (key, context) => {
   const { coordinate } = context;
-  logger6.default("remove", { key });
+  logger7.default("remove", { key });
   const wrappedRemove = createRemoveWrapper(
     coordinate,
     async (k) => {
@@ -933,7 +1284,7 @@ var remove = async (key, context) => {
 async function executeRemoveLogic(key, context) {
   const { api, cacheMap } = context;
   if (!isValidItemKey3(key)) {
-    logger6.error("Key for Remove is not a valid ItemKey: %j", key);
+    logger7.error("Key for Remove is not a valid ItemKey: %j", key);
     throw new Error("Key for Remove is not a valid ItemKey");
   }
   try {
@@ -951,9 +1302,9 @@ async function executeRemoveLogic(key, context) {
       { source: "operation", context: { operation: "remove" } }
     );
     context.eventEmitter.emit(queryInvalidatedEvent);
-    logger6.debug("Successfully removed item from API and cache", { key });
+    logger7.debug("Successfully removed item from API and cache", { key });
   } catch (e) {
-    logger6.error("Error deleting item", { error: e });
+    logger7.error("Error deleting item", { error: e });
     throw e;
   }
 }
@@ -963,10 +1314,10 @@ import {
   createUpdateWrapper,
   isValidItemKey as isValidItemKey4
 } from "@fjell/core";
-var logger7 = logger_default.get("update");
+var logger8 = logger_default.get("update");
 var update = async (key, v, context) => {
   const { coordinate } = context;
-  logger7.default("update", { key, v });
+  logger8.default("update", { key, v });
   const wrappedUpdate = createUpdateWrapper(
     coordinate,
     async (k, item) => {
@@ -979,16 +1330,16 @@ var update = async (key, v, context) => {
 async function executeUpdateLogic(key, v, context) {
   const { api, cacheMap, pkType } = context;
   if (!isValidItemKey4(key)) {
-    logger7.error("Key for Update is not a valid ItemKey: %j", key);
+    logger8.error("Key for Update is not a valid ItemKey: %j", key);
     throw new Error("Key for Update is not a valid ItemKey");
   }
-  logger7.debug("Invalidating item key before update", { key });
+  logger8.debug("Invalidating item key before update", { key });
   cacheMap.invalidateItemKeys([key]);
   await cacheMap.clearQueryResults();
   try {
     const previousItem = await cacheMap.get(key);
     const updated = await api.update(key, v);
-    logger7.debug("Caching update result", { updatedKey: updated.key });
+    logger8.debug("Caching update result", { updatedKey: updated.key });
     await cacheMap.set(updated.key, updated);
     const cachedItem = await cacheMap.get(updated.key);
     const keyStr = JSON.stringify(updated.key);
@@ -1021,7 +1372,7 @@ async function executeUpdateLogic(key, v, context) {
     context.eventEmitter.emit(queryInvalidatedEvent);
     return updated;
   } catch (e) {
-    logger7.error("Error updating item", { error: e });
+    logger8.error("Error updating item", { error: e });
     throw e;
   }
 }
@@ -1034,7 +1385,7 @@ import {
 
 // src/utils/cacheInvalidation.ts
 import { toKeyTypeArray } from "@fjell/core";
-var logger8 = logger_default.get("cache", "utils", "cacheInvalidation");
+var logger9 = logger_default.get("cache", "utils", "cacheInvalidation");
 var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   const keys = [];
   const keyTypeArrays = [];
@@ -1051,7 +1402,7 @@ var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   return { keys, keyTypeArrays };
 };
 var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) => {
-  logger8.debug("Invalidating caches by keys and key types", {
+  logger9.debug("Invalidating caches by keys and key types", {
     keysCount: keys.length,
     keyTypeArrays
   });
@@ -1069,22 +1420,22 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger8.debug("Found cache instance for targeted invalidation", {
+        logger9.debug("Found cache instance for targeted invalidation", {
           keyTypes,
           cacheType: cacheInstance.coordinate.kta,
           keysToInvalidate: cacheKeys.length
         });
         await cacheInstance.cacheMap.invalidateItemKeys(cacheKeys);
         await cacheInstance.cacheMap.clearQueryResults();
-        logger8.debug("Successfully invalidated specific items in cache", {
+        logger9.debug("Successfully invalidated specific items in cache", {
           keyTypes,
           invalidatedCount: cacheKeys.length
         });
       } else {
-        logger8.debug("No cache instance found for key types", { keyTypes });
+        logger9.debug("No cache instance found for key types", { keyTypes });
       }
     } catch (error) {
-      logger8.warning("Failed to invalidate cache for key types", {
+      logger9.warning("Failed to invalidate cache for key types", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1094,12 +1445,12 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger8.debug("Handling location-based invalidation", { keyTypes });
+        logger9.debug("Handling location-based invalidation", { keyTypes });
         await cacheInstance.cacheMap.clearQueryResults();
-        logger8.debug("Successfully cleared query results for location", { keyTypes });
+        logger9.debug("Successfully cleared query results for location", { keyTypes });
       }
     } catch (error) {
-      logger8.warning("Failed to handle location-based invalidation", {
+      logger9.warning("Failed to handle location-based invalidation", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1110,7 +1461,7 @@ function isCache(instance) {
   return instance !== null && typeof instance === "object" && "operations" in instance && "cacheMap" in instance && typeof instance.cacheMap.invalidateItemKeys === "function";
 }
 var handleActionCacheInvalidation = async (registry, affectedItems) => {
-  logger8.debug("Handling action cache invalidation", {
+  logger9.debug("Handling action cache invalidation", {
     affectedItemsCount: affectedItems.length
   });
   const { keys, keyTypeArrays } = extractKeysAndKeyTypesFromActionResult(affectedItems);
@@ -1118,10 +1469,10 @@ var handleActionCacheInvalidation = async (registry, affectedItems) => {
 };
 
 // src/ops/action.ts
-var logger9 = logger_default.get("action");
+var logger10 = logger_default.get("action");
 var action = async (key, action2, body = {}, context) => {
   const { coordinate } = context;
-  logger9.default("action", { key, action: action2, body });
+  logger10.default("action", { key, action: action2, body });
   const wrappedAction = createActionWrapper(
     coordinate,
     async (k, a, b) => {
@@ -1134,28 +1485,28 @@ var action = async (key, action2, body = {}, context) => {
 async function executeActionLogic(key, action2, body, context) {
   const { api, cacheMap, pkType, registry } = context;
   if (!isValidItemKey5(key)) {
-    logger9.error("Key for Action is not a valid ItemKey: %j", key);
+    logger10.error("Key for Action is not a valid ItemKey: %j", key);
     throw new Error("Key for Action is not a valid ItemKey");
   }
-  logger9.debug("Invalidating item key before action", { key });
+  logger10.debug("Invalidating item key before action", { key });
   cacheMap.invalidateItemKeys([key]);
   const result = await api.action(key, action2, body);
   const updated = result[0];
   const affectedItems = result[1];
   if (affectedItems && affectedItems.length > 0) {
-    logger9.debug("Handling cache invalidation for affected items", {
+    logger10.debug("Handling cache invalidation for affected items", {
       affectedItemsCount: affectedItems.length
     });
     try {
       await handleActionCacheInvalidation(registry, affectedItems);
     } catch (error) {
-      logger9.warning("Failed to handle cache invalidation for affected items", {
+      logger10.warning("Failed to handle cache invalidation for affected items", {
         error: error instanceof Error ? error.message : String(error),
         affectedItems
       });
     }
   }
-  logger9.debug("Caching action result", { updatedKey: updated.key });
+  logger10.debug("Caching action result", { updatedKey: updated.key });
   cacheMap.set(updated.key, updated);
   const keyStr = JSON.stringify(updated.key);
   context.ttlManager.onItemAdded(keyStr, cacheMap);
@@ -1165,19 +1516,19 @@ async function executeActionLogic(key, action2, body, context) {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
     } catch (error) {
-      logger9.error("Failed to parse evicted key during deletion", {
+      logger10.error("Failed to parse evicted key during deletion", {
         evictedKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   }
-  logger9.debug("Emitting itemUpdated event after action", {
+  logger10.debug("Emitting itemUpdated event after action", {
     key: updated.key,
     action: action2
   });
   const itemEvent = CacheEventFactory.itemUpdated(updated.key, updated, null, "api");
   context.eventEmitter.emit(itemEvent);
-  logger9.debug("Emitting queryInvalidatedEvent after action", {
+  logger10.debug("Emitting queryInvalidatedEvent after action", {
     eventType: "query_invalidated",
     reason: "item_changed",
     action: action2
@@ -1197,10 +1548,10 @@ import {
   createAllActionWrapper
 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
-var logger10 = logger_default.get("allAction");
+var logger11 = logger_default.get("allAction");
 var allAction = async (action2, body = {}, locations = [], context) => {
   const { coordinate } = context;
-  logger10.default("allAction", { action: action2, body, locations });
+  logger11.default("allAction", { action: action2, body, locations });
   const wrappedAllAction = createAllActionWrapper(
     coordinate,
     async (a, b, locs) => {
@@ -1220,10 +1571,10 @@ async function executeAllActionLogic(action2, body, locations, context) {
         existingItems.push(...cachedItems);
       }
     } catch (error) {
-      logger10.debug("Could not retrieve existing items for comparison", { error });
+      logger11.debug("Could not retrieve existing items for comparison", { error });
     }
   }
-  logger10.debug("Invalidating location before allAction", { locations });
+  logger11.debug("Invalidating location before allAction", { locations });
   await cacheMap.invalidateLocation(locations);
   let ret = [];
   let affectedItems = [];
@@ -1233,7 +1584,7 @@ async function executeAllActionLogic(action2, body, locations, context) {
       ret = result[0];
       affectedItems = result[1];
     } else {
-      logger10.warning("Unexpected result format from allAction", {
+      logger11.warning("Unexpected result format from allAction", {
         resultType: typeof result,
         isArray: Array.isArray(result),
         resultLength: Array.isArray(result) ? result.length : "not array"
@@ -1242,19 +1593,19 @@ async function executeAllActionLogic(action2, body, locations, context) {
       affectedItems = [];
     }
     if (affectedItems && affectedItems.length > 0) {
-      logger10.debug("Handling cache invalidation for affected items", {
+      logger11.debug("Handling cache invalidation for affected items", {
         affectedItemsCount: affectedItems.length
       });
       try {
         await handleActionCacheInvalidation(registry, affectedItems);
       } catch (error) {
-        logger10.warning("Failed to handle cache invalidation for affected items", {
+        logger11.warning("Failed to handle cache invalidation for affected items", {
           error: error instanceof Error ? error.message : String(error),
           affectedItems
         });
       }
     }
-    logger10.debug("Caching allAction results", { resultCount: ret.length });
+    logger11.debug("Caching allAction results", { resultCount: ret.length });
     const modifiedItems = [];
     const newItems = [];
     for (const v of ret) {
@@ -1276,7 +1627,7 @@ async function executeAllActionLogic(action2, body, locations, context) {
       }
     }
     for (const item of modifiedItems) {
-      logger10.debug("Emitting item_updated event for modified item", { key: item.key });
+      logger11.debug("Emitting item_updated event for modified item", { key: item.key });
       const itemEvent = CacheEventFactory.itemUpdated(
         item.key,
         item,
@@ -1287,7 +1638,7 @@ async function executeAllActionLogic(action2, body, locations, context) {
       eventEmitter.emit(itemEvent);
     }
     for (const item of newItems) {
-      logger10.debug("Emitting item_created event for new item", { key: item.key });
+      logger11.debug("Emitting item_created event for new item", { key: item.key });
       const itemEvent = CacheEventFactory.itemCreated(
         item.key,
         item,
@@ -1297,14 +1648,14 @@ async function executeAllActionLogic(action2, body, locations, context) {
     }
     if (modifiedItems.length > 0) {
       const modifiedKeys = modifiedItems.map((item) => item.key);
-      logger10.debug("Invalidating individual item keys for modified items", {
+      logger11.debug("Invalidating individual item keys for modified items", {
         keyCount: modifiedKeys.length,
         keys: modifiedKeys
       });
       await cacheMap.invalidateItemKeys(modifiedKeys);
     }
     await cacheMap.clearQueryResults();
-    logger10.debug("Emitting query_invalidated event after allAction", {
+    logger11.debug("Emitting query_invalidated event after allAction", {
       eventType: "query_invalidated",
       reason: "item_changed",
       action: action2,
@@ -1337,10 +1688,10 @@ async function executeAllActionLogic(action2, body, locations, context) {
 import {
   createFacetWrapper
 } from "@fjell/core";
-var logger11 = logger_default.get("facet");
+var logger12 = logger_default.get("facet");
 var facet = async (key, facet2, params = {}, context) => {
   const { coordinate, api } = context;
-  logger11.default("facet", { key, facet: facet2 });
+  logger12.default("facet", { key, facet: facet2 });
   const wrappedFacet = createFacetWrapper(
     coordinate,
     async (k, f, p) => {
@@ -1354,10 +1705,10 @@ var facet = async (key, facet2, params = {}, context) => {
 import {
   createAllFacetWrapper
 } from "@fjell/core";
-var logger12 = logger_default.get("allFacet");
+var logger13 = logger_default.get("allFacet");
 var allFacet = async (facet2, params = {}, locations = [], context) => {
   const { api, coordinate } = context;
-  logger12.default("allFacet", { facet: facet2, params, locations });
+  logger13.default("allFacet", { facet: facet2, params, locations });
   const wrappedAllFacet = createAllFacetWrapper(
     coordinate,
     async (f, p, locs) => {
@@ -1371,10 +1722,10 @@ var allFacet = async (facet2, params = {}, locations = [], context) => {
 import {
   createFindWrapper
 } from "@fjell/core";
-var logger13 = logger_default.get("find");
+var logger14 = logger_default.get("find");
 var find = async (finder, params = {}, locations = [], context) => {
   const { coordinate } = context;
-  logger13.default("find", { finder, params, locations });
+  logger14.default("find", { finder, params, locations });
   const wrappedFind = createFindWrapper(
     coordinate,
     async (f, p, locs) => {
@@ -1387,21 +1738,21 @@ var find = async (finder, params = {}, locations = [], context) => {
 async function executeFindLogic(finder, params, locations, context) {
   const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
   if (context.options?.bypassCache) {
-    logger13.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
+    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
     try {
       const ret2 = await api.find(finder, params, locations);
-      logger13.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
+      logger14.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
       return ret2;
     } catch (error) {
-      logger13.error("API request failed", { finder, params, locations, error });
+      logger14.error("API request failed", { finder, params, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, params, locations);
-  logger13.debug("Generated query hash for find", { queryHash, finder, params, locations });
+  logger14.debug("Generated query hash for find", { queryHash, finder, params, locations });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger13.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
+    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -1416,7 +1767,7 @@ async function executeFindLogic(finder, params, locations, context) {
     if (allItemsAvailable) {
       return cachedItems;
     } else {
-      logger13.debug("Some cached items missing, invalidating query cache");
+      logger14.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1433,7 +1784,7 @@ async function executeFindLogic(finder, params, locations, context) {
   }
   const itemKeys = ret.map((item) => item.key);
   cacheMap.setQueryResult(queryHash, itemKeys);
-  logger13.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+  logger14.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
   const event = CacheEventFactory.createQueryEvent(params, locations, ret);
   eventEmitter.emit(event);
   return ret;
@@ -1443,10 +1794,10 @@ async function executeFindLogic(finder, params, locations, context) {
 import {
   createFindOneWrapper
 } from "@fjell/core";
-var logger14 = logger_default.get("findOne");
+var logger15 = logger_default.get("findOne");
 var findOne = async (finder, finderParams = {}, locations = [], context) => {
   const { coordinate } = context;
-  logger14.default("findOne", { finder, finderParams, locations });
+  logger15.default("findOne", { finder, finderParams, locations });
   const wrappedFindOne = createFindOneWrapper(
     coordinate,
     async (f, p, locs) => {
@@ -1459,29 +1810,29 @@ 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) {
-    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
+    logger15.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
     try {
       const ret2 = await api.findOne(finder, finderParams, locations);
       if (ret2 === null) {
         throw new Error(`findOne returned null for finder: ${finder}`);
       }
-      logger14.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
+      logger15.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
       return ret2;
     } catch (error) {
-      logger14.error("API request failed", { finder, finderParams, locations, error });
+      logger15.error("API request failed", { finder, finderParams, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, finderParams, locations);
-  logger14.debug("Generated query hash for findOne", { queryHash });
+  logger15.debug("Generated query hash for findOne", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys && cachedItemKeys.length > 0) {
-    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger15.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const item = await cacheMap.get(cachedItemKeys[0]);
     if (item) {
       return item;
     } else {
-      logger14.debug("Cached item missing, invalidating query cache");
+      logger15.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1498,7 +1849,7 @@ async function executeFindOneLogic(finder, finderParams, locations, context) {
     await cacheMap.delete(parsedKey);
   }
   cacheMap.setQueryResult(queryHash, [ret.key]);
-  logger14.debug("Cached query result", { queryHash, itemKey: ret.key });
+  logger15.debug("Cached query result", { queryHash, itemKey: ret.key });
   const event = CacheEventFactory.createQueryEvent(finderParams, locations, [ret]);
   eventEmitter.emit(event);
   return ret;
@@ -1509,7 +1860,7 @@ import {
   isItemKeyEqual,
   isValidItemKey as isValidItemKey6
 } from "@fjell/core";
-var logger15 = logger_default.get("set");
+var logger16 = logger_default.get("set");
 var normalizeKeyValue2 = (value) => {
   return String(value);
 };
@@ -1559,13 +1910,13 @@ var normalizeKey = (key) => {
 };
 var set = async (key, v, context) => {
   const { cacheMap, pkType, ttlManager, evictionManager, eventEmitter } = context;
-  logger15.default("set", { key, v });
+  logger16.default("set", { key, v });
   if (!isValidItemKey6(key)) {
-    logger15.error("Key for Set is not a valid ItemKey: %j", key);
+    logger16.error("Key for Set is not a valid ItemKey: %j", key);
     throw new Error("Key for Set is not a valid ItemKey");
   }
   if (!isItemKeyEqualNormalized(key, v.key)) {
-    logger15.error("Key does not match item key: %j != %j", key, v.key);
+    logger16.error("Key does not match item key: %j != %j", key, v.key);
     throw new Error("Key does not match item key");
   }
   const previousItem = await cacheMap.get(key);
@@ -1599,17 +1950,7 @@ import {
   isComKey,
   isQueryMatch
 } from "@fjell/core";
-
-// src/CacheMap.ts
-var CacheMap = class {
-  types;
-  constructor(types) {
-    this.types = types;
-  }
-};
-
-// src/memory/MemoryCacheMap.ts
-var logger16 = logger_default.get("MemoryCacheMap");
+var logger17 = logger_default.get("MemoryCacheMap");
 var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   implementationType = "memory/memory";
   map = {};
@@ -1627,13 +1968,13 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger16.error("Failed to parse initial data key", { keyStr, error });
+          logger17.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger16.trace("get", { key });
+    logger17.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -1648,7 +1989,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger16.trace("set", { key, value });
+    logger17.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const keyStr = JSON.stringify(key);
     this.map[hashedKey] = { originalKey: key, value };
@@ -1675,7 +2016,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
   }
   async delete(key) {
-    logger16.trace("delete", { key });
+    logger17.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -1704,10 +2045,10 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger16.debug("Returning all items, LocKeys is empty");
+      logger17.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger16.debug("allIn", { locations, count: allValues.length });
+      logger17.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey(key)) {
@@ -1719,12 +2060,12 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger16.debug("contains", { query, locations });
+    logger17.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch(item, query));
   }
   async queryIn(query, locations = []) {
-    logger16.debug("queryIn", { query, locations });
+    logger17.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch(item, query));
   }
@@ -1747,7 +2088,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger16.trace("setQueryResult", { queryHash, itemKeys });
+    logger17.trace("setQueryResult", { queryHash, itemKeys });
     const entry = {
       itemKeys: [...itemKeys]
       // Create a copy to avoid external mutations
@@ -1755,7 +2096,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     this.queryResultCache[queryHash] = entry;
   }
   async getQueryResult(queryHash) {
-    logger16.trace("getQueryResult", { queryHash });
+    logger17.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -1767,11 +2108,11 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry;
   }
   async deleteQueryResult(queryHash) {
-    logger16.trace("deleteQueryResult", { queryHash });
+    logger17.trace("deleteQueryResult", { queryHash });
     delete this.queryResultCache[queryHash];
   }
   async invalidateItemKeys(keys) {
-    logger16.debug("invalidateItemKeys", { keys });
+    logger17.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -1802,14 +2143,14 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       this.deleteQueryResult(queryHash);
     });
-    logger16.debug("Selectively invalidated queries referencing affected keys", {
+    logger17.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
     });
   }
   async invalidateLocation(locations) {
-    logger16.debug("invalidateLocation", { locations });
+    logger17.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -1822,7 +2163,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     await this.invalidateItemKeys(keysToInvalidate);
   }
   async clearQueryResults() {
-    logger16.trace("clearQueryResults");
+    logger17.trace("clearQueryResults");
     this.queryResultCache = {};
   }
   // CacheMapMetadataProvider implementation
@@ -1864,7 +2205,7 @@ import {
   isComKey as isComKey2,
   isQueryMatch as isQueryMatch2
 } from "@fjell/core";
-var logger17 = logger_default.get("EnhancedMemoryCacheMap");
+var logger18 = logger_default.get("EnhancedMemoryCacheMap");
 var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   implementationType = "memory/enhanced";
   map = {};
@@ -1883,11 +2224,11 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.normalizedHashFunction = createNormalizedHashFunction();
     if (sizeConfig?.maxSizeBytes) {
       this.maxSizeBytes = parseSizeString(sizeConfig.maxSizeBytes);
-      logger17.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
+      logger18.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
     }
     if (sizeConfig?.maxItems) {
       this.maxItems = sizeConfig.maxItems;
-      logger17.debug("Cache item limit set", { maxItems: this.maxItems });
+      logger18.debug("Cache item limit set", { maxItems: this.maxItems });
     }
     if (initialData) {
       for (const [keyStr, value] of Object.entries(initialData)) {
@@ -1895,13 +2236,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger17.error("Failed to parse initial data key", { keyStr, error });
+          logger18.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger17.trace("get", { key });
+    logger18.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey && entry.value !== null) {
@@ -1910,7 +2251,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger17.trace("set", { key, value });
+    logger18.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const estimatedSize = estimateValueSize(value);
     const existingEntry = this.map[hashedKey];
@@ -1921,7 +2262,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const oldValue = existingEntry.value;
       existingEntry.value = value;
       existingEntry.metadata.estimatedSize = estimatedSize;
-      logger17.trace("Updated existing cache entry", {
+      logger18.trace("Updated existing cache entry", {
         key: hashedKey,
         sizeDiff,
         currentSize: this.currentSizeBytes,
@@ -1942,7 +2283,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       };
       this.currentSizeBytes += estimatedSize;
       this.currentItemCount++;
-      logger17.trace("Added new cache entry", {
+      logger18.trace("Added new cache entry", {
         key: hashedKey,
         size: estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1959,14 +2300,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.deleteInternal(key, true, "filter");
   }
   deleteInternal(key, invalidateQueries = false, invalidationMode = "remove") {
-    logger17.trace("delete", { key });
+    logger18.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
       this.currentSizeBytes -= entry.metadata.estimatedSize;
       this.currentItemCount--;
       delete this.map[hashedKey];
-      logger17.trace("Deleted cache entry", {
+      logger18.trace("Deleted cache entry", {
         key: hashedKey,
         freedSize: entry.metadata.estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1988,7 +2329,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.value);
   }
   async clear() {
-    logger17.debug("Clearing cache", {
+    logger18.debug("Clearing cache", {
       itemsCleared: this.currentItemCount,
       bytesFreed: this.currentSizeBytes
     });
@@ -1999,10 +2340,10 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger17.debug("Returning all items, LocKeys is empty");
+      logger18.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger17.debug("allIn", { locations, count: allValues.length });
+      logger18.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey2(key)) {
@@ -2013,12 +2354,12 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger17.debug("contains", { query, locations });
+    logger18.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch2(item, query));
   }
   async queryIn(query, locations = []) {
-    logger17.debug("queryIn", { query, locations });
+    logger18.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch2(item, query));
   }
@@ -2064,7 +2405,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   }
   // Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger17.trace("setQueryResult", { queryHash, itemKeys });
+    logger18.trace("setQueryResult", { queryHash, itemKeys });
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
     }
@@ -2076,7 +2417,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.addQueryResultToSizeTracking(queryHash, entry);
   }
   async getQueryResult(queryHash) {
-    logger17.trace("getQueryResult", { queryHash });
+    logger18.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -2098,7 +2439,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.queryResultsCacheSize = 0;
   }
   async invalidateItemKeys(keys) {
-    logger17.debug("invalidateItemKeys", { keys });
+    logger18.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2148,7 +2489,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     });
   }
   async invalidateLocation(locations) {
-    logger17.debug("invalidateLocation", { locations });
+    logger18.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2168,7 +2509,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     const itemKeysSize = estimateValueSize(entry.itemKeys);
     const totalSize = hashSize + itemKeysSize;
     this.queryResultsCacheSize += totalSize;
-    logger17.trace("Added query result to size tracking", {
+    logger18.trace("Added query result to size tracking", {
       queryHash,
       estimatedSize: totalSize,
       totalQueryCacheSize: this.queryResultsCacheSize
@@ -2184,7 +2525,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const itemKeysSize = estimateValueSize(entry.itemKeys);
       const totalSize = hashSize + itemKeysSize;
       this.queryResultsCacheSize = Math.max(0, this.queryResultsCacheSize - totalSize);
-      logger17.trace("Removed query result from size tracking", {
+      logger18.trace("Removed query result from size tracking", {
         queryHash,
         estimatedSize: totalSize,
         totalQueryCacheSize: this.queryResultsCacheSize
@@ -2269,7 +2610,7 @@ import {
   isComKey as isComKey3,
   isQueryMatch as isQueryMatch3
 } from "@fjell/core";
-var logger18 = logger_default.get("LocalStorageCacheMap");
+var logger19 = logger_default.get("LocalStorageCacheMap");
 var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
   implementationType = "browser/localStorage";
   keyPrefix;
@@ -2300,7 +2641,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return keys;
     } catch (error) {
-      logger18.error("Error getting keys by prefix from localStorage", { prefix, error });
+      logger19.error("Error getting keys by prefix from localStorage", { prefix, error });
       throw error;
     }
   }
@@ -2308,12 +2649,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       const allEntries = this.collectCacheEntries();
       if (allEntries.length === 0) {
-        logger18.debug("No entries to clean up");
+        logger19.debug("No entries to clean up");
         return false;
       }
       return this.removeOldestEntries(allEntries, aggressive);
     } catch (error) {
-      logger18.error("Failed to cleanup old localStorage entries", { error });
+      logger19.error("Failed to cleanup old localStorage entries", { error });
       return false;
     }
   }
@@ -2339,7 +2680,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           }
         }
       } catch (error) {
-        logger18.debug("Found corrupted entry during cleanup", { key, error });
+        logger19.debug("Found corrupted entry during cleanup", { key, error });
         allEntries.push({ key, timestamp: 0, size: 0 });
       }
     }
@@ -2358,12 +2699,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         removedCount++;
         removedSize += allEntries[i].size;
       } catch (error) {
-        logger18.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
+        logger19.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
       }
     }
     if (removedCount > 0) {
       const cleanupType = aggressive ? "aggressive" : "normal";
-      logger18.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
+      logger19.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
     }
     return removedCount > 0;
   }
@@ -2371,7 +2712,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     return this.getAllKeysStartingWith(`${this.keyPrefix}:`);
   }
   async get(key) {
-    logger18.trace("get", { key });
+    logger19.trace("get", { key });
     try {
       const storageKey = this.getStorageKey(key);
       let stored = localStorage.getItem(storageKey);
@@ -2386,18 +2727,18 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             return parsed.value;
           }
         } catch (parseError) {
-          logger18.debug("Failed to parse stored value", { key, error: parseError });
+          logger19.debug("Failed to parse stored value", { key, error: parseError });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger18.error("Error retrieving from localStorage", { key, error });
+      logger19.error("Error retrieving from localStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
-    logger18.trace("set", { key, value });
+    logger19.trace("set", { key, value });
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
         const storageKey = this.getStorageKey(key);
@@ -2408,12 +2749,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         };
         localStorage.setItem(storageKey, JSON.stringify(toStore));
         if (attempt > 0) {
-          logger18.info(`Successfully stored item after ${attempt} retries`);
+          logger19.info(`Successfully stored item after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger18.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger19.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           value,
           error,
@@ -2440,30 +2781,30 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           const parsed = JSON.parse(stored);
           return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
         } catch (parseError) {
-          logger18.debug("Failed to parse stored value in includesKey", { key, error: parseError });
+          logger19.debug("Failed to parse stored value in includesKey", { key, error: parseError });
           return false;
         }
       }
       return false;
     } catch (error) {
-      logger18.error("Error checking key in localStorage", { key, error });
+      logger19.error("Error checking key in localStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger18.trace("delete", { key });
+    logger19.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       localStorage.removeItem(storageKey);
     } catch (error) {
-      logger18.error("Error deleting from localStorage", { key, error });
+      logger19.error("Error deleting from localStorage", { key, error });
       throw error;
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger18.debug("Returning all items, LocKeys is empty");
+      logger19.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -2475,10 +2816,10 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger18.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey3(key)).filter((key) => {
         const ComKey16 = key;
-        logger18.debug("Comparing Location Keys", {
+        logger19.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey16
         });
@@ -2495,12 +2836,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger18.debug("contains", { query, locations });
+    logger19.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch3(item, query));
   }
   async queryIn(query, locations = []) {
-    logger18.debug("queryIn", { query, locations });
+    logger19.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch3(item, query));
   }
@@ -2514,7 +2855,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         return JSON.parse(stored);
       }
     } catch (parseError) {
-      logger18.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
+      logger19.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
     }
     return null;
   }
@@ -2529,7 +2870,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger18.error("Error getting keys from localStorage", { error });
+      logger19.error("Error getting keys from localStorage", { error });
     }
     return keys;
   }
@@ -2544,25 +2885,25 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger18.error("Error getting values from localStorage", { error });
+      logger19.error("Error getting values from localStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger18.debug("Clearing localStorage cache");
+    logger19.debug("Clearing localStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         localStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger18.error("Error clearing localStorage cache", { error });
+      logger19.error("Error clearing localStorage cache", { error });
       throw error;
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger18.trace("setQueryResult", { queryHash, itemKeys });
+    logger19.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -2570,11 +2911,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       localStorage.setItem(queryKey, JSON.stringify(entry));
     } catch (error) {
-      logger18.error("Failed to store query result in localStorage", { queryHash, error });
+      logger19.error("Failed to store query result in localStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger18.trace("getQueryResult", { queryHash });
+    logger19.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = localStorage.getItem(queryKey);
@@ -2587,7 +2928,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger18.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      logger19.error("Failed to retrieve query result from localStorage", { queryHash, error });
       return null;
     }
   }
@@ -2596,21 +2937,21 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       return localStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger18.error("Failed to check query result in localStorage", { queryHash, error });
+      logger19.error("Failed to check query result in localStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger18.trace("deleteQueryResult", { queryHash });
+    logger19.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       localStorage.removeItem(queryKey);
     } catch (error) {
-      logger18.error("Failed to delete query result from localStorage", { queryHash, error });
+      logger19.error("Failed to delete query result from localStorage", { queryHash, error });
     }
   }
   async invalidateItemKeys(keys) {
-    logger18.debug("invalidateItemKeys", { keys });
+    logger19.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2648,24 +2989,24 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger18.debug("Failed to parse query result", { queryKey, error });
+          logger19.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         localStorage.removeItem(queryKey);
       });
-      logger18.debug("Selectively invalidated queries referencing affected keys", {
+      logger19.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.length
       });
     } catch (error) {
-      logger18.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger19.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger18.debug("invalidateLocation", { locations });
+    logger19.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2680,7 +3021,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async clearQueryResults() {
-    logger18.trace("clearQueryResults");
+    logger19.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = this.getAllKeysStartingWith(queryPrefix);
@@ -2688,11 +3029,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           localStorage.removeItem(key);
         } catch (error) {
-          logger18.error("Failed to remove query result from localStorage", { key, error });
+          logger19.error("Failed to remove query result from localStorage", { key, error });
         }
       }
     } catch (error) {
-      logger18.error("Failed to clear query results from localStorage", { error });
+      logger19.error("Failed to clear query results from localStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -2704,13 +3045,13 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           return JSON.parse(stored);
         } catch (e) {
-          logger18.debug("Invalid metadata JSON, treating as null", { key, error: e });
+          logger19.debug("Invalid metadata JSON, treating as null", { key, error: e });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger18.error("Error getting metadata from localStorage", { key, error });
+      logger19.error("Error getting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2720,12 +3061,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         const metadataKey = `${this.keyPrefix}:metadata:${key}`;
         localStorage.setItem(metadataKey, JSON.stringify(metadata));
         if (attempt > 0) {
-          logger18.info(`Successfully stored metadata after ${attempt} retries`);
+          logger19.info(`Successfully stored metadata after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger18.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger19.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           error,
           isLastAttempt
@@ -2747,7 +3088,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       localStorage.removeItem(metadataKey);
     } catch (error) {
-      logger18.error("Error deleting metadata from localStorage", { key, error });
+      logger19.error("Error deleting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2766,11 +3107,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             metadata.set(metadataKey, parsed);
           }
         } catch (error) {
-          logger18.debug("Skipping invalid metadata entry", { key, error });
+          logger19.debug("Skipping invalid metadata entry", { key, error });
         }
       }
     } catch (error) {
-      logger18.error("Error getting metadata from localStorage", { error });
+      logger19.error("Error getting metadata from localStorage", { error });
       throw error;
     }
     return metadata;
@@ -2781,7 +3122,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const keysToDelete = this.getAllKeysStartingWith(metadataPrefix);
       keysToDelete.forEach((key) => localStorage.removeItem(key));
     } catch (error) {
-      logger18.error("Error clearing metadata from localStorage", { error });
+      logger19.error("Error clearing metadata from localStorage", { error });
       throw error;
     }
   }
@@ -2808,16 +3149,16 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
                 itemCount++;
               }
             } catch (error) {
-              logger18.debug("Invalid entry in getCurrentSize", { key, error });
+              logger19.debug("Invalid entry in getCurrentSize", { key, error });
             }
           }
         } catch (error) {
-          logger18.debug("Size calculation failed, using string length", { key, error });
+          logger19.debug("Size calculation failed, using string length", { key, error });
           sizeBytes += value.length;
         }
       }
     } catch (error) {
-      logger18.error("Error calculating size from localStorage", { error });
+      logger19.error("Error calculating size from localStorage", { error });
       throw error;
     }
     return { itemCount, sizeBytes };
@@ -2838,7 +3179,7 @@ import {
   isQueryMatch as isQueryMatch4
 } from "@fjell/core";
 import safeStringify2 from "fast-safe-stringify";
-var logger19 = logger_default.get("SessionStorageCacheMap");
+var logger20 = logger_default.get("SessionStorageCacheMap");
 var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   implementationType = "browser/sessionStorage";
   keyPrefix;
@@ -2866,7 +3207,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger19.error("Error getting keys from sessionStorage", { error });
+      logger20.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2889,7 +3230,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async get(key) {
-    logger19.trace("get", { key });
+    logger20.trace("get", { key });
     try {
       const currentHash = this.normalizedHashFunction(key);
       if (this.hasCollisionForHash(currentHash)) {
@@ -2909,14 +3250,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return null;
     } catch (error) {
-      logger19.error("Error retrieving from sessionStorage", { key, error });
+      logger20.error("Error retrieving from sessionStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
     try {
       const storageKey = this.getStorageKey(key);
-      logger19.trace("set", { storageKey });
+      logger20.trace("set", { storageKey });
       const toStore = {
         originalKey: key,
         value,
@@ -2926,7 +3267,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(toStore);
       sessionStorage.setItem(storageKey, jsonString);
     } catch (error) {
-      logger19.error("Error storing to sessionStorage", { errorMessage: error?.message });
+      logger20.error("Error storing to sessionStorage", { errorMessage: error?.message });
       throw new Error(`Failed to store item in sessionStorage: ${error}`);
     }
   }
@@ -2947,23 +3288,23 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return false;
     } catch (error) {
-      logger19.error("Error checking key in sessionStorage", { key, error });
+      logger20.error("Error checking key in sessionStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger19.trace("delete", { key });
+    logger20.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       sessionStorage.removeItem(storageKey);
     } catch (error) {
-      logger19.error("Error deleting from sessionStorage", { key, error });
+      logger20.error("Error deleting from sessionStorage", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger19.debug("Returning all items, LocKeys is empty");
+      logger20.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -2975,10 +3316,10 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger20.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey4(key)).filter((key) => {
         const ComKey16 = key;
-        logger19.debug("Comparing Location Keys", {
+        logger20.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey16
         });
@@ -2995,12 +3336,12 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger19.debug("contains", { query, locations });
+    logger20.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch4(item, query));
   }
   async queryIn(query, locations = []) {
-    logger19.debug("queryIn", { query, locations });
+    logger20.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch4(item, query));
   }
@@ -3020,11 +3361,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             keys.push(parsed.originalKey);
           }
         } catch (itemError) {
-          logger19.trace("Skipping invalid storage item", { storageKey, error: itemError });
+          logger20.trace("Skipping invalid storage item", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger19.error("Error getting keys from sessionStorage", { error });
+      logger20.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -3041,28 +3382,28 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             values.push(parsed.value);
           }
         } catch (itemError) {
-          logger19.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
+          logger20.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger19.error("Error getting values from sessionStorage", { error });
+      logger20.error("Error getting values from sessionStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger19.debug("Clearing sessionStorage cache");
+    logger20.debug("Clearing sessionStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         sessionStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger19.error("Error clearing sessionStorage cache", { error });
+      logger20.error("Error clearing sessionStorage cache", { error });
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger19.trace("setQueryResult", { queryHash, itemKeys });
+    logger20.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -3071,11 +3412,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(entry);
       sessionStorage.setItem(queryKey, jsonString);
     } catch (error) {
-      logger19.error("Failed to store query result in sessionStorage", { queryHash, error });
+      logger20.error("Failed to store query result in sessionStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger19.trace("getQueryResult", { queryHash });
+    logger20.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = sessionStorage.getItem(queryKey);
@@ -3088,7 +3429,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger19.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      logger20.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
       return null;
     }
   }
@@ -3097,21 +3438,21 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     try {
       return sessionStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger19.error("Failed to check query result in sessionStorage", { queryHash, error });
+      logger20.error("Failed to check query result in sessionStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger19.trace("deleteQueryResult", { queryHash });
+    logger20.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       sessionStorage.removeItem(queryKey);
     } catch (error) {
-      logger19.error("Failed to delete query result from sessionStorage", { queryHash, error });
+      logger20.error("Failed to delete query result from sessionStorage", { queryHash, error });
     }
   }
   async clearQueryResults() {
-    logger19.trace("clearQueryResults");
+    logger20.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = [];
@@ -3123,7 +3464,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       keysToRemove.forEach((key) => sessionStorage.removeItem(key));
     } catch (error) {
-      logger19.error("Failed to clear query results from sessionStorage", { error });
+      logger20.error("Failed to clear query results from sessionStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -3170,7 +3511,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return metadata;
     } catch (error) {
-      logger19.error("Error getting all metadata from sessionStorage", { error });
+      logger20.error("Error getting all metadata from sessionStorage", { error });
       return metadata;
     }
   }
@@ -3190,7 +3531,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger19.debug("invalidateItemKeys", { keys });
+    logger20.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3234,24 +3575,24 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger19.debug("Failed to parse query result", { queryKey, error });
+          logger20.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         sessionStorage.removeItem(queryKey);
       });
-      logger19.debug("Selectively invalidated queries referencing affected keys", {
+      logger20.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.length
       });
     } catch (error) {
-      logger19.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger20.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger19.debug("invalidateLocation", { locations });
+    logger20.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -3317,7 +3658,7 @@ import {
   isQueryMatch as isQueryMatch5
 } from "@fjell/core";
 import safeStringify3 from "fast-safe-stringify";
-var logger20 = logger_default.get("AsyncIndexDBCacheMap");
+var logger21 = logger_default.get("AsyncIndexDBCacheMap");
 var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   types;
   dbName;
@@ -3343,19 +3684,19 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         }
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Error opening IndexedDB", { error: request.error });
+          logger21.error("Error opening IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
-          logger20.debug("IndexedDB opened successfully");
+          logger21.debug("IndexedDB opened successfully");
           resolve(request.result);
         };
         request.onupgradeneeded = (event) => {
-          logger20.debug("IndexedDB upgrade needed");
+          logger21.debug("IndexedDB upgrade needed");
           const db = event.target.result;
           if (!db.objectStoreNames.contains(this.storeName)) {
             db.createObjectStore(this.storeName);
-            logger20.debug("Created object store", { storeName: this.storeName });
+            logger21.debug("Created object store", { storeName: this.storeName });
           }
         };
       });
@@ -3366,7 +3707,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     return this.normalizedHashFunction(key);
   }
   async get(key) {
-    logger20.trace("get", { key });
+    logger21.trace("get", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3375,7 +3716,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger20.error("Error getting from IndexedDB", { key, error: request.error });
+          logger21.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3388,7 +3729,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB get operation", { key, error });
+      logger21.error("Error in IndexedDB get operation", { key, error });
       return null;
     }
   }
@@ -3396,7 +3737,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Get both the value and metadata for an item
    */
   async getWithMetadata(key) {
-    logger20.trace("getWithMetadata", { key });
+    logger21.trace("getWithMetadata", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3405,7 +3746,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger20.error("Error getting from IndexedDB", { key, error: request.error });
+          logger21.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3421,12 +3762,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB getWithMetadata operation", { key, error });
+      logger21.error("Error in IndexedDB getWithMetadata operation", { key, error });
       return null;
     }
   }
   async set(key, value, metadata) {
-    logger20.trace("set", { key, value, hasMetadata: !!metadata });
+    logger21.trace("set", { key, value, hasMetadata: !!metadata });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3441,7 +3782,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.put(storedItem, storageKey);
         request.onerror = () => {
-          logger20.error("Error setting in IndexedDB", { key, value, error: request.error });
+          logger21.error("Error setting in IndexedDB", { key, value, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3449,7 +3790,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB set operation", { key, value, error });
+      logger21.error("Error in IndexedDB set operation", { key, value, error });
       throw new Error(`Failed to store item in IndexedDB: ${error}`);
     }
   }
@@ -3457,16 +3798,16 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Update only the metadata for an existing item
    */
   async setMetadata(key, metadata) {
-    logger20.trace("setMetadata", { key, metadata });
+    logger21.trace("setMetadata", { key, metadata });
     try {
       const existing = await this.getWithMetadata(key);
       if (existing) {
         await this.set(key, existing.value, metadata);
       } else {
-        logger20.warning("Attempted to set metadata for non-existent item", { key });
+        logger21.warning("Attempted to set metadata for non-existent item", { key });
       }
     } catch (error) {
-      logger20.error("Error in IndexedDB setMetadata operation", { key, error });
+      logger21.error("Error in IndexedDB setMetadata operation", { key, error });
       throw new Error(`Failed to update metadata in IndexedDB: ${error}`);
     }
   }
@@ -3479,7 +3820,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger20.error("Error checking key in IndexedDB", { key, error: request.error });
+          logger21.error("Error checking key in IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3493,12 +3834,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB includesKey operation", { key, error });
+      logger21.error("Error in IndexedDB includesKey operation", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger20.trace("delete", { key });
+    logger21.trace("delete", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3507,7 +3848,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.delete(storageKey);
         request.onerror = () => {
-          logger20.error("Error deleting from IndexedDB", { key, error: request.error });
+          logger21.error("Error deleting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3515,22 +3856,22 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB delete operation", { key, error });
+      logger21.error("Error in IndexedDB delete operation", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = await this.keys();
     if (locations.length === 0) {
-      logger20.debug("Returning all items, LocKeys is empty");
+      logger21.debug("Returning all items, LocKeys is empty");
       const promises = allKeys.map((key) => this.get(key));
       const results = await Promise.all(promises);
       return results.filter((item) => item !== null);
     } else {
       const locKeys = locations;
-      logger20.debug("allIn", { locKeys, keys: allKeys.length });
+      logger21.debug("allIn", { locKeys, keys: allKeys.length });
       const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
         const ComKey16 = key;
-        logger20.debug("Comparing Location Keys", {
+        logger21.debug("Comparing Location Keys", {
           locKeys,
           ComKey: ComKey16
         });
@@ -3542,12 +3883,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async contains(query, locations) {
-    logger20.debug("contains", { query, locations });
+    logger21.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch5(item, query));
   }
   async queryIn(query, locations = []) {
-    logger20.debug("queryIn", { query, locations });
+    logger21.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch5(item, query));
   }
@@ -3563,7 +3904,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger20.error("Error getting keys from IndexedDB", { error: request.error });
+          logger21.error("Error getting keys from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3578,7 +3919,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB keys operation", { error });
+      logger21.error("Error in IndexedDB keys operation", { error });
       return [];
     }
   }
@@ -3594,7 +3935,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger20.error("Error getting metadata from IndexedDB", { error: request.error });
+          logger21.error("Error getting metadata from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3612,7 +3953,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB getAllMetadata operation", { error });
+      logger21.error("Error in IndexedDB getAllMetadata operation", { error });
       return metadataMap;
     }
   }
@@ -3625,7 +3966,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger20.error("Error getting values from IndexedDB", { error: request.error });
+          logger21.error("Error getting values from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3640,12 +3981,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB values operation", { error });
+      logger21.error("Error in IndexedDB values operation", { error });
       return [];
     }
   }
   async clear() {
-    logger20.debug("Clearing IndexedDB cache");
+    logger21.debug("Clearing IndexedDB cache");
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3653,7 +3994,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.clear();
         request.onerror = () => {
-          logger20.error("Error clearing IndexedDB cache", { error: request.error });
+          logger21.error("Error clearing IndexedDB cache", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3661,17 +4002,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in IndexedDB clear operation", { error });
+      logger21.error("Error in IndexedDB clear operation", { error });
     }
   }
   // Async Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger20.trace("setQueryResult", { queryHash, itemKeys });
+    logger21.trace("setQueryResult", { queryHash, itemKeys });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for setQueryResult", { error: request.error });
+          logger21.error("Failed to open database for setQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3684,7 +4025,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const putRequest = store.put(safeStringify3(entry), queryKey);
           putRequest.onerror = () => {
-            logger20.error("Failed to store query result", { queryHash, error: putRequest.error });
+            logger21.error("Failed to store query result", { queryHash, error: putRequest.error });
             reject(putRequest.error);
           };
           putRequest.onsuccess = () => {
@@ -3693,17 +4034,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in setQueryResult", { queryHash, error });
+      logger21.error("Error in setQueryResult", { queryHash, error });
       throw error;
     }
   }
   async getQueryResult(queryHash) {
-    logger20.trace("getQueryResult", { queryHash });
+    logger21.trace("getQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for getQueryResult", { error: request.error });
+          logger21.error("Failed to open database for getQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3713,7 +4054,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const getRequest = store.get(queryKey);
           getRequest.onerror = () => {
-            logger20.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
+            logger21.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
             reject(getRequest.error);
           };
           getRequest.onsuccess = () => {
@@ -3730,34 +4071,34 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               }
               resolve(entry.itemKeys || null);
             } catch (parseError) {
-              logger20.error("Failed to parse query result", { queryHash, error: parseError });
+              logger21.error("Failed to parse query result", { queryHash, error: parseError });
               resolve(null);
             }
           };
         };
       });
     } catch (error) {
-      logger20.error("Error in getQueryResult", { queryHash, error });
+      logger21.error("Error in getQueryResult", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
-    logger20.trace("hasQueryResult", { queryHash });
+    logger21.trace("hasQueryResult", { queryHash });
     try {
       const result = await this.getQueryResult(queryHash);
       return result !== null;
     } catch (error) {
-      logger20.error("Error in hasQueryResult", { queryHash, error });
+      logger21.error("Error in hasQueryResult", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger20.trace("deleteQueryResult", { queryHash });
+    logger21.trace("deleteQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for deleteQueryResult", { error: request.error });
+          logger21.error("Failed to open database for deleteQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3767,7 +4108,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const deleteRequest = store.delete(queryKey);
           deleteRequest.onerror = () => {
-            logger20.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
+            logger21.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
             reject(deleteRequest.error);
           };
           deleteRequest.onsuccess = () => {
@@ -3776,12 +4117,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in deleteQueryResult", { queryHash, error });
+      logger21.error("Error in deleteQueryResult", { queryHash, error });
       throw error;
     }
   }
   async invalidateItemKeys(keys) {
-    logger20.debug("invalidateItemKeys", { keys });
+    logger21.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3818,7 +4159,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
                   queryResults2[queryHash] = itemKeys;
                 }
               } catch (error) {
-                logger20.debug("Failed to parse query result", { key: item.key, error });
+                logger21.debug("Failed to parse query result", { key: item.key, error });
               }
             }
           }
@@ -3846,18 +4187,18 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           });
         }
       }
-      logger20.debug("Selectively invalidated queries referencing affected keys", {
+      logger21.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: Object.keys(queryResults).length
       });
     } catch (error) {
-      logger20.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger21.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger20.debug("invalidateLocation", { locations });
+    logger21.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       await this.clearQueryResults();
@@ -3870,12 +4211,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async clearQueryResults() {
-    logger20.trace("clearQueryResults");
+    logger21.trace("clearQueryResults");
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger20.error("Failed to open database for clearQueryResults", { error: request.error });
+          logger21.error("Failed to open database for clearQueryResults", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3885,7 +4226,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const cursorRequest = store.openCursor();
           const keysToDelete = [];
           cursorRequest.onerror = () => {
-            logger20.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
+            logger21.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
             reject(cursorRequest.error);
           };
           cursorRequest.onsuccess = () => {
@@ -3906,7 +4247,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               keysToDelete.forEach((queryKey) => {
                 const deleteRequest = store.delete(queryKey);
                 deleteRequest.onerror = () => {
-                  logger20.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
+                  logger21.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
                   deletedCount++;
                   if (deletedCount === totalToDelete) {
                     resolve();
@@ -3924,14 +4265,14 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger20.error("Error in clearQueryResults", { error });
+      logger21.error("Error in clearQueryResults", { error });
       throw error;
     }
   }
 };
 
 // src/browser/IndexDBCacheMap.ts
-var logger21 = logger_default.get("IndexDBCacheMap");
+var logger22 = logger_default.get("IndexDBCacheMap");
 var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   implementationType = "browser/indexedDB";
   // Memory storage
@@ -4115,7 +4456,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger21.debug("invalidateItemKeys", { keys });
+    logger22.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -4145,7 +4486,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       delete this.queryResultCache[queryHash];
     });
-    logger21.debug("Selectively invalidated queries referencing affected keys", {
+    logger22.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
@@ -4279,6 +4620,7 @@ var createOptions = (cacheOptions) => {
   return result;
 };
 var createCacheMap = (kta, options) => {
+  let underlyingCache;
   switch (options.cacheType) {
     case "memory":
       if (options.memoryConfig?.size && (options.memoryConfig.size.maxSizeBytes || options.memoryConfig.size.maxItems)) {
@@ -4286,37 +4628,47 @@ var createCacheMap = (kta, options) => {
           maxSizeBytes: options.memoryConfig.size.maxSizeBytes,
           maxItems: options.memoryConfig.size.maxItems
         };
-        return new EnhancedMemoryCacheMap(
+        underlyingCache = new EnhancedMemoryCacheMap(
           kta,
           sizeConfig
         );
+      } else {
+        underlyingCache = new MemoryCacheMap(kta);
       }
-      return new MemoryCacheMap(kta);
+      break;
     case "localStorage":
-      return new LocalStorageCacheMap(
+      underlyingCache = new LocalStorageCacheMap(
         kta,
         options.webStorageConfig?.keyPrefix
       );
+      break;
     case "sessionStorage":
-      return new SessionStorageCacheMap(
+      underlyingCache = new SessionStorageCacheMap(
         kta,
         options.webStorageConfig?.keyPrefix
       );
+      break;
     case "indexedDB":
-      return new IndexDBCacheMap(
+      underlyingCache = new IndexDBCacheMap(
         kta,
         options.indexedDBConfig?.dbName,
         options.indexedDBConfig?.storeName,
         options.indexedDBConfig?.version
       );
+      break;
     case "custom":
       if (!options.customCacheMapFactory) {
         throw new Error('Custom cache map factory is required when cacheType is "custom"');
       }
-      return options.customCacheMapFactory(kta);
+      underlyingCache = options.customCacheMapFactory(kta);
+      break;
     default:
       throw new Error(`Unsupported cache type: ${options.cacheType}`);
   }
+  if (options.twoLayer && Object.keys(options.twoLayer).length > 0) {
+    return new TwoLayerCacheMap(underlyingCache, options.twoLayer);
+  }
+  return underlyingCache;
 };
 var validateOptions = (options) => {
   const validProperties = /* @__PURE__ */ new Set([
@@ -4333,7 +4685,9 @@ var validateOptions = (options) => {
     "webStorageConfig",
     "memoryConfig",
     "customCacheMapFactory",
-    "evictionConfig"
+    "evictionConfig",
+    // Two-layer cache configuration
+    "twoLayer"
   ]);
   const unknownProperties = [];
   const propertySuggestions = {
@@ -4526,41 +4880,213 @@ var reset = async (coordinate, options) => {
   }
 };
 
-// src/Operations.ts
-var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) => {
-  const context = createCacheContext(api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry, coordinate);
-  return {
-    all: (query, locations) => all(query, locations, context).then(([ctx, result]) => result),
-    one: (query, locations) => one(query, locations, context).then(([ctx, result]) => result),
-    create: (item, options2) => {
-      const locations = options2?.locations || [];
-      return create(item, locations, context).then(([ctx, result]) => result);
+// src/ttl/TTLConfig.ts
+var defaultTTLConfig = {
+  item: {
+    default: 3600,
+    // 1 hour for most items
+    byType: {
+      // Frequently changing data gets shorter TTL
+      "orderPhase": 1800,
+      // 30 minutes - order phases change often
+      "orderStep": 1800,
+      // 30 minutes - order steps change often
+      "orderStatus": 900,
+      // 15 minutes - status changes frequently
+      // Relatively static data gets longer TTL
+      "customer": 7200,
+      // 2 hours - customer data changes rarely
+      "user": 7200,
+      // 2 hours - user data changes rarely
+      "product": 14400,
+      // 4 hours - product data very stable
+      "category": 21600
+      // 6 hours - categories almost never change
+    }
+  },
+  query: {
+    complete: 300,
+    // 5 minutes for complete queries
+    faceted: 60,
+    // 1 minute for filtered queries
+    byFacet: {
+      "report": 30,
+      // 30 seconds - reports need fresh data
+      "search": 120,
+      // 2 minutes - search results can be cached longer
+      "dashboard": 45,
+      // 45 seconds - dashboards need recent data
+      "analytics": 180,
+      // 3 minutes - analytics can be slightly stale
+      "export": 15
+      // 15 seconds - exports need fresh data
+    }
+  },
+  adjustments: {
+    peakHours: {
+      start: 9,
+      // 9 AM
+      end: 17,
+      // 5 PM
+      multiplier: 0.5
+      // Half TTL during business hours for fresher data
     },
-    get: (key) => get(key, context).then(([ctx, result]) => result),
-    retrieve: (key) => retrieve(key, context).then(([ctx, result]) => result),
-    remove: (key) => remove(key, context).then((ctx) => void 0),
-    update: (key, item) => update(key, item, context).then(([ctx, result]) => result),
-    upsert: async (key, itemProperties, locations) => {
-      const existing = await get(key, context).then(([ctx, result]) => result);
-      if (existing) {
-        return update(key, itemProperties, context).then(([ctx, result]) => result);
-      } else {
-        return create(itemProperties, locations || [], context).then(([ctx, result]) => result);
-      }
+    staleWhileRevalidate: true,
+    timezone: "system"
+    // Use system timezone
+  },
+  warming: {
+    enabled: false,
+    // Disabled by default, enable per use case
+    interval: 3e5,
+    // 5 minutes
+    queries: [
+      // Common queries to warm - customize per application
+      { params: { limit: 20, status: "active" }, priority: 1 },
+      { params: { limit: 50, recent: true }, priority: 2 }
+    ]
+  }
+};
+var highTrafficTTLConfig = {
+  ...defaultTTLConfig,
+  query: {
+    complete: 180,
+    // 3 minutes (shorter for high traffic)
+    faceted: 30,
+    // 30 seconds
+    byFacet: {
+      "report": 15,
+      // 15 seconds
+      "search": 60,
+      // 1 minute
+      "dashboard": 20,
+      // 20 seconds
+      "analytics": 90
+      // 1.5 minutes
+    }
+  },
+  adjustments: {
+    peakHours: {
+      start: 8,
+      // Earlier peak
+      end: 18,
+      // Later peak
+      multiplier: 0.3
+      // Even shorter TTL during peaks
     },
-    action: (key, actionName, body) => action(key, actionName, body, context).then(([ctx, result, affectedItems]) => [result, affectedItems]),
-    allAction: (actionName, body, locations) => allAction(actionName, body, locations, context).then(([ctx, result, affectedItems]) => [result, affectedItems]),
-    facet: (key, facetName, params) => facet(key, facetName, params, context).then((result) => result),
-    allFacet: (facetName, params, locations) => allFacet(facetName, params, locations, context).then((result) => result),
-    find: (finder, params, locations) => find(finder, params, locations, context).then(([ctx, result]) => result),
-    findOne: (finder, params, locations) => findOne(finder, params, locations, context).then(([ctx, result]) => result),
-    set: (key, item) => set(key, item, context).then(([ctx, result]) => result),
-    reset: () => reset(coordinate, context.options).then(() => void 0)
-  };
+    staleWhileRevalidate: true
+  }
+};
+
+// src/Operations.ts
+var logger23 = logger_default.get("Operations");
+var CacheMapOperations = class {
+  constructor(api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) {
+    this.api = api;
+    this.coordinate = coordinate;
+    this.cacheMap = cacheMap;
+    this.pkType = pkType;
+    this.options = options;
+    this.eventEmitter = eventEmitter;
+    this.ttlManager = ttlManager;
+    this.evictionManager = evictionManager;
+    this.statsManager = statsManager;
+    this.registry = registry;
+    if (this.options.enableDebugLogging) {
+      logger23.debug("CacheMapOperations initialized", {
+        cacheType: this.cacheMap.implementationType,
+        isTwoLayer: this.cacheMap instanceof TwoLayerCacheMap
+      });
+    }
+  }
+  // Create the cache context once and reuse it across all operations
+  get context() {
+    return createCacheContext(
+      this.api,
+      this.cacheMap,
+      this.pkType,
+      this.options,
+      this.eventEmitter,
+      this.ttlManager,
+      this.evictionManager,
+      this.statsManager,
+      this.registry,
+      this.coordinate
+    );
+  }
+  async all(query = {}, locations = []) {
+    return all(query, locations, this.context).then(([ctx, result]) => result);
+  }
+  async one(query = {}, locations = []) {
+    return one(query, locations, this.context).then(([ctx, result]) => result);
+  }
+  async create(item, options) {
+    const locations = options?.locations || [];
+    return create(item, locations, this.context).then(([ctx, result]) => result);
+  }
+  async get(key) {
+    return get(key, this.context).then(([ctx, result]) => result);
+  }
+  async retrieve(key) {
+    return retrieve(key, this.context).then(([ctx, result]) => result);
+  }
+  async remove(key) {
+    return remove(key, this.context).then((ctx) => void 0);
+  }
+  async update(key, item) {
+    return update(key, item, this.context).then(([ctx, result]) => result);
+  }
+  async set(key, item) {
+    return set(key, item, this.context).then(([ctx, result]) => result);
+  }
+  async reset() {
+    await reset(this.coordinate, this.options);
+    await this.cacheMap.clear();
+  }
+  async upsert(key, itemProperties, locations) {
+    const existing = await this.get(key);
+    if (existing) {
+      return this.update(key, itemProperties);
+    } else {
+      return this.create(itemProperties, { locations: locations || [] });
+    }
+  }
+  async action(key, actionName, body) {
+    return action(key, actionName, body, this.context).then(([ctx, result, affectedItems]) => [result, affectedItems]);
+  }
+  async allAction(actionName, body, locations) {
+    return allAction(actionName, body, locations, this.context).then(([ctx, result, affectedItems]) => [result, affectedItems]);
+  }
+  async facet(key, facetName, params) {
+    return facet(key, facetName, params, this.context);
+  }
+  async allFacet(facetName, params, locations) {
+    return allFacet(facetName, params, locations, this.context);
+  }
+  async find(finder, params, locations) {
+    return find(finder, params, locations, this.context).then(([ctx, result]) => result);
+  }
+  async findOne(finder, params, locations) {
+    return findOne(finder, params, locations, this.context).then(([ctx, result]) => result);
+  }
+};
+var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry) => {
+  return new CacheMapOperations(
+    api,
+    coordinate,
+    cacheMap,
+    pkType,
+    options,
+    eventEmitter,
+    ttlManager,
+    evictionManager,
+    statsManager,
+    registry
+  );
 };
 
 // src/eviction/EvictionManager.ts
-var logger22 = logger_default.get("EvictionManager");
+var logger24 = logger_default.get("EvictionManager");
 var EvictionManager = class {
   evictionStrategy;
   constructor(evictionStrategy) {
@@ -4572,7 +5098,7 @@ var EvictionManager = class {
    */
   setEvictionStrategy(strategy) {
     this.evictionStrategy = strategy;
-    logger22.debug("Eviction strategy updated", {
+    logger24.debug("Eviction strategy updated", {
       strategy: strategy?.getStrategyName() || "none"
     });
   }
@@ -4595,7 +5121,7 @@ var EvictionManager = class {
     try {
       await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger22.error("Error in eviction strategy onItemAccessed", { key, error });
+      logger24.error("Error in eviction strategy onItemAccessed", { key, error });
     }
   }
   /**
@@ -4620,14 +5146,14 @@ var EvictionManager = class {
       }
       await this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
       if (evictedKeys.length > 0) {
-        logger22.debug("Items evicted during addition", {
+        logger24.debug("Items evicted during addition", {
           newKey: key,
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger22.error("Error in eviction strategy onItemAdded", { key, error });
+      logger24.error("Error in eviction strategy onItemAdded", { key, error });
     }
     return evictedKeys;
   }
@@ -4643,7 +5169,7 @@ var EvictionManager = class {
     try {
       this.evictionStrategy.onItemRemoved(key, metadataProvider);
     } catch (error) {
-      logger22.error("Error in eviction strategy onItemRemoved", { key, error });
+      logger24.error("Error in eviction strategy onItemRemoved", { key, error });
     }
   }
   /**
@@ -4664,13 +5190,13 @@ var EvictionManager = class {
         evictedKeys.push(evictKey);
       }
       if (evictedKeys.length > 0) {
-        logger22.debug("Manual eviction performed", {
+        logger24.debug("Manual eviction performed", {
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger22.error("Error in manual eviction", { error });
+      logger24.error("Error in manual eviction", { error });
     }
     return evictedKeys;
   }
@@ -4690,7 +5216,7 @@ var EvictionManager = class {
         this.evictionStrategy.reset();
       }
     }
-    logger22.debug("Eviction manager cleared");
+    logger24.debug("Eviction manager cleared");
   }
   /**
    * Create eviction context from current cache state
@@ -6028,7 +6554,7 @@ function createEvictionStrategy(policy, maxCacheSize, config) {
 }
 
 // src/ttl/TTLManager.ts
-var logger23 = logger_default.get("TTLManager");
+var logger25 = logger_default.get("TTLManager");
 var TTLManager = class {
   config;
   cleanupTimer;
@@ -6040,7 +6566,7 @@ var TTLManager = class {
       validateOnAccess: true,
       ...config
     };
-    logger23.debug("TTL_DEBUG: TTLManager created", {
+    logger25.debug("TTL_DEBUG: TTLManager created", {
       config: this.config,
       isTTLEnabled: this.isTTLEnabled(),
       defaultTTL: this.config.defaultTTL
@@ -6073,13 +6599,13 @@ var TTLManager = class {
         this.startAutoCleanup();
       }
     }
-    logger23.debug("TTL configuration updated", { config: this.config });
+    logger25.debug("TTL configuration updated", { config: this.config });
   }
   /**
    * Set TTL metadata for an item when it's added
    */
   async onItemAdded(key, metadataProvider, itemTTL) {
-    logger23.debug("TTL_DEBUG: onItemAdded called", {
+    logger25.debug("TTL_DEBUG: onItemAdded called", {
       key,
       itemTTL,
       isTTLEnabled: this.isTTLEnabled(),
@@ -6087,19 +6613,19 @@ var TTLManager = class {
       metadataProviderType: metadataProvider?.constructor?.name
     });
     if (!this.isTTLEnabled() && !itemTTL) {
-      logger23.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
+      logger25.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
       return;
     }
-    logger23.debug("TTL_DEBUG: Getting metadata for key", { key });
+    logger25.debug("TTL_DEBUG: Getting metadata for key", { key });
     const metadata = await metadataProvider.getMetadata(key);
-    logger23.debug("TTL_DEBUG: Retrieved metadata", {
+    logger25.debug("TTL_DEBUG: Retrieved metadata", {
       key,
       hasMetadata: !!metadata,
       metadataKeys: metadata ? Object.keys(metadata) : null,
       metadata
     });
     if (!metadata) {
-      logger23.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
+      logger25.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
         key,
         metadataProviderType: metadataProvider?.constructor?.name,
         metadataProviderMethods: metadataProvider ? Object.getOwnPropertyNames(Object.getPrototypeOf(metadataProvider)) : null
@@ -6107,7 +6633,7 @@ var TTLManager = class {
       return;
     }
     const ttl = itemTTL || this.config.defaultTTL;
-    logger23.debug("TTL_DEBUG: Calculated TTL value", {
+    logger25.debug("TTL_DEBUG: Calculated TTL value", {
       key,
       itemTTL,
       defaultTTL: this.config.defaultTTL,
@@ -6120,7 +6646,7 @@ var TTLManager = class {
         expiresAt: metadata.addedAt + ttl,
         ttl
       };
-      logger23.debug("TTL_DEBUG: Setting TTL metadata", {
+      logger25.debug("TTL_DEBUG: Setting TTL metadata", {
         key,
         ttl,
         addedAt: metadata.addedAt,
@@ -6128,9 +6654,9 @@ var TTLManager = class {
         ttlMetadata
       });
       await metadataProvider.setMetadata(key, ttlMetadata);
-      logger23.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+      logger25.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     } else {
-      logger23.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
+      logger25.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
     }
   }
   /**
@@ -6144,7 +6670,7 @@ var TTLManager = class {
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
     if (expired) {
-      logger23.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
+      logger25.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
     }
     return expired;
   }
@@ -6191,7 +6717,7 @@ var TTLManager = class {
       }
     }
     if (expiredKeys.length > 0) {
-      logger23.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
+      logger25.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
     }
     return expiredKeys;
   }
@@ -6219,7 +6745,7 @@ var TTLManager = class {
     }
     metadata.expiresAt += additionalTTL;
     await metadataProvider.setMetadata(key, metadata);
-    logger23.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
+    logger25.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
     return true;
   }
   /**
@@ -6241,7 +6767,7 @@ var TTLManager = class {
       ttl
     };
     await metadataProvider.setMetadata(key, ttlMetadata);
-    logger23.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+    logger25.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     return true;
   }
   /**
@@ -6253,9 +6779,9 @@ var TTLManager = class {
     }
     if (this.config.cleanupInterval) {
       this.cleanupTimer = setInterval(() => {
-        logger23.trace("Auto cleanup timer triggered");
+        logger25.trace("Auto cleanup timer triggered");
       }, this.config.cleanupInterval);
-      logger23.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
+      logger25.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
     }
   }
   /**
@@ -6265,7 +6791,7 @@ var TTLManager = class {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
-      logger23.debug("Auto cleanup stopped");
+      logger25.debug("Auto cleanup stopped");
     }
   }
   /**
@@ -6273,14 +6799,14 @@ var TTLManager = class {
    */
   clear() {
     this.stopAutoCleanup();
-    logger23.debug("TTL manager cleared");
+    logger25.debug("TTL manager cleared");
   }
   /**
    * Cleanup resources
    */
   destroy() {
     this.stopAutoCleanup();
-    logger23.debug("TTL manager destroyed");
+    logger25.debug("TTL manager destroyed");
   }
 };
 
@@ -6680,9 +7206,9 @@ var CacheStatsManager = class {
 };
 
 // src/Cache.ts
-var logger24 = logger_default.get("Cache");
+var logger26 = logger_default.get("Cache");
 var createCache = (api, coordinate, registry, options) => {
-  logger24.debug("createCache", { coordinate, registry, options });
+  logger26.debug("createCache", { coordinate, registry, options });
   const completeOptions = createOptions(options);
   const cacheMap = createCacheMap(coordinate.kta, completeOptions);
   const pkType = coordinate.kta[0];
@@ -6762,13 +7288,13 @@ var isCache2 = (cache) => {
 };
 
 // src/InstanceFactory.ts
-var logger25 = logger_default.get("InstanceFactory");
+var logger27 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (api, options) => {
   const templateOptions = createOptions(options);
   validateOptions(templateOptions);
   return (coordinate, context) => {
     const instanceOptions = createOptions(options);
-    logger25.debug("Creating cache instance", {
+    logger27.debug("Creating cache instance", {
       coordinate,
       registry: context.registry,
       api,
@@ -6835,9 +7361,9 @@ var createInstanceFactory = (api, options) => {
 };
 
 // src/Instance.ts
-var logger26 = logger_default.get("Instance");
+var logger28 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, api, options) => {
-  logger26.debug("createInstance", { coordinate, api, registry, options });
+  logger28.debug("createInstance", { coordinate, api, registry, options });
   return createCache(api, coordinate, registry, options);
 };
 var isInstance = (instance) => {
@@ -6845,7 +7371,7 @@ var isInstance = (instance) => {
 };
 
 // src/Aggregator.ts
-var logger27 = logger_default.get("ItemAggregator");
+var logger29 = logger_default.get("ItemAggregator");
 var toCacheConfig = (config) => {
   let cacheConfig;
   if (config.optional === void 0) {
@@ -6857,22 +7383,22 @@ var toCacheConfig = (config) => {
 };
 var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
   const populate = async (item) => {
-    logger27.default("populate", { item });
+    logger29.default("populate", { item });
     for (const key in aggregates) {
       await populateAggregate(key, item);
     }
     for (const key in events) {
       await populateEvent(key, item);
     }
-    logger27.default("populate done", { item });
+    logger29.default("populate done", { item });
     return item;
   };
   const populateAggregate = async (key, item) => {
-    logger27.default("populate aggregate key", { key });
+    logger29.default("populate aggregate key", { key });
     const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === void 0) {
       if (cacheConfig.optional === false) {
-        logger27.error("Item does not have refs an is not optional ", { item });
+        logger29.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)) {
@@ -6881,7 +7407,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else if (item.refs[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger27.error("Item does not have mandatory ref with key, not optional ", { key, item });
+        logger29.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)) {
@@ -6890,7 +7416,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else {
       const ref = item.refs[key];
-      logger27.default("AGG Retrieving Item in Populate", { key: ref });
+      logger29.default("AGG Retrieving Item in Populate", { key: ref });
       const newItem = await cacheConfig.cache.operations.retrieve(ref);
       if (newItem) {
         if (item.aggs === void 0) {
@@ -6907,25 +7433,25 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const populateEvent = async (key, item) => {
-    logger27.default("populate event key", { key });
+    logger29.default("populate event key", { key });
     const cacheConfig = toCacheConfig(events[key]);
     if (item.events === void 0) {
       throw new Error("Item does not have events " + JSON.stringify(item));
     } else if (item.events[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger27.error("Item does not have mandatory event with key", { key, item });
+        logger29.error("Item does not have mandatory event with key", { key, item });
         throw new Error("Item does not have mandatory event with key " + key + " " + JSON.stringify(item));
       }
     } else {
       const event = item.events[key];
       if (event.by === void 0) {
-        logger27.error(
+        logger29.error(
           "populateEvent with an Event that does not have by",
           { event, ik: item.key, eventKey: key }
         );
         throw new Error("populateEvent with an Event that does not have by: " + JSON.stringify({ key }));
       }
-      logger27.default("EVENT Retrieving Item in Populate", { key: event.by });
+      logger29.default("EVENT Retrieving Item in Populate", { key: event.by });
       const newItem = await cacheConfig.cache.operations.retrieve(event.by);
       if (newItem) {
         event.agg = newItem;
@@ -6933,13 +7459,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const all2 = async (query = {}, locations = []) => {
-    logger27.default("all", { query, locations });
+    logger29.default("all", { query, locations });
     const items = await cache.operations.all(query, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const one2 = async (query = {}, locations = []) => {
-    logger27.default("one", { query, locations });
+    logger29.default("one", { query, locations });
     const item = await cache.operations.one(query, locations);
     let populatedItem = null;
     if (item) {
@@ -6948,30 +7474,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger27.default("action", { key, action: action3, body });
+    logger29.default("action", { key, action: action3, body });
     const [item, affectedItems] = await cache.operations.action(key, action3, body);
     const populatedItem = await populate(item);
     return [populatedItem, affectedItems];
   };
   const allAction2 = async (action3, body = {}, locations = []) => {
-    logger27.default("action", { action: action3, body, locations });
+    logger29.default("action", { action: action3, body, locations });
     const [items, affectedItems] = await cache.operations.allAction(action3, body, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return [populatedItems, affectedItems];
   };
   const allFacet2 = async (facet3, params = {}, locations = []) => {
-    logger27.default("allFacet", { facet: facet3, params, locations });
+    logger29.default("allFacet", { facet: facet3, params, locations });
     const response = await cache.operations.allFacet(facet3, params, locations);
     return response;
   };
   const create2 = async (v, locations = []) => {
-    logger27.default("create", { v, locations });
+    logger29.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) => {
-    logger27.default("get", { key });
+    logger29.default("get", { key });
     const item = await cache.operations.get(key);
     let populatedItem = null;
     if (item) {
@@ -6980,7 +7506,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const retrieve2 = async (key) => {
-    logger27.default("retrieve", { key });
+    logger29.default("retrieve", { key });
     const item = await cache.operations.retrieve(key);
     let populatedItem = null;
     if (item) {
@@ -6989,28 +7515,28 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const remove2 = async (key) => {
-    logger27.default("remove", { key });
+    logger29.default("remove", { key });
     await cache.operations.remove(key);
   };
   const update2 = async (key, v) => {
-    logger27.default("update", { key, v });
+    logger29.default("update", { key, v });
     const item = await cache.operations.update(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const facet2 = async (key, facet3) => {
-    logger27.default("facet", { key, facet: facet3 });
+    logger29.default("facet", { key, facet: facet3 });
     const response = await cache.operations.facet(key, facet3);
     return response;
   };
   const find2 = async (finder, finderParams = {}, locations = []) => {
-    logger27.default("find", { finder, finderParams, locations });
+    logger29.default("find", { finder, finderParams, locations });
     const items = await cache.operations.find(finder, finderParams, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const findOne2 = async (finder, finderParams = {}, locations = []) => {
-    logger27.default("find", { finder, finderParams, locations });
+    logger29.default("find", { finder, finderParams, locations });
     const item = await cache.operations.findOne(finder, finderParams, locations);
     if (!item) {
       return null;
@@ -7019,7 +7545,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const set2 = async (key, v) => {
-    logger27.default("set", { key, v });
+    logger29.default("set", { key, v });
     const item = await cache.operations.set(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
@@ -7071,13 +7597,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger28 = logger_default.get("Registry");
+var logger30 = logger_default.get("Registry");
 var createRegistryFactory = () => {
   return (type, registryHub) => {
     if (type !== "cache") {
       throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
     }
-    logger28.debug("Creating cache registry", { type, registryHub });
+    logger30.debug("Creating cache registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };