@cqrs-ddd/core 0.2.0

package/dist/domain/decorators/mutable.decorator.js

@@ -0,0 +1,76 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mutable = Mutable;
+exports.getMutableFields = getMutableFields;
+const MUTABLE_FIELDS = Symbol('MUTABLE_FIELDS');
+/**
+ * Declares an aggregate property as mutable through domain methods.
+ *
+ * `RootEntity.applyPatch()` writes only to fields registered here, so the set of properties a
+ * mutation may touch is declared once on the field itself instead of being
+ * restated in every method that changes it.
+ *
+ * @param options - Patch key override and the field's normalizer.
+ * @returns A property decorator registering the field on the owning class.
+ *
+ * @example
+ * ```ts
+ * export class User extends RootEntity<UserSnapshot> {
+ *   @Mutable<string>({ normalize: (value) => User.normalizeUsername(value) })
+ *   private _username: string;
+ * }
+ * ```
+ */
+function Mutable(options = {}) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string') {
+            throw new TypeError('@Mutable() supports string properties only.');
+        }
+        // A static property decorates the class itself, whose constructor is `Function`.
+        const owner = target.constructor;
+        if (!owner || typeof target === 'function') {
+            throw new TypeError('@Mutable() supports instance properties only.');
+        }
+        const own = Object.hasOwn(owner, MUTABLE_FIELDS)
+            ? owner[MUTABLE_FIELDS]
+            : new Map();
+        owner[MUTABLE_FIELDS] = own;
+        const patchKey = options.as ?? propertyKey.replace(/^_/, '');
+        own.set(patchKey, {
+            propertyKey,
+            patchKey,
+            normalize: options.normalize,
+        });
+    };
+}
+/**
+ * Resolves every mutable field visible on an instance, including fields
+ * declared by base classes.
+ *
+ * @param instance - The aggregate to inspect.
+ * @returns Patch key to field definition, nearest declaration winning.
+ */
+function getMutableFields(instance) {
+    const resolved = new Map();
+    const chain = [];
+    let current = instance.constructor;
+    while (typeof current === 'function') {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    for (const owner of chain.reverse()) {
+        if (!Object.hasOwn(owner, MUTABLE_FIELDS)) {
+            continue;
+        }
+        const fields = owner[MUTABLE_FIELDS];
+        if (!fields) {
+            continue;
+        }
+        for (const [patchKey, definition] of fields) {
+            resolved.set(patchKey, definition);
+        }
+    }
+    return resolved;
+}
+//# sourceMappingURL=mutable.decorator.js.map

package/dist/domain/decorators/mutable.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutable.decorator.js","sourceRoot":"","sources":["../../../domain/decorators/mutable.decorator.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AAuDtE,0BA6BC;AASD,4CA0BC;AAxFD,MAAM,cAAc,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAMhD;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,OAAO,CACrB,UAAkC,EAAE;IAEpC,OAAO,CAAC,MAAc,EAAE,WAA4B,EAAE,EAAE;QACtD,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;YACpC,MAAM,IAAI,SAAS,CAAC,6CAA6C,CAAC,CAAC;QACrE,CAAC;QAED,iFAAiF;QACjF,MAAM,KAAK,GAAI,MAAmC,CAAC,WAEtC,CAAC;QAEd,IAAI,CAAC,KAAK,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YAC3C,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;QACvE,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,cAAc,CAAC;YAC9C,CAAC,CAAE,KAAK,CAAC,cAAc,CAAyC;YAChE,CAAC,CAAC,IAAI,GAAG,EAAkC,CAAC;QAC9C,KAAK,CAAC,cAAc,CAAC,GAAG,GAAG,CAAC;QAE5B,MAAM,QAAQ,GAAG,OAAO,CAAC,EAAE,IAAI,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC7D,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE;YAChB,WAAW;YACX,QAAQ;YACR,SAAS,EAAE,OAAO,CAAC,SAAsD;SAC1E,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAC9B,QAAgB;IAEhB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkC,CAAC;IAC3D,MAAM,KAAK,GAAqB,EAAE,CAAC;IAEnC,IAAI,OAAO,GAAY,QAAQ,CAAC,WAAW,CAAC;IAC5C,OAAO,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;QACrC,KAAK,CAAC,IAAI,CAAC,OAAyB,CAAC,CAAC;QACtC,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,cAAc,CAAC,EAAE,CAAC;YAC1C,SAAS;QACX,CAAC;QACD,MAAM,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC;QACrC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,SAAS;QACX,CAAC;QACD,KAAK,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,IAAI,MAAM,EAAE,CAAC;YAC5C,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/domain/events/domain.event.d.ts

@@ -0,0 +1,13 @@
+import type { IEvent } from './event.interface';
+/**
+ * Base class for all domain events.
+ *
+ * Carries a unique `id` (a time-sortable `uuidv7`) generated on construction
+ * unless one is supplied. Concrete events extend this to describe something that
+ * has happened in the domain.
+ */
+export declare abstract class DomainEvent implements IEvent {
+    readonly id: string;
+    protected constructor(id?: string);
+}
+//# sourceMappingURL=domain.event.d.ts.map

package/dist/domain/events/domain.event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.event.d.ts","sourceRoot":"","sources":["../../../domain/events/domain.event.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;GAMG;AACH,8BAAsB,WAAY,YAAW,MAAM;IACjD,SAAgB,EAAE,EAAE,MAAM,CAAC;IAE3B,SAAS,aAAa,EAAE,CAAC,EAAE,MAAM;CAGlC"}

package/dist/domain/events/domain.event.js

@@ -0,0 +1,20 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEvent = void 0;
+const uuidv7_1 = require("@cqrs-ddd/uuidv7");
+/**
+ * Base class for all domain events.
+ *
+ * Carries a unique `id` (a time-sortable `uuidv7`) generated on construction
+ * unless one is supplied. Concrete events extend this to describe something that
+ * has happened in the domain.
+ */
+class DomainEvent {
+    id;
+    constructor(id) {
+        this.id = id ?? (0, uuidv7_1.uuidv7)();
+    }
+}
+exports.DomainEvent = DomainEvent;
+//# sourceMappingURL=domain.event.js.map

package/dist/domain/events/domain.event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.event.js","sourceRoot":"","sources":["../../../domain/events/domain.event.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;AAEtE,6CAA0C;AAG1C;;;;;;GAMG;AACH,MAAsB,WAAW;IACf,EAAE,CAAS;IAE3B,YAAsB,EAAW;QAC/B,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,IAAA,eAAM,GAAE,CAAC;IAC3B,CAAC;CACF;AAND,kCAMC"}

package/dist/domain/events/event.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Marker interface for domain events.
+ *
+ * Framework-neutral base contract for all domain events buffered by
+ * {@link AggregateRoot} and published through {@link IDomainEventPublisher}.
+ */
+export interface IEvent {
+}
+//# sourceMappingURL=event.interface.d.ts.map

package/dist/domain/events/event.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.interface.d.ts","sourceRoot":"","sources":["../../../domain/events/event.interface.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,MAAM,WAAW,MAAM;CAAG"}

package/dist/domain/events/event.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=event.interface.js.map

package/dist/domain/events/event.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.interface.js","sourceRoot":"","sources":["../../../domain/events/event.interface.ts"],"names":[],"mappings":";AAAA,sEAAsE"}

package/dist/domain/events/root-domain.event.d.ts

@@ -0,0 +1,50 @@
+import { RootEntitySnapshot } from '../interfaces/root-entity-snapshot.interface';
+import { RootEntity } from '../models/root.entity';
+import { DomainEvent } from './domain.event';
+/** Payload type of an event raised from `T`: its `toJSON()` result, or `T` itself. */
+export type InferPayload<T> = T extends {
+    toJSON(): infer J;
+} ? J : T extends object ? T : unknown;
+/**
+ * Deep clones and recursively freezes any value, object, array, Date, Set, Map, or RegExp.
+ * Safely handles circular references via a WeakMap tracking visited objects.
+ * Guarantees that mutations on original nested objects do not leak into the clone.
+ *
+ * `Object.freeze` covers own properties only. The internal state of a cloned
+ * Date, Map or Set is guarded by overriding its mutating methods, which stops
+ * ordinary calls such as `date.setTime(...)` but not
+ * `Date.prototype.setTime.call(date, ...)`. Treat the result as detached and
+ * ordinarily read-only, not as a security boundary.
+ */
+export declare function deepCloneAndFreeze<T>(value: T, seen?: WeakMap<object, unknown>): T;
+/**
+ * A {@link DomainEvent} carrying aggregate identity/version and a detached,
+ * frozen state payload snapshot captured at event creation time.
+ *
+ * The snapshot is deep-cloned from the aggregate, so later aggregate mutations
+ * never reach it. Every consumer shares the same `payload` instance: its own
+ * properties are frozen, but Date/Map/Set internals can still be changed
+ * through their prototype methods (see {@link deepCloneAndFreeze}). A consumer
+ * that must not observe changes made by another consumer reads
+ * {@link RootDomainEvent.clonePayload} instead. Transports should serialize an
+ * explicit message rather than the payload object itself.
+ *
+ * @typeParam T - The aggregate input type used to infer the snapshot payload.
+ * @typeParam TPayload - The snapshot payload type.
+ */
+export declare class RootDomainEvent<T = RootEntity<Partial<RootEntitySnapshot>>, TPayload = InferPayload<T>> extends DomainEvent {
+    /** Detached, frozen state captured when the event was raised; shared by all consumers. */
+    readonly payload: Readonly<TPayload>;
+    /** Identity of the aggregate that raised the event. */
+    readonly aggregateId?: string;
+    /** Aggregate version at the moment the event was raised. */
+    readonly aggregateVersion?: number;
+    protected constructor(entity: T, payload?: TPayload);
+    /**
+     * Returns a new detached, frozen copy of {@link payload} on every call, so
+     * a change one consumer forces through a Date/Map/Set prototype method stays
+     * out of the shared payload and out of other copies.
+     */
+    clonePayload(): Readonly<TPayload>;
+}
+//# sourceMappingURL=root-domain.event.d.ts.map

package/dist/domain/events/root-domain.event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-domain.event.d.ts","sourceRoot":"","sources":["../../../domain/events/root-domain.event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,sFAAsF;AACtF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,MAAM,IAAI,MAAM,CAAC,CAAA;CAAE,GACzD,CAAC,GACD,CAAC,SAAS,MAAM,GACd,CAAC,GACD,OAAO,CAAC;AAwCd;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,EACR,IAAI,2BAAiC,GACpC,CAAC,CA+DH;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAe,CAC1B,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,EAC3C,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAC1B,SAAQ,WAAW;IACnB,0FAA0F;IAC1F,SAAgB,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAE5C,uDAAuD;IACvD,SAAgB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErC,4DAA4D;IAC5D,SAAgB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1C,SAAS,aAAa,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ;IAuBnD;;;;OAIG;IACH,YAAY,IAAI,QAAQ,CAAC,QAAQ,CAAC;CAGnC"}

package/dist/domain/events/root-domain.event.js

@@ -0,0 +1,156 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootDomainEvent = void 0;
+exports.deepCloneAndFreeze = deepCloneAndFreeze;
+const domain_event_1 = require("./domain.event");
+const MUTATING_DATE_METHODS = [
+    'setTime',
+    'setMilliseconds',
+    'setUTCMilliseconds',
+    'setSeconds',
+    'setUTCSeconds',
+    'setMinutes',
+    'setUTCMinutes',
+    'setHours',
+    'setUTCHours',
+    'setDate',
+    'setUTCDate',
+    'setMonth',
+    'setUTCMonth',
+    'setFullYear',
+    'setUTCFullYear',
+];
+const MUTATING_MAP_METHODS = ['set', 'delete', 'clear'];
+const MUTATING_SET_METHODS = ['add', 'delete', 'clear'];
+function freezeBuiltIn(copy, mutators, name) {
+    for (const method of mutators) {
+        Object.defineProperty(copy, method, {
+            value: () => {
+                throw new TypeError(`Cannot mutate frozen ${name}`);
+            },
+            configurable: false,
+            writable: false,
+        });
+    }
+    return Object.freeze(copy);
+}
+/**
+ * Deep clones and recursively freezes any value, object, array, Date, Set, Map, or RegExp.
+ * Safely handles circular references via a WeakMap tracking visited objects.
+ * Guarantees that mutations on original nested objects do not leak into the clone.
+ *
+ * `Object.freeze` covers own properties only. The internal state of a cloned
+ * Date, Map or Set is guarded by overriding its mutating methods, which stops
+ * ordinary calls such as `date.setTime(...)` but not
+ * `Date.prototype.setTime.call(date, ...)`. Treat the result as detached and
+ * ordinarily read-only, not as a security boundary.
+ */
+function deepCloneAndFreeze(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (seen.has(value)) {
+        return seen.get(value);
+    }
+    if (value instanceof Date) {
+        const copy = new Date(value.getTime());
+        return freezeBuiltIn(copy, MUTATING_DATE_METHODS, 'Date');
+    }
+    if (value instanceof RegExp) {
+        const copy = new RegExp(value.source, value.flags);
+        return Object.freeze(copy);
+    }
+    if (Array.isArray(value)) {
+        const copy = [];
+        seen.set(value, copy);
+        for (let i = 0; i < value.length; i++) {
+            copy[i] = deepCloneAndFreeze(value[i], seen);
+        }
+        return Object.freeze(copy);
+    }
+    if (value instanceof Map) {
+        const copy = new Map();
+        seen.set(value, copy);
+        for (const [k, v] of value.entries()) {
+            copy.set(deepCloneAndFreeze(k, seen), deepCloneAndFreeze(v, seen));
+        }
+        return freezeBuiltIn(copy, MUTATING_MAP_METHODS, 'Map');
+    }
+    if (value instanceof Set) {
+        const copy = new Set();
+        seen.set(value, copy);
+        for (const v of value.values()) {
+            copy.add(deepCloneAndFreeze(v, seen));
+        }
+        return freezeBuiltIn(copy, MUTATING_SET_METHODS, 'Set');
+    }
+    const proto = Object.getPrototypeOf(value);
+    const copy = Object.create(proto === Object.prototype || proto === null ? proto : Object.prototype);
+    seen.set(value, copy);
+    for (const key of Reflect.ownKeys(value)) {
+        const desc = Object.getOwnPropertyDescriptor(value, key);
+        if (desc) {
+            if ('value' in desc) {
+                desc.value = deepCloneAndFreeze(desc.value, seen);
+            }
+            Object.defineProperty(copy, key, desc);
+        }
+    }
+    return Object.freeze(copy);
+}
+/**
+ * A {@link DomainEvent} carrying aggregate identity/version and a detached,
+ * frozen state payload snapshot captured at event creation time.
+ *
+ * The snapshot is deep-cloned from the aggregate, so later aggregate mutations
+ * never reach it. Every consumer shares the same `payload` instance: its own
+ * properties are frozen, but Date/Map/Set internals can still be changed
+ * through their prototype methods (see {@link deepCloneAndFreeze}). A consumer
+ * that must not observe changes made by another consumer reads
+ * {@link RootDomainEvent.clonePayload} instead. Transports should serialize an
+ * explicit message rather than the payload object itself.
+ *
+ * @typeParam T - The aggregate input type used to infer the snapshot payload.
+ * @typeParam TPayload - The snapshot payload type.
+ */
+class RootDomainEvent extends domain_event_1.DomainEvent {
+    /** Detached, frozen state captured when the event was raised; shared by all consumers. */
+    payload;
+    /** Identity of the aggregate that raised the event. */
+    aggregateId;
+    /** Aggregate version at the moment the event was raised. */
+    aggregateVersion;
+    constructor(entity, payload) {
+        super();
+        const source = entity;
+        this.aggregateId = typeof source?.id === 'string' ? source.id : undefined;
+        this.aggregateVersion =
+            typeof source?.version === 'number' ? source.version : undefined;
+        let rawPayload;
+        if (payload !== undefined) {
+            rawPayload = payload;
+        }
+        else if (entity &&
+            typeof entity.toJSON === 'function') {
+            rawPayload = entity.toJSON();
+        }
+        else if (entity && typeof entity === 'object') {
+            rawPayload = { ...entity };
+        }
+        else {
+            rawPayload = {};
+        }
+        this.payload = deepCloneAndFreeze(rawPayload);
+    }
+    /**
+     * Returns a new detached, frozen copy of {@link payload} on every call, so
+     * a change one consumer forces through a Date/Map/Set prototype method stays
+     * out of the shared payload and out of other copies.
+     */
+    clonePayload() {
+        return deepCloneAndFreeze(this.payload);
+    }
+}
+exports.RootDomainEvent = RootDomainEvent;
+//# sourceMappingURL=root-domain.event.js.map

package/dist/domain/events/root-domain.event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-domain.event.js","sourceRoot":"","sources":["../../../domain/events/root-domain.event.ts"],"names":[],"mappings":"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"}

package/dist/domain/exceptions/concurrency-conflict.error.d.ts

@@ -0,0 +1,20 @@
+import { DomainException } from './domain.exception';
+/**
+ * Framework-neutral signal that a version-conditioned write lost a race.
+ *
+ * Persistence adapters translate their own concurrency failures into this error,
+ * exactly as they translate transient driver faults into
+ * {@link TransientOperationError}, so no ORM exception class reaches the
+ * application layer or the presentation boundary.
+ *
+ * Transport adapters map it to their own conflict representation, such as
+ * HTTP 409 through `domainErrorHttpStatus`.
+ */
+export declare class ConcurrencyConflictError extends DomainException {
+    readonly entityName: string;
+    readonly entityId: string;
+    readonly expectedVersion: number;
+    readonly actualVersion?: number | undefined;
+    constructor(entityName: string, entityId: string, expectedVersion: number, actualVersion?: number | undefined);
+}
+//# sourceMappingURL=concurrency-conflict.error.d.ts.map

package/dist/domain/exceptions/concurrency-conflict.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency-conflict.error.d.ts","sourceRoot":"","sources":["../../../domain/exceptions/concurrency-conflict.error.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,qBAAa,wBAAyB,SAAQ,eAAe;IAEzD,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM;gBAHtB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,YAAA;CAOlC"}

package/dist/domain/exceptions/concurrency-conflict.error.js

@@ -0,0 +1,32 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcurrencyConflictError = void 0;
+const domain_exception_1 = require("./domain.exception");
+/**
+ * Framework-neutral signal that a version-conditioned write lost a race.
+ *
+ * Persistence adapters translate their own concurrency failures into this error,
+ * exactly as they translate transient driver faults into
+ * {@link TransientOperationError}, so no ORM exception class reaches the
+ * application layer or the presentation boundary.
+ *
+ * Transport adapters map it to their own conflict representation, such as
+ * HTTP 409 through `domainErrorHttpStatus`.
+ */
+class ConcurrencyConflictError extends domain_exception_1.DomainException {
+    entityName;
+    entityId;
+    expectedVersion;
+    actualVersion;
+    constructor(entityName, entityId, expectedVersion, actualVersion) {
+        super(`${entityName} ${entityId} was modified concurrently: expected version ${expectedVersion}` +
+            (actualVersion === undefined ? '.' : `, found ${actualVersion}.`));
+        this.entityName = entityName;
+        this.entityId = entityId;
+        this.expectedVersion = expectedVersion;
+        this.actualVersion = actualVersion;
+    }
+}
+exports.ConcurrencyConflictError = ConcurrencyConflictError;
+//# sourceMappingURL=concurrency-conflict.error.js.map

package/dist/domain/exceptions/concurrency-conflict.error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency-conflict.error.js","sourceRoot":"","sources":["../../../domain/exceptions/concurrency-conflict.error.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;AAEtE,yDAAqD;AAErD;;;;;;;;;;GAUG;AACH,MAAa,wBAAyB,SAAQ,kCAAe;IAEhD;IACA;IACA;IACA;IAJX,YACW,UAAkB,EAClB,QAAgB,EAChB,eAAuB,EACvB,aAAsB;QAE/B,KAAK,CACH,GAAG,UAAU,IAAI,QAAQ,gDAAgD,eAAe,EAAE;YACxF,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,aAAa,GAAG,CAAC,CACpE,CAAC;QARO,eAAU,GAAV,UAAU,CAAQ;QAClB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,oBAAe,GAAf,eAAe,CAAQ;QACvB,kBAAa,GAAb,aAAa,CAAS;IAMjC,CAAC;CACF;AAZD,4DAYC"}

package/dist/domain/exceptions/domain.exception.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Base class for all domain-layer exceptions.
+ *
+ * Decouples business invariant failures from web frameworks, HTTP status codes,
+ * and transport boundaries, ensuring domain logic remains pure and executable
+ * across HTTP APIs, background jobs, CLIs, and microservices.
+ *
+ * Domain exceptions carry domain-specific contextual properties (e.g. invalid
+ * field values, threshold limits) rather than HTTP status codes. Presentation
+ * boundaries (such as NestJS exception filters) translate them into appropriate
+ * transport responses (e.g., HTTP 400, 409, 422).
+ *
+ * @example Defining a concrete domain exception
+ * ```typescript
+ * export class InvalidUsernameException extends DomainException {
+ *   readonly minLength: number;
+ *   readonly actualValue: string;
+ *
+ *   constructor(actualValue: string, minLength = 3) {
+ *     super(`Username must be at least ${minLength} characters, received: "${actualValue}".`);
+ *     this.minLength = minLength;
+ *     this.actualValue = actualValue;
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class DomainException extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=domain.exception.d.ts.map

package/dist/domain/exceptions/domain.exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.exception.d.ts","sourceRoot":"","sources":["../../../domain/exceptions/domain.exception.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8BAAsB,eAAgB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM;CAK5B"}

package/dist/domain/exceptions/domain.exception.js

@@ -0,0 +1,39 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainException = void 0;
+/**
+ * Base class for all domain-layer exceptions.
+ *
+ * Decouples business invariant failures from web frameworks, HTTP status codes,
+ * and transport boundaries, ensuring domain logic remains pure and executable
+ * across HTTP APIs, background jobs, CLIs, and microservices.
+ *
+ * Domain exceptions carry domain-specific contextual properties (e.g. invalid
+ * field values, threshold limits) rather than HTTP status codes. Presentation
+ * boundaries (such as NestJS exception filters) translate them into appropriate
+ * transport responses (e.g., HTTP 400, 409, 422).
+ *
+ * @example Defining a concrete domain exception
+ * ```typescript
+ * export class InvalidUsernameException extends DomainException {
+ *   readonly minLength: number;
+ *   readonly actualValue: string;
+ *
+ *   constructor(actualValue: string, minLength = 3) {
+ *     super(`Username must be at least ${minLength} characters, received: "${actualValue}".`);
+ *     this.minLength = minLength;
+ *     this.actualValue = actualValue;
+ *   }
+ * }
+ * ```
+ */
+class DomainException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.DomainException = DomainException;
+//# sourceMappingURL=domain.exception.js.map

package/dist/domain/exceptions/domain.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.exception.js","sourceRoot":"","sources":["../../../domain/exceptions/domain.exception.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAsB,eAAgB,SAAQ,KAAK;IACjD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;QAC5B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;CACF;AAND,0CAMC"}

package/dist/domain/exceptions/entity-not-found.exception.d.ts

@@ -0,0 +1,14 @@
+import { DomainException } from './domain.exception';
+/**
+ * Framework-neutral lookup failure for an aggregate or entity required by a use case.
+ *
+ * Application and persistence layers may throw this exception without importing
+ * HTTP/Nest presentation semantics. Transport adapters are responsible for mapping
+ * it to their own not-found representation (such as HTTP 404).
+ */
+export declare class EntityNotFoundException extends DomainException {
+    readonly entityName: string;
+    readonly entityId?: string | undefined;
+    constructor(entityName: string, entityId?: string | undefined);
+}
+//# sourceMappingURL=entity-not-found.exception.d.ts.map

package/dist/domain/exceptions/entity-not-found.exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-not-found.exception.d.ts","sourceRoot":"","sources":["../../../domain/exceptions/entity-not-found.exception.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,eAAe;IAExD,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM;gBADjB,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,YAAA;CAI7B"}

package/dist/domain/exceptions/entity-not-found.exception.js

@@ -0,0 +1,23 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityNotFoundException = void 0;
+const domain_exception_1 = require("./domain.exception");
+/**
+ * Framework-neutral lookup failure for an aggregate or entity required by a use case.
+ *
+ * Application and persistence layers may throw this exception without importing
+ * HTTP/Nest presentation semantics. Transport adapters are responsible for mapping
+ * it to their own not-found representation (such as HTTP 404).
+ */
+class EntityNotFoundException extends domain_exception_1.DomainException {
+    entityName;
+    entityId;
+    constructor(entityName, entityId) {
+        super(`${entityName} not found`);
+        this.entityName = entityName;
+        this.entityId = entityId;
+    }
+}
+exports.EntityNotFoundException = EntityNotFoundException;
+//# sourceMappingURL=entity-not-found.exception.js.map

package/dist/domain/exceptions/entity-not-found.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-not-found.exception.js","sourceRoot":"","sources":["../../../domain/exceptions/entity-not-found.exception.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;AAEtE,yDAAqD;AAErD;;;;;;GAMG;AACH,MAAa,uBAAwB,SAAQ,kCAAe;IAE/C;IACA;IAFX,YACW,UAAkB,EAClB,QAAiB;QAE1B,KAAK,CAAC,GAAG,UAAU,YAAY,CAAC,CAAC;QAHxB,eAAU,GAAV,UAAU,CAAQ;QAClB,aAAQ,GAAR,QAAQ,CAAS;IAG5B,CAAC;CACF;AAPD,0DAOC"}

package/dist/domain/exceptions/invalid-value.exception.d.ts

@@ -0,0 +1,35 @@
+import type { ValueViolation } from '../rules/value-violation';
+import { DomainException } from './domain.exception';
+/**
+ * A value broke a rule of a {@link textRule} or {@link numberRule}.
+ *
+ * It is the error both rules throw by default, and the base class for an
+ * application's own exceptions, which then share its message format and its
+ * `violation`. `domainErrorHttpStatus()` answers 400 for it, like any other
+ * `DomainException`.
+ *
+ * The rejected value is not kept, so logging the exception cannot leak it.
+ *
+ * @example
+ * ```ts
+ * export class InvalidUsernameException extends InvalidValueException {}
+ *
+ * const username = textRule({
+ *   field: 'username',
+ *   minLength: 3,
+ *   error: (violation) => new InvalidUsernameException(violation),
+ * });
+ *
+ * username.normalize('ab');
+ * // throws InvalidUsernameException: "username must be at least 3 characters."
+ * ```
+ */
+export declare class InvalidValueException extends DomainException {
+    readonly violation: ValueViolation;
+    /**
+     * @param violation - The broken rule.
+     * @param message - Replaces the default message built from `violation`.
+     */
+    constructor(violation: ValueViolation, message?: string);
+}
+//# sourceMappingURL=invalid-value.exception.d.ts.map

package/dist/domain/exceptions/invalid-value.exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-value.exception.d.ts","sourceRoot":"","sources":["../../../domain/exceptions/invalid-value.exception.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AA4BrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,qBAAsB,SAAQ,eAAe;IACxD,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IAEnC;;;OAGG;gBACS,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,MAAM;CAIxD"}