@vytches/ddd-aggregates 0.30.0 → 0.31.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 N, enrichEvent as M, createDomainEvent as T, EntityId as f } from "@vytches/ddd-contracts";
+import { internalLogger as y } from "@vytches/ddd-contracts/internal";
+import { LibUtils as E, Result as l } from "@vytches/ddd-utils";
+import { IDomainError as L, DomainErrorCode as c } 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;
-    let n = t;
+    let s = 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",
+      const g = this.upcasters.get(t.eventName);
+      for (let h = i; h < a; h++) {
+        const m = g.get(h);
+        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: h,
+              toVersion: h + 1
             }
           );
           continue;
         }
-        const I = f.upcast(n.payload, n.metadata);
-        n = {
-          ...n,
-          payload: I,
+        const D = m.upcast(s.payload, s.metadata);
+        s = {
+          ...s,
+          payload: D,
           metadata: {
-            ...n.metadata,
-            version: u + 1
+            ...s.metadata,
+            version: h + 1
           }
         };
       }
     }
-    const c = e.get(n.eventName);
-    c && c(n.payload, n.metadata);
+    const o = e.get(s.eventName);
+    o && o(s.payload, s.metadata);
   }
   /**
    * @returns {string[]} Array of event types that have registered upcasters
@@ -99,9 +112,10 @@ class p extends l {
     return t;
   }
 }
-class v {
+const b = 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._domainEventsCache = Object.freeze([]), this._domainEventsCacheDirty = !0, this._eventHandlers = /* @__PURE__ */ new Map(), this._capabilities = new N(), 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,17 +172,98 @@ 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).
    *
+   * VP-012b (D2, BREAKING behavior change, non-breaking signature): the
+   * returned array reference is now **stable between calls** — the same
+   * frozen array object is returned on every call until the next mutation
+   * (`apply()`, `commit()`, `loadFromHistory()`, or
+   * `transformDomainEvents()`), instead of a fresh array being built on
+   * every call as before. Content equality (`toEqual`) is unaffected either
+   * way. Code that relies on *identity* — e.g. asserting `not.toBe`/`!==`
+   * between two `getDomainEvents()` calls to prove "each call returns a new
+   * array" — will observe the new stable-reference behavior and must be
+   * updated; asserting `.toBe`/`===` between two calls made with no
+   * intervening mutation now holds, where it previously did not. This is
+   * safe to alias: the returned array and its contents are frozen, so
+   * holding onto the reference across a mutation still reflects the state
+   * as of the call that produced it (the cache is not that same array
+   * anymore after invalidation — a stored old reference is simply stale
+   * data, never mutated out from under the caller).
    * @returns {ReadonlyArray<IDomainEvent>} Array of uncommitted domain events
    */
   getDomainEvents() {
-    return [...this._domainEvents];
+    if (this._domainEventsCacheDirty) {
+      const t = /* @__PURE__ */ new WeakSet(), e = this._domainEvents.map((i) => E.deepFreeze(i, t));
+      this._domainEventsCache = Object.freeze(e), this._domainEventsCacheDirty = !1;
+    }
+    return this._domainEventsCache;
+  }
+  /**
+   * VP-012b (D2): single invalidation point for `_domainEventsCache`,
+   * called from every site that mutates `_domainEvents` — `apply()`,
+   * `commit()`, `transformDomainEvents()`, `loadFromHistory()`, and
+   * `_internal_setState()`. Keeping invalidation in one helper (rather than
+   * setting the flag ad hoc at each call site) means a future mutation site
+   * cannot silently forget to invalidate.
+   */
+  _invalidateDomainEventsCache() {
+    this._domainEventsCacheDirty = !0;
   }
   /**
    * Clear all uncommitted domain events and update initial version
    */
   commit() {
-    this._domainEvents = [], this._initialVersion = this._version;
+    this._domainEvents = [], this._initialVersion = this._version, this._invalidateDomainEventsCache();
+  }
+  /**
+   * Rewrite the payload and/or metadata of the uncommitted domain events.
+   *
+   * This is an infrastructure boundary API, in the same family as `commit()`:
+   * call it from a repository immediately before persisting, never from the
+   * domain or application layer. An aggregate records events through `apply()`;
+   * it does not rewrite its own history.
+   *
+   * It exists for data that only the persistence boundary knows — a
+   * crypto-shredding key id resolved at save time, a correlation id assigned at
+   * dispatch, an encrypted payload. Doing this by hand from outside is not
+   * possible: `getDomainEvents()` deep-freezes what it returns, and the
+   * internal list is private. The transformation has to land here rather than
+   * on a local copy inside `save()`, because the event dispatcher reads the
+   * aggregate's events again — a local copy would leave the in-process event
+   * bus publishing the untransformed originals.
+   *
+   * Only `payload` and `metadata` can be replaced. `eventName`, identity, and
+   * the number and order of events are fixed: changing those would desync
+   * handlers on replay or break the version invariant. Return nothing to leave
+   * an event as it is.
+   *
+   * Identity, prototype and `instanceof` survive, and the event's constructor
+   * is never called, so event classes with their own constructor arguments are
+   * safe.
+   *
+   * @example
+   * // inside a repository's save(), before persisting:
+   * order.transformDomainEvents(event => ({
+   *   payload: encrypt(event.payload, key),
+   *   metadata: { userSpecificKeyId: key.id },
+   * }));
+   *
+   * @param transform - Called per event; returns the parts to replace, or nothing to keep it
+   */
+  transformDomainEvents(t) {
+    this._domainEvents = this._domainEvents.map((e, i) => {
+      const a = t(e, i);
+      return a ? M(e, a) : e;
+    }), this._invalidateDomainEventsCache();
   }
   // ==========================================
   // EVENT HANDLING - Type-safe approach
@@ -162,27 +281,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 a = this._version + 1;
+    let s, o;
+    typeof t == "string" ? (s = T(t, e, i), o = s.metadata) : (s = t, o = i ? { ...s.metadata, ...i } : s.metadata);
+    const g = u.sanitizeMetadata({
+      ...o,
+      aggregateId: this._id.toString(),
+      aggregateType: this.constructor.name,
+      aggregateVersion: a,
+      timestamp: o?.timestamp ?? /* @__PURE__ */ new Date()
+    }), h = Object.assign(
+      Object.create(Object.getPrototypeOf(s)),
+      s,
+      { metadata: g }
+    );
+    this._version = a, this._domainEvents.push(h), this._invalidateDomainEventsCache(), this.handleEvent(h);
   }
   handleEvent(t) {
     const e = this.getCapability(p);
@@ -190,15 +322,30 @@ 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
    */
   loadFromHistory(t) {
-    this._version = this._initialVersion, this._domainEvents = [];
+    this._version = this._initialVersion, this._domainEvents = [], this._invalidateDomainEventsCache();
     for (const e of t)
       this.handleEvent(e), this._version++;
     this._initialVersion = this._version;
@@ -263,14 +410,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 !== b)
+      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], this._invalidateDomainEventsCache();
   }
 }
-class b extends l {
+class _ extends d {
   constructor() {
     super(...arguments), this.type = "audit", this.auditLog = [];
   }
@@ -306,12 +467,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((a, s) => {
+      if (t[a.eventName] = (t[a.eventName] || 0) + 1, s > 0) {
+        const o = this.auditLog[s - 1];
+        if (o) {
+          const g = new Date(o.timestamp).getTime(), h = new Date(a.timestamp).getTime();
+          e += h - g;
         }
       }
     });
@@ -334,7 +495,7 @@ class b extends l {
    */
   recordEvent(t) {
     const e = {
-      eventId: t.metadata?.eventId || `audit-${Date.now()}-${Math.random()}`,
+      eventId: t.metadata?.eventId || `audit-${E.getUUID()}`,
       eventName: t.eventName,
       aggregateId: this.aggregate.getId().toString(),
       aggregateType: this.aggregate.constructor.name,
@@ -380,13 +541,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: c.InvalidParameter,
       data: e
     };
     return new r(t, i);
@@ -395,8 +556,8 @@ 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,
+    const s = `Version conflict: Aggregate ${t} with ID ${e} has version ${i}, but expected ${a}`, o = {
+      code: c.ValidationFailed,
       data: {
         aggregateType: t,
         aggregateId: e,
@@ -404,14 +565,14 @@ class r extends M {
         expectedVersion: a
       }
     };
-    return new r(n, c);
+    return new r(s, 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: c.ValidationFailed,
       data: {
         feature: t
       }
@@ -423,7 +584,7 @@ class r extends M {
    */
   static methodNotImplemented(t, e) {
     const i = `Method '${t}' must be implemented by ${e} to use this feature`, a = {
-      code: o.MissingValue,
+      code: c.MissingValue,
       data: {
         methodName: t,
         aggregateType: e
@@ -436,7 +597,7 @@ class r extends M {
    */
   static invalidSnapshot(t, e) {
     const i = `Invalid snapshot for aggregate ${t}${e ? `: ${e}` : ""}`, a = {
-      code: o.InvalidFormat,
+      code: c.InvalidFormat,
       data: {
         aggregateType: t,
         reason: e
@@ -449,7 +610,7 @@ class r extends M {
    */
   static idMismatch(t, e) {
     const i = `ID mismatch: Snapshot is for ID ${t}, but aggregate has ID ${e}`, a = {
-      code: o.ValidationFailed,
+      code: c.ValidationFailed,
       data: {
         snapshotId: t,
         aggregateId: e
@@ -462,7 +623,7 @@ class r extends M {
    */
   static typeMismatch(t, e) {
     const i = `Aggregate type mismatch: Snapshot is for type ${t}, but trying to load into ${e}`, a = {
-      code: o.ValidationFailed,
+      code: c.ValidationFailed,
       data: {
         snapshotType: t,
         aggregateType: e
@@ -475,7 +636,7 @@ class r extends M {
    */
   static duplicateUpcaster(t, e) {
     const i = `Upcaster for event ${t} version ${e} already exists`, a = {
-      code: o.DuplicateEntry,
+      code: c.DuplicateEntry,
       data: {
         eventType: t,
         sourceVersion: e
@@ -487,22 +648,22 @@ class r extends M {
    * 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 a = `Missing upcaster for event ${t} from version ${e} to ${i}`, s = {
+      code: c.MissingValue,
       data: {
         eventType: t,
         fromVersion: e,
         toVersion: i
       }
     };
-    return new r(a, n);
+    return new r(a, s);
   }
   /**
    * Error for configuration problems
    */
   static configurationError(t, e) {
     const i = `Configuration error in ${t}: ${e}`, a = {
-      code: o.ValidationFailed,
+      code: c.ValidationFailed,
       data: {
         aggregateType: t,
         configurationError: e
@@ -515,7 +676,7 @@ class r extends M {
    */
   static cannotInterceptApplyMethod(t, e) {
     const i = `Cannot intercept apply method - method not found on aggregate ${t}`, a = {
-      code: o.InternalError,
+      code: c.InternalError,
       data: {
         aggergateId: t,
         ...e
@@ -528,7 +689,7 @@ class r extends M {
    */
   static eventStoreNotConfigured(t) {
     const e = "Event store not configured", i = {
-      code: o.MissingValue,
+      code: c.MissingValue,
       data: t
     };
     return new r(e, i);
@@ -538,7 +699,7 @@ class r extends M {
    */
   static aggregateDoesNotSupportReplay(t, e) {
     const i = `Aggregate ${t} does not support event replay`, a = {
-      code: o.MethodNotSupported,
+      code: c.MethodNotSupported,
       data: {
         aggregateType: t,
         ...e
@@ -547,7 +708,7 @@ class r extends M {
     return new r(i, a);
   }
 }
-class E extends l {
+class w extends d {
   constructor() {
     super(...arguments), this.type = "eventSourcing", this.eventStore = null;
   }
@@ -634,7 +795,7 @@ class E extends l {
     a.loadFromHistory && i.length > 0 && a.loadFromHistory(i);
   }
 }
-class S extends l {
+class S extends d {
   constructor() {
     super(...arguments), this.type = "snapshot", this._snapshot = null;
   }
@@ -656,13 +817,13 @@ 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(), s = (i.length > 0 ? i[i.length - 1] : null)?.metadata?.eventId, g = {
       aggregateId: this.aggregate.getId().toString(),
       version: this.aggregate.getVersion(),
       aggregateType: this.aggregate.constructor.name,
       state: t(),
       timestamp: /* @__PURE__ */ new Date(),
-      ...n !== void 0 && { lastEventId: n }
+      ...s !== void 0 && { lastEventId: s }
     };
     return e && (g.metadata = e()), g;
   }
@@ -680,9 +841,7 @@ class S extends l {
       throw r.idMismatch(t.aggregateId, a);
     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(b, {
       version: t.version,
       initialVersion: t.version,
       domainEvents: []
@@ -715,7 +874,7 @@ class S extends l {
     return this._snapshot = null, t;
   }
 }
-class m {
+class v {
   constructor(t) {
     this.capabilities = [], this.params = t;
   }
@@ -724,10 +883,10 @@ 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;
@@ -742,14 +901,14 @@ class m {
    * @returns {this} Builder instance for method chaining
    */
   withAudit() {
-    return this.capabilities.push({ capability: new b() }), this;
+    return this.capabilities.push({ capability: new _() }), 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 w();
     return this.capabilities.push({
       capability: e,
       configure: (i) => {
@@ -777,9 +936,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: a, configure: s } of this.capabilities)
+      i.addCapability(a), s && s(a);
     return i;
   }
   /**
@@ -790,10 +949,10 @@ class m {
     return this.withSnapshots().withVersioning().withAudit().withEventSourcing().build(t);
   }
 }
-function H(s) {
-  return m.create(s);
+function O(n) {
+  return v.create(n);
 }
-class w {
+class C {
   constructor(t) {
     this._id = t;
   }
@@ -812,77 +971,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(n) {
+  return n.hasCapability(S);
 }
-function C(s) {
-  return s.hasCapability(p);
+function I(n) {
+  return n.hasCapability(p);
 }
-function V(s) {
-  return s.hasCapability(b);
+function A(n) {
+  return n.hasCapability(_);
 }
-function A(s) {
-  return s.hasCapability(E);
+function $(n) {
+  return n.hasCapability(w);
 }
-function U(s) {
-  if (!_(s))
+function j(n) {
+  if (!V(n))
     throw r.featureNotEnabled("snapshot");
-  return s;
+  return n;
 }
-function O(s) {
-  return _(s) ? h.ok(s) : h.fail(r.featureNotEnabled("snapshot"));
+function k(n) {
+  return V(n) ? l.ok(n) : l.fail(r.featureNotEnabled("snapshot"));
 }
-function P(s) {
-  if (!C(s))
+function P(n) {
+  if (!I(n))
     throw r.featureNotEnabled("versioning");
-  return s;
+  return n;
 }
-function j(s) {
-  return C(s) ? h.ok(s) : h.fail(r.featureNotEnabled("versioning"));
+function W(n) {
+  return I(n) ? l.ok(n) : l.fail(r.featureNotEnabled("versioning"));
 }
-function k(s) {
-  if (!V(s))
+function z(n) {
+  if (!A(n))
     throw r.featureNotEnabled("audit");
-  return s;
+  return n;
 }
-function B(s) {
-  return V(s) ? h.ok(s) : h.fail(r.featureNotEnabled("audit"));
+function B(n) {
+  return A(n) ? l.ok(n) : l.fail(r.featureNotEnabled("audit"));
 }
-function W(s) {
-  if (!A(s))
+function R(n) {
+  if (!$(n))
     throw r.featureNotEnabled("eventSourcing");
-  return s;
+  return n;
 }
-function R(s) {
-  return A(s) ? h.ok(s) : h.fail(r.featureNotEnabled("eventSourcing"));
+function q(n) {
+  return $(n) ? l.ok(n) : l.fail(r.featureNotEnabled("eventSourcing"));
 }
-function z(s) {
-  return s.getCapabilityTypes();
+function K(n) {
+  return n.getCapabilityTypes();
 }
-function q(s, t) {
-  return t.every((e) => s.hasCapability(e));
+function G(n, t) {
+  return t.every((e) => n.hasCapability(e));
 }
 export {
-  m as AggregateBuilder,
+  v as AggregateBuilder,
   r as AggregateError,
-  v as AggregateRoot,
-  b as AuditCapability,
-  w as Entity,
-  E as EventSourcingCapability,
+  u as AggregateRoot,
+  _ as AuditCapability,
+  C as Entity,
+  w as EventSourcingCapability,
   S as SnapshotCapability,
   p as VersioningCapability,
-  H as aggregateBuilder,
-  k as asAuditAggregate,
-  W as asEventSourcingAggregate,
-  U as asSnapshotAggregate,
+  O as aggregateBuilder,
+  z as asAuditAggregate,
+  R as asEventSourcingAggregate,
+  j as asSnapshotAggregate,
   P as asVersioningAggregate,
-  z as getAggregateCapabilities,
-  q as hasAllCapabilities,
+  K as getAggregateCapabilities,
+  G as hasAllCapabilities,
   B as tryAsAuditAggregate,
-  R as tryAsEventSourcingAggregate,
-  O as tryAsSnapshotAggregate,
-  j as tryAsVersioningAggregate
+  q as tryAsEventSourcingAggregate,
+  k as tryAsSnapshotAggregate,
+  W as tryAsVersioningAggregate
 };