@fjell/cache 4.7.33 → 4.7.35

package/dist/index.js

@@ -1,3 +1,9 @@
+// src/Operations.ts
+import {
+  isOperationComKey as isComKey7,
+  isOperationPriKey as isPriKey
+} from "@fjell/core";
+
 // src/CacheContext.ts
 var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManager, evictionManager, statsManager, registry, coordinate) => {
   return {
@@ -16,7 +22,7 @@ var createCacheContext = (api, cacheMap, pkType, options, eventEmitter, ttlManag
 
 // src/ops/all.ts
 import {
-  validatePK
+  createAllWrapper
 } from "@fjell/core";
 import { NotFoundError } from "@fjell/http-api";
 
@@ -314,74 +320,38 @@ import Logging from "@fjell/logging";
 var LibLogger = Logging.getLogger("@fjell/cache");
 var logger_default = LibLogger;
 
-// src/validation/LocationKeyValidator.ts
-var logger = logger_default.get("LocationKeyValidator");
-var validateLocations = (locations, coordinate, operation) => {
-  if (!locations || locations.length === 0) {
-    return;
-  }
-  const keyTypeArray = coordinate.kta;
-  const expectedLocationTypes = keyTypeArray.slice(1);
-  const actualLocationTypes = locations.map((loc) => loc.kt);
-  logger.debug(`Validating locations for ${operation}`, {
-    expected: expectedLocationTypes,
-    actual: actualLocationTypes,
-    coordinate: keyTypeArray
-  });
-  if (actualLocationTypes.length > expectedLocationTypes.length) {
-    logger.error("Location key array has too many elements", {
-      expected: expectedLocationTypes.length,
-      actual: actualLocationTypes.length,
-      expectedTypes: expectedLocationTypes,
-      actualTypes: actualLocationTypes,
-      coordinate,
-      operation
-    });
-    throw new Error(
-      `Invalid location key array for ${operation}: Expected at most ${expectedLocationTypes.length} location keys (hierarchy: [${expectedLocationTypes.join(", ")}]), but received ${actualLocationTypes.length} (types: [${actualLocationTypes.join(", ")}])`
-    );
-  }
-  for (let i = 0; i < actualLocationTypes.length; i++) {
-    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
-      logger.error("Location key array order mismatch", {
-        position: i,
-        expected: expectedLocationTypes[i],
-        actual: actualLocationTypes[i],
-        expectedHierarchy: expectedLocationTypes,
-        actualOrder: actualLocationTypes,
-        coordinate,
-        operation
-      });
-      throw new Error(
-        `Invalid location key array order for ${operation}: At position ${i}, expected key type "${expectedLocationTypes[i]}" but received "${actualLocationTypes[i]}". Location keys must be ordered according to the hierarchy: [${expectedLocationTypes.join(", ")}]. Received order: [${actualLocationTypes.join(", ")}]`
-      );
-    }
-  }
-  logger.debug(`Location key array validation passed for ${operation}`, { locations });
-};
-
 // src/ops/all.ts
-var logger2 = logger_default.get("all");
+var logger = logger_default.get("all");
 var all = async (query = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, coordinate } = context;
-  logger2.default("all", { query, locations });
-  validateLocations(locations, coordinate, "all");
+  logger.default("all", { query, locations });
+  const wrappedAll = createAllWrapper(
+    coordinate,
+    async (q, locs) => {
+      return await executeAllLogic(q ?? {}, locs ?? [], context);
+    }
+  );
+  const result = await wrappedAll(query, locations);
+  return [context, result];
+};
+async function executeAllLogic(query, locations, context) {
+  const { api, cacheMap, pkType, ttlManager } = context;
   if (context.options?.bypassCache) {
-    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const ret2 = await api.all(query, locations);
-      logger2.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret2.length });
-      return [context, validatePK(ret2, pkType)];
+      logger.debug("API response received (not cached due to bypass)", { query, locations, itemCount: ret2.length });
+      return ret2;
     } catch (error) {
-      logger2.error("API request failed", { query, locations, error });
+      logger.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger2.debug("Generated query hash for all", { queryHash });
+  logger.debug("Generated query hash for all", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -394,23 +364,23 @@ var all = async (query = {}, locations = [], context) => {
       }
     }
     if (allItemsAvailable) {
-      return [context, validatePK(cachedItems, pkType)];
+      return cachedItems;
     } else {
-      logger2.debug("Some cached items missing, invalidating query cache");
+      logger.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger2.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
+      logger.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
       const itemKeys = directCachedItems.map((item) => item.key);
       await cacheMap.setQueryResult(queryHash, itemKeys);
-      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
-      return [context, validatePK(directCachedItems, pkType)];
+      logger.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
+      return directCachedItems;
     }
   } catch (error) {
-    logger2.debug("Error querying cache directly, proceeding to API", { error });
+    logger.debug("Error querying cache directly, proceeding to API", { error });
   }
   let ret = [];
   try {
@@ -427,23 +397,23 @@ var all = async (query = {}, locations = [], context) => {
     }
     const itemKeys = ret.map((item) => item.key);
     cacheMap.setQueryResult(queryHash, itemKeys);
-    logger2.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+    logger.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, []);
-      logger2.debug("Cached empty query result for not found", { queryHash });
+      logger.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
   }
-  return [context, validatePK(ret, pkType)];
-};
+  return ret;
+}
 
 // src/ops/one.ts
 import {
-  validatePK as validatePK2
+  createOneWrapper
 } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/http-api";
 
@@ -608,54 +578,64 @@ function validateSizeConfig(config) {
 }
 
 // src/ops/one.ts
-var logger3 = logger_default.get("one");
+var logger2 = logger_default.get("one");
 var one = async (query = {}, locations = [], context) => {
   const { api, cacheMap, pkType, ttlManager, coordinate } = context;
-  logger3.default("one", { query, locations });
-  validateLocations(locations, coordinate, "one");
+  logger2.default("one", { query, locations });
+  const wrappedOne = createOneWrapper(
+    coordinate,
+    async (q, locs) => {
+      return await executeOneLogic(q ?? {}, locs ?? [], context);
+    }
+  );
+  const result = await wrappedOne(query, locations);
+  return [context, result];
+};
+async function executeOneLogic(query, locations, context) {
+  const { api, cacheMap, pkType, ttlManager } = context;
   if (context.options?.bypassCache) {
-    logger3.debug("Cache bypass enabled, fetching directly from API", { query, locations });
+    logger2.debug("Cache bypass enabled, fetching directly from API", { query, locations });
     try {
       const retItem2 = await api.one(query, locations);
       if (retItem2) {
-        logger3.debug("API response received (not cached due to bypass)", { query, locations });
-        return [context, validatePK2(retItem2, pkType)];
+        logger2.debug("API response received (not cached due to bypass)", { query, locations });
+        return retItem2;
       } else {
-        logger3.debug("API returned null", { query, locations });
-        return [context, null];
+        logger2.debug("API returned null", { query, locations });
+        return null;
       }
     } catch (error) {
-      logger3.error("API request failed", { query, locations, error });
+      logger2.error("API request failed", { query, locations, error });
       throw error;
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger3.debug("Generated query hash for one", { queryHash });
+  logger2.debug("Generated query hash for one", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger3.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     if (cachedItemKeys.length === 0) {
-      return [context, null];
+      return null;
     }
     const item = await cacheMap.get(cachedItemKeys[0]);
     if (item) {
-      return [context, validatePK2(item, pkType)];
+      return item;
     } else {
-      logger3.debug("Cached item missing, invalidating query cache");
+      logger2.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger3.debug("Found item directly in cache, skipping API call");
+      logger2.debug("Found item directly in cache, skipping API call");
       const foundItem = directCachedItems[0];
       await cacheMap.setQueryResult(queryHash, [foundItem.key]);
-      logger3.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
-      return [context, validatePK2(foundItem, pkType)];
+      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
+      return foundItem;
     }
   } catch (error) {
-    logger3.debug("Error querying cache directly, proceeding to API", { error });
+    logger2.debug("Error querying cache directly, proceeding to API", { error });
   }
   let retItem = null;
   try {
@@ -682,35 +662,43 @@ var one = async (query = {}, locations = [], context) => {
         await cacheMap.delete(parsedKey);
       }
       await cacheMap.setQueryResult(queryHash, [retItem.key]);
-      logger3.debug("Cached query result", { queryHash, itemKey: retItem.key });
+      logger2.debug("Cached query result", { queryHash, itemKey: retItem.key });
     } else {
       await cacheMap.setQueryResult(queryHash, []);
-      logger3.debug("Cached empty query result", { queryHash });
+      logger2.debug("Cached empty query result", { queryHash });
     }
   } catch (e) {
     if (e instanceof NotFoundError2) {
       cacheMap.setQueryResult(queryHash, []);
-      logger3.debug("Cached empty query result for not found", { queryHash });
+      logger2.debug("Cached empty query result for not found", { queryHash });
     } else {
       throw e;
     }
   }
-  return [
-    context,
-    retItem ? validatePK2(retItem, pkType) : null
-  ];
-};
+  return retItem || null;
+}
 
 // src/ops/create.ts
 import {
-  validatePK as validatePK3
+  createCreateWrapper
 } from "@fjell/core";
-var logger4 = logger_default.get("create");
+var logger3 = logger_default.get("create");
 var create = async (v, locations = [], context) => {
-  const { api, cacheMap, pkType, eventEmitter, ttlManager, evictionManager, coordinate } = context;
-  logger4.default("create", { v, locations });
-  validateLocations(locations, coordinate, "create");
-  const created = await api.create(v, locations);
+  const { coordinate } = context;
+  logger3.default("create", { v, locations });
+  const wrappedCreate = createCreateWrapper(
+    coordinate,
+    async (item, createOptions2) => {
+      const locs = createOptions2?.locations ?? [];
+      return await executeCreateLogic(item, locs, context);
+    }
+  );
+  const result = await wrappedCreate(v, locations.length > 0 ? { locations } : void 0);
+  return [context, result];
+};
+async function executeCreateLogic(v, locations, context) {
+  const { api, cacheMap, pkType, eventEmitter, ttlManager, evictionManager } = context;
+  const created = await api.create(v, locations.length > 0 ? { locations } : void 0);
   cacheMap.set(created.key, created);
   const keyStr = JSON.stringify(created.key);
   ttlManager.onItemAdded(keyStr, cacheMap);
@@ -729,15 +717,15 @@ var create = async (v, locations = [], context) => {
     { source: "operation", context: { operation: "create" } }
   );
   eventEmitter.emit(queryInvalidatedEvent);
-  return [context, validatePK3(created, pkType)];
-};
+  return created;
+}
 
 // src/ops/get.ts
 import {
-  isValidItemKey,
-  validatePK as validatePK4
+  createGetWrapper,
+  isValidItemKey
 } from "@fjell/core";
-var logger5 = logger_default.get("get");
+var logger4 = logger_default.get("get");
 var inFlightRequests = /* @__PURE__ */ new Map();
 var CLEANUP_TIMEOUT = 5 * 60 * 1e3;
 var cleanupStaleRequests = () => {
@@ -749,34 +737,45 @@ var cleanupStaleRequests = () => {
     }
   });
   keysToDelete.forEach((key) => {
-    logger5.debug("Cleaning up stale in-flight request", { key });
+    logger4.debug("Cleaning up stale in-flight request", { key });
     inFlightRequests.delete(key);
   });
 };
 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() });
+  const wrappedGet = createGetWrapper(
+    coordinate,
+    async (k) => {
+      return await executeGetLogic(k, context);
+    }
+  );
+  const result = await wrappedGet(key);
+  return [context, result];
+};
+async function executeGetLogic(key, context) {
   const { api, cacheMap, pkType, ttlManager, statsManager } = context;
-  logger5.default("get", { key, defaultTTL: ttlManager.getDefaultTTL() });
   statsManager.incrementRequests();
   if (!isValidItemKey(key)) {
-    logger5.error("Key for Get is not a valid ItemKey: %j", key);
+    logger4.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) {
-    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger4.debug("Cache bypass enabled, fetching directly from API", { key });
     statsManager.incrementMisses();
     try {
       const ret2 = await api.get(key);
       if (ret2) {
-        logger5.debug("API response received (not cached due to bypass)", { key });
-        return [context, validatePK4(ret2, pkType)];
+        logger4.debug("API response received (not cached due to bypass)", { key });
+        return ret2;
       } else {
-        logger5.debug("API returned null", { key });
-        return [context, null];
+        logger4.debug("API returned null", { key });
+        return null;
       }
     } catch (error) {
-      logger5.error("API request failed", { key, error });
+      logger4.error("API request failed", { key, error });
       throw error;
     }
   }
@@ -786,24 +785,24 @@ var get = async (key, context) => {
     if (cachedItem) {
       const isValid = await ttlManager.validateItem(keyStr2, cacheMap);
       if (isValid) {
-        logger5.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
+        logger4.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
         statsManager.incrementHits();
-        return [context, validatePK4(cachedItem, pkType)];
+        return cachedItem;
       } else {
-        logger5.debug("Cache item expired, removing", { key });
+        logger4.debug("Cache item expired, removing", { key });
         cacheMap.delete(key);
         statsManager.incrementMisses();
       }
     } else {
       statsManager.incrementMisses();
     }
-    logger5.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
+    logger4.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
   } else {
     const cachedItem = await cacheMap.get(key);
     if (cachedItem) {
-      logger5.debug("Cache hit (TTL disabled)", { key });
+      logger4.debug("Cache hit (TTL disabled)", { key });
       statsManager.incrementHits();
-      return [context, validatePK4(cachedItem, pkType)];
+      return cachedItem;
     } else {
       statsManager.incrementMisses();
     }
@@ -826,7 +825,7 @@ var get = async (key, context) => {
         }
       }
     } else {
-      logger5.debug("Using in-flight request for key", { key });
+      logger4.debug("Using in-flight request for key", { key });
       apiRequest = requestEntry.promise;
     }
     ret = await apiRequest;
@@ -856,44 +855,40 @@ var get = async (key, context) => {
     }
   } catch (e) {
     inFlightRequests.delete(keyStr);
-    logger5.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+    logger4.error("Error getting item for key", { key, message: e.message, stack: e.stack });
     throw e;
   }
-  return [
-    context,
-    ret ? validatePK4(ret, pkType) : null
-  ];
-};
+  return ret || null;
+}
 
 // src/ops/retrieve.ts
 import {
-  isValidItemKey as isValidItemKey2,
-  validatePK as validatePK5
+  isValidItemKey as isValidItemKey2
 } from "@fjell/core";
-var logger6 = logger_default.get("retrieve");
+var logger5 = logger_default.get("retrieve");
 var retrieve = async (key, context) => {
   const { cacheMap, pkType, statsManager } = context;
-  logger6.default("retrieve", { key });
+  logger5.default("retrieve", { key });
   statsManager.incrementRequests();
   if (!isValidItemKey2(key)) {
-    logger6.error("Key for Retrieve is not a valid ItemKey: %j", key);
+    logger5.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) {
-    logger6.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
     statsManager.incrementMisses();
     try {
       const { api } = context;
       const retrieved2 = await api.get(key);
       if (retrieved2) {
-        logger6.debug("API response received (not cached due to bypass)", { key });
-        return [null, validatePK5(retrieved2, pkType)];
+        logger5.debug("API response received (not cached due to bypass)", { key });
+        return [null, retrieved2];
       } else {
-        logger6.debug("API returned null", { key });
+        logger5.debug("API returned null", { key });
         return [null, null];
       }
     } catch (error) {
-      logger6.error("API request failed", { key, error });
+      logger5.error("API request failed", { key, error });
       throw error;
     }
   }
@@ -901,32 +896,44 @@ var retrieve = async (key, context) => {
   let retrieved;
   let contextToReturn;
   if (containsItemKey) {
-    logger6.default("Looking for Object in Cache", key);
+    logger5.default("Looking for Object in Cache", key);
     retrieved = await cacheMap.get(key);
     contextToReturn = null;
     statsManager.incrementHits();
   } else {
-    logger6.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    logger5.default("Object Not Found in Cache, Retrieving from Server API", { key });
     statsManager.incrementMisses();
     [contextToReturn, retrieved] = await get(key, context);
   }
   const retValue = [
     contextToReturn,
-    retrieved ? validatePK5(retrieved, pkType) : null
+    retrieved || null
   ];
   return retValue;
 };
 
 // src/ops/remove.ts
 import {
+  createRemoveWrapper,
   isValidItemKey as isValidItemKey3
 } from "@fjell/core";
-var logger7 = logger_default.get("remove");
+var logger6 = logger_default.get("remove");
 var remove = async (key, context) => {
+  const { coordinate } = context;
+  logger6.default("remove", { key });
+  const wrappedRemove = createRemoveWrapper(
+    coordinate,
+    async (k) => {
+      await executeRemoveLogic(k, context);
+    }
+  );
+  await wrappedRemove(key);
+  return context;
+};
+async function executeRemoveLogic(key, context) {
   const { api, cacheMap } = context;
-  logger7.default("remove", { key });
   if (!isValidItemKey3(key)) {
-    logger7.error("Key for Remove is not a valid ItemKey: %j", key);
+    logger6.error("Key for Remove is not a valid ItemKey: %j", key);
     throw new Error("Key for Remove is not a valid ItemKey");
   }
   try {
@@ -940,39 +947,48 @@ var remove = async (key, context) => {
     }
     const queryInvalidatedEvent = CacheEventFactory.createQueryInvalidatedEvent(
       [],
-      // We don't track which specific queries were invalidated
       "item_changed",
       { source: "operation", context: { operation: "remove" } }
     );
     context.eventEmitter.emit(queryInvalidatedEvent);
-    logger7.debug("Successfully removed item from API and cache", { key });
+    logger6.debug("Successfully removed item from API and cache", { key });
   } catch (e) {
-    logger7.error("Error deleting item", { error: e });
+    logger6.error("Error deleting item", { error: e });
     throw e;
   }
-  return context;
-};
+}
 
 // src/ops/update.ts
 import {
-  isValidItemKey as isValidItemKey4,
-  validatePK as validatePK6
+  createUpdateWrapper,
+  isValidItemKey as isValidItemKey4
 } from "@fjell/core";
-var logger8 = logger_default.get("update");
+var logger7 = logger_default.get("update");
 var update = async (key, v, context) => {
+  const { coordinate } = context;
+  logger7.default("update", { key, v });
+  const wrappedUpdate = createUpdateWrapper(
+    coordinate,
+    async (k, item) => {
+      return await executeUpdateLogic(k, item, context);
+    }
+  );
+  const result = await wrappedUpdate(key, v);
+  return [context, result];
+};
+async function executeUpdateLogic(key, v, context) {
   const { api, cacheMap, pkType } = context;
-  logger8.default("update", { key, v });
   if (!isValidItemKey4(key)) {
-    logger8.error("Key for Update is not a valid ItemKey: %j", key);
+    logger7.error("Key for Update is not a valid ItemKey: %j", key);
     throw new Error("Key for Update is not a valid ItemKey");
   }
-  logger8.debug("Invalidating item key before update", { key });
+  logger7.debug("Invalidating item key before update", { key });
   cacheMap.invalidateItemKeys([key]);
   await cacheMap.clearQueryResults();
   try {
     const previousItem = await cacheMap.get(key);
     const updated = await api.update(key, v);
-    logger8.debug("Caching update result", { updatedKey: updated.key });
+    logger7.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);
@@ -1003,22 +1019,22 @@ var update = async (key, v, context) => {
       { source: "operation", context: { operation: "update" } }
     );
     context.eventEmitter.emit(queryInvalidatedEvent);
-    return [context, validatePK6(updated, pkType)];
+    return updated;
   } catch (e) {
-    logger8.error("Error updating item", { error: e });
+    logger7.error("Error updating item", { error: e });
     throw e;
   }
-};
+}
 
 // src/ops/action.ts
 import {
-  isValidItemKey as isValidItemKey5,
-  validatePK as validatePK7
+  createActionWrapper,
+  isValidItemKey as isValidItemKey5
 } from "@fjell/core";
 
 // src/utils/cacheInvalidation.ts
 import { toKeyTypeArray } from "@fjell/core";
-var logger9 = logger_default.get("cache", "utils", "cacheInvalidation");
+var logger8 = logger_default.get("cache", "utils", "cacheInvalidation");
 var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   const keys = [];
   const keyTypeArrays = [];
@@ -1035,7 +1051,7 @@ var extractKeysAndKeyTypesFromActionResult = (affectedItems) => {
   return { keys, keyTypeArrays };
 };
 var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) => {
-  logger9.debug("Invalidating caches by keys and key types", {
+  logger8.debug("Invalidating caches by keys and key types", {
     keysCount: keys.length,
     keyTypeArrays
   });
@@ -1053,22 +1069,22 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger9.debug("Found cache instance for targeted invalidation", {
+        logger8.debug("Found cache instance for targeted invalidation", {
           keyTypes,
           cacheType: cacheInstance.coordinate.kta,
           keysToInvalidate: cacheKeys.length
         });
         await cacheInstance.cacheMap.invalidateItemKeys(cacheKeys);
         await cacheInstance.cacheMap.clearQueryResults();
-        logger9.debug("Successfully invalidated specific items in cache", {
+        logger8.debug("Successfully invalidated specific items in cache", {
           keyTypes,
           invalidatedCount: cacheKeys.length
         });
       } else {
-        logger9.debug("No cache instance found for key types", { keyTypes });
+        logger8.debug("No cache instance found for key types", { keyTypes });
       }
     } catch (error) {
-      logger9.warning("Failed to invalidate cache for key types", {
+      logger8.warning("Failed to invalidate cache for key types", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1078,12 +1094,12 @@ var invalidateCachesByKeysAndKeyTypes = async (registry, keys, keyTypeArrays) =>
     try {
       const cacheInstance = registry.get(keyTypes);
       if (cacheInstance && isCache(cacheInstance)) {
-        logger9.debug("Handling location-based invalidation", { keyTypes });
+        logger8.debug("Handling location-based invalidation", { keyTypes });
         await cacheInstance.cacheMap.clearQueryResults();
-        logger9.debug("Successfully cleared query results for location", { keyTypes });
+        logger8.debug("Successfully cleared query results for location", { keyTypes });
       }
     } catch (error) {
-      logger9.warning("Failed to handle location-based invalidation", {
+      logger8.warning("Failed to handle location-based invalidation", {
         keyTypes,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1094,7 +1110,7 @@ function isCache(instance) {
   return instance !== null && typeof instance === "object" && "operations" in instance && "cacheMap" in instance && typeof instance.cacheMap.invalidateItemKeys === "function";
 }
 var handleActionCacheInvalidation = async (registry, affectedItems) => {
-  logger9.debug("Handling action cache invalidation", {
+  logger8.debug("Handling action cache invalidation", {
     affectedItemsCount: affectedItems.length
   });
   const { keys, keyTypeArrays } = extractKeysAndKeyTypesFromActionResult(affectedItems);
@@ -1102,33 +1118,44 @@ var handleActionCacheInvalidation = async (registry, affectedItems) => {
 };
 
 // src/ops/action.ts
-var logger10 = logger_default.get("action");
+var logger9 = logger_default.get("action");
 var action = async (key, action2, body = {}, context) => {
+  const { coordinate } = context;
+  logger9.default("action", { key, action: action2, body });
+  const wrappedAction = createActionWrapper(
+    coordinate,
+    async (k, a, b) => {
+      return await executeActionLogic(k, a, b, context);
+    }
+  );
+  const result = await wrappedAction(key, action2, body);
+  return [context, result[0], result[1]];
+};
+async function executeActionLogic(key, action2, body, context) {
   const { api, cacheMap, pkType, registry } = context;
-  logger10.default("action", { key, action: action2, body });
   if (!isValidItemKey5(key)) {
-    logger10.error("Key for Action is not a valid ItemKey: %j", key);
+    logger9.error("Key for Action is not a valid ItemKey: %j", key);
     throw new Error("Key for Action is not a valid ItemKey");
   }
-  logger10.debug("Invalidating item key before action", { key });
+  logger9.debug("Invalidating item key before action", { key });
   cacheMap.invalidateItemKeys([key]);
   const result = await api.action(key, action2, body);
   const updated = result[0];
   const affectedItems = result[1];
   if (affectedItems && affectedItems.length > 0) {
-    logger10.debug("Handling cache invalidation for affected items", {
+    logger9.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", {
+      logger9.warning("Failed to handle cache invalidation for affected items", {
         error: error instanceof Error ? error.message : String(error),
         affectedItems
       });
     }
   }
-  logger10.debug("Caching action result", { updatedKey: updated.key });
+  logger9.debug("Caching action result", { updatedKey: updated.key });
   cacheMap.set(updated.key, updated);
   const keyStr = JSON.stringify(updated.key);
   context.ttlManager.onItemAdded(keyStr, cacheMap);
@@ -1138,19 +1165,19 @@ var action = async (key, action2, body = {}, context) => {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
     } catch (error) {
-      logger10.error("Failed to parse evicted key during deletion", {
+      logger9.error("Failed to parse evicted key during deletion", {
         evictedKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   }
-  logger10.debug("Emitting itemUpdated event after action", {
+  logger9.debug("Emitting itemUpdated event after action", {
     key: updated.key,
     action: action2
   });
   const itemEvent = CacheEventFactory.itemUpdated(updated.key, updated, null, "api");
   context.eventEmitter.emit(itemEvent);
-  logger10.debug("Emitting queryInvalidatedEvent after action", {
+  logger9.debug("Emitting queryInvalidatedEvent after action", {
     eventType: "query_invalidated",
     reason: "item_changed",
     action: action2
@@ -1162,19 +1189,29 @@ var action = async (key, action2, body = {}, context) => {
     { source: "operation", context: { operation: "action" } }
   );
   context.eventEmitter.emit(queryInvalidatedEvent);
-  return [context, validatePK7(updated, pkType), affectedItems];
-};
+  return [updated, affectedItems];
+}
 
 // src/ops/allAction.ts
 import {
-  validatePK as validatePK8
+  createAllActionWrapper
 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
-var logger11 = logger_default.get("allAction");
+var logger10 = logger_default.get("allAction");
 var allAction = async (action2, body = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, eventEmitter, registry, coordinate } = context;
-  logger11.default("allAction", { action: action2, body, locations });
-  validateLocations(locations, coordinate, "allAction");
+  const { coordinate } = context;
+  logger10.default("allAction", { action: action2, body, locations });
+  const wrappedAllAction = createAllActionWrapper(
+    coordinate,
+    async (a, b, locs) => {
+      return await executeAllActionLogic(a, b, locs ?? [], context);
+    }
+  );
+  const result = await wrappedAllAction(action2, body, locations);
+  return [context, result[0], result[1]];
+};
+async function executeAllActionLogic(action2, body, locations, context) {
+  const { api, cacheMap, pkType, eventEmitter, registry } = context;
   const existingItems = [];
   if (locations && locations.length > 0) {
     try {
@@ -1183,10 +1220,10 @@ var allAction = async (action2, body = {}, locations = [], context) => {
         existingItems.push(...cachedItems);
       }
     } catch (error) {
-      logger11.debug("Could not retrieve existing items for comparison", { error });
+      logger10.debug("Could not retrieve existing items for comparison", { error });
     }
   }
-  logger11.debug("Invalidating location before allAction", { locations });
+  logger10.debug("Invalidating location before allAction", { locations });
   await cacheMap.invalidateLocation(locations);
   let ret = [];
   let affectedItems = [];
@@ -1196,7 +1233,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       ret = result[0];
       affectedItems = result[1];
     } else {
-      logger11.warning("Unexpected result format from allAction", {
+      logger10.warning("Unexpected result format from allAction", {
         resultType: typeof result,
         isArray: Array.isArray(result),
         resultLength: Array.isArray(result) ? result.length : "not array"
@@ -1205,19 +1242,19 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       affectedItems = [];
     }
     if (affectedItems && affectedItems.length > 0) {
-      logger11.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) {
-        logger11.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
         });
       }
     }
-    logger11.debug("Caching allAction results", { resultCount: ret.length });
+    logger10.debug("Caching allAction results", { resultCount: ret.length });
     const modifiedItems = [];
     const newItems = [];
     for (const v of ret) {
@@ -1239,7 +1276,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       }
     }
     for (const item of modifiedItems) {
-      logger11.debug("Emitting item_updated event for modified item", { key: item.key });
+      logger10.debug("Emitting item_updated event for modified item", { key: item.key });
       const itemEvent = CacheEventFactory.itemUpdated(
         item.key,
         item,
@@ -1250,7 +1287,7 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       eventEmitter.emit(itemEvent);
     }
     for (const item of newItems) {
-      logger11.debug("Emitting item_created event for new item", { key: item.key });
+      logger10.debug("Emitting item_created event for new item", { key: item.key });
       const itemEvent = CacheEventFactory.itemCreated(
         item.key,
         item,
@@ -1260,14 +1297,14 @@ var allAction = async (action2, body = {}, locations = [], context) => {
     }
     if (modifiedItems.length > 0) {
       const modifiedKeys = modifiedItems.map((item) => item.key);
-      logger11.debug("Invalidating individual item keys for modified items", {
+      logger10.debug("Invalidating individual item keys for modified items", {
         keyCount: modifiedKeys.length,
         keys: modifiedKeys
       });
       await cacheMap.invalidateItemKeys(modifiedKeys);
     }
     await cacheMap.clearQueryResults();
-    logger11.debug("Emitting query_invalidated event after allAction", {
+    logger10.debug("Emitting query_invalidated event after allAction", {
       eventType: "query_invalidated",
       reason: "item_changed",
       action: action2,
@@ -1293,53 +1330,78 @@ var allAction = async (action2, body = {}, locations = [], context) => {
       throw e;
     }
   }
-  return [context, validatePK8(ret, pkType), affectedItems];
-};
+  return [ret, affectedItems];
+}
 
 // src/ops/facet.ts
-var logger12 = logger_default.get("facet");
+import {
+  createFacetWrapper
+} from "@fjell/core";
+var logger11 = logger_default.get("facet");
 var facet = async (key, facet2, params = {}, context) => {
-  const { api } = context;
-  logger12.default("facet", { key, facet: facet2 });
-  const ret = await api.facet(key, facet2, params);
-  return ret;
+  const { coordinate, api } = context;
+  logger11.default("facet", { key, facet: facet2 });
+  const wrappedFacet = createFacetWrapper(
+    coordinate,
+    async (k, f, p) => {
+      return await api.facet(k, f, p ?? {});
+    }
+  );
+  return await wrappedFacet(key, facet2, params);
 };
 
 // src/ops/allFacet.ts
-var logger13 = logger_default.get("allFacet");
+import {
+  createAllFacetWrapper
+} from "@fjell/core";
+var logger12 = logger_default.get("allFacet");
 var allFacet = async (facet2, params = {}, locations = [], context) => {
   const { api, coordinate } = context;
-  logger13.default("allFacet", { facet: facet2, params, locations });
-  validateLocations(locations, coordinate, "allFacet");
-  const ret = await api.allFacet(facet2, params, locations);
-  return ret;
+  logger12.default("allFacet", { facet: facet2, params, locations });
+  const wrappedAllFacet = createAllFacetWrapper(
+    coordinate,
+    async (f, p, locs) => {
+      return await api.allFacet(f, p ?? {}, locs ?? []);
+    }
+  );
+  return await wrappedAllFacet(facet2, params, locations);
 };
 
 // src/ops/find.ts
 import {
-  validatePK as validatePK9
+  createFindWrapper
 } from "@fjell/core";
-var logger14 = logger_default.get("find");
+var logger13 = logger_default.get("find");
 var find = async (finder, params = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager, eventEmitter, coordinate } = context;
-  logger14.default("find", { finder, params, locations });
-  validateLocations(locations, coordinate, "find");
+  const { coordinate } = context;
+  logger13.default("find", { finder, params, locations });
+  const wrappedFind = createFindWrapper(
+    coordinate,
+    async (f, p, locs) => {
+      return await executeFindLogic(f, p ?? {}, locs ?? [], context);
+    }
+  );
+  const result = await wrappedFind(finder, params, locations);
+  return [context, result];
+};
+async function executeFindLogic(finder, params, locations, context) {
+  const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
   if (context.options?.bypassCache) {
-    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
+    logger13.debug("Cache bypass enabled, fetching directly from API", { finder, params, locations });
     try {
       const ret2 = await api.find(finder, params, locations);
-      logger14.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
-      return [context, validatePK9(ret2, pkType)];
+      logger13.debug("API response received (not cached due to bypass)", { finder, params, locations, itemCount: ret2.length });
+      return ret2;
     } catch (error) {
-      logger14.error("API request failed", { finder, params, locations, error });
+      logger13.error("API request failed", { finder, params, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, params, locations);
-  logger14.debug("Generated query hash for find", { queryHash, finder, params, locations });
+  logger13.debug("Generated query hash for find", { queryHash, finder, params, locations });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
+    logger13.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
     const cachedItems = [];
     let allItemsAvailable = true;
     for (const itemKey of cachedItemKeys) {
@@ -1352,9 +1414,9 @@ var find = async (finder, params = {}, locations = [], context) => {
       }
     }
     if (allItemsAvailable) {
-      return [context, validatePK9(cachedItems, pkType)];
+      return cachedItems;
     } else {
-      logger14.debug("Some cached items missing, invalidating query cache");
+      logger13.debug("Some cached items missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
@@ -1371,46 +1433,62 @@ var find = async (finder, params = {}, locations = [], context) => {
   }
   const itemKeys = ret.map((item) => item.key);
   cacheMap.setQueryResult(queryHash, itemKeys);
-  logger14.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+  logger13.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
   const event = CacheEventFactory.createQueryEvent(params, locations, ret);
   eventEmitter.emit(event);
-  return [context, validatePK9(ret, pkType)];
-};
+  return ret;
+}
 
 // src/ops/findOne.ts
 import {
-  validatePK as validatePK10
+  createFindOneWrapper
 } from "@fjell/core";
-var logger15 = logger_default.get("findOne");
+var logger14 = logger_default.get("findOne");
 var findOne = async (finder, finderParams = {}, locations = [], context) => {
-  const { api, cacheMap, pkType, ttlManager, eventEmitter, coordinate } = context;
-  logger15.default("findOne", { finder, finderParams, locations });
-  validateLocations(locations, coordinate, "findOne");
+  const { coordinate } = context;
+  logger14.default("findOne", { finder, finderParams, locations });
+  const wrappedFindOne = createFindOneWrapper(
+    coordinate,
+    async (f, p, locs) => {
+      return await executeFindOneLogic(f, p ?? {}, locs ?? [], context);
+    }
+  );
+  const result = await wrappedFindOne(finder, finderParams, locations);
+  return [context, result];
+};
+async function executeFindOneLogic(finder, finderParams, locations, context) {
+  const { api, cacheMap, pkType, ttlManager, eventEmitter } = context;
   if (context.options?.bypassCache) {
-    logger15.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
+    logger14.debug("Cache bypass enabled, fetching directly from API", { finder, finderParams, locations });
     try {
       const ret2 = await api.findOne(finder, finderParams, locations);
-      logger15.debug("API response received (not cached due to bypass)", { finder, finderParams, locations });
-      return [context, validatePK10(ret2, pkType)];
+      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 });
+      return ret2;
     } catch (error) {
-      logger15.error("API request failed", { finder, finderParams, locations, error });
+      logger14.error("API request failed", { finder, finderParams, locations, error });
       throw error;
     }
   }
   const queryHash = createFinderHash(finder, finderParams, locations);
-  logger15.debug("Generated query hash for findOne", { queryHash });
+  logger14.debug("Generated query hash for findOne", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys && cachedItemKeys.length > 0) {
-    logger15.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
     const item = await cacheMap.get(cachedItemKeys[0]);
     if (item) {
-      return [context, validatePK10(item, pkType)];
+      return item;
     } else {
-      logger15.debug("Cached item missing, invalidating query cache");
+      logger14.debug("Cached item missing, invalidating query cache");
       cacheMap.deleteQueryResult(queryHash);
     }
   }
   const ret = await api.findOne(finder, finderParams, locations);
+  if (ret === null) {
+    throw new Error(`findOne returned null for finder: ${finder}`);
+  }
   cacheMap.set(ret.key, ret);
   const keyStr = JSON.stringify(ret.key);
   ttlManager.onItemAdded(keyStr, cacheMap);
@@ -1420,19 +1498,18 @@ var findOne = async (finder, finderParams = {}, locations = [], context) => {
     await cacheMap.delete(parsedKey);
   }
   cacheMap.setQueryResult(queryHash, [ret.key]);
-  logger15.debug("Cached query result", { queryHash, itemKey: ret.key });
+  logger14.debug("Cached query result", { queryHash, itemKey: ret.key });
   const event = CacheEventFactory.createQueryEvent(finderParams, locations, [ret]);
   eventEmitter.emit(event);
-  return [context, validatePK10(ret, pkType)];
-};
+  return ret;
+}
 
 // src/ops/set.ts
 import {
   isItemKeyEqual,
-  isValidItemKey as isValidItemKey6,
-  validatePK as validatePK11
+  isValidItemKey as isValidItemKey6
 } from "@fjell/core";
-var logger16 = logger_default.get("set");
+var logger15 = logger_default.get("set");
 var normalizeKeyValue2 = (value) => {
   return String(value);
 };
@@ -1482,14 +1559,13 @@ var normalizeKey = (key) => {
 };
 var set = async (key, v, context) => {
   const { cacheMap, pkType, ttlManager, evictionManager, eventEmitter } = context;
-  logger16.default("set", { key, v });
+  logger15.default("set", { key, v });
   if (!isValidItemKey6(key)) {
-    logger16.error("Key for Set is not a valid ItemKey: %j", key);
+    logger15.error("Key for Set is not a valid ItemKey: %j", key);
     throw new Error("Key for Set is not a valid ItemKey");
   }
-  validatePK11(v, pkType);
   if (!isItemKeyEqualNormalized(key, v.key)) {
-    logger16.error("Key does not match item key: %j != %j", key, v.key);
+    logger15.error("Key does not match item key: %j != %j", key, v.key);
     throw new Error("Key does not match item key");
   }
   const previousItem = await cacheMap.get(key);
@@ -1515,7 +1591,7 @@ var set = async (key, v, context) => {
   }
   const event = CacheEventFactory.itemSet(key, v, previousItem);
   eventEmitter.emit(event);
-  return [context, validatePK11(v, pkType)];
+  return [context, v];
 };
 
 // src/memory/MemoryCacheMap.ts
@@ -1533,7 +1609,7 @@ var CacheMap = class {
 };
 
 // src/memory/MemoryCacheMap.ts
-var logger17 = logger_default.get("MemoryCacheMap");
+var logger16 = logger_default.get("MemoryCacheMap");
 var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   implementationType = "memory/memory";
   map = {};
@@ -1551,13 +1627,13 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger17.error("Failed to parse initial data key", { keyStr, error });
+          logger16.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger17.trace("get", { key });
+    logger16.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -1572,7 +1648,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger17.trace("set", { key, value });
+    logger16.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const keyStr = JSON.stringify(key);
     this.map[hashedKey] = { originalKey: key, value };
@@ -1599,7 +1675,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry && this.normalizedHashFunction(entry.originalKey) === hashedKey;
   }
   async delete(key) {
-    logger17.trace("delete", { key });
+    logger16.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
@@ -1628,10 +1704,10 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger17.debug("Returning all items, LocKeys is empty");
+      logger16.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger17.debug("allIn", { locations, count: allValues.length });
+      logger16.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey(key)) {
@@ -1643,12 +1719,12 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger17.debug("contains", { query, locations });
+    logger16.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch(item, query));
   }
   async queryIn(query, locations = []) {
-    logger17.debug("queryIn", { query, locations });
+    logger16.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch(item, query));
   }
@@ -1671,7 +1747,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger17.trace("setQueryResult", { queryHash, itemKeys });
+    logger16.trace("setQueryResult", { queryHash, itemKeys });
     const entry = {
       itemKeys: [...itemKeys]
       // Create a copy to avoid external mutations
@@ -1679,7 +1755,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     this.queryResultCache[queryHash] = entry;
   }
   async getQueryResult(queryHash) {
-    logger17.trace("getQueryResult", { queryHash });
+    logger16.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -1691,11 +1767,11 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     return !!entry;
   }
   async deleteQueryResult(queryHash) {
-    logger17.trace("deleteQueryResult", { queryHash });
+    logger16.trace("deleteQueryResult", { queryHash });
     delete this.queryResultCache[queryHash];
   }
   async invalidateItemKeys(keys) {
-    logger17.debug("invalidateItemKeys", { keys });
+    logger16.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -1726,14 +1802,14 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       this.deleteQueryResult(queryHash);
     });
-    logger17.debug("Selectively invalidated queries referencing affected keys", {
+    logger16.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
     });
   }
   async invalidateLocation(locations) {
-    logger17.debug("invalidateLocation", { locations });
+    logger16.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -1746,7 +1822,7 @@ var MemoryCacheMap = class _MemoryCacheMap extends CacheMap {
     await this.invalidateItemKeys(keysToInvalidate);
   }
   async clearQueryResults() {
-    logger17.trace("clearQueryResults");
+    logger16.trace("clearQueryResults");
     this.queryResultCache = {};
   }
   // CacheMapMetadataProvider implementation
@@ -1788,7 +1864,7 @@ import {
   isComKey as isComKey2,
   isQueryMatch as isQueryMatch2
 } from "@fjell/core";
-var logger18 = logger_default.get("EnhancedMemoryCacheMap");
+var logger17 = logger_default.get("EnhancedMemoryCacheMap");
 var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   implementationType = "memory/enhanced";
   map = {};
@@ -1807,11 +1883,11 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.normalizedHashFunction = createNormalizedHashFunction();
     if (sizeConfig?.maxSizeBytes) {
       this.maxSizeBytes = parseSizeString(sizeConfig.maxSizeBytes);
-      logger18.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
+      logger17.debug("Cache size limit set", { maxSizeBytes: this.maxSizeBytes });
     }
     if (sizeConfig?.maxItems) {
       this.maxItems = sizeConfig.maxItems;
-      logger18.debug("Cache item limit set", { maxItems: this.maxItems });
+      logger17.debug("Cache item limit set", { maxItems: this.maxItems });
     }
     if (initialData) {
       for (const [keyStr, value] of Object.entries(initialData)) {
@@ -1819,13 +1895,13 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
           const key = JSON.parse(keyStr);
           this.set(key, value);
         } catch (error) {
-          logger18.error("Failed to parse initial data key", { keyStr, error });
+          logger17.error("Failed to parse initial data key", { keyStr, error });
         }
       }
     }
   }
   async get(key) {
-    logger18.trace("get", { key });
+    logger17.trace("get", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey && entry.value !== null) {
@@ -1834,7 +1910,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return null;
   }
   async set(key, value) {
-    logger18.trace("set", { key, value });
+    logger17.trace("set", { key, value });
     const hashedKey = this.normalizedHashFunction(key);
     const estimatedSize = estimateValueSize(value);
     const existingEntry = this.map[hashedKey];
@@ -1845,7 +1921,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const oldValue = existingEntry.value;
       existingEntry.value = value;
       existingEntry.metadata.estimatedSize = estimatedSize;
-      logger18.trace("Updated existing cache entry", {
+      logger17.trace("Updated existing cache entry", {
         key: hashedKey,
         sizeDiff,
         currentSize: this.currentSizeBytes,
@@ -1866,7 +1942,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       };
       this.currentSizeBytes += estimatedSize;
       this.currentItemCount++;
-      logger18.trace("Added new cache entry", {
+      logger17.trace("Added new cache entry", {
         key: hashedKey,
         size: estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1883,14 +1959,14 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.deleteInternal(key, true, "filter");
   }
   deleteInternal(key, invalidateQueries = false, invalidationMode = "remove") {
-    logger18.trace("delete", { key });
+    logger17.trace("delete", { key });
     const hashedKey = this.normalizedHashFunction(key);
     const entry = this.map[hashedKey];
     if (entry && this.normalizedHashFunction(entry.originalKey) === hashedKey) {
       this.currentSizeBytes -= entry.metadata.estimatedSize;
       this.currentItemCount--;
       delete this.map[hashedKey];
-      logger18.trace("Deleted cache entry", {
+      logger17.trace("Deleted cache entry", {
         key: hashedKey,
         freedSize: entry.metadata.estimatedSize,
         currentSize: this.currentSizeBytes,
@@ -1912,7 +1988,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     return Object.values(this.map).filter((entry) => entry.value !== null).map((entry) => entry.value);
   }
   async clear() {
-    logger18.debug("Clearing cache", {
+    logger17.debug("Clearing cache", {
       itemsCleared: this.currentItemCount,
       bytesFreed: this.currentSizeBytes
     });
@@ -1923,10 +1999,10 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   async allIn(locations) {
     const allValues = await this.values();
     if (locations.length === 0) {
-      logger18.debug("Returning all items, LocKeys is empty");
+      logger17.debug("Returning all items, LocKeys is empty");
       return allValues;
     } else {
-      logger18.debug("allIn", { locations, count: allValues.length });
+      logger17.debug("allIn", { locations, count: allValues.length });
       return allValues.filter((item) => {
         const key = item.key;
         if (key && isComKey2(key)) {
@@ -1937,12 +2013,12 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger18.debug("contains", { query, locations });
+    logger17.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch2(item, query));
   }
   async queryIn(query, locations = []) {
-    logger18.debug("queryIn", { query, locations });
+    logger17.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch2(item, query));
   }
@@ -1988,7 +2064,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
   }
   // Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger18.trace("setQueryResult", { queryHash, itemKeys });
+    logger17.trace("setQueryResult", { queryHash, itemKeys });
     if (queryHash in this.queryResultCache) {
       this.removeQueryResultFromSizeTracking(queryHash);
     }
@@ -2000,7 +2076,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.addQueryResultToSizeTracking(queryHash, entry);
   }
   async getQueryResult(queryHash) {
-    logger18.trace("getQueryResult", { queryHash });
+    logger17.trace("getQueryResult", { queryHash });
     const entry = this.queryResultCache[queryHash];
     if (!entry) {
       return null;
@@ -2022,7 +2098,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     this.queryResultsCacheSize = 0;
   }
   async invalidateItemKeys(keys) {
-    logger18.debug("invalidateItemKeys", { keys });
+    logger17.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2072,7 +2148,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     });
   }
   async invalidateLocation(locations) {
-    logger18.debug("invalidateLocation", { locations });
+    logger17.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2092,7 +2168,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
     const itemKeysSize = estimateValueSize(entry.itemKeys);
     const totalSize = hashSize + itemKeysSize;
     this.queryResultsCacheSize += totalSize;
-    logger18.trace("Added query result to size tracking", {
+    logger17.trace("Added query result to size tracking", {
       queryHash,
       estimatedSize: totalSize,
       totalQueryCacheSize: this.queryResultsCacheSize
@@ -2108,7 +2184,7 @@ var EnhancedMemoryCacheMap = class _EnhancedMemoryCacheMap extends CacheMap {
       const itemKeysSize = estimateValueSize(entry.itemKeys);
       const totalSize = hashSize + itemKeysSize;
       this.queryResultsCacheSize = Math.max(0, this.queryResultsCacheSize - totalSize);
-      logger18.trace("Removed query result from size tracking", {
+      logger17.trace("Removed query result from size tracking", {
         queryHash,
         estimatedSize: totalSize,
         totalQueryCacheSize: this.queryResultsCacheSize
@@ -2193,7 +2269,7 @@ import {
   isComKey as isComKey3,
   isQueryMatch as isQueryMatch3
 } from "@fjell/core";
-var logger19 = logger_default.get("LocalStorageCacheMap");
+var logger18 = logger_default.get("LocalStorageCacheMap");
 var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
   implementationType = "browser/localStorage";
   keyPrefix;
@@ -2224,7 +2300,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return keys;
     } catch (error) {
-      logger19.error("Error getting keys by prefix from localStorage", { prefix, error });
+      logger18.error("Error getting keys by prefix from localStorage", { prefix, error });
       throw error;
     }
   }
@@ -2232,12 +2308,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       const allEntries = this.collectCacheEntries();
       if (allEntries.length === 0) {
-        logger19.debug("No entries to clean up");
+        logger18.debug("No entries to clean up");
         return false;
       }
       return this.removeOldestEntries(allEntries, aggressive);
     } catch (error) {
-      logger19.error("Failed to cleanup old localStorage entries", { error });
+      logger18.error("Failed to cleanup old localStorage entries", { error });
       return false;
     }
   }
@@ -2263,7 +2339,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           }
         }
       } catch (error) {
-        logger19.debug("Found corrupted entry during cleanup", { key, error });
+        logger18.debug("Found corrupted entry during cleanup", { key, error });
         allEntries.push({ key, timestamp: 0, size: 0 });
       }
     }
@@ -2282,12 +2358,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         removedCount++;
         removedSize += allEntries[i].size;
       } catch (error) {
-        logger19.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
+        logger18.error("Failed to remove entry during cleanup", { key: allEntries[i].key, error });
       }
     }
     if (removedCount > 0) {
       const cleanupType = aggressive ? "aggressive" : "normal";
-      logger19.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
+      logger18.info(`Cleaned up ${removedCount} old localStorage entries (${removedSize} bytes) using ${cleanupType} cleanup to free space`);
     }
     return removedCount > 0;
   }
@@ -2295,7 +2371,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     return this.getAllKeysStartingWith(`${this.keyPrefix}:`);
   }
   async get(key) {
-    logger19.trace("get", { key });
+    logger18.trace("get", { key });
     try {
       const storageKey = this.getStorageKey(key);
       let stored = localStorage.getItem(storageKey);
@@ -2310,18 +2386,18 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             return parsed.value;
           }
         } catch (parseError) {
-          logger19.debug("Failed to parse stored value", { key, error: parseError });
+          logger18.debug("Failed to parse stored value", { key, error: parseError });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger19.error("Error retrieving from localStorage", { key, error });
+      logger18.error("Error retrieving from localStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
-    logger19.trace("set", { key, value });
+    logger18.trace("set", { key, value });
     for (let attempt = 0; attempt < this.MAX_RETRY_ATTEMPTS; attempt++) {
       try {
         const storageKey = this.getStorageKey(key);
@@ -2332,12 +2408,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         };
         localStorage.setItem(storageKey, JSON.stringify(toStore));
         if (attempt > 0) {
-          logger19.info(`Successfully stored item after ${attempt} retries`);
+          logger18.info(`Successfully stored item after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger19.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger18.error(`Error storing to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           value,
           error,
@@ -2364,30 +2440,30 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
           const parsed = JSON.parse(stored);
           return this.normalizedHashFunction(parsed.originalKey) === this.normalizedHashFunction(key);
         } catch (parseError) {
-          logger19.debug("Failed to parse stored value in includesKey", { key, error: parseError });
+          logger18.debug("Failed to parse stored value in includesKey", { key, error: parseError });
           return false;
         }
       }
       return false;
     } catch (error) {
-      logger19.error("Error checking key in localStorage", { key, error });
+      logger18.error("Error checking key in localStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger19.trace("delete", { key });
+    logger18.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       localStorage.removeItem(storageKey);
     } catch (error) {
-      logger19.error("Error deleting from localStorage", { key, error });
+      logger18.error("Error deleting from localStorage", { key, error });
       throw error;
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger19.debug("Returning all items, LocKeys is empty");
+      logger18.debug("Returning all items, LocKeys is empty");
       const items = [];
       for (const key of await allKeys) {
         const item = await this.get(key);
@@ -2399,14 +2475,14 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger18.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey3(key)).filter((key) => {
-        const ComKey15 = key;
-        logger19.debug("Comparing Location Keys", {
+        const ComKey16 = key;
+        logger18.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey15
+          ComKey: ComKey16
         });
-        return isLocKeyArrayEqual(locKeys, ComKey15.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey16.loc);
       });
       const items = [];
       for (const key of filteredKeys) {
@@ -2419,12 +2495,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger19.debug("contains", { query, locations });
+    logger18.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch3(item, query));
   }
   async queryIn(query, locations = []) {
-    logger19.debug("queryIn", { query, locations });
+    logger18.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch3(item, query));
   }
@@ -2438,7 +2514,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         return JSON.parse(stored);
       }
     } catch (parseError) {
-      logger19.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
+      logger18.debug("Skipping corrupted localStorage entry", { storageKey, error: parseError });
     }
     return null;
   }
@@ -2453,7 +2529,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger19.error("Error getting keys from localStorage", { error });
+      logger18.error("Error getting keys from localStorage", { error });
     }
     return keys;
   }
@@ -2468,25 +2544,25 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger19.error("Error getting values from localStorage", { error });
+      logger18.error("Error getting values from localStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger19.debug("Clearing localStorage cache");
+    logger18.debug("Clearing localStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         localStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger19.error("Error clearing localStorage cache", { error });
+      logger18.error("Error clearing localStorage cache", { error });
       throw error;
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger19.trace("setQueryResult", { queryHash, itemKeys });
+    logger18.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -2494,11 +2570,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       localStorage.setItem(queryKey, JSON.stringify(entry));
     } catch (error) {
-      logger19.error("Failed to store query result in localStorage", { queryHash, error });
+      logger18.error("Failed to store query result in localStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger19.trace("getQueryResult", { queryHash });
+    logger18.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = localStorage.getItem(queryKey);
@@ -2511,7 +2587,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger19.error("Failed to retrieve query result from localStorage", { queryHash, error });
+      logger18.error("Failed to retrieve query result from localStorage", { queryHash, error });
       return null;
     }
   }
@@ -2520,21 +2596,21 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     try {
       return localStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger19.error("Failed to check query result in localStorage", { queryHash, error });
+      logger18.error("Failed to check query result in localStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger19.trace("deleteQueryResult", { queryHash });
+    logger18.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       localStorage.removeItem(queryKey);
     } catch (error) {
-      logger19.error("Failed to delete query result from localStorage", { queryHash, error });
+      logger18.error("Failed to delete query result from localStorage", { queryHash, error });
     }
   }
   async invalidateItemKeys(keys) {
-    logger19.debug("invalidateItemKeys", { keys });
+    logger18.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -2572,24 +2648,24 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger19.debug("Failed to parse query result", { queryKey, error });
+          logger18.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         localStorage.removeItem(queryKey);
       });
-      logger19.debug("Selectively invalidated queries referencing affected keys", {
+      logger18.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: queryKeys.length
       });
     } catch (error) {
-      logger19.error("Error during selective query invalidation, falling back to clearing all queries", { error });
+      logger18.error("Error during selective query invalidation, falling back to clearing all queries", { error });
       await this.clearQueryResults();
     }
   }
   async invalidateLocation(locations) {
-    logger19.debug("invalidateLocation", { locations });
+    logger18.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -2604,7 +2680,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
     }
   }
   async clearQueryResults() {
-    logger19.trace("clearQueryResults");
+    logger18.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = this.getAllKeysStartingWith(queryPrefix);
@@ -2612,11 +2688,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           localStorage.removeItem(key);
         } catch (error) {
-          logger19.error("Failed to remove query result from localStorage", { key, error });
+          logger18.error("Failed to remove query result from localStorage", { key, error });
         }
       }
     } catch (error) {
-      logger19.error("Failed to clear query results from localStorage", { error });
+      logger18.error("Failed to clear query results from localStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -2628,13 +2704,13 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         try {
           return JSON.parse(stored);
         } catch (e) {
-          logger19.debug("Invalid metadata JSON, treating as null", { key, error: e });
+          logger18.debug("Invalid metadata JSON, treating as null", { key, error: e });
           return null;
         }
       }
       return null;
     } catch (error) {
-      logger19.error("Error getting metadata from localStorage", { key, error });
+      logger18.error("Error getting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2644,12 +2720,12 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
         const metadataKey = `${this.keyPrefix}:metadata:${key}`;
         localStorage.setItem(metadataKey, JSON.stringify(metadata));
         if (attempt > 0) {
-          logger19.info(`Successfully stored metadata after ${attempt} retries`);
+          logger18.info(`Successfully stored metadata after ${attempt} retries`);
         }
         return;
       } catch (error) {
         const isLastAttempt = attempt === this.MAX_RETRY_ATTEMPTS - 1;
-        logger19.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
+        logger18.error(`Error storing metadata to localStorage (attempt ${attempt + 1}/${this.MAX_RETRY_ATTEMPTS})`, {
           key,
           error,
           isLastAttempt
@@ -2671,7 +2747,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const metadataKey = `${this.keyPrefix}:metadata:${key}`;
       localStorage.removeItem(metadataKey);
     } catch (error) {
-      logger19.error("Error deleting metadata from localStorage", { key, error });
+      logger18.error("Error deleting metadata from localStorage", { key, error });
       throw error;
     }
   }
@@ -2690,11 +2766,11 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
             metadata.set(metadataKey, parsed);
           }
         } catch (error) {
-          logger19.debug("Skipping invalid metadata entry", { key, error });
+          logger18.debug("Skipping invalid metadata entry", { key, error });
         }
       }
     } catch (error) {
-      logger19.error("Error getting metadata from localStorage", { error });
+      logger18.error("Error getting metadata from localStorage", { error });
       throw error;
     }
     return metadata;
@@ -2705,7 +2781,7 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
       const keysToDelete = this.getAllKeysStartingWith(metadataPrefix);
       keysToDelete.forEach((key) => localStorage.removeItem(key));
     } catch (error) {
-      logger19.error("Error clearing metadata from localStorage", { error });
+      logger18.error("Error clearing metadata from localStorage", { error });
       throw error;
     }
   }
@@ -2732,16 +2808,16 @@ var LocalStorageCacheMap = class _LocalStorageCacheMap extends CacheMap {
                 itemCount++;
               }
             } catch (error) {
-              logger19.debug("Invalid entry in getCurrentSize", { key, error });
+              logger18.debug("Invalid entry in getCurrentSize", { key, error });
             }
           }
         } catch (error) {
-          logger19.debug("Size calculation failed, using string length", { key, error });
+          logger18.debug("Size calculation failed, using string length", { key, error });
           sizeBytes += value.length;
         }
       }
     } catch (error) {
-      logger19.error("Error calculating size from localStorage", { error });
+      logger18.error("Error calculating size from localStorage", { error });
       throw error;
     }
     return { itemCount, sizeBytes };
@@ -2762,7 +2838,7 @@ import {
   isQueryMatch as isQueryMatch4
 } from "@fjell/core";
 import safeStringify2 from "fast-safe-stringify";
-var logger20 = logger_default.get("SessionStorageCacheMap");
+var logger19 = logger_default.get("SessionStorageCacheMap");
 var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   implementationType = "browser/sessionStorage";
   keyPrefix;
@@ -2790,7 +2866,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
         }
       }
     } catch (error) {
-      logger20.error("Error getting keys from sessionStorage", { error });
+      logger19.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2813,7 +2889,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async get(key) {
-    logger20.trace("get", { key });
+    logger19.trace("get", { key });
     try {
       const currentHash = this.normalizedHashFunction(key);
       if (this.hasCollisionForHash(currentHash)) {
@@ -2833,14 +2909,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return null;
     } catch (error) {
-      logger20.error("Error retrieving from sessionStorage", { key, error });
+      logger19.error("Error retrieving from sessionStorage", { key, error });
       return null;
     }
   }
   async set(key, value) {
     try {
       const storageKey = this.getStorageKey(key);
-      logger20.trace("set", { storageKey });
+      logger19.trace("set", { storageKey });
       const toStore = {
         originalKey: key,
         value,
@@ -2850,7 +2926,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(toStore);
       sessionStorage.setItem(storageKey, jsonString);
     } catch (error) {
-      logger20.error("Error storing to sessionStorage", { errorMessage: error?.message });
+      logger19.error("Error storing to sessionStorage", { errorMessage: error?.message });
       throw new Error(`Failed to store item in sessionStorage: ${error}`);
     }
   }
@@ -2871,23 +2947,23 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return false;
     } catch (error) {
-      logger20.error("Error checking key in sessionStorage", { key, error });
+      logger19.error("Error checking key in sessionStorage", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger20.trace("delete", { key });
+    logger19.trace("delete", { key });
     try {
       const storageKey = this.getStorageKey(key);
       sessionStorage.removeItem(storageKey);
     } catch (error) {
-      logger20.error("Error deleting from sessionStorage", { key, error });
+      logger19.error("Error deleting from sessionStorage", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = this.keys();
     if (locations.length === 0) {
-      logger20.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);
@@ -2899,14 +2975,14 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     } else {
       const locKeys = locations;
       const resolvedKeys = await allKeys;
-      logger20.debug("allIn", { locKeys, keys: resolvedKeys.length });
+      logger19.debug("allIn", { locKeys, keys: resolvedKeys.length });
       const filteredKeys = resolvedKeys.filter((key) => key && isComKey4(key)).filter((key) => {
-        const ComKey15 = key;
-        logger20.debug("Comparing Location Keys", {
+        const ComKey16 = key;
+        logger19.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey15
+          ComKey: ComKey16
         });
-        return isLocKeyArrayEqual(locKeys, ComKey15.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey16.loc);
       });
       const items = [];
       for (const key of filteredKeys) {
@@ -2919,12 +2995,12 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     }
   }
   async contains(query, locations) {
-    logger20.debug("contains", { query, locations });
+    logger19.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch4(item, query));
   }
   async queryIn(query, locations = []) {
-    logger20.debug("queryIn", { query, locations });
+    logger19.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch4(item, query));
   }
@@ -2944,11 +3020,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             keys.push(parsed.originalKey);
           }
         } catch (itemError) {
-          logger20.trace("Skipping invalid storage item", { storageKey, error: itemError });
+          logger19.trace("Skipping invalid storage item", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger20.error("Error getting keys from sessionStorage", { error });
+      logger19.error("Error getting keys from sessionStorage", { error });
     }
     return keys;
   }
@@ -2965,28 +3041,28 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             values.push(parsed.value);
           }
         } catch (itemError) {
-          logger20.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
+          logger19.trace("Skipping invalid storage item for values", { storageKey, error: itemError });
         }
       }
     } catch (error) {
-      logger20.error("Error getting values from sessionStorage", { error });
+      logger19.error("Error getting values from sessionStorage", { error });
     }
     return values;
   }
   async clear() {
-    logger20.debug("Clearing sessionStorage cache");
+    logger19.debug("Clearing sessionStorage cache");
     try {
       const storageKeys = this.getAllStorageKeys();
       for (const storageKey of storageKeys) {
         sessionStorage.removeItem(storageKey);
       }
     } catch (error) {
-      logger20.error("Error clearing sessionStorage cache", { error });
+      logger19.error("Error clearing sessionStorage cache", { error });
     }
   }
   // Query result caching methods implementation
   async setQueryResult(queryHash, itemKeys) {
-    logger20.trace("setQueryResult", { queryHash, itemKeys });
+    logger19.trace("setQueryResult", { queryHash, itemKeys });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     const entry = {
       itemKeys
@@ -2995,11 +3071,11 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       const jsonString = safeStringify2(entry);
       sessionStorage.setItem(queryKey, jsonString);
     } catch (error) {
-      logger20.error("Failed to store query result in sessionStorage", { queryHash, error });
+      logger19.error("Failed to store query result in sessionStorage", { queryHash, error });
     }
   }
   async getQueryResult(queryHash) {
-    logger20.trace("getQueryResult", { queryHash });
+    logger19.trace("getQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       const data = sessionStorage.getItem(queryKey);
@@ -3012,7 +3088,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return entry.itemKeys || null;
     } catch (error) {
-      logger20.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
+      logger19.error("Failed to retrieve query result from sessionStorage", { queryHash, error });
       return null;
     }
   }
@@ -3021,21 +3097,21 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
     try {
       return sessionStorage.getItem(queryKey) !== null;
     } catch (error) {
-      logger20.error("Failed to check query result in sessionStorage", { queryHash, error });
+      logger19.error("Failed to check query result in sessionStorage", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger20.trace("deleteQueryResult", { queryHash });
+    logger19.trace("deleteQueryResult", { queryHash });
     const queryKey = `${this.keyPrefix}:query:${queryHash}`;
     try {
       sessionStorage.removeItem(queryKey);
     } catch (error) {
-      logger20.error("Failed to delete query result from sessionStorage", { queryHash, error });
+      logger19.error("Failed to delete query result from sessionStorage", { queryHash, error });
     }
   }
   async clearQueryResults() {
-    logger20.trace("clearQueryResults");
+    logger19.trace("clearQueryResults");
     const queryPrefix = `${this.keyPrefix}:query:`;
     try {
       const keysToRemove = [];
@@ -3047,7 +3123,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       keysToRemove.forEach((key) => sessionStorage.removeItem(key));
     } catch (error) {
-      logger20.error("Failed to clear query results from sessionStorage", { error });
+      logger19.error("Failed to clear query results from sessionStorage", { error });
     }
   }
   // CacheMapMetadataProvider implementation
@@ -3094,7 +3170,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
       }
       return metadata;
     } catch (error) {
-      logger20.error("Error getting all metadata from sessionStorage", { error });
+      logger19.error("Error getting all metadata from sessionStorage", { error });
       return metadata;
     }
   }
@@ -3114,7 +3190,7 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger20.debug("invalidateItemKeys", { keys });
+    logger19.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3158,24 +3234,24 @@ var SessionStorageCacheMap = class _SessionStorageCacheMap extends CacheMap {
             }
           }
         } catch (error) {
-          logger20.debug("Failed to parse query result", { queryKey, error });
+          logger19.debug("Failed to parse query result", { queryKey, error });
         }
       }
       queriesToRemove.forEach((queryKey) => {
         sessionStorage.removeItem(queryKey);
       });
-      logger20.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) {
-      logger20.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) {
-    logger20.debug("invalidateLocation", { locations });
+    logger19.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       const allKeys = await this.keys();
@@ -3241,7 +3317,7 @@ import {
   isQueryMatch as isQueryMatch5
 } from "@fjell/core";
 import safeStringify3 from "fast-safe-stringify";
-var logger21 = logger_default.get("AsyncIndexDBCacheMap");
+var logger20 = logger_default.get("AsyncIndexDBCacheMap");
 var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
   types;
   dbName;
@@ -3267,19 +3343,19 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         }
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger21.error("Error opening IndexedDB", { error: request.error });
+          logger20.error("Error opening IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
-          logger21.debug("IndexedDB opened successfully");
+          logger20.debug("IndexedDB opened successfully");
           resolve(request.result);
         };
         request.onupgradeneeded = (event) => {
-          logger21.debug("IndexedDB upgrade needed");
+          logger20.debug("IndexedDB upgrade needed");
           const db = event.target.result;
           if (!db.objectStoreNames.contains(this.storeName)) {
             db.createObjectStore(this.storeName);
-            logger21.debug("Created object store", { storeName: this.storeName });
+            logger20.debug("Created object store", { storeName: this.storeName });
           }
         };
       });
@@ -3290,7 +3366,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     return this.normalizedHashFunction(key);
   }
   async get(key) {
-    logger21.trace("get", { key });
+    logger20.trace("get", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3299,7 +3375,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger21.error("Error getting from IndexedDB", { key, error: request.error });
+          logger20.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3312,7 +3388,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB get operation", { key, error });
+      logger20.error("Error in IndexedDB get operation", { key, error });
       return null;
     }
   }
@@ -3320,7 +3396,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Get both the value and metadata for an item
    */
   async getWithMetadata(key) {
-    logger21.trace("getWithMetadata", { key });
+    logger20.trace("getWithMetadata", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readonly");
@@ -3329,7 +3405,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger21.error("Error getting from IndexedDB", { key, error: request.error });
+          logger20.error("Error getting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3345,12 +3421,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB getWithMetadata operation", { key, error });
+      logger20.error("Error in IndexedDB getWithMetadata operation", { key, error });
       return null;
     }
   }
   async set(key, value, metadata) {
-    logger21.trace("set", { key, value, hasMetadata: !!metadata });
+    logger20.trace("set", { key, value, hasMetadata: !!metadata });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3365,7 +3441,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.put(storedItem, storageKey);
         request.onerror = () => {
-          logger21.error("Error setting in IndexedDB", { key, value, error: request.error });
+          logger20.error("Error setting in IndexedDB", { key, value, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3373,7 +3449,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB set operation", { key, value, error });
+      logger20.error("Error in IndexedDB set operation", { key, value, error });
       throw new Error(`Failed to store item in IndexedDB: ${error}`);
     }
   }
@@ -3381,16 +3457,16 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
    * Update only the metadata for an existing item
    */
   async setMetadata(key, metadata) {
-    logger21.trace("setMetadata", { key, metadata });
+    logger20.trace("setMetadata", { key, metadata });
     try {
       const existing = await this.getWithMetadata(key);
       if (existing) {
         await this.set(key, existing.value, metadata);
       } else {
-        logger21.warning("Attempted to set metadata for non-existent item", { key });
+        logger20.warning("Attempted to set metadata for non-existent item", { key });
       }
     } catch (error) {
-      logger21.error("Error in IndexedDB setMetadata operation", { key, error });
+      logger20.error("Error in IndexedDB setMetadata operation", { key, error });
       throw new Error(`Failed to update metadata in IndexedDB: ${error}`);
     }
   }
@@ -3403,7 +3479,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.get(storageKey);
         request.onerror = () => {
-          logger21.error("Error checking key in IndexedDB", { key, error: request.error });
+          logger20.error("Error checking key in IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3417,12 +3493,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB includesKey operation", { key, error });
+      logger20.error("Error in IndexedDB includesKey operation", { key, error });
       return false;
     }
   }
   async delete(key) {
-    logger21.trace("delete", { key });
+    logger20.trace("delete", { key });
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3431,7 +3507,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.delete(storageKey);
         request.onerror = () => {
-          logger21.error("Error deleting from IndexedDB", { key, error: request.error });
+          logger20.error("Error deleting from IndexedDB", { key, error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3439,26 +3515,26 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB delete operation", { key, error });
+      logger20.error("Error in IndexedDB delete operation", { key, error });
     }
   }
   async allIn(locations) {
     const allKeys = await this.keys();
     if (locations.length === 0) {
-      logger21.debug("Returning all items, LocKeys is empty");
+      logger20.debug("Returning all items, LocKeys is empty");
       const promises = allKeys.map((key) => this.get(key));
       const results = await Promise.all(promises);
       return results.filter((item) => item !== null);
     } else {
       const locKeys = locations;
-      logger21.debug("allIn", { locKeys, keys: allKeys.length });
+      logger20.debug("allIn", { locKeys, keys: allKeys.length });
       const filteredKeys = allKeys.filter((key) => key && isComKey5(key)).filter((key) => {
-        const ComKey15 = key;
-        logger21.debug("Comparing Location Keys", {
+        const ComKey16 = key;
+        logger20.debug("Comparing Location Keys", {
           locKeys,
-          ComKey: ComKey15
+          ComKey: ComKey16
         });
-        return isLocKeyArrayEqual(locKeys, ComKey15.loc);
+        return isLocKeyArrayEqual(locKeys, ComKey16.loc);
       });
       const promises = filteredKeys.map((key) => this.get(key));
       const results = await Promise.all(promises);
@@ -3466,12 +3542,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async contains(query, locations) {
-    logger21.debug("contains", { query, locations });
+    logger20.debug("contains", { query, locations });
     const items = await this.allIn(locations);
     return items.some((item) => isQueryMatch5(item, query));
   }
   async queryIn(query, locations = []) {
-    logger21.debug("queryIn", { query, locations });
+    logger20.debug("queryIn", { query, locations });
     const items = await this.allIn(locations);
     return items.filter((item) => isQueryMatch5(item, query));
   }
@@ -3487,7 +3563,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger21.error("Error getting keys from IndexedDB", { error: request.error });
+          logger20.error("Error getting keys from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3502,7 +3578,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB keys operation", { error });
+      logger20.error("Error in IndexedDB keys operation", { error });
       return [];
     }
   }
@@ -3518,7 +3594,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger21.error("Error getting metadata from IndexedDB", { error: request.error });
+          logger20.error("Error getting metadata from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3536,7 +3612,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB getAllMetadata operation", { error });
+      logger20.error("Error in IndexedDB getAllMetadata operation", { error });
       return metadataMap;
     }
   }
@@ -3549,7 +3625,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.openCursor();
         request.onerror = () => {
-          logger21.error("Error getting values from IndexedDB", { error: request.error });
+          logger20.error("Error getting values from IndexedDB", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = (event) => {
@@ -3564,12 +3640,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB values operation", { error });
+      logger20.error("Error in IndexedDB values operation", { error });
       return [];
     }
   }
   async clear() {
-    logger21.debug("Clearing IndexedDB cache");
+    logger20.debug("Clearing IndexedDB cache");
     try {
       const db = await this.getDB();
       const transaction = db.transaction([this.storeName], "readwrite");
@@ -3577,7 +3653,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
       return new Promise((resolve, reject) => {
         const request = store.clear();
         request.onerror = () => {
-          logger21.error("Error clearing IndexedDB cache", { error: request.error });
+          logger20.error("Error clearing IndexedDB cache", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3585,17 +3661,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in IndexedDB clear operation", { error });
+      logger20.error("Error in IndexedDB clear operation", { error });
     }
   }
   // Async Query result caching methods
   async setQueryResult(queryHash, itemKeys) {
-    logger21.trace("setQueryResult", { queryHash, itemKeys });
+    logger20.trace("setQueryResult", { queryHash, itemKeys });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger21.error("Failed to open database for setQueryResult", { error: request.error });
+          logger20.error("Failed to open database for setQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3608,7 +3684,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const putRequest = store.put(safeStringify3(entry), queryKey);
           putRequest.onerror = () => {
-            logger21.error("Failed to store query result", { queryHash, error: putRequest.error });
+            logger20.error("Failed to store query result", { queryHash, error: putRequest.error });
             reject(putRequest.error);
           };
           putRequest.onsuccess = () => {
@@ -3617,17 +3693,17 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in setQueryResult", { queryHash, error });
+      logger20.error("Error in setQueryResult", { queryHash, error });
       throw error;
     }
   }
   async getQueryResult(queryHash) {
-    logger21.trace("getQueryResult", { queryHash });
+    logger20.trace("getQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger21.error("Failed to open database for getQueryResult", { error: request.error });
+          logger20.error("Failed to open database for getQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3637,7 +3713,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const getRequest = store.get(queryKey);
           getRequest.onerror = () => {
-            logger21.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
+            logger20.error("Failed to retrieve query result", { queryHash, error: getRequest.error });
             reject(getRequest.error);
           };
           getRequest.onsuccess = () => {
@@ -3654,34 +3730,34 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               }
               resolve(entry.itemKeys || null);
             } catch (parseError) {
-              logger21.error("Failed to parse query result", { queryHash, error: parseError });
+              logger20.error("Failed to parse query result", { queryHash, error: parseError });
               resolve(null);
             }
           };
         };
       });
     } catch (error) {
-      logger21.error("Error in getQueryResult", { queryHash, error });
+      logger20.error("Error in getQueryResult", { queryHash, error });
       return null;
     }
   }
   async hasQueryResult(queryHash) {
-    logger21.trace("hasQueryResult", { queryHash });
+    logger20.trace("hasQueryResult", { queryHash });
     try {
       const result = await this.getQueryResult(queryHash);
       return result !== null;
     } catch (error) {
-      logger21.error("Error in hasQueryResult", { queryHash, error });
+      logger20.error("Error in hasQueryResult", { queryHash, error });
       return false;
     }
   }
   async deleteQueryResult(queryHash) {
-    logger21.trace("deleteQueryResult", { queryHash });
+    logger20.trace("deleteQueryResult", { queryHash });
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger21.error("Failed to open database for deleteQueryResult", { error: request.error });
+          logger20.error("Failed to open database for deleteQueryResult", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3691,7 +3767,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const queryKey = `query:${queryHash}`;
           const deleteRequest = store.delete(queryKey);
           deleteRequest.onerror = () => {
-            logger21.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
+            logger20.error("Failed to delete query result", { queryHash, error: deleteRequest.error });
             reject(deleteRequest.error);
           };
           deleteRequest.onsuccess = () => {
@@ -3700,12 +3776,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in deleteQueryResult", { queryHash, error });
+      logger20.error("Error in deleteQueryResult", { queryHash, error });
       throw error;
     }
   }
   async invalidateItemKeys(keys) {
-    logger21.debug("invalidateItemKeys", { keys });
+    logger20.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -3742,7 +3818,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
                   queryResults2[queryHash] = itemKeys;
                 }
               } catch (error) {
-                logger21.debug("Failed to parse query result", { key: item.key, error });
+                logger20.debug("Failed to parse query result", { key: item.key, error });
               }
             }
           }
@@ -3770,18 +3846,18 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           });
         }
       }
-      logger21.debug("Selectively invalidated queries referencing affected keys", {
+      logger20.debug("Selectively invalidated queries referencing affected keys", {
         affectedKeys: keys.length,
         queriesRemoved: queriesToRemove.length,
         totalQueries: Object.keys(queryResults).length
       });
     } catch (error) {
-      logger21.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) {
-    logger21.debug("invalidateLocation", { locations });
+    logger20.debug("invalidateLocation", { locations });
     let keysToInvalidate = [];
     if (locations.length === 0) {
       await this.clearQueryResults();
@@ -3794,12 +3870,12 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
     }
   }
   async clearQueryResults() {
-    logger21.trace("clearQueryResults");
+    logger20.trace("clearQueryResults");
     try {
       return new Promise((resolve, reject) => {
         const request = indexedDB.open(this.dbName, this.version);
         request.onerror = () => {
-          logger21.error("Failed to open database for clearQueryResults", { error: request.error });
+          logger20.error("Failed to open database for clearQueryResults", { error: request.error });
           reject(request.error);
         };
         request.onsuccess = () => {
@@ -3809,7 +3885,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
           const cursorRequest = store.openCursor();
           const keysToDelete = [];
           cursorRequest.onerror = () => {
-            logger21.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
+            logger20.error("Failed to open cursor for clearQueryResults", { error: cursorRequest.error });
             reject(cursorRequest.error);
           };
           cursorRequest.onsuccess = () => {
@@ -3830,7 +3906,7 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
               keysToDelete.forEach((queryKey) => {
                 const deleteRequest = store.delete(queryKey);
                 deleteRequest.onerror = () => {
-                  logger21.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
+                  logger20.error("Failed to delete query key", { queryKey, error: deleteRequest.error });
                   deletedCount++;
                   if (deletedCount === totalToDelete) {
                     resolve();
@@ -3848,14 +3924,14 @@ var AsyncIndexDBCacheMap = class _AsyncIndexDBCacheMap {
         };
       });
     } catch (error) {
-      logger21.error("Error in clearQueryResults", { error });
+      logger20.error("Error in clearQueryResults", { error });
       throw error;
     }
   }
 };
 
 // src/browser/IndexDBCacheMap.ts
-var logger22 = logger_default.get("IndexDBCacheMap");
+var logger21 = logger_default.get("IndexDBCacheMap");
 var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   implementationType = "browser/indexedDB";
   // Memory storage
@@ -4039,7 +4115,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
   }
   // Invalidation methods
   async invalidateItemKeys(keys) {
-    logger22.debug("invalidateItemKeys", { keys });
+    logger21.debug("invalidateItemKeys", { keys });
     if (keys.length === 0) {
       return;
     }
@@ -4069,7 +4145,7 @@ var IndexDBCacheMap = class _IndexDBCacheMap extends CacheMap {
     queriesToRemove.forEach((queryHash) => {
       delete this.queryResultCache[queryHash];
     });
-    logger22.debug("Selectively invalidated queries referencing affected keys", {
+    logger21.debug("Selectively invalidated queries referencing affected keys", {
       affectedKeys: keys.length,
       queriesRemoved: queriesToRemove.length,
       totalQueries: Object.keys(this.queryResultCache).length
@@ -4456,11 +4532,22 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
   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, locations) => create(item, locations, context).then(([ctx, result]) => result),
+    create: (item, options2) => {
+      const locations = options2?.locations || [];
+      return create(item, locations, context).then(([ctx, result]) => result);
+    },
     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);
+      }
+    },
     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),
@@ -4473,7 +4560,7 @@ var createOperations = (api, coordinate, cacheMap, pkType, options, eventEmitter
 };
 
 // src/eviction/EvictionManager.ts
-var logger23 = logger_default.get("EvictionManager");
+var logger22 = logger_default.get("EvictionManager");
 var EvictionManager = class {
   evictionStrategy;
   constructor(evictionStrategy) {
@@ -4485,7 +4572,7 @@ var EvictionManager = class {
    */
   setEvictionStrategy(strategy) {
     this.evictionStrategy = strategy;
-    logger23.debug("Eviction strategy updated", {
+    logger22.debug("Eviction strategy updated", {
       strategy: strategy?.getStrategyName() || "none"
     });
   }
@@ -4508,7 +4595,7 @@ var EvictionManager = class {
     try {
       await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger23.error("Error in eviction strategy onItemAccessed", { key, error });
+      logger22.error("Error in eviction strategy onItemAccessed", { key, error });
     }
   }
   /**
@@ -4533,14 +4620,14 @@ var EvictionManager = class {
       }
       await this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
       if (evictedKeys.length > 0) {
-        logger23.debug("Items evicted during addition", {
+        logger22.debug("Items evicted during addition", {
           newKey: key,
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger23.error("Error in eviction strategy onItemAdded", { key, error });
+      logger22.error("Error in eviction strategy onItemAdded", { key, error });
     }
     return evictedKeys;
   }
@@ -4556,7 +4643,7 @@ var EvictionManager = class {
     try {
       this.evictionStrategy.onItemRemoved(key, metadataProvider);
     } catch (error) {
-      logger23.error("Error in eviction strategy onItemRemoved", { key, error });
+      logger22.error("Error in eviction strategy onItemRemoved", { key, error });
     }
   }
   /**
@@ -4577,13 +4664,13 @@ var EvictionManager = class {
         evictedKeys.push(evictKey);
       }
       if (evictedKeys.length > 0) {
-        logger23.debug("Manual eviction performed", {
+        logger22.debug("Manual eviction performed", {
           evictedKeys,
           strategy: this.evictionStrategy.getStrategyName()
         });
       }
     } catch (error) {
-      logger23.error("Error in manual eviction", { error });
+      logger22.error("Error in manual eviction", { error });
     }
     return evictedKeys;
   }
@@ -4603,7 +4690,7 @@ var EvictionManager = class {
         this.evictionStrategy.reset();
       }
     }
-    logger23.debug("Eviction manager cleared");
+    logger22.debug("Eviction manager cleared");
   }
   /**
    * Create eviction context from current cache state
@@ -5941,7 +6028,7 @@ function createEvictionStrategy(policy, maxCacheSize, config) {
 }
 
 // src/ttl/TTLManager.ts
-var logger24 = logger_default.get("TTLManager");
+var logger23 = logger_default.get("TTLManager");
 var TTLManager = class {
   config;
   cleanupTimer;
@@ -5953,7 +6040,7 @@ var TTLManager = class {
       validateOnAccess: true,
       ...config
     };
-    logger24.debug("TTL_DEBUG: TTLManager created", {
+    logger23.debug("TTL_DEBUG: TTLManager created", {
       config: this.config,
       isTTLEnabled: this.isTTLEnabled(),
       defaultTTL: this.config.defaultTTL
@@ -5986,13 +6073,13 @@ var TTLManager = class {
         this.startAutoCleanup();
       }
     }
-    logger24.debug("TTL configuration updated", { config: this.config });
+    logger23.debug("TTL configuration updated", { config: this.config });
   }
   /**
    * Set TTL metadata for an item when it's added
    */
   async onItemAdded(key, metadataProvider, itemTTL) {
-    logger24.debug("TTL_DEBUG: onItemAdded called", {
+    logger23.debug("TTL_DEBUG: onItemAdded called", {
       key,
       itemTTL,
       isTTLEnabled: this.isTTLEnabled(),
@@ -6000,19 +6087,19 @@ var TTLManager = class {
       metadataProviderType: metadataProvider?.constructor?.name
     });
     if (!this.isTTLEnabled() && !itemTTL) {
-      logger24.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
+      logger23.debug("TTL_DEBUG: No TTL configured for item - returning early", { key });
       return;
     }
-    logger24.debug("TTL_DEBUG: Getting metadata for key", { key });
+    logger23.debug("TTL_DEBUG: Getting metadata for key", { key });
     const metadata = await metadataProvider.getMetadata(key);
-    logger24.debug("TTL_DEBUG: Retrieved metadata", {
+    logger23.debug("TTL_DEBUG: Retrieved metadata", {
       key,
       hasMetadata: !!metadata,
       metadataKeys: metadata ? Object.keys(metadata) : null,
       metadata
     });
     if (!metadata) {
-      logger24.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
+      logger23.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
         key,
         metadataProviderType: metadataProvider?.constructor?.name,
         metadataProviderMethods: metadataProvider ? Object.getOwnPropertyNames(Object.getPrototypeOf(metadataProvider)) : null
@@ -6020,7 +6107,7 @@ var TTLManager = class {
       return;
     }
     const ttl = itemTTL || this.config.defaultTTL;
-    logger24.debug("TTL_DEBUG: Calculated TTL value", {
+    logger23.debug("TTL_DEBUG: Calculated TTL value", {
       key,
       itemTTL,
       defaultTTL: this.config.defaultTTL,
@@ -6033,7 +6120,7 @@ var TTLManager = class {
         expiresAt: metadata.addedAt + ttl,
         ttl
       };
-      logger24.debug("TTL_DEBUG: Setting TTL metadata", {
+      logger23.debug("TTL_DEBUG: Setting TTL metadata", {
         key,
         ttl,
         addedAt: metadata.addedAt,
@@ -6041,9 +6128,9 @@ var TTLManager = class {
         ttlMetadata
       });
       await metadataProvider.setMetadata(key, ttlMetadata);
-      logger24.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+      logger23.trace("TTL_DEBUG: TTL set for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     } else {
-      logger24.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
+      logger23.debug("TTL_DEBUG: No TTL set - invalid TTL value", { key, ttl });
     }
   }
   /**
@@ -6057,7 +6144,7 @@ var TTLManager = class {
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
     if (expired) {
-      logger24.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
+      logger23.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
     }
     return expired;
   }
@@ -6104,7 +6191,7 @@ var TTLManager = class {
       }
     }
     if (expiredKeys.length > 0) {
-      logger24.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
+      logger23.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
     }
     return expiredKeys;
   }
@@ -6132,7 +6219,7 @@ var TTLManager = class {
     }
     metadata.expiresAt += additionalTTL;
     await metadataProvider.setMetadata(key, metadata);
-    logger24.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
+    logger23.trace("TTL extended for item", { key, additionalTTL, newExpiresAt: metadata.expiresAt });
     return true;
   }
   /**
@@ -6154,7 +6241,7 @@ var TTLManager = class {
       ttl
     };
     await metadataProvider.setMetadata(key, ttlMetadata);
-    logger24.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
+    logger23.trace("TTL refreshed for item", { key, ttl, expiresAt: ttlMetadata.expiresAt });
     return true;
   }
   /**
@@ -6166,9 +6253,9 @@ var TTLManager = class {
     }
     if (this.config.cleanupInterval) {
       this.cleanupTimer = setInterval(() => {
-        logger24.trace("Auto cleanup timer triggered");
+        logger23.trace("Auto cleanup timer triggered");
       }, this.config.cleanupInterval);
-      logger24.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
+      logger23.debug("Auto cleanup started", { interval: this.config.cleanupInterval });
     }
   }
   /**
@@ -6178,7 +6265,7 @@ var TTLManager = class {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
-      logger24.debug("Auto cleanup stopped");
+      logger23.debug("Auto cleanup stopped");
     }
   }
   /**
@@ -6186,14 +6273,14 @@ var TTLManager = class {
    */
   clear() {
     this.stopAutoCleanup();
-    logger24.debug("TTL manager cleared");
+    logger23.debug("TTL manager cleared");
   }
   /**
    * Cleanup resources
    */
   destroy() {
     this.stopAutoCleanup();
-    logger24.debug("TTL manager destroyed");
+    logger23.debug("TTL manager destroyed");
   }
 };
 
@@ -6593,9 +6680,9 @@ var CacheStatsManager = class {
 };
 
 // src/Cache.ts
-var logger25 = logger_default.get("Cache");
+var logger24 = logger_default.get("Cache");
 var createCache = (api, coordinate, registry, options) => {
-  logger25.debug("createCache", { coordinate, registry, options });
+  logger24.debug("createCache", { coordinate, registry, options });
   const completeOptions = createOptions(options);
   const cacheMap = createCacheMap(coordinate.kta, completeOptions);
   const pkType = coordinate.kta[0];
@@ -6675,13 +6762,13 @@ var isCache2 = (cache) => {
 };
 
 // src/InstanceFactory.ts
-var logger26 = logger_default.get("InstanceFactory");
+var logger25 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (api, options) => {
   const templateOptions = createOptions(options);
   validateOptions(templateOptions);
   return (coordinate, context) => {
     const instanceOptions = createOptions(options);
-    logger26.debug("Creating cache instance", {
+    logger25.debug("Creating cache instance", {
       coordinate,
       registry: context.registry,
       api,
@@ -6748,9 +6835,9 @@ var createInstanceFactory = (api, options) => {
 };
 
 // src/Instance.ts
-var logger27 = logger_default.get("Instance");
+var logger26 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, api, options) => {
-  logger27.debug("createInstance", { coordinate, api, registry, options });
+  logger26.debug("createInstance", { coordinate, api, registry, options });
   return createCache(api, coordinate, registry, options);
 };
 var isInstance = (instance) => {
@@ -6758,7 +6845,7 @@ var isInstance = (instance) => {
 };
 
 // src/Aggregator.ts
-var logger28 = logger_default.get("ItemAggregator");
+var logger27 = logger_default.get("ItemAggregator");
 var toCacheConfig = (config) => {
   let cacheConfig;
   if (config.optional === void 0) {
@@ -6770,22 +6857,22 @@ var toCacheConfig = (config) => {
 };
 var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
   const populate = async (item) => {
-    logger28.default("populate", { item });
+    logger27.default("populate", { item });
     for (const key in aggregates) {
       await populateAggregate(key, item);
     }
     for (const key in events) {
       await populateEvent(key, item);
     }
-    logger28.default("populate done", { item });
+    logger27.default("populate done", { item });
     return item;
   };
   const populateAggregate = async (key, item) => {
-    logger28.default("populate aggregate key", { key });
+    logger27.default("populate aggregate key", { key });
     const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === void 0) {
       if (cacheConfig.optional === false) {
-        logger28.error("Item does not have refs an is not optional ", { item });
+        logger27.error("Item does not have refs an is not optional ", { item });
         throw new Error("Item does not have refs an is not optional " + JSON.stringify(item));
       } else {
         if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
@@ -6794,7 +6881,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else if (item.refs[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger28.error("Item does not have mandatory ref with key, not optional ", { key, item });
+        logger27.error("Item does not have mandatory ref with key, not optional ", { key, item });
         throw new Error("Item does not have mandatory ref with key, not optional " + key + " " + JSON.stringify(item));
       } else {
         if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
@@ -6803,7 +6890,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
       }
     } else {
       const ref = item.refs[key];
-      logger28.default("AGG Retrieving Item in Populate", { key: ref });
+      logger27.default("AGG Retrieving Item in Populate", { key: ref });
       const newItem = await cacheConfig.cache.operations.retrieve(ref);
       if (newItem) {
         if (item.aggs === void 0) {
@@ -6820,25 +6907,25 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const populateEvent = async (key, item) => {
-    logger28.default("populate event key", { key });
+    logger27.default("populate event key", { key });
     const cacheConfig = toCacheConfig(events[key]);
     if (item.events === void 0) {
       throw new Error("Item does not have events " + JSON.stringify(item));
     } else if (item.events[key] === void 0) {
       if (cacheConfig.optional === false) {
-        logger28.error("Item does not have mandatory event with key", { key, item });
+        logger27.error("Item does not have mandatory event with key", { key, item });
         throw new Error("Item does not have mandatory event with key " + key + " " + JSON.stringify(item));
       }
     } else {
       const event = item.events[key];
       if (event.by === void 0) {
-        logger28.error(
+        logger27.error(
           "populateEvent with an Event that does not have by",
           { event, ik: item.key, eventKey: key }
         );
         throw new Error("populateEvent with an Event that does not have by: " + JSON.stringify({ key }));
       }
-      logger28.default("EVENT Retrieving Item in Populate", { key: event.by });
+      logger27.default("EVENT Retrieving Item in Populate", { key: event.by });
       const newItem = await cacheConfig.cache.operations.retrieve(event.by);
       if (newItem) {
         event.agg = newItem;
@@ -6846,13 +6933,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     }
   };
   const all2 = async (query = {}, locations = []) => {
-    logger28.default("all", { query, locations });
+    logger27.default("all", { query, locations });
     const items = await cache.operations.all(query, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const one2 = async (query = {}, locations = []) => {
-    logger28.default("one", { query, locations });
+    logger27.default("one", { query, locations });
     const item = await cache.operations.one(query, locations);
     let populatedItem = null;
     if (item) {
@@ -6861,30 +6948,30 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const action2 = async (key, action3, body = {}) => {
-    logger28.default("action", { key, action: action3, body });
+    logger27.default("action", { key, action: action3, body });
     const [item, affectedItems] = await cache.operations.action(key, action3, body);
     const populatedItem = await populate(item);
     return [populatedItem, affectedItems];
   };
   const allAction2 = async (action3, body = {}, locations = []) => {
-    logger28.default("action", { action: action3, body, locations });
+    logger27.default("action", { action: action3, body, locations });
     const [items, affectedItems] = await cache.operations.allAction(action3, body, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return [populatedItems, affectedItems];
   };
   const allFacet2 = async (facet3, params = {}, locations = []) => {
-    logger28.default("allFacet", { facet: facet3, params, locations });
+    logger27.default("allFacet", { facet: facet3, params, locations });
     const response = await cache.operations.allFacet(facet3, params, locations);
     return response;
   };
   const create2 = async (v, locations = []) => {
-    logger28.default("create", { v, locations });
-    const item = await cache.operations.create(v, locations);
+    logger27.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) => {
-    logger28.default("get", { key });
+    logger27.default("get", { key });
     const item = await cache.operations.get(key);
     let populatedItem = null;
     if (item) {
@@ -6893,7 +6980,7 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const retrieve2 = async (key) => {
-    logger28.default("retrieve", { key });
+    logger27.default("retrieve", { key });
     const item = await cache.operations.retrieve(key);
     let populatedItem = null;
     if (item) {
@@ -6902,34 +6989,37 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
     return populatedItem;
   };
   const remove2 = async (key) => {
-    logger28.default("remove", { key });
+    logger27.default("remove", { key });
     await cache.operations.remove(key);
   };
   const update2 = async (key, v) => {
-    logger28.default("update", { key, v });
+    logger27.default("update", { key, v });
     const item = await cache.operations.update(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const facet2 = async (key, facet3) => {
-    logger28.default("facet", { key, facet: facet3 });
+    logger27.default("facet", { key, facet: facet3 });
     const response = await cache.operations.facet(key, facet3);
     return response;
   };
   const find2 = async (finder, finderParams = {}, locations = []) => {
-    logger28.default("find", { finder, finderParams, locations });
+    logger27.default("find", { finder, finderParams, locations });
     const items = await cache.operations.find(finder, finderParams, locations);
     const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return populatedItems;
   };
   const findOne2 = async (finder, finderParams = {}, locations = []) => {
-    logger28.default("find", { finder, finderParams, locations });
+    logger27.default("find", { finder, finderParams, locations });
     const item = await cache.operations.findOne(finder, finderParams, locations);
+    if (!item) {
+      return null;
+    }
     const populatedItem = await populate(item);
     return populatedItem;
   };
   const set2 = async (key, v) => {
-    logger28.default("set", { key, v });
+    logger27.default("set", { key, v });
     const item = await cache.operations.set(key, v);
     const populatedItem = await populate(item);
     return populatedItem;
@@ -6981,13 +7071,13 @@ var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger29 = logger_default.get("Registry");
+var logger28 = logger_default.get("Registry");
 var createRegistryFactory = () => {
   return (type, registryHub) => {
     if (type !== "cache") {
       throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
     }
-    logger29.debug("Creating cache registry", { type, registryHub });
+    logger28.debug("Creating cache registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };