@shirudo/ddd-kit 0.16.0 → 1.0.0-rc.2

package/dist/index.js

@@ -1,2 +1,1145 @@
-var F=Object.defineProperty;var o=(t,e)=>F(t,"name",{value:e,configurable:true});function Z(t,e=0){return {state:t,version:e,pendingEvents:[]}}o(Z,"aggregate");function ee(t,e){return {...t,pendingEvents:[...t.pendingEvents,e]}}o(ee,"withEvent");function te(t){return {...t,version:t.version+1}}o(te,"bump");function M(t,e,r){return {type:t,payload:e,occurredAt:r?.occurredAt??new Date,version:r?.version??1,metadata:r?.metadata}}o(M,"createDomainEvent");function re(t,e,r,n){return M(t,e,{...n,metadata:r})}o(re,"createDomainEventWithMetadata");function ne(t,e){return {...t.metadata??{},...e??{}}}o(ne,"copyMetadata");function oe(...t){return Object.assign({},...t.filter(Boolean))}o(oe,"mergeMetadata");function se(t,e){return t.id===e.id&&t.version===e.version}o(se,"sameAggregate");function v(t,e){if(e.endsWith("Array]")||ArrayBuffer.isView(t)||e==="[object ArrayBuffer]"||e==="[object SharedArrayBuffer]")return  true;let r=t.constructor;if(r&&typeof r=="function"){let a=r.name;if(a&&typeof globalThis<"u"&&a in globalThis&&globalThis[a]===r){let s=Object.getPrototypeOf(t);if(s!==Object.prototype&&s!==null)return  true}}return new Set(["[object Date]","[object RegExp]","[object Map]","[object Set]","[object WeakMap]","[object WeakSet]","[object Promise]","[object Error]","[object Boolean]","[object Number]","[object String]"]).has(e)}o(v,"isBuiltInObject");var O=Object.prototype,b=O.toString,K=O.hasOwnProperty;function m(t,e){return h(t,e,new WeakMap)}o(m,"deepEqual");function h(t,e,r){if(t===e)return  true;let n=typeof t,a=typeof e;if(n!=="object"||t===null||a!=="object"||e===null)return n==="number"&&a==="number"?Number.isNaN(t)&&Number.isNaN(e):false;let s=t,i=e,g=r.get(s);if(g!==void 0)return g===i;if(r.set(s,i),ArrayBuffer.isView(s)||ArrayBuffer.isView(i)){if(!ArrayBuffer.isView(s)||!ArrayBuffer.isView(i))return  false;let c=b.call(s),l=b.call(i);if(c!==l)return  false;if(c==="[object DataView]"){let T=s,P=i;if(T.byteLength!==P.byteLength)return  false;let Q=T.byteLength;for(let R=0;R<Q;R++)if(T.getUint8(R)!==P.getUint8(R))return  false;return  true}let u=s,d=i,p=u.length;if(p!==d.length)return  false;for(let T=0;T<p;T++)if(u[T]!==d[T])return  false;return  true}let y=b.call(s),x=b.call(i);if(y!==x)return  false;switch(y){case "[object Array]":{let c=s,l=i,u=c.length;if(u!==l.length)return  false;for(let d=0;d<u;d++)if(!h(c[d],l[d],r))return  false;return  true}case "[object Map]":{let c=s,l=i;if(c.size!==l.size)return  false;for(let[u,d]of c){if(!l.has(u))return  false;let p=l.get(u);if(!h(d,p,r))return  false}return  true}case "[object Set]":{let c=s,l=i;if(c.size!==l.size)return  false;for(let u of c)if(!l.has(u))return  false;return  true}case "[object Date]":{let c=s.getTime(),l=i.getTime();return c===l}case "[object RegExp]":{let c=s,l=i;return c.source===l.source&&c.flags===l.flags}case "[object Boolean]":case "[object Number]":case "[object String]":return s.valueOf()===i.valueOf();default:{if(v(s,y)&&v(i,x))return s===i;let c=Object.keys(s),l=Object.keys(i),u=Object.getOwnPropertySymbols(s),d=Object.getOwnPropertySymbols(i);if(c.length!==l.length||u.length!==d.length)return  false;for(let p of c)if(!K.call(i,p))return  false;for(let p of u)if(!Object.getOwnPropertySymbols(i).includes(p))return  false;for(let p of c)if(!h(s[p],i[p],r))return  false;for(let p of u)if(!h(s[p],i[p],r))return  false;return  true}}}o(h,"deepEqualInner");var w=class{static{o(this,"Entity");}id;get state(){return this._state}_state;constructor(e,r){if(e==null)throw new Error("Entity ID cannot be null or undefined");this.id=e,this._state=r,this.validateState(this._state);}validateState(e){}setState(e){this.validateState(e),this._state=e;}};function Ee(t,e){return m(t.id,e.id)}o(Ee,"sameEntity");function me(t,e){return t.find(r=>m(r.id,e))}o(me,"findEntityById");function Te(t,e){return t.some(r=>m(r.id,e))}o(Te,"hasEntityId");function ye(t,e){return t.filter(r=>!m(r.id,e))}o(ye,"removeEntityById");function ge(t,e,r){return t.map(n=>m(n.id,e)?r(n):n)}o(ge,"updateEntityById");function ve(t,e,r){return t.map(n=>m(n.id,e)?r:n)}o(ve,"replaceEntityById");function he(t){return t.map(e=>e.id)}o(he,"entityIds");var k=class extends w{static{o(this,"AggregateRoot");}version=0;_config;_autoVersionBump;_domainEvents=[];get domainEvents(){return this._domainEvents}clearDomainEvents(){this._domainEvents=[];}constructor(e,r,n){super(e,r),this._config=n??{},this._autoVersionBump=this._config.autoVersionBump??false;}addDomainEvent(e){this._domainEvents.push(e);}bumpVersion(){this.version=this.version+1;}setState(e,r){super.setState(e),(r??this._autoVersionBump)&&this.bumpVersion();}createSnapshot(){return {state:{...this._state},version:this.version,snapshotAt:new Date}}restoreFromSnapshot(e){this.validateState(e.state),this._state=e.state,this.version=e.version;}};function E(t){return {ok:true,value:t}}o(E,"ok");function f(t){return {ok:false,error:t}}o(f,"err");var j=class extends k{static{o(this,"AggregateEventSourced");}_eventConfig;_eventAutoVersionBump;constructor(e,r,n){super(e,r,n),this._eventConfig=n??{},this._eventAutoVersionBump=this._eventConfig.autoVersionBump??true;}get pendingEvents(){return this.domainEvents}clearPendingEvents(){this.clearDomainEvents();}validateEvent(e){return E(true)}apply(e,r=true){let n=this.validateEvent(e);if(!n.ok)return f(`Event validation failed for ${e.type}: ${n.error}`);let a=this.handlers[e.type];return a?(this._state=a(this._state,e),r&&(this.addDomainEvent(e),this._eventAutoVersionBump&&(this.version=this.version+1)),E()):f(`Missing handler for event type: ${e.type}`)}applyUnsafe(e,r=true){let n=this.validateEvent(e);if(!n.ok)throw new Error(`Event validation failed for ${e.type}: ${n.error}`);let a=this.handlers[e.type];if(!a)throw new Error(`Missing handler for event type: ${e.type}`);this._state=a(this._state,e),r&&(this.addDomainEvent(e),this._eventAutoVersionBump&&(this.version=this.version+1));}bumpVersion(){this.version=this.version+1;}loadFromHistory(e){for(let r of e){let n=this.apply(r,false);if(!n.ok)return n}return this.version=e.length,E()}hasPendingEvents(){return this.domainEvents.length>0}getEventCount(){return this.domainEvents.length}getLatestEvent(){let e=this.domainEvents;return e[e.length-1]}restoreFromSnapshotWithEvents(e,r){this._state=e.state,this.version=e.version;for(let n of r){let a=this.apply(n,false);if(!a.ok)return a}return this.version=e.version+r.length,E()}};var V=class{static{o(this,"CommandBus");}handlers=new Map;register(e,r){this.handlers.set(e,r);}async execute(e){let r=this.handlers.get(e.type);if(!r)return f(`No handler registered for command type: ${e.type}`);try{return await r(e)}catch(n){return f(n instanceof Error?n.message:String(n))}}};function Je(t,e){return t.uow.transactional(async()=>{let{result:r,events:n}=await e();return await t.outbox.add(n),t.bus&&await t.bus.publish(n),r})}o(Je,"withCommit");var B=class{static{o(this,"QueryBus");}handlers=new Map;register(e,r){this.handlers.set(e,r);}async execute(e){let r=this.handlers.get(e.type);if(!r)return f(`No handler registered for query type: ${e.type}`);try{let n=await r(e);return E(n)}catch(n){return f(n instanceof Error?n.message:String(n))}}async executeUnsafe(e){let r=this.handlers.get(e.type);if(!r)throw new Error(`No handler registered for query type: ${e.type}`);return r(e)}};function rt(t,e){return t?E(true):f(e)}o(rt,"guard");var D=class{static{o(this,"EventBusImpl");}handlers=new Map;subscribe(e,r){let n=e;this.handlers.has(n)||this.handlers.set(n,new Set);let a=this.handlers.get(n);return a.add(r),()=>{a.delete(r),a.size===0&&this.handlers.delete(n);}}once(e){return new Promise(r=>{let n=this.subscribe(e,a=>{n(),r(a);});})}async publish(e){let r=[];for(let n of e){let a=this.handlers.get(n.type);if(a){let s=await Promise.allSettled(Array.from(a).map(i=>i(n)));for(let i of s)i.status==="rejected"&&r.push(i.reason instanceof Error?i.reason:new Error(String(i.reason)));}}if(r.length===1)throw r[0];if(r.length>1)throw new AggregateError(r,"Multiple event handlers failed")}};function S(t,e){return I(t,e,[],new WeakMap)}o(S,"deepOmit");function I(t,e,r,n){if(t===null||typeof t!=="object")return t;let s=t,i=n.get(s);if(i!==void 0)return i;let g=Object.prototype.toString.call(s);if(g==="[object Array]"){let u=s,d=new Array(u.length);n.set(s,d);for(let p=0;p<u.length;p++)r.push(p),d[p]=I(u[p],e,r,n),r.pop();return d}if(v(s,g))return t;let y=Object.create(Object.getPrototypeOf(s));n.set(s,y);let x=Object.keys(s),c=Object.getOwnPropertySymbols(s),l=[...x,...c];for(let u of l)X(u,r,e)||(r.push(u),y[u]=I(s[u],e,r,n),r.pop());return y}o(I,"omitInternal");function X(t,e,r){return !!(r.ignoreKeys?.includes(t)||r.ignoreKeyPredicate?.(t,e))}o(X,"shouldIgnoreKey");function _(t,e,r){let n=S(t,r),a=S(e,r);return m(n,a)}o(_,"deepEqualExcept");function A(t,e=new WeakSet){if(t===null||typeof t!="object"||e.has(t))return t;e.add(t);let r=Object.getOwnPropertyNames(t);for(let n of r){let a=t[n];a&&(typeof a=="object"||Array.isArray(a))&&A(a,e);}return Object.freeze(t)}o(A,"deepFreeze");function C(t){return A({...t})}o(C,"vo");function yt(t,e){return m(t,e)}o(yt,"voEquals");function gt(t,e,r){return _(t,e,r)}o(gt,"voEqualsExcept");function vt(t,e,r){return e(t)?E(C(t)):f(r??`Validation failed for value object: ${JSON.stringify(t)}`)}o(vt,"voWithValidation");function ht(t,e,r){if(!e(t))throw new Error(r??`Validation failed for value object: ${JSON.stringify(t)}`);return C(t)}o(ht,"voWithValidationUnsafe");var U=class{static{o(this,"ValueObject");}props;constructor(e){this.validate(e),this.props=A({...e});}validate(e){}equals(e){return e==null||this.constructor!==e.constructor?false:m(this.props,e.props)}clone(e){let r=this.constructor;return new r({...this.props,...e||{}})}toJSON(){return this.props}};export{j as AggregateEventSourced,k as AggregateRoot,V as CommandBus,w as Entity,D as EventBusImpl,B as QueryBus,U as ValueObject,Z as aggregate,te as bump,ne as copyMetadata,M as createDomainEvent,re as createDomainEventWithMetadata,A as deepFreeze,he as entityIds,me as findEntityById,rt as guard,Te as hasEntityId,oe as mergeMetadata,ye as removeEntityById,ve as replaceEntityById,se as sameAggregate,Ee as sameEntity,ge as updateEntityById,C as vo,yt as voEquals,gt as voEqualsExcept,vt as voWithValidation,ht as voWithValidationUnsafe,Je as withCommit,ee as withEvent};//# sourceMappingURL=index.js.map
+import { err, ok } from '@shirudo/result';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/utils/array/is-built-in.ts
+var BUILT_IN_TAGS = /* @__PURE__ */ new Set([
+  "[object Date]",
+  "[object RegExp]",
+  "[object Map]",
+  "[object Set]",
+  "[object WeakMap]",
+  "[object WeakSet]",
+  "[object Promise]",
+  "[object Error]",
+  "[object Boolean]",
+  "[object Number]",
+  "[object String]",
+  "[object ArrayBuffer]",
+  "[object SharedArrayBuffer]",
+  "[object DataView]"
+]);
+function isBuiltInObject(obj, tag) {
+  if (tag.endsWith("Array]")) return true;
+  if (ArrayBuffer.isView(obj)) return true;
+  return BUILT_IN_TAGS.has(tag);
+}
+__name(isBuiltInObject, "isBuiltInObject");
+
+// src/utils/array/deep-equal.ts
+var objProto = Object.prototype;
+var objToString = objProto.toString;
+var objHasOwn = objProto.hasOwnProperty;
+function deepEqual(a, b) {
+  return deepEqualInner(a, b, /* @__PURE__ */ new WeakMap());
+}
+__name(deepEqual, "deepEqual");
+function deepEqualInner(a, b, visited) {
+  if (a === b) return true;
+  const typeA = typeof a;
+  const typeB = typeof b;
+  if (typeA !== "object" || a === null || typeB !== "object" || b === null) {
+    if (typeA === "number" && typeB === "number") {
+      return Number.isNaN(a) && Number.isNaN(b);
+    }
+    return false;
+  }
+  const objA = a;
+  const objB = b;
+  let cachedBs = visited.get(objA);
+  if (cachedBs?.has(objB)) {
+    return true;
+  }
+  if (!cachedBs) {
+    cachedBs = /* @__PURE__ */ new WeakSet();
+    visited.set(objA, cachedBs);
+  }
+  cachedBs.add(objB);
+  if (ArrayBuffer.isView(objA) || ArrayBuffer.isView(objB)) {
+    if (!ArrayBuffer.isView(objA) || !ArrayBuffer.isView(objB)) return false;
+    const tagA2 = objToString.call(objA);
+    const tagB2 = objToString.call(objB);
+    if (tagA2 !== tagB2) return false;
+    if (tagA2 === "[object DataView]") {
+      const viewA = objA;
+      const viewB = objB;
+      if (viewA.byteLength !== viewB.byteLength) return false;
+      const len2 = viewA.byteLength;
+      for (let i = 0; i < len2; i++) {
+        if (viewA.getUint8(i) !== viewB.getUint8(i)) return false;
+      }
+      return true;
+    }
+    const arrA = objA;
+    const arrB = objB;
+    const len = arrA.length;
+    if (len !== arrB.length) return false;
+    for (let i = 0; i < len; i++) {
+      if (arrA[i] !== arrB[i]) return false;
+    }
+    return true;
+  }
+  const tagA = objToString.call(objA);
+  const tagB = objToString.call(objB);
+  if (tagA !== tagB) return false;
+  switch (tagA) {
+    case "[object Array]": {
+      const arrA = objA;
+      const arrB = objB;
+      const len = arrA.length;
+      if (len !== arrB.length) return false;
+      for (let i = 0; i < len; i++) {
+        if (!deepEqualInner(arrA[i], arrB[i], visited)) return false;
+      }
+      return true;
+    }
+    case "[object Map]": {
+      const mapA = objA;
+      const mapB = objB;
+      if (mapA.size !== mapB.size) return false;
+      for (const [key, valA] of mapA) {
+        if (!mapB.has(key)) return false;
+        const valB = mapB.get(key);
+        if (!deepEqualInner(valA, valB, visited)) return false;
+      }
+      return true;
+    }
+    case "[object Set]": {
+      const setA = objA;
+      const setB = objB;
+      if (setA.size !== setB.size) return false;
+      for (const value of setA) {
+        if (!setB.has(value)) return false;
+      }
+      return true;
+    }
+    case "[object Date]": {
+      const timeA = objA.getTime();
+      const timeB = objB.getTime();
+      return timeA === timeB;
+    }
+    case "[object RegExp]": {
+      const regA = objA;
+      const regB = objB;
+      return regA.source === regB.source && regA.flags === regB.flags;
+    }
+    case "[object Boolean]":
+    case "[object Number]":
+    case "[object String]": {
+      return objA.valueOf() === objB.valueOf();
+    }
+    default: {
+      if (isBuiltInObject(objA, tagA) && isBuiltInObject(objB, tagB)) {
+        return objA === objB;
+      }
+      const recA = objA;
+      const recB = objB;
+      const stringKeysA = Object.keys(objA);
+      const stringKeysB = Object.keys(objB);
+      if (stringKeysA.length !== stringKeysB.length) return false;
+      const symbolKeysA = Object.getOwnPropertySymbols(objA);
+      const symbolKeysB = Object.getOwnPropertySymbols(objB);
+      if (symbolKeysA.length !== symbolKeysB.length) return false;
+      const symbolKeysBSet = new Set(symbolKeysB);
+      for (const key of stringKeysA) {
+        if (!objHasOwn.call(objB, key)) return false;
+      }
+      for (const key of symbolKeysA) {
+        if (!symbolKeysBSet.has(key)) return false;
+      }
+      for (const key of stringKeysA) {
+        if (!deepEqualInner(recA[key], recB[key], visited)) {
+          return false;
+        }
+      }
+      for (const key of symbolKeysA) {
+        if (!deepEqualInner(recA[key], recB[key], visited)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+__name(deepEqualInner, "deepEqualInner");
+
+// src/utils/array/deep-omit.ts
+function deepOmit(value, options) {
+  const visited = /* @__PURE__ */ new WeakMap();
+  const ignoreKeys = options.ignoreKeys ? new Set(options.ignoreKeys) : void 0;
+  return omitInternal(value, options, ignoreKeys, [], visited);
+}
+__name(deepOmit, "deepOmit");
+function omitInternal(value, options, ignoreKeys, path, visited) {
+  if (value === null) return value;
+  if (typeof value !== "object") return value;
+  const obj = value;
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const tag = Object.prototype.toString.call(obj);
+  if (tag === "[object Array]") {
+    const arr = obj;
+    const clone2 = new Array(arr.length);
+    visited.set(obj, clone2);
+    for (let i = 0; i < arr.length; i++) {
+      path.push(i);
+      clone2[i] = omitInternal(arr[i], options, ignoreKeys, path, visited);
+      path.pop();
+    }
+    return clone2;
+  }
+  if (isBuiltInObject(obj, tag)) {
+    const builtInClone = cloneBuiltIn(obj, tag);
+    visited.set(obj, builtInClone);
+    return builtInClone;
+  }
+  const clone = Object.create(Object.getPrototypeOf(obj));
+  visited.set(obj, clone);
+  const stringKeys = Object.keys(obj);
+  const symbolKeys = Object.getOwnPropertySymbols(obj);
+  for (const key of stringKeys) {
+    if (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;
+    path.push(key);
+    assignOwn(
+      clone,
+      key,
+      omitInternal(
+        obj[key],
+        options,
+        ignoreKeys,
+        path,
+        visited
+      )
+    );
+    path.pop();
+  }
+  for (const key of symbolKeys) {
+    if (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;
+    path.push(key);
+    assignOwn(
+      clone,
+      key,
+      omitInternal(
+        obj[key],
+        options,
+        ignoreKeys,
+        path,
+        visited
+      )
+    );
+    path.pop();
+  }
+  return clone;
+}
+__name(omitInternal, "omitInternal");
+function assignOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+__name(assignOwn, "assignOwn");
+function cloneBuiltIn(obj, tag) {
+  switch (tag) {
+    case "[object Date]":
+      return new Date(obj.getTime());
+    case "[object RegExp]": {
+      const re = obj;
+      const copy = new RegExp(re.source, re.flags);
+      copy.lastIndex = re.lastIndex;
+      return copy;
+    }
+    case "[object Map]": {
+      const m = obj;
+      return new Map(m);
+    }
+    case "[object Set]": {
+      const s = obj;
+      return new Set(s);
+    }
+    default:
+      return structuredClone(obj);
+  }
+}
+__name(cloneBuiltIn, "cloneBuiltIn");
+function shouldIgnoreKey(key, path, ignoreKeys, options) {
+  if (ignoreKeys?.has(key)) return true;
+  if (options.ignoreKeyPredicate?.(key, path)) return true;
+  return false;
+}
+__name(shouldIgnoreKey, "shouldIgnoreKey");
+
+// src/utils/array/deep-equal-except.ts
+function deepEqualExcept(a, b, options) {
+  const prunedA = deepOmit(a, options);
+  const prunedB = deepOmit(b, options);
+  return deepEqual(prunedA, prunedB);
+}
+__name(deepEqualExcept, "deepEqualExcept");
+function deepFreeze(obj, visited = /* @__PURE__ */ new WeakSet()) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return obj;
+  }
+  visited.add(obj);
+  const keys = Reflect.ownKeys(obj);
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== null && typeof value === "object") {
+      deepFreeze(value, visited);
+    }
+  }
+  return Object.freeze(obj);
+}
+__name(deepFreeze, "deepFreeze");
+function vo(t) {
+  return deepFreeze(structuredClone(t));
+}
+__name(vo, "vo");
+function voEquals(a, b) {
+  return deepEqual(a, b);
+}
+__name(voEquals, "voEquals");
+function voEqualsExcept(a, b, options) {
+  return deepEqualExcept(a, b, options);
+}
+__name(voEqualsExcept, "voEqualsExcept");
+function voWithValidation(t, validate, errorMessage) {
+  if (!validate(t)) {
+    return err(
+      errorMessage ?? `Validation failed for value object: ${JSON.stringify(t)}`
+    );
+  }
+  return ok(vo(t));
+}
+__name(voWithValidation, "voWithValidation");
+var ValueObject = class {
+  static {
+    __name(this, "ValueObject");
+  }
+  props;
+  /**
+   * Creates a new ValueObject.
+   * The properties are deeply frozen to ensure immutability.
+   *
+   * @param props - The properties of the value object
+   * @example
+   * ```ts
+   * class Money extends ValueObject<{ amount: number; currency: string }> {
+   *   constructor(props: { amount: number; currency: string }) {
+   *     super(props);
+   *   }
+   *
+   *   protected validate(props: { amount: number; currency: string }): void {
+   *     if (props.amount < 0) throw new Error("Amount cannot be negative");
+   *   }
+   * }
+   * ```
+   */
+  constructor(props) {
+    this.validate(props);
+    this.props = deepFreeze({ ...props });
+  }
+  /**
+   * Optional validation hook that can be overridden by subclasses.
+   * Should throw an error if validation fails.
+   *
+   * @param props - The properties to validate
+   * @throws Error if validation fails
+   */
+  validate(props) {
+  }
+  /**
+   * Checks if this value object is equal to another.
+   * Uses deep equality comparison on the properties and checks for constructor equality.
+   *
+   * @param other - The other value object to compare
+   * @returns true if the properties are deeply equal and constructors match
+   */
+  equals(other) {
+    if (other === null || other === void 0) {
+      return false;
+    }
+    if (this.constructor !== other.constructor) {
+      return false;
+    }
+    return deepEqual(this.props, other.props);
+  }
+  /**
+   * Creates a clone of the value object with optional property overrides.
+   *
+   * @param props - Optional properties to override
+   * @returns A new instance of the value object
+   */
+  clone(props) {
+    const Constructor = this.constructor;
+    return new Constructor({ ...this.props, ...props || {} });
+  }
+  /**
+   * Serializes the value object to its raw properties for JSON operations.
+   *
+   * @returns The raw properties object
+   */
+  toJSON() {
+    return this.props;
+  }
+};
+
+// src/aggregate/domain-event.ts
+var defaultEventIdFactory = /* @__PURE__ */ __name(() => crypto.randomUUID(), "defaultEventIdFactory");
+var currentEventIdFactory = defaultEventIdFactory;
+function setEventIdFactory(factory) {
+  currentEventIdFactory = factory;
+}
+__name(setEventIdFactory, "setEventIdFactory");
+function resetEventIdFactory() {
+  currentEventIdFactory = defaultEventIdFactory;
+}
+__name(resetEventIdFactory, "resetEventIdFactory");
+var defaultClockFactory = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "defaultClockFactory");
+var currentClockFactory = defaultClockFactory;
+function setClockFactory(factory) {
+  currentClockFactory = factory;
+}
+__name(setClockFactory, "setClockFactory");
+function resetClockFactory() {
+  currentClockFactory = defaultClockFactory;
+}
+__name(resetClockFactory, "resetClockFactory");
+function createDomainEvent(type, payload, options) {
+  const event = {
+    eventId: options?.eventId ?? currentEventIdFactory(),
+    type,
+    aggregateId: options?.aggregateId,
+    aggregateType: options?.aggregateType,
+    payload,
+    occurredAt: options?.occurredAt ?? currentClockFactory(),
+    version: options?.version ?? 1,
+    metadata: options?.metadata
+  };
+  return deepFreeze(event);
+}
+__name(createDomainEvent, "createDomainEvent");
+function createDomainEventWithMetadata(type, payload, metadata, options) {
+  return createDomainEvent(type, payload, {
+    ...options,
+    metadata
+  });
+}
+__name(createDomainEventWithMetadata, "createDomainEventWithMetadata");
+function copyMetadata(sourceEvent, additionalMetadata) {
+  return {
+    ...sourceEvent.metadata ?? {},
+    ...additionalMetadata ?? {}
+  };
+}
+__name(copyMetadata, "copyMetadata");
+function mergeMetadata(...metadataObjects) {
+  return Object.assign({}, ...metadataObjects.filter(Boolean));
+}
+__name(mergeMetadata, "mergeMetadata");
+
+// src/aggregate/aggregate.ts
+function sameVersion(a, b) {
+  return a.id === b.id && a.version === b.version;
+}
+__name(sameVersion, "sameVersion");
+
+// src/entity/entity.ts
+var Entity = class {
+  static {
+    __name(this, "Entity");
+  }
+  id;
+  /**
+   * Returns the current state of the entity.
+   *
+   * The state object is **shallowly frozen** — direct property writes
+   * (`entity.state.foo = …`) throw in strict mode, but writes to nested
+   * objects (`entity.state.address.zip = …`) bypass the freeze. For deep
+   * immutability either model nested data with `vo()` (which freezes
+   * deeply) or reach for a structural-sharing library like Immer at the
+   * App layer. The shallow contract is intentional: deep freezing on
+   * every state write is too expensive for hot paths, and DDD aggregates
+   * normally treat their own state as private (`Tell, Don't Ask`).
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * The state is 'protected' so that only the subclass can modify it.
+   * Subclasses can mutate this directly or use helper methods.
+   */
+  _state;
+  constructor(id, initialState) {
+    if (id === null || id === void 0) {
+      throw new Error("Entity ID cannot be null or undefined");
+    }
+    this.id = id;
+    this._state = freezeShallow(initialState);
+    this.validateState(this._state);
+  }
+  /**
+   * Optional validation hook to ensure state invariants. Called during
+   * construction (from `Entity`'s constructor) and again on every
+   * `setState()` call. Throw to reject invalid state.
+   *
+   * **⚠️ Must not read subclass instance fields via `this`.** The
+   * constructor calls `validateState(initialState)` BEFORE the subclass's
+   * field initializers run, so `this.someField` is `undefined` at that
+   * point — a classic TypeScript/JavaScript constructor-ordering footgun.
+   * The `state` argument is the single source of truth; treat the method
+   * as pure with respect to `this`.
+   *
+   * If your invariants genuinely depend on per-instance configuration
+   * that isn't part of the state, pass that configuration into the state
+   * itself (DDD-canonical: the aggregate's state contains everything it
+   * needs) or perform the additional check after construction in a
+   * dedicated factory method.
+   *
+   * @param state - The state to validate
+   * @throws Error (or `DomainError` subclass) if validation fails
+   */
+  validateState(_state) {
+  }
+  /**
+   * Sets the state of the entity.
+   * This is a convenience method for state mutations.
+   * Automatically validates the newState using `validateState()`.
+   *
+   * @param newState - The new state
+   */
+  setState(newState) {
+    this.validateState(newState);
+    this._state = freezeShallow(newState);
+  }
+};
+function freezeShallow(value) {
+  if (value !== null && typeof value === "object") {
+    return Object.freeze(value);
+  }
+  return value;
+}
+__name(freezeShallow, "freezeShallow");
+function sameEntity(a, b) {
+  return a.id === b.id;
+}
+__name(sameEntity, "sameEntity");
+function findEntityById(entities, id) {
+  return entities.find((entity) => entity.id === id);
+}
+__name(findEntityById, "findEntityById");
+function hasEntityId(entities, id) {
+  return entities.some((entity) => entity.id === id);
+}
+__name(hasEntityId, "hasEntityId");
+function removeEntityById(entities, id) {
+  return entities.filter((entity) => entity.id !== id);
+}
+__name(removeEntityById, "removeEntityById");
+function updateEntityById(entities, id, updater) {
+  return entities.map((entity) => entity.id === id ? updater(entity) : entity);
+}
+__name(updateEntityById, "updateEntityById");
+function replaceEntityById(entities, id, replacement) {
+  return entities.map((entity) => entity.id === id ? replacement : entity);
+}
+__name(replaceEntityById, "replaceEntityById");
+function entityIds(entities) {
+  return entities.map((entity) => entity.id);
+}
+__name(entityIds, "entityIds");
+
+// src/aggregate/aggregate-root.ts
+var AggregateRoot = class extends Entity {
+  static {
+    __name(this, "AggregateRoot");
+  }
+  _version = 0;
+  get version() {
+    return this._version;
+  }
+  setVersion(version) {
+    this._version = version;
+  }
+  _config;
+  _autoVersionBump;
+  _domainEvents = [];
+  /**
+   * Returns a read-only list of domain events recorded by this aggregate.
+   * These events are side-effects of state changes.
+   */
+  get domainEvents() {
+    return Object.freeze(this._domainEvents.slice());
+  }
+  /**
+   * Clears the list of recorded domain events.
+   * Call this after dispatching the events.
+   */
+  clearDomainEvents() {
+    this._domainEvents = [];
+  }
+  /**
+   * Post-save hook called by a `Repository.save()` implementation to push
+   * the persisted version back into the in-memory aggregate and clear the
+   * recorded domain events (they are now safely on the write side / in
+   * the outbox).
+   *
+   * Use this so `save()` can keep its `Promise<void>` return type: the
+   * caller holds the aggregate reference, which is up to date after this
+   * call.
+   */
+  markPersisted(version) {
+    this.setVersion(version);
+    this._domainEvents = [];
+  }
+  /**
+   * Mutates state and records the resulting domain events in the
+   * **canonical record-after-mutation order**. Use this instead of calling
+   * `setState` + `addDomainEvent` separately and you cannot trip the
+   * "event for a fact that never happened" footgun.
+   *
+   * Order of operations:
+   *  1. `setState(newState, true)` — runs `validateState` first.
+   *     If it throws, the method propagates and **no event is recorded
+   *     and no version is bumped**.
+   *  2. Each event in `events` is appended via `addDomainEvent`.
+   *
+   * `commit()` **always bumps the version**, regardless of the aggregate's
+   * `autoVersionBump` config. Recording a domain event implies "something
+   * happened that the outside world cares about", and optimistic-
+   * concurrency callers must see a fresh version every time. The config
+   * still governs the un-coupled `setState` path. If you need to mutate
+   * state without bumping (e.g. cosmetic caches), call `setState(newState,
+   * false)` and skip `commit` entirely.
+   *
+   * `events` accepts a single event or an array. Omit it (or pass `[]`)
+   * for state-only mutations.
+   *
+   * @example
+   * ```ts
+   * confirm(): void {
+   *   if (this.state.status === "confirmed") {
+   *     throw new OrderAlreadyConfirmedError(this.id);
+   *   }
+   *   this.commit(
+   *     { ...this.state, status: "confirmed" },
+   *     { type: "OrderConfirmed", orderId: this.id },
+   *   );
+   * }
+   * ```
+   *
+   * `EventSourcedAggregate.apply()` enforces the same ordering
+   * structurally; `commit()` is the opt-in equivalent on `AggregateRoot`,
+   * where `setState` and `addDomainEvent` are otherwise decoupled and the
+   * ordering is convention-only.
+   *
+   * @param newState - The new state (validated by `validateState`)
+   * @param events - One event, an array of events, or none (default)
+   */
+  commit(newState, events = []) {
+    this.setState(newState, true);
+    const list = Array.isArray(events) ? events : [events];
+    for (const ev of list) {
+      this.addDomainEvent(ev);
+    }
+  }
+  constructor(id, initialState, config) {
+    super(id, initialState);
+    this._config = config ?? {};
+    this._autoVersionBump = this._config.autoVersionBump ?? false;
+  }
+  /**
+   * Records a domain event for later publication.
+   *
+   * **Ordering: record AFTER state mutation.** Vernon (IDDD §8) is
+   * explicit: a domain event describes something that has just happened
+   * to the aggregate — its existence implies the state change already
+   * occurred. Concretely:
+   *
+   * ```ts
+   * confirm(): void {
+   *   if (this.state.status === "confirmed") {
+   *     throw new OrderAlreadyConfirmedError(this.id);
+   *   }
+   *   this.setState({ ...this.state, status: "confirmed" }, true);
+   *   this.addDomainEvent({ type: "OrderConfirmed", orderId: this.id });
+   *   // ↑ post-mutation. The event represents the committed fact.
+   * }
+   * ```
+   *
+   * Recording before mutation is a footgun: if a subsequent invariant
+   * check throws, the event has already been queued but the state never
+   * actually changed — consumers see an event for a fact that did not
+   * happen.
+   *
+   * `EventSourcedAggregate.apply()` enforces this ordering structurally;
+   * `AggregateRoot` leaves it as a convention because the state-mutation
+   * path (`setState`) is decoupled from event recording.
+   *
+   * @param event - The domain event to record
+   */
+  addDomainEvent(event) {
+    this._domainEvents.push(event);
+  }
+  /**
+   * Manually bumps the aggregate version.
+   * Call this after state changes for Optimistic Concurrency Control.
+   *
+   * If `autoVersionBump` is enabled, this is called automatically
+   * when using `setState()`.
+   */
+  bumpVersion() {
+    this.setVersion(this._version + 1);
+  }
+  /**
+   * Sets the state and optionally bumps the version automatically.
+   * This is a convenience method for state mutations.
+   * Automatically validates the newState using `validateState()`.
+   * Overrides Entity.setState to add version bumping.
+   *
+   * @param newState - The new state
+   * @param bumpVersion - Whether to bump the version (defaults to autoVersionBump config)
+   */
+  setState(newState, bumpVersion) {
+    super.setState(newState);
+    const shouldBump = bumpVersion ?? this._autoVersionBump;
+    if (shouldBump) {
+      this.bumpVersion();
+    }
+  }
+  /**
+   * Creates a snapshot of the current aggregate state.
+   * Useful for performance optimization, backup/restore, and audit trails.
+   *
+   * @returns A snapshot containing the current state and version
+   *
+   * @example
+   * ```typescript
+   * const snapshot = aggregate.createSnapshot();
+   * await snapshotRepository.save(aggregate.id, snapshot);
+   * ```
+   */
+  createSnapshot() {
+    return {
+      state: structuredClone(this._state),
+      version: this.version,
+      snapshotAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Restores the aggregate from a snapshot.
+   * This is useful for loading aggregates from snapshots instead of
+   * rebuilding them from scratch.
+   * Validates the restored state.
+   *
+   * @param snapshot - The snapshot to restore from
+   *
+   * @example
+   * ```typescript
+   * const snapshot = await snapshotRepository.getLatest(aggregateId);
+   * aggregate.restoreFromSnapshot(snapshot);
+   * ```
+   */
+  restoreFromSnapshot(snapshot) {
+    this.validateState(snapshot.state);
+    this._state = freezeShallow(snapshot.state);
+    this.setVersion(snapshot.version);
+  }
+};
+
+// src/core/errors.ts
+var DomainError = class extends Error {
+  static {
+    __name(this, "DomainError");
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var MissingHandlerError = class extends DomainError {
+  constructor(eventType) {
+    super(`Missing handler for event type: ${eventType}`);
+    this.eventType = eventType;
+  }
+  static {
+    __name(this, "MissingHandlerError");
+  }
+};
+var AggregateNotFoundError = class extends DomainError {
+  constructor(aggregateType, id) {
+    super(`Aggregate not found: ${aggregateType}(${id})`);
+    this.aggregateType = aggregateType;
+    this.id = id;
+  }
+  static {
+    __name(this, "AggregateNotFoundError");
+  }
+};
+var ConcurrencyConflictError = class extends DomainError {
+  constructor(aggregateType, aggregateId, expectedVersion, actualVersion) {
+    super(
+      `Concurrency conflict on ${aggregateType}(${aggregateId}): expected version ${expectedVersion}, actual ${actualVersion}`
+    );
+    this.aggregateType = aggregateType;
+    this.aggregateId = aggregateId;
+    this.expectedVersion = expectedVersion;
+    this.actualVersion = actualVersion;
+  }
+  static {
+    __name(this, "ConcurrencyConflictError");
+  }
+};
+
+// src/aggregate/event-sourced-aggregate.ts
+var EventSourcedAggregate = class extends Entity {
+  static {
+    __name(this, "EventSourcedAggregate");
+  }
+  // --- Version management (own, not inherited from AggregateRoot) ---
+  _version = 0;
+  get version() {
+    return this._version;
+  }
+  setVersion(version) {
+    this._version = version;
+  }
+  // --- Event tracking ---
+  _pendingEvents = [];
+  _autoVersionBump;
+  get pendingEvents() {
+    return Object.freeze(this._pendingEvents.slice());
+  }
+  clearPendingEvents() {
+    this._pendingEvents = [];
+  }
+  /**
+   * Post-save hook called by a `Repository.save()` implementation to push
+   * the persisted version back into the in-memory aggregate and clear the
+   * pending events (they are now in the event store / outbox). Lets
+   * `save()` keep its `Promise<void>` return type.
+   */
+  markPersisted(version) {
+    this.setVersion(version);
+    this._pendingEvents = [];
+  }
+  constructor(id, initialState, config) {
+    super(id, initialState);
+    this._autoVersionBump = config?.autoVersionBump ?? true;
+  }
+  // --- Event application ---
+  /**
+   * Validates an event before it is applied. Default is no-op.
+   * Subclasses override to throw a concrete `DomainError` subclass when
+   * the event violates an invariant in the current state.
+   */
+  validateEvent(_event) {
+  }
+  /**
+   * Applies an event: validates, locates the handler, computes the next
+   * state, then commits state + pending event + version bump atomically.
+   *
+   * Throws `DomainError` (or a subclass) on validation failure.
+   * Throws `MissingHandlerError` if no handler is registered for `event.type`.
+   *
+   * State is not mutated if any step throws — the handler is invoked into
+   * a local and only assigned to `_state` once all checks pass.
+   *
+   * The method is generic in the event tag `K`, so concrete callers
+   * (`this.apply(orderCreated)`) narrow to the literal tag and the
+   * dispatched handler is typed as `Handler<TState, Extract<TEvent, { type: K }>>`
+   * — no `as` cast required at the call site.
+   *
+   * @param event - The domain event to apply
+   * @param isNew - Whether the event is new (needs persisting) or replayed from history
+   */
+  apply(event, isNew = true) {
+    this.dispatchAndCommit(event, isNew);
+  }
+  /**
+   * Internal dispatch path used by `apply()` and the replay methods
+   * (`loadFromHistory`, `restoreFromSnapshotWithEvents`). The replay loop
+   * iterates over `TEvent[]` and therefore cannot supply a narrowed `K`
+   * generic, so this helper accepts `TEvent` and the discriminator is
+   * resolved via the (statically-sound) `handlers` map.
+   */
+  dispatchAndCommit(event, isNew) {
+    this.validateEvent(event);
+    const handler = this.handlers[event.type];
+    if (!handler) {
+      throw new MissingHandlerError(event.type);
+    }
+    const nextState = handler(this._state, event);
+    this._state = freezeShallow(nextState);
+    if (isNew) {
+      this._pendingEvents.push(event);
+      if (this._autoVersionBump) {
+        this.setVersion(this._version + 1);
+      }
+    }
+  }
+  /**
+   * Manually bumps the aggregate version.
+   * Only needed if `autoVersionBump` is disabled.
+   */
+  bumpVersion() {
+    this.setVersion(this._version + 1);
+  }
+  // --- History & Snapshots ---
+  /**
+   * Reconstitutes the aggregate from an event history. Catches `DomainError`
+   * thrown during replay and returns it as an `Err` — this is the
+   * infrastructure boundary, where event-stream corruption is an expected
+   * recoverable failure. Unexpected (non-DomainError) throws propagate.
+   *
+   * Version advances additively: the aggregate's pre-existing version plus
+   * `history.length`. A fresh aggregate (v=0) loading 3 events ends at v=3;
+   * an aggregate already at v=1 (e.g. after a creation event) loading
+   * 2 events ends at v=3, not v=2.
+   */
+  loadFromHistory(history) {
+    const startVersion = this._version;
+    for (const event of history) {
+      try {
+        this.dispatchAndCommit(event, false);
+      } catch (e) {
+        if (e instanceof DomainError) return err(e);
+        throw e;
+      }
+    }
+    this.setVersion(startVersion + history.length);
+    return ok();
+  }
+  hasPendingEvents() {
+    return this._pendingEvents.length > 0;
+  }
+  getEventCount() {
+    return this._pendingEvents.length;
+  }
+  getLatestEvent() {
+    return this._pendingEvents[this._pendingEvents.length - 1];
+  }
+  /**
+   * Creates a snapshot of the current aggregate state.
+   */
+  createSnapshot() {
+    return {
+      state: structuredClone(this._state),
+      version: this._version,
+      snapshotAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Restores the aggregate from a snapshot and applies events that occurred
+   * after. Same infrastructure-boundary semantics as `loadFromHistory`:
+   * catches `DomainError` and returns it as an `Err`; non-domain throws
+   * propagate.
+   *
+   * All-or-nothing: if any event mid-stream throws a `DomainError`, the
+   * aggregate is rolled back to its pre-call state + version. Partial
+   * restoration is never observable to the caller.
+   */
+  restoreFromSnapshotWithEvents(snapshot, eventsAfterSnapshot) {
+    const previousState = this._state;
+    const previousVersion = this._version;
+    this._state = freezeShallow(snapshot.state);
+    this.setVersion(snapshot.version);
+    for (const event of eventsAfterSnapshot) {
+      try {
+        this.dispatchAndCommit(event, false);
+      } catch (e) {
+        this._state = previousState;
+        this.setVersion(previousVersion);
+        if (e instanceof DomainError) return err(e);
+        throw e;
+      }
+    }
+    this.setVersion(snapshot.version + eventsAfterSnapshot.length);
+    return ok();
+  }
+};
+var CommandBus = class {
+  static {
+    __name(this, "CommandBus");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlers = /* @__PURE__ */ new Map();
+  register(commandType, handler) {
+    this.handlers.set(commandType, handler);
+  }
+  async execute(command) {
+    const handler = this.handlers.get(command.type);
+    if (!handler) {
+      return err(`No handler registered for command type: ${command.type}`);
+    }
+    try {
+      return await handler(command);
+    } catch (error) {
+      return err(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+};
+
+// src/app/handler.ts
+async function withCommit(deps, fn) {
+  const { result, events } = await deps.scope.transactional(async () => {
+    const fnResult = await fn();
+    await deps.outbox.add(fnResult.events);
+    return fnResult;
+  });
+  if (deps.bus) {
+    await deps.bus.publish(events);
+  }
+  return result;
+}
+__name(withCommit, "withCommit");
+var QueryBus = class {
+  static {
+    __name(this, "QueryBus");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlers = /* @__PURE__ */ new Map();
+  register(queryType, handler) {
+    this.handlers.set(queryType, handler);
+  }
+  async execute(query) {
+    const handler = this.handlers.get(query.type);
+    if (!handler) {
+      return err(`No handler registered for query type: ${query.type}`);
+    }
+    try {
+      const result = await handler(query);
+      return ok(result);
+    } catch (error) {
+      return err(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  async executeUnsafe(query) {
+    const handler = this.handlers.get(query.type);
+    if (!handler) {
+      throw new Error(`No handler registered for query type: ${query.type}`);
+    }
+    return handler(query);
+  }
+};
+
+// src/events/event-bus.ts
+var EventBusImpl = class {
+  static {
+    __name(this, "EventBusImpl");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlers = /* @__PURE__ */ new Map();
+  subscribe(eventType, handler) {
+    const type = eventType;
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, []);
+    }
+    const handlersForType = this.handlers.get(type);
+    const casted = handler;
+    handlersForType.push(casted);
+    let removed = false;
+    return () => {
+      if (removed) return;
+      const idx = handlersForType.indexOf(casted);
+      if (idx !== -1) {
+        handlersForType.splice(idx, 1);
+        removed = true;
+      }
+      if (handlersForType.length === 0) {
+        this.handlers.delete(type);
+      }
+    };
+  }
+  once(eventType, options) {
+    return new Promise((resolve, reject) => {
+      if (options?.signal?.aborted) {
+        reject(options.signal.reason ?? new Error("EventBus.once aborted"));
+        return;
+      }
+      let timer;
+      let settled = false;
+      let abortListener;
+      const cleanup = /* @__PURE__ */ __name(() => {
+        if (settled) return;
+        settled = true;
+        unsubscribe();
+        if (timer !== void 0) clearTimeout(timer);
+        if (abortListener && options?.signal) {
+          options.signal.removeEventListener("abort", abortListener);
+        }
+      }, "cleanup");
+      const unsubscribe = this.subscribe(eventType, (event) => {
+        cleanup();
+        resolve(event);
+      });
+      if (options?.signal) {
+        abortListener = /* @__PURE__ */ __name(() => {
+          cleanup();
+          reject(
+            options.signal.reason ?? new Error("EventBus.once aborted")
+          );
+        }, "abortListener");
+        options.signal.addEventListener("abort", abortListener);
+      }
+      if (typeof options?.timeoutMs === "number") {
+        timer = setTimeout(() => {
+          cleanup();
+          reject(
+            new Error(
+              `EventBus.once timed out after ${options.timeoutMs}ms waiting for "${eventType}"`
+            )
+          );
+        }, options.timeoutMs);
+      }
+    });
+  }
+  /**
+   * See {@link EventBus.publish} for the full ordering / parallelism /
+   * error-aggregation contract this implementation realises:
+   *  - events in input order, sequentially;
+   *  - handlers within one event in parallel via `Promise.allSettled`;
+   *  - errors collected and thrown after the batch (single Error, or
+   *    `AggregateError` for multiple failures).
+   */
+  async publish(events) {
+    const errors = [];
+    for (const event of events) {
+      const handlersForType = this.handlers.get(event.type);
+      if (handlersForType) {
+        const results = await Promise.allSettled(
+          handlersForType.slice().map((handler) => handler(event))
+        );
+        for (const result of results) {
+          if (result.status === "rejected") {
+            errors.push(
+              result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+            );
+          }
+        }
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    }
+    if (errors.length > 1) {
+      throw new AggregateError(errors, "Multiple event handlers failed");
+    }
+  }
+};
+
+export { AggregateNotFoundError, AggregateRoot, CommandBus, ConcurrencyConflictError, DomainError, Entity, EventBusImpl, EventSourcedAggregate, MissingHandlerError, QueryBus, ValueObject, copyMetadata, createDomainEvent, createDomainEventWithMetadata, deepEqual, deepEqualExcept, deepFreeze, deepOmit, entityIds, findEntityById, freezeShallow, hasEntityId, mergeMetadata, removeEntityById, replaceEntityById, resetClockFactory, resetEventIdFactory, sameEntity, sameVersion, setClockFactory, setEventIdFactory, updateEntityById, vo, voEquals, voEqualsExcept, voWithValidation, withCommit };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map