@fjell/core 4.4.73 → 4.4.74

package/dist/index.js

@@ -3,84 +3,14 @@ import Logging from "@fjell/logging";
 var LibLogger = Logging.getLogger("@fjell/core");
 var logger_default = LibLogger;
 
-// src/dictionary.ts
-var logger = logger_default.get("Dictionary");
-var Dictionary = class _Dictionary {
-  map = {};
-  hashFunction = (key) => JSON.stringify(key);
-  constructor(map, hashFunction) {
-    if (hashFunction) {
-      this.hashFunction = hashFunction;
-    }
-    if (map) {
-      Object.entries(map).forEach(([hashedKey, value]) => {
-        try {
-          const originalKey = JSON.parse(hashedKey);
-          this.map[hashedKey] = { originalKey, value };
-        } catch {
-          logger.warning("Cannot recover original key from legacy map entry", { hashedKey });
-        }
-      });
-    }
-  }
-  set(key, item) {
-    logger.trace("set", { key, item });
-    const hashedKey = this.hashFunction(key);
-    this.map[hashedKey] = { originalKey: key, value: item };
-  }
-  get(key) {
-    logger.trace("get", { key });
-    const hashedKey = this.hashFunction(key);
-    const entry = this.map[hashedKey];
-    return entry && this.keysEqual(entry.originalKey, key) ? entry.value : null;
-  }
-  keysEqual(key1, key2) {
-    return key1 === key2;
-  }
-  delete(key) {
-    logger.trace("delete", { key });
-    const hashedKey = this.hashFunction(key);
-    delete this.map[hashedKey];
-  }
-  keys() {
-    return Object.values(this.map).map((entry) => entry.originalKey);
-  }
-  values() {
-    return Object.values(this.map).map((entry) => entry.value);
-  }
-  includesKey(key) {
-    const hashedKey = this.hashFunction(key);
-    const entry = this.map[hashedKey];
-    return entry ? this.keysEqual(entry.originalKey, key) : false;
-  }
-  clone() {
-    const clonedMap = {};
-    Object.entries(this.map).forEach(([hashedKey, entry]) => {
-      clonedMap[hashedKey] = entry.value;
-    });
-    const clone = new _Dictionary(clonedMap, this.hashFunction);
-    clone.map = Object.assign({}, this.map);
-    return clone;
-  }
+// src/key/KUtils.ts
+var logger = logger_default.get("KUtils");
+var isComKey = (key) => {
+  return key !== null && typeof key === "object" && "kt" in key && "pk" in key && "loc" in key && Array.isArray(key.loc) && key.loc.length > 0;
 };
-
-// src/Coordinate.ts
-var logger2 = logger_default.get("Coordinate");
-var createCoordinate = (kta, scopes = []) => {
-  const ktArray = Array.isArray(kta) ? kta : [kta];
-  const toString = () => {
-    logger2.debug("toString", { kta, scopes });
-    return `${ktArray.join(", ")} - ${scopes.join(", ")}`;
-  };
-  logger2.debug("createCoordinate", { kta: ktArray, scopes, toString });
-  return { kta: ktArray, scopes, toString };
+var isPriKey = (key) => {
+  return key !== null && typeof key === "object" && "kt" in key && "pk" in key && (!("loc" in key) || !key.loc || Array.isArray(key.loc) && key.loc.length === 0);
 };
-
-// src/item/IFactory.ts
-import deepmerge from "deepmerge";
-
-// src/key/KUtils.ts
-var logger3 = logger_default.get("KUtils");
 var normalizeKeyValue = (value) => {
   return String(value);
 };
@@ -108,15 +38,15 @@ var createNormalizedHashFunction = () => {
   };
 };
 var isPriKeyEqualNormalized = (a, b) => {
-  logger3.trace("isPriKeyEqualNormalized", { a, b });
+  logger.trace("isPriKeyEqualNormalized", { a, b });
   return a && b && normalizeKeyValue(a.pk) === normalizeKeyValue(b.pk) && a.kt === b.kt;
 };
 var isLocKeyEqualNormalized = (a, b) => {
-  logger3.trace("isLocKeyEqualNormalized", { a, b });
+  logger.trace("isLocKeyEqualNormalized", { a, b });
   return a && b && normalizeKeyValue(a.lk) === normalizeKeyValue(b.lk) && a.kt === b.kt;
 };
 var isComKeyEqualNormalized = (a, b) => {
-  logger3.trace("isComKeyEqualNormalized", { a, b });
+  logger.trace("isComKeyEqualNormalized", { a, b });
   if (a && b && isPriKeyEqualNormalized({ kt: a.kt, pk: a.pk }, { kt: b.kt, pk: b.pk })) {
     if (a.loc.length === b.loc.length) {
       for (let i = 0; i < a.loc.length; i++) {
@@ -133,7 +63,7 @@ var isComKeyEqualNormalized = (a, b) => {
   }
 };
 var isItemKeyEqualNormalized = (a, b) => {
-  logger3.trace("isItemKeyEqualNormalized", { a, b });
+  logger.trace("isItemKeyEqualNormalized", { a, b });
   if (isComKey(a) && isComKey(b)) {
     return isComKeyEqualNormalized(a, b);
   } else if (isPriKey(a) && isPriKey(b)) {
@@ -147,7 +77,7 @@ var isItemKeyEqualNormalized = (a, b) => {
   }
 };
 var isItemKeyEqual = (a, b) => {
-  logger3.trace("isKeyEqual", { a, b });
+  logger.trace("isKeyEqual", { a, b });
   if (isComKey(a) && isComKey(b)) {
     return isComKeyEqual(a, b);
   } else if (isPriKey(a) && isPriKey(b)) {
@@ -161,15 +91,15 @@ var isItemKeyEqual = (a, b) => {
   }
 };
 var isPriKeyEqual = (a, b) => {
-  logger3.trace("isPriKeyEqual", { a, b });
+  logger.trace("isPriKeyEqual", { a, b });
   return a && b && a.pk === b.pk && a.kt === b.kt;
 };
 var isLocKeyEqual = (a, b) => {
-  logger3.trace("isLocKeyEqual", { a, b });
+  logger.trace("isLocKeyEqual", { a, b });
   return a && b && a.lk === b.lk && a.kt === b.kt;
 };
 var isComKeyEqual = (a, b) => {
-  logger3.trace("isComKeyEqual", { a, b });
+  logger.trace("isComKeyEqual", { a, b });
   if (a && b && isPriKeyEqual({ kt: a.kt, pk: a.pk }, { kt: b.kt, pk: b.pk })) {
     if (a.loc.length === b.loc.length) {
       for (let i = 0; i < a.loc.length; i++) {
@@ -186,23 +116,15 @@ var isComKeyEqual = (a, b) => {
   }
 };
 var isItemKey = (key) => {
-  logger3.trace("isItemKey", { key });
+  logger.trace("isItemKey", { key });
   return key !== void 0 && (isComKey(key) || isPriKey(key));
 };
-var isComKey = (key) => {
-  logger3.trace("isComKey", { key });
-  return key !== void 0 && (key.pk !== void 0 && key.kt !== void 0) && (key.loc !== void 0 && Array.isArray(key.loc));
-};
-var isPriKey = (key) => {
-  logger3.trace("isPriKey", { key });
-  return key !== void 0 && (key.pk !== void 0 && key.kt !== void 0) && key.loc === void 0;
-};
 var isLocKey = (key) => {
-  logger3.trace("isLocKey", { key });
+  logger.trace("isLocKey", { key });
   return key !== void 0 && (key.lk !== void 0 && key.kt !== void 0);
 };
 var generateKeyArray = (key) => {
-  logger3.trace("generateKeyArray", { key });
+  logger.trace("generateKeyArray", { key });
   const keys = [];
   if (isComKey(key) || isPriKey(key)) {
     if (isComKey(key)) {
@@ -223,7 +145,7 @@ var generateKeyArray = (key) => {
   return keys;
 };
 var constructPriKey = (pk, kt) => {
-  logger3.trace("constructPriKey", { pk, kt });
+  logger.trace("constructPriKey", { pk, kt });
   let pri;
   if (typeof pk === "string" || typeof pk === "number") {
     pri = { kt, pk };
@@ -234,7 +156,7 @@ var constructPriKey = (pk, kt) => {
 };
 var cPK = constructPriKey;
 var toKeyTypeArray = (ik) => {
-  logger3.trace("toKeyTypeArray", { ik });
+  logger.trace("toKeyTypeArray", { ik });
   if (isComKey(ik)) {
     const ck = ik;
     return [ck.kt, ...ck.loc.map((l) => l.kt)];
@@ -243,7 +165,7 @@ var toKeyTypeArray = (ik) => {
   }
 };
 var extractKeyTypeArray = (key) => {
-  logger3.trace("extractKeyTypeArray", { key });
+  logger.trace("extractKeyTypeArray", { key });
   if (isComKey(key)) {
     const ck = key;
     return [ck.kt, ...ck.loc.map((l) => l.kt)];
@@ -252,12 +174,12 @@ var extractKeyTypeArray = (key) => {
   } else if (Array.isArray(key)) {
     return key.map((locKey) => locKey.kt);
   } else {
-    logger3.warning("extractKeyTypeArray: Unknown key type", { key });
+    logger.warning("extractKeyTypeArray: Unknown key type", { key });
     return [];
   }
 };
 var abbrevIK = (ik) => {
-  logger3.trace("abbrevIK", { ik });
+  logger.trace("abbrevIK", { ik });
   if (ik) {
     if (isComKey(ik)) {
       const ck = ik;
@@ -270,7 +192,7 @@ var abbrevIK = (ik) => {
   }
 };
 var abbrevLKA = (keyArray) => {
-  logger3.trace("abbrevLKA", { keyArray });
+  logger.trace("abbrevLKA", { keyArray });
   if (keyArray === void 0 || keyArray === null) {
     return "null LKA";
   } else {
@@ -284,7 +206,7 @@ var abbrevLKA = (keyArray) => {
   }
 };
 var primaryType = (ik) => {
-  logger3.trace("primaryType", { ik });
+  logger.trace("primaryType", { ik });
   if (isComKey(ik)) {
     return ik.kt;
   } else {
@@ -292,7 +214,7 @@ var primaryType = (ik) => {
   }
 };
 var itemKeyToLocKeyArray = (ik) => {
-  logger3.trace("itemKeyToLocKeyArray", { ik: abbrevIK(ik) });
+  logger.trace("itemKeyToLocKeyArray", { ik: abbrevIK(ik) });
   let lka = [];
   if (isComKey(ik)) {
     const ck = ik;
@@ -301,12 +223,12 @@ var itemKeyToLocKeyArray = (ik) => {
     const pk = ik;
     lka = [{ kt: pk.kt, lk: pk.pk }];
   }
-  logger3.trace("itemKeyToLocKeyArray Results", { ik: abbrevIK(ik), lka: abbrevLKA(lka) });
+  logger.trace("itemKeyToLocKeyArray Results", { ik: abbrevIK(ik), lka: abbrevLKA(lka) });
   return lka;
 };
 var ikToLKA = itemKeyToLocKeyArray;
 var locKeyArrayToItemKey = (lka) => {
-  logger3.trace("locKeyArrayToItemKey", { lka: abbrevLKA(lka) });
+  logger.trace("locKeyArrayToItemKey", { lka: abbrevLKA(lka) });
   if (lka && lka.length === 1) {
     const priKey = cPK(lka[0].lk, lka[0].kt);
     return priKey;
@@ -336,96 +258,13 @@ var isValidComKey = (key) => {
   return key !== void 0 && key !== null && isValidPriKey(key) && isValidLocKeyArray(key.loc);
 };
 var isValidItemKey = (key) => {
+  if (key === null) throw new Error("Key cannot be null");
+  if (key === void 0) return false;
   return isComKey(key) && isValidComKey(key) || isPriKey(key) && isValidPriKey(key);
 };
 var lkaToIK = locKeyArrayToItemKey;
 
-// src/item/IFactory.ts
-var IFactory = class _IFactory {
-  item = {};
-  constructor(props = {}) {
-    this.item = deepmerge(this.item, props);
-  }
-  addRef(i, name) {
-    const ik = i.key;
-    const refName = name || primaryType(ik);
-    if (!this.item.refs) {
-      this.item.refs = {};
-    }
-    this.item.refs[refName] = ik;
-    return this;
-  }
-  static addRef(i, name) {
-    return new _IFactory().addRef(i, name);
-  }
-  addDefaultEvents() {
-    if (!this.item.events) {
-      this.item.events = {};
-    }
-    const now = /* @__PURE__ */ new Date();
-    if (!this.item.events.created) {
-      this.item.events.created = { at: now };
-    }
-    if (!this.item.events.updated) {
-      this.item.events.updated = { at: now };
-    }
-    if (!this.item.events.deleted) {
-      this.item.events.deleted = { at: null };
-    }
-    return this;
-  }
-  addEvent(name, at, by) {
-    if (!this.item.events) {
-      this.item.events = {};
-    }
-    this.item.events[name] = { at, by };
-    return this;
-  }
-  static addEvent(name, at, by) {
-    return new _IFactory().addEvent(name, at, by);
-  }
-  addProp(name, value) {
-    this.item[name] = value;
-    return this;
-  }
-  static addProp(name, value) {
-    return new _IFactory().addProp(name, value);
-  }
-  addProps(props) {
-    this.item = deepmerge(this.item, props);
-    return this;
-  }
-  static addProps(props) {
-    return new _IFactory().addProps(props);
-  }
-  toItem() {
-    return this.item;
-  }
-};
-
-// src/AItemService.ts
-var AItemService = class {
-  pkType;
-  parentService = null;
-  constructor(pkType, parentService) {
-    this.pkType = pkType;
-    if (parentService) {
-      this.parentService = parentService;
-    }
-  }
-  getPkType = () => {
-    return this.pkType;
-  };
-  getKeyTypes = () => {
-    let keyTypes = [this.getPkType()];
-    if (this.parentService) {
-      keyTypes = keyTypes.concat(this.parentService.getKeyTypes());
-    }
-    return keyTypes;
-  };
-};
-
-// src/item/ItemQuery.ts
+// node_modules/@fjell/types/dist/chunk-5M6KJZFD.js
 var isCondition = (condition) => {
   return (typeof condition.column === "string" && (Array.isArray(condition.value) && condition.value.every((item) => typeof item === "string")) || Array.isArray(condition.value) && condition.value.every((item) => typeof item === "number") || typeof condition.value === "string" || typeof condition.value === "number" || typeof condition.value === "boolean" || condition.value instanceof Date || condition.value === null) && (condition.operator ? typeof condition.operator === "string" : true);
 };
@@ -550,63 +389,221 @@ var IQFactory = class _IQFactory {
   }
 };
 
-// src/item/IQUtils.ts
-import * as luxon from "luxon";
-var logger4 = logger_default.get("IQUtils");
-var queryToParams = (query) => {
-  const params = {};
-  if (query.compoundCondition) {
-    params.compoundCondition = JSON.stringify(query.compoundCondition);
-  }
-  if (query.refs) {
-    params.refs = JSON.stringify(query.refs);
-  }
-  if (query.limit) {
-    params.limit = query.limit;
-  }
-  if (query.offset) {
-    params.offset = query.offset;
-  }
-  if (query.aggs) {
-    params.aggs = JSON.stringify(query.aggs);
+// src/item/IFactory.ts
+import deepmerge from "deepmerge";
+var IFactory = class _IFactory {
+  item = {};
+  constructor(props = {}) {
+    this.item = deepmerge(this.item, props);
   }
-  if (query.events) {
-    params.events = JSON.stringify(query.events);
+  addRef(i, name) {
+    const ik = i.key;
+    const refName = name || primaryType(ik);
+    if (!this.item.refs) {
+      this.item.refs = {};
+    }
+    this.item.refs[refName] = ik;
+    return this;
   }
-  if (query.orderBy) {
-    params.orderBy = JSON.stringify(query.orderBy);
+  static addRef(i, name) {
+    return new _IFactory().addRef(i, name);
   }
-  return params;
-};
-var dateTimeReviver = function(key, value) {
-  if (typeof value === "string") {
-    const parsedDate = luxon.DateTime.fromISO(value);
-    if (parsedDate.isValid) {
-      return parsedDate.toJSDate();
-      ;
+  addDefaultEvents() {
+    if (!this.item.events) {
+      this.item.events = {};
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (!this.item.events.created) {
+      this.item.events.created = { at: now };
+    }
+    if (!this.item.events.updated) {
+      this.item.events.updated = { at: now };
+    }
+    if (!this.item.events.deleted) {
+      this.item.events.deleted = { at: null };
     }
+    return this;
   }
-  return value;
-};
-var paramsToQuery = (params) => {
-  const query = {};
-  if (params.compoundCondition) {
-    query.compoundCondition = JSON.parse(params.compoundCondition);
+  addEvent(name, at, by) {
+    if (!this.item.events) {
+      this.item.events = {};
+    }
+    this.item.events[name] = { at, by };
+    return this;
   }
-  if (params.refs) {
-    query.refs = JSON.parse(params.refs);
+  static addEvent(name, at, by) {
+    return new _IFactory().addEvent(name, at, by);
   }
-  if (params.limit) {
-    query.limit = Number(params.limit);
+  addProp(name, value) {
+    this.item[name] = value;
+    return this;
   }
-  if (params.offset) {
-    query.offset = Number(params.offset);
+  static addProp(name, value) {
+    return new _IFactory().addProp(name, value);
   }
-  if (params.aggs) {
-    query.aggs = JSON.parse(params.aggs);
+  addProps(props) {
+    this.item = deepmerge(this.item, props);
+    return this;
   }
-  if (params.events) {
-    query.events = JSON.parse(params.events, dateTimeReviver);
+  static addProps(props) {
+    return new _IFactory().addProps(props);
+  }
+  toItem() {
+    return this.item;
+  }
+};
+
+// src/AItemService.ts
+var AItemService = class {
+  pkType;
+  parentService = null;
+  constructor(pkType, parentService) {
+    this.pkType = pkType;
+    if (parentService) {
+      this.parentService = parentService;
+    }
+  }
+  getPkType = () => {
+    return this.pkType;
+  };
+  getKeyTypes = () => {
+    let keyTypes = [this.getPkType()];
+    if (this.parentService) {
+      keyTypes = keyTypes.concat(this.parentService.getKeyTypes());
+    }
+    return keyTypes;
+  };
+};
+
+// src/Coordinate.ts
+var logger2 = logger_default.get("Coordinate");
+var createCoordinate = (kta, scopes = []) => {
+  const ktArray = Array.isArray(kta) ? kta : [kta];
+  const toString = () => {
+    logger2.debug("toString", { kta, scopes });
+    return `${ktArray.join(", ")} - ${scopes.join(", ")}`;
+  };
+  logger2.debug("createCoordinate", { kta: ktArray, scopes, toString });
+  return { kta: ktArray, scopes, toString };
+};
+
+// src/dictionary.ts
+var logger3 = logger_default.get("Dictionary");
+var Dictionary = class _Dictionary {
+  map = {};
+  hashFunction = (key) => JSON.stringify(key);
+  constructor(map, hashFunction) {
+    if (hashFunction) {
+      this.hashFunction = hashFunction;
+    }
+    if (map) {
+      Object.entries(map).forEach(([hashedKey, value]) => {
+        try {
+          const originalKey = JSON.parse(hashedKey);
+          this.map[hashedKey] = { originalKey, value };
+        } catch {
+          logger3.warning("Cannot recover original key from legacy map entry", { hashedKey });
+        }
+      });
+    }
+  }
+  set(key, item) {
+    logger3.trace("set", { key, item });
+    const hashedKey = this.hashFunction(key);
+    this.map[hashedKey] = { originalKey: key, value: item };
+  }
+  get(key) {
+    logger3.trace("get", { key });
+    const hashedKey = this.hashFunction(key);
+    const entry = this.map[hashedKey];
+    return entry && this.keysEqual(entry.originalKey, key) ? entry.value : null;
+  }
+  keysEqual(key1, key2) {
+    return key1 === key2;
+  }
+  delete(key) {
+    logger3.trace("delete", { key });
+    const hashedKey = this.hashFunction(key);
+    delete this.map[hashedKey];
+  }
+  keys() {
+    return Object.values(this.map).map((entry) => entry.originalKey);
+  }
+  values() {
+    return Object.values(this.map).map((entry) => entry.value);
+  }
+  includesKey(key) {
+    const hashedKey = this.hashFunction(key);
+    const entry = this.map[hashedKey];
+    return entry ? this.keysEqual(entry.originalKey, key) : false;
+  }
+  clone() {
+    const clonedMap = {};
+    Object.entries(this.map).forEach(([hashedKey, entry]) => {
+      clonedMap[hashedKey] = entry.value;
+    });
+    const clone = new _Dictionary(clonedMap, this.hashFunction);
+    clone.map = Object.assign({}, this.map);
+    return clone;
+  }
+};
+
+// src/item/IQUtils.ts
+import * as luxon from "luxon";
+var logger4 = logger_default.get("IQUtils");
+var queryToParams = (query) => {
+  const params = {};
+  if (query.compoundCondition) {
+    params.compoundCondition = JSON.stringify(query.compoundCondition);
+  }
+  if (query.refs) {
+    params.refs = JSON.stringify(query.refs);
+  }
+  if (query.limit) {
+    params.limit = query.limit;
+  }
+  if (query.offset) {
+    params.offset = query.offset;
+  }
+  if (query.aggs) {
+    params.aggs = JSON.stringify(query.aggs);
+  }
+  if (query.events) {
+    params.events = JSON.stringify(query.events);
+  }
+  if (query.orderBy) {
+    params.orderBy = JSON.stringify(query.orderBy);
+  }
+  return params;
+};
+var dateTimeReviver = function(key, value) {
+  if (typeof value === "string") {
+    const parsedDate = luxon.DateTime.fromISO(value);
+    if (parsedDate.isValid) {
+      return parsedDate.toJSDate();
+    }
+  }
+  return value;
+};
+var paramsToQuery = (params) => {
+  const query = {};
+  if (params.compoundCondition) {
+    query.compoundCondition = JSON.parse(params.compoundCondition);
+  }
+  if (params.refs) {
+    query.refs = JSON.parse(params.refs);
+  }
+  if (params.limit) {
+    query.limit = Number(params.limit);
+  }
+  if (params.offset) {
+    query.offset = Number(params.offset);
+  }
+  if (params.aggs) {
+    query.aggs = JSON.parse(params.aggs);
+  }
+  if (params.events) {
+    query.events = JSON.parse(params.events, dateTimeReviver);
   }
   if (params.orderBy) {
     query.orderBy = JSON.parse(params.orderBy);
@@ -816,115 +813,6 @@ var abbrevCondition = (condition) => {
   }
 };
 
-// src/validation/ItemValidator.ts
-var logger5 = logger_default.get("validation", "ItemValidator");
-var validatePKForItem = (item, pkType) => {
-  if (!item) {
-    logger5.error("Item validation failed - item is undefined", {
-      component: "core",
-      operation: "validatePK",
-      expectedType: pkType,
-      item,
-      suggestion: "Ensure the operation returns a valid item object, not undefined/null"
-    });
-    throw new Error(
-      `Item validation failed: item is undefined. Expected item of type '${pkType}'. This usually indicates a database operation returned null/undefined unexpectedly.`
-    );
-  }
-  if (!item.key) {
-    logger5.error("Item validation failed - item missing key", {
-      component: "core",
-      operation: "validatePK",
-      expectedType: pkType,
-      item,
-      suggestion: "Ensure the item has a valid key property with kt and pk fields"
-    });
-    throw new Error(
-      `Item validation failed: item does not have a key property. Expected key with type '${pkType}'. Item: ${JSON.stringify(item)}. This indicates a database processing error.`
-    );
-  }
-  const keyTypeArray = toKeyTypeArray(item.key);
-  if (keyTypeArray[0] !== pkType) {
-    logger5.error("Key type mismatch during validation", {
-      component: "core",
-      operation: "validatePK",
-      expectedType: pkType,
-      actualType: keyTypeArray[0],
-      keyTypeArray,
-      itemKey: item.key,
-      suggestion: `Ensure the item key has kt: '${pkType}', not '${keyTypeArray[0]}'`
-    });
-    throw new Error(
-      `Item has incorrect primary key type. Expected '${pkType}', got '${keyTypeArray[0]}'. Key: ${JSON.stringify(item.key)}. This indicates a data model mismatch.`
-    );
-  }
-  return item;
-};
-var validatePK = (input, pkType) => {
-  logger5.trace("Checking Return Type", { input });
-  if (Array.isArray(input)) {
-    return input.map((item) => validatePKForItem(item, pkType));
-  }
-  return validatePKForItem(input, pkType);
-};
-var validateKeys = (item, keyTypes) => {
-  logger5.trace("Checking Return Type", { item });
-  if (!item) {
-    logger5.error("Key validation failed - item is undefined", {
-      component: "core",
-      operation: "validateKeys",
-      expectedKeyTypes: keyTypes,
-      suggestion: "Ensure the operation returns a valid item object, not undefined/null"
-    });
-    throw new Error(
-      `Key validation failed: item is undefined. Expected item with key types [${keyTypes.join(", ")}]. This usually indicates a database operation returned null/undefined unexpectedly.`
-    );
-  }
-  if (!item.key) {
-    logger5.error("Key validation failed - item missing key", {
-      component: "core",
-      operation: "validateKeys",
-      expectedKeyTypes: keyTypes,
-      item: JSON.stringify(item),
-      suggestion: "Ensure the item has a valid key property"
-    });
-    throw new Error(
-      `Key validation failed: item does not have a key property. Expected key with types [${keyTypes.join(", ")}]. Item: ${JSON.stringify(item)}. This indicates a database processing error.`
-    );
-  }
-  const keyTypeArray = toKeyTypeArray(item.key);
-  if (keyTypeArray.length !== keyTypes.length) {
-    logger5.error("Key hierarchy depth mismatch", {
-      component: "core",
-      operation: "validateKeys",
-      expectedKeyTypes: keyTypes,
-      expectedDepth: keyTypes.length,
-      actualKeyTypes: keyTypeArray,
-      actualDepth: keyTypeArray.length,
-      itemKey: item.key,
-      suggestion: `Check coordinate definition. Expected hierarchy depth of ${keyTypes.length}, got ${keyTypeArray.length}`
-    });
-    throw new Error(
-      `Item has incorrect key hierarchy depth. Expected ${keyTypes.length} levels [${keyTypes.join(" > ")}], but got ${keyTypeArray.length} levels [${keyTypeArray.join(" > ")}]. Key: ${JSON.stringify(item.key)}. This indicates a coordinate/hierarchy mismatch.`
-    );
-  }
-  const match = JSON.stringify(keyTypeArray) === JSON.stringify(keyTypes);
-  if (!match) {
-    logger5.error("Key Type Array Mismatch", {
-      component: "core",
-      operation: "validateKeys",
-      expectedKeyTypes: keyTypes,
-      actualKeyTypes: keyTypeArray,
-      itemKey: item.key,
-      suggestion: `Ensure item key matches expected hierarchy: [${keyTypes.join(" > ")}]`
-    });
-    throw new Error(
-      `Item has incorrect key types. Expected [${keyTypes.join(" > ")}], but got [${keyTypeArray.join(" > ")}]. Key: ${JSON.stringify(item.key)}. This indicates a data model mismatch.`
-    );
-  }
-  return item;
-};
-
 // src/item/IUtils.ts
 var isPriItem = (item) => {
   return !!(item && item.key && isPriKey(item.key));
@@ -933,173 +821,430 @@ var isComItem = (item) => {
   return !!(item && item.key && isComKey(item.key));
 };
 
-// src/validation/LocationValidator.ts
-var logger6 = logger_default.get("validation", "LocationValidator");
-var validateLocations = (locations, coordinate, operation) => {
-  if (!locations || locations.length === 0) {
-    return;
+// src/errors/ActionError.ts
+var ActionError = class extends Error {
+  constructor(errorInfo, cause) {
+    super(errorInfo.message);
+    this.errorInfo = errorInfo;
+    this.name = "ActionError";
+    this.cause = cause;
+    if (!this.errorInfo.technical) {
+      this.errorInfo.technical = { timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    if (!this.errorInfo.technical.timestamp) {
+      this.errorInfo.technical.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
   }
-  const keyTypeArray = coordinate.kta;
-  const expectedLocationTypes = keyTypeArray.slice(1);
-  const actualLocationTypes = locations.map((loc) => loc.kt);
-  logger6.debug(`Validating locations for ${operation}`, {
-    expected: expectedLocationTypes,
-    actual: actualLocationTypes,
-    coordinate: keyTypeArray
-  });
-  if (actualLocationTypes.length > expectedLocationTypes.length) {
-    logger6.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(", ")}])`
-    );
+  toJSON() {
+    return this.errorInfo;
   }
-  for (let i = 0; i < actualLocationTypes.length; i++) {
-    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
-      logger6.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(", ")}]`
-      );
+};
+
+// src/errors/ValidationError.ts
+var ValidationError = class extends ActionError {
+  fieldErrors;
+  constructor(message, validOptions, suggestedAction, conflictingValue, fieldErrors) {
+    super({
+      code: "VALIDATION_ERROR",
+      message,
+      operation: { type: "create", name: "", params: {} },
+      // Will be filled by wrapper
+      context: { itemType: "" },
+      // Will be filled by wrapper
+      details: {
+        validOptions,
+        suggestedAction: suggestedAction || (validOptions && validOptions.length > 0 ? `Valid options are: ${validOptions.join(", ")}. Please use one of these values.` : "Check the validation requirements and ensure all fields meet the required format, type, and constraints."),
+        retryable: true,
+        conflictingValue,
+        fieldErrors
+      },
+      technical: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    this.fieldErrors = fieldErrors;
+    if (fieldErrors) {
+      if (!this.errorInfo.details) this.errorInfo.details = {};
+      this.errorInfo.details.fieldErrors = fieldErrors;
     }
   }
-  logger6.debug(`Location key array validation passed for ${operation}`, { locations });
 };
-var isValidLocations = (locations, coordinate, operation) => {
-  try {
-    validateLocations(locations, coordinate, operation);
-    return { valid: true };
-  } catch (error) {
-    return {
-      valid: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+
+// src/errors/NotFoundError.ts
+var NotFoundError = class extends ActionError {
+  constructor(message, itemType, key) {
+    super({
+      code: "NOT_FOUND",
+      message,
+      operation: { type: "get", name: "", params: {} },
+      context: {
+        itemType,
+        key: typeof key === "object" ? key : { primary: key }
+      },
+      details: {
+        suggestedAction: "Verify the item ID/key is correct, check if the item was deleted, or create the item if it should exist.",
+        retryable: false
+      },
+      technical: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    this.name = "NotFoundError";
   }
 };
 
-// src/validation/KeyValidator.ts
-var logger7 = logger_default.get("validation", "KeyValidator");
-var validateLocationKeyOrder = (key, coordinate, operation) => {
-  const keyTypeArray = coordinate.kta;
-  const expectedLocationTypes = keyTypeArray.slice(1);
-  const actualLocationTypes = key.loc.map((loc) => loc.kt);
-  if (expectedLocationTypes.length !== actualLocationTypes.length) {
-    logger7.error("Location key array length mismatch", {
-      expected: expectedLocationTypes.length,
-      actual: actualLocationTypes.length,
-      key,
-      coordinate,
-      operation
+// src/errors/BusinessLogicError.ts
+var BusinessLogicError = class extends ActionError {
+  constructor(message, suggestedAction, retryable = false) {
+    super({
+      code: "BUSINESS_LOGIC_ERROR",
+      message,
+      operation: { type: "action", name: "", params: {} },
+      context: { itemType: "" },
+      details: {
+        suggestedAction: suggestedAction || "Review the business logic requirements and ensure all conditions are met before retrying.",
+        retryable
+      },
+      technical: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
     });
-    const expectedOrder = expectedLocationTypes.map(
-      (kt, i) => `  [${i}] { kt: '${kt}', lk: <value> }`
-    ).join("\n");
-    const actualOrder = key.loc.map(
-      (loc, i) => `  [${i}] { kt: '${loc.kt}', lk: ${JSON.stringify(loc.lk)} }`
-    ).join("\n");
-    throw new Error(
-      `Location key array length mismatch for ${operation} operation.
-
-Expected ${expectedLocationTypes.length} location keys but received ${actualLocationTypes.length}.
-
-Expected location key order for '${keyTypeArray[0]}':
-${expectedOrder}
-
-Received location key order:
-${actualOrder}`
-    );
   }
-  for (let i = 0; i < expectedLocationTypes.length; i++) {
-    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
-      logger7.error("Location key array order mismatch", {
-        position: i,
-        expected: expectedLocationTypes[i],
-        actual: actualLocationTypes[i],
-        key,
-        coordinate,
-        operation
-      });
-      const expectedOrder = expectedLocationTypes.map(
-        (kt, i2) => `  [${i2}] { kt: '${kt}', lk: <value> }`
-      ).join("\n");
-      const actualOrder = key.loc.map(
-        (loc, i2) => `  [${i2}] { kt: '${loc.kt}', lk: ${JSON.stringify(loc.lk)} }`
-      ).join("\n");
-      throw new Error(
-        `Location key array order mismatch for ${operation} operation.
-
-At position ${i}, expected key type "${expectedLocationTypes[i]}" but received "${actualLocationTypes[i]}".
-
-Expected location key order for '${keyTypeArray[0]}':
-${expectedOrder}
-
-Received location key order:
-${actualOrder}
+};
 
-Tip: Location keys must be ordered according to the hierarchy: [${expectedLocationTypes.join(", ")}]`
-      );
-    }
+// src/errors/PermissionError.ts
+var PermissionError = class extends ActionError {
+  constructor(message, requiredPermission, currentPermissions) {
+    super({
+      code: "PERMISSION_DENIED",
+      message,
+      operation: { type: "action", name: "", params: {} },
+      context: {
+        itemType: "",
+        ...requiredPermission && { requiredPermission }
+      },
+      details: {
+        ...requiredPermission && {
+          suggestedAction: `Required permission: ${requiredPermission}`,
+          expectedValue: requiredPermission
+        },
+        ...currentPermissions && { conflictingValue: currentPermissions },
+        retryable: false
+      },
+      technical: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
   }
 };
-var validateKey = (key, coordinate, operation) => {
-  logger7.debug(`Validating key for ${operation}`, { key, coordinate: coordinate.kta });
-  if (!key || key === null) {
-    throw new Error(
-      `Invalid key structure for ${operation} operation.
 
-The provided key is null or undefined.
-
-Valid key formats:
-  PriKey: { kt: string, pk: string|number }
-  ComKey: { kt: string, pk: string|number, loc: Array<{ kt: string, lk: string|number }> }`
-    );
+// src/errors/DuplicateError.ts
+var DuplicateError = class extends ActionError {
+  constructor(message, existingItemIdOrKey, duplicateField) {
+    let existingItemId = null;
+    let keyInfo = null;
+    if (typeof existingItemIdOrKey === "object" && existingItemIdOrKey !== null) {
+      existingItemId = existingItemIdOrKey.pk || existingItemIdOrKey.id || existingItemIdOrKey.primary || null;
+      if (existingItemId !== null) {
+        keyInfo = {
+          primary: existingItemId,
+          ...existingItemIdOrKey
+        };
+      } else {
+        keyInfo = existingItemIdOrKey;
+      }
+    } else if (typeof existingItemIdOrKey !== "undefined") {
+      existingItemId = existingItemIdOrKey;
+      keyInfo = { primary: existingItemId };
+    }
+    super({
+      code: "DUPLICATE_ERROR",
+      message,
+      operation: { type: "create", name: "", params: {} },
+      context: {
+        itemType: "",
+        ...keyInfo && { key: keyInfo },
+        ...existingItemId && {
+          affectedItems: [{
+            id: existingItemId,
+            type: "",
+            displayName: `Existing item with ${duplicateField || "key"}`
+          }]
+        }
+      },
+      details: {
+        suggestedAction: duplicateField ? `An item with this ${duplicateField} already exists. Use a different ${duplicateField} value or update the existing item.` : "An item with this key already exists. Use a different key or update the existing item using upsert.",
+        retryable: false,
+        conflictingValue: duplicateField
+      },
+      technical: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
   }
-  const isCompositeLibrary = coordinate.kta.length > 1;
-  const keyIsComposite = isComKey(key);
-  const keyIsPrimary = isPriKey(key);
-  if (isCompositeLibrary && !keyIsComposite) {
-    logger7.error(`Composite library received primary key in ${operation}`, { key, coordinate });
-    const keyTypeArray = coordinate.kta;
-    throw new Error(
-      `Invalid key type for ${operation} operation.
-
-This is a composite item library. You must provide a ComKey with location keys.
+};
 
-Expected: ComKey with format:
-  {
-    kt: '${keyTypeArray[0]}',
-    pk: string|number,
-    loc: [
-` + keyTypeArray.slice(1).map((kt) => `      { kt: '${kt}', lk: string|number }`).join(",\n") + `
-    ]
+// src/operations/errorEnhancer.ts
+async function executeWithContext(operation, context) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw enhanceError(error, context);
   }
-
-Received: PriKey with format:
-  ${JSON.stringify(key, null, 2)}
-
-Example correct usage:
-  library.operations.${operation}({
-    kt: '${keyTypeArray[0]}',
-    pk: 'item-id',
-    loc: [${keyTypeArray.slice(1).map((kt) => `{ kt: '${kt}', lk: 'parent-id' }`).join(", ")}]
-  })`
-    );
+}
+function executeWithContextSync(operation, context) {
+  try {
+    return operation();
+  } catch (error) {
+    throw enhanceError(error, context);
   }
-  if (!isCompositeLibrary && keyIsComposite) {
-    logger7.error(`Primary library received composite key in ${operation}`, { key, coordinate });
+}
+function enhanceError(error, context) {
+  if (!(error instanceof ActionError)) {
+    return error;
+  }
+  error.errorInfo.operation = {
+    type: context.operationType,
+    name: context.operationName,
+    params: context.params
+  };
+  if (!error.errorInfo.context.itemType) {
+    error.errorInfo.context.itemType = context.itemType;
+  }
+  if (context.key) {
+    const existingKey = error.errorInfo.context.key;
+    const hasNoPrimaryKey = !existingKey || typeof existingKey.primary === "undefined";
+    const hasNoCompositeKey = !existingKey || !existingKey.composite;
+    const shouldOverride = hasNoPrimaryKey && hasNoCompositeKey;
+    if (shouldOverride) {
+      error.errorInfo.context.key = extractKeyInfo(context.key);
+    }
+  }
+  if (context.locations && context.locations.length > 0 && !error.errorInfo.context.parentLocation) {
+    error.errorInfo.context.parentLocation = {
+      id: context.locations[0].lk,
+      type: context.locations[0].kt
+    };
+  }
+  return error;
+}
+function extractKeyInfo(key) {
+  if ("loc" in key) {
+    const ktaArray = Array.isArray(key.kt) ? key.kt : [key.kt];
+    const locations = Array.isArray(key.loc) ? key.loc : [];
+    return {
+      composite: {
+        sk: key.pk,
+        kta: ktaArray,
+        locations: locations.map((loc) => ({
+          lk: loc.lk,
+          kt: loc.kt
+        }))
+      }
+    };
+  } else if ("pk" in key) {
+    return { primary: key.pk };
+  }
+  return { primary: JSON.stringify(key) };
+}
+function isActionError(error) {
+  return error instanceof ActionError;
+}
+function getErrorInfo(error) {
+  if (isActionError(error)) {
+    return error.toJSON();
+  }
+  if (error instanceof Error) {
+    return {
+      code: "UNKNOWN_ERROR",
+      message: error.message,
+      technical: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        stackTrace: error.stack
+      }
+    };
+  }
+  return {
+    code: "UNKNOWN_ERROR",
+    message: String(error),
+    technical: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+
+// node_modules/@fjell/validation/dist/index.js
+import Logging2 from "@fjell/logging";
+import Logging22 from "@fjell/logging";
+import Logging3 from "@fjell/logging";
+import Logging4 from "@fjell/logging";
+var logger5 = Logging2.getLogger("validation.LocationValidator");
+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);
+  logger5.debug(`Validating locations for ${operation}`, {
+    expected: expectedLocationTypes,
+    actual: actualLocationTypes,
+    coordinate: keyTypeArray
+  });
+  if (actualLocationTypes.length > expectedLocationTypes.length) {
+    logger5.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]) {
+      logger5.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(", ")}]`
+      );
+    }
+  }
+  logger5.debug(`Location key array validation passed for ${operation}`, { locations });
+};
+var isComKey3 = (key) => {
+  return typeof key !== "undefined" && (typeof key.pk !== "undefined" && typeof key.kt !== "undefined") && (typeof key.loc !== "undefined" && Array.isArray(key.loc));
+};
+var isPriKey3 = (key) => {
+  return typeof key !== "undefined" && (typeof key.pk !== "undefined" && typeof key.kt !== "undefined") && typeof key.loc === "undefined";
+};
+var toKeyTypeArray2 = (ik) => {
+  if (isComKey3(ik)) {
+    const ck = ik;
+    return [ck.kt, ...ck.loc.map((l) => l.kt)];
+  } else {
+    return [ik.kt];
+  }
+};
+var logger22 = Logging22.getLogger("validation.KeyValidator");
+var validateLocationKeyOrder = (key, coordinate, operation) => {
+  const keyTypeArray = coordinate.kta;
+  const expectedLocationTypes = keyTypeArray.slice(1);
+  const actualLocationTypes = key.loc.map((loc) => loc.kt);
+  if (expectedLocationTypes.length !== actualLocationTypes.length) {
+    logger22.error("Location key array length mismatch", {
+      expected: expectedLocationTypes.length,
+      actual: actualLocationTypes.length,
+      key,
+      coordinate,
+      operation
+    });
+    const expectedOrder = expectedLocationTypes.map(
+      (kt, i) => `  [${i}] { kt: '${kt}', lk: <value> }`
+    ).join("\n");
+    const actualOrder = key.loc.map(
+      (loc, i) => `  [${i}] { kt: '${loc.kt}', lk: ${JSON.stringify(loc.lk)} }`
+    ).join("\n");
+    throw new Error(
+      `Location key array length mismatch for ${operation} operation.
+
+Expected ${expectedLocationTypes.length} location keys but received ${actualLocationTypes.length}.
+
+Expected location key order for '${keyTypeArray[0]}':
+${expectedOrder}
+
+Received location key order:
+${actualOrder}`
+    );
+  }
+  for (let i = 0; i < expectedLocationTypes.length; i++) {
+    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
+      logger22.error("Location key array order mismatch", {
+        position: i,
+        expected: expectedLocationTypes[i],
+        actual: actualLocationTypes[i],
+        key,
+        coordinate,
+        operation
+      });
+      const expectedOrder = expectedLocationTypes.map(
+        (kt, i2) => `  [${i2}] { kt: '${kt}', lk: <value> }`
+      ).join("\n");
+      const actualOrder = key.loc.map(
+        (loc, i2) => `  [${i2}] { kt: '${loc.kt}', lk: ${JSON.stringify(loc.lk)} }`
+      ).join("\n");
+      throw new Error(
+        `Location key array order mismatch for ${operation} operation.
+
+At position ${i}, expected key type "${expectedLocationTypes[i]}" but received "${actualLocationTypes[i]}".
+
+Expected location key order for '${keyTypeArray[0]}':
+${expectedOrder}
+
+Received location key order:
+${actualOrder}
+
+Tip: Location keys must be ordered according to the hierarchy: [${expectedLocationTypes.join(", ")}]`
+      );
+    }
+  }
+};
+var validateKey = (key, coordinate, operation) => {
+  logger22.debug(`Validating key for ${operation}`, { key, coordinate: coordinate.kta });
+  if (!key || key === null) {
+    throw new Error(
+      `Invalid key structure for ${operation} operation.
+
+The provided key is null or undefined.
+
+Valid key formats:
+  PriKey: { kt: string, pk: string|number }
+  ComKey: { kt: string, pk: string|number, loc: Array<{ kt: string, lk: string|number }> }`
+    );
+  }
+  const isCompositeLibrary = coordinate.kta.length > 1;
+  const keyIsComposite = isComKey3(key);
+  const keyIsPrimary = isPriKey3(key);
+  if (isCompositeLibrary && !keyIsComposite) {
+    logger22.error(`Composite library received primary key in ${operation}`, { key, coordinate });
+    const keyTypeArray = coordinate.kta;
+    throw new Error(
+      `Invalid key type for ${operation} operation.
+
+This is a composite item library. You must provide a ComKey with location keys.
+
+Expected: ComKey with format:
+  {
+    kt: '${keyTypeArray[0]}',
+    pk: string|number,
+    loc: [
+` + keyTypeArray.slice(1).map((kt) => `      { kt: '${kt}', lk: string|number }`).join(",\n") + `
+    ]
+  }
+
+Received: PriKey with format:
+  ${JSON.stringify(key, null, 2)}
+
+Example correct usage:
+  library.operations.${operation}({
+    kt: '${keyTypeArray[0]}',
+    pk: 'item-id',
+    loc: [${keyTypeArray.slice(1).map((kt) => `{ kt: '${kt}', lk: 'parent-id' }`).join(", ")}]
+  })`
+    );
+  }
+  if (!isCompositeLibrary && keyIsComposite) {
+    logger22.error(`Primary library received composite key in ${operation}`, { key, coordinate });
     const keyTypeArray = coordinate.kta;
     throw new Error(
       `Invalid key type for ${operation} operation.
@@ -1117,7 +1262,7 @@ Example correct usage:
     );
   }
   if (!keyIsPrimary && !keyIsComposite) {
-    logger7.error(`Invalid key structure in ${operation}`, { key, coordinate });
+    logger22.error(`Invalid key structure in ${operation}`, { key, coordinate });
     throw new Error(
       `Invalid key structure for ${operation} operation.
 
@@ -1133,7 +1278,7 @@ Valid key formats:
   }
   const expectedKeyType = coordinate.kta[0];
   if (key.kt !== expectedKeyType) {
-    logger7.error(`Key type mismatch in ${operation}`, {
+    logger22.error(`Key type mismatch in ${operation}`, {
       expected: expectedKeyType,
       received: key.kt,
       key,
@@ -1152,754 +1297,218 @@ Example correct usage:
   if (keyIsComposite) {
     const comKey = key;
     if (comKey.loc.length === 0) {
-      logger7.debug(`Empty loc array detected in ${operation} - will search across all locations`, { key });
+      logger22.debug(`Empty loc array detected in ${operation} - will search across all locations`, { key });
     } else {
       validateLocationKeyOrder(comKey, coordinate, operation);
     }
   }
-  logger7.debug(`Key validation passed for ${operation}`, { key });
-};
-var validatePriKey = (key, expectedType, operation) => {
-  if (!key || key === null) {
-    throw new Error(`[${operation}] PriKey is undefined or null`);
-  }
-  if (!key.kt) {
-    throw new Error(`[${operation}] PriKey is missing 'kt' field`);
-  }
-  if (key.kt !== expectedType) {
-    throw new Error(
-      `[${operation}] PriKey has incorrect type.
-Expected: '${expectedType}'
-Received: '${key.kt}'`
-    );
-  }
-  if (typeof key.pk === "undefined" || key.pk === null) {
-    throw new Error(`[${operation}] PriKey is missing 'pk' field`);
-  }
+  logger22.debug(`Key validation passed for ${operation}`, { key });
 };
-var validateComKey = (key, coordinate, operation) => {
-  if (!key || key === null) {
-    throw new Error(`[${operation}] ComKey is undefined or null`);
-  }
-  if (!key.kt) {
-    throw new Error(`[${operation}] ComKey is missing 'kt' field`);
-  }
-  if (key.kt !== coordinate.kta[0]) {
+var logger32 = Logging3.getLogger("validation.ItemValidator");
+var validatePKForItem = (item, pkType) => {
+  if (!item) {
+    logger32.error("Item validation failed - item is undefined", {
+      component: "core",
+      operation: "validatePK",
+      expectedType: pkType,
+      item,
+      suggestion: "Ensure the operation returns a valid item object, not undefined/null"
+    });
     throw new Error(
-      `[${operation}] ComKey has incorrect type.
-Expected: '${coordinate.kta[0]}'
-Received: '${key.kt}'`
+      `Item validation failed: item is undefined. Expected item of type '${pkType}'. This usually indicates a database operation returned null/undefined unexpectedly.`
     );
   }
-  if (typeof key.pk === "undefined" || key.pk === null) {
-    throw new Error(`[${operation}] ComKey is missing 'pk' field`);
-  }
-  if (!Array.isArray(key.loc)) {
-    throw new Error(`[${operation}] ComKey is missing or invalid 'loc' field (must be an array)`);
-  }
-  if (key.loc.length > 0) {
-    validateLocationKeyOrder(key, coordinate, operation);
-  }
-};
-
-// src/validation/QueryValidator.ts
-var logger8 = logger_default.get("validation", "QueryValidator");
-var validateQuery = (query, operation) => {
-  if (typeof query === "undefined" || query === null) {
-    return;
-  }
-  if (typeof query !== "object") {
-    logger8.error(`Invalid query type for ${operation}`, { query, type: typeof query });
-    throw new Error(
-      `[${operation}] Invalid query parameter.
-
-Expected: object or undefined
-Received: ${typeof query}
-
-Example valid queries:
-  {}
-  { filter: { status: 'active' } }
-  { limit: 10, sort: { field: 'name', order: 'asc' } }`
-    );
-  }
-  if (Array.isArray(query)) {
-    logger8.error(`Query cannot be an array for ${operation}`, { query });
-    throw new Error(
-      `[${operation}] Invalid query parameter.
-
-Query cannot be an array.
-Received: ${JSON.stringify(query)}`
-    );
-  }
-  logger8.debug(`Query validation passed for ${operation}`, { query });
-};
-var validateOperationParams = (params, operation) => {
-  if (typeof params === "undefined") {
-    return;
-  }
-  if (params === null) {
-    logger8.error(`Params cannot be null for ${operation}`, { params });
-    throw new Error(
-      `[${operation}] Invalid operation parameters.
-
-Parameters cannot be null.
-Expected: object or undefined
-Received: null
-
-Example valid parameters:
-  {}
-  { email: 'user@example.com' }
-  { status: 'active', limit: 10 }`
-    );
-  }
-  if (typeof params !== "object") {
-    logger8.error(`Invalid params type for ${operation}`, { params, type: typeof params });
-    throw new Error(
-      `[${operation}] Invalid operation parameters.
-
-Expected: object or undefined
-Received: ${typeof params}
-
-Example valid parameters:
-  {}
-  { email: 'user@example.com' }
-  { status: 'active', limit: 10 }`
-    );
-  }
-  if (Array.isArray(params)) {
-    logger8.error(`Params cannot be an array for ${operation}`, { params });
-    throw new Error(
-      `[${operation}] Invalid operation parameters.
-
-Parameters cannot be an array.
-Received: ${JSON.stringify(params)}`
-    );
-  }
-  for (const [key, value] of Object.entries(params)) {
-    const valueType = typeof value;
-    const isValidType = valueType === "string" || valueType === "number" || valueType === "boolean" || value instanceof Date || Array.isArray(value) && value.every(
-      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v instanceof Date
-    );
-    if (!isValidType) {
-      logger8.error(`Invalid param value type for ${operation}`, { key, value, valueType });
-      throw new Error(
-        `[${operation}] Invalid value type for parameter "${key}".
-
-Allowed types: string, number, boolean, Date, or arrays of these types
-Received: ${valueType}
-Value: ${JSON.stringify(value)}`
-      );
-    }
-  }
-  logger8.debug(`Operation params validation passed for ${operation}`, { params });
-};
-var validateFinderName = (finder, operation) => {
-  if (!finder || typeof finder !== "string") {
-    logger8.error(`Invalid finder name for ${operation}`, { finder, type: typeof finder });
-    throw new Error(
-      `[${operation}] Finder name must be a non-empty string.
-
-Received: ${JSON.stringify(finder)}`
-    );
-  }
-  if (finder.trim().length === 0) {
-    logger8.error(`Empty finder name for ${operation}`, { finder });
-    throw new Error(
-      `[${operation}] Finder name cannot be empty or whitespace only.
-
-Received: "${finder}"`
-    );
-  }
-  logger8.debug(`Finder name validation passed for ${operation}`, { finder });
-};
-var validateActionName = (action, operation) => {
-  if (!action || typeof action !== "string") {
-    logger8.error(`Invalid action name for ${operation}`, { action, type: typeof action });
-    throw new Error(
-      `[${operation}] Action name must be a non-empty string.
-
-Received: ${JSON.stringify(action)}`
-    );
-  }
-  if (action.trim().length === 0) {
-    logger8.error(`Empty action name for ${operation}`, { action });
-    throw new Error(
-      `[${operation}] Action name cannot be empty or whitespace only.
-
-Received: "${action}"`
-    );
-  }
-  logger8.debug(`Action name validation passed for ${operation}`, { action });
-};
-var validateFacetName = (facet, operation) => {
-  if (!facet || typeof facet !== "string") {
-    logger8.error(`Invalid facet name for ${operation}`, { facet, type: typeof facet });
-    throw new Error(
-      `[${operation}] Facet name must be a non-empty string.
-
-Received: ${JSON.stringify(facet)}`
-    );
-  }
-  if (facet.trim().length === 0) {
-    logger8.error(`Empty facet name for ${operation}`, { facet });
-    throw new Error(
-      `[${operation}] Facet name cannot be empty or whitespace only.
-
-Received: "${facet}"`
-    );
-  }
-  logger8.debug(`Facet name validation passed for ${operation}`, { facet });
-};
-
-// src/errors/ActionError.ts
-var ActionError = class extends Error {
-  constructor(errorInfo, cause) {
-    super(errorInfo.message);
-    this.errorInfo = errorInfo;
-    this.name = "ActionError";
-    this.cause = cause;
-    if (!this.errorInfo.technical) {
-      this.errorInfo.technical = { timestamp: (/* @__PURE__ */ new Date()).toISOString() };
-    }
-    if (!this.errorInfo.technical.timestamp) {
-      this.errorInfo.technical.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-  toJSON() {
-    return this.errorInfo;
-  }
-};
-
-// src/errors/ValidationError.ts
-var ValidationError = class extends ActionError {
-  fieldErrors;
-  constructor(message, validOptions, suggestedAction, conflictingValue, fieldErrors) {
-    super({
-      code: "VALIDATION_ERROR",
-      message,
-      operation: { type: "create", name: "", params: {} },
-      // Will be filled by wrapper
-      context: { itemType: "" },
-      // Will be filled by wrapper
-      details: {
-        validOptions,
-        suggestedAction: suggestedAction || (validOptions && validOptions.length > 0 ? `Valid options are: ${validOptions.join(", ")}. Please use one of these values.` : "Check the validation requirements and ensure all fields meet the required format, type, and constraints."),
-        retryable: true,
-        conflictingValue,
-        fieldErrors
-      },
-      technical: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-    this.fieldErrors = fieldErrors;
-    if (fieldErrors) {
-      if (!this.errorInfo.details) this.errorInfo.details = {};
-      this.errorInfo.details.fieldErrors = fieldErrors;
-    }
-  }
-};
-
-// src/errors/NotFoundError.ts
-var NotFoundError = class extends ActionError {
-  constructor(message, itemType, key) {
-    super({
-      code: "NOT_FOUND",
-      message,
-      operation: { type: "get", name: "", params: {} },
-      context: {
-        itemType,
-        key: typeof key === "object" ? key : { primary: key }
-      },
-      details: {
-        suggestedAction: "Verify the item ID/key is correct, check if the item was deleted, or create the item if it should exist.",
-        retryable: false
-      },
-      technical: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-    this.name = "NotFoundError";
-  }
-};
-
-// src/errors/BusinessLogicError.ts
-var BusinessLogicError = class extends ActionError {
-  constructor(message, suggestedAction, retryable = false) {
-    super({
-      code: "BUSINESS_LOGIC_ERROR",
-      message,
-      operation: { type: "action", name: "", params: {} },
-      context: { itemType: "" },
-      details: {
-        suggestedAction: suggestedAction || "Review the business logic requirements and ensure all conditions are met before retrying.",
-        retryable
-      },
-      technical: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-  }
-};
-
-// src/errors/PermissionError.ts
-var PermissionError = class extends ActionError {
-  constructor(message, requiredPermission, currentPermissions) {
-    super({
-      code: "PERMISSION_DENIED",
-      message,
-      operation: { type: "action", name: "", params: {} },
-      context: {
-        itemType: "",
-        ...requiredPermission && { requiredPermission }
-      },
-      details: {
-        ...requiredPermission && {
-          suggestedAction: `Required permission: ${requiredPermission}`,
-          expectedValue: requiredPermission
-        },
-        ...currentPermissions && { conflictingValue: currentPermissions },
-        retryable: false
-      },
-      technical: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-  }
-};
-
-// src/errors/DuplicateError.ts
-var DuplicateError = class extends ActionError {
-  constructor(message, existingItemIdOrKey, duplicateField) {
-    let existingItemId = null;
-    let keyInfo = null;
-    if (typeof existingItemIdOrKey === "object" && existingItemIdOrKey !== null) {
-      existingItemId = existingItemIdOrKey.pk || existingItemIdOrKey.id || existingItemIdOrKey.primary || null;
-      if (existingItemId !== null) {
-        keyInfo = {
-          primary: existingItemId,
-          ...existingItemIdOrKey
-        };
-      } else {
-        keyInfo = existingItemIdOrKey;
-      }
-    } else if (typeof existingItemIdOrKey !== "undefined") {
-      existingItemId = existingItemIdOrKey;
-      keyInfo = { primary: existingItemId };
-    }
-    super({
-      code: "DUPLICATE_ERROR",
-      message,
-      operation: { type: "create", name: "", params: {} },
-      context: {
-        itemType: "",
-        ...keyInfo && { key: keyInfo },
-        ...existingItemId && {
-          affectedItems: [{
-            id: existingItemId,
-            type: "",
-            displayName: `Existing item with ${duplicateField || "key"}`
-          }]
-        }
-      },
-      details: {
-        suggestedAction: duplicateField ? `An item with this ${duplicateField} already exists. Use a different ${duplicateField} value or update the existing item.` : "An item with this key already exists. Use a different key or update the existing item using upsert.",
-        retryable: false,
-        conflictingValue: duplicateField
-      },
-      technical: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-  }
-};
-
-// src/validation/schema.ts
-async function validateSchema(data, schema) {
-  if (!schema) {
-    return data;
-  }
-  try {
-    if (schema.parseAsync) {
-      return await schema.parseAsync(data);
-    }
-    const result = schema.safeParse(data);
-    if (result.success) {
-      return result.data;
-    } else {
-      throw result.error;
-    }
-  } catch (error) {
-    if (error && Array.isArray(error.issues)) {
-      const fieldErrors = error.issues.map((issue) => ({
-        path: issue.path,
-        message: issue.message,
-        code: issue.code
-      }));
-      const validationError = new ValidationError(
-        "Schema validation failed",
-        // eslint-disable-next-line no-undefined
-        void 0,
-        // eslint-disable-next-line no-undefined
-        void 0,
-        // eslint-disable-next-line no-undefined
-        void 0,
-        fieldErrors
-      );
-      throw validationError;
-    }
-    if (error instanceof ValidationError) {
-      throw error;
-    }
-    throw new ValidationError(`Validation failed: ${error.message || "Unknown error"}`);
-  }
-}
-
-// src/operations/errorEnhancer.ts
-async function executeWithContext(operation, context) {
-  try {
-    return await operation();
-  } catch (error) {
-    throw enhanceError(error, context);
-  }
-}
-function executeWithContextSync(operation, context) {
-  try {
-    return operation();
-  } catch (error) {
-    throw enhanceError(error, context);
-  }
-}
-function enhanceError(error, context) {
-  if (!(error instanceof ActionError)) {
-    return error;
-  }
-  error.errorInfo.operation = {
-    type: context.operationType,
-    name: context.operationName,
-    params: context.params
-  };
-  if (!error.errorInfo.context.itemType) {
-    error.errorInfo.context.itemType = context.itemType;
-  }
-  if (context.key) {
-    const existingKey = error.errorInfo.context.key;
-    const hasNoPrimaryKey = !existingKey || typeof existingKey.primary === "undefined";
-    const hasNoCompositeKey = !existingKey || !existingKey.composite;
-    const shouldOverride = hasNoPrimaryKey && hasNoCompositeKey;
-    if (shouldOverride) {
-      error.errorInfo.context.key = extractKeyInfo(context.key);
-    }
-  }
-  if (context.locations && context.locations.length > 0 && !error.errorInfo.context.parentLocation) {
-    error.errorInfo.context.parentLocation = {
-      id: context.locations[0].lk,
-      type: context.locations[0].kt
-    };
-  }
-  return error;
-}
-function extractKeyInfo(key) {
-  if ("loc" in key) {
-    const ktaArray = Array.isArray(key.kt) ? key.kt : [key.kt];
-    const locations = Array.isArray(key.loc) ? key.loc : [];
-    return {
-      composite: {
-        sk: key.pk,
-        kta: ktaArray,
-        locations: locations.map((loc) => ({
-          lk: loc.lk,
-          kt: loc.kt
-        }))
-      }
-    };
-  } else if ("pk" in key) {
-    return { primary: key.pk };
-  }
-  return { primary: JSON.stringify(key) };
-}
-function isActionError(error) {
-  return error instanceof ActionError;
-}
-function getErrorInfo(error) {
-  if (isActionError(error)) {
-    return error.toJSON();
-  }
-  if (error instanceof Error) {
-    return {
-      code: "UNKNOWN_ERROR",
-      message: error.message,
-      technical: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        stackTrace: error.stack
-      }
-    };
-  }
-  return {
-    code: "UNKNOWN_ERROR",
-    message: String(error),
-    technical: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-}
-
-// src/event/events.ts
-function isCreateEvent(event) {
-  return event.eventType === "create";
-}
-function isUpdateEvent(event) {
-  return event.eventType === "update";
-}
-function isDeleteEvent(event) {
-  return event.eventType === "delete";
-}
-function isActionEvent(event) {
-  return event.eventType === "action";
-}
-
-// src/event/subscription.ts
-function isItemSubscription(subscription) {
-  return "key" in subscription;
-}
-function isLocationSubscription(subscription) {
-  return "kta" in subscription && "location" in subscription;
-}
-function generateSubscriptionId() {
-  return `sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-}
-function createItemSubscription(key, options) {
-  return {
-    id: generateSubscriptionId(),
-    key,
-    eventTypes: options?.eventTypes,
-    scopes: options?.scopes,
-    query: options?.query
-  };
-}
-function createLocationSubscription(kta, location, options) {
-  return {
-    id: generateSubscriptionId(),
-    kta,
-    location,
-    eventTypes: options?.eventTypes,
-    scopes: options?.scopes,
-    query: options?.query
-  };
-}
-
-// src/operations/Operations.ts
-function isPriKey2(key) {
-  return !("loc" in key) || !key.loc;
-}
-function isComKey2(key) {
-  return "loc" in key && key.loc && Array.isArray(key.loc) && key.loc.length > 0;
-}
-
-// src/event/matching.ts
-function doesEventMatchSubscription(event, subscription) {
-  if (!doesScopeMatch(event.scopes, subscription.scopes)) {
-    return false;
-  }
-  if (!doesEventTypeMatch(event.eventType, subscription.eventTypes)) {
-    return false;
-  }
-  if (isItemSubscription(subscription)) {
-    return doesKeyMatch(event.key, subscription.key);
-  } else if (isLocationSubscription(subscription)) {
-    return doesKeyMatchLocation(event.key, subscription.kta, subscription.location);
-  }
-  return false;
-}
-function doesScopeMatch(eventScopes, subscriptionScopes) {
-  if (!subscriptionScopes || subscriptionScopes.length === 0) {
-    return true;
-  }
-  return subscriptionScopes.some(
-    (requiredScope) => eventScopes.includes(requiredScope)
-  );
-}
-function doesEventTypeMatch(eventType, subscriptionEventTypes) {
-  if (!subscriptionEventTypes || subscriptionEventTypes.length === 0) {
-    return true;
-  }
-  return subscriptionEventTypes.includes(eventType);
-}
-function doesKeyMatch(eventKey, subscriptionKey) {
-  if (isPriKey2(eventKey) && isPriKey2(subscriptionKey)) {
-    return eventKey.pk === subscriptionKey.pk && eventKey.kt === subscriptionKey.kt;
-  }
-  if (isComKey2(eventKey) && isComKey2(subscriptionKey)) {
-    const eventComKey = eventKey;
-    const subscriptionComKey = subscriptionKey;
-    if (eventComKey.pk !== subscriptionComKey.pk || eventComKey.kt !== subscriptionComKey.kt) {
-      return false;
-    }
-    if (eventComKey.loc.length !== subscriptionComKey.loc.length) {
-      return false;
-    }
-    return eventComKey.loc.every((eventLocKey, index) => {
-      const subLocKey = subscriptionComKey.loc[index];
-      return eventLocKey.lk === subLocKey.lk && eventLocKey.kt === subLocKey.kt;
+  if (!item.key) {
+    logger32.error("Item validation failed - item missing key", {
+      component: "core",
+      operation: "validatePK",
+      expectedType: pkType,
+      item,
+      suggestion: "Ensure the item has a valid key property with kt and pk fields"
     });
+    throw new Error(
+      `Item validation failed: item does not have a key property. Expected key with type '${pkType}'. Item: ${JSON.stringify(item)}. This indicates a database processing error.`
+    );
   }
-  return false;
-}
-function doesKeyMatchLocation(eventKey, subscriptionKta, subscriptionLocation) {
-  const targetItemType = subscriptionKta[subscriptionKta.length - 1];
-  if (eventKey.kt !== targetItemType) {
-    return false;
+  const keyTypeArray = toKeyTypeArray2(item.key);
+  if (keyTypeArray[0] !== pkType) {
+    logger32.error("Key type mismatch during validation", {
+      component: "core",
+      operation: "validatePK",
+      expectedType: pkType,
+      actualType: keyTypeArray[0],
+      keyTypeArray,
+      itemKey: item.key,
+      suggestion: `Ensure the item key has kt: '${pkType}', not '${keyTypeArray[0]}'`
+    });
+    throw new Error(
+      `Item has incorrect primary key type. Expected '${pkType}', got '${keyTypeArray[0]}'. Key: ${JSON.stringify(item.key)}. This indicates a data model mismatch.`
+    );
   }
-  if (isPriKey2(eventKey)) {
-    return subscriptionLocation.length === 0;
+  return item;
+};
+var validatePK = (input, pkType) => {
+  logger32.trace("Checking Return Type", { input });
+  if (Array.isArray(input)) {
+    return input.map((item) => validatePKForItem(item, pkType));
   }
-  if (isComKey2(eventKey)) {
-    const comKey = eventKey;
-    return doesLocationMatch(comKey.loc, subscriptionLocation, subscriptionKta);
+  return validatePKForItem(input, pkType);
+};
+var logger42 = Logging4.getLogger("validation.QueryValidator");
+var validateQuery = (query, operation) => {
+  if (typeof query === "undefined" || query === null) {
+    return;
   }
-  return false;
-}
-function doesLocationMatch(eventLocation, subscriptionLocation, _subscriptionKta) {
-  if (subscriptionLocation.length === 0) {
-    return true;
+  if (typeof query !== "object") {
+    logger42.error(`Invalid query type for ${operation}`, { query, type: typeof query });
+    throw new Error(
+      `[${operation}] Invalid query parameter.
+
+Expected: object or undefined
+Received: ${typeof query}
+
+Example valid queries:
+  {}
+  { filter: { status: 'active' } }
+  { limit: 10, sort: { field: 'name', order: 'asc' } }`
+    );
   }
-  if (eventLocation.length < subscriptionLocation.length) {
-    return false;
+  if (Array.isArray(query)) {
+    logger42.error(`Query cannot be an array for ${operation}`, { query });
+    throw new Error(
+      `[${operation}] Invalid query parameter.
+
+Query cannot be an array.
+Received: ${JSON.stringify(query)}`
+    );
   }
-  for (let i = 0; i < subscriptionLocation.length; i++) {
-    const eventLocKey = eventLocation[i];
-    const subLocKey = subscriptionLocation[i];
-    if (!eventLocKey || !subLocKey) {
-      return false;
-    }
-    if (eventLocKey.lk !== subLocKey.lk || eventLocKey.kt !== subLocKey.kt) {
-      return false;
-    }
+  logger42.debug(`Query validation passed for ${operation}`, { query });
+};
+var validateOperationParams = (params, operation) => {
+  if (typeof params === "undefined") {
+    return;
   }
-  return true;
-}
-function findMatchingSubscriptions(event, subscriptions) {
-  return subscriptions.filter(
-    (subscription) => doesEventMatchSubscription(event, subscription)
-  );
-}
-function extractLocationValues(location) {
-  return location.map((locKey) => String(locKey.lk));
-}
-function compareLocationValues(location1, location2) {
-  if (location1.length !== location2.length) {
-    return false;
+  if (params === null) {
+    logger42.error(`Params cannot be null for ${operation}`, { params });
+    throw new Error(
+      `[${operation}] Invalid operation parameters.
+
+Parameters cannot be null.
+Expected: object or undefined
+Received: null
+
+Example valid parameters:
+  {}
+  { email: 'user@example.com' }
+  { status: 'active', limit: 10 }`
+    );
   }
-  return location1.every((locKey1, index) => {
-    const locKey2 = location2[index];
-    return locKey1.lk === locKey2.lk && locKey1.kt === locKey2.kt;
-  });
-}
+  if (typeof params !== "object") {
+    logger42.error(`Invalid params type for ${operation}`, { params, type: typeof params });
+    throw new Error(
+      `[${operation}] Invalid operation parameters.
 
-// src/event/types.ts
-var STANDARD_EVENT_TYPES = {
-  CREATE: "create",
-  UPDATE: "update",
-  DELETE: "delete",
-  ACTION: "action"
-};
-var STANDARD_SCOPES = {
-  FIRESTORE: "firestore",
-  SEQUELIZE: "sequelize",
-  POSTGRESQL: "postgresql",
-  MYSQL: "mysql",
-  MONGODB: "mongodb",
-  REDIS: "redis"
-};
-var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
-  SubscriptionStatus2["PENDING"] = "pending";
-  SubscriptionStatus2["ACTIVE"] = "active";
-  SubscriptionStatus2["PAUSED"] = "paused";
-  SubscriptionStatus2["ERROR"] = "error";
-  SubscriptionStatus2["CANCELLED"] = "cancelled";
-  return SubscriptionStatus2;
-})(SubscriptionStatus || {});
-var DEFAULT_EVENT_CONFIG = {
-  maxBatchSize: 100,
-  maxBatchWaitTime: 50,
-  // 50ms
-  maxRetryAttempts: 3,
-  retryDelay: 1e3,
-  // 1 second
-  enableStats: true,
-  maxSubscriptions: 1e3,
-  subscriptionCleanupInterval: 3e5
-  // 5 minutes
-};
-var EventSystemError = class extends Error {
-  constructor(message, code, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "EventSystemError";
+Expected: object or undefined
+Received: ${typeof params}
+
+Example valid parameters:
+  {}
+  { email: 'user@example.com' }
+  { status: 'active', limit: 10 }`
+    );
   }
-};
-var SubscriptionError = class extends EventSystemError {
-  constructor(message, subscriptionId, details) {
-    super(message, "SUBSCRIPTION_ERROR", { subscriptionId, ...details });
-    this.subscriptionId = subscriptionId;
-    this.name = "SubscriptionError";
+  if (Array.isArray(params)) {
+    logger42.error(`Params cannot be an array for ${operation}`, { params });
+    throw new Error(
+      `[${operation}] Invalid operation parameters.
+
+Parameters cannot be an array.
+Received: ${JSON.stringify(params)}`
+    );
   }
-};
-var EventEmissionError = class extends EventSystemError {
-  constructor(message, eventType, details) {
-    super(message, "EVENT_EMISSION_ERROR", { eventType, ...details });
-    this.eventType = eventType;
-    this.name = "EventEmissionError";
+  for (const [key, value] of Object.entries(params)) {
+    const valueType = typeof value;
+    const isValidType = valueType === "string" || valueType === "number" || valueType === "boolean" || value instanceof Date || Array.isArray(value) && value.every(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v instanceof Date
+    );
+    if (!isValidType) {
+      logger42.error(`Invalid param value type for ${operation}`, { key, value, valueType });
+      throw new Error(
+        `[${operation}] Invalid value type for parameter "${key}".
+
+Allowed types: string, number, boolean, Date, or arrays of these types
+Received: ${valueType}
+Value: ${JSON.stringify(value)}`
+      );
+    }
   }
+  logger42.debug(`Operation params validation passed for ${operation}`, { params });
 };
-var EventMatchingError = class extends EventSystemError {
-  constructor(message, details) {
-    super(message, "EVENT_MATCHING_ERROR", details);
-    this.name = "EventMatchingError";
+var validateFinderName = (finder, operation) => {
+  if (!finder || typeof finder !== "string") {
+    logger42.error(`Invalid finder name for ${operation}`, { finder, type: typeof finder });
+    throw new Error(
+      `[${operation}] Finder name must be a non-empty string.
+
+Received: ${JSON.stringify(finder)}`
+    );
+  }
+  if (finder.trim().length === 0) {
+    logger42.error(`Empty finder name for ${operation}`, { finder });
+    throw new Error(
+      `[${operation}] Finder name cannot be empty or whitespace only.
+
+Received: "${finder}"`
+    );
   }
+  logger42.debug(`Finder name validation passed for ${operation}`, { finder });
 };
-function createEventSystemError(type, message, details) {
-  switch (type) {
-    case "subscription":
-      return new SubscriptionError(message, details?.subscriptionId || "unknown", details);
-    case "emission":
-      return new EventEmissionError(message, details?.eventType || "unknown", details);
-    case "matching":
-      return new EventMatchingError(message, details);
-    case "general":
-    default:
-      return new EventSystemError(message, "GENERAL_ERROR", details);
+var validateActionName = (action, operation) => {
+  if (!action || typeof action !== "string") {
+    logger42.error(`Invalid action name for ${operation}`, { action, type: typeof action });
+    throw new Error(
+      `[${operation}] Action name must be a non-empty string.
+
+Received: ${JSON.stringify(action)}`
+    );
   }
-}
-function isEventSystemError(error) {
-  return error instanceof EventSystemError;
-}
+  if (action.trim().length === 0) {
+    logger42.error(`Empty action name for ${operation}`, { action });
+    throw new Error(
+      `[${operation}] Action name cannot be empty or whitespace only.
 
-// src/event/index.ts
-var EVENT_SYSTEM_VERSION = "1.0.0";
-var SUPPORTED_EVENT_TYPES = [
-  "create",
-  "update",
-  "delete",
-  "action"
-];
-var SUPPORTED_SCOPES = [
-  "firestore",
-  "sequelize",
-  "postgresql",
-  "mysql",
-  "mongodb",
-  "redis"
-];
+Received: "${action}"`
+    );
+  }
+  logger42.debug(`Action name validation passed for ${operation}`, { action });
+};
+var validateFacetName = (facet, operation) => {
+  if (!facet || typeof facet !== "string") {
+    logger42.error(`Invalid facet name for ${operation}`, { facet, type: typeof facet });
+    throw new Error(
+      `[${operation}] Facet name must be a non-empty string.
+
+Received: ${JSON.stringify(facet)}`
+    );
+  }
+  if (facet.trim().length === 0) {
+    logger42.error(`Empty facet name for ${operation}`, { facet });
+    throw new Error(
+      `[${operation}] Facet name cannot be empty or whitespace only.
+
+Received: "${facet}"`
+    );
+  }
+  logger42.debug(`Facet name validation passed for ${operation}`, { facet });
+};
 
 // src/operations/wrappers/createOneWrapper.ts
-var logger9 = logger_default.get("operations", "wrappers", "one");
+var logger6 = logger_default.get("operations", "wrappers", "one");
 function createOneWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "one";
   return async (query, locations) => {
     if (options.debug) {
-      logger9.debug(`[${operationName}] Called with:`, { query, locations });
+      logger6.debug(`[${operationName}] Called with:`, { query, locations });
     }
     if (!options.skipValidation) {
       try {
@@ -1914,7 +1523,7 @@ function createOneWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(normalizedQuery, normalizedLocations);
       if (options.debug) {
-        logger9.debug(`[${operationName}] Result:`, result ? "found" : "not found");
+        logger6.debug(`[${operationName}] Result:`, result ? "found" : "not found");
       }
       if (result && !options.skipValidation) {
         return validatePK(result, coordinate.kta[0]);
@@ -1942,19 +1551,19 @@ function createOneWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createAllWrapper.ts
-var logger10 = logger_default.get("operations", "wrappers", "all");
+var logger7 = logger_default.get("operations", "wrappers", "all");
 function createAllWrapper(coordinate, implementation, wrapperOptions = {}) {
   const operationName = wrapperOptions.operationName || "all";
   return async (query, locations, allOptions) => {
     if (wrapperOptions.debug) {
-      logger10.debug(`[${operationName}] Called with:`, { query, locations, allOptions });
+      logger7.debug(`[${operationName}] Called with:`, { query, locations, allOptions });
     }
     if (!wrapperOptions.skipValidation) {
       validateQuery(query, operationName);
       validateLocations(locations, coordinate, operationName);
       if (allOptions && "limit" in allOptions && allOptions.limit != null) {
         if (!Number.isInteger(allOptions.limit) || allOptions.limit < 1) {
-          logger10.error(`Invalid limit parameter in ${operationName}`, {
+          logger7.error(`Invalid limit parameter in ${operationName}`, {
             component: "core",
             wrapper: "createAllWrapper",
             operation: operationName,
@@ -1978,7 +1587,7 @@ function createAllWrapper(coordinate, implementation, wrapperOptions = {}) {
     try {
       const result = await implementation(normalizedQuery, normalizedLocations, allOptions);
       if (wrapperOptions.debug) {
-        logger10.debug(`[${operationName}] Result: ${result.items.length} items, total: ${result.metadata.total}`);
+        logger7.debug(`[${operationName}] Result: ${result.items.length} items, total: ${result.metadata.total}`);
       }
       if (!wrapperOptions.skipValidation) {
         const validatedItems = validatePK(result.items, coordinate.kta[0]);
@@ -2006,12 +1615,12 @@ function createAllWrapper(coordinate, implementation, wrapperOptions = {}) {
 }
 
 // src/operations/wrappers/createGetWrapper.ts
-var logger11 = logger_default.get("operations", "wrappers", "get");
+var logger8 = logger_default.get("operations", "wrappers", "get");
 function createGetWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "get";
   return async (key) => {
     if (options.debug) {
-      logger11.debug(`[${operationName}] Called with key:`, key);
+      logger8.debug(`[${operationName}] Called with key:`, key);
     }
     if (!options.skipValidation) {
       validateKey(key, coordinate, operationName);
@@ -2019,7 +1628,7 @@ function createGetWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(key);
       if (options.debug) {
-        logger11.debug(`[${operationName}] Result:`, result ? "found" : "not found");
+        logger8.debug(`[${operationName}] Result:`, result ? "found" : "not found");
       }
       if (result && !options.skipValidation) {
         return validatePK(result, coordinate.kta[0]);
@@ -2035,7 +1644,7 @@ function createGetWrapper(coordinate, implementation, options = {}) {
         throw options.onError(error, context);
       }
       if (error instanceof NotFoundError) {
-        logger11.debug(`[${operationName}] Item not found`, {
+        logger8.debug(`[${operationName}] Item not found`, {
           component: "core",
           wrapper: "createGetWrapper",
           operation: operationName,
@@ -2045,7 +1654,7 @@ function createGetWrapper(coordinate, implementation, options = {}) {
         });
         throw error;
       }
-      logger11.error(`[${operationName}] Operation failed in wrapper`, {
+      logger8.error(`[${operationName}] Operation failed in wrapper`, {
         component: "core",
         wrapper: "createGetWrapper",
         operation: operationName,
@@ -2065,12 +1674,12 @@ function createGetWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createCreateWrapper.ts
-var logger12 = logger_default.get("operations", "wrappers", "create");
+var logger9 = logger_default.get("operations", "wrappers", "create");
 function createCreateWrapper(coordinate, implementation, wrapperOptions = {}) {
   const operationName = wrapperOptions.operationName || "create";
   return async (item, createOptions) => {
     if (wrapperOptions.debug) {
-      logger12.debug(`[${operationName}] Called with:`, { item, options: createOptions });
+      logger9.debug(`[${operationName}] Called with:`, { item, options: createOptions });
     }
     if (!wrapperOptions.skipValidation) {
       if (!item || typeof item !== "object" || Array.isArray(item)) {
@@ -2093,7 +1702,7 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
     try {
       const result = await implementation(item, createOptions);
       if (wrapperOptions.debug) {
-        logger12.debug(`[${operationName}] Created item:`, result.key);
+        logger9.debug(`[${operationName}] Created item:`, result.key);
       }
       if (!wrapperOptions.skipValidation) {
         return validatePK(result, coordinate.kta[0]);
@@ -2108,7 +1717,7 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
         };
         throw wrapperOptions.onError(error, context);
       }
-      logger12.error(`[${operationName}] Operation failed in wrapper`, {
+      logger9.error(`[${operationName}] Operation failed in wrapper`, {
         component: "core",
         wrapper: "createCreateWrapper",
         operation: operationName,
@@ -2129,12 +1738,12 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
 }
 
 // src/operations/wrappers/createUpdateWrapper.ts
-var logger13 = logger_default.get("operations", "wrappers", "update");
+var logger10 = logger_default.get("operations", "wrappers", "update");
 function createUpdateWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "update";
   return async (key, item, updateOptions) => {
     if (options.debug) {
-      logger13.debug(`[${operationName}] Called with:`, { key, item, updateOptions });
+      logger10.debug(`[${operationName}] Called with:`, { key, item, updateOptions });
     }
     if (!options.skipValidation) {
       validateKey(key, coordinate, operationName);
@@ -2150,7 +1759,7 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
     try {
       const result = await implementation(key, item, updateOptions);
       if (options.debug) {
-        logger13.debug(`[${operationName}] Updated item:`, result.key);
+        logger10.debug(`[${operationName}] Updated item:`, result.key);
       }
       if (!options.skipValidation) {
         return validatePK(result, coordinate.kta[0]);
@@ -2174,15 +1783,18 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
 }
 
 // src/operations/wrappers/createUpsertWrapper.ts
-var logger14 = logger_default.get("operations", "wrappers", "upsert");
+var logger11 = logger_default.get("operations", "wrappers", "upsert");
 function createUpsertWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "upsert";
   return async (key, item, locations, updateOptions) => {
     if (options.debug) {
-      logger14.debug(`[${operationName}] Called with:`, { key, item, locations, updateOptions });
+      logger11.debug(`[${operationName}] Called with:`, { key, item, locations, updateOptions });
     }
     if (!options.skipValidation) {
       validateKey(key, coordinate, operationName);
+      if (locations) {
+        validateLocations(locations, coordinate, operationName);
+      }
       if (!item || typeof item !== "object" || Array.isArray(item)) {
         throw new Error(
           `[${operationName}] Invalid item parameter.
@@ -2195,7 +1807,7 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
     try {
       const result = await implementation(key, item, locations, updateOptions);
       if (options.debug) {
-        logger14.debug(`[${operationName}] Upserted item:`, result.key);
+        logger11.debug(`[${operationName}] Upserted item:`, result.key);
       }
       if (!options.skipValidation) {
         return validatePK(result, coordinate.kta[0]);
@@ -2219,12 +1831,12 @@ Received: ${Array.isArray(item) ? "array" : typeof item}`
 }
 
 // src/operations/wrappers/createRemoveWrapper.ts
-var logger15 = logger_default.get("operations", "wrappers", "remove");
+var logger12 = logger_default.get("operations", "wrappers", "remove");
 function createRemoveWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "remove";
   return async (key) => {
     if (options.debug) {
-      logger15.debug(`[${operationName}] Called with key:`, key);
+      logger12.debug(`[${operationName}] Called with key:`, key);
     }
     if (!options.skipValidation) {
       validateKey(key, coordinate, operationName);
@@ -2232,7 +1844,7 @@ function createRemoveWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(key);
       if (options.debug) {
-        logger15.debug(`[${operationName}] Removed item:`, key);
+        logger12.debug(`[${operationName}] Removed item:`, key);
       }
       return result;
     } catch (error) {
@@ -2244,7 +1856,7 @@ function createRemoveWrapper(coordinate, implementation, options = {}) {
         };
         throw options.onError(error, context);
       }
-      logger15.error(`[${operationName}] Operation failed in wrapper`, {
+      logger12.error(`[${operationName}] Operation failed in wrapper`, {
         component: "core",
         wrapper: "createRemoveWrapper",
         operation: operationName,
@@ -2264,7 +1876,7 @@ function createRemoveWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createFindWrapper.ts
-var logger16 = logger_default.get("operations", "wrappers", "find");
+var logger13 = logger_default.get("operations", "wrappers", "find");
 function isFindOperationResult(value) {
   return value && typeof value === "object" && "items" in value && "metadata" in value && Array.isArray(value.items) && value.metadata && typeof value.metadata === "object" && "total" in value.metadata;
 }
@@ -2296,7 +1908,7 @@ function createFindWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "find";
   return async (finder, params, locations, findOptions) => {
     if (options.debug) {
-      logger16.debug(`[${operationName}] Called:`, { finder, params, locations, findOptions });
+      logger13.debug(`[${operationName}] Called:`, { finder, params, locations, findOptions });
     }
     if (!options.skipValidation) {
       validateFinderName(finder, operationName);
@@ -2309,7 +1921,7 @@ function createFindWrapper(coordinate, implementation, options = {}) {
       const result = await implementation(finder, normalizedParams, normalizedLocations, findOptions);
       if (isFindOperationResult(result)) {
         if (options.debug) {
-          logger16.debug(`[${operationName}] Finder "${finder}" opted-in to pagination, found ${result.items.length} items (total: ${result.metadata.total})`);
+          logger13.debug(`[${operationName}] Finder "${finder}" opted-in to pagination, found ${result.items.length} items (total: ${result.metadata.total})`);
         }
         if (!options.skipValidation) {
           const validatedItems = validatePK(result.items, coordinate.kta[0]);
@@ -2321,7 +1933,7 @@ function createFindWrapper(coordinate, implementation, options = {}) {
         return result;
       } else {
         if (options.debug) {
-          logger16.debug(`[${operationName}] Finder "${finder}" using legacy signature, applying post-processing pagination`);
+          logger13.debug(`[${operationName}] Finder "${finder}" using legacy signature, applying post-processing pagination`);
         }
         let validatedItems;
         if (!options.skipValidation) {
@@ -2343,7 +1955,7 @@ function createFindWrapper(coordinate, implementation, options = {}) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       const errorStack = error instanceof Error ? error.stack : null;
       const errorCause = error instanceof Error && "cause" in error ? error.cause : null;
-      logger16.error(`[${operationName}] Operation failed for finder "${finder}"`, {
+      logger13.error(`[${operationName}] Operation failed for finder "${finder}"`, {
         finder,
         params,
         locations,
@@ -2361,12 +1973,12 @@ function createFindWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createFindOneWrapper.ts
-var logger17 = logger_default.get("operations", "wrappers", "findOne");
+var logger14 = logger_default.get("operations", "wrappers", "findOne");
 function createFindOneWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "findOne";
   return async (finder, params, locations) => {
     if (options.debug) {
-      logger17.debug(`[${operationName}] Called:`, { finder, params, locations });
+      logger14.debug(`[${operationName}] Called:`, { finder, params, locations });
     }
     if (!options.skipValidation) {
       validateFinderName(finder, operationName);
@@ -2378,7 +1990,7 @@ function createFindOneWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(finder, normalizedParams, normalizedLocations);
       if (options.debug) {
-        logger17.debug(`[${operationName}] Result for finder "${finder}":`, result ? "found" : "not found");
+        logger14.debug(`[${operationName}] Result for finder "${finder}":`, result ? "found" : "not found");
       }
       if (result && !options.skipValidation) {
         return validatePK(result, coordinate.kta[0]);
@@ -2402,12 +2014,12 @@ function createFindOneWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createActionWrapper.ts
-var logger18 = logger_default.get("operations", "wrappers", "action");
+var logger15 = logger_default.get("operations", "wrappers", "action");
 function createActionWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "action";
   return async (key, action, params) => {
     if (options.debug) {
-      logger18.debug(`[${operationName}] Called:`, { key, action, params });
+      logger15.debug(`[${operationName}] Called:`, { key, action, params });
     }
     if (!options.skipValidation) {
       validateKey(key, coordinate, operationName);
@@ -2418,7 +2030,7 @@ function createActionWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(key, action, normalizedParams);
       if (options.debug) {
-        logger18.debug(`[${operationName}] Action "${action}" completed:`, {
+        logger15.debug(`[${operationName}] Action "${action}" completed:`, {
           itemKey: result[0].key,
           affectedKeys: result[1].length
         });
@@ -2437,7 +2049,7 @@ function createActionWrapper(coordinate, implementation, options = {}) {
         };
         throw options.onError(error, context);
       }
-      logger18.error(`[${operationName}] Action failed in wrapper`, {
+      logger15.error(`[${operationName}] Action failed in wrapper`, {
         component: "core",
         wrapper: "createActionWrapper",
         operation: operationName,
@@ -2459,12 +2071,12 @@ function createActionWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createAllActionWrapper.ts
-var logger19 = logger_default.get("operations", "wrappers", "allAction");
+var logger16 = logger_default.get("operations", "wrappers", "allAction");
 function createAllActionWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "allAction";
   return async (action, params, locations) => {
     if (options.debug) {
-      logger19.debug(`[${operationName}] Called:`, { action, params, locations });
+      logger16.debug(`[${operationName}] Called:`, { action, params, locations });
     }
     if (!options.skipValidation) {
       validateActionName(action, operationName);
@@ -2476,7 +2088,7 @@ function createAllActionWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(action, normalizedParams, normalizedLocations);
       if (options.debug) {
-        logger19.debug(`[${operationName}] Action "${action}" completed:`, {
+        logger16.debug(`[${operationName}] Action "${action}" completed:`, {
           itemsAffected: result[0].length,
           affectedKeys: result[1].length
         });
@@ -2504,12 +2116,12 @@ function createAllActionWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createFacetWrapper.ts
-var logger20 = logger_default.get("operations", "wrappers", "facet");
+var logger17 = logger_default.get("operations", "wrappers", "facet");
 function createFacetWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "facet";
   return async (key, facet, params) => {
     if (options.debug) {
-      logger20.debug(`[${operationName}] Called:`, { key, facet, params });
+      logger17.debug(`[${operationName}] Called:`, { key, facet, params });
     }
     if (!options.skipValidation) {
       validateKey(key, coordinate, operationName);
@@ -2520,7 +2132,7 @@ function createFacetWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(key, facet, normalizedParams);
       if (options.debug) {
-        logger20.debug(`[${operationName}] Facet "${facet}" completed`);
+        logger17.debug(`[${operationName}] Facet "${facet}" completed`);
       }
       return result;
     } catch (error) {
@@ -2541,12 +2153,12 @@ function createFacetWrapper(coordinate, implementation, options = {}) {
 }
 
 // src/operations/wrappers/createAllFacetWrapper.ts
-var logger21 = logger_default.get("operations", "wrappers", "allFacet");
+var logger18 = logger_default.get("operations", "wrappers", "allFacet");
 function createAllFacetWrapper(coordinate, implementation, options = {}) {
   const operationName = options.operationName || "allFacet";
   return async (facet, params, locations) => {
     if (options.debug) {
-      logger21.debug(`[${operationName}] Called:`, { facet, params, locations });
+      logger18.debug(`[${operationName}] Called:`, { facet, params, locations });
     }
     if (!options.skipValidation) {
       validateFacetName(facet, operationName);
@@ -2558,7 +2170,7 @@ function createAllFacetWrapper(coordinate, implementation, options = {}) {
     try {
       const result = await implementation(facet, normalizedParams, normalizedLocations);
       if (options.debug) {
-        logger21.debug(`[${operationName}] Facet "${facet}" completed`);
+        logger18.debug(`[${operationName}] Facet "${facet}" completed`);
       }
       return result;
     } catch (error) {
@@ -2577,6 +2189,247 @@ function createAllFacetWrapper(coordinate, implementation, options = {}) {
     }
   };
 }
+
+// src/event/events.ts
+function isCreateEvent(event) {
+  return event.eventType === "create";
+}
+function isUpdateEvent(event) {
+  return event.eventType === "update";
+}
+function isDeleteEvent(event) {
+  return event.eventType === "delete";
+}
+function isActionEvent(event) {
+  return event.eventType === "action";
+}
+
+// src/event/subscription.ts
+function isItemSubscription(subscription) {
+  return "key" in subscription;
+}
+function isLocationSubscription(subscription) {
+  return "kta" in subscription && "location" in subscription;
+}
+function generateSubscriptionId() {
+  return `sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function createItemSubscription(key, options) {
+  return {
+    id: generateSubscriptionId(),
+    key,
+    eventTypes: options?.eventTypes,
+    scopes: options?.scopes,
+    query: options?.query
+  };
+}
+function createLocationSubscription(kta, location, options) {
+  return {
+    id: generateSubscriptionId(),
+    kta,
+    location,
+    eventTypes: options?.eventTypes,
+    scopes: options?.scopes,
+    query: options?.query
+  };
+}
+
+// src/event/matching.ts
+function doesEventMatchSubscription(event, subscription) {
+  if (!doesScopeMatch(event.scopes, subscription.scopes)) {
+    return false;
+  }
+  if (!doesEventTypeMatch(event.eventType, subscription.eventTypes)) {
+    return false;
+  }
+  if (isItemSubscription(subscription)) {
+    return doesKeyMatch(event.key, subscription.key);
+  } else if (isLocationSubscription(subscription)) {
+    return doesKeyMatchLocation(event.key, subscription.kta, subscription.location);
+  }
+  return false;
+}
+function doesScopeMatch(eventScopes, subscriptionScopes) {
+  if (!subscriptionScopes || subscriptionScopes.length === 0) {
+    return true;
+  }
+  return subscriptionScopes.some(
+    (requiredScope) => eventScopes.includes(requiredScope)
+  );
+}
+function doesEventTypeMatch(eventType, subscriptionEventTypes) {
+  if (!subscriptionEventTypes || subscriptionEventTypes.length === 0) {
+    return true;
+  }
+  return subscriptionEventTypes.includes(eventType);
+}
+function doesKeyMatch(eventKey, subscriptionKey) {
+  if (isPriKey(eventKey) && isPriKey(subscriptionKey)) {
+    return eventKey.pk === subscriptionKey.pk && eventKey.kt === subscriptionKey.kt;
+  }
+  if (isComKey(eventKey) && isComKey(subscriptionKey)) {
+    const eventComKey = eventKey;
+    const subscriptionComKey = subscriptionKey;
+    if (eventComKey.pk !== subscriptionComKey.pk || eventComKey.kt !== subscriptionComKey.kt) {
+      return false;
+    }
+    if (eventComKey.loc.length !== subscriptionComKey.loc.length) {
+      return false;
+    }
+    return eventComKey.loc.every((eventLocKey, index) => {
+      const subLocKey = subscriptionComKey.loc[index];
+      return eventLocKey.lk === subLocKey.lk && eventLocKey.kt === subLocKey.kt;
+    });
+  }
+  return false;
+}
+function doesKeyMatchLocation(eventKey, subscriptionKta, subscriptionLocation) {
+  const targetItemType = subscriptionKta[subscriptionKta.length - 1];
+  if (eventKey.kt !== targetItemType) {
+    return false;
+  }
+  if (isPriKey(eventKey)) {
+    return subscriptionLocation.length === 0;
+  }
+  if (isComKey(eventKey)) {
+    const comKey = eventKey;
+    return doesLocationMatch(comKey.loc, subscriptionLocation, subscriptionKta);
+  }
+  return false;
+}
+function doesLocationMatch(eventLocation, subscriptionLocation, _subscriptionKta) {
+  if (subscriptionLocation.length === 0) {
+    return true;
+  }
+  if (eventLocation.length < subscriptionLocation.length) {
+    return false;
+  }
+  for (let i = 0; i < subscriptionLocation.length; i++) {
+    const eventLocKey = eventLocation[i];
+    const subLocKey = subscriptionLocation[i];
+    if (!eventLocKey || !subLocKey) {
+      return false;
+    }
+    if (eventLocKey.lk !== subLocKey.lk || eventLocKey.kt !== subLocKey.kt) {
+      return false;
+    }
+  }
+  return true;
+}
+function findMatchingSubscriptions(event, subscriptions) {
+  return subscriptions.filter(
+    (subscription) => doesEventMatchSubscription(event, subscription)
+  );
+}
+function extractLocationValues(location) {
+  return location.map((locKey) => String(locKey.lk));
+}
+function compareLocationValues(location1, location2) {
+  if (location1.length !== location2.length) {
+    return false;
+  }
+  return location1.every((locKey1, index) => {
+    const locKey2 = location2[index];
+    return locKey1.lk === locKey2.lk && locKey1.kt === locKey2.kt;
+  });
+}
+
+// src/event/types.ts
+var STANDARD_EVENT_TYPES = {
+  CREATE: "create",
+  UPDATE: "update",
+  DELETE: "delete",
+  ACTION: "action"
+};
+var STANDARD_SCOPES = {
+  FIRESTORE: "firestore",
+  SEQUELIZE: "sequelize",
+  POSTGRESQL: "postgresql",
+  MYSQL: "mysql",
+  MONGODB: "mongodb",
+  REDIS: "redis"
+};
+var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
+  SubscriptionStatus2["PENDING"] = "pending";
+  SubscriptionStatus2["ACTIVE"] = "active";
+  SubscriptionStatus2["PAUSED"] = "paused";
+  SubscriptionStatus2["ERROR"] = "error";
+  SubscriptionStatus2["CANCELLED"] = "cancelled";
+  return SubscriptionStatus2;
+})(SubscriptionStatus || {});
+var DEFAULT_EVENT_CONFIG = {
+  maxBatchSize: 100,
+  maxBatchWaitTime: 50,
+  // 50ms
+  maxRetryAttempts: 3,
+  retryDelay: 1e3,
+  // 1 second
+  enableStats: true,
+  maxSubscriptions: 1e3,
+  subscriptionCleanupInterval: 3e5
+  // 5 minutes
+};
+var EventSystemError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "EventSystemError";
+  }
+};
+var SubscriptionError = class extends EventSystemError {
+  constructor(message, subscriptionId, details) {
+    super(message, "SUBSCRIPTION_ERROR", { subscriptionId, ...details });
+    this.subscriptionId = subscriptionId;
+    this.name = "SubscriptionError";
+  }
+};
+var EventEmissionError = class extends EventSystemError {
+  constructor(message, eventType, details) {
+    super(message, "EVENT_EMISSION_ERROR", { eventType, ...details });
+    this.eventType = eventType;
+    this.name = "EventEmissionError";
+  }
+};
+var EventMatchingError = class extends EventSystemError {
+  constructor(message, details) {
+    super(message, "EVENT_MATCHING_ERROR", details);
+    this.name = "EventMatchingError";
+  }
+};
+function createEventSystemError(type, message, details) {
+  switch (type) {
+    case "subscription":
+      return new SubscriptionError(message, details?.subscriptionId || "unknown", details);
+    case "emission":
+      return new EventEmissionError(message, details?.eventType || "unknown", details);
+    case "matching":
+      return new EventMatchingError(message, details);
+    case "general":
+    default:
+      return new EventSystemError(message, "GENERAL_ERROR", details);
+  }
+}
+function isEventSystemError(error) {
+  return error instanceof EventSystemError;
+}
+
+// src/event/index.ts
+var EVENT_SYSTEM_VERSION = "1.0.0";
+var SUPPORTED_EVENT_TYPES = [
+  "create",
+  "update",
+  "delete",
+  "action"
+];
+var SUPPORTED_SCOPES = [
+  "firestore",
+  "sequelize",
+  "postgresql",
+  "mysql",
+  "mongodb",
+  "redis"
+];
 export {
   AItemService,
   ActionError,
@@ -2649,7 +2502,6 @@ export {
   isComKey,
   isComKeyEqual,
   isComKeyEqualNormalized,
-  isCondition,
   isCreateEvent,
   isDeleteEvent,
   isEventSystemError,
@@ -2661,8 +2513,6 @@ export {
   isLocKeyEqual,
   isLocKeyEqualNormalized,
   isLocationSubscription,
-  isComKey2 as isOperationComKey,
-  isPriKey2 as isOperationPriKey,
   isPriItem,
   isPriKey,
   isPriKeyEqual,
@@ -2673,7 +2523,6 @@ export {
   isValidItemKey,
   isValidLocKey,
   isValidLocKeyArray,
-  isValidLocations,
   isValidPriKey,
   itemKeyToLocKeyArray,
   lkaToIK,
@@ -2681,17 +2530,5 @@ export {
   paramsToQuery,
   primaryType,
   queryToParams,
-  toKeyTypeArray,
-  validateActionName,
-  validateComKey,
-  validateFacetName,
-  validateFinderName,
-  validateKey,
-  validateKeys,
-  validateLocations,
-  validateOperationParams,
-  validatePK,
-  validatePriKey,
-  validateQuery,
-  validateSchema
+  toKeyTypeArray
 };