@vytches/ddd-aggregates 0.29.3 → 0.31.0-alpha.0

package/dist/index.js

@@ -1,8 +1,8 @@
-import { Capability as l, CapabilityRegistry as $, createDomainEvent as N, EntityId as y } from "@vytches/ddd-contracts";
-import { Logger as L } from "@vytches/ddd-logging";
-import { IDomainError as M, DomainErrorCode as o } from "@vytches/ddd-domain-primitives";
-import { Result as h } from "@vytches/ddd-utils";
-class p extends l {
+import { Capability as d, CapabilityRegistry as M, createDomainEvent as T, EntityId as f } from "@vytches/ddd-contracts";
+import { internalLogger as y } from "@vytches/ddd-contracts/internal";
+import { LibUtils as b, Result as l } from "@vytches/ddd-utils";
+import { IDomainError as L, DomainErrorCode as g } from "@vytches/ddd-domain-primitives";
+class p extends d {
   constructor() {
     super(...arguments), this.type = "versioning", this.upcasters = /* @__PURE__ */ new Map();
   }
@@ -27,40 +27,53 @@ class p extends l {
     this.upcasters.has(t) || this.upcasters.set(t, /* @__PURE__ */ new Map()), this.upcasters.get(t).set(e, i);
   }
   /**
-   * @param {IDomainEvent} event - Event to process with version handling
+   * Applies registered upcasters to bring `event` from its stored version up
+   * to the aggregate's current version, then invokes the matching handler.
+   *
+   * **Upcasting only activates if `event.metadata.targetVersion` is set.**
+   * This is NOT inferred automatically from registered upcasters or from
+   * any aggregate-level "current version" — the caller (typically your
+   * event-sourcing replay/load path) must explicitly stamp each historical
+   * event's metadata with `targetVersion` before calling this method. If
+   * `targetVersion` is absent, `currentVersion` falls back to `eventVersion`
+   * (i.e. no upcasting happens — the event is passed through unchanged even
+   * if upcasters are registered for it).
+   *
+   * @param {IDomainEvent} event - Event to process with version handling;
+   *   set `event.metadata.targetVersion` to enable upcasting
    * @param {Map<string, IAggregateEventHandler>} handlers - Map of event handlers
    */
   handleVersionedEvent(t, e) {
-    const i = t.metadata?.version || 1, a = t.metadata?.targetVersion || i;
+    const i = t.metadata?.version || 1, s = t.metadata?.targetVersion || i;
     let n = t;
-    if (i < a && this.upcasters.has(t.eventName)) {
-      const g = this.upcasters.get(t.eventName), d = L.forContext("VersioningCapability");
-      for (let u = i; u < a; u++) {
-        const f = g.get(u);
-        if (!f) {
-          d.warn(
-            "Missing upcaster for event version — event will be processed without upcast",
+    if (i < s && this.upcasters.has(t.eventName)) {
+      const h = this.upcasters.get(t.eventName);
+      for (let c = i; c < s; c++) {
+        const m = h.get(c);
+        if (!m) {
+          y.warn(
+            "VersioningCapability: Missing upcaster for event version — event will be processed without upcast",
             {
               eventName: t.eventName,
-              fromVersion: u,
-              toVersion: u + 1
+              fromVersion: c,
+              toVersion: c + 1
             }
           );
           continue;
         }
-        const I = f.upcast(n.payload, n.metadata);
+        const N = m.upcast(n.payload, n.metadata);
         n = {
           ...n,
-          payload: I,
+          payload: N,
           metadata: {
             ...n.metadata,
-            version: u + 1
+            version: c + 1
           }
         };
       }
     }
-    const c = e.get(n.eventName);
-    c && c(n.payload, n.metadata);
+    const o = e.get(n.eventName);
+    o && o(n.payload, n.metadata);
   }
   /**
    * @returns {string[]} Array of event types that have registered upcasters
@@ -99,9 +112,10 @@ class p extends l {
     return t;
   }
 }
-class v {
+const E = Symbol("vytches-ddd-aggregate-internal-state");
+class u {
   constructor(t) {
-    this._version = 0, this._initialVersion = 0, this._domainEvents = [], this._eventHandlers = /* @__PURE__ */ new Map(), this._capabilities = new $(), this._id = t.id, this._version = t.version || 0, this._initialVersion = t.version || 0, this._maxEvents = t.maxEvents;
+    this._version = 0, this._initialVersion = 0, this._domainEvents = [], this._eventHandlers = /* @__PURE__ */ new Map(), this._capabilities = new M(), this._id = t.id, this._version = t.version || 0, this._initialVersion = t.version || 0, this._maxEvents = t.maxEvents, this._onMissingHandler = t.onMissingHandler ?? "warn";
   }
   // ==========================================
   // CORE AGGREGATE FUNCTIONALITY
@@ -113,6 +127,24 @@ class v {
     return this._id;
   }
   /**
+   * Identity-based equality, matching {@link Entity.equals}. Two aggregates
+   * are equal iff they have the same id (compared via `EntityId.equals()`);
+   * attribute/version differences are ignored.
+   *
+   * VF-023 (D-5, AC10, non-breaking addition): `AggregateRoot` does not
+   * extend `Entity` (it implements `IAggregateRoot<TId>` directly), so this
+   * mirrors `Entity.equals()` rather than inheriting it.
+   *
+   * @param other - Aggregate to compare against. May be `null` or `undefined`.
+   * @returns `true` if both aggregates have the same id; `false` otherwise.
+   */
+  equals(t) {
+    return t == null ? !1 : t === this ? !0 : t instanceof u ? this._id.equals(t._id) : !1;
+  }
+  /**
+   * The version increments by one each time `apply()` successfully records a
+   * domain event; compare it against the persisted version to detect
+   * concurrent modification (optimistic locking).
    *
    * @returns {number} Current version number for optimistic locking
    */
@@ -120,6 +152,9 @@ class v {
     return this._version;
   }
   /**
+   * The version this aggregate had when it was loaded (or as of the last
+   * `commit()`), letting callers work out how many events have been applied
+   * since without recomputing from the event log.
    *
    * @returns {number} Initial version when aggregate was loaded
    */
@@ -127,6 +162,9 @@ class v {
     return this._initialVersion;
   }
   /**
+   * Whether this aggregate has recorded domain events since its last
+   * `commit()` — use it to decide whether persistence/dispatch work is
+   * needed at all.
    *
    * @returns {boolean} True if aggregate has uncommitted domain events
    */
@@ -134,11 +172,20 @@ class v {
     return this._domainEvents.length > 0;
   }
   /**
-   *
+   * VF-023 (D-3, AC11, BREAKING): the returned array and every event object
+   * it contains (including nested `payload`/`metadata`) are now deep-frozen
+   * via `LibUtils.deepFreeze` — the same immutability guarantee applied to
+   * `BaseValueObject` values (see `base-value-object.ts`). Previously this
+   * returned only a shallow array copy: the array itself couldn't be
+   * mutated by callers, but the event objects (and their nested payload
+   * data) inside it could still be mutated in place, silently corrupting
+   * state shared with `_domainEvents` (the same object references are
+   * stored internally — events are never re-cloned after creation).
    * @returns {ReadonlyArray<IDomainEvent>} Array of uncommitted domain events
    */
   getDomainEvents() {
-    return [...this._domainEvents];
+    const t = this._domainEvents.map((e) => b.deepFreeze(e));
+    return Object.freeze(t);
   }
   /**
    * Clear all uncommitted domain events and update initial version
@@ -162,27 +209,40 @@ class v {
    * @param {string | IDomainEvent<P>} eventTypeOrEvent - Event type string or complete event object
    * @param {P} payload - Event payload data
    * @param {Partial<IEventMetadata>} metadata - Optional event metadata
+   * @throws {Error} when the aggregate's configured maxEvents limit would be exceeded
+   * @example Hitting the maxEvents guard
+   * ```typescript
+   * class Order extends AggregateRoot<string> {
+   *   record(customerId: string, amount: number): void {
+   *     this.apply('OrderCreated', { customerId, amount });
+   *   }
+   * }
+   *
+   * const order = new Order({ id: EntityId.create(), version: 0, maxEvents: 1 });
+   * order.record('c-1', 100); // ok, 1 event recorded
+   * order.record('c-1', 100); // throws: maxEvents limit of 1 exceeded
+   * ```
    */
   apply(t, e, i) {
-    this._version++;
-    let a, n;
-    typeof t == "string" ? (a = N(t, e, i), n = a.metadata) : (a = t, n = i ? { ...a.metadata, ...i } : a.metadata);
-    const c = v.sanitizeMetadata({
-      ...n,
-      aggregateId: this._id.toString(),
-      aggregateType: this.constructor.name,
-      aggregateVersion: this._version,
-      timestamp: n?.timestamp ?? /* @__PURE__ */ new Date()
-    }), g = Object.assign(
-      Object.create(Object.getPrototypeOf(a)),
-      a,
-      { metadata: c }
-    );
     if (this._maxEvents !== void 0 && this._domainEvents.length >= this._maxEvents)
       throw new Error(
         `Aggregate ${this.constructor.name} (id=${this._id.toString()}) exceeded maxEvents limit of ${this._maxEvents}. This usually indicates a runaway loop or replay of a corrupted event stream. Increase maxEvents in the aggregate constructor params if the limit is too restrictive for your domain.`
       );
-    this._domainEvents.push(g), this.handleEvent(g);
+    const s = this._version + 1;
+    let n, o;
+    typeof t == "string" ? (n = T(t, e, i), o = n.metadata) : (n = t, o = i ? { ...n.metadata, ...i } : n.metadata);
+    const h = u.sanitizeMetadata({
+      ...o,
+      aggregateId: this._id.toString(),
+      aggregateType: this.constructor.name,
+      aggregateVersion: s,
+      timestamp: o?.timestamp ?? /* @__PURE__ */ new Date()
+    }), c = Object.assign(
+      Object.create(Object.getPrototypeOf(n)),
+      n,
+      { metadata: h }
+    );
+    this._version = s, this._domainEvents.push(c), this.handleEvent(c);
   }
   handleEvent(t) {
     const e = this.getCapability(p);
@@ -190,9 +250,24 @@ class v {
       e.handleVersionedEvent(t, this._eventHandlers);
     else {
       const i = this._eventHandlers.get(t.eventName);
-      i && i(t.payload, t.metadata);
+      i ? i(t.payload, t.metadata) : this.reportMissingHandler(t.eventName);
     }
   }
+  /**
+   * VF-023 (D-4, AC6): called from `handleEvent()`, which is shared by both
+   * `apply()` (live) and `loadFromHistory()` (replay) — so the missing-
+   * handler policy applies identically to both paths.
+   */
+  reportMissingHandler(t) {
+    const e = `Aggregate ${this.constructor.name} (id=${this._id.toString()}) has no registered handler for event "${t}". State will not be updated for this event. Register a handler via registerEventHandler('${t}', ...) before applying/replaying this event, or pass onMissingHandler: "warn" explicitly to silence this in the constructor params.`;
+    if (this._onMissingHandler === "throw")
+      throw new Error(e);
+    y.warn(e, {
+      aggregateType: this.constructor.name,
+      aggregateId: this._id.toString(),
+      eventName: t
+    });
+  }
   /**
    * Reconstruct aggregate state from historical domain events
    * @param {IDomainEvent[]} events - Array of events to replay for state reconstruction
@@ -263,14 +338,28 @@ class v {
   // INTERNAL ACCESS FOR CAPABILITIES
   // ==========================================
   /**
-   * Internal method for capabilities to access private state
-   * Should only be used by capabilities, not directly by domain code
+   * Internal method for capabilities to access private state.
+   *
+   * VF-023 (D-2, AC5, BREAKING, CRITICAL F-H4): gated by
+   * {@link INTERNAL_STATE_TOKEN}, a module-private `unique symbol` that is
+   * exported only from this module (not from the package's public barrel).
+   * Callers must supply the exact token reference to invoke this method —
+   * consumers of `@vytches/ddd-aggregates` cannot obtain it, so this method
+   * is unreachable from outside this package's own source, even via
+   * `as unknown as {...}` casts (the token value itself, not just its type,
+   * is required and cannot be forged).
+   *
+   * @throws {TypeError} if `token` does not match {@link INTERNAL_STATE_TOKEN}
    */
-  _internal_setState(t) {
-    this._version = t.version, this._initialVersion = t.initialVersion, this._domainEvents = [...t.domainEvents];
+  _internal_setState(t, e) {
+    if (t !== E)
+      throw new TypeError(
+        "_internal_setState: invalid or missing internal state token. This method is restricted to capabilities within @vytches/ddd-aggregates."
+      );
+    this._version = e.version, this._initialVersion = e.initialVersion, this._domainEvents = [...e.domainEvents];
   }
 }
-class b extends l {
+class w extends d {
   constructor() {
     super(...arguments), this.type = "audit", this.auditLog = [];
   }
@@ -284,8 +373,8 @@ class b extends l {
     this.aggregate = t;
     const e = this.aggregate;
     typeof e.apply == "function" && (this.originalApply = e.apply, this.originalApply && (this.aggregate.apply = (...i) => {
-      const a = this.originalApply.call(this.aggregate, ...i);
-      return this.recordAuditEvent(), a;
+      const s = this.originalApply.call(this.aggregate, ...i);
+      return this.recordAuditEvent(), s;
     }));
   }
   detach() {
@@ -306,12 +395,12 @@ class b extends l {
   getAuditStatistics() {
     const t = {};
     let e = 0;
-    this.auditLog.forEach((a, n) => {
-      if (t[a.eventName] = (t[a.eventName] || 0) + 1, n > 0) {
-        const c = this.auditLog[n - 1];
-        if (c) {
-          const g = new Date(c.timestamp).getTime(), d = new Date(a.timestamp).getTime();
-          e += d - g;
+    this.auditLog.forEach((s, n) => {
+      if (t[s.eventName] = (t[s.eventName] || 0) + 1, n > 0) {
+        const o = this.auditLog[n - 1];
+        if (o) {
+          const h = new Date(o.timestamp).getTime(), c = new Date(s.timestamp).getTime();
+          e += c - h;
         }
       }
     });
@@ -334,7 +423,7 @@ class b extends l {
    */
   recordEvent(t) {
     const e = {
-      eventId: t.metadata?.eventId || `audit-${Date.now()}-${Math.random()}`,
+      eventId: t.metadata?.eventId || `audit-${b.getUUID()}`,
       eventName: t.eventName,
       aggregateId: this.aggregate.getId().toString(),
       aggregateType: this.aggregate.constructor.name,
@@ -363,8 +452,8 @@ class b extends l {
    */
   getEventsByTimeRange(t, e) {
     return this.auditLog.filter((i) => {
-      const a = new Date(i.timestamp).getTime();
-      return a >= t.getTime() && a <= e.getTime();
+      const s = new Date(i.timestamp).getTime();
+      return s >= t.getTime() && s <= e.getTime();
     });
   }
   /**
@@ -380,13 +469,13 @@ class b extends l {
     return this.auditLog[this.auditLog.length - 1] || null;
   }
 }
-class r extends M {
+class r extends L {
   /**
    * Error for invalid arguments provided to the aggregate
    */
   static invalidArguments(t, e) {
     const i = {
-      code: o.InvalidParameter,
+      code: g.InvalidParameter,
       data: e
     };
     return new r(t, i);
@@ -394,24 +483,24 @@ class r extends M {
   /**
    * Error for version conflicts in the aggregate
    */
-  static versionConflict(t, e, i, a) {
-    const n = `Version conflict: Aggregate ${t} with ID ${e} has version ${i}, but expected ${a}`, c = {
-      code: o.ValidationFailed,
+  static versionConflict(t, e, i, s) {
+    const n = `Version conflict: Aggregate ${t} with ID ${e} has version ${i}, but expected ${s}`, o = {
+      code: g.ValidationFailed,
       data: {
         aggregateType: t,
         aggregateId: e,
         currentVersion: i,
-        expectedVersion: a
+        expectedVersion: s
       }
     };
-    return new r(n, c);
+    return new r(n, o);
   }
   /**
    * Error for when a required feature is not enabled
    */
   static featureNotEnabled(t) {
     const e = `Feature '${t}' is not enabled on aggregate`, i = {
-      code: o.ValidationFailed,
+      code: g.ValidationFailed,
       data: {
         feature: t
       }
@@ -422,113 +511,113 @@ class r extends M {
    * Error for when a required method is not implemented
    */
   static methodNotImplemented(t, e) {
-    const i = `Method '${t}' must be implemented by ${e} to use this feature`, a = {
-      code: o.MissingValue,
+    const i = `Method '${t}' must be implemented by ${e} to use this feature`, s = {
+      code: g.MissingValue,
       data: {
         methodName: t,
         aggregateType: e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for invalid snapshot
    */
   static invalidSnapshot(t, e) {
-    const i = `Invalid snapshot for aggregate ${t}${e ? `: ${e}` : ""}`, a = {
-      code: o.InvalidFormat,
+    const i = `Invalid snapshot for aggregate ${t}${e ? `: ${e}` : ""}`, s = {
+      code: g.InvalidFormat,
       data: {
         aggregateType: t,
         reason: e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for ID mismatch during snapshot restoration
    */
   static idMismatch(t, e) {
-    const i = `ID mismatch: Snapshot is for ID ${t}, but aggregate has ID ${e}`, a = {
-      code: o.ValidationFailed,
+    const i = `ID mismatch: Snapshot is for ID ${t}, but aggregate has ID ${e}`, s = {
+      code: g.ValidationFailed,
       data: {
         snapshotId: t,
         aggregateId: e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for type mismatch during snapshot restoration
    */
   static typeMismatch(t, e) {
-    const i = `Aggregate type mismatch: Snapshot is for type ${t}, but trying to load into ${e}`, a = {
-      code: o.ValidationFailed,
+    const i = `Aggregate type mismatch: Snapshot is for type ${t}, but trying to load into ${e}`, s = {
+      code: g.ValidationFailed,
       data: {
         snapshotType: t,
         aggregateType: e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for duplicate upcaster registration
    */
   static duplicateUpcaster(t, e) {
-    const i = `Upcaster for event ${t} version ${e} already exists`, a = {
-      code: o.DuplicateEntry,
+    const i = `Upcaster for event ${t} version ${e} already exists`, s = {
+      code: g.DuplicateEntry,
       data: {
         eventType: t,
         sourceVersion: e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for missing upcaster
    */
   static missingUpcaster(t, e, i) {
-    const a = `Missing upcaster for event ${t} from version ${e} to ${i}`, n = {
-      code: o.MissingValue,
+    const s = `Missing upcaster for event ${t} from version ${e} to ${i}`, n = {
+      code: g.MissingValue,
       data: {
         eventType: t,
         fromVersion: e,
         toVersion: i
       }
     };
-    return new r(a, n);
+    return new r(s, n);
   }
   /**
    * Error for configuration problems
    */
   static configurationError(t, e) {
-    const i = `Configuration error in ${t}: ${e}`, a = {
-      code: o.ValidationFailed,
+    const i = `Configuration error in ${t}: ${e}`, s = {
+      code: g.ValidationFailed,
       data: {
         aggregateType: t,
         configurationError: e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for when apply method interception fails (e.g. method not found)
    */
   static cannotInterceptApplyMethod(t, e) {
-    const i = `Cannot intercept apply method - method not found on aggregate ${t}`, a = {
-      code: o.InternalError,
+    const i = `Cannot intercept apply method - method not found on aggregate ${t}`, s = {
+      code: g.InternalError,
       data: {
         aggergateId: t,
         ...e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
   /**
    * Error for when event store is not configured
    */
   static eventStoreNotConfigured(t) {
     const e = "Event store not configured", i = {
-      code: o.MissingValue,
+      code: g.MissingValue,
       data: t
     };
     return new r(e, i);
@@ -537,17 +626,17 @@ class r extends M {
    * Error for when aggregate does not support event replay
    */
   static aggregateDoesNotSupportReplay(t, e) {
-    const i = `Aggregate ${t} does not support event replay`, a = {
-      code: o.MethodNotSupported,
+    const i = `Aggregate ${t} does not support event replay`, s = {
+      code: g.MethodNotSupported,
       data: {
         aggregateType: t,
         ...e
       }
     };
-    return new r(i, a);
+    return new r(i, s);
   }
 }
-class E extends l {
+class S extends d {
   constructor() {
     super(...arguments), this.type = "eventSourcing", this.eventStore = null;
   }
@@ -630,11 +719,11 @@ class E extends l {
         this.aggregate.constructor.name,
         "Event store not configured"
       );
-    const i = await this.eventStore.getEventsAfterVersion(t, e), a = this.aggregate;
-    a.loadFromHistory && i.length > 0 && a.loadFromHistory(i);
+    const i = await this.eventStore.getEventsAfterVersion(t, e), s = this.aggregate;
+    s.loadFromHistory && i.length > 0 && s.loadFromHistory(i);
   }
 }
-class S extends l {
+class _ extends d {
   constructor() {
     super(...arguments), this.type = "snapshot", this._snapshot = null;
   }
@@ -656,7 +745,7 @@ class S extends l {
    * @returns {IAggregateSnapshot<TState, TMeta>} Created snapshot with state and metadata
    */
   createSnapshot(t, e) {
-    const i = this.aggregate.getDomainEvents(), n = (i.length > 0 ? i[i.length - 1] : null)?.metadata?.eventId, g = {
+    const i = this.aggregate.getDomainEvents(), n = (i.length > 0 ? i[i.length - 1] : null)?.metadata?.eventId, h = {
       aggregateId: this.aggregate.getId().toString(),
       version: this.aggregate.getVersion(),
       aggregateType: this.aggregate.constructor.name,
@@ -664,7 +753,7 @@ class S extends l {
       timestamp: /* @__PURE__ */ new Date(),
       ...n !== void 0 && { lastEventId: n }
     };
-    return e && (g.metadata = e()), g;
+    return e && (h.metadata = e()), h;
   }
   /**
    * @param {IAggregateSnapshot<TState, TMeta>} snapshot - Snapshot to restore from
@@ -675,14 +764,12 @@ class S extends l {
   restoreFromSnapshot(t, e, i) {
     if (!t || !t.state)
       throw r.invalidSnapshot(this.aggregate.constructor.name, "Invalid snapshot");
-    const a = this.aggregate.getId().toString();
-    if (t.aggregateId !== a)
-      throw r.idMismatch(t.aggregateId, a);
+    const s = this.aggregate.getId().toString();
+    if (t.aggregateId !== s)
+      throw r.idMismatch(t.aggregateId, s);
     if (t.aggregateType !== this.aggregate.constructor.name)
       throw r.typeMismatch(t.aggregateType, this.aggregate.constructor.name);
-    e(t.state), t.metadata && i && i(t.metadata);
-    const n = this.aggregate;
-    n._internal_setState && n._internal_setState({
+    e(t.state), t.metadata && i && i(t.metadata), this.aggregate._internal_setState(E, {
       version: t.version,
       initialVersion: t.version,
       domainEvents: []
@@ -715,7 +802,7 @@ class S extends l {
     return this._snapshot = null, t;
   }
 }
-class m {
+class v {
   constructor(t) {
     this.capabilities = [], this.params = t;
   }
@@ -724,13 +811,13 @@ class m {
    */
   static create(t) {
     const e = {
-      id: t.id instanceof y ? t.id : new y(t.id, "text"),
+      id: t.id instanceof f ? t.id : new f(t.id, "text"),
       version: t.version || 0
     };
-    return new m(e);
+    return new v(e);
   }
   withSnapshots() {
-    return this.capabilities.push({ capability: new S() }), this;
+    return this.capabilities.push({ capability: new _() }), this;
   }
   /**
    * @returns {this} Builder instance for method chaining
@@ -742,19 +829,19 @@ class m {
    * @returns {this} Builder instance for method chaining
    */
   withAudit() {
-    return this.capabilities.push({ capability: new b() }), this;
+    return this.capabilities.push({ capability: new w() }), this;
   }
   /**
    * @param {IEventStore} [eventStore] - Optional event store for event sourcing
    * @returns {this} Builder instance for method chaining
    */
   withEventSourcing(t) {
-    const e = new E();
+    const e = new S();
     return this.capabilities.push({
       capability: e,
       configure: (i) => {
-        const a = i;
-        t ? a.setEventStore(t) : this.eventStore && a.setEventStore(this.eventStore);
+        const s = i;
+        t ? s.setEventStore(t) : this.eventStore && s.setEventStore(this.eventStore);
       }
     }), this;
   }
@@ -777,9 +864,9 @@ class m {
     return this.eventStore = t, this;
   }
   build(t) {
-    const e = t || v, i = new e(this.params);
-    for (const { capability: a, configure: n } of this.capabilities)
-      i.addCapability(a), n && n(a);
+    const e = t || u, i = new e(this.params);
+    for (const { capability: s, configure: n } of this.capabilities)
+      i.addCapability(s), n && n(s);
     return i;
   }
   /**
@@ -790,10 +877,10 @@ class m {
     return this.withSnapshots().withVersioning().withAudit().withEventSourcing().build(t);
   }
 }
-function H(s) {
-  return m.create(s);
+function U(a) {
+  return v.create(a);
 }
-class w {
+class C {
   constructor(t) {
     this._id = t;
   }
@@ -812,77 +899,77 @@ class w {
    * @returns `true` if both entities have the same id; `false` otherwise.
    */
   equals(t) {
-    return t == null ? !1 : t === this ? !0 : t instanceof w ? this._id.equals(t._id) : !1;
+    return t == null ? !1 : t === this ? !0 : t instanceof C ? this._id.equals(t._id) : !1;
   }
 }
-function _(s) {
-  return s.hasCapability(S);
+function V(a) {
+  return a.hasCapability(_);
 }
-function C(s) {
-  return s.hasCapability(p);
+function I(a) {
+  return a.hasCapability(p);
 }
-function V(s) {
-  return s.hasCapability(b);
+function A(a) {
+  return a.hasCapability(w);
 }
-function A(s) {
-  return s.hasCapability(E);
+function $(a) {
+  return a.hasCapability(S);
 }
-function U(s) {
-  if (!_(s))
+function O(a) {
+  if (!V(a))
     throw r.featureNotEnabled("snapshot");
-  return s;
+  return a;
 }
-function O(s) {
-  return _(s) ? h.ok(s) : h.fail(r.featureNotEnabled("snapshot"));
+function j(a) {
+  return V(a) ? l.ok(a) : l.fail(r.featureNotEnabled("snapshot"));
 }
-function P(s) {
-  if (!C(s))
+function k(a) {
+  if (!I(a))
     throw r.featureNotEnabled("versioning");
-  return s;
+  return a;
 }
-function j(s) {
-  return C(s) ? h.ok(s) : h.fail(r.featureNotEnabled("versioning"));
+function P(a) {
+  return I(a) ? l.ok(a) : l.fail(r.featureNotEnabled("versioning"));
 }
-function k(s) {
-  if (!V(s))
+function W(a) {
+  if (!A(a))
     throw r.featureNotEnabled("audit");
-  return s;
+  return a;
 }
-function B(s) {
-  return V(s) ? h.ok(s) : h.fail(r.featureNotEnabled("audit"));
+function z(a) {
+  return A(a) ? l.ok(a) : l.fail(r.featureNotEnabled("audit"));
 }
-function W(s) {
-  if (!A(s))
+function B(a) {
+  if (!$(a))
     throw r.featureNotEnabled("eventSourcing");
-  return s;
+  return a;
 }
-function R(s) {
-  return A(s) ? h.ok(s) : h.fail(r.featureNotEnabled("eventSourcing"));
+function R(a) {
+  return $(a) ? l.ok(a) : l.fail(r.featureNotEnabled("eventSourcing"));
 }
-function z(s) {
-  return s.getCapabilityTypes();
+function q(a) {
+  return a.getCapabilityTypes();
 }
-function q(s, t) {
-  return t.every((e) => s.hasCapability(e));
+function K(a, t) {
+  return t.every((e) => a.hasCapability(e));
 }
 export {
-  m as AggregateBuilder,
+  v as AggregateBuilder,
   r as AggregateError,
-  v as AggregateRoot,
-  b as AuditCapability,
-  w as Entity,
-  E as EventSourcingCapability,
-  S as SnapshotCapability,
+  u as AggregateRoot,
+  w as AuditCapability,
+  C as Entity,
+  S as EventSourcingCapability,
+  _ as SnapshotCapability,
   p as VersioningCapability,
-  H as aggregateBuilder,
-  k as asAuditAggregate,
-  W as asEventSourcingAggregate,
-  U as asSnapshotAggregate,
-  P as asVersioningAggregate,
-  z as getAggregateCapabilities,
-  q as hasAllCapabilities,
-  B as tryAsAuditAggregate,
+  U as aggregateBuilder,
+  W as asAuditAggregate,
+  B as asEventSourcingAggregate,
+  O as asSnapshotAggregate,
+  k as asVersioningAggregate,
+  q as getAggregateCapabilities,
+  K as hasAllCapabilities,
+  z as tryAsAuditAggregate,
   R as tryAsEventSourcingAggregate,
-  O as tryAsSnapshotAggregate,
-  j as tryAsVersioningAggregate
+  j as tryAsSnapshotAggregate,
+  P as tryAsVersioningAggregate
 };