@cullet/erp-core 1.1.0 → 1.3.0

package/dist/validation-error.d.ts

@@ -1,4 +1,5 @@
 import { a as JsonSafeRecord, n as AppErrorOptions, r as ErrorSeverity, t as AppError } from "./app-error.js";
+import { t as ValidationCode } from "./validation-code.js";
 import { t as ValidationField } from "./validation-field.js";
 
 //#region src/core/errors/error-codes.d.ts
@@ -749,27 +750,6 @@ declare class UnexpectedError extends AppError {
   constructor(message?: string, cause?: unknown, options?: Omit<AppErrorOptions, "cause">);
 }
 //#endregion
-//#region src/core/exceptions/validation-code.d.ts
-declare class ValidationCode {
-  readonly value: string;
-  private constructor();
-  static of(value: string): ValidationCode;
-  static readonly BLANK: ValidationCode;
-  static readonly REQUIRED: ValidationCode;
-  static readonly INVALID_FORMAT: ValidationCode;
-  static readonly INVALID_CHARACTERS: ValidationCode;
-  static readonly INVALID_LENGTH: ValidationCode;
-  static readonly TOO_SHORT: ValidationCode;
-  static readonly TOO_LONG: ValidationCode;
-  static readonly OUT_OF_RANGE: ValidationCode;
-  static readonly INVALID_CHECKSUM: ValidationCode;
-  static readonly INVALID_CHECKING_DIGIT: ValidationCode;
-  static readonly ALREADY_EXISTS: ValidationCode;
-  static readonly NOT_FOUND: ValidationCode;
-  static readonly NOT_ALLOWED: ValidationCode;
-  static readonly UNEXPECTED: ValidationCode;
-}
-//#endregion
 //#region src/core/errors/validation-error.d.ts
 /**
  * Raised when a single input fails a validation rule — the canonical

package/dist/validation-error.js

@@ -1,4 +1,4 @@
-import { a as ErrorCodes, o as serializationErrorCode, r as AppError } from "./validation-code.js";
+import { a as serializationErrorCode, i as ErrorCodes, n as AppError } from "./unexpected-error.js";
 //#region src/core/errors/authentication-error.ts
 var AuthenticationError = class AuthenticationError extends AppError {
 	constructor(params) {

package/dist/validation-exception.cjs

@@ -0,0 +1,41 @@
+const require_domain_exception = require("./domain-exception.cjs");
+//#region src/core/exceptions/validation-exception.ts
+var ValidationException = class extends require_domain_exception.DomainException {
+	constructor(field, code, message) {
+		super(message);
+		this.field = field;
+		this.code = code;
+	}
+};
+var MultipleValidationException = class extends require_domain_exception.DomainException {
+	constructor(violations) {
+		super(violations.map((v) => v.message).join("; "));
+		this.violations = violations;
+	}
+};
+var InvalidValueException = class extends ValidationException {
+	constructor(field, code, message) {
+		super(field, code, message);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "InvalidValueException", {
+	enumerable: true,
+	get: function() {
+		return InvalidValueException;
+	}
+});
+Object.defineProperty(exports, "MultipleValidationException", {
+	enumerable: true,
+	get: function() {
+		return MultipleValidationException;
+	}
+});
+Object.defineProperty(exports, "ValidationException", {
+	enumerable: true,
+	get: function() {
+		return ValidationException;
+	}
+});
+
+//# sourceMappingURL=validation-exception.cjs.map

package/dist/validation-exception.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-exception.cjs","names":["DomainException"],"sources":["../src/core/exceptions/validation-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\nimport { ValidationCode } from \"./validation-code.js\";\nimport { ValidationField } from \"./validation-field.js\";\n\nexport interface ValidationViolation {\n    readonly field: ValidationField;\n    readonly code: ValidationCode;\n    readonly message: string;\n}\n\nclass ValidationException extends DomainException {\n    constructor(\n        public readonly field: ValidationField,\n        public readonly code: ValidationCode,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\n// Carries multiple validation violations from a single operation (e.g. bulk validation).\n// Use when you need to report all field errors at once rather than failing on the first.\nclass MultipleValidationException extends DomainException {\n    constructor(public readonly violations: readonly ValidationViolation[]) {\n        super(violations.map((v) => v.message).join(\"; \"));\n    }\n}\n\nclass InvalidValueException extends ValidationException {\n    constructor(field: ValidationField, code: ValidationCode, message: string) {\n        super(field, code, message);\n    }\n}\n\nexport {\n    InvalidValueException,\n    MultipleValidationException,\n    ValidationException,\n};\n"],"mappings":";;AAUA,IAAM,sBAAN,cAAkCA,yBAAAA,gBAAgB;CAC9C,YACI,OACA,MACA,SACF;EACE,MAAM,OAAO;EAJG,KAAA,QAAA;EACA,KAAA,OAAA;CAIpB;AACJ;AAIA,IAAM,8BAAN,cAA0CA,yBAAAA,gBAAgB;CACtD,YAAY,YAA4D;EACpE,MAAM,WAAW,KAAK,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;EADzB,KAAA,aAAA;CAE5B;AACJ;AAEA,IAAM,wBAAN,cAAoC,oBAAoB;CACpD,YAAY,OAAwB,MAAsB,SAAiB;EACvE,MAAM,OAAO,MAAM,OAAO;CAC9B;AACJ"}

package/dist/validation-exception.d.cts

@@ -0,0 +1,50 @@
+import { t as ValidationCode } from "./validation-code.cjs";
+import { t as ValidationField } from "./validation-field.cjs";
+import { t as DomainException } from "./domain-exception.cjs";
+
+//#region src/core/exceptions/business-rule-violation-exception.d.ts
+declare class BusinessRuleViolationException extends DomainException {
+  readonly rule: string;
+  constructor(rule: string, message: string);
+}
+//#endregion
+//#region src/core/exceptions/entity-not-found-exception.d.ts
+declare class EntityNotFoundException extends DomainException {
+  readonly entityName: string;
+  readonly identifier: string;
+  constructor(entityName: string, identifier: string);
+}
+//#endregion
+//#region src/core/exceptions/invalid-state-transition-exception.d.ts
+declare class InvalidStateTransitionException<TState extends string = string> extends DomainException {
+  readonly from: TState;
+  readonly to: TState;
+  constructor(from: TState, to: TState, message: string);
+}
+//#endregion
+//#region src/core/exceptions/invariant-violation-exception.d.ts
+declare class InvariantViolationException extends DomainException {
+  constructor(message: string);
+}
+//#endregion
+//#region src/core/exceptions/validation-exception.d.ts
+interface ValidationViolation {
+  readonly field: ValidationField;
+  readonly code: ValidationCode;
+  readonly message: string;
+}
+declare class ValidationException extends DomainException {
+  readonly field: ValidationField;
+  readonly code: ValidationCode;
+  constructor(field: ValidationField, code: ValidationCode, message: string);
+}
+declare class MultipleValidationException extends DomainException {
+  readonly violations: readonly ValidationViolation[];
+  constructor(violations: readonly ValidationViolation[]);
+}
+declare class InvalidValueException extends ValidationException {
+  constructor(field: ValidationField, code: ValidationCode, message: string);
+}
+//#endregion
+export { InvariantViolationException as a, BusinessRuleViolationException as c, ValidationViolation as i, MultipleValidationException as n, InvalidStateTransitionException as o, ValidationException as r, EntityNotFoundException as s, InvalidValueException as t };
+//# sourceMappingURL=validation-exception.d.cts.map

package/dist/validation-exception.d.ts

@@ -0,0 +1,50 @@
+import { t as ValidationCode } from "./validation-code.js";
+import { t as ValidationField } from "./validation-field.js";
+import { t as DomainException } from "./domain-exception.js";
+
+//#region src/core/exceptions/business-rule-violation-exception.d.ts
+declare class BusinessRuleViolationException extends DomainException {
+  readonly rule: string;
+  constructor(rule: string, message: string);
+}
+//#endregion
+//#region src/core/exceptions/entity-not-found-exception.d.ts
+declare class EntityNotFoundException extends DomainException {
+  readonly entityName: string;
+  readonly identifier: string;
+  constructor(entityName: string, identifier: string);
+}
+//#endregion
+//#region src/core/exceptions/invalid-state-transition-exception.d.ts
+declare class InvalidStateTransitionException<TState extends string = string> extends DomainException {
+  readonly from: TState;
+  readonly to: TState;
+  constructor(from: TState, to: TState, message: string);
+}
+//#endregion
+//#region src/core/exceptions/invariant-violation-exception.d.ts
+declare class InvariantViolationException extends DomainException {
+  constructor(message: string);
+}
+//#endregion
+//#region src/core/exceptions/validation-exception.d.ts
+interface ValidationViolation {
+  readonly field: ValidationField;
+  readonly code: ValidationCode;
+  readonly message: string;
+}
+declare class ValidationException extends DomainException {
+  readonly field: ValidationField;
+  readonly code: ValidationCode;
+  constructor(field: ValidationField, code: ValidationCode, message: string);
+}
+declare class MultipleValidationException extends DomainException {
+  readonly violations: readonly ValidationViolation[];
+  constructor(violations: readonly ValidationViolation[]);
+}
+declare class InvalidValueException extends ValidationException {
+  constructor(field: ValidationField, code: ValidationCode, message: string);
+}
+//#endregion
+export { InvariantViolationException as a, BusinessRuleViolationException as c, ValidationViolation as i, MultipleValidationException as n, InvalidStateTransitionException as o, ValidationException as r, EntityNotFoundException as s, InvalidValueException as t };
+//# sourceMappingURL=validation-exception.d.ts.map

package/dist/validation-exception.js

@@ -1,4 +1,4 @@
-import { a as DomainException } from "./temporal-guards.js";
+import { t as DomainException } from "./domain-exception.js";
 //#region src/core/exceptions/validation-exception.ts
 var ValidationException = class extends DomainException {
 	constructor(field, code, message) {
@@ -7,12 +7,18 @@ var ValidationException = class extends DomainException {
 		this.code = code;
 	}
 };
+var MultipleValidationException = class extends DomainException {
+	constructor(violations) {
+		super(violations.map((v) => v.message).join("; "));
+		this.violations = violations;
+	}
+};
 var InvalidValueException = class extends ValidationException {
 	constructor(field, code, message) {
 		super(field, code, message);
 	}
 };
 //#endregion
-export { InvalidValueException as t };
+export { MultipleValidationException as n, ValidationException as r, InvalidValueException as t };
 
 //# sourceMappingURL=validation-exception.js.map

package/dist/validation-exception.js.map

@@ -1 +1 @@
-{"version":3,"file":"validation-exception.js","names":[],"sources":["../src/core/exceptions/validation-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\nimport { ValidationCode } from \"./validation-code.js\";\nimport { ValidationField } from \"./validation-field.js\";\n\nexport interface ValidationViolation {\n    readonly field: ValidationField;\n    readonly code: ValidationCode;\n    readonly message: string;\n}\n\nclass ValidationException extends DomainException {\n    constructor(\n        public readonly field: ValidationField,\n        public readonly code: ValidationCode,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\n// Carries multiple validation violations from a single operation (e.g. bulk validation).\n// Use when you need to report all field errors at once rather than failing on the first.\nclass MultipleValidationException extends DomainException {\n    constructor(public readonly violations: readonly ValidationViolation[]) {\n        super(violations.map((v) => v.message).join(\"; \"));\n    }\n}\n\nclass InvalidValueException extends ValidationException {\n    constructor(field: ValidationField, code: ValidationCode, message: string) {\n        super(field, code, message);\n    }\n}\n\nexport {\n    InvalidValueException,\n    MultipleValidationException,\n    ValidationException,\n};\n"],"mappings":";;AAUA,IAAM,sBAAN,cAAkC,gBAAgB;CAC9C,YACI,OACA,MACA,SACF;EACE,MAAM,OAAO;EAJG,KAAA,QAAA;EACA,KAAA,OAAA;CAIpB;AACJ;AAUA,IAAM,wBAAN,cAAoC,oBAAoB;CACpD,YAAY,OAAwB,MAAsB,SAAiB;EACvE,MAAM,OAAO,MAAM,OAAO;CAC9B;AACJ"}
+{"version":3,"file":"validation-exception.js","names":[],"sources":["../src/core/exceptions/validation-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\nimport { ValidationCode } from \"./validation-code.js\";\nimport { ValidationField } from \"./validation-field.js\";\n\nexport interface ValidationViolation {\n    readonly field: ValidationField;\n    readonly code: ValidationCode;\n    readonly message: string;\n}\n\nclass ValidationException extends DomainException {\n    constructor(\n        public readonly field: ValidationField,\n        public readonly code: ValidationCode,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\n// Carries multiple validation violations from a single operation (e.g. bulk validation).\n// Use when you need to report all field errors at once rather than failing on the first.\nclass MultipleValidationException extends DomainException {\n    constructor(public readonly violations: readonly ValidationViolation[]) {\n        super(violations.map((v) => v.message).join(\"; \"));\n    }\n}\n\nclass InvalidValueException extends ValidationException {\n    constructor(field: ValidationField, code: ValidationCode, message: string) {\n        super(field, code, message);\n    }\n}\n\nexport {\n    InvalidValueException,\n    MultipleValidationException,\n    ValidationException,\n};\n"],"mappings":";;AAUA,IAAM,sBAAN,cAAkC,gBAAgB;CAC9C,YACI,OACA,MACA,SACF;EACE,MAAM,OAAO;EAJG,KAAA,QAAA;EACA,KAAA,OAAA;CAIpB;AACJ;AAIA,IAAM,8BAAN,cAA0C,gBAAgB;CACtD,YAAY,YAA4D;EACpE,MAAM,WAAW,KAAK,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;EADzB,KAAA,aAAA;CAE5B;AACJ;AAEA,IAAM,wBAAN,cAAoC,oBAAoB;CACpD,YAAY,OAAwB,MAAsB,SAAiB;EACvE,MAAM,OAAO,MAAM,OAAO;CAC9B;AACJ"}

package/dist/validation-field.cjs

@@ -0,0 +1,28 @@
+//#region src/core/exceptions/validation-field.ts
+var ValidationField = class ValidationField {
+	constructor(value) {
+		this.value = value;
+	}
+	static of(value) {
+		return new ValidationField(value);
+	}
+	nested(child) {
+		const childValue = child instanceof ValidationField ? child.value : child;
+		return new ValidationField(`${this.value}.${childValue}`);
+	}
+	toString() {
+		return this.value;
+	}
+	equals(other) {
+		return this.value === other.value;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "ValidationField", {
+	enumerable: true,
+	get: function() {
+		return ValidationField;
+	}
+});
+
+//# sourceMappingURL=validation-field.cjs.map

package/dist/validation-field.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-field.cjs","names":[],"sources":["../src/core/exceptions/validation-field.ts"],"sourcesContent":["// Object-oriented representation of validation fields.\n// Indicates WHERE a validation error occurred.\n// This is a minimal base class — field catalogs are defined per domain/module.\n\nclass ValidationField {\n    public readonly value: string;\n\n    private constructor(value: string) {\n        this.value = value;\n    }\n\n    // Factory for custom or domain-specific fields\n    public static of(value: string): ValidationField {\n        return new ValidationField(value);\n    }\n\n    // Creates a nested field path: parent.nested('child') -> 'parent.child'\n    public nested(child: string | ValidationField): ValidationField {\n        const childValue =\n            child instanceof ValidationField ? child.value : child;\n        return new ValidationField(`${this.value}.${childValue}`);\n    }\n\n    public toString(): string {\n        return this.value;\n    }\n\n    public equals(other: ValidationField): boolean {\n        return this.value === other.value;\n    }\n}\n\nexport { ValidationField };\n"],"mappings":";AAIA,IAAM,kBAAN,MAAM,gBAAgB;CAGlB,YAAoB,OAAe;EAC/B,KAAK,QAAQ;CACjB;CAGA,OAAc,GAAG,OAAgC;EAC7C,OAAO,IAAI,gBAAgB,KAAK;CACpC;CAGA,OAAc,OAAkD;EAC5D,MAAM,aACF,iBAAiB,kBAAkB,MAAM,QAAQ;EACrD,OAAO,IAAI,gBAAgB,GAAG,KAAK,MAAM,GAAG,YAAY;CAC5D;CAEA,WAA0B;EACtB,OAAO,KAAK;CAChB;CAEA,OAAc,OAAiC;EAC3C,OAAO,KAAK,UAAU,MAAM;CAChC;AACJ"}

package/dist/validation-field.d.cts

@@ -0,0 +1,12 @@
+//#region src/core/exceptions/validation-field.d.ts
+declare class ValidationField {
+  readonly value: string;
+  private constructor();
+  static of(value: string): ValidationField;
+  nested(child: string | ValidationField): ValidationField;
+  toString(): string;
+  equals(other: ValidationField): boolean;
+}
+//#endregion
+export { ValidationField as t };
+//# sourceMappingURL=validation-field.d.cts.map

package/dist/value-object-ruleset.contracts.d.cts

@@ -0,0 +1,36 @@
+//#region src/core/domain/rulesets/ruleset.contracts.d.ts
+type RulesetId = `${string}@${number}.${number}`;
+interface Ruleset {
+  readonly id: RulesetId;
+  readonly description: string;
+}
+interface RulesetRegistry$1 {
+  register(ruleset: Ruleset): void;
+  seal(): void;
+  get<T extends Ruleset>(id: string): T;
+  getCurrent<T extends Ruleset>(prefix: string): T;
+}
+//#endregion
+//#region src/core/domain/rulesets/entity-ruleset.contracts.d.ts
+interface CreationRuleset<TData> extends Ruleset {
+  validate(data: TData): void;
+}
+type InvariantRuleset = Ruleset;
+//#endregion
+//#region src/core/domain/rulesets/ruleset-registry.d.ts
+declare class RulesetRegistry implements RulesetRegistry$1 {
+  private readonly _store;
+  private _sealed;
+  register(ruleset: Ruleset): void;
+  seal(): void;
+  get<T extends Ruleset>(id: string): T;
+  getCurrent<T extends Ruleset>(prefix: string): T;
+}
+//#endregion
+//#region src/core/domain/rulesets/value-object-ruleset.contracts.d.ts
+interface ValueObjectRuleset<T> extends Ruleset {
+  validate(value: T): void;
+}
+//#endregion
+export { Ruleset as a, InvariantRuleset as i, RulesetRegistry as n, RulesetId as o, CreationRuleset as r, ValueObjectRuleset as t };
+//# sourceMappingURL=value-object-ruleset.contracts.d.cts.map

package/dist/value-object-ruleset.contracts.d.ts

@@ -0,0 +1,36 @@
+//#region src/core/domain/rulesets/ruleset.contracts.d.ts
+type RulesetId = `${string}@${number}.${number}`;
+interface Ruleset {
+  readonly id: RulesetId;
+  readonly description: string;
+}
+interface RulesetRegistry$1 {
+  register(ruleset: Ruleset): void;
+  seal(): void;
+  get<T extends Ruleset>(id: string): T;
+  getCurrent<T extends Ruleset>(prefix: string): T;
+}
+//#endregion
+//#region src/core/domain/rulesets/entity-ruleset.contracts.d.ts
+interface CreationRuleset<TData> extends Ruleset {
+  validate(data: TData): void;
+}
+type InvariantRuleset = Ruleset;
+//#endregion
+//#region src/core/domain/rulesets/ruleset-registry.d.ts
+declare class RulesetRegistry implements RulesetRegistry$1 {
+  private readonly _store;
+  private _sealed;
+  register(ruleset: Ruleset): void;
+  seal(): void;
+  get<T extends Ruleset>(id: string): T;
+  getCurrent<T extends Ruleset>(prefix: string): T;
+}
+//#endregion
+//#region src/core/domain/rulesets/value-object-ruleset.contracts.d.ts
+interface ValueObjectRuleset<T> extends Ruleset {
+  validate(value: T): void;
+}
+//#endregion
+export { Ruleset as a, InvariantRuleset as i, RulesetRegistry as n, RulesetId as o, CreationRuleset as r, ValueObjectRuleset as t };
+//# sourceMappingURL=value-object-ruleset.contracts.d.ts.map

package/dist/value-object.cjs

@@ -0,0 +1,208 @@
+const require_invariant_violation_exception = require("./invariant-violation-exception.cjs");
+const require_immutable = require("./immutable.cjs");
+const require_temporal_guards = require("./temporal-guards.cjs");
+const require_plugin = require("./plugin.cjs");
+//#region src/core/shared/aggregate-version.ts
+function assertValidAggregateVersion(aggregateVersion) {
+	if (!Number.isInteger(aggregateVersion) || aggregateVersion < 0) throw new require_invariant_violation_exception.InvariantViolationException(`aggregateVersion must be a non-negative integer. Received: ${aggregateVersion}`);
+}
+//#endregion
+//#region src/core/domain/entity.ts
+var _Entity;
+/**
+* Base class for domain entities — objects defined by a stable identity rather
+* than by their attributes. Two entities are "the same" when their `id`
+* matches, even if every other field differs; this is the opposite of a
+* {@link ValueObject}, which is defined entirely by its contents.
+*
+* The class owns the bookkeeping common to every aggregate root: a creation
+* timestamp that never changes, a last-modified timestamp, and an
+* `aggregateVersion` counter used for optimistic concurrency control. All three
+* are validated on construction and the dates are defensively cloned, so an
+* entity can never be built into — or leak — an inconsistent temporal state.
+*
+* @typeParam TIdentifier - The identity type (e.g. a branded string id or a VO).
+*/
+let Entity = class Entity {
+	static {
+		_Entity = this;
+	}
+	/**
+	* Reconstitutes an entity from its persisted {@link EntityState}.
+	*
+	* Validates the temporal invariants up front so an invalid entity is
+	* impossible to construct: both dates must be valid, the aggregate version
+	* must be a non-negative integer, and `updatedAt` may not predate
+	* `createdAt`. Both dates are cloned on the way in so a later mutation of
+	* the caller's `Date` objects cannot reach into the entity's internal state.
+	*
+	* Declared `protected` because entities are reconstituted through a
+	* subclass factory, never instantiated directly by application code.
+	*
+	* @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.
+	*/
+	constructor(state) {
+		require_temporal_guards.assertValidDate("createdAt", state.createdAt);
+		require_temporal_guards.assertValidDate("updatedAt", state.updatedAt);
+		assertValidAggregateVersion(state.aggregateVersion);
+		if (state.updatedAt.getTime() < state.createdAt.getTime()) throw new require_invariant_violation_exception.InvariantViolationException("updatedAt cannot be earlier than createdAt");
+		this._id = state.id;
+		this._createdAt = require_temporal_guards.cloneDate(state.createdAt);
+		this._updatedAt = require_temporal_guards.cloneDate(state.updatedAt);
+		this._aggregateVersion = state.aggregateVersion;
+	}
+	/** The entity's stable identity — the basis for equality between entities. */
+	get id() {
+		return this._id;
+	}
+	/**
+	* When the entity was first created.
+	*
+	* Returns a clone so callers cannot mutate the entity's internal `Date`;
+	* the value is fixed at construction and never changes thereafter.
+	*/
+	get createdAt() {
+		return require_temporal_guards.cloneDate(this._createdAt);
+	}
+	/**
+	* When the entity was last modified.
+	*
+	* Returns a clone for the same encapsulation reason as {@link createdAt};
+	* the underlying value advances only through {@link markAsModified}.
+	*/
+	get updatedAt() {
+		return require_temporal_guards.cloneDate(this._updatedAt);
+	}
+	/**
+	* Monotonic counter incremented on every mutation, used for optimistic
+	* concurrency control: a writer reads this value, and the persistence layer
+	* rejects the write if the stored version has moved on in the meantime.
+	*/
+	get aggregateVersion() {
+		return this._aggregateVersion;
+	}
+	/**
+	* The schema/contract version stamped on this entity type by the
+	* `@version` decorator — used to detect and migrate state persisted under
+	* an older shape.
+	*/
+	get contractVersion() {
+		return _Entity.CONTRACT_VERSION;
+	}
+	/**
+	* The single seam through which an entity records a mutation: it advances
+	* `updatedAt` and bumps {@link aggregateVersion} by one. Subclasses must
+	* call this from every state-changing method so the version counter stays
+	* an accurate optimistic-lock token.
+	*
+	* @param updatedAt - The modification instant; defaults to now. Validated
+	*   and required not to predate `createdAt`, preserving the same invariant
+	*   the constructor enforces.
+	* @returns The new aggregate version after the increment.
+	* @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.
+	*/
+	markAsModified(updatedAt = /* @__PURE__ */ new Date()) {
+		require_temporal_guards.assertValidDate("updatedAt", updatedAt);
+		if (updatedAt.getTime() < this._createdAt.getTime()) throw new require_invariant_violation_exception.InvariantViolationException("updatedAt cannot be earlier than createdAt");
+		this._updatedAt = require_temporal_guards.cloneDate(updatedAt);
+		this._aggregateVersion += 1;
+		return this._aggregateVersion;
+	}
+};
+Entity = _Entity = require_immutable.__decorate([require_immutable.version("1.0")], Entity);
+//#endregion
+//#region src/core/domain/value-object.ts
+var _ValueObject;
+/**
+* Base class for value objects — domain concepts defined entirely by their
+* contents, with no identity of their own. Two value objects are
+* interchangeable when they hold equal data, which is the opposite of an
+* {@link Entity} (compared by id). Money, a CPF, a date range: replacing one
+* instance with an equal one changes nothing about the model.
+*
+* Immutability is the defining guarantee here. The wrapped `value` is
+* deep-frozen on construction, so a value object can be shared freely without
+* any risk of a consumer mutating shared state. Subclasses seal the instance
+* itself with {@link finalize} once their own fields are set.
+*
+* @typeParam T - The shape of the wrapped data.
+* @typeParam P - The primitive form produced by {@link toPrimitive} / {@link toJSON}.
+*/
+let ValueObject = class ValueObject {
+	static {
+		_ValueObject = this;
+	}
+	static {
+		this.plugins = new require_plugin.PluginManager();
+	}
+	/**
+	* Wraps `value`, deep-freezing it so the value object is immutable from the
+	* moment it exists. Declared `protected` because value objects are built
+	* through a validating subclass factory, never instantiated directly.
+	*/
+	constructor(value) {
+		this.value = require_immutable.makeImmutable(value);
+	}
+	/**
+	* The schema/contract version stamped on this value-object type by the
+	* `@version` decorator — used to detect state persisted under an older shape.
+	*/
+	get contractVersion() {
+		return _ValueObject.CONTRACT_VERSION;
+	}
+	/**
+	* Freezes the instance shell, blocking reassignment of any own field.
+	*
+	* `value` is already deep-frozen by the constructor, so the wrapped data is
+	* immutable regardless. The instance itself is NOT frozen automatically
+	* because a subclass may still need to assign its own fields after
+	* `super(value)` runs. Call `finalize()` at the very end of the subclass
+	* constructor (after all fields are set) to make the whole value object
+	* immutable.
+	*/
+	finalize() {
+		Object.freeze(this);
+	}
+	/**
+	* Hook for `JSON.stringify`. Delegates to {@link toPrimitive} so a value
+	* object serializes to its primitive form rather than exposing the internal
+	* `value` wrapper.
+	*/
+	toJSON() {
+		return this.toPrimitive();
+	}
+	/**
+	* Compares this value object with another by content. Because value objects
+	* carry no identity, two independently constructed instances holding the
+	* same data are considered equal.
+	*
+	* Delegates to the registered equality {@link plugins}; with no plugin
+	* registered it falls back to comparing the serialized wrapped `value`.
+	* Subclasses may still override for a faster or domain-specific comparison.
+	*/
+	equals(other) {
+		return _ValueObject.plugins.invoke("equals", [this, other], { fallback: (a, b) => JSON.stringify(a.value) === JSON.stringify(b.value) });
+	}
+};
+ValueObject = _ValueObject = require_immutable.__decorate([require_immutable.version("1.0")], ValueObject);
+//#endregion
+Object.defineProperty(exports, "Entity", {
+	enumerable: true,
+	get: function() {
+		return Entity;
+	}
+});
+Object.defineProperty(exports, "ValueObject", {
+	enumerable: true,
+	get: function() {
+		return ValueObject;
+	}
+});
+Object.defineProperty(exports, "assertValidAggregateVersion", {
+	enumerable: true,
+	get: function() {
+		return assertValidAggregateVersion;
+	}
+});
+
+//# sourceMappingURL=value-object.cjs.map

package/dist/value-object.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-object.cjs","names":["InvariantViolationException","InvariantViolationException","cloneDate","version","PluginManager","makeImmutable","version"],"sources":["../src/core/shared/aggregate-version.ts","../src/core/domain/entity.ts","../src/core/domain/value-object.ts"],"sourcesContent":["import { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\n\nfunction assertValidAggregateVersion(aggregateVersion: number): void {\n    if (!Number.isInteger(aggregateVersion) || aggregateVersion < 0) {\n        throw new InvariantViolationException(\n            `aggregateVersion must be a non-negative integer. Received: ${aggregateVersion}`,\n        );\n    }\n}\n\nexport { assertValidAggregateVersion };\n","import { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { assertValidDate, cloneDate } from \"../shared/temporal-guards.js\";\nimport { type ContractVersion, version } from \"../versioning/version.js\";\n\n/**\n * The minimal persisted shape needed to reconstitute an {@link Entity}.\n *\n * This is the contract between storage and the domain: a repository maps a row\n * (or document) onto these four fields and hands them to a subclass constructor.\n * `aggregateVersion` travels with the state so optimistic-concurrency checks\n * survive a round-trip through the database.\n */\ninterface EntityState<TIdentifier> {\n    readonly id: TIdentifier;\n    readonly createdAt: Date;\n    readonly updatedAt: Date;\n    readonly aggregateVersion: number;\n}\n\n/**\n * Base class for domain entities — objects defined by a stable identity rather\n * than by their attributes. Two entities are \"the same\" when their `id`\n * matches, even if every other field differs; this is the opposite of a\n * {@link ValueObject}, which is defined entirely by its contents.\n *\n * The class owns the bookkeeping common to every aggregate root: a creation\n * timestamp that never changes, a last-modified timestamp, and an\n * `aggregateVersion` counter used for optimistic concurrency control. All three\n * are validated on construction and the dates are defensively cloned, so an\n * entity can never be built into — or leak — an inconsistent temporal state.\n *\n * @typeParam TIdentifier - The identity type (e.g. a branded string id or a VO).\n */\n@version(\"1.0\")\nabstract class Entity<TIdentifier> {\n    declare public static readonly CONTRACT_VERSION: ContractVersion;\n\n    private readonly _id: TIdentifier;\n    private readonly _createdAt: Date;\n    private _updatedAt: Date;\n    private _aggregateVersion: number;\n\n    /**\n     * Reconstitutes an entity from its persisted {@link EntityState}.\n     *\n     * Validates the temporal invariants up front so an invalid entity is\n     * impossible to construct: both dates must be valid, the aggregate version\n     * must be a non-negative integer, and `updatedAt` may not predate\n     * `createdAt`. Both dates are cloned on the way in so a later mutation of\n     * the caller's `Date` objects cannot reach into the entity's internal state.\n     *\n     * Declared `protected` because entities are reconstituted through a\n     * subclass factory, never instantiated directly by application code.\n     *\n     * @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.\n     */\n    protected constructor(state: EntityState<TIdentifier>) {\n        assertValidDate(\"createdAt\", state.createdAt);\n        assertValidDate(\"updatedAt\", state.updatedAt);\n        assertValidAggregateVersion(state.aggregateVersion);\n\n        if (state.updatedAt.getTime() < state.createdAt.getTime()) {\n            throw new InvariantViolationException(\n                \"updatedAt cannot be earlier than createdAt\",\n            );\n        }\n\n        this._id = state.id;\n        this._createdAt = cloneDate(state.createdAt);\n        this._updatedAt = cloneDate(state.updatedAt);\n        this._aggregateVersion = state.aggregateVersion;\n    }\n\n    /** The entity's stable identity — the basis for equality between entities. */\n    public get id(): TIdentifier {\n        return this._id;\n    }\n\n    /**\n     * When the entity was first created.\n     *\n     * Returns a clone so callers cannot mutate the entity's internal `Date`;\n     * the value is fixed at construction and never changes thereafter.\n     */\n    public get createdAt(): Date {\n        return cloneDate(this._createdAt);\n    }\n\n    /**\n     * When the entity was last modified.\n     *\n     * Returns a clone for the same encapsulation reason as {@link createdAt};\n     * the underlying value advances only through {@link markAsModified}.\n     */\n    public get updatedAt(): Date {\n        return cloneDate(this._updatedAt);\n    }\n\n    /**\n     * Monotonic counter incremented on every mutation, used for optimistic\n     * concurrency control: a writer reads this value, and the persistence layer\n     * rejects the write if the stored version has moved on in the meantime.\n     */\n    public get aggregateVersion(): number {\n        return this._aggregateVersion;\n    }\n\n    /**\n     * The schema/contract version stamped on this entity type by the\n     * `@version` decorator — used to detect and migrate state persisted under\n     * an older shape.\n     */\n    public get contractVersion(): ContractVersion {\n        return Entity.CONTRACT_VERSION;\n    }\n\n    /**\n     * The single seam through which an entity records a mutation: it advances\n     * `updatedAt` and bumps {@link aggregateVersion} by one. Subclasses must\n     * call this from every state-changing method so the version counter stays\n     * an accurate optimistic-lock token.\n     *\n     * @param updatedAt - The modification instant; defaults to now. Validated\n     *   and required not to predate `createdAt`, preserving the same invariant\n     *   the constructor enforces.\n     * @returns The new aggregate version after the increment.\n     * @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.\n     */\n    protected markAsModified(updatedAt: Date = new Date()): number {\n        assertValidDate(\"updatedAt\", updatedAt);\n\n        if (updatedAt.getTime() < this._createdAt.getTime()) {\n            throw new InvariantViolationException(\n                \"updatedAt cannot be earlier than createdAt\",\n            );\n        }\n\n        this._updatedAt = cloneDate(updatedAt);\n        this._aggregateVersion += 1;\n\n        return this._aggregateVersion;\n    }\n}\n\nexport { Entity, type EntityState };\n","import { PluginManager } from \"../plugins/index.js\";\nimport { type DeepReadonly, makeImmutable } from \"../shared/immutable.js\";\nimport { type ContractVersion, version } from \"../versioning/version.js\";\n\n/**\n * Extension point for value-object equality. A plugin implementing this\n * contract overrides how any two value objects are compared, letting the host\n * application swap in a structural comparator (e.g. `lodash.isEqual` over the\n * wrapped `value`) without every value object having to implement `equals` by\n * hand.\n */\ntype ValueObjectPluginContract = {\n    equals: (\n        a: ValueObject<unknown, unknown>,\n        b: ValueObject<unknown, unknown>,\n    ) => boolean;\n};\n\n/**\n * Base class for value objects — domain concepts defined entirely by their\n * contents, with no identity of their own. Two value objects are\n * interchangeable when they hold equal data, which is the opposite of an\n * {@link Entity} (compared by id). Money, a CPF, a date range: replacing one\n * instance with an equal one changes nothing about the model.\n *\n * Immutability is the defining guarantee here. The wrapped `value` is\n * deep-frozen on construction, so a value object can be shared freely without\n * any risk of a consumer mutating shared state. Subclasses seal the instance\n * itself with {@link finalize} once their own fields are set.\n *\n * @typeParam T - The shape of the wrapped data.\n * @typeParam P - The primitive form produced by {@link toPrimitive} / {@link toJSON}.\n */\n@version(\"1.0\")\nabstract class ValueObject<T, P> {\n    declare public static readonly CONTRACT_VERSION: ContractVersion;\n\n    /**\n     * Registry of equality plugins shared by every value object. Empty by\n     * default — when nothing is registered, {@link equals} falls back to a\n     * structural comparison of the wrapped `value`. Hosts register a plugin\n     * (e.g. `lodash.isEqual`) once at startup to customise equality globally.\n     */\n    public static readonly plugins =\n        new PluginManager<ValueObjectPluginContract>();\n\n    /** The wrapped data, deep-frozen so it can never be mutated after construction. */\n    public readonly value: DeepReadonly<T>;\n\n    /**\n     * Wraps `value`, deep-freezing it so the value object is immutable from the\n     * moment it exists. Declared `protected` because value objects are built\n     * through a validating subclass factory, never instantiated directly.\n     */\n    protected constructor(value: T) {\n        this.value = makeImmutable(value);\n    }\n\n    /**\n     * The schema/contract version stamped on this value-object type by the\n     * `@version` decorator — used to detect state persisted under an older shape.\n     */\n    public get contractVersion(): ContractVersion {\n        return ValueObject.CONTRACT_VERSION;\n    }\n\n    /**\n     * Freezes the instance shell, blocking reassignment of any own field.\n     *\n     * `value` is already deep-frozen by the constructor, so the wrapped data is\n     * immutable regardless. The instance itself is NOT frozen automatically\n     * because a subclass may still need to assign its own fields after\n     * `super(value)` runs. Call `finalize()` at the very end of the subclass\n     * constructor (after all fields are set) to make the whole value object\n     * immutable.\n     */\n    protected finalize(): void {\n        Object.freeze(this);\n    }\n\n    /**\n     * Hook for `JSON.stringify`. Delegates to {@link toPrimitive} so a value\n     * object serializes to its primitive form rather than exposing the internal\n     * `value` wrapper.\n     */\n    public toJSON(): P {\n        return this.toPrimitive();\n    }\n\n    /**\n     * Compares this value object with another by content. Because value objects\n     * carry no identity, two independently constructed instances holding the\n     * same data are considered equal.\n     *\n     * Delegates to the registered equality {@link plugins}; with no plugin\n     * registered it falls back to comparing the serialized wrapped `value`.\n     * Subclasses may still override for a faster or domain-specific comparison.\n     */\n    public equals(other: this): boolean {\n        return ValueObject.plugins.invoke(\"equals\", [this, other], {\n            fallback: (a, b) =>\n                JSON.stringify(a.value) === JSON.stringify(b.value),\n        });\n    }\n\n    /**\n     * Projects the value object down to a plain, serializable primitive form —\n     * the representation suitable for persistence, transport, or comparison.\n     */\n    public abstract toPrimitive(): P;\n}\n\nexport { type DeepReadonly, ValueObject, type ValueObjectPluginContract };\n"],"mappings":";;;;;AAEA,SAAS,4BAA4B,kBAAgC;CACjE,IAAI,CAAC,OAAO,UAAU,gBAAgB,KAAK,mBAAmB,GAC1D,MAAM,IAAIA,sCAAAA,4BACN,8DAA8D,kBAClE;AAER;;;;;;;;;;;;;;;;;;AC0BA,IAAA,SAAA,MACe,OAAoB;;;;;;;;;;;;;;;;;;CAsB/B,YAAsB,OAAiC;EACnD,wBAAA,gBAAgB,aAAa,MAAM,SAAS;EAC5C,wBAAA,gBAAgB,aAAa,MAAM,SAAS;EAC5C,4BAA4B,MAAM,gBAAgB;EAElD,IAAI,MAAM,UAAU,QAAQ,IAAI,MAAM,UAAU,QAAQ,GACpD,MAAM,IAAIC,sCAAAA,4BACN,4CACJ;EAGJ,KAAK,MAAM,MAAM;EACjB,KAAK,aAAaC,wBAAAA,UAAU,MAAM,SAAS;EAC3C,KAAK,aAAaA,wBAAAA,UAAU,MAAM,SAAS;EAC3C,KAAK,oBAAoB,MAAM;CACnC;;CAGA,IAAW,KAAkB;EACzB,OAAO,KAAK;CAChB;;;;;;;CAQA,IAAW,YAAkB;EACzB,OAAOA,wBAAAA,UAAU,KAAK,UAAU;CACpC;;;;;;;CAQA,IAAW,YAAkB;EACzB,OAAOA,wBAAAA,UAAU,KAAK,UAAU;CACpC;;;;;;CAOA,IAAW,mBAA2B;EAClC,OAAO,KAAK;CAChB;;;;;;CAOA,IAAW,kBAAmC;EAC1C,OAAA,QAAc;CAClB;;;;;;;;;;;;;CAcA,eAAyB,4BAAkB,IAAI,KAAK,GAAW;EAC3D,wBAAA,gBAAgB,aAAa,SAAS;EAEtC,IAAI,UAAU,QAAQ,IAAI,KAAK,WAAW,QAAQ,GAC9C,MAAM,IAAID,sCAAAA,4BACN,4CACJ;EAGJ,KAAK,aAAaC,wBAAAA,UAAU,SAAS;EACrC,KAAK,qBAAqB;EAE1B,OAAO,KAAK;CAChB;AACJ;iDA7GCC,kBAAAA,QAAQ,KAAK,CAAA,GAAA,MAAA;;;;;;;;;;;;;;;;;;;ACDd,IAAA,cAAA,MACe,YAAkB;;;;;iBAUzB,IAAIC,eAAAA,cAAyC;;;;;;;CAUjD,YAAsB,OAAU;EAC5B,KAAK,QAAQC,kBAAAA,cAAc,KAAK;CACpC;;;;;CAMA,IAAW,kBAAmC;EAC1C,OAAA,aAAmB;CACvB;;;;;;;;;;;CAYA,WAA2B;EACvB,OAAO,OAAO,IAAI;CACtB;;;;;;CAOA,SAAmB;EACf,OAAO,KAAK,YAAY;CAC5B;;;;;;;;;;CAWA,OAAc,OAAsB;EAChC,OAAA,aAAmB,QAAQ,OAAO,UAAU,CAAC,MAAM,KAAK,GAAG,EACvD,WAAW,GAAG,MACV,KAAK,UAAU,EAAE,KAAK,MAAM,KAAK,UAAU,EAAE,KAAK,EAC1D,CAAC;CACL;AAOJ;2DA7ECC,kBAAAA,QAAQ,KAAK,CAAA,GAAA,WAAA"}