@cullet/erp-core 1.5.0 → 2.0.0

package/dist/domain/index.d.ts

@@ -1,4 +1,28 @@
 import { t as DeepReadonly } from "../immutable.js";
 import { n as ValueObjectPluginContract, t as ValueObject } from "../value-object.js";
+import { a as ValidTime, c as CreateTransactionTimeInput, d as createTransactionTime, i as CreateValidTimeInput, l as TransactionTime, n as TemporalSnapshot, o as assertValidTime, r as createTemporalSnapshot, s as createValidTime, t as CreateTemporalSnapshotInput, u as assertTransactionTime } from "../temporal-snapshot.js";
 import { n as Entity, r as EntityState, t as UuidIdentifier } from "../uuid-identifier.js";
-export { type DeepReadonly, Entity, type EntityState, UuidIdentifier, ValueObject, type ValueObjectPluginContract };
+
+//#region src/core/domain/temporal/temporal-range.d.ts
+/**
+ * Checks whether a temporal range is "open" (has no end date).
+ * Useful for identifying information that is still in effect / active.
+ */
+declare function isOpen(range: ValidTime): boolean;
+/**
+ * Checks whether a temporal range is "closed" (has a defined end date).
+ */
+declare function isClosed(range: ValidTime): boolean;
+/**
+ * Checks whether a specific date is contained within the temporal range.
+ * The lower bound (`from`) is inclusive, while the upper bound (`to`) is exclusive.
+ */
+declare function contains(range: ValidTime, date: Date): boolean;
+/**
+ * Checks whether two temporal ranges overlap at any point.
+ * Useful for validating whether a new rule conflicts with an existing one.
+ */
+declare function overlaps(left: ValidTime, right: ValidTime): boolean;
+//#endregion
+export { CreateTemporalSnapshotInput, CreateTransactionTimeInput, CreateValidTimeInput, type DeepReadonly, Entity, type EntityState, TemporalSnapshot, TransactionTime, UuidIdentifier, ValidTime, ValueObject, type ValueObjectPluginContract, assertTransactionTime, assertValidTime, contains, createTemporalSnapshot, createTransactionTime, createValidTime, isClosed, isOpen, overlaps };
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/index.js

@@ -1,4 +1,100 @@
-import { t as Entity } from "../entity.js";
+import { t as InvariantViolationException } from "../invariant-violation-exception.js";
+import { t as assertValidDate } from "../temporal-guards.js";
+import { n as makeImmutable } from "../immutable.js";
 import { t as ValueObject } from "../value-object.js";
-import { t as UuidIdentifier } from "../uuid-identifier.js";
-export { Entity, UuidIdentifier, ValueObject };
+import { n as Entity, t as UuidIdentifier } from "../uuid-identifier.js";
+//#region src/core/domain/temporal/half-open-interval.ts
+/**
+* Shared core of the bitemporal primitives: a half-open interval
+* `[start, end)` whose end, when present, must be strictly later than its
+* start. `ValidTime` and `TransactionTime` are the same shape under different
+* (deliberate) vocabularies — the invariant lives here once so the two files
+* cannot drift apart.
+*
+* Internal to `domain/temporal`; not exported from the barrel.
+*/
+function assertHalfOpenInterval(startLabel, start, endLabel, end) {
+	assertValidDate(startLabel, start);
+	if (end === void 0) return;
+	assertValidDate(endLabel, end);
+	if (end.getTime() <= start.getTime()) throw new InvariantViolationException(`${endLabel} must be later than ${startLabel}`);
+}
+//#endregion
+//#region src/core/domain/temporal/transaction-time.ts
+function assertTransactionTime(txTime, fieldName = "txTime") {
+	assertHalfOpenInterval(`${fieldName}.recordedAt`, txTime.recordedAt, `${fieldName}.supersededAt`, txTime.supersededAt);
+}
+function createTransactionTime(input) {
+	assertTransactionTime(input, "txTime");
+	if (input.supersededAt === void 0) return makeImmutable({ recordedAt: input.recordedAt });
+	return makeImmutable({
+		recordedAt: input.recordedAt,
+		supersededAt: input.supersededAt
+	});
+}
+//#endregion
+//#region src/core/domain/temporal/valid-time.ts
+function assertValidTime(validTime, fieldName = "validTime") {
+	assertHalfOpenInterval(`${fieldName}.from`, validTime.from, `${fieldName}.to`, validTime.to);
+}
+function createValidTime(input) {
+	assertValidTime(input, "validTime");
+	if (input.to === void 0) return makeImmutable({ from: input.from });
+	return makeImmutable({
+		from: input.from,
+		to: input.to
+	});
+}
+//#endregion
+//#region src/core/domain/temporal/temporal-range.ts
+/**
+* Checks whether a temporal range is "open" (has no end date).
+* Useful for identifying information that is still in effect / active.
+*/
+function isOpen(range) {
+	assertValidTime(range, "range");
+	return range.to === void 0;
+}
+/**
+* Checks whether a temporal range is "closed" (has a defined end date).
+*/
+function isClosed(range) {
+	return !isOpen(range);
+}
+/**
+* Checks whether a specific date is contained within the temporal range.
+* The lower bound (`from`) is inclusive, while the upper bound (`to`) is exclusive.
+*/
+function contains(range, date) {
+	assertValidTime(range, "range");
+	assertValidDate("date", date);
+	const fromTime = range.from.getTime();
+	const toTime = range.to?.getTime() ?? Number.POSITIVE_INFINITY;
+	const targetTime = date.getTime();
+	return targetTime >= fromTime && targetTime < toTime;
+}
+/**
+* Checks whether two temporal ranges overlap at any point.
+* Useful for validating whether a new rule conflicts with an existing one.
+*/
+function overlaps(left, right) {
+	assertValidTime(left, "left");
+	assertValidTime(right, "right");
+	const leftFrom = left.from.getTime();
+	const leftTo = left.to?.getTime() ?? Number.POSITIVE_INFINITY;
+	const rightFrom = right.from.getTime();
+	return leftFrom < (right.to?.getTime() ?? Number.POSITIVE_INFINITY) && rightFrom < leftTo;
+}
+//#endregion
+//#region src/core/domain/temporal/temporal-snapshot.ts
+function createTemporalSnapshot(input) {
+	return Object.freeze({
+		data: makeImmutable(input.data),
+		validTime: createValidTime(input.validTime),
+		txTime: createTransactionTime(input.txTime)
+	});
+}
+//#endregion
+export { Entity, UuidIdentifier, ValueObject, assertTransactionTime, assertValidTime, contains, createTemporalSnapshot, createTransactionTime, createValidTime, isClosed, isOpen, overlaps };
+
+//# sourceMappingURL=index.js.map

package/dist/domain/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/core/domain/temporal/half-open-interval.ts","../../src/core/domain/temporal/transaction-time.ts","../../src/core/domain/temporal/valid-time.ts","../../src/core/domain/temporal/temporal-range.ts","../../src/core/domain/temporal/temporal-snapshot.ts"],"sourcesContent":["import { InvariantViolationException } from \"../../exceptions/invariant-violation-exception.js\";\nimport { assertValidDate } from \"../../shared/temporal-guards.js\";\n\n/**\n * Shared core of the bitemporal primitives: a half-open interval\n * `[start, end)` whose end, when present, must be strictly later than its\n * start. `ValidTime` and `TransactionTime` are the same shape under different\n * (deliberate) vocabularies — the invariant lives here once so the two files\n * cannot drift apart.\n *\n * Internal to `domain/temporal`; not exported from the barrel.\n */\nfunction assertHalfOpenInterval(\n    startLabel: string,\n    start: Date,\n    endLabel: string,\n    end: Date | undefined,\n): void {\n    assertValidDate(startLabel, start);\n\n    if (end === undefined) {\n        return;\n    }\n\n    assertValidDate(endLabel, end);\n\n    if (end.getTime() <= start.getTime()) {\n        throw new InvariantViolationException(\n            `${endLabel} must be later than ${startLabel}`,\n        );\n    }\n}\n\nexport { assertHalfOpenInterval };\n","import { makeImmutable } from \"../../shared/immutable.js\";\n\nimport { assertHalfOpenInterval } from \"./half-open-interval.js\";\n\n/**\n * Represents transaction time (Transaction Time).\n * Defines when the system learned about or recorded a piece of information.\n * Useful for auditing and reconstructing system state at a specific past moment.\n *\n * The window is half-open — `recordedAt` inclusive, `supersededAt` exclusive —\n * and strictly non-empty: `supersededAt` must be later than `recordedAt`, so a\n * record superseded in the same instant it was written is not representable.\n *\n * One caveat mirrors {@link ValueObject}: `createTransactionTime` clones the\n * input dates (no aliasing) but the inner `Date`s are NOT frozen —\n * `Object.freeze` cannot block `setTime`/`setFullYear`, so a caller can still\n * mutate `recordedAt` in place and corrupt the audit record after creation.\n * `readonly` only prevents reassignment. Treat the dates as read-only, or keep\n * instants as ISO/epoch in your own state when that guarantee matters.\n */\ninterface TransactionTime {\n    /** When the information was first recorded in the system. */\n    readonly recordedAt: Date;\n    /** When this information was superseded or invalidated by a newer version. */\n    readonly supersededAt?: Date;\n}\n\ntype CreateTransactionTimeInput = TransactionTime;\n\nfunction assertTransactionTime(\n    txTime: TransactionTime,\n    fieldName: string = \"txTime\",\n): void {\n    assertHalfOpenInterval(\n        `${fieldName}.recordedAt`,\n        txTime.recordedAt,\n        `${fieldName}.supersededAt`,\n        txTime.supersededAt,\n    );\n}\n\nfunction createTransactionTime(\n    input: CreateTransactionTimeInput,\n): TransactionTime {\n    assertTransactionTime(input, \"txTime\");\n\n    if (input.supersededAt === undefined) {\n        return makeImmutable({\n            recordedAt: input.recordedAt,\n        });\n    }\n\n    return makeImmutable({\n        recordedAt: input.recordedAt,\n        supersededAt: input.supersededAt,\n    });\n}\n\nexport {\n    assertTransactionTime,\n    createTransactionTime,\n    type CreateTransactionTimeInput,\n    type TransactionTime,\n};\n","import { makeImmutable } from \"../../shared/immutable.js\";\n\nimport { assertHalfOpenInterval } from \"./half-open-interval.js\";\n\n/**\n * Represents business time (Valid Time).\n * Defines when a piece of information is considered true or in effect in the real world.\n *\n * The window is half-open — `from` inclusive, `to` exclusive — and strictly\n * non-empty: `to` must be later than `from`, so a zero-duration range `[t, t)`\n * is deliberately not representable. Model an instantaneous event as an open\n * range closed by the next fact, not as an empty window.\n *\n * One caveat mirrors {@link ValueObject}: `createValidTime` clones the input\n * dates (no aliasing) but the inner `Date`s are NOT frozen — `Object.freeze`\n * cannot block `setTime`/`setFullYear`, so a caller can still mutate `from`\n * in place and corrupt the range after creation. `readonly` only prevents\n * reassignment. Treat the dates as read-only, or keep instants as ISO/epoch in\n * your own state when that guarantee matters.\n */\ninterface ValidTime {\n    /** Start of the validity window (inclusive). */\n    readonly from: Date;\n    /** End of the validity window (exclusive). When absent, the information is still in effect. */\n    readonly to?: Date;\n}\n\ntype CreateValidTimeInput = ValidTime;\n\nfunction assertValidTime(\n    validTime: ValidTime,\n    fieldName: string = \"validTime\",\n): void {\n    assertHalfOpenInterval(\n        `${fieldName}.from`,\n        validTime.from,\n        `${fieldName}.to`,\n        validTime.to,\n    );\n}\n\nfunction createValidTime(input: CreateValidTimeInput): ValidTime {\n    assertValidTime(input, \"validTime\");\n\n    if (input.to === undefined) {\n        return makeImmutable({\n            from: input.from,\n        });\n    }\n\n    return makeImmutable({\n        from: input.from,\n        to: input.to,\n    });\n}\n\nexport {\n    assertValidTime,\n    createValidTime,\n    type CreateValidTimeInput,\n    type ValidTime,\n};\n","import { assertValidDate } from \"../../shared/temporal-guards.js\";\n\nimport { assertValidTime, type ValidTime } from \"./valid-time.js\";\n\n/**\n * Checks whether a temporal range is \"open\" (has no end date).\n * Useful for identifying information that is still in effect / active.\n */\nfunction isOpen(range: ValidTime): boolean {\n    assertValidTime(range, \"range\");\n\n    return range.to === undefined;\n}\n\n/**\n * Checks whether a temporal range is \"closed\" (has a defined end date).\n */\nfunction isClosed(range: ValidTime): boolean {\n    return !isOpen(range);\n}\n\n/**\n * Checks whether a specific date is contained within the temporal range.\n * The lower bound (`from`) is inclusive, while the upper bound (`to`) is exclusive.\n */\nfunction contains(range: ValidTime, date: Date): boolean {\n    assertValidTime(range, \"range\");\n    assertValidDate(\"date\", date);\n\n    const fromTime = range.from.getTime();\n    const toTime = range.to?.getTime() ?? Number.POSITIVE_INFINITY;\n    const targetTime = date.getTime();\n\n    return targetTime >= fromTime && targetTime < toTime;\n}\n\n/**\n * Checks whether two temporal ranges overlap at any point.\n * Useful for validating whether a new rule conflicts with an existing one.\n */\nfunction overlaps(left: ValidTime, right: ValidTime): boolean {\n    assertValidTime(left, \"left\");\n    assertValidTime(right, \"right\");\n\n    const leftFrom = left.from.getTime();\n    const leftTo = left.to?.getTime() ?? Number.POSITIVE_INFINITY;\n    const rightFrom = right.from.getTime();\n    const rightTo = right.to?.getTime() ?? Number.POSITIVE_INFINITY;\n\n    return leftFrom < rightTo && rightFrom < leftTo;\n}\n\nexport { contains, isClosed, isOpen, overlaps };\n","import { type DeepReadonly, makeImmutable } from \"../../shared/immutable.js\";\n\nimport {\n    createTransactionTime,\n    type CreateTransactionTimeInput,\n    type TransactionTime,\n} from \"./transaction-time.js\";\nimport {\n    createValidTime,\n    type CreateValidTimeInput,\n    type ValidTime,\n} from \"./valid-time.js\";\n\n/**\n * Pairs a domain datum with its time dimensions (Business and Transaction).\n * It is the representation of an entry in the append-only (historical) table.\n *\n * `data` must be plain, structured-cloneable state — the primitive shape of an\n * aggregate, not the aggregate itself. `createTemporalSnapshot` deep-clones it\n * via `structuredClone`: functions and symbols inside `data` throw an\n * `InvariantViolationException`, and class instances (a `ValueObject`, an\n * `Entity`) are NOT rejected — they are silently flattened to plain objects,\n * losing their prototype (and with it `equals`/`toPrimitive`). Project rich\n * objects down first, e.g. with `toPrimitive()`.\n */\ninterface TemporalSnapshot<T> {\n    /** The data or state captured by the snapshot. */\n    readonly data: DeepReadonly<T>;\n    /** Period during which this datum was valid in the real world. */\n    readonly validTime: ValidTime;\n    /** Period during which this record was the state known to the system. */\n    readonly txTime: TransactionTime;\n}\n\ninterface CreateTemporalSnapshotInput<T> {\n    readonly data: T;\n    readonly validTime: CreateValidTimeInput;\n    readonly txTime: CreateTransactionTimeInput;\n}\n\nfunction createTemporalSnapshot<T>(\n    input: CreateTemporalSnapshotInput<T>,\n): TemporalSnapshot<T> {\n    // The time dimensions come out of their factories already cloned and\n    // frozen; only `data` still needs the clone+freeze. Freezing the shell by\n    // hand avoids a second structuredClone pass over the whole snapshot.\n    return Object.freeze({\n        data: makeImmutable(input.data),\n        validTime: createValidTime(input.validTime),\n        txTime: createTransactionTime(input.txTime),\n    });\n}\n\nexport {\n    createTemporalSnapshot,\n    type CreateTemporalSnapshotInput,\n    type TemporalSnapshot,\n};\n"],"mappings":";;;;;;;;;;;;;;;AAYA,SAAS,uBACL,YACA,OACA,UACA,KACI;CACJ,gBAAgB,YAAY,KAAK;CAEjC,IAAI,QAAQ,KAAA,GACR;CAGJ,gBAAgB,UAAU,GAAG;CAE7B,IAAI,IAAI,QAAQ,KAAK,MAAM,QAAQ,GAC/B,MAAM,IAAI,4BACN,GAAG,SAAS,sBAAsB,YACtC;AAER;;;ACFA,SAAS,sBACL,QACA,YAAoB,UAChB;CACJ,uBACI,GAAG,UAAU,cACb,OAAO,YACP,GAAG,UAAU,gBACb,OAAO,YACX;AACJ;AAEA,SAAS,sBACL,OACe;CACf,sBAAsB,OAAO,QAAQ;CAErC,IAAI,MAAM,iBAAiB,KAAA,GACvB,OAAO,cAAc,EACjB,YAAY,MAAM,WACtB,CAAC;CAGL,OAAO,cAAc;EACjB,YAAY,MAAM;EAClB,cAAc,MAAM;CACxB,CAAC;AACL;;;AC3BA,SAAS,gBACL,WACA,YAAoB,aAChB;CACJ,uBACI,GAAG,UAAU,QACb,UAAU,MACV,GAAG,UAAU,MACb,UAAU,EACd;AACJ;AAEA,SAAS,gBAAgB,OAAwC;CAC7D,gBAAgB,OAAO,WAAW;CAElC,IAAI,MAAM,OAAO,KAAA,GACb,OAAO,cAAc,EACjB,MAAM,MAAM,KAChB,CAAC;CAGL,OAAO,cAAc;EACjB,MAAM,MAAM;EACZ,IAAI,MAAM;CACd,CAAC;AACL;;;;;;;AC9CA,SAAS,OAAO,OAA2B;CACvC,gBAAgB,OAAO,OAAO;CAE9B,OAAO,MAAM,OAAO,KAAA;AACxB;;;;AAKA,SAAS,SAAS,OAA2B;CACzC,OAAO,CAAC,OAAO,KAAK;AACxB;;;;;AAMA,SAAS,SAAS,OAAkB,MAAqB;CACrD,gBAAgB,OAAO,OAAO;CAC9B,gBAAgB,QAAQ,IAAI;CAE5B,MAAM,WAAW,MAAM,KAAK,QAAQ;CACpC,MAAM,SAAS,MAAM,IAAI,QAAQ,KAAK,OAAO;CAC7C,MAAM,aAAa,KAAK,QAAQ;CAEhC,OAAO,cAAc,YAAY,aAAa;AAClD;;;;;AAMA,SAAS,SAAS,MAAiB,OAA2B;CAC1D,gBAAgB,MAAM,MAAM;CAC5B,gBAAgB,OAAO,OAAO;CAE9B,MAAM,WAAW,KAAK,KAAK,QAAQ;CACnC,MAAM,SAAS,KAAK,IAAI,QAAQ,KAAK,OAAO;CAC5C,MAAM,YAAY,MAAM,KAAK,QAAQ;CAGrC,OAAO,YAFS,MAAM,IAAI,QAAQ,KAAK,OAAO,sBAEjB,YAAY;AAC7C;;;ACVA,SAAS,uBACL,OACmB;CAInB,OAAO,OAAO,OAAO;EACjB,MAAM,cAAc,MAAM,IAAI;EAC9B,WAAW,gBAAgB,MAAM,SAAS;EAC1C,QAAQ,sBAAsB,MAAM,MAAM;CAC9C,CAAC;AACL"}

package/dist/domain-event-contracts.cjs

@@ -1,17 +1,21 @@
-const require_use_case = require("./use-case.cjs");
-const require_entity = require("./entity.cjs");
-const require_value_object = require("./value-object.cjs");
+const require_immutable = require("./immutable.cjs");
+const require_aggregate_version = require("./aggregate-version.cjs");
 //#region src/core/versioning/domain-event-contracts.ts
 function buildDomainEventContractVersions(selection) {
 	const contractVersions = {};
-	if (selection.entity) contractVersions.entity_contract = require_entity.Entity.CONTRACT_VERSION;
-	if (selection.valueObject) contractVersions.value_object_contract = require_value_object.ValueObject.CONTRACT_VERSION;
-	if (selection.useCase) contractVersions.use_case_contract = require_use_case.UseCase.CONTRACT_VERSION;
+	if (selection.entity) contractVersions.entity_contract = selection.entity.CONTRACT_VERSION;
+	if (selection.valueObject) contractVersions.value_object_contract = selection.valueObject.CONTRACT_VERSION;
+	if (selection.useCase) contractVersions.use_case_contract = selection.useCase.CONTRACT_VERSION;
 	return Object.freeze(contractVersions);
 }
+/**
+* Builds a frozen domain-event envelope. The whole envelope is deep-frozen,
+* so the `payload` handed in becomes immutable too — an event is an immutable
+* fact, and the caller must not mutate the payload after wrapping it.
+*/
 function createDomainEventEnvelope(input) {
-	require_entity.assertValidAggregateVersion(input.aggregateVersion);
-	return Object.freeze({
+	require_aggregate_version.assertValidAggregateVersion(input.aggregateVersion);
+	return require_immutable.deepFreeze({
 		aggregate_version: input.aggregateVersion,
 		payload: input.payload,
 		...buildDomainEventContractVersions(input.contracts)

package/dist/domain-event-contracts.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"domain-event-contracts.cjs","names":["Entity","ValueObject","UseCase"],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { UseCase } from \"../application/use-case.js\";\nimport { Entity } from \"../domain/entity.js\";\nimport { ValueObject } from \"../domain/value-object.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { type ContractVersion } from \"./version.js\";\n\ninterface DomainEventContractSelection {\n    readonly entity?: boolean;\n    readonly valueObject?: boolean;\n    readonly useCase?: boolean;\n}\n\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: {\n        entity_contract?: ContractVersion;\n        value_object_contract?: ContractVersion;\n        use_case_contract?: ContractVersion;\n    } = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = Entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return Object.freeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;;AA6BA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAIF,CAAC;CAEL,IAAI,UAAU,QACV,iBAAiB,kBAAkBA,eAAAA,OAAO;CAG9C,IAAI,UAAU,aACV,iBAAiB,wBAAwBC,qBAAAA,YAAY;CAGzD,IAAI,UAAU,SACV,iBAAiB,oBAAoBC,iBAAAA,QAAQ;CAGjD,OAAO,OAAO,OAAO,gBAAgB;AACzC;AAEA,SAAS,0BACL,OAC6B;CAC7B,eAAA,4BAA4B,MAAM,gBAAgB;CAElD,OAAO,OAAO,OAAO;EACjB,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}
+{"version":3,"file":"domain-event-contracts.cjs","names":["deepFreeze"],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { deepFreeze } from \"../shared/immutable.js\";\nimport { type ContractVersion } from \"./version.js\";\n\n/** Anything carrying a `CONTRACT_VERSION` — a class decorated with `@version`. */\ninterface ContractVersioned {\n    readonly CONTRACT_VERSION: ContractVersion;\n}\n\n/**\n * The classes whose contract version should be recorded on the envelope.\n *\n * Pass the **concrete** aggregate/value-object/use-case class (not the base),\n * so the envelope records the version the caller actually annotated with\n * `@version`. A base class handed here would report only the framework's\n * version, not the concrete shape that produced the event.\n */\ninterface DomainEventContractSelection {\n    readonly entity?: ContractVersioned;\n    readonly valueObject?: ContractVersioned;\n    readonly useCase?: ContractVersioned;\n}\n\n// Wire-format shape: `snake_case` keys, deliberately distinct from the\n// `camelCase` builder input above — these travel in the serialized event.\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ntype MutableContractVersions = {\n    -readonly [K in keyof DomainEventContractVersions]: DomainEventContractVersions[K];\n};\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\n/**\n * A deliberately minimal domain-event envelope: it carries only the aggregate\n * version and the structural contract versions needed for state/event\n * migration. It intentionally omits `eventId`, `eventType`, `occurredAt` and\n * correlation ids — those require a clock/id source and belong to the\n * consumer's event infrastructure. Treat this as a versioning core to extend,\n * not a complete event record.\n */\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: MutableContractVersions = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = selection.entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract =\n            selection.valueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = selection.useCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\n/**\n * Builds a frozen domain-event envelope. The whole envelope is deep-frozen,\n * so the `payload` handed in becomes immutable too — an event is an immutable\n * fact, and the caller must not mutate the payload after wrapping it.\n */\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return deepFreeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type ContractVersioned,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;AAsDA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAA4C,CAAC;CAEnD,IAAI,UAAU,QACV,iBAAiB,kBAAkB,UAAU,OAAO;CAGxD,IAAI,UAAU,aACV,iBAAiB,wBACb,UAAU,YAAY;CAG9B,IAAI,UAAU,SACV,iBAAiB,oBAAoB,UAAU,QAAQ;CAG3D,OAAO,OAAO,OAAO,gBAAgB;AACzC;;;;;;AAOA,SAAS,0BACL,OAC6B;CAC7B,0BAAA,4BAA4B,MAAM,gBAAgB;CAElD,OAAOA,kBAAAA,WAAW;EACd,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}

package/dist/domain-event-contracts.d.cts

@@ -1,10 +1,22 @@
 import { n as ContractVersion } from "./version.cjs";
 
 //#region src/core/versioning/domain-event-contracts.d.ts
+/** Anything carrying a `CONTRACT_VERSION` — a class decorated with `@version`. */
+interface ContractVersioned {
+  readonly CONTRACT_VERSION: ContractVersion;
+}
+/**
+ * The classes whose contract version should be recorded on the envelope.
+ *
+ * Pass the **concrete** aggregate/value-object/use-case class (not the base),
+ * so the envelope records the version the caller actually annotated with
+ * `@version`. A base class handed here would report only the framework's
+ * version, not the concrete shape that produced the event.
+ */
 interface DomainEventContractSelection {
-  readonly entity?: boolean;
-  readonly valueObject?: boolean;
-  readonly useCase?: boolean;
+  readonly entity?: ContractVersioned;
+  readonly valueObject?: ContractVersioned;
+  readonly useCase?: ContractVersioned;
 }
 interface DomainEventContractVersions {
   readonly entity_contract?: ContractVersion;
@@ -16,12 +28,25 @@ interface CreateDomainEventEnvelopeInput<TPayload> {
   readonly payload: TPayload;
   readonly contracts: DomainEventContractSelection;
 }
+/**
+ * A deliberately minimal domain-event envelope: it carries only the aggregate
+ * version and the structural contract versions needed for state/event
+ * migration. It intentionally omits `eventId`, `eventType`, `occurredAt` and
+ * correlation ids — those require a clock/id source and belong to the
+ * consumer's event infrastructure. Treat this as a versioning core to extend,
+ * not a complete event record.
+ */
 interface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {
   readonly aggregate_version: number;
   readonly payload: TPayload;
 }
 declare function buildDomainEventContractVersions(selection: DomainEventContractSelection): DomainEventContractVersions;
+/**
+ * Builds a frozen domain-event envelope. The whole envelope is deep-frozen,
+ * so the `payload` handed in becomes immutable too — an event is an immutable
+ * fact, and the caller must not mutate the payload after wrapping it.
+ */
 declare function createDomainEventEnvelope<TPayload>(input: CreateDomainEventEnvelopeInput<TPayload>): DomainEventEnvelope<TPayload>;
 //#endregion
-export { buildDomainEventContractVersions as a, DomainEventEnvelope as i, DomainEventContractSelection as n, createDomainEventEnvelope as o, DomainEventContractVersions as r, CreateDomainEventEnvelopeInput as t };
+export { DomainEventEnvelope as a, DomainEventContractVersions as i, CreateDomainEventEnvelopeInput as n, buildDomainEventContractVersions as o, DomainEventContractSelection as r, createDomainEventEnvelope as s, ContractVersioned as t };
 //# sourceMappingURL=domain-event-contracts.d.cts.map

package/dist/domain-event-contracts.d.ts

@@ -1,10 +1,22 @@
 import { n as ContractVersion } from "./version.js";
 
 //#region src/core/versioning/domain-event-contracts.d.ts
+/** Anything carrying a `CONTRACT_VERSION` — a class decorated with `@version`. */
+interface ContractVersioned {
+  readonly CONTRACT_VERSION: ContractVersion;
+}
+/**
+ * The classes whose contract version should be recorded on the envelope.
+ *
+ * Pass the **concrete** aggregate/value-object/use-case class (not the base),
+ * so the envelope records the version the caller actually annotated with
+ * `@version`. A base class handed here would report only the framework's
+ * version, not the concrete shape that produced the event.
+ */
 interface DomainEventContractSelection {
-  readonly entity?: boolean;
-  readonly valueObject?: boolean;
-  readonly useCase?: boolean;
+  readonly entity?: ContractVersioned;
+  readonly valueObject?: ContractVersioned;
+  readonly useCase?: ContractVersioned;
 }
 interface DomainEventContractVersions {
   readonly entity_contract?: ContractVersion;
@@ -16,12 +28,25 @@ interface CreateDomainEventEnvelopeInput<TPayload> {
   readonly payload: TPayload;
   readonly contracts: DomainEventContractSelection;
 }
+/**
+ * A deliberately minimal domain-event envelope: it carries only the aggregate
+ * version and the structural contract versions needed for state/event
+ * migration. It intentionally omits `eventId`, `eventType`, `occurredAt` and
+ * correlation ids — those require a clock/id source and belong to the
+ * consumer's event infrastructure. Treat this as a versioning core to extend,
+ * not a complete event record.
+ */
 interface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {
   readonly aggregate_version: number;
   readonly payload: TPayload;
 }
 declare function buildDomainEventContractVersions(selection: DomainEventContractSelection): DomainEventContractVersions;
+/**
+ * Builds a frozen domain-event envelope. The whole envelope is deep-frozen,
+ * so the `payload` handed in becomes immutable too — an event is an immutable
+ * fact, and the caller must not mutate the payload after wrapping it.
+ */
 declare function createDomainEventEnvelope<TPayload>(input: CreateDomainEventEnvelopeInput<TPayload>): DomainEventEnvelope<TPayload>;
 //#endregion
-export { buildDomainEventContractVersions as a, DomainEventEnvelope as i, DomainEventContractSelection as n, createDomainEventEnvelope as o, DomainEventContractVersions as r, CreateDomainEventEnvelopeInput as t };
+export { DomainEventEnvelope as a, DomainEventContractVersions as i, CreateDomainEventEnvelopeInput as n, buildDomainEventContractVersions as o, DomainEventContractSelection as r, createDomainEventEnvelope as s, ContractVersioned as t };
 //# sourceMappingURL=domain-event-contracts.d.ts.map

package/dist/domain-event-contracts.js

@@ -1,17 +1,21 @@
-import { t as UseCase } from "./use-case.js";
-import { n as assertValidAggregateVersion, t as Entity } from "./entity.js";
-import { t as ValueObject } from "./value-object.js";
+import { t as deepFreeze } from "./immutable.js";
+import { t as assertValidAggregateVersion } from "./aggregate-version.js";
 //#region src/core/versioning/domain-event-contracts.ts
 function buildDomainEventContractVersions(selection) {
 	const contractVersions = {};
-	if (selection.entity) contractVersions.entity_contract = Entity.CONTRACT_VERSION;
-	if (selection.valueObject) contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;
-	if (selection.useCase) contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;
+	if (selection.entity) contractVersions.entity_contract = selection.entity.CONTRACT_VERSION;
+	if (selection.valueObject) contractVersions.value_object_contract = selection.valueObject.CONTRACT_VERSION;
+	if (selection.useCase) contractVersions.use_case_contract = selection.useCase.CONTRACT_VERSION;
 	return Object.freeze(contractVersions);
 }
+/**
+* Builds a frozen domain-event envelope. The whole envelope is deep-frozen,
+* so the `payload` handed in becomes immutable too — an event is an immutable
+* fact, and the caller must not mutate the payload after wrapping it.
+*/
 function createDomainEventEnvelope(input) {
 	assertValidAggregateVersion(input.aggregateVersion);
-	return Object.freeze({
+	return deepFreeze({
 		aggregate_version: input.aggregateVersion,
 		payload: input.payload,
 		...buildDomainEventContractVersions(input.contracts)

package/dist/domain-event-contracts.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain-event-contracts.js","names":[],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { UseCase } from \"../application/use-case.js\";\nimport { Entity } from \"../domain/entity.js\";\nimport { ValueObject } from \"../domain/value-object.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { type ContractVersion } from \"./version.js\";\n\ninterface DomainEventContractSelection {\n    readonly entity?: boolean;\n    readonly valueObject?: boolean;\n    readonly useCase?: boolean;\n}\n\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: {\n        entity_contract?: ContractVersion;\n        value_object_contract?: ContractVersion;\n        use_case_contract?: ContractVersion;\n    } = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = Entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return Object.freeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;;AA6BA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAIF,CAAC;CAEL,IAAI,UAAU,QACV,iBAAiB,kBAAkB,OAAO;CAG9C,IAAI,UAAU,aACV,iBAAiB,wBAAwB,YAAY;CAGzD,IAAI,UAAU,SACV,iBAAiB,oBAAoB,QAAQ;CAGjD,OAAO,OAAO,OAAO,gBAAgB;AACzC;AAEA,SAAS,0BACL,OAC6B;CAC7B,4BAA4B,MAAM,gBAAgB;CAElD,OAAO,OAAO,OAAO;EACjB,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}
+{"version":3,"file":"domain-event-contracts.js","names":[],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { deepFreeze } from \"../shared/immutable.js\";\nimport { type ContractVersion } from \"./version.js\";\n\n/** Anything carrying a `CONTRACT_VERSION` — a class decorated with `@version`. */\ninterface ContractVersioned {\n    readonly CONTRACT_VERSION: ContractVersion;\n}\n\n/**\n * The classes whose contract version should be recorded on the envelope.\n *\n * Pass the **concrete** aggregate/value-object/use-case class (not the base),\n * so the envelope records the version the caller actually annotated with\n * `@version`. A base class handed here would report only the framework's\n * version, not the concrete shape that produced the event.\n */\ninterface DomainEventContractSelection {\n    readonly entity?: ContractVersioned;\n    readonly valueObject?: ContractVersioned;\n    readonly useCase?: ContractVersioned;\n}\n\n// Wire-format shape: `snake_case` keys, deliberately distinct from the\n// `camelCase` builder input above — these travel in the serialized event.\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ntype MutableContractVersions = {\n    -readonly [K in keyof DomainEventContractVersions]: DomainEventContractVersions[K];\n};\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\n/**\n * A deliberately minimal domain-event envelope: it carries only the aggregate\n * version and the structural contract versions needed for state/event\n * migration. It intentionally omits `eventId`, `eventType`, `occurredAt` and\n * correlation ids — those require a clock/id source and belong to the\n * consumer's event infrastructure. Treat this as a versioning core to extend,\n * not a complete event record.\n */\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: MutableContractVersions = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = selection.entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract =\n            selection.valueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = selection.useCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\n/**\n * Builds a frozen domain-event envelope. The whole envelope is deep-frozen,\n * so the `payload` handed in becomes immutable too — an event is an immutable\n * fact, and the caller must not mutate the payload after wrapping it.\n */\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return deepFreeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type ContractVersioned,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;AAsDA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAA4C,CAAC;CAEnD,IAAI,UAAU,QACV,iBAAiB,kBAAkB,UAAU,OAAO;CAGxD,IAAI,UAAU,aACV,iBAAiB,wBACb,UAAU,YAAY;CAG9B,IAAI,UAAU,SACV,iBAAiB,oBAAoB,UAAU,QAAQ;CAG3D,OAAO,OAAO,OAAO,gBAAgB;AACzC;;;;;;AAOA,SAAS,0BACL,OAC6B;CAC7B,4BAA4B,MAAM,gBAAgB;CAElD,OAAO,WAAW;EACd,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}

package/dist/domain-exception.cjs

@@ -1,7 +1,8 @@
 //#region src/core/exceptions/domain-exception.ts
 var DomainException = class extends Error {
-	constructor(message) {
+	constructor(message, options) {
 		super(message);
+		this.cause = options?.cause;
 		Object.setPrototypeOf(this, new.target.prototype);
 		this.name = new.target.name;
 	}

package/dist/domain-exception.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"domain-exception.cjs","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    constructor(message: string) {\n        super(message);\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CACzC,YAAY,SAAiB;EACzB,MAAM,OAAO;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}
+{"version":3,"file":"domain-exception.cjs","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    // ES2020's `Error` lib type does not declare `cause`; mirror the sibling\n    // `AppError` and carry it explicitly so a domain exception can wrap the\n    // lower-level failure that triggered it. Assigned rather than passed to\n    // `super` to stay independent of the ES2022 `Error(message, { cause })`\n    // overload the build target doesn't guarantee.\n    public readonly cause?: unknown;\n\n    constructor(message: string, options?: { cause?: unknown }) {\n        super(message);\n        this.cause = options?.cause;\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CAQzC,YAAY,SAAiB,SAA+B;EACxD,MAAM,OAAO;EACb,KAAK,QAAQ,SAAS;EACtB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}

package/dist/domain-exception.js

@@ -1,7 +1,8 @@
 //#region src/core/exceptions/domain-exception.ts
 var DomainException = class extends Error {
-	constructor(message) {
+	constructor(message, options) {
 		super(message);
+		this.cause = options?.cause;
 		Object.setPrototypeOf(this, new.target.prototype);
 		this.name = new.target.name;
 	}

package/dist/domain-exception.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain-exception.js","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    constructor(message: string) {\n        super(message);\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CACzC,YAAY,SAAiB;EACzB,MAAM,OAAO;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}
+{"version":3,"file":"domain-exception.js","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    // ES2020's `Error` lib type does not declare `cause`; mirror the sibling\n    // `AppError` and carry it explicitly so a domain exception can wrap the\n    // lower-level failure that triggered it. Assigned rather than passed to\n    // `super` to stay independent of the ES2022 `Error(message, { cause })`\n    // overload the build target doesn't guarantee.\n    public readonly cause?: unknown;\n\n    constructor(message: string, options?: { cause?: unknown }) {\n        super(message);\n        this.cause = options?.cause;\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CAQzC,YAAY,SAAiB,SAA+B;EACxD,MAAM,OAAO;EACb,KAAK,QAAQ,SAAS;EACtB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}

package/dist/errors/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_app_error = require("../app-error.cjs");
-const require_validation_error = require("../validation-error.cjs");
 const require_authorization_error = require("../authorization-error.cjs");
+const require_validation_error = require("../validation-error.cjs");
 const require_not_found_error = require("../not-found-error.cjs");
 const require_stable_stringify = require("../stable-stringify.cjs");
 const require_hashing = require("../hashing.cjs");

package/dist/errors/index.d.cts

@@ -1,4 +1,4 @@
 import { a as JsonSafeRecord, i as JsonSafePrimitive, n as AppErrorOptions, o as JsonSafeValue, r as ErrorSeverity, t as AppError } from "../app-error.cjs";
 import { i as AuthorizationRequirement, n as AuthorizationErrorMetadata, r as AuthorizationErrorReason, t as AuthorizationError } from "../authorization-error.cjs";
-import { A as IdempotencyPayloadMismatchError, B as UniqueConstraintViolation, C as IntegrationErrorMetadata, D as IdempotencyFailureKind, E as IdempotencyErrorMetadata, F as AlreadyExistsError, G as AuthenticationErrorMetadata, H as translateUniqueViolationToDuplicate, I as ConflictError, J as ErrorCodes, K as AuthenticationErrorReason, L as ConflictErrorMetadata, M as payloadHash, N as sha256Hex, O as IdempotencyInProgressError, P as stableStringify, R as ConflictKind, S as IntegrationError, T as IdempotencyError, U as BusinessRuleViolationError, V as UniqueConstraintViolationError, W as AuthenticationError, Y as serializationErrorCode, _ as SerializationMessages, a as TemporalError, b as NotFoundError, c as TemporalPrecision, d as SerializationCodes, f as SerializationDirection, g as SerializationInError, h as SerializationFailureCategory, i as NotYetValidError, j as IdempotencyReplayNotSupportedError, k as IdempotencyKeyMissingError, l as evaluateTemporalWindow, m as SerializationErrorMetadata, n as UnexpectedError, o as TemporalErrorMetadata, p as SerializationError, q as assertJsonSafeMetadata, r as ExpiredError, s as TemporalKind, t as ValidationError, u as SerializationBoundary, v as SerializationOutError, w as IntegrationErrorReason, x as LegacyIncompatibleError, y as safePreview, z as DuplicateError } from "../validation-error.cjs";
+import { A as IdempotencyPayloadMismatchError, B as UniqueConstraintViolation, C as IntegrationErrorMetadata, D as IdempotencyFailureKind, E as IdempotencyErrorMetadata, F as AlreadyExistsError, G as AuthenticationErrorMetadata, H as translateUniqueViolationToDuplicate, I as ConflictError, J as ErrorCodes, K as AuthenticationErrorReason, L as ConflictErrorMetadata, M as stableStringify, N as payloadHash, O as IdempotencyInProgressError, P as sha256Hex, R as ConflictKind, S as IntegrationError, T as IdempotencyError, U as BusinessRuleViolationError, V as UniqueConstraintViolationError, W as AuthenticationError, Y as serializationErrorCode, _ as SerializationMessages, a as TemporalError, b as NotFoundError, c as TemporalPrecision, d as SerializationCodes, f as SerializationDirection, g as SerializationInError, h as SerializationFailureCategory, i as NotYetValidError, j as IdempotencyReplayNotSupportedError, k as IdempotencyKeyMissingError, l as evaluateTemporalWindow, m as SerializationErrorMetadata, n as UnexpectedError, o as TemporalErrorMetadata, p as SerializationError, q as assertJsonSafeMetadata, r as ExpiredError, s as TemporalKind, t as ValidationError, u as SerializationBoundary, v as SerializationOutError, w as IntegrationErrorReason, x as LegacyIncompatibleError, y as safePreview, z as DuplicateError } from "../validation-error.cjs";
 export { AlreadyExistsError, AppError, AppErrorOptions, AuthenticationError, AuthenticationErrorMetadata, AuthenticationErrorReason, AuthorizationError, AuthorizationErrorMetadata, AuthorizationErrorReason, AuthorizationRequirement, BusinessRuleViolationError, ConflictError, ConflictErrorMetadata, ConflictKind, SerializationInError as DeserializationError, SerializationInError, DuplicateError, ErrorCodes, ErrorSeverity, ExpiredError, TemporalErrorMetadata as ExpiredErrorMetadata, TemporalErrorMetadata, TemporalPrecision as ExpiredErrorPrecision, TemporalPrecision, IdempotencyError, IdempotencyErrorMetadata, IdempotencyFailureKind, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, IntegrationError, IntegrationErrorMetadata, IntegrationErrorReason, JsonSafePrimitive, JsonSafeRecord, JsonSafeValue, LegacyIncompatibleError, NotFoundError, NotYetValidError, SerializationBoundary, SerializationCodes, SerializationDirection, SerializationError, SerializationErrorMetadata, SerializationFailureCategory, SerializationMessages, SerializationOutError, TemporalError, TemporalKind, UnexpectedError, UniqueConstraintViolation, UniqueConstraintViolationError, ValidationError, assertJsonSafeMetadata, evaluateTemporalWindow, payloadHash, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate };

package/dist/errors/index.d.ts

@@ -1,4 +1,4 @@
 import { a as JsonSafeRecord, i as JsonSafePrimitive, n as AppErrorOptions, o as JsonSafeValue, r as ErrorSeverity, t as AppError } from "../app-error.js";
 import { i as AuthorizationRequirement, n as AuthorizationErrorMetadata, r as AuthorizationErrorReason, t as AuthorizationError } from "../authorization-error.js";
-import { A as IdempotencyPayloadMismatchError, B as UniqueConstraintViolation, C as IntegrationErrorMetadata, D as IdempotencyFailureKind, E as IdempotencyErrorMetadata, F as AlreadyExistsError, G as AuthenticationErrorMetadata, H as translateUniqueViolationToDuplicate, I as ConflictError, J as ErrorCodes, K as AuthenticationErrorReason, L as ConflictErrorMetadata, M as payloadHash, N as sha256Hex, O as IdempotencyInProgressError, P as stableStringify, R as ConflictKind, S as IntegrationError, T as IdempotencyError, U as BusinessRuleViolationError, V as UniqueConstraintViolationError, W as AuthenticationError, Y as serializationErrorCode, _ as SerializationMessages, a as TemporalError, b as NotFoundError, c as TemporalPrecision, d as SerializationCodes, f as SerializationDirection, g as SerializationInError, h as SerializationFailureCategory, i as NotYetValidError, j as IdempotencyReplayNotSupportedError, k as IdempotencyKeyMissingError, l as evaluateTemporalWindow, m as SerializationErrorMetadata, n as UnexpectedError, o as TemporalErrorMetadata, p as SerializationError, q as assertJsonSafeMetadata, r as ExpiredError, s as TemporalKind, t as ValidationError, u as SerializationBoundary, v as SerializationOutError, w as IntegrationErrorReason, x as LegacyIncompatibleError, y as safePreview, z as DuplicateError } from "../validation-error.js";
+import { A as IdempotencyPayloadMismatchError, B as UniqueConstraintViolation, C as IntegrationErrorMetadata, D as IdempotencyFailureKind, E as IdempotencyErrorMetadata, F as AlreadyExistsError, G as AuthenticationErrorMetadata, H as translateUniqueViolationToDuplicate, I as ConflictError, J as ErrorCodes, K as AuthenticationErrorReason, L as ConflictErrorMetadata, M as stableStringify, N as payloadHash, O as IdempotencyInProgressError, P as sha256Hex, R as ConflictKind, S as IntegrationError, T as IdempotencyError, U as BusinessRuleViolationError, V as UniqueConstraintViolationError, W as AuthenticationError, Y as serializationErrorCode, _ as SerializationMessages, a as TemporalError, b as NotFoundError, c as TemporalPrecision, d as SerializationCodes, f as SerializationDirection, g as SerializationInError, h as SerializationFailureCategory, i as NotYetValidError, j as IdempotencyReplayNotSupportedError, k as IdempotencyKeyMissingError, l as evaluateTemporalWindow, m as SerializationErrorMetadata, n as UnexpectedError, o as TemporalErrorMetadata, p as SerializationError, q as assertJsonSafeMetadata, r as ExpiredError, s as TemporalKind, t as ValidationError, u as SerializationBoundary, v as SerializationOutError, w as IntegrationErrorReason, x as LegacyIncompatibleError, y as safePreview, z as DuplicateError } from "../validation-error.js";
 export { AlreadyExistsError, AppError, AppErrorOptions, AuthenticationError, AuthenticationErrorMetadata, AuthenticationErrorReason, AuthorizationError, AuthorizationErrorMetadata, AuthorizationErrorReason, AuthorizationRequirement, BusinessRuleViolationError, ConflictError, ConflictErrorMetadata, ConflictKind, SerializationInError as DeserializationError, SerializationInError, DuplicateError, ErrorCodes, ErrorSeverity, ExpiredError, TemporalErrorMetadata as ExpiredErrorMetadata, TemporalErrorMetadata, TemporalPrecision as ExpiredErrorPrecision, TemporalPrecision, IdempotencyError, IdempotencyErrorMetadata, IdempotencyFailureKind, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, IntegrationError, IntegrationErrorMetadata, IntegrationErrorReason, JsonSafePrimitive, JsonSafeRecord, JsonSafeValue, LegacyIncompatibleError, NotFoundError, NotYetValidError, SerializationBoundary, SerializationCodes, SerializationDirection, SerializationError, SerializationErrorMetadata, SerializationFailureCategory, SerializationMessages, SerializationOutError, TemporalError, TemporalKind, UnexpectedError, UniqueConstraintViolation, UniqueConstraintViolationError, ValidationError, assertJsonSafeMetadata, evaluateTemporalWindow, payloadHash, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate };

package/dist/errors/index.js

@@ -1,8 +1,8 @@
 import { i as serializationErrorCode, n as assertJsonSafeMetadata, r as ErrorCodes, t as AppError } from "../app-error.js";
-import { C as translateUniqueViolationToDuplicate, S as UniqueConstraintViolationError, _ as IdempotencyPayloadMismatchError, a as evaluateTemporalWindow, b as ConflictError, c as SerializationInError, d as safePreview, f as LegacyIncompatibleError, g as IdempotencyKeyMissingError, h as IdempotencyInProgressError, i as TemporalError, l as SerializationMessages, m as IdempotencyError, n as ExpiredError, o as SerializationCodes, p as IntegrationError, r as NotYetValidError, s as SerializationError, t as ValidationError, u as SerializationOutError, v as IdempotencyReplayNotSupportedError, w as AuthenticationError, x as DuplicateError, y as AlreadyExistsError } from "../validation-error.js";
 import { t as AuthorizationError } from "../authorization-error.js";
+import { C as translateUniqueViolationToDuplicate, S as UniqueConstraintViolationError, _ as IdempotencyPayloadMismatchError, a as evaluateTemporalWindow, b as ConflictError, c as SerializationInError, d as safePreview, f as LegacyIncompatibleError, g as IdempotencyKeyMissingError, h as IdempotencyInProgressError, i as TemporalError, l as SerializationMessages, m as IdempotencyError, n as ExpiredError, o as SerializationCodes, p as IntegrationError, r as NotYetValidError, s as SerializationError, t as ValidationError, u as SerializationOutError, v as IdempotencyReplayNotSupportedError, w as AuthenticationError, x as DuplicateError, y as AlreadyExistsError } from "../validation-error.js";
 import { n as BusinessRuleViolationError, t as NotFoundError } from "../not-found-error.js";
-import { t as stableStringify } from "../stable-stringify.js";
+import { n as stableStringify } from "../stable-stringify.js";
 import { n as sha256Hex, t as payloadHash } from "../hashing.js";
 import { t as UnexpectedError } from "../unexpected-error.js";
 export { AlreadyExistsError, AppError, AuthenticationError, AuthorizationError, BusinessRuleViolationError, ConflictError, SerializationInError as DeserializationError, SerializationInError, DuplicateError, ErrorCodes, ExpiredError, IdempotencyError, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, IntegrationError, LegacyIncompatibleError, NotFoundError, NotYetValidError, SerializationCodes, SerializationError, SerializationMessages, SerializationOutError, TemporalError, UnexpectedError, UniqueConstraintViolationError, ValidationError, assertJsonSafeMetadata, evaluateTemporalWindow, payloadHash, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate };

package/dist/exceptions/index.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_domain_exception = require("../domain-exception.cjs");
+const require_invariant_violation_exception = require("../invariant-violation-exception.cjs");
 const require_validation_code = require("../validation-code.cjs");
 const require_validation_field = require("../validation-field.cjs");
-const require_domain_exception = require("../domain-exception.cjs");
 const require_invalid_state_transition_exception = require("../invalid-state-transition-exception.cjs");
-const require_invariant_violation_exception = require("../invariant-violation-exception.cjs");
 const require_validation_exception = require("../validation-exception.cjs");
 exports.BusinessRuleViolationException = require_invalid_state_transition_exception.BusinessRuleViolationException;
 exports.DomainException = require_domain_exception.DomainException;

package/dist/exceptions/index.d.cts

@@ -1,5 +1,4 @@
 import { t as ValidationCode } from "../validation-code.cjs";
 import { t as ValidationField } from "../validation-field.cjs";
-import { t as DomainException } from "../domain-exception.cjs";
-import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.cjs";
+import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, l as DomainException, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.cjs";
 export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField, ValidationViolation };

package/dist/exceptions/index.d.ts

@@ -1,5 +1,4 @@
 import { t as ValidationCode } from "../validation-code.js";
 import { t as ValidationField } from "../validation-field.js";
-import { t as DomainException } from "../domain-exception.js";
-import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.js";
+import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, l as DomainException, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.js";
 export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField, ValidationViolation };

package/dist/exceptions/index.js

@@ -1,7 +1,7 @@
+import { t as DomainException } from "../domain-exception.js";
+import { t as InvariantViolationException } from "../invariant-violation-exception.js";
 import { t as ValidationCode } from "../validation-code.js";
 import { t as ValidationField } from "../validation-field.js";
-import { t as DomainException } from "../domain-exception.js";
 import { n as EntityNotFoundException, r as BusinessRuleViolationException, t as InvalidStateTransitionException } from "../invalid-state-transition-exception.js";
-import { t as InvariantViolationException } from "../invariant-violation-exception.js";
 import { n as MultipleValidationException, r as ValidationException, t as InvalidValueException } from "../validation-exception.js";
 export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField };